C # Utilisant L'Activateur.Créatéinstance

je vous suggère de donner à votre mise en œuvre d'usine une méthode RegisterImplementation . Donc chaque nouvelle classe n'est qu'un appel à cette méthode et vous ne changerez pas votre code d'usine.

mise à jour:

Ce que je veux dire, c'est quelque chose comme ceci:

Créer une interface qui définit un calcul. Selon votre code, vous l'avez déjà fait. Par souci d'être complet, je vais utiliser l'interface suivante dans le reste de ma réponse:

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

votre usine ressemblera à quelque chose comme ceci:

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

cette classe d'usine simple manque de vérification d'erreur pour la raison de la simplicité.

mise à JOUR 2:

Vous l'initialiseriez comme ceci quelque part dans votre routine d'initialisation des applications:

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

comme exemple comment ajouter l'initialisation dans le constructeur:

quelque chose de similaire à:

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

mais écrit avec L'Expression Linq, une partie du code est prise ici :

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

l'usage est le suivant:

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

la même chose peut être implémentée avec des méthodes dynamiques.

en outre, les classes ne sont pas tenus d'être héritées de la même interface ou de la même base classe.

Merci, Vitaliy

une stratégie que j'utilise dans des cas comme celui-ci est de signaler mes différentes implémentations avec un attribut spécial pour indiquer sa clé, et de scanner les assemblages actifs pour les types avec cette clé:

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

de cette façon, juste en créant une nouvelle classe avec une nouvelle chaîne de touches, vous pouvez automatiquement" brancher " à l'usine, sans avoir à modifier le code d'usine du tout.

vous noterez également que plutôt que de dépendre de chaque mise en œuvre à fournir un constructeur spécifique, j'ai créé une méthode D'initialisation sur l'interface que je m'attends à ce que les classes implémentent. Tant qu'ils mettent en place l'interface, je pourrai leur envoyer la "originalData" sans aucune bizarrerie de réflexion.

je suggère aussi d'utiliser un framework d'injection de dépendances comme Ninject au lieu d'utiliser L'activateur.CreateInstance. De cette façon, vos implémentations d'opération peuvent utiliser l'injection du constructeur pour leurs différentes dépendances.

Essentiellement, il semble que vous voulez le modèle de fabrique. Dans cette situation, vous définissez un mappage des entrées vers les types de sortie et instanciez le type à l'exécution comme vous le faites.

exemple:

vous avez X nombre de classes, et ils partagent tous une interface commune D'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. il n'y a pas d'erreur ici. Êtes-vous absolument sûr que _class se résoudra à une classe valide? Est-ce que vous contrôlez toutes les valeurs possibles ou est-ce que cette chaîne est en quelque sorte générée par un utilisateur final?
2. la réflexion est généralement plus coûteuse que son évitement. Les problèmes de performances sont proportionnelles au nombre d'objets que vous envisagez d'instancier cette façon.
3. avant de vous enfuir et d'utiliser un framework d'injection de dépendances lire les critiques. = )