don't understand INotification and event

Ivan

15y2.8k

Hello to everybody...

I've been trying to understand how to use INotifyPropertyChanged interface inside a class that i'm using but i have a problem understanding the link between the event raised inside the class e the INotifyPropertyChanged that, from what i understood, is sent to the UI...

So i have a class with a property that can have two values (two string: "EXP" and "INS")...

Depending on the value of this property I need to use a different list and different constants inside the logic of the class, but since the information about that property will be helpful also in the UI i thought that would have been a good idea to sue the INotifyPropertyChanged inside the class....

Just i don't get if I need to create an event for what i have to use inside the class AND INotifyPC for the UI, or if it'ìs possible to use simply INotifyPC to achieve both things....

if the class has the structure suggesting by MSDN

public event PropertyChangedEventHandler PropertyChanged;

public string myProperty      {           get { return name; }           set           {               name = value;                              OnPropertyChanged(String);           }       }

Where exactly i should subscribe this event in order to modify other property inside my class (like which list i'm using, which constants, etc...)

Thanks a lot, I.

21 Replies

Know the answer? Post it — somebody with the same question will find it here.

Vulpes15y ago
Accepted answer
Although the code behind can instantiate and use objects in the usual fashion, the problem here is that it's the XAML which is creating the encoder object as a resource and so the code behind doesn't know anything about it.

The code behind therefore needs to find the resource corresponding to the object and assign it to a field so that it can be used anywhere within the code behind.

So, I'm not saying that you need to do this:

Person p = new Person();

because that's creating a new Person object which won't be the same as the object created in the XAML whose properties you're binding.

You should simply do this:

Person p;

p will then be null (the default value for all reference types).

When you then do this:

p = (Person)this.FindResource....

p will then be assigned a reference to the same object as was created in the XAML and all will be well :)
Ivan15y ago
...yes great effort .... :) and thanks again for your help...
Mahesh Chand15y ago
Nice effort Vulpes
Vulpes15y ago
Yes, you can access objects created in the code behind from within the XAML.

First, add another TextBox, textBox2, to the project.

Now change the code behind I posted earlier, as follows:

public partial class MainWindow : Window
{
encoder en;
public string MyString { get; set; }

public MainWindow()
{
InitializeComponent();
en = (encoder)this.FindResource("MyEncoderData"); // get encoder object from resource
DataContext = this;
MyString = "Vulpes";
}

private void button1_Click(object sender, RoutedEventArgs e)
{
en.Start();
}
}

Finally, change the XAML for textBox2 as follows (positional properties will of course be different):

Text="{Binding Path=MyString}" />

When you build and run, the string "Vulpes" should now appear in textBox2.
Ivan15y ago
thanks again for you clear explanation...

Just last question then i promise i'll stop :)..

Is there a way to do this way back?... I mean i have to get a handle to an object instantiated by the WPF layer in the code behind...

Can i get a handle in the WPF to an object already instantiated in the code behind?....

thanks...
Vulpes15y ago
The XAML does in fact have a binding to a specific object of the class, not to the class itself.

The following line creates an object of type encoder and sets its ValueAng property to zero.

For this to work, the encoder class needs to have a public parameterless constructor, which it has. This constructor is called in the background by the WPF infrastructure.

The object is given a key of "MyEncoderData" in the ResourceDictionary which is then used in the FindResource() method to retrieve it. It's also used in the following bit of XAML which binds its ValueAng property to the textbox's Text property:

Text="{Binding Source={StaticResource MyEncoderData}, Path=ValueAng}"

Where you were going wrong originally in the code behind was to create another instance of encoder, rather than use the existing instance, and assign it to your field 'en'. This new object was unbound and so when it was started, the textbox was not updating with the changing values of ValueAng.

Any clearer?
Ivan15y ago
...ok first i put the correct answer.... :)

then so if i understood well, the XAML has a binding to the class, not to a specific object... is there aa way to bind a control of the XAML to a specific object i created on the code?... is the famous "Separation of Concerns" connected to this structure?....
Ivan15y ago
... evrything works perfectly.... :)

thanks... anyway i still don't understand what you tried to explained me.

I thought that having the class was enough for the main window to instantiate an object,so why the main window should search the same object as a resource of somthing i declared in the xaml?..

I know i can't express my self good enough.

But all the examples i saw on the web they lack this part... there are a lot of examples about class Person with name, etc...

so i can boud the property name to a textbox and the textbox will change the content based on the name of the object person that i created in the main window...

Are you saying that also in this case i have to put

Person p = new Person()

and then after the inizialization:

p = (Person)this.FindResource....

like this?.. for every object that i use in the main window and is binded to some control?
Vulpes15y ago
There's nothing wrong with the XAML which should be left as it is.

The problem is that you need to get a reference to the encoder object in the code behind and the only way to do that is to use FindResource() because the code behind knows nothing about that object.

Ivan15y ago

ah...

so should be smt like

xmlns:c="clr-namespace:testWPF1

and then


:encoder x:Key="myDataSource" > 




more or less is this how it should be?...

is that "local" keyword that was mistaken?

Vulpes15y ago
The difference is that this piece of code in the XAML is creating an instance of the encoder class:

and you're then binding the textbox to the ValueAng property of this instance.

You therefore need to call the Start() method of this instance from the code behind rather than create a new one which will be unbound.
Ivan15y ago
... wait, so i really didn't get it...

but my object is encoder.cs, and in windows.xaml.cs (that is the main right?)

i have encoder en = new encoder()...

so i basically created my object in code like i used to be with windows form application....

where's exactly the difference?....

thanks again.. I
Vulpes15y ago
If you create an object in the XAML then, yes, you have to call FindResource() to use it from the code behind because otherwise it just doesn't know it exists.

