Tutorial: Erstellen von Sammlungslisten mit LiveBindings

Aus RAD Studio
Wechseln zu: Navigation, Suche

Nach oben zu Tutorials zu Datenbanken und LiveBindings


In diesem Tutorial wird gezeigt, wie die im Beispielprojekt ListCollections verwendete Anwendung erstellt wird.

Hinweis: Sie finden das Beispielprojekt ListCollections unter:

Start | Programme | Embarcadero RAD Studio Rio | Beispiele und navigieren Sie zu Object Pascal\FireMonkey Desktop\ListCollections.


Dieses Beispiel ist unter FMX.ListCollections (Beispiel) beschrieben.

Schritt 1: Erstellen des Projekts

  1. Erstellen Sie ein neues Projekt: Datei > Neu > Geräteübergreifende Anwendung - Delphi
    Wählen Sie im Experten Leere Anwendung.
  2. Wählen Sie das Formular aus, und ändern Sie im Objektinspektor die Eigenschaft Caption in "List Collections Demo".
  3. Fügen Sie dem Formular eine TLabel-Komponente hinzu, und ändern Sie im Objektinspektor deren Eigenschaft Text in "Collection: ".
  4. Suchen Sie in der Tool-Palette die Komponente ComboBox, und ziehen Sie sie auf das Formular.
  5. Klicken Sie im Formular-Designer mit der rechten Maustaste auf die Komponente ComboBox1, und wählen Sie Eintrag hinzufügen > TListBoxItem aus.
    AddItem.png
  6. Fügen Sie dem Formular vier TLabel-Komponenten hinzu, und ändern Sie die Eigenschaft Text für die jeweilige Komponente in:
    "Control Component:", "Control Expression:", "Source Component:", "Source Expression:"
    Ändern Sie auch die Eigenschaft Name für die jeweilige Komponente in:
    "LabelControlComponent", "LabelControlExpression", "LabelSourceComponent"
  7. Fügen Sie für jede Beschriftung ("LabelControlComponent", "LabelControlExpression", "LabelSourceComponent") eine TEdit-Komponente hinzu, und ändern Sie die Eigenschaft Name der jeweiligen Komponente in:
    "EditControlComponent", "EditControlExpression", "EditSourceComponent"
    Setzen Sie für jede TEdit-Komponente auch die Eigenschaft Enabled auf False.
  8. Fügen Sie den Formular eine TEdit-Komponente hinzu, und ändern Sie die Eigenschaft Name in "EditSourceExpression".
  9. Fügen Sie dem Formular zwei TButton-Komponenten hinzu, und ändern Sie die Eigenschaft Text in "Fill" bzw. "Clear".
    Ändern Sie auch die Eigenschaft Name in "ButtonEvaluate" bzw. "ButtonClear".
  10. Fügen Sie dem Formular drei TCheckBox-Komponenten hinzu, und ändern Sie die Eigenschaft Text der jeweiligen Komponente in:
    "Auto Active", "Active", "Auto Fill"
    Ändern Sie auch die Eigenschaft Name für die jeweilige Komponente in:
    "CheckBoxAutoActive", "CheckBoxActive", "CheckBoxAutoFill"
    LabelAndEdit.png
  11. Suchen Sie in der Tool-Palette die Komponente TListBox, und ziehen Sie sie auf das Formular.
  12. Fügen Sie dem Formular eine TBindingList-Komponente hinzu.
  13. Klicken Sie im Formular mit der rechten Maustaste auf die Komponente BindingList1, und wählen Sie Bindungskomponenten...
  14. Wählen Sie im Editor für Bindungslisten die Option Neue Bindung (Einfg) aus.
    NewBinding.png
  15. Wählen Sie im Dialogfeld Neue LiveBinding die Option Listen > TBindList aus.
  16. Setzen Sie im Objektinspektor die Eigenschaft ControlComponent auf ListBox1.
    ControlComponent.png

Schritt 2: Implementierung

  • Die Unit SampleCollections.pas implementiert die weiteren unterstützten Sammlungen von Elementen, die in das Listenfeld per LiveBindings exportiert werden. In dem Beispiel werden mit dem Design-Pattern "Factory" zur Klassengenerierung mehrere verschiedene Typen von Sammlungen dynamisch erzeugt:
  • Ein Dictionary
  • Eine Liste mit Objekten
  • Eine Liste mit Generics
  • Eine Liste mit Strings
  • Das Produktbeispiel ListCollections eignet sich nicht für Anfänger (fortgeschrittene Kenntnisse sind erforderlich; zum Lesen des Codes müssen Ihnen die RTTI und erweiterte Sprachelemente, wie anonyme Methoden und Design-Pattern) vertraut sein.


