調用方法匿名類

Question

我對C＃世界相當陌生，如果問題標題與內容不完全匹配，我表示歉意。但現在我的問題：

我有以下結構：

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 
     { 

     } 
    } 

我的目標是實例基於它的枚舉所有現有的具體類，所有實例存儲在一個字典，後來調用每個一些方法目的。 我不確定這是否可能？

我很高興有任何提示！

Answer 1

如果我明白你想要做什麼，聽起來像是Multiton Pattern的一個版本。你可能會發現研究它很有用。

維基百科的例子多例代碼：

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; 
    } 
} 

這不是直接pasteable到類，但因爲你正在尋找線索，我認爲它應該指向你在正確的方向。

關於上述代碼需要注意的一個字：如果未找到key，則方法GetInstance將更改字典。就我個人而言，我將「Get」前綴與只讀方法相關聯。我會重命名GetInstance或將其分爲兩種方法。不過，我不太清楚你的意思是「基於它的枚舉實例化所有現有的具體類」。你能澄清一下嗎？

Answer 2

使用Activator.CreateInstance()來創建具體類的對象並將它們存儲到字典中。

傳遞您的string classname from Enum並創建動態類對象。它們存儲到Dictionary<Enum, ISecondClass>

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

or 

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

雖然檢索，根據您的枚舉密鑰，你知道代表什麼類型的實例值。

Answer 3

我不明白，示例代碼的目標，但你可以寫一些這樣的事：

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 
    { 

    } 
}