Überprüfung ob Objekt eine generische Liste ist

[Neutral General]

Hallo,

Ich habe gerade so meine Probleme damit zu überprüfen ob ein übergebenes TObject eine generische Objektliste egal welchen Typs ist.

Der is-Operator kriegt das scheinbar nicht richtig hin:

Delphi-Quellcode:

var 
  test: TObjectList<TButton>;
begin
  // E2010 Inkompatible Typen: 'TObjectList<StdCtrls.TButton>' und 'TObjectList<System.TObject>'
  if test is TObjectList<TObject> then
    ShowMessage('compiliert nichtmal!');

  if test is TObjectList<TButton> then
    ShowMessage('compiliert und liefert true!');
end;

Getestet unter Delphi2010.

Kennt jemand ne Methode oder einen Trick um das gewünschte zu überprüfen?

Gruß
Neutral General

[s.h.a.r.k]

// edit: Code aufgrund völliger Inkorrektheit entfernt :mrgreen:

Man sollte allgemein einfach mehr schlafen :roll:

[Neutral General]

Ich kann leider keinen Zusammenhang zwischen deiner Antwort und meiner Frage finden. Zudem ist deine Aussage auch noch falsch :stupid: Jedes Objekt besitzt TObject als Basisklasse (Ausnahme: TObject selbst)

[s.h.a.r.k]

Du könntest über den String selbst laufen lassen, wobei ich das als eine eher sehr unschöne Lösung erachte. Ist ein < und > vorhanden, so ists wohl eine generische Klasse mit der Klasse innerhalb der eckigen Klammern. Diese kann man dann ja via FindClass umwandeln... Aber das ist halt eher eine Dirty-Lösung :stupid:

// edit

Habs bis gerade die Generics.Collections und Generics.Defaults durchgeschaut und nichts gefunden, was helfen könnte, außer ich bin komplett blind :mrgreen:

[Neutral General]

Ah jo die Units hab ich auch schon durchgeschaut ;)

Wenn da was gewesen wäre, hätte ich nicht gefragt^^ Das mit den < > im Classname hatte ich auch mal kurz überlegt, ist aber keine - wie du schon sagtest - besonders schöne Lösung

[Khabarakh]

Zitat:

Zitat von Neutral General

Der is-Operator kriegt das scheinbar nicht richtig hin:

Sollte er auch nicht, schließlich ist TObjectList<Y> nicht von TObjectList<X> abgeleitet, nur weil X von Y es ist (Stichwort Ko- und Kontravarianz; TObjectList<> ist auf jeden Fall invariant).
Bei solchen Fällen muss man normalerweise über Reflection gehen, á la (Prism)

Delphi-Quellcode:

test.GetType.GetGenericTypeDefinition = typeOf(List<1>)

Aber auch die neue RTTI scheint dafür zu schwach zu sein, ich sehe da keine Erwähnung von Generics :| .

Was hast du damit überhaupt vor?

[himitsu]

Es geht leider nicht, daß man den "Typen" (falls Delphi ihn schon als Typen ansieht) auf das Generische Objekt erreichen/abfragen kann.

if test is TObjectList<T: class> then
ShowMessage('compiliert nichtmal!');

TObjectList<TObjekt> ist eine Ableitung von TObjectList<>
und TObjectList<TButton> ist auch eine Ableitung.
Es sind also Geschwister und keine Nachfahren, darum kann man diese Beiden auch nicht vergleichen.
Siehe:

Delphi-Quellcode:

type
  TMyObjectA = Class(TObject)
  End;
  TMyObjectB = Class(TMyObjectA)
  End;
  TMyObjectC = Class(TObject)
  End;
var
 X: TMyObjectC; 

if X is TObjectA then
  ShowMessage('compiliert nichtmal!');

Zitat:

[DCC Fehler] Project3.dpr(20): E2010 Inkompatible Typen: 'TMyObjectA' und 'TMyObjectC'

