Download PrivateProxy - Download do código-fonte PrivateProxy

Importante

O Roslyn/Source Generator atual tem limitações no acesso a membros privados de projetos referenciados. Além disso, o acesso a membros privados pode levar a situações em que funciona bem no IDE, mas falha durante o processo de construção. Para obter mais detalhes, consulte o problema de Roslyn, MetadataImportOptions.All não funciona em geradores de origem?. Para evitar confusão, arquivarei isso até que o relacionamento entre os Geradores de Fonte e os membros privados seja melhorado.

Proxy Privado

Source Generator e .NET 8 UnsafeAccessor baseado em acessador privado de alto desempenho e fortemente tipado para teste de unidade e tempo de execução.

[GeneratePrivateProxy(typeof(TargetType))] gera proxy do acessador.

 using PrivateProxy ;

public class Sample
{
    int _field1 ;
    int PrivateAdd ( int x , int y ) => x + y ;
}

[ GeneratePrivateProxy ( typeof ( Sample ) ) ]
public partial struct SampleProxy ;

 // Source Generator generate this type
partial struct SampleProxy ( Sample target )
{
    [ UnsafeAccessor ( UnsafeAccessorKind . Field , Name = " _field1 " ) ]
    static extern ref int ___field1__ ( Sample target ) ;

    [ UnsafeAccessor ( UnsafeAccessorKind . Method , Name = " PrivateAdd " ) ]
    static extern int __PrivateAdd__ ( Sample target , int x , int y ) ;

    public ref int _field1 => ref ___field1__ ( target ) ;
    public int PrivateAdd ( int x , int y ) => __PrivateAdd__ ( target , x , y ) ;
}

public static class SamplePrivateProxyExtensions
{
    public static SampleProxy AsPrivateProxy ( this Sample target )
    {
        return new SampleProxy ( target ) ;
    }
}

 // You can access like this.
var sample = new Sample ( ) ;
sample . AsPrivateProxy ( ) . _field1 = 10 ;

O código gerado é totalmente digitado, você pode acessar o campo privado via IntelliSense e quando o campo privado for alterado, pode verificar o erro do compilador.

imagem

Sem penalidade de desempenho, ele pode ser usado não apenas para testes unitários, mas também para tempo de execução
Nenhuma dependência de tempo de execução (todos os códigos estão incluídos no gerador de origem)
Acessadores privados são fortemente tipados
Suporta instância, estática e campos, propriedades, métodos
Suporta parâmetros de método ref , out , in e ref readonly
Suporta campo e propriedade readonly
Suporta retorno ref
Suporta estrutura mutável
Suporta construtor de instância

Por exemplo, esta é a estrutura mutável e estática, retorno de referência e amostra de construtor.

 using PrivateProxy ;

public struct MutableStructSample
{
    int _counter ;
    void Increment ( ) => _counter ++ ;

    // static and ref sample
    static ref int GetInstanceCounter ( ref MutableStructSample sample ) => ref sample . _counter ;
    
    // constructor sample
    MutalbeStructSample ( int x , int y ) { /* ... */ }
}

// use ref partial struct
[ GeneratePrivateProxy ( typeof ( MutableStructSample ) ) ]
public ref partial struct MutableStructSampleProxy ;

 var sample = new MutableStructSample ( ) ;
var proxy = sample . AsPrivateProxy ( ) ;
proxy . Increment ( ) ;
proxy . Increment ( ) ;
proxy . Increment ( ) ;

// call private static method.
ref var counter = ref MutableStructSampleProxy . GetInstanceCounter ( ref sample ) ;

Console . WriteLine ( counter ) ; // 3
counter = 9999 ;
Console . WriteLine ( proxy . _counter ) ; // 9999

// call private constructor and create instance.
var sample = MutableStructSampleProxy . CreateMutableStructFromConstructor ( 111 , 222 ) ;

Instalação

Esta biblioteca é distribuída via NuGet, o requisito mínimo é .NET 8 e C# 12.

PM> Instalar pacote PrivateProxy

O pacote fornece apenas um analisador e o código gerado não depende de nenhuma outra biblioteca.

Membros Apoiados