You can, of course, create objects in the usual way from the code behind itself.

WPF is complicated - an order of magnitude more so than Windows Forms - but that's the price you pay for the additional power it gives you.
Ivan15y ago
thanks a lot Vulpes....

to be honest that never crossed my mind... (by the way, is there any reason why it shoudl behave like that?... If i create any object on the main window i have to get the reference form the Static resource?... I'm not very good but doens't it sound complex??... )..

I'll try tomorrow morning as soon as i have a working visual studio under my hands (i just discovered that Vista Home and VS2010 don't like each other... )

thanks again, tomorrow i wil let you know...

I.
Vulpes15y ago
OK, to get it working using data-binding, leave the XAML file as it is. However, you'll need to change the code behind file so that it uses the instance of the encoder class created in the XAML file rather than a new instance as you have it right now:

public partial class MainWindow : Window
{
encoder en;

public MainWindow()
{
InitializeComponent();
en = (encoder)this.FindResource("MyEncoderData"); // get encoder object from resource
}

private void button1_Click(object sender, RoutedEventArgs e)
{
en.Start();
}
}
Ivan15y ago
..thank you, but i made that answer because i wanted to understand the InotifyPropertychanged with databinding and objects....

That encoder it's just a little example i made to make myself things clearer, but i have to face a bigger problem where i need the databinding use...
Vulpes15y ago
You should be able to do this without the complexities of data-binding. I'd try the following.

First change your XAML file as follows:

xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
Title="MainWindow" Height="350" Width="525"
xmlns:local="clr-namespace:testWPF1" >

Now change your code behind file to the following:

//add this using directive to the others
using System.ComponentModel;

// ...

public partial class MainWindow : Window
{
encoder en = new encoder();

public MainWindow()
{
InitializeComponent();
en.PropertyChanged += PropertyChangedHandler; // wire up eventhandler
}

private void button1_Click(object sender, RoutedEventArgs e)
{
en.Start();
}

private void PropertyChangedHandler(object sender, PropertyChangedEventArgs e)
{
textBox1.Text = en.ValueAng;
}
}

When you press the button, the textbox should now show the value of the ValueAng property being updated by the timer.
Ivan15y ago
I just have

encoder en = new encoder();

and under the click event button

en.Start();

did i miss something?
Vulpes15y ago
What code so you have in your MainWindow.xaml.cs file?
Ivan15y ago
hello Vulpes,

thank you for the fast reply... I think i get it (I'm not sure anyway)...

but really i wanted to ask smt more specific, (of course i can't find the link in your answer becasue i'm new in all of this)...

what if i have a Property inside the class, and i need that when it changes the event can both make smt happens inside the class (like another pèroperty changes) and change some visual controls?...

I will try to post an example so maybe i can be clearer,....

I have this encoder class that uses a timer and simulates an angle encoder... so when it arrives to 360° it should both writes on the textbox smt and changes some other property (in this example i just put to zero the value again...)

Is is the right way to use the InotifyPropertyChanged and above all... Is it the right way of binding on the UI cause on the textBox i can't see anything....

here's the code...

Thanks, I.

---------
the xaml is

   xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
   xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
   Title="MainWindow" Height="350" Width="525"
   xmlns:local="clr-namespace:testWPF1" >








and the class is

namespace testWPF1
{
   public class encoder: INotifyPropertyChanged
   {
   int tempVa;

   public encoder()
   {

   }

   public event PropertyChangedEventHandler PropertyChanged;

   private DispatcherTimer myTimer = new DispatcherTimer();

   private string _valueAng;

   protected void OnPropertyChanged(PropertyChangedEventArgs e)
   {
   if (e.Equals(ValueAng))
   {
   if (ValueAng.Equals("360"))
   ValueAng = "0";
   }

   PropertyChangedEventHandler handler = PropertyChanged;
   if (handler != null)
   handler(this, e);
   }

   protected void OnPropertyChanged(string propertyName)
   {
   OnPropertyChanged(new PropertyChangedEventArgs(propertyName));
   }

   public string ValueAng
   {
   get { return _valueAng; }

   set
   {
   if (value != _valueAng)
   {
   _valueAng = value;
   OnPropertyChanged("ValueAng");
   }
   }
   }

   #region main

   public void Start()
   {
   myTimer.Interval = new TimeSpan(0, 0, 0, 0, 1000);
   myTimer.Tick += new EventHandler(myTimer_Tick);
   ValueAng = "0";
   myTimer.Start();
   }

   private void myTimer_Tick(object sender, EventArgs e)
   {
   tempVa = Int16.Parse(ValueAng);
   tempVa += 10;
   ValueAng = tempVa.ToString();
   }

   #endregion
   }
}
Vulpes15y ago
You can subscribe to the PropertyChanged event from any other class which needs a notification when a property of the first class changes. This simple example may help to make the situation a bit clearer:

using System;
using System.ComponentModel;

class Test
{
   static void Main()
   {
   Person p = new Person("George");
   p.PropertyChanged += PropertyChangedHandler; // subscribe to event
   p.Name = "Barack"; // change property
   Console.ReadKey();
   }

   static void PropertyChangedHandler(object sender, PropertyChangedEventArgs e)
   {
   Console.WriteLine("{0} has changed!", e.PropertyName);
   }
}

public class Person : INotifyPropertyChanged
{
   private string name;

   public event PropertyChangedEventHandler PropertyChanged;

   public Person(string name)
   {
   this.name = name;
   }

   public string Name
   {
   get { return name; }
   set
   {
   name = value;
   OnPropertyChanged("Name"); // fire event
   }
   }

   protected void OnPropertyChanged(string name)
   {
   if (PropertyChanged != null)
   {
   PropertyChanged(this, new PropertyChangedEventArgs(name)); // notify subscribers
   }
   }
}