¿Cómo se puede heredar de una clase sellada usando la reflexión en .Net?

Question

Antes de que comiences a dispararme, NO estoy buscando hacer esto, pero alguien en another post 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

Sin funciones virtuales que sobrescribir, no tiene mucho sentido crear subclases de una clase sellada.

Si intenta escribir una clase sellada con una función virtual en ella, se obtiene 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 cerradas que declaró en una clase base (como este),

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 colar a través del compilador para permitir que se declara 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, por lo que supongo que el CLR en realidad lo hace cumplir. Tendría que cargar el código, desmontarlo, quitar el bit 'sellado', volver a montarlo y cargar la nueva versión.

Answer 2

Se FUERZA (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 CONOZCA cómo ... era lo que pensaban.

Answer 3

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 this article). Pero ciertamente es posible atornillar algo con Reflection. Emit que no estén atrapados hasta que intentes ejecutar realmente el código emitido.

Answer 4

Lo siento por 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

Crear una nueva clase llamada GenericKeyValueBase

poner esto en él

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

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

Y heredar de que además se puede añadir métodos de extensión adicionales para Agregar/Quitar (AddAt y RemoveAt) a su nueva clase derivada (y convertirla en una colección/diccionario) si te sientes realmente genial.

Un ejemplo implementació sencillo en el que se utilizaría un System.Collections.Generic.KeyValuePair normal para una base, pero en su lugar puede utilizar el código anterior

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