Utilisation de Reflection.Emit pour créer une classe implémentant une interface

J'ai besoin de générer une classe à l'aide de la Réflexion.Émettent qui implémente l'interface suivante.

public interface IObject
{
    T Get<T>(string propertyName); 
}

Quelqu'un aurait-il un exemple de la façon dont je voudrais émettre le suit comme un simple cas de test?

class GeneratedObject : IObject
{
    public T Get<T>(string propertyName)
    {
        //this is the simplest possible implementation
        return default(T);
    }
}

source d'informationauteur karma

  1. 10

    Si vous êtes à l'aide de la Réflexion.Émettre, vous devriez vraiment prendre une copie de la De la réflexion.Émettre de la langue de complément pour Réflecteur. Tout n'est pas parfait, il devrait vous obtenir au moins 95% de la sorte à un code émis.

  2. 4

    Je n'ai pas de compilateur à portée de main, mais quelque chose comme cela devrait fonctionner:

    var aName = new AssemblyName("temp");
var appDomain = Threading.Thread.GetDomain();
var aBuilder = appDomain.DefineDynamicAssembly(aName, AssemblyBuilderAccess.Run);
var mBuilder = aBuilder.DefineDynamicModule(aName.Name);
var tBuilder = mBuilder.DefineType("GeneratedObject", TypeAttributes.Public | TypeAttributes.Class);
tBuilder.AddInterfaceImplementation(typeof(IObject));
var methBuilder = tBuilder.DefineMethod("Get", MethodAttributes.Public | MethodAttributes.Final | MethodAttributes.Virtual);
var typeParam = mb.DefineGenericParameters(new string[] { "T" })[0];
methBuilder.SetParameters(new Type[] { typeof(string) });
methBuilder.SetReturnType(typeParam);
var ilg = methBuilder.GetILGenerator();
let lBuilder = ilg.DeclareLocal(typeParam);
ilg.Emit(OpCodes.Ldloca_S, (byte)0);
ilg.Emit(OpCodes.Initobj, typeParam);
ilg.Emit(OpCodes.Ldloc_0);
ilg.Emit(OpCodes.Ret);
var generatedType = tBuilder.CreateType();
  3. 0

    Je crois AutoMapper et/ou LinFu le fera pour vous. Vous pouvez certainement créer une instance d'une interface à l'aide de AutoMapper, je l'ai fait.

  4. 0

    Vous avez oublié de COCHER le retour:

    internal delegate object FastConstructorHandler(object[] paramters);

    private static FastConstructorHandler CreateDelegate(Type Tipo)
    {
        DynamicMethod dynamicMethod = new DynamicMethod(string.Empty,
            typeof(object), new Type[] { typeof(object[]) }, Tipo.Module, false);

        ILGenerator ilg = dynamicMethod.GetILGenerator();

        ilg.DeclareLocal(Tipo);
        ilg.Emit(OpCodes.Ldloca_S, (byte)0);
        ilg.Emit(OpCodes.Initobj, Tipo);
        ilg.Emit(OpCodes.Ldloc_0);
        ilg.Emit(OpCodes.Box, Tipo);
        ilg.Emit(OpCodes.Ret);

        return (FastConstructorHandler)dynamicMethod.CreateDelegate(typeof(FastConstructorHandler));
    }
  5. 0

    Paraît-il, vous voulez faire de l'accès rapide à des propriétés de l'objet par son nom, sans réflexion au moment de l'exécution.
    À l'aide de Yappi et de ses Biens<> classe, vous pouvez mettre en œuvre étant donné interface comme ceci:

    class GeneratedObject : IObject
{
    public string Value { get { return "Test"; } }

    public T Get<T>(string propertyName)
    {
        return Property<GeneratedObject>.Get<T>(this,propertyName);
    }
}

    et ensuite l'utiliser comme ceci:

    IObject obj = new GeneratedObject();
var value = obj.Get<String>("Value"); //value contains "Test"

    Avez-vous encore besoin IObject et de type dynamique de construction?