Fügen Sie dem Projekt die Unit SampleCollections.pas hinzu.

Fügen Sie in den "private"-Abschnitt von TForm1 diese Variablen ein:

Delphi:
FChecking: Boolean;
FDataObjects: TDictionary<TCollectionFactory, TObject>;
FFactory: TCollectionFactory;
FChanging: Boolean;

Fügen Sie der Unit die folgende Variable hinzu:

Delphi:
var
  BindScope1: TBindScope;

1. Hinzufügen einer OnCreate-Ereignisbehandlungsroutine für das Formular

1. Wählen Sie in der Strukturansicht die Komponente Form1 aus.
2. Öffnen Sie im Objektinspektor die Registerkarte Ereignisse, und doppelklicken Sie auf OnCreate.
3. Fügen Sie im Quelltext-Editor den folgenden Code hinzu:
Delphi:
procedure TForm1.FormCreate(Sender: TObject);
var
  LFactory: TCollectionFactory;
  LListItem: TListBoxItem;
begin
  BindScope1 := TBindScope.Create(Self);
  BindList1.SourceComponent := BindScope1;
  FDataObjects := TObjectDictionary<TCollectionFactory, TObject>.Create([doOwnsValues]);
  // List test data in combobox
  for LFactory in GetCollectionFactories do
  begin
    LListItem := TListBoxItem.Create(ComboBox1);
    ComboBox1.AddObject(LListItem);
    LListItem.Text := LFactory.DisplayName;
    LListItem.Data := LFactory;
  end;
  Application.OnIdle := OnIdle;
  UpdateDisplayFields;
end;

Fügen Sie in den "public"-Abschnitt von TForm1 diese Prozeduren ein:

Delphi:
procedure OnIdle(Sender: TObject; var Done: Boolean);;
procedure UpdateDisplayFields;


Implementierung der obigen Prozeduren:

Delphi:
procedure TForm1.OnIdle(Sender: TObject; var Done: Boolean);
begin
  FChecking := True;
  try
    CheckBoxActive.IsChecked := BindList1.Active;
    CheckBoxAutoFill.IsChecked := BindList1.AutoFill;
    CheckBoxAutoActivate.IsChecked := BindList1.AutoActivate;
  finally
    FChecking := False;
  end;
end;

//  Display information about binding
procedure TForm1.UpdateDisplayFields;
var
  LSourceExpression: string;
  LControlExpression: string;
  LSourceComponent: string;
  LControlComponent: string;
begin
  if BindList1.FormatExpressions.Count > 0 then
  begin
    LSourceExpression := BindList1.FormatExpressions[0].SourceExpression;
    LControlExpression := BindList1.FormatExpressions[0].ControlExpression;
  end;
  if BindList1.ControlComponent <> nil then
    LControlComponent := BindList1.ControlComponent.ClassName;
  if BindList1.SourceComponent <> nil then
  begin
    LSourceComponent := BindList1.SourceComponent.ClassName;
    if BindList1.SourceComponent is TBindScope then
      with TBindScope(BindList1.SourceComponent) do
        if DataObject <> nil then
          LSourceComponent := LSourceComponent + ' (' +
            DataObject.ClassName + ')'
      else if Component <> nil then
        LSourceComponent := LSourceComponent + ' (' +
          Component.ClassName + ')';
  end;
  EditSourceExpression.Text := LSourceExpression;
  EditControlExpression.Text := LControlExpression;
  EditControlComponent.Text := LControlComponent;
  EditSourceComponent.Text := LSourceComponent;
end;

2. Hinzufügen einer OnChange-Ereignisbehandlungsroutine für das Kombinationsfeld

1. Wählen Sie in der Strukturansicht die Komponente ComboBox1 aus.
2. Öffnen Sie im Objektinspektor die Registerkarte Ereignisse, und doppelklicken Sie auf OnChange.
3. Fügen Sie im Quelltext-Editor den folgenden Code hinzu:
Delphi:
procedure TForm1.ComboBox1Change(Sender: TObject);
var
  LDataObject: TObject;
