C# С Помощью Активатора.Метод createinstance

Я предлагаю вам дать вашей заводской реализации метод RegisterImplementation. Поэтому каждый новый класс-это просто вызов метода, и вы не меняете свой код фабрик.

обновление:
Я имею в виду что-то вроде этого:

создайте интерфейс, который определяет вычисление. Согласно вашему коду, вы уже сделали это. Для того, чтобы быть полным, я собираюсь использовать следующий интерфейс в остальной части моего ответа:

public interface ICalculation
{
    void Initialize(string originalData);
    void DoWork();
}

ваш фабрика будет выглядеть примерно так:

public class CalculationFactory
{
    private readonly Dictionary<string, Func<string, ICalculation>> _calculations = 
                        new Dictionary<string, Func<string, ICalculation>>();

    public void RegisterCalculation<T>(string method)
        where T : ICalculation, new()
    {
        _calculations.Add(method, originalData =>
                                  {
                                      var calculation = new T();
                                      calculation.Initialize(originalData);
                                      return calculation;
                                  });
    }

    public ICalculation CreateInstance(string method, string originalData)
    {
        return _calculations[method](originalData);
    }
}

этот простой класс фабрики не хватает проверки ошибок по причине простоты.

обновление 2:
Вы бы инициализировать его, как это где-то в вашей программе инициализации приложений:

CalculationFactory _factory = new CalculationFactory();

public void RegisterCalculations()
{
    _factory.RegisterCalculation<Pivot>("Pivot");
    _factory.RegisterCalculation<GroupBy>("GroupBy");
    _factory.RegisterCalculation<StandardDeviation>("Standard deviation");
    _factory.RegisterCalculation<PhosphoPRASPercentage>("% phospho PRAS Protein");
    _factory.RegisterCalculation<AveragePPPperTreatment>("AveragePPPperTreatment");
    _factory.RegisterCalculation<AvgPPPNControl>("AvgPPPNControl");
    _factory.RegisterCalculation<PercentageInhibition>("PercentageInhibition");
}

просто в качестве примера, как добавить инициализацию в конструктор:

что-то похожее на:

Activator.CreateInstance(Type.GetType("ConsoleApplication1.Operation1"), initializationData);

но написанный с выражением Linq, часть кода берется здесь:

public class Operation1 
{
    public Operation1(object data)
    { 
    }
}

public class Operation2 
{
    public Operation2(object data)
    {
    }
}

public class ActivatorsStorage
{
    public delegate object ObjectActivator(params object[] args);

    private readonly Dictionary<string, ObjectActivator> activators = new Dictionary<string,ObjectActivator>();

    private ObjectActivator CreateActivator(ConstructorInfo ctor)
    {
        Type type = ctor.DeclaringType;

        ParameterInfo[] paramsInfo = ctor.GetParameters();
        ParameterExpression param = Expression.Parameter(typeof(object[]), "args");

        Expression[] argsExp = new Expression[paramsInfo.Length];

        for (int i = 0; i < paramsInfo.Length; i++)
        {
            Expression index = Expression.Constant(i);
            Type paramType = paramsInfo[i].ParameterType;

            Expression paramAccessorExp = Expression.ArrayIndex(param, index);

            Expression paramCastExp = Expression.Convert(paramAccessorExp, paramType);

            argsExp[i] = paramCastExp;
        }

        NewExpression newExp = Expression.New(ctor, argsExp);

        LambdaExpression lambda = Expression.Lambda(typeof(ObjectActivator), newExp, param);

        return (ObjectActivator)lambda.Compile();
    }

    private ObjectActivator CreateActivator(string className)
    {
        Type type = Type.GetType(className);
        if (type == null)
            throw new ArgumentException("Incorrect class name", "className");

        // Get contructor with one parameter
        ConstructorInfo ctor = type.GetConstructors()
            .SingleOrDefault(w => w.GetParameters().Length == 1 
                && w.GetParameters()[0].ParameterType == typeof(object));

        if (ctor == null)
                throw new Exception("There is no any constructor with 1 object parameter.");

        return CreateActivator(ctor);
    }

    public ObjectActivator GetActivator(string className)
    {
        ObjectActivator activator;

        if (activators.TryGetValue(className, out activator))
        {
            return activator;
        }
        activator = CreateActivator(className);
        activators[className] = activator;
        return activator;
    }
}

