Mit Hilfe von Generischen Containern in Delphi XE - immer?

Generische Container kann eine Zeitersparnis, wenn Sie ein Element, und eine stark typisierte Liste dieser Elemente. Es erspart die wiederholte Programmierung erstellen Sie eine neue Klasse mit vielleicht einer TList internen Variablen und typisierte Hinzufügen/Löschen, geben Sie Methoden, unter anderen Vorteile (wie die neue Funktionalität zur Verfügung gestellt durch die Generische container-Klassen.)

Jedoch ist es empfohlen, immer die Verwendung generischer Container für stark typisierte Listen der Zukunft an? Was sind die spezifischen Nachteile, dies zu tun? (Wenn Sie nicht besorgt über die Abwärtskompatibilität von code.) Ich war das schreiben einer server-Anwendung gestern und hatte eine Liste der Gegenstände, die ich erstellt 'der alte Weg' und ging, um es zu ersetzen mit einer generischen Liste, aber beschlossen, es zu halten, lean, aber meistens aus Gewohnheit. (Sollten wir diese Gewohnheit abzulegen und eine neue zu beginnen, indem Sie immer mit generics?)

  • Aus den eingegangen Antworten wurde dies ist ein Beispiel, warum StackOverflow ist so gut!
InformationsquelleAutor Darian Miller | 2011-03-15
  1. 12

    In Delphi XE, gibt es keinen Grund für die Verwendung generischer Container.

    Wechsel von der alten Methode mit dem Gießen geben Sie:

    • cleaner, type-safe, weniger fehleranfälligen code,
    • Enumeratoren für in Schleifen,
    • die gleichenbessere Fahreigenschaften.
    • Nicht die gleichen Leistungsmerkmale, bessere Leistung, da Sie nicht mehr die dummy-getter, behebt den Typ für die Rückkehr. Und die Enumeratoren wurden die "killer" für mich. Es genügt zu sagen, dass ich jetzt haben viele Klassen, die so Aussehen TSomethingList = class(TObjectList<TSomething>): Diejenigen Klassen, die früher existierten als hand-schriftliche Nachkommen von TObjectList aber wandte sich nun in Generika Behälter, so dass ich verwenden können, die for in Schleife.
    • Ich bin mir nicht sicher, dass die durchschnittlichen performance-Verbesserung ist real. Getter sind nicht so zeitaufwendig, und es ist immer besser für die Verwendung einer lokalen Variablen zum Zugriff auf mehrere Eigenschaften, um eine indizierte Element in einer Schleife, z.B. in der Erwägung, dass alle duplizierten code generiert durch Generika (siehe Mason Antwort) könnte das Programm langsamer: der CPU-cache wird gefüllt mit all diesem unnötigen code.
    • Ich bin damit einverstanden, dass generische Container können die Leistung steigern, weil die Delphi-Versionen, die Unterstützung Generika haben TDictionary das ist wahrscheinlich der Schnellste container können Sie erhalten, wenn Sie brauchen, um zu finden, ein Element in eine Liste von Schlüssel-Wert.
    • könnten Sie TDictionary wie Funktion ohne die Generika, auch mit "alten" Delphi-Versionen - siehe synopse.info/forum/viewtopic.php?pid=1610#p1610
    • Interessantes Beispiel, aber mit generics ist es viel einfacher und sauberer IMO. Und Ihr dynamisches array benutzt binäre Suche (wenn ich richtig untersucht), die langsamer ist als die Wörterbuch-Suche.
    • Generika sind nicht viel Verwendung in einer älteren Delphi-version. Ich bin sicher, wenn XE war das nur Delphi in der Existenz, @A. Bouchez würde immer mit einem TDictionary, anstatt den code, den er auf die verlinkt wird.
    • Das ist wahr. XE erheblich verbessert, wenn der Umgang mit Generika. Aber das ist ein anderes Thema.
    • +1 Danke Jungs! Ich werde markieren Sie diese als Antwort, aber war nicht wirklich überzeugt sicher...dann lese ich Deltics Antwort.
    • Über die Geschwindigkeit, du hast Recht, von der mathematischen POV. TDictionary verwendet einen klassischen Ansatz der Vermischung + modulo für die Suche. Die hash-Fenster wird immer eine Potenz von zwei. Abhängig von der hash-Funktion verwendet (die Standard-hash für ein Objekt zurückgegeben, dessen Speicher-Adresse, so ist es weit weit Weg von einer perfekten hash), seine Geschwindigkeit kann variieren. Es ist nie wirklich O(1) aber, wird es schneller als O(n) binäre Suche in den meisten Fällen. Mit das ausgeben von größeren Arbeitsspeicher verwenden. Und wenn die hash-Funktion ist die Standard-Einstellung (D. H. seine memory-Adresse), haben Sie eine Menge von Kollisionen IMHO. So könnte es langsamer sein.
    • die Falle in Ihre akzeptierte Antwort ist eigentlich eine Einschränkung in der Antwort der Autors wissen. Es ist nicht ein echtes problem. Tut mir Leid, dass Sie verführt worden sind von diesem argument.
    • Beachten Sie, dass es nicht nur Deltics Beispiel, Mason hatte einen Artikel verlinkt in seinem Kommentar. Ich versuche, Generika in neue Entwicklung, aber in den original-post habe ich erwähnt, die gerade geschrieben code mit der standard-tlist und typsichere Methoden Hinzugefügt und ich hatte den Wunsch, einfach nur zu ersetzen Sie alle eine generische Liste..das Tat ich mit einigen Einheiten, aber hab dann zu Fragen, welche Art von ärger könnte ich erstellen. Geht nach vorn, ich werde aufhören, mit meinem handy-dandy-IDE-tool, das generiert type-safe "TList" - code in ein paar Tastenanschläge.
    • Ein weiterer Nagel zu den generics performance Mythos Sarg: inlining deaktiviert ist, die für Generika. IMHO nicht behaupten, dass etwas schneller ist, ohne tatsächlich zu Messen (oder zumindest einen Blick in den asm-code)

    InformationsquelleAutor David Heffernan
  2. 10

    Auslöser war Deltic Antwort, ich wollte ein Gegenbeispiel beweisen, können Sie Generika für die Tierische Fütterung routine. (ie: Polymorph-Generische Liste)

    Zunächst einige hintergrund: Der Grund, warum Sie ernähren können generische Tiere mit einem generischen Basis-Liste ist Klasse, da werden Sie in der Regel diese Art von Vererbung:

    TBaseList = class
  // Some code to actually make this a list