Hier mal die Abstammung von

Code:

TObjectList<TButton> :
TObjectList<StdCtrls.TButton> TList<StdCtrls.TButton> TEnumerable<StdCtrls.TButton> TObject

TObjectList<TObject> :
TObjectList<System.TObject>   TList<System.TObject>   TEnumerable<System.TObject>   TObject

[Neutral General]

Ja mir ist auch klar, warum der is-Operator eigentlich nicht viel Sinn macht... :/

Ich brauche das ganze, weil ich eine Klasse habe, der man ein TObject übergeben kann. Allerdings muss ich jetzt intern unterscheiden können, ob das Objekt eine Objektliste ist oder ein "einfaches" Objekt.

(Bitte keine alternativen Lösungswege - In meinem konkreten Fall muss es so gelöst werden und es geht nicht über z.B. überladene constructoren o.ä. !)

[himitsu]

Delphi-Quellcode:

if Copy(test.ClassName, 1, 12) = 'TObjectList<' then
  ShowMessage('compiliert ^_^ ');

Schade ist auch noch, daß der genischer Typ TObjectList<...> nicht von TObjectList abgeleitet ist,
somit sind diese auch nicht kompatibel. :wall:

[Neutral General]

Hallo,

Nachdem ich etwas Aufwand betrieben habe, habe ich eine bisher zuverlässig funktionierende Funktion schreiben können.
Da ich den internen Aufbau der Klassen in Delphi nicht kenne, weiß ich nicht was ich hier tatsächlich vergleiche, und dementsprechend ist das ganze natürlich wage. Das hier beruht auf Beobachtung, Erfahrung und Testergebnissen.

Delphi-Quellcode:

function IsGenericObjectList(AClass: TClass): Boolean;
const ListMagic: Array[0..7] of Byte = ($54,$4F,$62,$6A,$65,$63,$74,$4C);
begin
  Result := CompareMem(@ListMagic[0],Pointer(Integer(AClass)+$09),SizeOf(ListMagic));
end;

Das gleiche funktioniert auch für TObjectStack und TObjectQueue. Für andere habe ich es noch nicht genügend ausprobiert:

Delphi-Quellcode:

const StackMagic: Array[0..7] of Byte = ($54,$4F,$62,$6A,$65,$63,$74,$53);
const QueueMagic: Array[0..7] of Byte = ($54,$4F,$62,$6A,$65,$63,$74,$51);

Gruß
Neutral General

[himitsu]

Code:

$54,$4F,$62,$6A,$65,$63,$74,$4C = 'TObjectL'
$54,$4F,$62,$6A,$65,$63,$74,$53 = 'TObjectS'
$54,$4F,$62,$6A,$65,$63,$74,$51 = 'TObjectQ'

Ob deine Vergleiche so wirklich zuverlässig sind?

[Neutral General]

Zitat:

Zitat von himitsu

Code:

$54,$4F,$62,$6A,$65,$63,$74,$4C = 'TObjectL'
$54,$4F,$62,$6A,$65,$63,$74,$53 = 'TObjectS'
$54,$4F,$62,$6A,$65,$63,$74,$51 = 'TObjectQ'

Ob deine Vergleiche so wirklich zuverlässig sind?

Habe ja gesagt, dass ich für nichts garantiere. Hab den Code in einigen unterschiedlichen Projekten mit jeweils 5 verschiedenen Arten von Objektlisten/Stacks/Queues getestet und bisher scheint das so zu funktionieren.

EDIT: Verdammt ich Idiot. Jetzt verstehe ich auch was du geschrieben hast. Das ist natürlich Schwachsinn -.-^^ :wall:

PS: Aber Hauptsache ich habe nicht auf Classname geprüft :stupid: :mrgreen:

[stahli]

Kennt jemand inzwischen vielleicht doch eine Lösung?

Mein Problem:
Ich habe einen Container mit einer generischen Liste

Delphi-Quellcode:

