Discussion :

[pmorestin]

Bonjour, voici ma problématique:

J'utilise MVVM et je veux afficher ds un objet de type GRID (? à voir), des données (EF+RIA ) du genre.... List<List<String>>. Par exemple:
C1R1 |C2R1 |C3R1 |C4R1 |C5R1
C1R2 |C2R2 |C3R2 |C4R2 |C5R2... mais je ne connais pas au départ le nb de colonnes....

J'ai bien des idées: customControl, dependyProperty... mais je ne sais pas comment partir...
- faut-t-il utiliser un GRID? et comment faire puisque ColumnDefinition ne propose pas de binding ...
- un DataGrid ?....là je vois pas comment faire...
Bref si quelqu'un a déja eu cette problématique ou une piste... merci d'avance

PM

[Pragmateek]

Une méthode brute mais efficace est de générer des objets dynamiquement avec autant de propriétés que nécessaire.

Une implémentation de ce principe : http://blog.bodurov.com/How-to-bind-...of-IDictionary

Le problème principal reste bien sûr la maintenance d'un code aussi bas niveau.
Donc à bien encapsuler dans la couche de données afin d'éviter tout couplage.

[pmorestin]

Ok, merci pour cette 1ere approche. Mais j'aurais préféré une solution avec un binding directement en xaml...car ViewModel et pas de code dans le c# de ma View. -> et la solution n'est-ce pas de passer par un control personnalisé de type GRID avec des DependencyProperty ....?

[Samuel Blanchard]

Bonjour,

Si tu connais la taille exacte d'une colonne tu peux utiliser un WrapPanel en fixant La taille dynamiquement sur nombre de colonne * taille d'une colonne; Il arrangera les cellules tout seul et tu pourras utiliser le Binding en le couplant à un ItemsControl ou une ListBox.

Sinon si tu veux absolument utiliser le Binding, tu ne pourras pas utiliser un Grid, mais rien ne t'empeche de créer ton propre Panel (plus adapté) ou un CustomControl à la rigueur (plus facile peut être).

[pmorestin]

Merci.
Effectivement, mon but est d'avoir un control dont la propriété column binde une valeur pour que celui-ci puisse redessiner dynamiquement son nombre de colonnes ...me suis-je bien fais comprendre .....

[Samuel Blanchard]

Voici l'exemple dont je te parlais tout à l'heure

coté XAML :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
<ItemsControl ItemsSource="{Binding Table.Datas}">
    <ItemsControl.ItemsPanel>
        <ItemsPanelTemplate>
            <controlsToolkit:WrapPanel ItemWidth="{Binding Table.ColumnWidth}" Width="{Binding Table.TableWidth}"></controlsToolkit:WrapPanel>
        </ItemsPanelTemplate>                
    </ItemsControl.ItemsPanel>                    
</ItemsControl>

coté CS :

la structure des données :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
 
public class Table : INotifyPropertyChanged
{
    public Table()
    {
        this.Datas = new ObservableCollection<string>();
    }
 
    public ObservableCollection<string> Datas
    {
        get;
        set;
    }
 
    public int ColumnsByRow
    {
        get
        {
            return this.columnsByRow;
        }
 
        set
        {
            this.columnsByRow = value;
            this.RaisePropertyChanged("ColumnsByRow");
            this.RaisePropertyChanged("TableWidth");
        }
    }
 
    private int columnsByRow = 4;
 
    /// <summary>
    /// Taille de la colonne
    /// </summary>
 
    public double ColumnWidth
    {
        get
        {
            return this.columnWidth;
        }
 
        set
        {
            this.columnWidth = value;
            this.RaisePropertyChanged("ColumnWidth");
            this.RaisePropertyChanged("TableWidth");
        }
    }
 
    private double columnWidth = 0;
 
 
    public double TableWidth
    {
        get
        {
            return this.ColumnWidth * this.ColumnsByRow;
        }
    }
 
    public event PropertyChangedEventHandler PropertyChanged;
 
    /// <summary>
    /// Raise
    /// </summary>
    /// <param name="propertyName"></param>
 
    protected void RaisePropertyChanged(string propertyName)
    {
        if (this.PropertyChanged != null)
        {
            this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
        }
    }
}

la mise en place

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
 
public partial class MainPage : UserControl
{
    public MainPage()
    {
        InitializeComponent();
        this.LayoutRoot.DataContext = this;
 
        Table table = new Table();
 
        // les données
 
        ObservableCollection<string> datas = new ObservableCollection<string>();
 
 
        datas.Add("Super 1");
        datas.Add("Super 2");
        datas.Add("Super 3");
        datas.Add("Super 4");
 
        table.Datas = datas;
 
        table.ColumnWidth = 100;
        table.ColumnsByRow = 3;
 
        this.Table = table;
    }
 
    public Table Table
    {
        get { return (Table)GetValue(TableProperty); }
        set { SetValue(TableProperty, value); }
    }
 
    // Using a DependencyProperty as the backing store for Table.  This enables animation, styling, binding, etc...
    public static readonly DependencyProperty TableProperty =
        DependencyProperty.Register("Table", typeof(Table), typeof(MainPage), new PropertyMetadata(null));
 
}

[pmorestin]

ok et merci....

Malheureusement ce n'est pas tout a fait ce que je veux.
Il me faut un composant de type GRID mais dont le nombre de colonne et de ligne dépendrait du résultat d'une List<List<String>>.

Et même sans cela, ce composant doit pouvoir augmenter ou diminuer son nombre de colonne directement par binding sur une valeur d'un slider par exemple.