WPF case de liaison

Vous avez besoin d'une propriété de dépendance à cela:

public BindingList<User> Users
{
    get { return (BindingList<User>)GetValue(UsersProperty); }
    set { SetValue(UsersProperty, value); }
}

public static readonly DependencyProperty UsersProperty =
    DependencyProperty.Register("Users", typeof(BindingList<User>), 
      typeof(OptionsDialog));

Une fois que c'est fait, vous pouvez lier la case à cocher à la propriété de dépendance:

<CheckBox x:Name="myCheckBox"
          IsChecked="{Binding ElementName=window1, Path=CheckBoxIsChecked}" />

Pour que cela fonctionne vous devez nom de votre Fenêtre ou votre UserControl dans son ouverture de la balise, et d'utiliser ce nom dans le ElementName paramètre.

Avec ce code, à chaque fois que vous modifiez la propriété sur le code côté, vous pouvez modifier la zone de texte. Aussi, chaque fois que vous cochez/décochez la zone de texte, la Propriété de Dépendance à changer.

EDIT:

Un moyen facile de créer une dépendance de la propriété est de taper le fragment de propdp, ce qui vous donnera le code général des Propriétés de Dépendance.

Tout le code:

XAML:

<Window x:Class="StackOverflowTests.Window1"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Title="Window1" x:Name="window1" Height="300" Width="300">
    <Grid>
        <StackPanel Orientation="Vertical">
            <CheckBox Margin="10"
                      x:Name="myCheckBox"
                      IsChecked="{Binding ElementName=window1, Path=IsCheckBoxChecked}">
                Bound CheckBox
            </CheckBox>
            <Label Content="{Binding ElementName=window1, Path=IsCheckBoxChecked}"
                   ContentStringFormat="Is checkbox checked? {0}" />
        </StackPanel>
    </Grid>
</Window>

C#:

using System.Windows;

namespace StackOverflowTests
{
    ///<summary>
    ///Interaction logic for Window1.xaml
    ///</summary>
    public partial class Window1 : Window
    {
        public bool IsCheckBoxChecked
        {
           get { return (bool)GetValue(IsCheckBoxCheckedProperty); }
           set { SetValue(IsCheckBoxCheckedProperty, value); }
        }

        //Using a DependencyProperty as the backing store for 
         //IsCheckBoxChecked.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty IsCheckBoxCheckedProperty =
            DependencyProperty.Register("IsCheckBoxChecked", typeof(bool), 
            typeof(Window1), new UIPropertyMetadata(false));

        public Window1()
        {             
            InitializeComponent();
        }
    }
}

Remarquez comment le seul code derrière est la Propriété de Dépendance. L'étiquette et la case à cocher sont liés. Si la case à cocher changements, les modifications de l'étiquette trop.

Bonjour c'est mon premier temps à poster, donc s'il vous plaît être patient:
ma réponse a été de créer une propriété simple:

public bool Checked { get; set; }

Puis de définir les données de contexte de la Case (appelé cb1):

cb1.DataContext = this;

Puis de lier la propriété IsChecked dans le xaml

IsChecked="{Binding Checked}"

Le code ressemble à ceci:

XAML

<CheckBox x:Name="cb1"
          HorizontalAlignment="Left"
          Margin="439,81,0,0"
          VerticalAlignment="Top"
          Height="35" Width="96"
          IsChecked="{Binding Checked}"/>

Code derrière

public partial class MainWindow : Window
{
    public bool Checked { get; set; }

    public MainWindow()
    {
        InitializeComponent();

        cb1.DataContext = this;
    }

    private void myyButton_Click(object sender, RoutedEventArgs e)
    {
        MessageBox.Show(Checked.ToString());
    }
}

Voici un post qui montre un exemple simple de la liaison de données pour une propriété IsChecked de deux cases à cocher, qui sont mutuellement exclusifs.

http://www.helplessautomation.com/2011/01/wpf-coding-mutually-exclusive-check-boxes-with-data-binding/

Espère que ça aide.

Cela fonctionne pour moi (l'essentiel de code inclus seulement, de remplir plus à vos besoins):

En XAML un contrôle utilisateur est défini:

<UserControl x:Class="Mockup.TestTab" ......>
    <!-- a checkbox somewhere within the control -->
    <!-- IsChecked is bound to Property C1 of the DataContext -->
    <CheckBox Content="CheckBox 1" IsChecked="{Binding C1, Mode=TwoWay}" />
</UserControl>

Dans le code derrière pour UserControl

public partial class TestTab : UserControl
{
    public TestTab()
    {
        InitializeComponent();  //the standard bit

    //then we set the DataContex of TestTab Control to a MyViewModel object
    //this MyViewModel object becomes the DataContext for all controls
         //within TestTab ... including our CheckBox
         DataContext = new MyViewModel(....);
    }

}

Quelque part dans une solution de classe MyViewModel est défini

public class MyViewModel : INotifyPropertyChanged 
{
    public event PropertyChangedEventHandler PropertyChanged;
    private bool m_c1 = true;

    public bool C1 {
        get { return m_c1; }
        set {
            if (m_c1 != value) {
                m_c1 = value;
                if (PropertyChanged != null)
                    PropertyChanged(this, new PropertyChangedEventArgs("C1"));
            }
        }
    }
}