Remplir un Datagrid avec des colonnes dynamiques

Il y a au moins trois façons de le faire:

1. Modifier les colonnes du DataGrid manuellement à partir du code-derrière
2. utiliser un DataTable comme source Itemss*

3. utilisez un CustomTypeDescriptor

   * recommandé pour la simplicité

1ère approche: utilisez code-behind pour générer les colonnes de DataGrid à l'exécution. C'est simple à mettre en œuvre, mais peut-être se sent un peu hackish, surtout si vous utilisez MVVM. Vous avez donc votre DataGrid avec des colonnes fixes:

<DataGrid x:Name="grid">
    <DataGrid.Columns>
        <DataGridTextColumn Binding="{Binding id}" Header="id" />
        <DataGridTextColumn Binding="{Binding image}" Header="image" />
    </DataGrid.Columns>
</DataGrid>

quand vous avez vos" noms " prêts, alors Modifiez la grille en ajoutant/supprimant des colonnes, par exemple:

// add new columns to the data grid
void AddColumns(string[] newColumnNames)
{
    foreach (string name in newColumnNames)
    {
        grid.Columns.Add(new DataGridTextColumn { 
            // bind to a dictionary property
            Binding = new Binding("Custom[" + name + "]"), 
            Header = name 
        });
    }
}

vous voulez créer une classe wrapper, qui devrait contenir la classe originale, plus un dictionnaire pour contenir les propriétés personnalisées. Disons que votre classe de rangée principale est "utilisateur", alors vous voulez une classe d'emballage quelque chose comme ceci:

public class CustomUser : User
{
    public Dictionary<string, object> Custom { get; set; }

    public CustomUser() : base()
    {
        Custom = new Dictionary<string, object>();
    }
}

peupler le ItemsSource avec une collection de cette nouvelle classe" CustomUser":

void PopulateRows(User[] users, Dictionary<string, object>[] customProps)
{
    var customUsers = users.Select((user, index) => new CustomUser {
        Custom = customProps[index];
    });
    grid.ItemsSource = customUsers;
}

donc, le liant ensemble, par exemple:

var newColumnNames = new string[] { "Name1", "Name2" };
var users = new User[] { new User { id="First User" } };
var newProps = new Dictionary<string, object>[] {
    new Dictionary<string, object> { 
        "Name1", "First Name of First User",
        "Name2", "Second Name of First User",
    },
};
AddColumns(newColumnNames);
PopulateRows(users, newProps);

2ème approche: un DataTable. Cela rend l'utilisation de ce type d'infrastructure sous le capot, mais est plus facile à utiliser. Il suffit de lier le DataGrid de ItemsSourceDataTable.DefaultView propriété:

<DataGrid ItemsSource="{Binding Data.DefaultView}" AutoGenerateColumns="True" />

alors vous pouvez définir les colonnes cependant, vous comme, par exemple:

Data = new DataTable();

// create "fixed" columns
Data.Columns.Add("id");
Data.Columns.Add("image");

// create custom columns
Data.Columns.Add("Name1");
Data.Columns.Add("Name2");

// add one row as an object array
Data.Rows.Add(new object[] { 123, "image.png", "Foo", "Bar" });

3ème approche: utilisez l'extensibilité du système de type .Net. Plus précisément, utilisez un CustomTypeDescriptor. Cela vous permet de créer un type personnalisé à l'exécution, ce qui à son tour vous permet de dire au DataGrid que votre type a les propriétés "Name1", "Name2",... "NameN", ou ce que vous voulez. Voir ici pour un exemple simple de cette approche.