Warum wird diese generische Methode benötigen, T um einen öffentlichen, parameterlosen Konstruktor?

public void Getrecords(ref IList iList,T dataItem) 
{ 
  iList = Populate.GetList<dataItem>() //GetListis defined as GetList<T>
}

dataItem kann sein meine um Objekt-oder Benutzer-Objekt, das entscheidet zur Laufzeit.Die oben nicht funktioniert, wie es gibt mir diese Fehlermeldung
Der Typ 'T' muss einen öffentlichen parameterlosen Konstruktor, um es zu verwenden als parameter " T " in der generischen Typ

Sie Frage ist sehr vage und schwer zu verstehen..., was wollen Sie tun?
formatiert meine Frage
Warum ist dieser Kerl immer abgestimmt ist, die einfach nur eine Frage?
Können Sie näher erläutern, was dataItem nicht hier? Es kann nicht verwendet werden, weil der generische Typ argument (T, kann). Also was bringt es?
Re die Antwort (auf mein post) - also nicht einem der beiden Szenarien, die ich geschrieben helfen?

InformationsquelleAutor | 2008-10-30

c#generics

6
```
public void GetRecords<T>(ref IList<T> iList, T dataitem)
{
}
```
Was suchst du?

Überarbeitete Frage:
```
 iList = Populate.GetList<dataItem>() 
```
"dataitem" ist eine variable. Sie möchten einen Typ da:
```
 iList = Populate.GetList<T>() 
```
Den Typ 'T' muss eine öffentliche
parameterlosen Konstruktor, um zu
verwenden Sie es als parameter " T " in der generischen
geben Sie GetList:new()

Dies ist zu sagen, dass, wenn Sie definiert Auffüllen.GetList(), Sie erklärt es so:
```
IList<T> GetList<T>() where T: new() 
{...}
```
Sagt der compiler, dass GetList kann nur Typen verwendet werden, die einen öffentlichen parameterlosen Konstruktor. Verwenden Sie T zum erstellen eines GetList-Methode GetRecords (T bezieht sich auf verschiedene Typen hier), haben Sie die gleiche Einschränkung auf ihn:
```
public void GetRecords<T>(ref IList<T> iList, T dataitem) where T: new() 
{
   iList = Populate.GetList<T>();
}
```
- Dank James für detaillierte Informationen
InformationsquelleAutor James Curran
4

Ihre überarbeitete Frage geht in dataItem-Objekt als ein Objekt des Typs T und versucht dann, es zu benutzen, als eine Art argument zu GetList(). Vielleicht passieren Sie dataItem in nur als ein Weg zu geben Sie T?

Wenn ja, möchten Sie vielleicht so etwas wie:
```
public IList<T> GetRecords<T>() {
  return Populate.GetList<T>();
}
```
Dann nennt man das etwa so:
```
IList<int> result = GetRecords<int>();
```
- Ich habe versucht, und ich bekomme Den Typ 'T' muss einen öffentlichen parameterlosen Konstruktor, um es zu verwenden als parameter " T " in der generischen Typ GetList<T>:new()
- Wenn Sie brauchen, um in der Lage sein, um eine neue zu erstellen, geben Sie T: Objekt
- Oder nutzen Sie die Standardeinstellung(T) um eine neue Instanz erstellen, wie gut.
- where T : new() ist das, was der compiler will
- Ich dachte, das war es, was er wollte, für eine Weile zu, und dann merkte ich, dass er wahrscheinlich schon ein Objekt eines Typs, die will er verwenden, um zu bestimmen, die Art-parameter für die Methode. Auch so, noch ist dies wohl der richtige Weg zu gehen. Verwenden Sie einfach MyDataItem.GetType() für den Typ-parameter.
- Hmm... außer man kann das nicht tun.
- meines Wissens nach c# generics ausgeführt werden, da ein compiler-trick, um zu erreichen das die statische Typisierung. Wenn jon b wirklich braucht run-time-generic eingeben, vielleicht ist das DLR helfen.
- ja, Sie können; über MakeGenericMethod (siehe pots)
- Nein, Generika sind ein Kernbestandteil der CLR-v2; der compiler keinen echten tricks hier; in der Tat, generics in C# Folgen statische typregeln (alles in C# < 4.0 ist statisch typisiert)
InformationsquelleAutor David Alpert
3

Das Problem mit fordern einen öffentlichen, parameterlosen Konstruktor kann nur werden, weil Bevölkern.GetList es verlangt - d.h. "T : new ()" - Einschränkung. Um dies zu beheben, fügen Sie einfach die gleiche Einschränkung Ihrer Methode.

Tatsächlich, ich bezweifle, dass ref ist eine gute Strategie hier. Bei einem Stoß out tun könnten (da Sie nicht gelesen den Wert), aber eine viel einfachere (und mehr erwartet) - option Rückgabewert:
```
public IList<T> GetRecords<T>(T dataItem) where T : new()
{  //MG: what does dataItem do here???
  return Populate.GetList<T>();
}
```
Natürlich, an diesem Punkt, der Anrufer könnte genauso gut einfach anrufen Populate.GetList direkt!

Ich vermute, Sie können entfernen dataItem zu... aber es ist nicht ganz klar aus der Frage.

Wenn Sie nicht beabsichtigen, es zu werden generische (und dataItem ist das template-Objekt), dann können Sie dies über MakeGenericMethod:
```
public static IList GetRecords(object dataItem) 
{
    Type type = dataItem.GetType();
    return (IList) typeof(Populate).GetMethod("GetList")
        .MakeGenericMethod(type).Invoke(null,null);
}
```
- MG: Wenn ich ein order-Objekt dann in der Liste werden die Sammlung um Objekte und es hilft mir zu vermeiden, Baue meine eigene typisierte collection erbt von collection-base und Schleifen durch ein dataset und den Aufbau der Sammlung, so kann ich durch die übergabe des custom collection um anstelle eines dataset -
InformationsquelleAutor Marc Gravell
-1

Können Sie Generisch mit < T > wird akzeptieren, dass die Art in der runtime, wie Sie wollen.

InformationsquelleAutor Patrick Desjardins
-1
```
Getrecords<T> ...
```
Diese sollte keine weitere detaillierte Informationen, die Sie benötigen.
http://msdn.microsoft.com/en-us/library/twcad0zb(VS.80).aspx

InformationsquelleAutor Ryan Lanciaux

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.