调用方法匿名类

本文关键字：方法 调用 | 更新日期: 2023-09-27 17:52:16

我是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
        {
        }
    }

我的目标是基于它的枚举实例化所有现有的具体类，将所有实例存储在字典中，然后在每个对象上调用一些方法。我不确定这是否可能?

我很高兴在这方面的任何提示!

调用方法匿名类

如果我理解你想做什么，它听起来像是一个多元素模式的版本。你可能会发现研究一下这个很有用。

来自维基百科的示例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;
    }
}

这不能直接粘贴到你的类中，但既然你在寻找提示，我认为它应该为你指明正确的方向。

关于上面代码的一个警告:如果没有找到key，方法GetInstance将更改字典。个人而言，我将"Get"前缀与只读方法联系起来。我要么重命名GetInstance，要么将其分成两个方法。

我真的不确定你的意思是"实例化所有现有的具体类基于它的枚举"，虽然。你能解释一下吗?

使用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);

在检索时，基于枚举键，您知道实例值代表的类型。

我不明白示例代码的目的，但是您可以这样写:

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
    {
    }
}
相关文章：