Stateless - StateMachine für Delphi

[Sir Rufo]

Hattest du an so etwas gedacht? (Ist jetzt nicht unbedingt state-of-the-art aber funktioniert).

Im Anhang das komplette Projekt (Source + EXE)

Delphi-Quellcode:

unit DataFetcher.DataContainer;

interface

uses
  System.Classes,
  System.SysUtils,
  System.Threading,
  stateless;

type
{$SCOPEDENUMS ON}
  TDataState   = ( Empty, Busy, Fetching, Cancelling, Refetching, Fetched, HasData, HasError );
  TDataTrigger = ( Fetch, Cancel, Data, Error, Clear );
{$SCOPEDENUMS OFF}
  TDataSM = TStateMachine<TDataState, TDataTrigger>;

type
  TDataContainer<TSource, TResult> = class
  private
    FDataAccessor: TFunc<TSource, TResult>;
    FState       : TDataSM;
    FDataTask    : ITask;
    FValue       : TResult;
    FSource      : TSource;
    procedure ConfigureSM;
    function GetValue: TResult;
    function GetHasValue: Boolean;
    procedure SetSource( const Value: TSource );
    function GetIsBusy: Boolean;
  protected
    procedure FetchData;
    procedure CancelFetch;
  public
    constructor Create( DataAccessor: TFunc<TSource, TResult> );
    destructor Destroy; override;

    procedure Clear;

    function ToString: string; override;

    property HasValue: Boolean read GetHasValue;
    property IsBusy: Boolean read GetIsBusy;
    property Source: TSource read FSource write SetSource;
    property Value: TResult read GetValue;
  end;

implementation

{ TDataContainer }

procedure TDataContainer<TSource, TResult>.CancelFetch;
var
  lTask: ITask;
begin
  lTask := FDataTask;
  if Assigned( lTask )
  then
    lTask.Cancel;
end;

procedure TDataContainer<TSource, TResult>.Clear;
begin
  FState.Fire( TDataTrigger.Clear );
  FSource := default ( TSource );
end;

procedure TDataContainer<TSource, TResult>.ConfigureSM;
begin
  FState := TDataSM.Create( TDataState.Empty );

  FState.Configure( TDataState.Empty )
  {} .Ignore( TDataTrigger.Clear )
  {} .Permit( TDataTrigger.Fetch, TDataState.Fetching );

  FState.Configure( TDataState.Fetching )
  {} .SubstateOf( TDataState.Busy )
  {} .OnEntry( FetchData )
  {} .Permit( TDataTrigger.Clear, TDataState.Cancelling )
  {} .Permit( TDataTrigger.Cancel, TDataState.Cancelling )
  {} .Permit( TDataTrigger.Fetch, TDataState.Refetching )
  {} .Permit( TDataTrigger.Data, TDataState.HasData )
  {} .Permit( TDataTrigger.Error, TDataState.HasError );

  FState.Configure( TDataState.Cancelling )
  {} .SubstateOf( TDataState.Busy )
  {} .OnEntry( CancelFetch )
  {} .Ignore( TDataTrigger.Cancel )
  {} .Ignore( TDataTrigger.Clear )
  {} .Permit( TDataTrigger.Fetch, TDataState.Refetching )
  {} .Permit( TDataTrigger.Data, TDataState.Empty )
  {} .Permit( TDataTrigger.Error, TDataState.Empty );

  FState.Configure( TDataState.Refetching )
  {} .SubstateOf( TDataState.Busy )
  {} .OnEntry( CancelFetch )
  {} .Ignore( TDataTrigger.Fetch )
  {} .Permit( TDataTrigger.Cancel, TDataState.Cancelling )
  {} .Permit( TDataTrigger.Clear, TDataState.Cancelling )
  {} .Permit( TDataTrigger.Data, TDataState.Fetching )
  {} .Permit( TDataTrigger.Error, TDataState.Fetching );

  FState.Configure( TDataState.Fetched )
  {} .Permit( TDataTrigger.Fetch, TDataState.Fetching )
  {} .Permit( TDataTrigger.Clear, TDataState.Empty );

  FState.Configure( TDataState.HasData )
  {} .SubstateOf( TDataState.Fetched );

  FState.Configure( TDataState.HasError )
  {} .SubstateOf( TDataState.Fetched );
end;

constructor TDataContainer<TSource, TResult>.Create( DataAccessor: TFunc<TSource, TResult> );
begin
  inherited Create;
  FDataAccessor := DataAccessor;
  ConfigureSM;
end;

destructor TDataContainer<TSource, TResult>.Destroy;
begin
  FState.Free;
  inherited;
end;

procedure TDataContainer<TSource, TResult>.FetchData;
var
  lSource: TSource;
