Seriallisieren/Deseriallisieren von Enums via RTTI

[Ghostwalker]

MoinMoin,

ich bin gerade drüber, mir eine (möglichst Allgemeingültige und flexible) Lösung zu bauen, um Optionen/Einstellungen eines Programmes zu speichern (ich weiß...gibts in 20002 mögliche Varianten )

Plan:

Die App definiert sich eine Klasse (oder einen Record) für die ganzen Optionen/Einstellungen.

Ein Objekt nimmt die Klasse/Record und seriallisiert/deseriallisiert das ganze in eine Datei (Format steht derzeit nicht fest). Dazu wird, via RTTI, für jede Property der Options-Klasse ein, ich nenn es mal Field-Objekt
erzeugt, das die Informationen wie Typ, Value usw. enthält.

Delphi-Quellcode:

  TAbsField = class(TPersistent)
    private
       fname : Unicodestring;
       fvalue: TValue;
       fseperator : UnicodeString;
       ftype : Unicodestring;
    protected

       function GetType:TTypeKind;
    public
       constructor Create(Seperator:Unicodestring=';');
       procedure Assign(source:TPersistent);
       function SerializeToString:UnicodeString;virtual;
       procedure DeserializeFromString(aString:UnicodeString);virtual;
    published
       property Kind : TTypekind read GetType;
       property Name : UnicodeString read fname write fname;
       property Value : TValue read fvalue write fvalue;
       property Typename: Unicodestring read ftype write ftype;
       Property Seperator : UnicodeString read fseperator write fseperator;

  end;

Seriallisiert sieht so ein Objekt so aus:

Code:

   :
   tkInteger,"Integer","Wert",42
   :

Problem ist nun, wie ich das ganze mit Enums mache. Seriallisiert sieht das ganze derzeit so aus:

Code:

  :
  tkEnumeration,"TMyEnum01","MyEnum1","me1A"
  :

Bein Einlesen steh ich aber vor dem Problem, wie ich nun aus den Infos wieder ein TValue (oder TMyEnum01) mache, um das in der Field-List reinbekomme. Hat da jemand ne Idee ?

[TiGü]

Nicht selber stricken!
Schau doch mal, wie weit du mit den schon eingebauten Mechanismen kommst.

Delphi-Quellcode:

uses 
  REST.JSON,
  System.JSON;

procedure TForm1.Button1Click(Sender: TObject);
var
  Foo: TFoo;
begin
  Foo := TFoo.Create;
  try
    Foo.Foo := 'Hello World';
    Foo.Fee := 42;

    Memo1.Lines.Text := TJson.ObjectToJsonString(Foo);
  finally
    Foo.Free;
  end;

  Foo := TJson.JsonToObject<TFoo>(Memo1.Lines.Text);
  try
    Foo.Fee := 100;
    Memo1.Lines.Add(TJson.ObjectToJsonString(Foo));
  finally
    Foo.Free;
  end;
end;

[Ghostwalker]

Gugg mal auf die Version von Delphi von mir

Starter hat kein REST.

Und mit System.Json muss ich den RTTI-Teil auch selber machen.

[Uwe Raabe]

Zitat von Ghostwalker:

Bein Einlesen steh ich aber vor dem Problem, wie ich nun aus den Infos wieder ein TValue (oder TMyEnum01) mache, um das in der Field-List reinbekomme. Hat da jemand ne Idee ?

Wenn du weißt, daß der Typ TMyEnum01 ist, dann sollte es einfach so gehen:

  value := TValue.From<TMyEnum01>(TRttiEnumerationType.GetValue<TMyEnum01>('me1A'));

[TiGü]

Zitat von Ghostwalker:

Gugg mal auf die Version von Delphi von mir

Starter hat kein REST.

Und mit System.Json muss ich den RTTI-Teil auch selber machen.

Da gibt es keine Unit namens REST.Json und REST.JsonReflect?

[Ghostwalker]

@TiGü
Nein, leider nicht (btw. auch kein DBExpress )

@Uwe
Jo, dann müsst ich aber eine Case machen (für jeden Enum-Typ).

Den Typ hab ich als String (weil ja aus Datei) vorliegen.

und bei

Delphi-Quellcode:

var
  tenumtypename : string;

begin
  value := TValue.From<tenumtypename>(TRttiEnumerationType.GetValue<tenumtypename>('me1A'));
end;

zeigt sich der Compiler leider von der störrischen Seite

[Zacherl]

Wie wäre es, wenn du Enums einfach genauso wie andere Ordinal-Typen behandelst? Sprich: Die Werte als Zahl abspeichern/auslesen.

[Ghostwalker]

Würde nix daran ändern. Früher oder Später muss ich auf den entsprechenden Enum-Type (den ich aber nur als String hab).


Edit:

Ok....es ändert sehr viel, wenn man das ganze mal richtig betrachtet Ich muss nur anhand des Enum-Type die
Größe feststellen und das ganze entsprechend casten (Byte,word..).

[Uwe Raabe]

Zitat von Ghostwalker:

Würde nix daran ändern. Früher oder Später muss ich auf den entsprechenden Enum-Type (den ich aber nur als String hab).

Ich kenne bislang auch keine Möglichkeit von einem String auf einen Enum-Type zu kommen, außer man hat den Namen der Unit, in der er deklariert ist. Dann könnte das so gehen:

Delphi-Quellcode:

var
  context: TRttiContext;
  rtype: TRttiType;
  value: TValue;
begin
  context := TRttiContext.Create;
  rtype := context.FindType('<unitname>.TMyEnum01');
  value := TValue.FromOrdinal(rtype.Handle, GetEnumValue(rType.Handle, 'me1A'));
end;

[himitsu]

Zitat von Ghostwalker:

Ich muss nur anhand des Enum-Type die
Größe feststellen und das ganze entsprechend casten (Byte,word..).

Ord