Überprüfung ob Objekt eine generische Liste ist

[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 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 -.-^^

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

[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 (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;