begin
  lSource   := FSource;
  FDataTask := TTask.Run(
    procedure
    var
      lValue: TResult;
      lTrigger: TDataTrigger;
    begin
      try
        lValue := FDataAccessor( lSource );
        FValue := lValue;
        lTrigger := TDataTrigger.Data;
      except
        lTrigger := TDataTrigger.Error;
      end;

      TMonitor.Enter( FState );
      try
        FState.Fire( lTrigger );
        FDataTask := nil;
      finally
        TMonitor.Exit( FState );
      end;
    end );
end;

function TDataContainer<TSource, TResult>.GetHasValue: Boolean;
begin
  Result := FState.IsInState( TDataState.HasData );
end;

function TDataContainer<TSource, TResult>.GetIsBusy: Boolean;
begin
  TMonitor.Enter( FState );
  try
    Result := FState.IsInState( TDataState.Busy );
  finally
    TMonitor.Exit( FState );
  end;
end;

function TDataContainer<TSource, TResult>.GetValue: TResult;
begin
  TMonitor.Enter( FState );
  try
    if not HasValue
    then
      raise EInvalidOperation.Create( 'Fehlermeldung' );
  finally
    TMonitor.Exit( FState );
  end;
  Result := FValue
end;

procedure TDataContainer<TSource, TResult>.SetSource( const Value: TSource );
begin
  FSource := Value;
  TMonitor.Enter( FState );
  try
    FState.Fire( TDataTrigger.Fetch );
  finally
    TMonitor.Exit( FState );
  end;
end;

function TDataContainer<TSource, TResult>.ToString: string;
begin
  TMonitor.Enter( FState );
  try
    Result := FState.ToString;
  finally
    TMonitor.Exit( FState );
  end;
end;

end.

[Vis]

Puh, was man alles machen kann.

Aber im Prinzip entscheidest du im OnEntry von TDataState.Fetching mit Hilfe der Methode "FetchData" welcher Zustand als nächstes kommt. Also TDataTrigger.Data oder TDataTrigger.Error.

Als weiteren Punkt nehme ich mit, dass über den "DataAccessor", welcher der State Machine als anonyme Methode übergeben wird, je nach Anwendungsfall unterschiedliche Datenzugriffe möglich werden. Also je nachdem was als TSource und TResult festgelegt wird.

Ich suche eigentlich nur einen Ablauf, wenn nach einer Eingabe das Edit-Feld verlassen wird. Also das "Refetching" könnte ich mir sparen. Der Aufwand scheint mir trotzdem relativ hoch.

Setzt du diesen DataContainer universell ein? Benutzt du allgemein State Machines um z.B. Daten über Edit-Felder vom Bediener abzufragen und dann weiterzuverarbeiten?

[Sir Rufo]

Zitat von Vis:

Puh, was man alles machen kann.

Ja, ist schon nett ...

Zitat von Vis:

Aber im Prinzip entscheidest du im OnEntry von TDataState.Fetching mit Hilfe der Methode "FetchData" welcher Zustand als nächstes kommt. Also TDataTrigger.Data oder TDataTrigger.Error.

Hmmm, wenn ich in den Status Fetching komme, dann soll der Fetch-Prozess gestartet werden. Dieser kann irgendwann mit dem Trigger Data oder Error enden und der wird dann an die SM übergeben.

Es ist also keine Entscheidung, sondern ein eine Reaktion und der Status folgt dieser.

Zitat von Vis:

Als weiteren Punkt nehme ich mit, dass über den "DataAccessor", welcher der State Machine als anonyme Methode übergeben wird, je nach Anwendungsfall unterschiedliche Datenzugriffe möglich werden. Also je nachdem was als TSource und TResult festgelegt wird.

Jupp, du kannst einen String übergeben und dir damit ein Objekt irgendwo herholen (der String ist evtl. ein Dateiname und zurück kommt ein MemoryStream oder ein Text ...).

Zitat von Vis:

Ich suche eigentlich nur einen Ablauf, wenn nach einer Eingabe das Edit-Feld verlassen wird. Also das "Refetching" könnte ich mir sparen. Der Aufwand scheint mir trotzdem relativ hoch.

Wodurch was ausgelöst wird ist ja egal, man muss nur schauen, was es für Auslöser (Trigger) gibt und welche Statüsse () es gibt.

Zitat von Vis:

Setzt du diesen DataContainer universell ein?

Nö, den habe ich gerade mal zusammengehauen, sonst wär der etwas schöner

Zitat von Vis:

Benutzt du allgemein State Machines um z.B. Daten über Edit-Felder vom Bediener abzufragen und dann weiterzuverarbeiten?

Das kommt darauf an, was ich da wirklich will. Die SM alleine macht ja noch keinen vernünftigen Ablauf. Man kann nur einen Ablauf dort mit abbilden und auch einfach erweitern, umbauen, ergänzen.

Die SM wird man in den seltensten Fällen in freier Wildbahn erleben, sondern meistens (wie hier) eingebettet in einer anderen Klasse. Bei den Beispielen kann man das auch schön sehen.

[Vis]

Danke mal soweit für die Infos. Ich glaub ich muss noch viel lernen