Téléchargement PrivateProxy - Téléchargement du code source PrivateProxy

Important

Le générateur Roslyn/Source actuel a des limites pour accéder aux membres privés des projets référencés. De plus, l'accès aux membres privés peut conduire à des situations où cela fonctionne correctement dans l'EDI mais échoue pendant le processus de construction. Pour plus de détails, veuillez vous référer au problème Roslyn, MetadataImportOptions.All ne fonctionne pas dans les générateurs de sources ?. Pour éviter toute confusion, j'archiverai ceci jusqu'à ce que la relation entre les générateurs de sources et les membres privés soit améliorée.

Proxy Privé

Source Generator et .NET 8 UnsafeAccessor, un accesseur privé hautes performances fortement typé pour les tests unitaires et l'exécution.

[GeneratePrivateProxy(typeof(TargetType))] génère un proxy accesseur.

 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 ;

Le code généré est entièrement saisi, vous pouvez accéder au fichier privé via IntelliSense et lorsque le champ privé a été modifié, vous pouvez vérifier l'erreur du compilateur.

Aucune pénalité de performances, il peut être utilisé non seulement pour les tests unitaires mais également pour l'exécution
Aucune dépendance d'exécution (tous les codes sont inclus dans le générateur source)
Les accesseurs privés sont fortement typés
Prend en charge à la fois les instances, les statiques et les champs, propriétés et méthodes
Prend en charge les paramètres de méthode ref , out , in et ref readonly
Prend en charge le champ et la propriété readonly
Prend en charge le retour ref
Prend en charge la structure mutable
Prend en charge le constructeur d'instance

Par exemple, il s'agit de l'exemple de structure mutable et statique, de retour de référence et de constructeur.

 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

Cette bibliothèque est distribuée via NuGet, la configuration minimale requise est .NET 8 et C# 12.

PM> Package d'installation PrivateProxy

Le package fournit uniquement un analyseur et le code généré ne dépend d’aucune autre bibliothèque.

Membres pris en charge

Type de cible et membre 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 ) { }
}

Le type de proxy peut être 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 a deux constructeurs, lorsque vous utilisez le paramètre PrivateProxyGenerateKinds , vous pouvez configurer la génération du type de membre.

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

Limitation

Actuellement, les fonctionnalités suivantes ne sont pas prises en charge

Type de génériques
- voir : dotnet/runtime#89439 Implémenter la prise en charge générique non liée pour UnsafeAccessorAttribute
Classe statique, type de retour/paramètre non public (ignorer la génération)
- voir : dotnet/runtime#90081 UnsafeAccessorTypeAttribute pour un accès de type statique ou privé
structure de référence
- Le champ ref ne peut pas passer au paramètre de la méthode ref
Types de DLL externes (par exemple String )
- Probablement, en activant MetadataImportOptions.All dans le générateur de source, il devrait être possible de le lire. Cependant, je n'ai pas réussi à trouver un moyen de le faire. J'ai besoin d'aide.