Bindung DataGrid ObservableCollection<Wörterbücher>

Ich habe eine ObservableCollection<Dictionary> wollen und binden Sie es an einen DataGrid.

ObservableDictionary<String,Object> NewRecord1 = new ObservableDictionary<string,object>();

Dictionary<String,Object> Record1 = new Dictionary<string,object>();
Record1.Add("FirstName", "FName1");
Record1.Add("LastName", "LName1");
Record1.Add("Age", "32");

DictRecords.Add(Record1);

Dictionary<String, Object> Record2 = new Dictionary<string, object>();
NewRecord2.Add("FirstName", "FName2");
NewRecord2.Add("LastName", "LName2");
NewRecord2.Add("Age", "42");

DictRecords.Add(Record2);

Wollte ich die Schlüssel zu den header der DataGrid und die Werte der einzelnen Dictionary Artikel auf die Zeilen. Einstellung der ItemsSource funktioniert nicht.

DataGrid einfach nicht unterstützen. Wenn Sie brauchen, dynamische Spalten gibt es andere Möglichkeiten.
Ich brauche dynamischen Spalten. Können Sie bitte zeigen Sie mir andere Wege, dies zu tun?
In deinem Beispiel sieht es aus wie Sie ' re hinzufügen von Personen in das raster. Ich nehme an, Sie brauchen dynamische Spalten, weil Sie brauchen werden, um andere Dinge als Personen, die im gleichen raster eine andere Zeit? Wenn dem so ist, wäre es akzeptabel, um eine Person Klasse, und ähnliche Klassen für alle anderen Elemente, die Sie anzeigen müssen (anstatt Dictionary<>)?
Ja, du hast Recht. Eigentlich wäre es test Ergebnisse - mehrere tests werden in der Folge, und derzeit Laufenden test Ergebnis wäre in der Tabellenansicht dargestellt. Ich hielt das hinzufügen von Ergebnis-Klasse für jeden test-Ergebnis. Ich bin verwirrt, wie ich die Daten aktualisieren, die Bindung auf der Grundlage der test ausgeführt wird. Ich wollte nicht, fügen Sie eine select-Anweisung in der Ansicht, um das entsprechende Objekt zu binden - wie dies erforderlich wäre, mich zu aktualisieren, jedes mal, wenn wir einen neuen test. ich dachte, das war nicht ein gutes design. Eine bessere Möglichkeit des Umgangs mit diesen?
Würden Sie wirklich brauchen, verschiedene Klassen für die verschiedenen tests? Könnte Sie aktualisieren Sie Ihren Beitrag, indem ein Beispiel einer solchen Klasse?

InformationsquelleAutor Manoj | 2013-01-05

  1. 23

    Könnten Sie eine bindbare dynamisches Wörterbuch. Dadurch werden jeden Wörterbuch-Eintrag als eine Eigenschaft.

    ///<summary>
///Bindable dynamic dictionary.
///</summary>
public sealed class BindableDynamicDictionary : DynamicObject, INotifyPropertyChanged
{
    ///<summary>
    ///The internal dictionary.
    ///</summary>
    private readonly Dictionary<string, object> _dictionary;

    ///<summary>
    ///Creates a new BindableDynamicDictionary with an empty internal dictionary.
    ///</summary>
    public BindableDynamicDictionary()
    {
        _dictionary = new Dictionary<string, object>();
    }

    ///<summary>
    ///Copies the contents of the given dictionary to initilize the internal dictionary.
    ///</summary>
    ///<param name="source"></param>
    public BindableDynamicDictionary(IDictionary<string, object> source)
    {
        _dictionary = new Dictionary<string, object>(source);
    }
    ///<summary>
    ///You can still use this as a dictionary.
    ///</summary>
    ///<param name="key"></param>
    ///<returns></returns>
    public object this[string key]
    {
        get
        {
            return _dictionary[key];
        }
        set
        {
            _dictionary[key] = value;
            RaisePropertyChanged(key);
        }
    }

    ///<summary>
    ///This allows you to get properties dynamically.
    ///</summary>
    ///<param name="binder"></param>
    ///<param name="result"></param>
    ///<returns></returns>
    public override bool TryGetMember(GetMemberBinder binder, out object result)
    {
        return _dictionary.TryGetValue(binder.Name, out result);
    }

