Discussion :

[cyberbobby]

Bonjour,

J'ai une application qui contient des TextBlocks bindés sur des propriétés. Je souhaiterais détecter, d'une manière ou d'une autre, lorsque le texte affiché par mon TextBlock change et ce via un événement dans la vue (pas dans ma propriété). Soit au niveau du textblock ou du binding ? Est-ce possible de le détecter ?

Merci

[Skyounet]

Bonjour,

J'ai une application qui contient des TextBlocks bindés sur des propriétés. Je souhaiterais détecter, d'une manière ou d'une autre, lorsque le texte affiché par mon TextBlock change et ce via un événement dans la vue (pas dans ma propriété). Soit au niveau du textblock ou du binding ? Est-ce possible de le détecter ?

Merci

Ben dans ta vue tu t'abonnes au PropertyChanged de ton model et dans la callback tu regardes si c'est une des propriétés qui est bindé à tes TextBlocks.

[cyberbobby]

Euh, un peu de code peut-être ?

En fait, j'ai ma propriété dans un objet qui est dans mon VM.

Genre :

MonObjet.UnAutreObjet.Value;

J'ai une prop vers MonObjet dans ma VM.

[cyberbobby]

Euh ... Non ?

[Nathanael Marchand]

Il faut que le binding soit en Direction=TwoWay ou peut être ai-je mal compris la question?

[cyberbobby]

Tu as sans doute mal compris

Je parle ici d'un TextBlock.

Lorsque son texte est rafraichi :

ex, il affichait 2, puis affiche 5.

J'aimerais avoir un événement qui me prévient que la valeur a changé. (équivalent tu TextChanged pour une TextBox)

[Nathanael Marchand]

Haaan voui! En effet, autant pour moi! J'avais lu TextBox

Du coup effectivement c'est la solution de skyounet qui prime.

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
 
public class MyView
{
public MyView()
{
//TonConstructeur
 
Loaded+=ViewLoaded;
}
 
public void ViewLoaded(object sender, EventArgs e)
{
var viewmodel = DataContext as MyViewModel;
viewmodel.MyObjet.PropertyChanged+=MyTextChanged;
}
 
public void MyTextChanged(object sender, PropertyChangedEventArgs e)
{
 if(e.Property =="MyFieldOnMyObject")
    //Mon traitement ici
}
 
}

[Samuel Blanchard]

Bonjour,

Bien que la notification par VM soit la façon la plus simple et la plus élégante de détecter un changement, il peut être pratique parfois qu'une DependencyProperty d'un control (dont on a pas forcément le source) soit notifiable :

Cette technique est issu de ce blog :

http://agsmith.wordpress.com/2008/04...d-alternative/

J'ai repris le code et l'ai légèrement modifié pour Silverlight :

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
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
 
    public sealed class PropertyChangeNotifier :
    DependencyObject,
    IDisposable
    {
        #region Member Variables
        private WeakReference _propertySource;
        #endregion // Member Variables
 
        #region Constructor
        public PropertyChangeNotifier(DependencyObject propertySource, string path)
            : this(propertySource, new PropertyPath(path))
        {
        }
        public PropertyChangeNotifier(DependencyObject propertySource, DependencyProperty property)
            : this(propertySource, new PropertyPath(property))
        {
        }
        public PropertyChangeNotifier(DependencyObject propertySource, PropertyPath property)
        {
            if (null == propertySource)
                throw new ArgumentNullException("propertySource");
            if (null == property)
                throw new ArgumentNullException("property");
            this._propertySource = new WeakReference(propertySource);
            Binding binding = new Binding();
            binding.Path = property;
            binding.Mode = BindingMode.OneWay;
            binding.Source = propertySource;
            BindingOperations.SetBinding(this, ValueProperty, binding);
        }
        #endregion // Constructor
 
        #region PropertySource
        public DependencyObject PropertySource
        {
            get
            {
                try
                {
                    // note, it is possible that accessing the target property
                    // will result in an exception so i’ve wrapped this check
                    // in a try catch
                    return this._propertySource.IsAlive
                    ? this._propertySource.Target as DependencyObject
                    : null;
                }
                catch
                {
                    return null;
                }
            }
        }
        #endregion // PropertySource
 
        #region Value
        /// <summary>
        /// Identifies the <see cref=”Value”/> dependency property
        /// </summary>
        public static readonly DependencyProperty ValueProperty = DependencyProperty.Register("Value",
        typeof(object), typeof(PropertyChangeNotifier), new PropertyMetadata(null, new PropertyChangedCallback(OnPropertyChanged)));
 
        private static void OnPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            PropertyChangeNotifier notifier = (PropertyChangeNotifier)d;
            if (null != notifier.ValueChanged)
                notifier.ValueChanged(notifier, EventArgs.Empty);
        }
 
        /// <summary>
        /// Returns/sets the value of the property
        /// </summary>
        /// <seealso cref=”ValueProperty”/>
        [Description("Returns/sets the value of the property")]
        [Category("Behavior")]
        //[Bindable(true)]
        public object Value
        {
            get
            {
                return (object)this.GetValue(PropertyChangeNotifier.ValueProperty);
            }
            set
            {
                this.SetValue(PropertyChangeNotifier.ValueProperty, value);
            }
        }
        #endregion //Value
 
        #region Events
        public event EventHandler ValueChanged;
        #endregion // Events
 
        #region IDisposable Members
        public void Dispose()
        {
            //BindingOperations.ClearBinding(this, ValueProperty);
        }
        #endregion
    }

à utiliser c'est assez simple :

en XAML :

Code :

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

1
2
3
4
 
  <Grid x:Name="LayoutRoot">
        <TextBlock x:Name="TextBlock"></TextBlock>
  </Grid>

en C# :

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
 
    public partial class MainPage : UserControl
    {
        public MainPage()
        {
            InitializeComponent();
 
            PropertyChangeNotifier notifierText = new PropertyChangeNotifier(this.TextBlock, "Text");
            notifierText.ValueChanged += new EventHandler(TextValueChanged);
 
            this.TextBlock.Text = "Hello";
        }
 
        /// <summary>
        /// Changement de Text
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
 
        void TextValueChanged(object sender, EventArgs e)
        {
              PropertyChangeNotifier notifier = sender as PropertyChangeNotifier;
              string text = (string)notifier.Value;
        }

Je n'ai pas utilisé cette technique en production donc pas possible de te donner les inconvénients celle ci (s'il y en a).

[cyberbobby]

Wow ! Extra !

J'avais commencé avec la première mais je garde la deuxième au chaud !

Merci à tous les 3. ;-)