C# - Generische Methode, kann nicht implizit konvertiert

Habe ich den folgenden code:

public static T GetCar<T>() where T : ICar
{
    T objCar = default(T);

    if (typeof(T) == typeof(SmallCar)) {
        objCar = new SmallCar("");
    } else if (typeof(T) == typeof(MediumCar)) {
        objCar = new MediumCar("");
    } else if (typeof(T) == typeof(BigCar)) {
        objCar = new BigCar("");
    }

    return objCar;
}

- Und das ist der Fehler den ich erhalte: Cannot implicitly convert type 'Test.Cars' to 'T'

Was vermisse ich hier? Alle Auto-Typen implementieren das ICar-Schnittstelle.

Dank

Es wird leichter sein, zu helfen, wenn Sie nach der Prüfung.PKW-code zusammen Nutzung in Frage.
mögliche Duplikate von implict Typumwandlung in generische Methode

InformationsquelleAutor MeTitus | 2012-04-07

c#generics methods

9

Können Sie nicht konvertieren T aufgrund der Tatsache, dass T nicht zur Kompilierzeit bekannt ist.
Wenn Sie möchten, um Ihren code zu arbeiten, können Sie ändern Sie den Rückgabetyp zu ICar und entfernen Sie die generische T zurück geben.

Kann man auch werfen, um T. Dies würde auch funktionieren.
Wenn Sie nur mit dem Standard-Konstruktor können Sie auch constain auf new() und verwenden new T() um Ihren code zu arbeiten.

Proben
```
public ICar GetCar<T>()
    where T : ICar
{
    ICar objCar = null;

    if (typeof(T) == typeof(SmallCar)) {
        objCar = new SmallCar();
    } else if (typeof(T) == typeof(MediumCar)) {
        objCar = new MediumCar();
    } else if (typeof(T) == typeof(BigCar)) {
        objCar = new BigCar();
    }

    return objCar;
}
```
Darsteller:
```
public T GetCar<T>()
    where T : ICar
{
    Object objCar = null;

    if (typeof(T) == typeof(SmallCar)) {
        objCar = new SmallCar();
    } else if (typeof(T) == typeof(MediumCar)) {
        objCar = new MediumCar();
    } else if (typeof(T) == typeof(BigCar)) {
        objCar = new BigCar();
    }

    return (T)objCar;
}
```
New-Einschränkung:
```
public T GetCar<T>()
    where T : ICar, new()
{
    return new T();
}
```
- Deine 2. Lösung. Danke.
- Froh, dass ich helfen konnte.
- Ich bin mal gespannt. In Ihrem 3. Beispiel mit der neuen Einschränkung, wie es funktionieren würde mit seinem Beispiel von der Rückkehr der verschiedenen Klassen. Das ist klar, in deinem 2. Beispiel, aber wie würden Sie es anstellen, mit dem 3.?
- ist in diesem Fall die Klasse haben Sie gewählt, zum Beispiel SmallCar. Die Einschränkung sagt dem compiler, dass jeder Typ in der Methode als generische parameter muss einen parameterlosen Konstruktor ( new constraint ) und implementieren müssen, die Art ICar. Die Methode Körper jetzt erstellt eine neue Instanz von T und kümmert sich nicht welche Art es tatsächlich ist. Aber diese Methode ist irgendwie begrenzt, da es noch nicht möglich zu definieren, die möglichen Parameter für die Methode. Wenn Sie möchten, übergeben Sie Parameter, die Sie verwenden können, die Activator Klasse.
- Ich möchte nur erwähnen, dass Sie fehlen die Klammern für die new() contraint: msdn.microsoft.com/en-us/library/sd2w2ew5.aspx
- Danke.
InformationsquelleAutor Felix K.
7

Dein code ist illegal, weil, während Sie möglicherweise testen und wissen, dass Ihre T ist BigCar oder einige andere solche Typ, der compiler kann nicht wissen, dass es im Voraus und somit der code ist illegal. Basierend auf Ihrer Nutzung gegeben haben, könnte
```
public static T GetCar<T>() where T : ICar, new()
{
    return new T();
}
```
Den new() Einschränkung ermöglicht das aufrufen des Standard - (parameterlosen) Konstruktor für ein Typ ist.
- Aber ich will nicht zum aufrufen der default-Konstruktor für den angegebenen Typ. In dem Beispiel habe ich einen parameterlosen Konstruktor für die Typen, aber das ist nicht der Fall.Danke für Sie Hilfe.
- in diesem Fall rufen Sie eine factory-Methode, aber was auch immer es ist, das aussetzen einer parameterlosen Konstruktor ist weniger schädlich als die if-else-Typ-überprüfung, die Sie tun (vor allem im inneren eine generische Methode).
InformationsquelleAutor Anthony Pegram

Können Sie den code vereinfachen

public static T GetCar<T>()
    where T : ICar, new()
{
    return new T();
}

InformationsquelleAutor Olivier Jacot-Descombes

Generika ist ein run-time-Konzept. Informationen zu den verwendeten Typen in einer generischen Datentyp-unabhängig davon, ob es sich um ein Wert-oder Referenz-Typ erhalten werden können, die zur Laufzeit über Reflexion.

Wenn ein code mit T ist zusammengestellt in MSIL es nur identifiziert es als eine Art parameter. Deshalb generischen Typ-parameter T nicht bekannt ist zur compile-Zeit.

class Program
{
    static void Main(string[] args)
    {
        ICar smallCar = Helper.GetCar<SmallCar>("car 1");
        ICar mediumCar = Helper.GetCar<MediumCar>("car 2");

        Console.ReadLine();
    }
}

static class Helper
{
    public static T GetCar<T>(string carName) where T : ICar
    {
        ICar objCar = default(T);

        if (typeof(T) == typeof(SmallCar))
        {
            objCar = new SmallCar { CarName = carName };
        }
        else if (typeof(T) == typeof(MediumCar))
        {
            objCar = new MediumCar { CarName = carName };
        }

        return (T)objCar;
    }

}

interface ICar
{
    string CarName { get; set; }
}

class SmallCar : ICar
{
    public string CarName { get; set ; }
}

class MediumCar : ICar
{
    public string CarName { get; set; }
}

InformationsquelleAutor Nipuna

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.

Proben