polimorfico - ¿Cómo puedes heredar de una clase sellada usando el reflejo en.Net?

polimorfismo en c# windows form

Question

Antes de que comiences a dispararme, NO estoy buscando hacer esto, pero alguien en otra publicación dijo que era posible. ¿Como es posible? Nunca he oído hablar de heredar de nada usando la reflexión. Pero he visto algunas cosas extrañas ...

Answer 1

El otro póster puede haber estado pensando más en las líneas de Reflection.Emit en lugar de las API de Reflection de solo lectura más habituales.

Sin embargo, todavía no es posible (al menos según este artículo ). Pero ciertamente es posible atornillar algo con Reflection. Emit que no estén atrapados hasta que intentes ejecutar realmente el código emitido.

Answer 2

Sin funciones virtuales que anular, no tiene mucho sentido subclasificar una clase sellada.

Si intenta escribir una clase sellada con una función virtual en ella, obtendrá el siguiente error de compilación:

// error CS0549: ''Seal.GetName()'' is a new virtual member in sealed class ''Seal''

Sin embargo, puede obtener funciones virtuales en clases selladas al declararlas en una clase base (como esta),

public abstract class Animal
{
    private readonly string m_name;

    public virtual string GetName() { return m_name; }

    public Animal( string name )
    { m_name = name; }
}

public sealed class Seal : Animal
{
    public Seal( string name ) : base(name) {}
}

El problema sigue siendo sin embargo, no puedo ver cómo se puede escabullir el compilador para que pueda declarar una subclase. Traté de usar IronRuby (ruby es el más hackeo de todos los lenguajes de hackety) pero incluso no me lo permitió.

La parte ''sellada'' está incrustada en el MSIL, así que supongo que el CLR en sí mismo aplica esto. Tendría que cargar el código, desmontarlo, quitar el bit ''sellado'', volver a montarlo y cargar la nueva versión.

Answer 3

PODRÍA (aumentaría el tamaño si pudiera). Según los chicos de freenode, implicaría modificar el código de byte, usar Reflection.Emit, y darle al JIT un nuevo conjunto de código byte.

No es que yo sepa cómo ... fue solo lo que pensaron.

Answer 4

Lamento publicar suposiciones incorrectas en el otro hilo, no pude recordar correctamente. Usando el siguiente ejemplo, usando Reflection.Emit, muestra cómo derivar de otra clase, pero falla en tiempo de ejecución al lanzar una TypeLoadException.

sealed class Sealed
{
   public int x;
   public int y;
}

class Program
{
   static void Main(string[] args)
   {
      AppDomain ad = Thread.GetDomain();
      AssemblyName an = new AssemblyName();
      an.Name = "MyAssembly";
      AssemblyBuilder ab = ad.DefineDynamicAssembly(an, AssemblyBuilderAccess.Run);
      ModuleBuilder mb = ab.DefineDynamicModule("MyModule");
      TypeBuilder tb = mb.DefineType("MyType", TypeAttributes.Class, typeof(Sealed));

      // Following throws TypeLoadException: Could not load type ''MyType'' from
      // assembly ''MyAssembly'' because the parent type is sealed.
      Type t = tb.CreateType();
   }
}

Answer 5

Crea una nueva clase llamada GenericKeyValueBase

poner esto en esto

  public class GenericKeyValueBase<TKey,TValue>
    {
        public TKey Key;
        public TValue Value;

        public GenericKeyValueBase(TKey ItemKey, TValue ItemValue)
        {
            Key = ItemKey;
            Value = ItemValue;
        }
    }

Y hereda de esa ventaja, puedes agregar métodos de extensión adicionales para Agregar / Eliminar (AddAt y RemoveAt) a tu nueva clase derivada (y convertirla en una colección / diccionario) si te sientes realmente genial.

Un ejemplo simple de implementación en el que usaría un System.Collections.Generic.KeyValuePair normal para una base, pero en su lugar puede usar el código anterior

  class GenericCookieItem<TCookieKey, TCookieValue> : GenericKeyValueBase<TCookieKey,TCookieValue>
    {
        public GenericCookieItem(TCookieKey KeyValue, TCookieValue ItemValue) : base(KeyValue, ItemValue)
        {
        }
    }