c # comment obtenir le nom du type d'un appelant

J'ai obtenu cette classe

public class fooBase
{
    public List<MethodsWithCustAttribute> MethodsList;
    public bool fooMethod([CallerMemberName]string membername =""))
    {
        //This returns a value depending of type and method 
    } 
    public void GetMethods()
    {
        //Here populate MethodsList using reflection
    }
}

Et Cet Attribut N'Classe

//This attribute get from a database some things, then fooMethod check this attribute members 
public class CustomAttribute
{
    public string fullMethodPath;
    public bool someThing ; 
    public bool CustomAttribute([CallerMemberName]string membername ="")
    {
        fullMethodPath = **DerivedType** + membername 
        // I need here to get the type of membername parent. 
        // Here I want to get CustClass, not fooBase

    }
}

Puis j'ai cette

public class CustClass : fooBase
{
     [CustomAttribute()]
     public string method1()
     {
         if (fooMethod())
         {
             ....
         }
     }
}

J'ai besoin du nom du Type de l'CallerMember, il y a quelque chose comme [CallerMemberName] pour obtenir le Type de la classe propriétaire de l'Appelant ?

source d'informationauteur Juan Pablo Gomez

  1. 8

    Il n'est pas infaillible, mais la convention .NET est d'avoir un type de fichier et le nom du fichier le même que le type. Notre outillage tend également à faire respecter cette convention, c'est à dire Resharper & Visual Studio.

    Par conséquent, il doit être raisonnable de déduire le type de nom du chemin d'accès au fichier.

    public class MyClass
{
  public void MyMethod([CallerFilePath]string callerFilePath = null, [CallerMemberName]string callerMemberName = null)
  {
    var callerTypeName = Path.GetFileNameWithoutExtension(callerFilePath);
    Console.WriteLine(callerTypeName);
    Console.WriteLine(callerMemberName);
  }
}
  2. 4

    Les informations que CompilerServices offre est trop peu à mon avis, pour obtenir le type de la méthode appelante.
    Ce que vous pourriez faire est d'utiliser StackTrace (voir) pour trouver la méthode d'appel (à l'aide de GetMethod()) et le type à l'aide de Reflection à partir de là.

    Considérer les points suivants:

    using System.Runtime.CompilerServices;

public class Foo {
    public void Main() {
        what();
    }

    public void what() {
        Bar.GetCallersType();
    }

    public static class Bar {

        [MethodImpl(MethodImplOptions.NoInlining)]  //This will prevent inlining by the complier.
        public static void GetCallersType() {
            StackTrace stackTrace = new StackTrace(1, false); //Captures 1 frame, false for not collecting information about the file
            var type = stackTrace.GetFrame(1).GetMethod().DeclaringType;
            //this will provide you typeof(Foo);
        }
    }
}

    Avis - @Jay a dit dans les commentaires, il peut être assez cher, mais il fait le travail.

    Edit:

    J'ai trouvé quelques arcticles de la comparaison de la performance, et il est en effet horrbily cher par rapport à Reflection qui est également considéré comme pas le meilleur.
    Voir: [1] [2]

    Edit 2:

    Donc, après un regard en profondeur sur StackTraceil n'est en effet pas sûr de l'utiliser et même coûteux.

    Puisque chaque méthode qui sera appelée va être marqué avec un [CustomAttribute()], il est possible de recueillir toutes les méthodes qu'il contient en une liste statique.

    public class CustomAttribute : Attribute {
    public static List<MethodInfo> MethodsList = new List<MethodInfo>();
    static CustomAttribute() {
        var methods = Assembly.GetExecutingAssembly() //Use .GetCallingAssembly() if this method is in a library, or even both
                  .GetTypes()
                  .SelectMany(t => t.GetMethods())
                  .Where(m => m.GetCustomAttributes(typeof(CustomAttribute), false).Length > 0)
                  .ToArray();
        MethodsList = new List<MethodInfo>(methods);
    }

    public string fullMethodPath;
    public bool someThing;

    public  CustomAttribute([CallerMemberName] string membername = "") {
        var method = MethodsList.FirstOrDefault(m=>m.Name == membername);
        if (method == null || method.DeclaringType == null) return; //Not suppose to happen, but safety comes first
        fullMethodPath = method.DeclaringType.Name + membername; //Work it around any way you want it
        // I need here to get the type of membername parent. 
        // Here I want to get CustClass, not fooBase
    }
}

    Jouer avec cette approche pour s'adapter à votre besoin précis.

  3. 3

    Appelant membre

    Accordée, l'obtention de l'appelant nom de membre est pas "naturel" dans le modèle objet.
    C'est pourquoi les ingénieurs C# introduit CallerMemberName dans le compilateur.

    Le véritable ennemi est la duplication, et basée sur la pile des solutions de contournement sont inefficaces.

    [CallerMemberName] permet d'obtenir l'information sans duplication et sans mauvais effet.

    De l'appelant type de

    Mais l'obtention de l'appelant membre type est naturel et facile à obtenir sans duplication.

    Comment le faire

    Ajouter un "appelant" paramètre fooMethodsans attribut nécessaire.

        public bool fooMethod(object caller, [CallerMemberName]string membername = "")
    {
        Type callerType = caller.GetType();
        //This returns a value depending of type and method 
        return true;
    }

    Et de l'appeler comme ceci:

    fooMethod(this);

    - Ce répondre à la question

    Vous avez déclaré

    //Ici je veux obtenir CustClass, pas fooBase

    et c'est exactement ce que vous allez obtenir.

    D'autres situations où il ne serait pas wok.

    Tout ce exactement répond à vos exigences, il existe d'autres, différentes, des cas où ça ne marcherait pas.

    • Lorsque l'appelant est une des méthodes statiques (il n'y a pas de "ce").
    • Quand on veut le type de l'appelant de la méthode elle-même, et non pas le type de l'appelant lui-même (qui peut être une sous-classe de la première).

    Dans ceux cas, un [CallerMemberType] peut avoir du sens.
    Pourtant, ces cas ont des solutions de locaux pour la plupart à l'appelant fichier source, de sorte qu'ils ne sont pas une grosse affaire, à mon humble avis.