использование следующее:

ActivatorsStorage ast = new ActivatorsStorage();
var a = ast.GetActivator("ConsoleApplication1.Operation1")(initializationData);
var b = ast.GetActivator("ConsoleApplication1.Operation2")(initializationData);

то же самое может быть реализовано с помощью DynamicMethods.

кроме того, классы не должны наследоваться от того же интерфейса или базового класса.

Спасибо, Виталий

одна стратегия, которую я использую в таких случаях, заключается в том, чтобы помечать мои различные реализации специальным атрибутом, чтобы указать его ключ, и сканировать активные сборки для типов с этим ключом:

[AttributeUsage(AttributeTargets.Class)]
public class OperationAttribute : System.Attribute
{ 
    public OperationAttribute(string opKey)
    {
        _opKey = opKey;
    }

    private string _opKey;
    public string OpKey {get {return _opKey;}}
}

[Operation("Standard deviation")]
public class StandardDeviation : IOperation
{
    public void Initialize(object originalData)
    {
        //...
    }
}

public interface IOperation
{
    void Initialize(object originalData);
}

public class OperationFactory
{
    static OperationFactory()
    {
        _opTypesByKey = 
            (from a in AppDomain.CurrentDomain.GetAssemblies()
             from t in a.GetTypes()
             let att = t.GetCustomAttributes(typeof(OperationAttribute), false).FirstOrDefault()
             where att != null
             select new { ((OperationAttribute)att).OpKey, t})
             .ToDictionary(e => e.OpKey, e => e.t);
    }
    private static IDictionary<string, Type> _opTypesByKey;
    public IOperation GetOperation(string opKey, object originalData)
    {
        var op = (IOperation)Activator.CreateInstance(_opTypesByKey[opKey]);
        op.Initialize(originalData);
        return op;
    }
}

таким образом, просто создав новый класс с новой ключевой строкой, вы можете автоматически "подключаться" к фабрике, не изменяя заводской код вообще.

вы также заметите, что вместо того, чтобы зависеть от каждой реализации, чтобы обеспечить определенный конструктор, я создал метод инициализации на интерфейсе, который я ожидаю, что классы будут реализованы. Пока они реализуют интерфейс, я смогу отправить им "originalData" без каких-либо странностей отражения.

Я бы также предложил использовать структуру инъекции зависимостей, такую как Ninject, вместо использования активатора.Метод createinstance. Таким образом, ваши реализации операций могут использовать инъекцию конструктора для своих различных зависимостей.

по сути, это звучит как шаблон фабрика. В этом случае вы определяете сопоставление входных и выходных типов, а затем создаете экземпляр типа во время выполнения, как вы делаете.

пример:

у вас есть X количество классов, и все они имеют общий интерфейс IDoSomething.

public interface IDoSomething
{
     void DoSomething();
}

public class Foo : IDoSomething
{
    public void DoSomething()
    {
         // Does Something specific to Foo
    }
}

public class Bar : IDoSomething
{
    public void DoSomething()
    {
        // Does something specific to Bar
    }
}

public class MyClassFactory
{
     private static Dictionary<string, Type> _mapping = new Dictionary<string, Type>();

     static MyClassFactory()
     {
          _mapping.Add("Foo", typeof(Foo));
          _mapping.Add("Bar", typeof(Bar));
     }

     public static void AddMapping(string query, Type concreteType)
     {
          // Omitting key checking code, etc. Basically, you can register new types at runtime as well.
          _mapping.Add(query, concreteType);
     }

     public IDoSomething GetMySomething(string desiredThing)
     {
          if(!_mapping.ContainsKey(desiredThing))
              throw new ApplicationException("No mapping is defined for: " + desiredThing);

          return Activator.CreateInstance(_mapping[desiredThing]) as IDoSomething;
     }
}

1. здесь нет проверки ошибок. Вы абсолютно уверены, что _class разрешится в допустимый класс? Вы контролируете все возможные значения или эта строка каким-то образом заполняется конечным пользователем?
2. отражение, как правило, наиболее дорогостоящим, чем избежать его. Проблемы с производительностью пропорциональны количеству объектов, которые вы планируете создать таким образом.
3. перед тем, как запустить и использовать фреймворк инъекции зависимостей, прочитайте его критику. =)