MSDN Magazine - December 2008 - (Page 27)

Delete, the window both removes the item from the collection and removes the event handler: ' From DeleteItemButton_Click Dim index As Integer = ItemComboBox.SelectedIndex If index >= 0 Then RemoveHandler Data.Item(index).PropertyChanged, _ AddressOf HandlePropertyChanged Data.RemoveAt(index) Figure 7 HandlePropertyChanged Using Reflection Private Sub HandlePropertyChanged( _ ByVal sender As Object, _ ByVal e As PropertyChangedEventArgs) ' In this particular application, you only want to bother with this ' code for the first window, although both will run the code. In this ' case, if the event was raised by the window whose title is ' "Observable Collection 1" then process the event: If Me.Title.EndsWith("1") Then Dim propName As String = e.PropertyName Dim myCustomer As Customer = CType(sender, Customer) ' Unfortunately, no one hands you the old property value, or the new ' property value. You can use Reflection to retrieve the new property ' value, given the object that raised the event and the name of the ' property: Dim propInfo As System.Reflection.PropertyInfo = _ GetType(Customer).GetProperty(propName) Dim value As Object = _ propInfo.GetValue(myCustomer, Nothing) MessageBox.Show(String.Format( _ "You changed the property '{0}' to '{1}'", _ propName, value)) End If End Sub When you click Add New Item, the code creates the new customer, and it also hooks up its PropertyChanged event: ' From NewItemButton_Click cust = New Customer(NewItemTextBox.Text) HookupChangeEventHandler(cust) Data.Add(cust) Of course, because the window binds the ListBox control to the ObservableCollection instance, all these changes appear automatically, without any code support, in both instances of the window. In fact, you only need the code support to programmatically add and remove customers from the list, and to hook up and react to changes within an individual customer. When you do change the value of a property within the Customer class, the client application receives the notification via the PropertyChanged event handler. Note that the HandlePropertyChanged procedure (shown in Figure 7) contains the application’s most complex code. Because the change notification supplies only the name of the changed property, you must remember that it’s up to your code to retrieve the current value of the property, should you have some need for it. The procedure starts by ensuring that the code only runs once— because you have two instances of the window open, the code would otherwise run for each instance, and there’s no point in seeing the alert twice. The code simply checks the final character of the title (assuming that you haven’t changed the window’s Title property) and restricts the behavior to a single window: If Me.Title.EndsWith("1") Then 'Code removed here… End If The code retrieves and stores the name of the property that was changed and a reference to the object that raised the event—that is, the current customer: Dim propName As String = e.PropertyName Dim myCustomer As Customer = CType(sender, Customer) use the class this way. Because it notifies listeners that its contents have changed, you can replace any List or Collection instance that you use with an ObservableCollection instance (even if you’re not creating a WPF application) and then hook up event handlers to notify clients that the collection’s contents have changed. Just as the sample window updated the list of integers corresponding to collection indexes when the collection changed size, you could react in any necessary way to changes in the collection from a client class. Remember, however, that the collection won’t tell you, on its own, whether the properties of its child elements have changed. You’ll need to hook up event handlers within the client, so the client gets notified when the properties of a child element within the collection change. Also remember that the rich data binding support that you saw in the sample application only works within WPF applications— if you’re creating a Windows Forms application, you’ll still need to manually refresh the binding for any control that’s bound to an ObservableCollection instance when the collection changes. On the other hand, because the collection notifies you when it changes, at least it’s now possible to make this happen.  The code then uses Reflection to retrieve a System.Reflection.PropertyInfo instance, given the name of the property and the type: Dim propInfo As System.Reflection.PropertyInfo = _ GetType(Customer).GetProperty(propName) Given the PropertyInfo object and a particular Customer instance, the code can then retrieve the current value of the property: Dim value As Object = _ propInfo.GetValue(myCustomer, Nothing) The remainder of the code in the application maintains the user interface, including enabling/disabling buttons, keeping the combobox and listbox in sync, and so on. Although this application made use of the binding support provided by the ObservableCollection class and also reacted to its CollectionChanged event in order to update the user interface, you needn’t msdnmagazine.com author for AppDev (appdev.com). He is coauthor of ASP .NET Developers Jumpstart, Access Developer’s Handbook, and VBA Developer’s Handbook, 2nd Edition. Reach him at keng@mcwtech.com. December 2008 27 Ken Getz is a Senior Consultant with MCW Technologies and a courseware http://www.appdev.com http://www.msdnmagazine.com

Table of Contents Feed for the Digital Edition of MSDN Magazine - December 2008

MSDN Magazine - December 2008 Contents Toolbox CLR Inside Out Advanced Basics Cutting Edge Patterns In Practice Team System Real-World WF Visual Studio OBA Tools SOA Data Access Geneva Framework Test Run Foundations Windows With C++ Going Places End Bracket

MSDN Magazine - December 2008

For optimal viewing of this digital publication, please enable JavaScript and then refresh the page. If you would like to try to load the digital publication without using Flash Player detection, please click here.