WPF-Binding-Konzept bzw. ViewModel o.ä. gesucht

[Matze]

Hallo zusammen,

in einer Textdatei möchte ich WPF-Controls definieren können. Nach dem Einlesen der Datei sollen diese WPF-Controls erzeugt werden. Hintergrund ist der, dass eine einzige Software für verschiedene Eingabeparameter konfiguriert werden kann.
Das funktioniert soweit auch und sieht grob wie folgt aus:

Textdatei:

Code:

DEF_USERPARAM: PROGRAM(Name="Bezeichnung", Datatype="string", UIPosX=0, UIPosY=75, UIWidth=100)
DEF_USERPARAM: PROGRAM(Name="Anzahl Tests", Datatype="int32", UIPosX=130, UIPosY=75, UIWidth=50)

Ein Parser macht mir daraus das hier:

Code:

// Key = Parameter-Name
// Value = Object mit den Properties "UIPosX" etc.
Dictionary<string, DefUserParamProgram> ProgramParam

Über eine Foreach-Schleife erzeugt mir das 2 x eine WPF-TextBox an den entsprechenden Prositionen (UIPosX/UIPosY).

Die Binding-Daten sehen so aus:

Code:

public class UIElemData : INotifyPropertyChanged
{
   public event PropertyChangedEventHandler PropertyChanged;

   protected void OnPropertyChanged(string name)
   {
      PropertyChangedEventHandler handler = PropertyChanged;
      if (handler != null)
      {
         handler(this, new PropertyChangedEventArgs(name));
      }
   }

   private Thickness _margin;
   public Thickness Margin
   {
      get { return _margin; }
      set
      {
         _margin = value;
         OnPropertyChanged("Margin");
      }
   }

   private int _width;
   public int Width
   {
      get { return _width; }
      set
      {
         _width = value;
         OnPropertyChanged("Width");
      }
   }

   // ...
}

Der Code zum Erzeugen der WPF-Controls ist folgender:

Code:

UIElemData uiElemData = new UIElemData();
// ... (Zuweisung der Properties)

StackPanel pnlElem = new StackPanel();
pnlElem.DataContext = uiElemData;
pnlElem.SetBinding(StackPanel.MarginProperty, new Binding("Margin"));

// ...

TextBox elemStr = new TextBox();
elemStr.SetBinding(TextBox.WidthProperty, new Binding("Width"));
pnlElem.Children.Add(elemStr);

Wie gesagt, das funktioniert so alles und die Elemente werden erzeugt.

Für mich momentan unlösbar ist folgendes:
Die Oberfläche steht nun und diese soll verschiedene "Parametersätze" verwalten können:
Bei Parametersatz 1 enthalten die 2 TextBoxen z.B. die Werte "ABC" und "1", bei Parametersatz 2 "DEF" und "7".

Der Parametersatz soll aus einer ComboBox ausgewählt werden können (als "Tag" könnte hier der Satz-Index hinterlegt sein). Und je nach gewähltem Parametersatz sollen die Werte in den WPF-Controls aktualisiert werden. Hierfür muss auch TwoWay-Binding möglich sein.

Wie kann sowas realisiert werden? Ich vermute irgendwie mit MultiBinding, aber ich habe keine Idee, wie das hier aussehen könnte bzw. ob das Binding-Object "UIElemData" überhaupt in der Art geeignet ist.
Das Ganze muss natürlich im Code-Behind den WPF-Controls zugewiesen werden können, da diese zur Design-Time nicht bekannt sind.

Wer hat Ideen und kann mir helfen?

Grüße
Matze

[DP-Maintenance]

Dieses Thema wurde am "04. Oct 2015, 08:21 Uhr" von "Matze" aus dem Forum ".NET-Sprachen" in das Forum ".NET-Framework (managed code)" verschoben.

[Dejan Vu]

