Wie diese generische Vererbung gemacht wird (intern)?

Question

Wie finden Sie den folgenden Code? Ist das gut? Wenn ja, warum ist es? Wenn nicht, warum nicht? Und wie sieht CLR diesen Code?

public abstract class EntityBase<TEntity> : IEquatable<TEntity> 
{   
    public bool Equals(TEntity other) 
    { 
     // check equalitiy 
    } 

    // yes, below is object's Equals and GetHashCode method implementation 
} 

public class Person : EntityBase<Person> 
{ 
} 

Ich habe ein bisschen seltsames Gefühl auf diesem. Wie Huhn und Ei Problem. Und hier ist .Net-Framework-Code, der das gleiche Verhalten hat.

public sealed class String : IComparable<string>, IEquatable<string> // I removed other interfaces 

Irgendwelche Gedanken?

Answer 1

Für andere Leute Referenz, kopierte ich die Antwort Eric Lippert (wer im Kommentar antworten).

Obwohl die Definition zirkulär erscheint, ist es nicht. Der C# Compiler Zyklus Erkennungsalgorithmus ist jedoch sowohl falsch als auch schwach. Falsch, weil nicht-Zyklen als Zyklen falsch erkannt und schwach ist, weil es bestimmte sehr unangenehme Zyklen erkennt. Wenn dieses Thema interessiert, finden Sie in meinem Artikel über sie hier: http://blogs.msdn.com/ericlippert/archive/2008/05/07/covariance-and-contravariance-part-twelve-to-infinity-but-not-beyond.aspx

Answer 2

Unter den richtigen Umständen (z. B. Implementierung IComparable<T>) ist es genau das Richtige zu tun.

Aber das kann nur von Fall zu Fall bestimmt werden, indem man die Details betrachtet, warum es in Betracht gezogen wird.

Auf der anderen Seite erlaubt C++ das „seltsam wiederkehrende Grundmuster“:

template<typename T> 
class SomeWrapper<T> : T { ... ] 

wo eine generische Klasse seine generische Wrapper erbt. Dies ermöglicht einige erweiterte Umhüllungsszenarien, kann jedoch schnell unübersichtlich werden, wenn sie über den Umbruch hinaus verwendet werden. Zum Glück (?) Ist dieses Muster in .NET nicht erlaubt.

Answer 3

Ich sehe kein Problem mit Ihrem Code. Warum sollte es ein Problem sein?

Über die interne Darstellung kompiliert der dotNet JIT eine Klasse für jede generische Version. Also folgende:

class Foo<T> { public T Property; } 
Foo<Int> fooint; 
Foo<String> foostring; 

ist eine Art zusammengestellt in:

class FooInt { public Int Property; } 
class FooString { public String Property; } 
FooInt fooint; 
FooString foostring; 
// This is kept for if it is needed later. 
// For example for generic casting, a C#4 feature. 
class Foo<T> { public T Property; } 

Answer 4

nicht wirklich eine Antwort, aber ich fand es irgendwie Sinn machen, nachdem ich diesen seltsamen Code geschrieben ...

class Program 
{ 
    static void Main(string[] args) 
    { 
     var wife = new Human(Gender.Female); 
     var baby = wife.GiveBirth(); 
     Console.WriteLine(baby.Gender); 

     Console.ReadKey(); 
    } 
} 

class CanGiveBirthTo<T> where T : new() 
{ 
    public CanGiveBirthTo() 
    { 
    } 

    public T GiveBirth() 
    { 
     return new T(); 
    } 
} 

class Human : CanGiveBirthTo<Human> 
{ 
    public Gender Gender { get; private set; } 

    public Human(Gender gender) 
    { 
     Gender = gender; 
    } 

    public Human() 
    { 
     Gender = RandomlyAssignAGender(); 
    } 

    Gender RandomlyAssignAGender() 
    { 
     var rand = new Random(); 
     return (Gender) rand.Next(2); 
    } 
} 

enum Gender 
{ 
    Male = 0, 
    Female = 1 
}