end

TSpecificList = class(TBaseList)
  // Code that reintroduces the Add and GetItem routines to turn TSpecificList
  // into a type-safe list of a different type, compatible with the TBaseList
end

    Das funktioniert nicht mit Generika, weil Sie normalerweise haben diese:

    TDogList = TList<TDog>
end

TCatList = TList<TCat>
end

    ... und das nur "gemeinsame Vorfahren" für beide Listen ist TObject - überhaupt nicht hilfreich. Aber wir können definieren, eine neue, generische Liste Typs, der zwei-Klassen-Argumente: eine TAnimal und ein TSpecificAnimal generieren eine typsichere Liste der TSpecificAnimal kompatibel mit einem generischen Liste der TAnimal. Hier ist die grundlegende Art definition:

    TCompatibleList<T1:class;T2:class> = class(TObjectList<T1>)
private
  function GetItem(i: Integer): T2;
public
  procedure Add(A:T2);
  property Item[i:Integer]:T2 read GetItem;default;
end;

    Mithilfe dieser können wir tun:

    TAnimal = class; 
TDog = class(TAnimal); 
TCat = class(TAnimal);

TDogList = TCompatibleList<TAnimal, TDog>;
TCatList = TCompatibleList<TAnimal, TCat>;

    Diese Weise sowohl TDogList und TCatList tatsächlich Erben von TObjectList<TAnimal>, so haben wir jetzt eine polymorph-generische Liste!

    Hier ist eine komplette Konsole-Anwendung, die zeigt, dass dieses Konzept in Aktion. Und diese Klasse ist jetzt in meinem ClassLibrary für die Wiederverwendung!

    program Project23;

{$APPTYPE CONSOLE}

uses
  SysUtils, Generics.Collections;

type

  TAnimal = class
  end;

  TDog = class(TAnimal)
  end;

  TCat = class(TAnimal)
  end;

  TCompatibleList<T1:class;T2:class> = class(TObjectList<T1>)
  private
    function GetItem(i: Integer): T2;
  public
    procedure Add(A:T2);
    property Item[i:Integer]:T2 read GetItem;default;
  end;

{ TX<T1, T2> }

procedure TCompatibleList<T1, T2>.Add(A: T2);
begin
  inherited Add(T1(TObject(A)));
end;

function TCompatibleList<T1, T2>.GetItem(i: Integer): T2;
begin
  Result := T2(TObject(inherited Items[i]));
end;

procedure FeedTheAnimals(L: TObjectList<TAnimal>);
var A: TAnimal;
begin
  for A in L do
    Writeln('Feeding a ' + A.ClassName);
end;

var Dogs: TCompatibleList<TAnimal, TDog>;
    Cats: TCompatibleList<TAnimal, TCat>;
    Mixed: TObjectList<TAnimal>;

begin
  try
    // Feed some dogs
    Dogs := TCompatibleList<TAnimal, TDog>.Create;
    try
      Dogs.Add(TDog.Create);
      FeedTheAnimals(Dogs);
    finally Dogs.Free;
    end;
    // Feed some cats
    Cats := TCompatibleList<TAnimal, TCat>.Create;
    try
      Cats.Add(TCat.Create);
      FeedTheAnimals(Cats);
    finally Cats.Free;
    end;
    // Feed a mixed lot
    Mixed := TObjectList<TAnimal>.Create;
    try
      Mixed.Add(TDog.Create);
      Mixed.Add(TCat.Create);
      FeedTheAnimals(Mixed);
    finally Mixed.Free;
    end;
    Readln;
  except
    on E: Exception do
      Writeln(E.ClassName, ': ', E.Message);
  end;
end.
    • Ich habe nicht gesagt, es war unmöglich, mit Generics, sagte ich und Sie machte es ein Hindernis. Herzlichen Glückwunsch: Sie und David zwischen Sie haben sehr effektiv erwies sich gerade mein Punkt, danke! 😉 -1, denn es beantwortet nicht die Frage an alle. Es ist eine Antwort, die eine Antwort auf eine andere Antwort - es sollte ein Kommentar mit einem link zum blog oder einem anderen medium erweitert für Ihre Beobachtung/Erklärung.
    • Ich bekomme Ihren Standpunkt und respektiere Ihre Entscheidung, downvote. Nichtsdestoweniger habe ich der Umsetzung Ihrer ganzen Fütterung-routine, die Verwendung von generischen polymorphe Listen in 79 Zeilen code, ohne auch nur zu versuchen, es kurz zu halten. Und beachten Sie, dass Sie eine komplette Konsole-Anwendung, einschließlich tests. Wie können Generika sein, eine Behinderung, wenn Sie mir erlaubt, das zu tun? Und meine Entscheidung für einen anderen ", SO die Antwort" gegen Ihr Beispiel ist im Einklang mit der SO Verfahren, da Sie nicht haben kann, code in die Kommentare. Und bitte nicht halten Sie meine Entscheidung nicht, einen blog zu schreiben gegen mich!
    • Dies ist eine Ausarbeitung der ursprünglichen Frage. Völlig in Ordnung in meinem Buch.
    • Upvoting weil diesem ausgearbeiteten Beispiel-code ist sehr nützlich für mich in meiner Arbeit. Ich Schätze die Zeit genommen, und möchte zum Ausgleich der ungerechtfertigten downvote!
    • Das ist genau das, was ich suchte. Danke.
    InformationsquelleAutor Cosmin Prund
  3. 4

    Sollten wir diese Gewohnheit abzulegen und eine neue zu beginnen, indem wir immer die Verwendung von Generika?
    JA

    • +1 für konkret und prägnant die Beantwortung der genannten Frage. 🙂
    • -1 für die Beantwortung nicht den Aspekt der Frage, die Sie gefragt werden, über Nachteile. 😉
    • In gewisser Weise Robert gezeigt, einer der Nachteile.
    InformationsquelleAutor Robert Love
  4. 3

    In den meisten Fällen, ja, generische Container sind eine gute Sache. Allerdings der compiler erzeugt viel doppelten code, und leider ist der linker nicht weiß, wie Sie es noch so starker Einsatz von Generika könnten die Folge einer Aufblähung der ausführbaren Datei. Aber anders als das, Sie sind groß.

    • Häufigste Verwendung Muster nicht dazu führen, dass sehr viel aufblasen. Nichts wie das, was die neue RTTI produziert.
    • Wheeler - Es ist nur ein aufgeblähten EXE-Datei oder auch eine Abnahme in der Geschwindigkeit? Wenn es nur die EXE-Größe als ist nicht ein GROßES problem.
    InformationsquelleAutor Mason Wheeler
  5. 2

    In den Geist von Cosmin Antwort, die im wesentlichen eine Reaktion auf die Deltic ' s Antwort, hier ist, wie zu beheben Deltic code:

    type
  TAnimal = class
  end;

  TDog = class(TAnimal)
  end;

  TAnimalList<T:TAnimal> = class(TList<T>)
    procedure Feed;
  end;
  TDogList = TAnimalList<TDog>;

    Nun kann man schreiben:

    var
  Dogs: TDogList;
...
  Dogs.Feed;
    • TAnimalList<TDog> erbt von TList<TDog> und erbt TObject. Sie können nicht var L:TList<TAnimal> := TAnimalList<TDog>.Create ist das nicht eine polymorphe Liste.
    • Es löst Deltics' problem. Ich habe gesehen, Ihr polymorphe Liste. Ich war nicht versuchen zu replizieren, dass.
    • Deltic ' s Antwort war "If you need polymoprhic lists then Generics are a hindrance".
    • Aber dann ist sein Beispiel ist eigentlich am besten gelöst, indem ich den code präsentieren, glaube ich.
    • Ich nehme Deltic code als nur ein Beispiel für das scheinbare fehlen von polymorphen Verhalten in generischen Containern. Es ist ein gutes Beispiel dafür. Seine ganze Antwort ist eigentlich zusammengefasst in den ersten Satz, alles andere ist der Beispiel.
    • Eine Globale Funktion wird der Kampf um Polymorphismus. Sie Lösung, die zwar sehr klug, ist Komplex. In der Realität, mit der realen Welt Probleme, ist dies ein nicht-Thema. Ich bin ein bisschen genervt, dass die Deltics getäuscht hat Darian in dieser Weise mit dem, was ich sehe, als unbegründet Pessimismus.
    • Polymorphismus ist eine Eigenschaft der Klassenhierarchie, hat nichts zu tun mit der globalen Funktion. Polymorphe Listen sind genauso nützlich wie jede andere form von OOP Polymorphismus, und ebenso notwendig. Ihr Beispiel löst nicht das polymorphe problem. Und meine "komplizierte" code ist nur 10 Zeilen lang! Ich bin natürlich nur zählen die generische Deklaration der Klasse plus, die Umsetzung der Add und GetItem Methoden. Die Laufzeit-Komplexität ist, dass der "alte Buch" Handbuch getter Neudefinition. Mit ist es genauso einfach wie mit jedem anderen generischen container.
    • Gib mir die Reale Welt Beispiel, wo Sie müssen Ihre Lösung. Ich habe nicht einen in meinem codebase. Ich sage nicht, dass es nicht auch Fälle, wo es wichtig ist. Mein Punkt ist, dass es fühlt sich dumm zu berauben Sie sich selbst von den Vorteilen der generische Container für einen Nachteil, dass würde nie auf Sie auswirken!
    • Und ich glaube nicht, dass Deltics getäuscht Darian, ich glaube, Darian war auf der Suche für einen Grund zu halten, die er den "alten Weg", Dinge zu tun. Aber ich denke, Deltics war falsch: als bewährte, können Sie generische und polymorphe Container.
    • Sie sind wahrscheinlich Recht. Ich bin wahrscheinlich über reagieren. Immerhin sind wir alle Erwachsene Menschen und können unsere eigenen Entscheidungen.
    • du hast Recht, das ist ein problem, das vielleicht nicht viele Menschen betreffen, und Sie können sogar die polymorphe Liste mit "old school" - Techniken, wenn die Notwendigkeit überhaupt kommt, einfach durch Erben von TList<TAnimal>. In der Tat bin ich ein Buch zu Lesen auf asp.net gerade jetzt, wo der Autor sagt: polymorphism is the most talked about and least useful feature (stark umformuliert, weil ich nicht das Buch bei mir und ich bin mir auch nicht sicher, ob der Autor redete über OOP im Allgemeinen oder nur die asp.net framework). (Fortsetzung folgt...)
    • Geben Sie ein Beispiel für nützliche polymorphe Listen erfordert eine nicht-triviale Klassen-Hierarchie mit mindestens zwei Ebenen. Ich weiß sicher, dass ich verwendet, polymorphe Listen in meinem Delphi 2010-code, aber natürlich bin ich so fokussiert auf die "Lösung", die es nie in den Sinn gekommen zu schreiben, dass generische Klasse, habe ich einfach die Lösung implementiert mit "old school" - Techniken und zogen auf. Da ein Beispiel aus meinem eigenen code ist nicht hilfreich, hier ein aus ein: sagen wir, wir haben eine routine der Einnahme eine Liste von TControl-Objekte. Sagen wir, wir haben eine Liste der benutzerdefinierten TFrames, dass wir zur Laufzeit erstellt und wir brauchen, um zu verfolgen...
    • ... caling die routine, dauert (TList<TControl>) mit (TList<TMyFrame> ist nicht möglich; Doch TMyFrame erbt von TControl und die erste routine kann angewendet werden, um die Liste der frames. Hätten wir eine polymorphe Liste der TMyFrame erbt TList<TControl> wären wir in der Lage, um die routine. Tut mir Leid, wenn das klingt weit hergeholt, aber Polymorphie ist in sich selbst hoch "verbose" und setzen Sie eine andere Ebene der OOP-ish Polymorphismus oben drauf macht es nur Ausführlicher.
    • Ich sagte, es war ein Hindernis - die Tatsache, dass Sie brauchen, um zu ersinnen, die nicht-intuitive Lösungen für ein problem, das eine intuitive Lösung, ohne die Generika-macht einfach mein Punkt ist, dass Generika solche Dinge schwieriger (nicht unmöglich). -1 weil es beantwortet nicht die Frage an alle. Es ist die Antwort auf eine andere Antwort, "Fixierung" etwas nicht brauchen "fixieren", wie der "defekt" - code wurde zur Verfügung gestellt, um eine Beobachtung, nicht um einen konkreten Fall. Ihre Widerlegung der Betrachtung sollte sein, einen Kommentar mit link zum blog oder einem anderen medium erweitert für Ihre Beobachtung/Erklärung.
    • +1 Der Nachteil ist vor allem die Neuheit von Generika und die mögliche Zeitfresser zu schlagen, in einem Beispiel, wie Deltics gepostet, die sieht aus wie ich würde. (Zeit sinkt = lenkt davon ab, den Fluss der Entwicklung.) Wenn das hinzufügen von eine kurze Liste der Elemente, um eine server-Anwendung, wobei wahrscheinlich das einzige, was Sie brauchen, ist ein Add(x) Count() und vielleicht eine benutzerdefinierte Find () - routine, dann denke ich ist es am besten (für mich) zu halten mit den altbekannten, bis MEINE Codebasis auf Generika erweitert, und Sie werden weniger ein Problem. All dies ist Teil des iterativen Lern-Zyklus, obwohl, und es ist sehr viel geschätzt!
    • Ich, für einen, werden mit Cosmin Lösung, wenn ich einfach Listen von Objekten mit einem gemeinsamen Vorfahren. Ich in der Regel tun. Ich will vergessen alten Zeiten mit TStringLists als Container für Objekte!

    InformationsquelleAutor David Heffernan
  6. 1

    Sie schrieb über die rückwärts-Kompatibilität... das ist meine größte Sorge, wenn (wie ich) Sie schreiben, die Bibliotheken, die sollten besser kompilieren mit den meisten gängigen Versionen von Delphi.

    Selbst wenn Sie nur XE für ein geschlossenes Projekt, sind Sie wahrscheinlich machen einige benutzerdefinierte Bibliotheken von Ihrem eigenen, auch wenn Sie nie veröffentlichen den code. Wir alle haben solche Lieblings Einheiten bei der hand, nur nicht das Rad neu erfinden für jedes Projekt.

    In einer zukünftigen Zuordnung, die Sie haben können, weiterhin etwas älterer code, ohne die Möglichkeit, ein upgrade auf eine neuere Delphi-version (kein Geld für 1.000.000 Codezeilen, migration und Kritik). In diesem Fall, verpassen Sie Ihren XE-nur Bibliotheken mit glänzenden generic-basierte Listen...

    Aber für eine 100% "private" Anwendung, wenn Sie sicher sind, dass Sie nie haben, pflegen ältere Delphi-code, ich sehe keinen Grund, nicht zu verwenden Generika. Meine einzige Sorge ist der duplizierten code Problem (zitiert von Mason): der CPU-cache gefüllt werden kann mit unnötigen code, sodass die Ausführung Geschwindigkeit könnte darunter leiden. Aber in der realen app, ich denke, dass Sie nicht sehen, keinen Unterschied.

    Hinweis: ich habe nur Hinzugefügt, einige neue Funktionen auf meiner TDynArray wrapper. Ich habe versucht, zu imitieren,der Beispielcode von EMB docwiki. So hätte man generic-ähnliche Funktionen, mit der guten alten Delphi-Versionen... natürlich, Generika sind besser für die Arbeit mit Klassen, sondern mit einigen arrays und records, die es nur Felsen!

    • +1 ich ursprünglich angegeben nicht zu befürchten, rückwärts-Kompatibilität, aber natürlich hast du Recht... ich habe zur Unterstützung von Delphi 5 apps, Delphi 7 apps, Delphi 2006-apps, Delphi 2007-apps und Delphi XE-apps...ich bin auf einer mission, um alles zu konvertieren, um XE obwohl.
    • A. Bouchez, du bist ein "Sonderfall", weil Sie schreiben Bibliotheken auch für andere zu verwenden, ich verstehe Ihren Wunsch, rückwärts kompatibel Sprachkonstrukte. Aber gilt das nicht für den rest von uns: in Dem moment öffnen wir die Delphi (N+1) box, die wir kennen, die wir verwenden Funktionen, die nicht verfügbar in Delphi (N) - das ist, warum wir kauften Delphi (N+1)
    • Schreiben von Bibliotheken ist ein "schlimmer Fall" für rückwärts Kompatibilität, du hast Recht. Aber es gibt Unternehmen, die pflegen, verschiedene software, die auf mehreren Delphi-version. Und die migration auf eine neuere Delphi ist nicht immer möglich, aus technischen Gründen (third-party-Komponenten) oder business-budget (Umstellungskosten, vor allem in einer Delphi-Unicode-version). So könnten Sie haben, wie Darian zugeben, mehrere Delphi-version immer noch lebendig in der gleichen Firma und Ihrem computer.
    InformationsquelleAutor Arnaud Bouchez
  7. 1

    Wenn Sie brauchen, polymoprhic Listen dann Generika sind ein Hindernis, keine Hilfe. Diese nicht selbst kompilieren, zum Beispiel, weil Sie nicht verwenden können, eine TDogList, wo ein TAnimalList ist erforderlich:

      uses
    Generics.Collections;

  type
    TAnimal = class
    end;

    TDog = class(TAnimal)
    end;

    TAnimalList = TList<TAnimal>;
    TDogList = TList<TDog>;


  procedure FeedTheAnimals(const aList: TAnimalList);
  begin
    // Blah blah blah
  end;


  var
    dogs: TDogList;
  begin
    dogs := TDogList.Create;
    try
      FeedTheAnimals(dogs);

    finally
      dogs.Free;
    end;
  end;

    Die Gründe dafür sind ziemlich klar und leicht zu erklären, aber es ist gleichermaßen counter-intuitive.

    Meine eigene Ansicht ist, dass Sie sparen ein paar Sekunden oder Minuten (wenn Sie eine langsame schreibkraft) durch die Verwendung eines generischen anstatt zu Rollen eine typsichere container mehr spezifische und für Ihre Bedürfnisse geeignet, aber Sie können am Ende verbringen mehr Zeit mit der Arbeit rund um die Probleme und Beschränkungen von Generika in die Zukunft, als Sie gerettet, indem er Sie, mit zu beginnen (und per definition, wenn Sie nicht mit generischen Containern bis zu jetzt, da Sie nicht wissen, was diese Probleme/Einschränkungen könnte, bis Sie laufen in Ihnen).

    Wenn ich eine TAnimalList dann sind die Chancen, die ich brauchen oder davon profitieren könnten zusätzliche TAnimal spezifische Methoden auf, die Liste Klasse, die würde ich gerne Erben in einem TDogList, was wiederum einen zusätzlichen spezifischen Mitglieder relevant es ist TDog Elemente.

    (Tier und Hund genutzt, nur zur Veranschaulichung, natürlich. Ich weiß nicht wirklich Arbeit auf Tierarzt-code aktuell LOL)

    Das problem ist, dass du nicht immer wissen, an den start.

    Defensive Programmierung an den Prinzipien vorschlagen (für mich ymmv), dass die Malerei selbst in eine Ecke zuliebe ein bisschen Zeit sparen ist wahrscheinlich am Ende kostet eine Menge in der Zukunft. Und wenn es nicht die zusätzlichen "Kosten" des nicht unter die up-front-sparen ist an sich vernachlässigbar.

    Plus Ihr code ist mehr shareable mit Benutzern von älteren Delphi-Versionen, wenn Sie geneigt sind, so großzügig sein.

    🙂

    • Falls Sie sich Wundern über die "klaren, aber counter-intuitive" Prinzipien, die halten hier das Beispiel von arbeiten, schrieb ich einen Artikel über eine Weile zurück. tech.turbu-rpg.com/149/generics-and-the-covariance-problem
    • dein Beispiel ist eine Einschränkung des Standard-TList<T> im Bereich der Generika.Sammlungen, es ist nicht eine innewohnende Einschränkung von Generika. Siehe meine Antwort ein Beispiel für die Fütterung der verschiedenen Arten von generischen Tiere mit einer einzigen routine!
    • -1 Es ist trivial einfach zu vermeiden, das so genannte Problem mit der richtigen Verwendung von constraints. Ich bin überrascht, jemanden so erfahrenen wie Sie sind, nicht bewusst.
    • wie behebt man dieses Problem mit "bestimmungsgemäße Verwendung von Einschränkungen"? Ich glaube nicht, dass Einschränkungen allein sind genug,... Sie haben immer noch die unvereinbar Vererbung problem (TList<T> im wesentlichen erbt direkt von TObject)
    • siehe meine neue Antwort.
    • Ich habe nicht gelernt, wie manipulieren die neuen Generischen Cat Skinning-tools ermöglichen es mir, Haut die Katzen, die ich brauche. Ich bin viel zu beschäftigt, skinning Katzen effektiv, effizient und produktiv mit sehr effektiv und viel einfacher zu lernen und zu lehren, cat skinning-tools zu lernen redundante wissen oder zu haben, um die Zeit zu verbringen, dann Lehre, redundantes wissen zu anderen, die arbeiten müssen in der gleichen cat skinning-Anlage.
    • OK, wir haben verstanden, dass Sie nicht lernen wollen.
    • Ich würde sagen, es ist nicht so, dass wir nicht lernen wollen, es ist eine Kosten-nutzen-Typ-Sache. Die potenziellen Kosten, die Verwendung von Generika auf alles, als ich dachte, ich würde wechseln, um auch auf einfachen Listen, die Sie Strich sich täglich, scheint zu überwiegen sofort die Vorteile, dies zu tun. Auf lange Sicht würde ich dem Zustimmen, dass es Sinn macht.
    • Generika bezahlen, die aus vor allem für eine einfache Liste, die Sie Strich sich täglich. Mit Generika Sie nur die erklären, die Liste und verwenden Sie es, um nichts anderes. Und wenn die polymorphe Liste Ausgabe sorgen, können Sie immer leiten Sie eine neue Liste aus der generischen Verwendung von "klassischen" Techniken, also bist du auf der sicheren Seite mit, dass als gut. Nicht zu erwähnen, Sie können immer wieder von Generika auf "manuell", da Sie nur ersetzen eine Zeile code zu tun! Meiner Meinung nach der einzige gültige Grund, nicht zu verwenden, allgemein ist die Abwärtskompatibilität.

    InformationsquelleAutor Deltics
Schreibe einen Kommentar