Ne peut pas se lier à la cible de la méthode lors de la création de délégués pour les propriétés

En essayant de créer deux dictionnaires d'émissions de délégués pour permettre l'amélioration de la performance lors de l'dynamiquement obtenir/définir les valeurs des propriétés.

Code:

  Properties = type.GetProperties(BindingFlags.Public | BindingFlags.Instance)
                    .Where(p => p.CanRead && !p.GetIndexParameters().Any())
                    .AsEnumerable();
  PropertyGetters = Properties.ToDictionary(p => p.Name, p => (Func<object, object>)Delegate.CreateDelegate(typeof(Func<object, object>), p.GetGetMethod()));
  PropertySetters = Properties.Where(p => p.GetSetMethod() != null)
                    .ToDictionary(p => p.Name, p => (Action<object, object>)Delegate.CreateDelegate(typeof(Action<object, object>), p.GetSetMethod()));

Mais j'ai l'exception suivante:

Ne peut pas se lier à la cible de la méthode en raison de sa signature ou de sécurité
la transparence n'est pas compatible avec le type de délégué.

De ce que j'ai lu ce seront causés par l'électricité statique/indexés/type de la valeur des propriétés, les Properties collection contient pas de charges ou d'indexer les propriétés, mais toutefois, j'ai besoin de ce travail pour le type de valeur des propriétés telles que int et double.

Comment puis-je créer les getters/setters que j'ai besoin tout en gardant mon code abstrait et en évitant les génériques?

Comment voulez-vous créer Properties? Exactement quand et vous obtenez cette exception?
Ajout de la collection de propriétés de définition de la inclus code, j'obtiens l'exception lorsque le code est exécuté sur un type.
Vous pouvez ajouter cette ligne de code, où vous obtenez une exception. il aidera aussi à comprendre, c'est comment vous allez utiliser ces dictionnaires.
La ligne où je reçois l'exception est juste le PropertyGetters de l'assignation, le code où elle est appelée à partir est juste une classe abstraite constructeur. Cependant j'ai tout simplement l'intention de les utiliser pour obtenir et définir les valeurs dynamiquement, donc, fondamentalement, je veux cache émis accesseurs et de les utiliser où chaque j'ai l'habitude d'être à l'aide de PropertyInfo.GetValue()

OriginalL'auteur Alex Hope O'Connor | 2013-07-02

  1. 7

    Ok fini par trouver ma réponse de cette question:
    MethodInfo.Invoquer problème de performance

    Plus particulièrement cet article:
    Faire la réflexion à la mouche et à explorer les délégués

    Voici le jist de code que j'ai fini avec:

    public class Helper
{
private IDictionary<string, Func<object, object>> PropertyGetters { get; set; }
private IDictionary<string, Action<object, object>> PropertySetters { get; set; }
public static Func<object, object> CreateGetter(PropertyInfo property)
{
if (property == null)
throw new ArgumentNullException("property");
var getter = property.GetGetMethod();
if (getter == null)
throw new ArgumentException("The specified property does not have a public accessor.");
var genericMethod = typeof(Helper).GetMethod("CreateGetterGeneric");
MethodInfo genericHelper = genericMethod.MakeGenericMethod(property.DeclaringType, property.PropertyType);
return (Func<object, object>)genericHelper.Invoke(null, new object[] { getter });
}
public static Func<object, object> CreateGetterGeneric<T, R>(MethodInfo getter) where T : class
{
Func<T, R> getterTypedDelegate = (Func<T, R>)Delegate.CreateDelegate(typeof(Func<T, R>), getter);
Func<object, object> getterDelegate = (Func<object, object>)((object instance) => getterTypedDelegate((T)instance));
return getterDelegate;
}
public static Action<object, object> CreateSetter(PropertyInfo property)
{
if (property == null)
throw new ArgumentNullException("property");
var setter = property.GetSetMethod();
if (setter == null)
throw new ArgumentException("The specified property does not have a public setter.");
var genericMethod = typeof(Helper).GetMethod("CreateSetterGeneric");
MethodInfo genericHelper = genericMethod.MakeGenericMethod(property.DeclaringType, property.PropertyType);
return (Action<object, object>)genericHelper.Invoke(null, new object[] { setter });
}
public static Action<object, object> CreateSetterGeneric<T, V>(MethodInfo setter) where T : class
{
Action<T, V> setterTypedDelegate = (Action<T, V>)Delegate.CreateDelegate(typeof(Action<T, V>), setter);
Action<object, object> setterDelegate = (Action<object, object>)((object instance, object value) => { setterTypedDelegate((T)instance, (V)value); });
return setterDelegate;
}
public Helper(Type type)
{
var Properties = type.GetProperties(BindingFlags.Public | BindingFlags.Instance)
.Where(p => p.CanRead && !p.GetIndexParameters().Any()).AsEnumerable();
PropertyGetters = Properties.ToDictionary(p => p.Name, p => CreateGetter(p));
PropertySetters = Properties.Where(p => p.GetSetMethod() != null)
.ToDictionary(p => p.Name, p => CreateSetter(p));
}
}

    Générés délégués sur la moyenne semble être de 80% plus rapide que l'utilisation de la réflexion, donc je suis content du résultat!

    Glad vous avez trouvé des avantages à partir de l'article ci-dessus!

    OriginalL'auteur Alex Hope O'Connor

  2. -1

    J'ai été faire la même erreur. J'ai utilisé Expressions API pour résoudre ce problème.

    Remarque : la Méthode pour être référencé est

    • pas générique.
    • est statique.

    Nom du délégué est de la Formule et sa signature est comme suit

    public delegate float Formula(Dictionary<string, float> cr, 
List<Dictionary<string, float>> allr);

    1. Obtenir MethodInfo qui est d'être référencé en tant que Délégué

      Assembly assembly = results.CompiledAssembly;
var generatedType = assembly.GetType("First.NewClass");
var generatedMethod = generatedType.GetMethod("FormulaMethod");

    2. Préparer les arguments du Délégué comme Paramètre une Expression.
      Argument 1 : Dictionary<string, float>
      Argument 2 : List<Dictionary<string, float>>

      var arg1Expression = Expression.Parameter(typeof(Dictionary<string, float>));

      var arg2Expression = Expression.Paramètre(typeof(Liste>));

    3. Générer de la finale de l'Appel de méthode d'Expression et de retour Délégué.

      var methodCall = Expression.Call(generatedMethod,
arg1Expression,
arg2Expression);  
return Expression.Lambda <Formula> (methodCall, 
arg1Expression, 
arg2Expression).Compile();

    OriginalL'auteur Abhijeet Nagre