Du verwaltest die Liste der Parametersätze im Viewmodel und bindest die Index-Eigenschaft der Combobox zur Auswahl des Parametersatzes an die neue 'ParamIndex'-Property des VM.
Im Setter der ParamIndex-Property rufst Du die PropertyChanged-Eventhandler aller Properties auf.
Mit der neuen Methode 'AddParam' kannst Du weitere Parametersätze anfügen.

Code:

public class UIElemData : INotifyPropertyChanged
 {
    private List<Params> _params = new List<Params>();

    public event PropertyChangedEventHandler PropertyChanged;

    protected void OnPropertyChanged(string name)
    {
       PropertyChangedEventHandler handler = PropertyChanged;
       if (handler != null)
       {
          handler(this, new PropertyChangedEventArgs(name));
       }
    }

    private int _paramIndex;
    public int ParamIndex 
    { 
      get{ return _paramIndex;}
      set{ 
        _paramIndex = value;
        OnPropertyChanged("Margin");
        OnPropertyChanged("Width");
      }
    }

    public void AddParam(Param param) { _params.Add(param); }

    public Thickness Margin
    {
       get { return _params[_paramIndex].Margin; }
       set
       {
          _params[_paramIndex].Margin = value;
          OnPropertyChanged("Margin");
       }
    }

    public int Width
    {
       get { return _params[_paramIndex].Width; }
       set
       {
          _params[_paramIndex].Width = value;
          OnPropertyChanged("Width");
       }
    }

    // ...
 }

[Matze]

Hallo,

das klingt gar nicht schlecht, danke! :thumb:

Ich hatte erst einen ähnlichen Ansatz und fand es dann schwierig, die Parametersätze abzuspeichern, da die den GUI-Properties zugeordnet sind und somit nicht ohne weiteres in der Software später umgeschaltet werden können. Mein Wunsch war es, den Parametersatz-Index vorzugeben und daraufhin erhalte ich alle zugehörigen Daten.
Aber dafür kann ich ja eine separate Liste o.ä. erstellen.
Für das Einstellen der Parametersätze ich dein Vorschlag vermutlich der geeignetste und später auch nachvollziehbar, was das Binding betrifft.

Grüße
Matze

[Dejan Vu]

Falls Du es immer noch schwierig findest, sag Bescheid

Zitat:

Zitat von Matze (Beitrag 1317677)

Mein Wunsch war es, den Parametersatz-Index vorzugeben und daraufhin erhalte ich alle zugehörigen Daten.

Genau das macht die Snippet. Sobald Du den ParamIndex veränderst, kannst du die entsprechenden Werte aus 'Width' und 'Margin' auslesen.

Zitat:

...die Parametersätze abzuspeichern, da die den GUI-Properties zugeordnet sind und somit nicht ohne weiteres in der Software später umgeschaltet werden können.

Also Abspeichern geht doch, sofern Du deine Parameterliste zugänglich machst. Wir verwenden dafür Controller, d.h. eine Klasse, welches die Form und das VM instantiiert, die VM konfiguriert (also z.B. die Parameterliste injiziert) und dann beides verheiratet (VM+Form) und anzeigt. Kommt die form mit 'OK' zurück, speichert der Controller den Parametersatz wieder ab.

[Matze]

Hallo,

so, jetzt komme ich wieder dazu.
Ich wollte mich grad dran machen, aber wie kann ich denn den gewählten ComboBox-Index an alle UIElemData-Instanzen binden?
Ich habe ja pro WPF-Control eine Instanz von UIElemData und die müssten alle den gewählten Index übermittelt bekommen.

Ich könnte den Index natürlich übergeordnet führen und im "set" alle UIElemData-Elemente durchlaufen und den Index setzen. Aber direkt mittels Binding wäre es schöner.

Grüße
Matze

[Dejan Vu]

