So füllen Sie ein WPF-Gitter basierend auf einem 2-dimensionalen Array

Hier ist ein Steuerelement mit dem Namen DataGrid2D, das basierend auf einem 2D-Element oder gefüllt werden kann
1D-Array (oder etwas, das die IList-Schnittstelle implementiert). Die Unterklassen sind DataGrid und fügen eine Eigenschaft namens ItemsSource2D hinzu, die für die Bindung von 2D- oder 1D-Quellen verwendet wird. Bibliothek kann heruntergeladen werden hier und Quellcode kann heruntergeladen werden hier .

Um es zu verwenden, fügen Sie einfach einen Verweis auf DataGrid2DLibrary.dll hinzu, und fügen Sie diesen Namespace hinzu

xmlns:dg2d="clr-namespace:DataGrid2DLibrary;Assembly=DataGrid2DLibrary"

erstellen Sie dann ein DataGrid2D und binden Sie es wie folgt an Ihr IList-, 2D-Array oder 1D-Array

<dg2d:DataGrid2D Name="dataGrid2D"
                 ItemsSource2D="{Binding Int2DList}"/>

OLD POST
Hier ist eine Implementierung, die ein 2D-Array an das WPF-Datenraster binden kann. 

Angenommen, wir haben dieses 2D-Array

private int[,] m_intArray = new int[5, 5];
...
for (int i = 0; i < 5; i++)
{
    for (int j = 0; j < 5; j++)
    {
        m_intArray[i,j] = (i * 10 + j);
    }
}

Und dann möchten wir dieses 2D-Array an das WPF-DataGrid binden, und die von uns vorgenommenen Änderungen werden im Array wiedergegeben. Dazu habe ich die Ref-Klasse von Eric Lippert aus this thread verwendet.

public class Ref<T>  
{ 
    private readonly Func<T> getter;  
    private readonly Action<T> setter; 
    public Ref(Func<T> getter, Action<T> setter)  
    {  
        this.getter = getter;  
        this.setter = setter;  
    } 
    public T Value { get { return getter(); } set { setter(value); } }  
} 

Dann erstellte ich eine statische Hilfsklasse mit einer Methode, die ein 2D-Array verwenden und ein DataView mit der obigen Ref-Klasse zurückgeben konnte.

public static DataView GetBindable2DArray<T>(T[,] array)
{
    DataTable dataTable = new DataTable();
    for (int i = 0; i < array.GetLength(1); i++)
    {
        dataTable.Columns.Add(i.ToString(), typeof(Ref<T>));
    }
    for (int i = 0; i < array.GetLength(0); i++)
    {
        DataRow dataRow = dataTable.NewRow();
        dataTable.Rows.Add(dataRow);
    }
    DataView dataView = new DataView(dataTable);
    for (int i = 0; i < array.GetLength(0); i++)
    {
        for (int j = 0; j < array.GetLength(1); j++)
        {
            int a = i;
            int b = j;
            Ref<T> refT = new Ref<T>(() => array[a, b], z => { array[a, b] = z; });
            dataView[i][j] = refT;
        }
    }
    return dataView;
}

Dies wäre fast zum Binden ausreichend, aber der Pfad in der Bindung verweist auf das Ref-Objekt statt auf den Ref.Value-Wert, den wir benötigen. Daher müssen wir dies ändern, wenn die Spalten generiert werden.

<DataGrid Name="c_dataGrid"
          RowHeaderWidth="0"
          ColumnHeaderHeight="0"
          AutoGenerateColumns="True"
          AutoGeneratingColumn="c_dataGrid_AutoGeneratingColumn"/>

private void c_dataGrid_AutoGeneratingColumn(object sender, DataGridAutoGeneratingColumnEventArgs e)
{
    DataGridTextColumn column = e.Column as DataGridTextColumn;
    Binding binding = column.Binding as Binding;
    binding.Path = new PropertyPath(binding.Path.Path + ".Value");
}

Und danach können wir verwenden

c_dataGrid.ItemsSource = BindingHelper.GetBindable2DArray<int>(m_intArray);

Und die Ausgabe wird so aussehen

Alle Änderungen, die in der Variablen DataGrid vorgenommen wurden, werden im m_intArray wiedergegeben.

Für DataGrid habe ich eine kleine Bibliothek mit angefügten Eigenschaften geschrieben. Hier ist die Quelle

Beispiel, wo Data2D int[,] ist:

<DataGrid HeadersVisibility="None"
          dataGrid2D:Source2D.ItemsSource2D="{Binding Data2D}" />

Rendert:

Sie können diesen Link überprüfen: http://www.thinkbottomup.com.au/site/blog/Game_of_Life_in_XAML_WPF_using_embedded_Python

Wenn Sie eine Liste in einer Liste verwenden, können Sie mit myList [x] [y] auf eine Zelle zugreifen.

Hier ist eine andere Lösung, die auf der Antwort von Meleak basiert, jedoch ohne einen AutoGeneratingColumn-Ereignishandler im Code hinter jeder gebundenen DataGrid:

public static DataView GetBindable2DArray<T>(T[,] array)
{
    var table = new DataTable();
    for (var i = 0; i < array.GetLength(1); i++)
    {
        table.Columns.Add(i+1, typeof(bool))
                     .ExtendedProperties.Add("idx", i); // Save original column index
    }
    for (var i = 0; i < array.GetLength(0); i++)
    {
        table.Rows.Add(table.NewRow());
    }

    var view = new DataView(table);
    for (var ri = 0; ri < array.GetLength(0); ri++)
    {
        for (var ci = 0; ci < array.GetLength(1); ci++)
        {
            view[ri][ci] = array[ri, ci];
        }
    }

    // Avoids writing an 'AutogeneratingColumn' handler
    table.ColumnChanged += (s, e) => 
    {
        var ci = (int)e.Column.ExtendedProperties["idx"]; // Retrieve original column index
        var ri = e.Row.Table.Rows.IndexOf(e.Row); // Retrieve row index

        array[ri, ci] = (T)view[ri][ci];
    };

    return view;
}