Objets de liaison définis dans le code-behind

Question

J'ai un objet qui est instancié dans le code derrière, par exemple, le XAML est appelé window.xaml et dans le window.xaml.cs

protected Dictionary<string, myClass> myDictionary;

Comment puis-je lier cet objet à une vue de liste, par exemple, en utilisant uniquement des balises XAML ?

Mise à jour :

(C'est exactement ce que j'ai dans mon code de test) :

<Window x:Class="QuizBee.Host.Window1"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Title="{Binding windowname}" Height="300" Width="300"
    DataContext="{Binding RelativeSource={RelativeSource Self}}">
    <Grid>
    </Grid>
</Window>

Et dans codebehind

public partial class Window1 : Window
{
    public const string windowname = "ABCDEFG";

    public Window1()
    {
        InitializeComponent();
    }
}

Supposons que le titre devrait devenir "ABCDEFG", n'est-ce pas ? mais il ne montre rien.

Answer 1

Il y a un moyen beaucoup plus facile de le faire. Vous pouvez attribuer un nom à votre fenêtre ou à votre UserControl, puis lier par ElementName.

Window1.xaml

<Window x:Class="QuizBee.Host.Window1"
        x:Name="Window1"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">

    <ListView ItemsSource="{Binding ElementName=Window1, Path=myDictionary}" />
</Window>

Window1.xaml.cs

public partial class Window1:Window
{
    // the property must be public, and it must have a getter & setter
    public Dictionary<string, myClass> myDictionary { get; set; }

    public Window1()
    {
        // define the dictionary items in the constructor
        // do the defining BEFORE the InitializeComponent();

        myDictionary = new Dictionary<string, myClass>()
        {
            {"item 1", new myClass(1)},
            {"item 2", new myClass(2)},
            {"item 3", new myClass(3)},
            {"item 4", new myClass(4)},
            {"item 5", new myClass(5)},
        }; 

        InitializeComponent();
    }
}

Answer 2

Vous pouvez définir le DataContext de votre contrôle, formulaire, etc. comme suit :

DataContext="{Binding RelativeSource={RelativeSource Self}}"

Clarification :

La définition du contexte de données à la valeur ci-dessus doit être effectuée au niveau de l'élément qui "possède" le code derrière - ainsi, pour une fenêtre, vous devez le définir dans la déclaration de la fenêtre.

J'ai fait fonctionner votre exemple avec ce code :

<Window x:Class="MyClass"
  Title="{Binding windowname}"
  DataContext="{Binding RelativeSource={RelativeSource Self}}"
  Height="470" Width="626">

Le DataContext défini à ce niveau est ensuite hérité par tous les éléments de la fenêtre (à moins que vous ne le modifiiez explicitement pour un élément enfant). Ainsi, après avoir défini le DataContext de la fenêtre, vous devriez être en mesure d'effectuer une liaison directe avec le CodeBehind. propriétés à partir de n'importe quel contrôle de la fenêtre.

Answer 3

Bien que la réponse de Guy soit correcte (et corresponde probablement à 9 cas sur 10), il convient de noter que si vous essayez de faire cela à partir d'un contrôle dont le DataContext est déjà défini plus haut dans la pile, vous le réinitialiserez lorsque vous redéfinirez le DataContext sur lui-même :

DataContext="{Binding RelativeSource={RelativeSource Self}}"

Cela aura bien sûr pour effet de casser vos fixations existantes.

Si c'est le cas, vous devez définir le paramètre RelativeSource sur le contrôle que vous essayez de lier, plutôt que sur son parent.

c'est-à-dire pour lier les propriétés d'un UserControl :

Binding Path=PropertyName, 
        RelativeSource={RelativeSource FindAncestor, AncestorType={x:Type UserControl}}

Étant donné qu'il est actuellement difficile de comprendre ce qui se passe avec la liaison de données, il est utile de garder cela à l'esprit même si vous trouvez que le réglage de la liaison de données n'est pas toujours facile. RelativeSource={RelativeSource Self} fonctionne actuellement :)

Answer 4

Juste une petite clarification supplémentaire : Une propriété sans 'get' ou 'set' ne pourra pas être liée.

J'affronte le cas comme celui de l'auteur de la question. Et je dois avoir les éléments suivants pour que la liaison fonctionne correctement :

//(1) Declare a property with 'get','set' in code behind
public partial class my_class:Window {
  public String My_Property { get; set; }
  ...

//(2) Initialise the property in constructor of code behind
public partial class my_class:Window {
  ...
  public my_class() {
     My_Property = "my-string-value";
     InitializeComponent();
  }

//(3) Set data context in window xaml and specify a binding
<Window ...
DataContext="{Binding RelativeSource={RelativeSource Self}}">
  <TextBlock Text="{Binding My_Property}"/>
</Window>

Answer 5

Définir un convertisseur :

public class RowIndexConverter : IValueConverter
{
    public object Convert( object value, Type targetType,
                           object parameter, CultureInfo culture )
    {
        var row = (IDictionary<string, object>) value;
        var key = (string) parameter;
        return row.Keys.Contains( key ) ? row[ key ] : null;
    }

    public object ConvertBack( object value, Type targetType,
                               object parameter, CultureInfo culture )
    {
        throw new NotImplementedException( );
    }
}

Lier à une définition personnalisée d'un dictionnaire. Il y a beaucoup de surcharges que j'ai omises, mais l'indexeur est le plus important, car il émet l'événement de changement de propriété lorsque la valeur est modifiée. Ceci est nécessaire pour la liaison source à cible.

public class BindableRow : INotifyPropertyChanged, IDictionary<string, object>
{
    private Dictionary<string, object> _data = new Dictionary<string, object>( );

    public object Dummy   // Provides a dummy property for the column to bind to
    {
        get
        {
            return this;
        }
        set
        {
            var o = value;
        }
    }

    public object this[ string index ]
    {
        get
        {
            return _data[ index ];
        }
        set
        {
            _data[ index ] = value;
            InvokePropertyChanged( new PropertyChangedEventArgs( "Dummy" ) ); // Trigger update
        }
    }

}

Dans votre fichier .xaml, utilisez ce convertisseur. Il faut d'abord le référencer :

<UserControl.Resources>
    <ViewModelHelpers:RowIndexConverter x:Key="RowIndexConverter"/>
</UserControl.Resources>

Ainsi, par exemple, si votre dictionnaire contient une entrée dont la clé est "Nom", pour se lier à elle, utilisez

<TextBlock  Text="{Binding Dummy, Converter={StaticResource RowIndexConverter}, ConverterParameter=Name}">