Nee, Du hast nur eine Instanz von UIElemData. Den ParamIndex bindest Du an die Combobox und die anderen Properties an die Edit-Controls. Änderst Du die Combobox, änderst Du den Paramindex und damit die Werte der 'Width' und 'Margin' Property. Denn die zeigen ja jeweils genau den Parametersatz an, der mit Paramindex gewählt wurde.

[Matze]

Hm, vielleicht haben wir uns auch alsch verstanden.
Ich versuche nochmals zu erklären, was ich versuche

Es handelt sich um eine Software, die gewisse Prüfungen durchführt. Die Art der Prüfung wird z.B. in einer Ini-Datei definiert (so muss ich bei Änderung einer Prüfart nichts programmieren). Je nach Art der Prüfung gibt es z.B. verschieden einstellbare Grenzwerte.

Beispiel:
Prüfart 1 hat folgende einstellbare Parameter: Grenzwert 1, Grenzwert 2 und Prüfzeit
Prüfart 2 hat folgende einstellbare Parameter: Grenzwert 1, Grenzwert 2, Grenzwert 3, Prüfzeit 1 und Prüfzeit 2

Die Werte der Parameter selbst kann der Benutzer frei eingeben und verschiedene Parametersätze nutzen.

Beispiel: Prüfart 1 ist konfiguriert
Parametersatz 1: Grenzwert 1 = 5, Grenzwert 2 = 10, Prüfzeit = 20
Parametersatz 2: Grenzwert 1 = 5, Grenzwert 2 = 15, Prüfzeit = 25

Da die Prüfart konfiguriert werden kann (Ini-Datei o.ä.) und davon die Paremeter abhängen, müssen die Parameterfelder (= WPF-Controls wie TextBox, CheckBox, ...) zur Laufzeit erzeugt werden. Die Felder werden innerhalb eines Fensters alle auf einmal dargestellt. Die Positionen und Größen können über "Margin" und "Width" festgelegt werden (Ini-Datei).
Ein Parameterfeld war für mich bisher ein UIElemData-Element. Und da es mehrere Parameterfelder gibt, habe ich mehrere UIElemData-Elemente.

In dem Fenster mit den Feldern für die Parameter gibt es oben eine ComboBox zur Auswahl des Parametersatzes. Ändert man den ComboBox-Eintrag, werden alle Parameterfelder aktualisiert. Wird im Parameterfeld etwas geändert, soll der zugehörige Parametersatz geändert werden.

Ist das von der Aufgabenstellung her klar?
Nicht, dass wir hier aneinander vorbei"schreiben". ;)

Grüße
Matze

[Dejan Vu]

Ah.... Im Grunde genommen habe ich ein Array von Parametern pro Prüfart. Jeder Parameter ist von einem bestimmten Datentyp, zu dem es ein entsprechendes Control gibt. Weiterhin hat jeder Parameter einen Label. Gut, damit bekomme ich zur Laufzeit meine Controls.

Ich lese also meine Prüfarten ein und erstelle mir für jede Prüfart ein eigenes TabSheet in einem Tabcontrol (kann man in WinForms die Tabs/Reiter unsichtbar machen?). Auf dem Tabsheet (oder Panel) erzeuge ich je Prüfart die Controls und binde jedes Control an die entsprechende Property. Zusätzlich klatsche ich auf jedes Panel meine Combobox, um die Parametersätze auszuwählen.

So. Nun noch das Formular: 1x Splitter. Linke Seite die Prüfarten (TreeView eignet sich bei vielen, sonst eine Listbox). Reche Seite das Tabcontrol mit den Tabsheets. Wechsel im TreeView => Anzeigen des entsprechendes Tabsheets.

[Matze]

Hallo,

pro Parametersatz ein TabSheet zu generieren kommt für mich nicht in Frage. Das wären 100 - 200 TabSheets in meiner Anwendung. Das geht sicherlich auf die Performance. Zumal die TabSheets alle identisch aussehen würden, nur das Binding wäre anders.

Grüße
Matze