Liaison statique de la propriété et de la mise en œuvre de INotifyPropertyChanged

Je suis en train de lier une propriété statique de la classe à un certain contrôle. J'ai tryied un peu de mise en oeuvre, mais chacun a son problème:

Tous les exemples utilisent la prochaine XAML:

 <Label Name="label1" Content="{Binding Path=text}"/>

1ère approche - ne pas utiliser de INotifyPropertyChanged

public class foo1
{
    public static string text { get; set; }
}

Le problème est que lorsque 'texte' propery changements de contrôle n'est pas averti.

Deuxième approche consiste à utiliser INotifyPropertyChanged

public class foo1 : INotifyPropertyChanged
{
    public event PropertyChangedEventHandler PropertyChanged;
    public void OnPropertyChanged(string propertyName)
    {
        if (PropertyChanged != null)
            PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
    }

    private static string _text;
    public static string text
    {
        get { return _text; }
        set
        {
            _text = value;
            OnPropertyChanged("text");
        }
    }
}

Cela ne veut pas compiler, car OnPropertyChanged() la méthode n'est pas statique et qu'il est appelé à l'intérieur d'une méthode statique.

Deuxième approche essayez 2: faire OnPropertyChanged() la méthode statique => cela ne veut pas compiler, car OnPropertyChanged() est statique et est maintenant, il essaie d'utiliser 'PropertyChanged' événement qui n'est pas statique.

Deuxième approche essayez 3: faire de "PropertyChanged' événement statique => cela ne veut pas compiler, car la classe n'implémente pas 'INotifyPropertyChanged.PropertyChanged de l'événement (l'événement est défini dans 'interface INotifyPropertyChanged est pas statique, mais ici, il est statique).

À ce point, j'ai renoncé.

Des Idées?

OriginalL'auteur dana | 2011-01-13

  1. 11

    je te suggère de vous avez juste un exemple-retour de propriété de votre propriété statique comme ceci:

    private static string _text;
public string text
{
    get { return _text; }
    set
    {
        _text = value;
        OnPropertyChanged("text");
    }
}

    Toutefois, cela rend l'ensemble de la liaison relativement inutile car les notifications de changement sont créés uniquement dans une instance de la classe et pas tous les cas. Ainsi, seules les liaisons qui lient à la propriété sur l'instance spécifique sur lequel il a été modifié sera mise à jour.

    Une meilleure méthode serait d'utiliser un singleton comme on peut le voir ici.

    OriginalL'auteur H.B.

  2. 2

    À l'aide d'un singleton va être la méthode la plus simple et la plus propre à mettre en œuvre. Si vous voulez aller à la dure, sans l'aide d'un singleton, vous pouvez utiliser la syntaxe suivante.

    Créer un statique PropertyChangedEventHandler qui est appelée à partir de votre propriété statique. Lorsque vous créez une nouvelle instance de votre classe, vous inscrire pour recevoir un appel de retour de l'événement statique. Lorsque vous obtenez le rappel, appel OnPropertyChanged("texte"). Le GROS problème avec cela est que vous devez utiliser une WeakReference lorsque vous vous inscrivez pour l'événement statique. Sinon, votre objet restera toujours. J'ai sauté cette étape dans le code.

    La raison pour laquelle vous devez le transmettre à l'instance de l'événement est parce que, qui a déjà enregistré le NotifyPropertyChanged besoin de savoir qui l '"expéditeur" (c'est à dire l'instance de toto1 avec l'instance de la propriété)

    public class foo1 : System.ComponentModel.INotifyPropertyChanged
{
    //static property
    private static string _text = "static string";
    public static string static_text
    {
        get
        {
            return _text;
        }
        set
        {
            _text = value;
            OnStaticPropertyChanged("static_text");
        }
    }
    private static System.ComponentModel.PropertyChangedEventHandler staticpropChanged;
    static protected void OnStaticPropertyChanged(string pname)
    {
        System.ComponentModel.PropertyChangedEventArgs e = new System.ComponentModel.PropertyChangedEventArgs(pname);
        System.ComponentModel.PropertyChangedEventHandler h = staticpropChanged;
        if (h != null)
            h(null, e);

    }
    public foo1()
    {
        //really should use a weakreference here.. but leaving it out
        //for simplicity
        staticpropChanged += foo1_staticpropChanged;
    }

    void foo1_staticpropChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
    {
        //map the static name to the instance name
        if(e.PropertyName == "static_text") OnPropertyChanged("text");
    }
    //instance-property forwards to static
    public string text
    {
        get { return foo1.static_text; }
        set { foo1.static_text = value; }
    }
    thumbs up j'ai mis en place un peu différente voir ci-dessous

    OriginalL'auteur shimpossible

  3. 0
        public static String StatusInformation
    {
        get { return _StatusInformation; }
        set { _StatusInformation = value; OnStaticPropertyChanged("StatusText"); }
    }

    #region Handlig Static Properties Changed
    private static System.ComponentModel.PropertyChangedEventHandler staticpropChanged;
    static protected void OnStaticPropertyChanged(string pname)
    {
        System.ComponentModel.PropertyChangedEventArgs e = new System.ComponentModel.PropertyChangedEventArgs(pname);
        System.ComponentModel.PropertyChangedEventHandler h = staticpropChanged;
        if (h != null)
            h(null, e);

    }
    private void Handler_PropertyChange(object sender, System.ComponentModel.PropertyChangedEventArgs e)
    {
        NotifyPropertyChanged(e.PropertyName);
    }
    #endregion
    public string StatusText
    {
        get { return ExchangeServices.StatusInformation; }
        set { ExchangeServices.StatusInformation = value; }
    }

    de cette façon, je n'avais pas à faire la manipulation dans l'événement.
    c'était vraiment utile de créer une barre de statut pour l'ensemble de mon programme et de le mettre à jour à partir de n'importe où et de contrôle de l'utilisateur dans ma toujours croissante programme.

    Merci à shimpossible

    OriginalL'auteur New Bee