Tipo de destino e membro de GeneratePrivateProxy

 public class /* struct */ SupportTarget
{
    // field
    private int field ;
    private readonly int readOnlyField ;
    
    // property
    private int Property { get ; set ; }
    private int GetOnlyProperty { get ; }
    public int GetOnlyPrivateProperty { private get ; set ; }
    public int SetOnlyPrivateProperty { get ; private set ; }
    private int SetOnlyProperty { set => field = value ; }
    private ref int RefGetOnlyProperty => ref field ;
    private ref readonly int RefReadOnlyGetOnlyProperty => ref field ;

    // method
    private void VoidMethod ( ) { }
    private int ReturnMethod ( ) => field ;
    private int ParameterMethod ( int x , int y ) => x + y ;
    private void RefOutInMethod ( in int x , ref int y , out int z , ref readonly int xyz ) { z = field ; }
    private ref int RefReturnMethod ( ) => ref field ;
    private ref readonly int RefReadOnlyReturnMethod ( ) => ref field ;

    // static
    static int staticField ;
    static readonly int staticReadOnlyField ;
    static int StaticProperty { get ; set ; }
    static int StaticGetOnlyProperty { get ; }
    public static int StaticGetOnlyPrivateProperty { private get ; set ; }
    public static int StaticSetOnlyPrivateProperty { get ; private set ; }
    private static int StaticSetOnlyProperty { set => staticField = value ; }
    private static ref int StaticRefGetOnlyProperty => ref staticField ;
    private static ref readonly int StaticRefReadOnlyGetOnlyProperty => ref staticField ;
    private static void StaticVoidMethod ( ) { }
    static int StaticReturnMethod ( ) => staticField ;
    static int StaticParameterMethod ( int x , int y ) => x + y ;
    static void StaticRefOutInMethod ( in int x , ref int y , out int z , ref readonly int xyz ) { z = staticField ; }
    static ref int StaticRefReturnMethod ( ) => ref staticField ;
    static ref readonly int StaticRefReadOnlyReturnMethod ( ) => ref staticField ;
    static ref int StaticRefReturnMethodParameter ( ) => ref staticField ;
    
    // constructor
    SupportTarget ( ) { }
    SupportTarget ( int x , int y ) { }
}

O tipo de proxy pode ser class => class ou struct , struct => ref struct .

 using PrivateProxy ;

public class Sample ;

// class proxy type both supports class and struct(recommend is struct)
[ GeneratePrivateProxy ( typeof ( Sample ) ) ]
public partial class SampleProxy1 ;

[ GeneratePrivateProxy ( typeof ( Sample ) ) ]
public partial struct SampleProxy2 ;

public struct SamplleStruct ;

// struct only supports ref struct(when use standard struct, analyzer shows error)
[ GeneratePrivateProxy ( typeof ( SamplleStruct ) ) ]
public ref partial struct SamplleStructProxy ;

GeneratePrivateProxyAttribute possui dois construtores, ao usar o parâmetro PrivateProxyGenerateKinds , pode configurar a geração de tipo de membro.

 public GeneratePrivateProxyAttribute ( Type target ) // use PrivateProxyGenerateKinds.All
public GeneratePrivateProxyAttribute ( Type target , PrivateProxyGenerateKinds generateKinds )

[ Flags ]
internal enum PrivateProxyGenerateKinds
{
    All = 0 , // Field | Method | Property | Instance | Static | Constructor
    Field = 1 ,
    Method = 2 ,
    Property = 4 ,
    Instance = 8 ,
    Static = 16 ,
    Constructor = 32 ,
}

Limitação

Atualmente, os seguintes recursos não são suportados

Tipo genérico
- consulte: dotnet/runtime#89439 Implementar suporte genérico não vinculado para UnsafeAccessorAttribute
Classe estática, tipo de parâmetro/retorno não público (ignorar geração)
- consulte: dotnet/runtime#90081 UnsafeAccessorTypeAttribute para acesso de tipo estático ou privado
estrutura de referência
- O campo ref não pode passar para o parâmetro do método ref
Tipos de dll externa (por exemplo String )
- Provavelmente, habilitando MetadataImportOptions.All no Source Generator, deverá ser possível lê-lo. No entanto, não consegui encontrar uma maneira de fazer isso. Eu preciso de ajuda.