集中程序的操作

本文关键字：操作 程序 集中 | 更新日期: 2023-09-27 17:53:17

我有一个程序，需要从各种形式执行一些操作。我想把这些动作放在一个集中的空间里。每个操作都有自己的类，该类派生自接口。

每个操作只实例化一次，但在不同的地方使用，如上下文菜单，功能区，工具栏等。

我有下面的代码工作，我想摆脱类型in时，使一个列表。我想要强类型，无反射和重构的可能性。

这能做得更有效率吗?

class Program
    {
        static void Main(string[] args)
        {
            ActionManager actionManager = new ActionManager();
            List<SomeInterface> listA = actionManager.CreateList(typeof(Do_A), typeof(Do_B));
            List<SomeInterface> listB = actionManager.CreateList(typeof(Do_A), typeof(Do_B));
        }
    }
    public class ActionManager
    {
        private Dictionary<Type, SomeInterface> instantiatedActions = new Dictionary<Type, SomeInterface>();
        public List<SomeInterface> CreateList(params Type[] actions)
        {
            List<SomeInterface> theList = new List<SomeInterface>();
            foreach (Type type in actions)
            {
                if(!instantiatedActions.ContainsKey(type))
                {
                    instantiatedActions.Add(type, (SomeInterface)Activator.CreateInstance(type));
                }
                theList.Add(instantiatedActions[type]);
            }
            return theList;
        }
    }
    public interface SomeInterface
    {
    }
    public class Do_A : SomeInterface
    {
    }
    public class Do_B : SomeInterface
    {
    }
    public class Do_C : SomeInterface
    {
    }

集中程序的操作

如果类型尚未出现，则可以创建返回类型的表达式。这将允许您保留强类型，并强制只允许传入SomeInterface实现。

static void Main(string[] args)
{
    ActionManager actionManager = new ActionManager();
    List<SomeInterface> listA = actionManager.CreateList<SomeInterface>(
            () => new Do_A(), () => new Do_B());
    List<SomeInterface> listB = actionManager.CreateList<SomeInterface>(
            () => new Do_A(), () => new Do_B());
}
public class ActionManager
{
    private Dictionary<Type, SomeInterface> instantiatedActions = 
            new Dictionary<Type, SomeInterface>();
    public List<SomeInterface> CreateList<T>(params Expression<Func<T>>[] actions)
    {
        List<SomeInterface> theList = new List<SomeInterface>();
        foreach (var action in actions)
        {
            var type = GetObjectType<T>(action);
            if(!instantiatedActions.ContainsKey(type))
            {
                instantiatedActions.Add(type, (SomeInterface)action.Compile().Invoke());
            }
            theList.Add(instantiatedActions[type]);
        }
        return theList;
    }
    private static Type GetObjectType<T>(Expression<Func<T>> expr)
    {
        if ((expr.Body.NodeType == ExpressionType.Convert) ||
            (expr.Body.NodeType == ExpressionType.ConvertChecked))
        {
            var unary = expr.Body as UnaryExpression;
            if (unary != null)
                return unary.Operand.Type;
        }
        return expr.Body.Type;
    }
}

需要注意的是，既需要编译表达式来调用它，又需要从表达式树返回类型。但是，根据您的评论，它只在类型尚未被看到的情况下才确保惰性实例化，并保证类型安全。

相关文章：