Comment pouvez-vous hériter d'une classe scellée en utilisant la réflexion dans .Net?

Question

Avant de commencer à tirer sur moi, je ne cherche pas à le faire, mais quelqu'un au another post a dit que c'était possible. Comment est-ce possible? Je n'ai jamais entendu parler d'hériter de quelque chose en utilisant la réflexion. Mais j'ai vu des choses étranges ...

Answer 1

Sans fonctions virtuelles à remplacer, il est inutile de sous-classer une classe scellée.

Si vous essayez d'écrire une classe scellée avec une fonction virtuelle, vous obtenez l'erreur du compilateur suivant:

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

Cependant, vous pouvez obtenir des fonctions virtuelles dans les classes scellées en les déclarant dans une classe de base (comme celui-ci),

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) {} 
} 

le problème reste encore bien, je ne vois pas comment vous pourriez se faufiler devant le compilateur pour vous racontons une sous-classe. J'ai essayé d'utiliser IronRuby (ruby est le plus hack de toutes les langues hackety) mais même cela ne me laisserait pas.

La partie 'scellée' est intégrée dans le MSIL, donc j'imagine que le CLR lui-même l'applique réellement. Vous devez charger le code, le désassembler, retirer le bit «scellé», puis le réassembler et charger la nouvelle version.

Answer 2

Il Might (augmenterait la taille si je pouvais). Selon les gars de freenode, cela impliquerait de modifier le code de byte, en utilisant Reflection.Emit, et de donner au JIT un nouvel ensemble de code de byte.

Pas que je SAVOIR comment ... c'était juste ce qu'ils pensaient.

Answer 3

L'autre affiche peut-être plus penser à Reflection.Emit plutôt que les API de réflexion en lecture seule plus habituelles.

Cependant, ce n'est toujours pas possible (au moins selon this article). Mais il est certainement possible de visser quelque chose avec Reflection.Emit qui ne sont pas piégés jusqu'à ce que vous essayez d'exécuter réellement le code émis.

Answer 4

Je suis désolé de publier des hypothèses incorrectes dans l'autre thread, j'ai échoué à rappeler correctement. À l'aide de l'exemple suivant, en utilisant Reflection.Emit, montre comment dériver d'une autre classe, mais il échoue à l'exécution en lançant une exception 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

Créer une nouvelle classe appelée GenericKeyValueBase

mis cela dans ce

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

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

Et hériter de ce plus, vous pouvez ajouter des méthodes d'extension supplémentaires pour Ajout/Suppression (Addat et RemoveAt) à votre nouvelle classe dérivée (et en faire une collection/dictionnaire) si vous vous sentez vraiment cool.

Un exemple simple implentation où vous utiliseriez un System.Collections.Generic.KeyValuePair normal pour une base, mais peut plutôt utiliser le code ci-dessus

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