Invoquer une méthode de classe anonyme

Question

Je suis assez nouveau dans le monde C# et je m'excuse si le titre de la question ne correspond pas exactement au contenu. Mais maintenant, à mon problème:

J'ai la construction suivante:

public interface IClass<TEnum> 
    { 
     Dictionary<TEnum, ISecondClass> dictionary { get; } 
    } 

    public abstract class ClassBase<TEnum> : IClass<TEnum> 
    { 
    public abstract Dictionary<TEnum, ISecondClass> dictionary { get; protected set; } 
    } 

    public class ConcreteClass : ClassBase<ConcreteClass.Concrete> 
    { 
     public override Dictionary<Concrete, ISecondClass> dictionary { get; protected set; } 

     public enum Concrete : ulong 
     { 

     } 
    } 

    public class OtherClass : ClassBase<OtherClass.Other> 
    { 
     public override Dictionary<Concrete, ISecondClass> dictionary { get; protected set; } 

     public enum Other : ulong 
     { 

     } 
    } 

Mon but est de instancier toutes les classes existantes en béton, basé sur l'énumérations, stocker tous les cas dans un dictionnaire, puis appeler des méthodes sur chaque objet. Je ne suis pas sûr si c'est même possible?

Je suis content de vous avoir fait signe!

Answer 1

Si je comprends ce que vous essayez de faire, cela ressemble à une version de Multiton Pattern. Vous trouverez peut-être utile de faire cette recherche.

Dans l'exemple de code Multiton Wikipedia:

class FooMultiton 
{ 
    private static readonly Dictionary<object, FooMultiton> _instances = new Dictionary<object, FooMultiton>(); 

    private FooMultiton() {} 

    public static FooMultiton GetInstance(object key) 
    { 
     lock (_instances) 
     { 
      FooMultiton instance; 
      if (!_instances.TryGetValue(key, out instance)) 
      { 
       instance = new FooMultiton(); 
       _instances.Add(key, instance); 
      } 
     } 
     return instance; 
    } 
} 

Ce n'est pas pasteable directement dans votre classe, mais puisque vous êtes à la recherche de conseils, je pense qu'il devrait vous orienter dans la bonne direction. Un mot de prudence sur le code ci-dessus: La méthode GetInstance va modifier le dictionnaire si key est introuvable. Personnellement, j'associe le préfixe "Get" aux méthodes en lecture seule. Je renommerais GetInstance ou le diviserais en deux méthodes.

Je ne suis pas vraiment sûr de ce que vous entendez par "instancier toutes les classes de béton existantes basées sur ses enums", cependant. Pouvez-vous clarifier cela?

Answer 2

Utilisez Activator.CreateInstance() pour créer des objets de classes concrètes et les stocker dans un dictionnaire.

Passez votre string classname from Enum et créez des objets de classe dynamiques. les stocker dans Dictionary<Enum, ISecondClass>

myObject = (MyAbstractClass)Activator.CreateInstance("AssemblyName", "TypeName"); 

or 

var type = Type.GetType("MyFullyQualifiedTypeName"); 
var myObject = (MyAbstractClass)Activator.CreateInstance(type); 

Lors de la récupération, en fonction de votre clé ENUM, vous savez quel type de valeur d'instance représente.

Answer 3

Je ne comprends pas un objectif du code de l'échantillon, mais vous pouvez écrire quelque chose comme ceci:

public interface IClass 
{ 
    void MethodToDynamicInvoke(); 
} 

public abstract class ClassBase<T> 
    : IClass 
{ 
    private Dictionary<Type, List<IClass>> instances = new Dictionary<Type, List<IClass>>(); 

    public ClassBase() 
    { 
     List<IClass> list; 
     if (!instances.TryGetValue(typeof(T), out list)) 
     { 
      list = new List<IClass>(); 
      instances.Add(typeof(T), list); 
     } 

     list.Add(this); 
    } 

    public abstract void MethodToDynamicInvoke(); 

    public void InvokeMetodOnClassesWithSameEnum() 
    { 
     List<IClass> list; 
     if (instances.TryGetValue(EnumType, out list)) 
     { 
      foreach (var instance in list) 
      { 
       instance.MethodToDynamicInvoke(); 
      } 
     } 
    } 
} 

public class ConcreteClass 
    : ClassBase<ConcreteClass.Concrete> 
{ 
    public ConcreteClass() 
     : base() 
    { 
    } 

    public override void MethodToDynamicInvoke() 
    { 
     throw new NotImplementedException(); 
    } 

    public enum Concrete : ulong 
    { 
    } 
} 

public class OtherClass : ClassBase<OtherClass.Other> 
{ 
    public OtherClass() 
     : base() 
    { 
    } 

    public override void MethodToDynamicInvoke() 
    { 
     throw new NotImplementedException(); 
    } 

    public enum Other : ulong 
    { 

    } 
}