unit od;

interface

uses
  Classes, Contnrs, Generics.Collections;

type

  AttrOd = class(TCustomAttribute);

  Tod = class(TComponent)
  private
    ...
  protected
  public
    constructor Create(AOwner: TComponent); override;
    destructor Destroy; override;
    ...
  published
    ...
  end;

  Todl<T: Tod> = class(Tod)
  private
    FItems: TObjectList<T>;
  protected
    ...
  public
    constructor Create(AOwner: TComponent); override;
    destructor Destroy; override;
    property Items: TObjectList<T>read FItems;
  published
  end;

...

constructor TodSport.Create(AOwner: TComponent);
begin
  inherited;
  FNumeratorList := Todl<TodNumerator>.Create(Self);
  FDisciplineGroupList := Todl<TodDisciplineGroup>.Create(Self);
end;

...

Über RTTI ermittle ich verschiedene Eigenschaften und erhalte ein TObject "O", das auf die Property NumeratorList von Sport zeigt.
Nun würde ich gern auf die einzelnen Items zugreifen (z.B. über

Delphi-Quellcode:

(O as Todl<Tod>).Items[0]

).

An den ClassName 'TObjectList<odNumerator.TodNumerator>' komme ich heran, aber ein Cast ist wohl nicht möglich, oder?

Ich will mit allen Items (die vom Typ "Tod" sein müssen) eine Aktion durchführen.
Muss ich in diesem Fall auf Generics verzichten?

[webcss]

Schau mal hier den konkreten typ eines generics ermitteln
Das ist wohl genau die Lösung zu Deinem Problem, welches sich mir auch schon stellte...

[stahli]

Den Thread kenne ich und habe die Funktion getestet.
Ich muss jedoch auf den Container casten, der die generische Liste enthält und will dann auf die Liste zugreifen.
Das ist mir nicht gelungen...

[himitsu]

Delphi-Quellcode:

var c: class of ...;

(O as C).xyz

Sowas geht hier eh nicht, da hier der /basis)Typ statisch (konstant) sein muß, weil dieser Zugriff ja über den Compiler aufgelöst wird.

Wenn du über die RTTI willst, dann wirst du dieses auch weiter manuell/dynamisch über die RTTI auflösen müssen.

Also über den gefundenen Typ die Property abfragen, dann vom gewünschten Property den Type und nun auch noch über die RTTI auf dieses Property zugreifen.

[stahli]

Ok, danke.

Ich kann mich erst heute Abend damit beschäftigen, aber ich denke mir das dann so:

- O nicht casten, sondern nur prüfen, ob ein '<' im ClassName enthalten ist
- dann einfach O mit RTTI weiter untersuchen
- dann komme ich auf TObjectList<TodNumerator>

Hmm, dann kann ich aber ja auch nicht korrekt (und ohne schmutzige Tricks) auf Items<Tod> casten.
Wenn ich den benutzten Typ (TodNumerator oder einen seiner Geschwister) erfahre, bringt mich das ja auch noch nicht wirklich weiter...

Und wenn ich TObjectList<TodNumerator> als Objekt weiter untersuche, kann ich dann die einzelnen TodNumerator finden (und diese als Tod weiter bearbeiten)?

Ich werde das heute Abend noch mal anschauen. Notfalls verzichte ich in dem Fall auf Generics, dann sehe ich beim Cast von Listen-Containern eigentlich keine Probleme.



RTTI und Generics sind schon sehr interessant, passen aber wohl noch (oder prinzipiell) nicht 100%ig zusammen.

[stahli]

Folgende Eigenschaften und Felder konnte ich ermitteln:

Code:

