Passer des informations à un constructeur sans utiliser de paramètre en C#

Question

Je me suis reculé dans un coin. Voici une version simplifiée de ce que j'ai (en C#):

class OuterClass 
{ 
    private class BadClass 
    { 
     private int Data; 

     public BadClass() 
     { 
      Data = 0; 

      ... 
     } 
    } 

    T Build<T>(Object Input) 
    { 
     T x = new T(); 
     ... 
     return x; 
    } 

    void SomeMethod() 
    { 
     BadClass a = Build<BadClass>(anObject); 
     ... 
    } 
    ... 
} 

Le problème que j'ai est que je dois maintenant changer la valeur initiale des données en fonction de l'instance de OuterClass qui crée l'instance BadClass. Normalement, je voudrais simplement utiliser un constructeur BadClass qui prend un paramètre:

public BadClass(int Data) 
{ 
    this.Data = Data; 
    ... 
} 

Mais j'utiliser BadClass dans plusieurs types génériques, donc je dois avoir un constructeur BadClass parameterless. Dommage que je ne peux pas faire quelque chose comme ceci:

Build<BadClass(5)>(anObject); 

Alors, comment puis-je donner un constructeur d'informations d'exécution lorsque je ne peux pas passer des paramètres dans le constructeur?
Est-il possible de créer une instance d'exécution d'un type BadClass, de lui donner les informations dont il a besoin, puis de l'utiliser dans mes types génériques?

EDIT: je liste comme un exemple type générique, mais qui n'a pas exprimer pleinement la profondeur de mon dilemme ...
Je peux créer un test Build pour appeler une fonction init si je travaille avec une BadClass, mais c'est très hacky. J'espère trouver une façon un peu moins laide de s'y prendre. Lorsque vous créez le List<BadClass>, vous ne créez aucune instance BadClass.

Answer 1

Si vous avez besoin d'avoir plusieurs types de BadClass qui sont des variations de génériques, vous pouvez le faire en changeant votre arbre d'héritage:

class OuterClass { 
    private class BadClassBase { 
     // whatever BadClass does 
    } 
    private class BadClass : BadClassBase { 
     public BadClass(T item) { 
      ... 
     } 
    } 
} 

Vous ne savez pas si c'est ce que vous cherchez mais vous pouvez ensuite créer votre Liste <BadClassBase>.

Answer 2

Allez-y et créez un de cette façon, mais lorsque vous créez une instance BadClass à ajouter, c'est lorsque vous appelez votre constructeur paramétrées:

List<BadClass> a = new List<BadClass>(); 
a.Add(new BadClass(1)); 
a.Add(new BadClass(2)); 

Par ailleurs, ayant la construction d'une instance BadClass dépendent des OuterClass est en train de créer c'est un peu d'une odeur de code. Qu'est-ce que vous essayez d'accomplir?

Answer 3

Pouvez-vous donner à BadClass une méthode d'initialisation?

private class BadClass 
{ 
    private int Data; 

    public BadClass() 
    { 
     Data = 0; 
     ... 
    } 

    public void Init(int dataValue) 
    { 
     Data = dataValue; 
    } 
} 

Ensuite, lorsque vous créez un il est:

BadClass myInst = new BadClass(); // void constructor, as you require. 
myInst.Init(5); // Set the value to 5. 

Answer 4

Que diriez-vous de faire quelque chose comme ça?

using System.Collections.Generic; 

class OuterClass 
{ 
    private class BadClass 
    { 
     private int _data; 

     public BadClass() 
     { 
      _data = 0; 

     } 

     public int Data 
     { 
      get 
      { 
      return _data; 
      } 
      set 
      { 
      _data = value; 
      } 
     } 

    } 

    void SomeMethod() 
    { 
     List<BadClass> a = new List<BadClass>() 
     { 
      new BadClass() { Data = 7 }, 
      new BadClass() { Data = 9 } 
     }; 
    } 
}