PrivateProxy

Wichtig

Der aktuelle Roslyn/Source Generator weist Einschränkungen beim Zugriff auf private Mitglieder referenzierter Projekte auf. Darüber hinaus kann der Zugriff auf private Mitglieder zu Situationen führen, in denen er in der IDE einwandfrei funktioniert, während des Build-Prozesses jedoch fehlschlägt. Weitere Einzelheiten finden Sie im Roslyn-Problem „MetadataImportOptions.All funktioniert nicht in Quellgeneratoren?“. Um Verwirrung zu vermeiden, werde ich dies archivieren, bis die Beziehung zwischen Quellgeneratoren und privaten Mitgliedern verbessert ist.

PrivateProxy

Auf Quellgenerator und .NET 8 UnsafeAccessor basierender leistungsstarker, stark typisierter privater Accessor für Unit-Tests und Laufzeit.

[GeneratePrivateProxy(typeof(TargetType))] generiert einen Accessor-Proxy.

 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 ;

Der generierte Code ist vollständig typisiert. Sie können über IntelliSense auf private Felder zugreifen und bei Änderungen im privaten Feld den Compilerfehler überprüfen.

• Keine Leistungseinbußen, es kann nicht nur für Unit-Tests, sondern auch zur Laufzeit verwendet werden
• Keine Laufzeitabhängigkeit (alle Codes sind im Quellgenerator enthalten)
• Private Accessoren sind stark typisiert
• Unterstützt sowohl Instanzen, statische als auch Felder, Eigenschaften und Methoden
• Unterstützt ref , out , in und ref readonly -Methodenparameter
• Unterstützt readonly Felder und Eigenschaften
• Unterstützt ref Rückgabe
• Unterstützt veränderliche Strukturen
• Unterstützt den Instanzkonstruktor

Dies ist beispielsweise das veränderbare Struktur- und Statik-, Ref-Return- und Konstruktorbeispiel.

 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 ) ; 

Installation

Diese Bibliothek wird über NuGet verteilt, Mindestanforderung ist .NET 8 und C# 12.

PM> Install-Package PrivateProxy

Das Paket stellt nur einen Analysator bereit und der generierte Code ist nicht von anderen Bibliotheken abhängig.

Unterstützte Mitglieder

GeneratePrivateProxy Zieltyp und -Member

 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 ) { }
}

Der Proxy-Typ kann class => class oder struct , struct => ref struct sein.

 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 verfügt über zwei Konstruktoren. Wenn Sie den Parameter PrivateProxyGenerateKinds verwenden, können Sie die Art der generierten Mitglieder konfigurieren.

 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 ,
} 

Einschränkung

Derzeit werden die folgenden Funktionen nicht unterstützt

• Generika-Typ
  • siehe: dotnet/runtime#89439 Implementieren Sie ungebundene generische Unterstützung für UnsafeAccessorAttribute
• Statische Klasse, nicht öffentlicher Rückgabe-/Parametertyp (Generieren ignorieren)
  • siehe: dotnet/runtime#90081 UnsafeAccessorTypeAttribute für statischen oder privaten Typzugriff
• Ref-Struktur
  • Das Ref-Feld kann nicht an den Ref-Methodenparameter übergeben werden
• Typen aus externer DLL (zum Beispiel String )
  • Durch die Aktivierung von MetadataImportOptions.All im Quellgenerator sollte es wahrscheinlich möglich sein, es zu lesen. Allerdings habe ich keine Möglichkeit gefunden, das zu tun. Ich brauche Hilfe.

Lizenz

Diese Bibliothek ist unter der MIT-Lizenz lizenziert.