    ///<summary>
    ///This allows you to set properties dynamically.
    ///</summary>
    ///<param name="binder"></param>
    ///<param name="value"></param>
    ///<returns></returns>
    public override bool TrySetMember(SetMemberBinder binder, object value)
    {
        _dictionary[binder.Name] = value;
        RaisePropertyChanged(binder.Name);
        return true;
    }

    ///<summary>
    ///This is used to list the current dynamic members.
    ///</summary>
    ///<returns></returns>
    public override IEnumerable<string> GetDynamicMemberNames()
    {
        return _dictionary.Keys;
    }

    public event PropertyChangedEventHandler PropertyChanged;

    private void RaisePropertyChanged(string propertyName)
    {
        var propChange = PropertyChanged;
        if (propChange == null) return;
        propChange(this, new PropertyChangedEventArgs(propertyName));
    }
}

    Dann können Sie es verwenden, wie diese:

        private void testButton1_Click(object sender, RoutedEventArgs e)
    {
        //Creating a dynamic dictionary.
        var dd = new BindableDynamicDictionary();

        //access like any dictionary
        dd["Age"] = 32;

        //or as a dynamic
        dynamic person = dd;

        //Adding new dynamic properties.  
        //The TrySetMember method is called.
        person.FirstName = "Alan";
        person.LastName = "Evans";

        //hacky for short example, should have a view model and use datacontext
        var collection = new ObservableCollection<object>();
        collection.Add(person);
        dataGrid1.ItemsSource = collection;
    }

    Datagrid-muss benutzerdefinierte code für den Aufbau der Spalten:

    XAML:

    <DataGrid AutoGenerateColumns="True" Name="dataGrid1" AutoGeneratedColumns="dataGrid1_AutoGeneratedColumns" />

    AutoGeneratedColumns Veranstaltung:

        private void dataGrid1_AutoGeneratedColumns(object sender, EventArgs e)
    {
        var dg = sender as DataGrid;
        var first = dg.ItemsSource.Cast<object>().FirstOrDefault() as DynamicObject;
        if (first == null) return;
        var names = first.GetDynamicMemberNames();
        foreach(var name in names)
        {
            dg.Columns.Add(new DataGridTextColumn { Header = name, Binding = new Binding(name) });            
        }            
    }
    BindableDynamicDictionary ist perfekt für meine Anforderung. Vielen Dank für das Beispiel mit den Kommentaren.
    Warum verwenden Sie lokale Variablen propChange im RaisePropertyChanged und names im dataGrid1_AutoGeneratedColumns() ?
    Es gibt keine Anforderung für Sie. Ich denke, ich dachte, Sie machten es besser lesbar an der Zeit.
    Einfach Fragen, wenn Sie einfach die änderung-Dictionary Schlüssel Typ von Objekt auf eine Art, die implementiert IPropertyChanged würde nicht dieses Problem lösen? So wird jedes Element verkabelt werden über IPropertyChanged
    Auch eine Taste, ändert sich der Wert, während in einem Wörterbuch, ist eine schlechte Idee, also ich bin mir nicht sicher wie das funktionieren würde.

    InformationsquelleAutor weston

  2. 1

    Basierend auf westons Antwort kam ich auf eine andere Lösung ohne Verwendung einer benutzerdefinierten BindableDynamicDictionary Klasse.

    Gibt es eine Klasse namens ExpandoObject im namespace System.Dynamic(die ist Massiv in ASP.NET).

    Es im Grunde genommen die gleiche Sache wie westons BindableDynamicDictionary mit dem Nachteil, nicht über den index-operator zur Verfügung, da es explizit implementiert die Schnittstelle IDictionary<string, object>

    private void MyDataGrid_AutoGeneratedColumns(object sender, EventArgs e)
{
  var dg = sender as DataGrid;
  dg.Columns.Clear();
  var first = dg.ItemsSource.Cast<object>().FirstOrDefault() as IDictionary<string, object>;
  if (first == null) return;
  var names = first.Keys;
  foreach (var name in names)
  {
    dg.Columns.Add(new DataGridTextColumn { Header = name, Binding = new Binding(name) });
  }
}

    Beachten Sie, dass der einzige Unterschied hier ist, dass Sie das wirken des ExpandoObject zu IDictionary<string, object> Zugang/Werte hinzufügen oder Eigenschaften über den index-operator.

    InformationsquelleAutor Thomas Eggemann

Schreibe einen Kommentar