C# Define base-Klasse von <T>

Ich versuche einen Weg zu finden, leiten Sie eine Klasse von einer generischen Basisklasse. Sagen:

sealed public class Final : Base<Something>
{

}

public class Base<T> : T
    where T : Anything //<-- Generics do not allow this
{

}

In C# scheint dies nicht möglich zu sein.

Gibt es eine andere Lösung, die etwas erreichen ähnlich wie diese?

Fand ich diese StackOverflow-Frage, aber es scheint nicht, um das Problem zu lösen, oder zumindest ich verstehe nicht, wie es sollte.

EDIT:

Dem Ergebnis würde ich mag, um in der Lage zu sein, etwas zu tun:

Anything[] anything;
//Assign some Instances to anything 

foreach(Final final in anything){
     //do something with final
}
möglich, Duplikat der Vererbung auf eine eingeschränkte generischen Typ-parameter
Wenn Sie es verwenden möchten, in einem foreach Sie implementieren müssen, um IEnumerable<Final>.
In meinem edit oben, "alles" ist ein array. So brauche ich nicht zu tun.
nur ein MoveNext und Current Methode genügen würde, keine Notwendigkeit zur Umsetzung der gesamten IEnumerable - Schnittstelle.
Was Sie tun möchten, ist das nicht logisch Klang und funktioniert nicht. Können Sie nicht ableiten, die von einem Typ-argument, wenn es die Werte zur Laufzeit. Wie würden Sie wissen, welche Methoden Sie können zum Beispiel überschreiben? Ich glaube, Sie brauchen, um zu überdenken Sie Ihre design, so dass Sie die Ableitung von was auch immer geben T ist, und verwenden Sie dann die DerivedT beim instanziieren Base anstatt zu versuchen, eine Ableitung von T im Base<T>. Macht das Sinn?

InformationsquelleAutor Noel Widmer | 2015-05-04

  1. 7

    Dem Ergebnis würde ich mag, um in der Lage zu sein, etwas zu tun:

     Anything[] anything;
 //Assign some Instances to anything 

 foreach(Final final in anything){
     //do something with final
 }

    Ihre foreach loop-deutet dies: class Anything : Final { … }.

    Diese offensichtlich dreht sich um die Vererbungshierarchie, wie Sie geplant und benannt. (Sie können die Zyklen in Ihre vererbungsbeziehungen).

    public class Base<T> : T where T : Anything { …

    Lassen Sie mich näher auf das Teil ein bisschen. Ich werde reduzieren Sie Ihre Beispiel sogar noch weiter auf nur class Base<T> : T.

    Dies ist nicht möglich, mit gutem Grund. Stellen Sie sich vor:

    class Base<T> : T
{
    public override string Frobble()
    {
        Fiddle();
        return "*" + base.Frobble() + "*";
    }
}

class A
{
    public sealed string Frobble() { … }
}

class B
{
}

class C
{
    public virtual string Frobble() { … }
}

abstract class D
{
    public abstract void Fiddle();
    public virtual string Frobble() { … }
}

class E
{
    public void Fiddle() { … }
    public virtual string Frobble() { … }
}

    Bekommen Sie auch alle Arten von absurden Situationen, wenn class Base<T> : T durften.

    • Base<A> wäre absurd, weil Frobble nicht in einer abgeleiteten Klasse überschrieben.
    • Base<B> wäre absurd, denn man kann nicht eine Methode überschreiben,
      existiert nicht in der base-Klasse.
    • Base<C> funktioniert nicht, weil es keine Fiddle Methode zu nennen.
    • Base<D> würde nicht funktionieren, weil Sie nicht Aufruf einer abstrakten Methode.
    • Nur Base<E> funktionieren würde.

    Wie würde der compiler überhaupt weiß, wie man richtig kompilieren Base<T> und analysieren code, die davon abhängt?

    Der Punkt ist, dass man nicht eine Ableitung von einer Klasse ist nicht bekannt, dass zur compile-Zeit. T ist ein parameter, D. H. eine variable, ein Platzhalter. So class Base<T> : T ist im Grunde wie zu sagen, "Base<T> erbt von einigen (unbekannten) Klasse". Vererbung ist eine Art Beziehung, die erfordert, dass beide beteiligten Arten bekannt werden zur compile-Zeit. (Eigentlich ist das nicht eine super-präzise Aussage, weil Sie Erben von einer generischen Typ-wie class SpecialList<T> : List<T>. Zumindest aber die, die abgeleitete Klasse hat, um zu wissen, was die Mitglieder (Methoden, Eigenschaften, etc.) verfügbar sind in der base-Klasse.)

    InformationsquelleAutor stakx

  2. 1

    Ist das, was Sie wollen?

    sealed public class Final : Base<int>{

}

public class Base<T> {

}
    Base<T> sollte nun die Ableitung von <T>, das ist in diesem Fall int
    Das heißt generische constraints wenn Sie den Zustand zu beschränken, die Art T.

    InformationsquelleAutor Robert McKee

  3. 0

    Könnten Sie dies nur tun, wenn Final wäre eine generische Klasse als gut, etwa so:

    public sealed class Final<T> : Base<T>

    Dann können Sie eine Art Zurückhaltung auf T entweder als ein class zu ermöglichen, nur Referenz-Typen als T werden, oder eine Instanz von Base<T> zu ermöglichen, sich nur Typen, die sich aus Base<T>:

    public class Base<T> where T : Base<T>

    InformationsquelleAutor aevitas

Schreibe einen Kommentar