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的一个版本。您可能会发现研究它很有用。

来自维基百科的示例Multiton代码：

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

这不能直接粘贴到你的班级，但由于你正在寻找提示，我认为它应该指向你正确的方向。

关于上述代码的一个注意事项：如果找不到GetInstance，方法key将改变字典。就个人而言，我将“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
    {

    }
}

调用Method匿名类

3 个答案: