Question

这是我的班级员工，另一个来自Employee（它只是一个示例类）：

public class Employee
{
    public int EmployeeID { get; set; }
    public Type type { get; set; }
    public string Name { get; set; }
}

public class Manager : Employee
{
    public void DoSomething()
    {
        // Bla bla
    }
}

public class Salesman : Employee
{
    public void DoAnotherSomething()
    {
        // Bla bla
    }
}

如您所见，我的Employee类有一个Type属性，包含Manager或Salesman。我不想使用很多switch case，所以有没有办法在知道类型变量的情况下创建对象？

更新1：

好吧，我的意思是。在我的真实节目中。我正在使用许多开关案例来创建对象：

        Employee employee = new Employee();
        // I do somethings to get the values to employee I store it in a Employee list

        // Then I need to create the particular object of each one, I need to travel all 
        // the list an create its instance
        switch (employee.Type)
        {
            case Manager:
                employee = new Manager();

                // Some stuff
                break;
            case Salesman:
                employee = new Salesman();

                // Some stuff
                break;
        }

在我的真实代码中，我需要使用130个案例，或多或少。所以我想用另一种方法来避免这个。

Answer 1

如果您试图避免切换到设置Type属性，可以在Employee上定义一个构造函数，它将type作为参数：

protected Employee(Type type) { 
    this.type = type;
}

从每个子类的构造函数中调用它：

public Manager() : base(typeof(Manager)) { }

此模式通常还要求将Employee声明为抽象，以便您不会意外创建不是已知类型的Employee。如果您希望Employees只是Employees，您可以将其保留为具体（非抽象）类，并定义一个构造函数来调用我建议的新构造函数，如下所示：

public Employee() : this(typeof(Employee)) { }

Answer 2

为什么不创建一个接口IEmployee而不是继承类Employee，并且要创建每个“Employee”类型类来实现该接口？

Answer 3

你永远不想要开启类型。这是代码气味，你正在使用OOP错误。相反，您应该始终努力以多态方式使用您的类。如果我正确理解你的问题，你就有了一个员工，并希望制作另一个相同的类型。这称为虚拟构造函数，通常使用虚拟克隆方法处理：

class Employee
{
  public virtual Employee Clone();
};

class Manager
{
  public override Manager Clone()
  {
     return new Manager(this);
  }
};

或类似的东西。

Answer 4

这听起来像你想要一个工厂模式来获取一些鉴别器并创建一个实例并通过静态方法返回它：

class EmployeeFactory
{
  public static Employee NewEmployee(EmployeeType type)
  {
     Employee emp = null;
     switch (type)
     {
        case EmployeeType.Manager :
           emp = new Manager();
           break;
        case EmployeeType.Salesman :
           emp = new Salesman();
           break;
     }
     return emp;
  }
}

Answer 5

你可以做一个

var factory = new Dictionary<Type, Func<Employee>> {
    Type.Mgr, ()=>new Manager(),
    Type.Sales, ()=>new Salesman()
};

并像

一样使用它

var salesman = factory[Type.Sales](); //creates a salesman

（假设这是你的问题所要求的）。但我同意其他海报，如果这是你所要求的，那么它通常被认为是不好的做法。

Answer 6

由于您已经拥有该类型，因此可以使用System.Activator？

Type type = typeof(Manager);  
var manager = (Manager) Activator.CreateInstance(type);

了解业务案例将有助于具体回答。目前尚不清楚为什么要实例化已经知道Type的对象。而不是将Type-parameter传递给工厂方法，为什么不直接传入Func或对象？

是否有另一种方法来创建一个不使用new的实例？

6 个答案: