Abgeleitete generische Klasse ist nicht mehr generisch

[Codehunter]

Hallo!

Dieser Lösung hier folgend habe ich eine identische Implementierung vorgenommen:

Delphi-Quellcode:

type
  TmyArray = class(System.Generics.Collections.TArray)
  public
    class function Contains<T>(const Values: array of T; const Item: T; const Comparer: IEqualityComparer<T>; out ItemIndex: Integer): Boolean; overload; static;
    class function Contains<T>(const Values: array of T; const Item: T; out ItemIndex: Integer): Boolean; overload; static;
    class function Contains<T>(const Values: array of T; const Item: T): Boolean; overload; static;
    class function IndexOf<T>(const Values: array of T; const Item: T; const Comparer: IEqualityComparer<T>): Integer; overload; static;
    class function IndexOf<T>(const Values: array of T; const Item: T): Integer; overload; static;
  end;

Doch wenn ich diesen Typ dann analog zu TArray<string> als TmyArray<string> verwenden will, meckert der Compiler:

Delphi-Quellcode:

procedure Produce;
var
  myArray: TmyArray<string>; // <-- E2003 Undeklarierter Bezeichner: 'TmyArray<>'
begin
  {...}
end;

Lasse ich das <string> in der Deklaration weg, kompiliert das zwar, kracht dann aber anschließend (logischerweise) in der Verwendung:

Delphi-Quellcode:

procedure Produce;
var
  myArray: TmyArray;
begin
  myArray := ['Foo', 'Bar', 'Baz']; // <-- E2001 Ordinaltyp erforderlich
end;

Und nu steh ich auf dem Schlauch.

Grüße
Cody

[Neutral General]

Edit: Was hier vorher stand war alles Unsinn.

Das TArray von Generics.Collections ist nur eine Klasse mit Helpermethoden für TArray<T> aus der System.pas.
Und TArray<T> ist keine Klasse, also kannst du nicht davon ableiten.
Was hast du denn vor? Wenn du einfach nur mehr Helper-Methoden willst, dann kannst du dein TmyArray so lassen, aber musst dann deine Variablen trotzdem als TArray<T> (z.B. TArray<String>) deklarieren.

[Codehunter]

Zitat von Neutral General:

Was hast du denn vor? Wenn du einfach nur mehr Helper-Methoden willst, dann kannst du dein TmyArray so lassen, aber musst dann deine Variablen trotzdem als TArray<T> (z.B. TArray<String>) deklarieren.

Darauf läufts ja hinaus. Das Problem hier ist aber anscheinend, dass TmyArray sich in einer anderen Unit befindet. Wenn ich das jetzt so lasse, wie benutze ich dann meine Zusatzimplementierung "IndexOf"?

[himitsu]

Als Class/Record-Helper könnte er seine Methoden aber dennoch dranhängen, selbst wenn Ableiten nicht geht.

[Codehunter]

Ach, ich bin doch doof Hab ich doch glatt übersehen, dass das class functions sind. Typischer Fall von Wald und Bäumen ^^

[Codehunter]

Jetzt bin ich in dem Zusammenhang auf ein weiteres Problem gestoßen:

Delphi-Quellcode:

const
  A_ITEMS: TArray<string> = ['A','B','C'];
begin
  case TmyArray.IndexOf(A_ITEMS, 'B') of // <-- E2532 Generisches Typargument konnte aus den unterschiedlichen Argumenttypen für Methode 'IndexOf' nicht abgeleitet werden
    0: ;
   1: ;
   2: ;
  end;
end;

Die Deklaration von TmyArray hat sich nicht geändert (siehe oben)

EDIT: Verwende ich statt eines konstanten Arrays eines, das als lokale Variable deklariert ist, dann geht es. Nur warum ist das so?