=> Todl<odNumerator.TodNumerator>:
  
  *****PROP*****
  Items
  Items: TObjectList<odNumerator.TodNumerator>
    
    *****PROP*****
    OwnsObjects
    Capacity
    Count
    OnNotify
    
    *****VAR*****
    FOwnsObjects
    FItems
    FCount
    FComparer
    FOnNotify
    
  odName
  odClass
  odId
  odCT
  ComponentCount
  ComponentIndex
  ComponentState
  ComponentStyle
  DesignInfo
  VCLComObject
  Name
  Tag
  
  *****VAR*****
  FItems
  FItems: TObjectList<odNumerator.TodNumerator>
  FodName
  FodClass
  FodId
  FodCT
  FOwner
  FName
  FTag
  FComponents
  FFreeNotifies
  FFreeNotifies: TList
  FDesignInfo
  FComponentState
  FVCLComObject
  FComponentStyle
  FSortedComponents

Ich habe jetzt keine Idee, wie ich an die einzelnen Items heran komme und werde in dem Fall doch auf Generics verzichten.
Vielleicht könnte man auf eine Funktion zugreifen, aber das wird mir dann zu kompliziert.

Falls jemand damit herumspielen möchte, hier meine Funktion (schnell gestrickt und etwas unsauber):

Delphi-Quellcode:

function TodProp.GetProps(O: TObject; Deep: Integer): String;
var
  Context: TRttiContext;
  RttiType: TRttiType;
  PropInfo: TRttiProperty;
  FieldInfo: TRttiField;
  Attr: TCustomAttribute;
  Value: TValue;
  SO: TObject;

  procedure Write(S: String);
  begin
    S := DeepString(Deep) + S;
    Result := Result + S + #13#10;
    OutputDebugString(PChar(S));
  end;
  
begin
  Result := '';
  if (not Assigned(O)) then
    Exit;

  if Deep = 0 then
    Write('=> ' + O.ClassName + ':');
  Inc(Deep);

  Write('');
  Write('*****PROP*****');

  Context := TRttiContext.Create;
  RttiType := Context.GetType(O.ClassType);

  if Assigned(RttiType) then
  begin
    for PropInfo in RttiType.GetProperties do
    begin
      if PropInfo.Name = 'ComObject' then
        Continue;
      if PropInfo.Name = 'Owner' then
        Continue;
      if PropInfo.Name = 'Parent' then
        Continue;
      if PropInfo.Name = 'Sport' then
      begin
        Beep;
      end;
      Write(PropInfo.Name);
      case PropInfo.PropertyType.TypeKind of
        tkClass:
          begin
            Value := PropInfo.GetValue(O);
            if (not Value.IsEmpty) then
            begin
              SO := Value.AsObject;
              if (Assigned(SO)) and ((not(SO is TComponent)) or ((SO as TComponent).Owner = O)) then
              begin
                Write(PropInfo.Name + ': ' + SO.ClassName);
                Result := Result + GetProps(SO, Deep);
              end;
            end;
          end;
      end;
    end;
  end;

  Write('');
  Write('*****VAR*****');

  Context := TRttiContext.Create;
  RttiType := Context.GetType(O.ClassType);

  if Assigned(RttiType) then
  begin
    for FieldInfo in RttiType.GetFields do
    begin
      if FieldInfo.Name = 'ComObject' then
        Continue;
      if FieldInfo.Name = 'Owner' then
        Continue;
      if FieldInfo.Name = 'Parent' then
        Continue;
      if FieldInfo.Name = 'Sport' then
      begin
        Beep;
      end;
      Write(FieldInfo.Name);
      case FieldInfo.FieldType.TypeKind of
        tkClass:
          begin
            Value := FieldInfo.GetValue(O);
            if (not Value.IsEmpty) then
            begin
              SO := Value.AsObject;
              if (Assigned(SO)) and ((not(SO is TComponent)) or ((SO as TComponent).Owner = O)) then
              begin
                Write(FieldInfo.Name + ': ' + SO.ClassName);
//                Result := Result + GetFields(SO, Deep);
              end;
            end;
          end;
      end;
    end;
  end;

  Write('');
  Dec(Deep);
  
  Context.Free;
end;