begin
  FChanging := True;
  try
    if ComboBox1.ItemIndex <> -1 then
    begin
      FFactory := ComboBox1.ListBox.Selected.Data as TCollectionFactory;
    end
    else
    begin
      FFactory := nil;
    end;
    if FFactory <> nil then
    begin
      if BindList1.FormatExpressions.Count = 0 then
        BindList1.FormatExpressions.Add;
      BindList1.FormatExpressions[0].SourceExpression := FFactory.GetExpression;
      BindList1.FormatExpressions[0].ControlExpression := 'Text';
      LDataObject := FFactory.CreateCollection;
      FDataObjects.AddOrSetValue(FFactory, LDataObject);  // Track objects in order to free when not in use
      // Set DataObject last because this can trigger activation and auto fill
      BindScope1.DataObject := LDataObject;
    end
    else
      BindScope1.DataObject := nil;
  finally
    FChanging := False;
    UpdateDisplayFields;
  end;
end;

3. Hinzufügen einer OnClick-Ereignisbehandlungsroutine für Schaltflächen

1. Wählen Sie in der Strukturansicht die Komponente ButtonEvaluate aus.
2. Öffnen Sie im Objektinspektor die Registerkarte Ereignisse, und doppelklicken Sie auf OnClick.
3. Fügen Sie im Quelltext-Editor den folgenden Code hinzu:
Delphi:
procedure TForm1.ButtonEvaluateClick(Sender: TObject);
begin
  BindList1Activating(Self); // Update expression
  BindList1.FillList;
end;
4. Wiederholen Sie die obigen Schritte für ButtonClear, und fügen Sie im Quelltext-Editor den folgenden Code hinzu:
Delphi:
procedure TForm1.ButtonClearClick(Sender: TObject);
begin
  BindList1.ClearList;
end;

4. Hinzufügen einer OnChange-Ereignisbehandlungsroutine für Kontrollkästchen

1. Wählen Sie in der Strukturansicht die Komponente CheckBoxAutoActive aus.
2. Öffnen Sie im Objektinspektor die Registerkarte Ereignisse, und doppelklicken Sie auf OnChange.
3. Fügen Sie im Quelltext-Editor den folgenden Code hinzu:
Delphi:
procedure TForm1.CheckBoxAutoActivateChange(Sender: TObject);
begin
  if not FChecking then
    BindList1.AutoActivate := CheckBoxAutoActivate.IsChecked;
end;
4. Wiederholen Sie die obigen Schritte für CheckBoxActive und CheckBoxAutoFill, und fügen Sie im Quelltext-Editor den folgenden Code hinzu:
Delphi:
procedure TForm1.CheckBoxActiveChange(Sender: TObject);
begin
  if not FChecking then
    BindList1.Active := CheckBoxActive.IsChecked;
end;
Delphi:
procedure TForm1.CheckBoxAutoFillChange(Sender: TObject);
begin
  if not FChecking then
    BindList1.AutoFill := CheckBoxAutoFill.IsChecked;
end;

5. Hinzufügen der OnActivating- und OnEvalError-Ereignisbehandlungsroutinen für BindList

1. Wählen Sie in der Strukturansicht die Komponente BindList1 aus.
2. Öffnen Sie im Objektinspektor die Registerkarte Ereignisse, und doppelklicken Sie auf OnActivating.
3. Fügen Sie im Quelltext-Editor den folgenden Code hinzu:
Delphi:
procedure TForm1.BindList1Activating(Sender: TObject);
begin
  if not FChanging then
    if BindList1.FormatExpressions.Count > 0 then
      BindList1.FormatExpressions[0].SourceExpression := EditSourceExpression.Text;
end;
4. Öffnen Sie im Objektinspektor die Registerkarte Ereignisse, und doppelklicken Sie auf OnEvalError.
5. Fügen Sie im Quelltext-Editor den folgenden Code hinzu:
Delphi:
procedure TForm1.BindList1EvalError(Sender: TObject; AException: Exception);
begin
  // Generate a new exception with more information
  raise TBindCompException.CreateFmt(
    'Evaluation Exception'#13#10 +
    'Component Name: %s'#13#10 +
    'Exception Class: %s'#13#10 +
    'Exception Message: %s',
    [TComponent(Sender).Name, AException.ClassName, AException.Message]);
end;

Die Ergebnisse

Drücken Sie F9, oder wählen Sie Start > Start.

Klassen

Die List Collections Demo zeigt ein Hauptfenster für das Beispiel an. Es enthält die folgenden Komponenten:

Verwendete Komponenten

Siehe auch