Chris Garty's Weblog : C#

Fun with Generics: BindingList and ReadOnlyCollection

chrisgarty — Thu, 16 Sep 2004 02:07:00 GMT

Mitch Denny's post about List events and Bill McCarthy's subsequent answer pointing him to BindingList had me looking at some Generics Design Guidelines and there were two generic collection types that I really glad I found out about.

Mitch's question ("why doesn't List<T> fire events") was similar to the one I was asking myself the other day. I was getting tired of providing Add and Remove methods on every object that managed a collection. For example, if I have an Order object and an OrderItem object, I can create Order.AddOrderItem, Order.RemoveOrderItem, but I'd really rather just expose a list of OrderItems from Order, validate each OrderItem as it is added, and allow the standard IList.Remove method to handle removals. It might not be something you'd want to do all the time, but it would mean less code and it could be a useful option to utilise in certain situations. BindingList<T> provides this useful 'list with events' capability.

The other generic collection type I was interested by was ReadOnlyCollection<T>. Have you ever used an IList (probably an ArrayList) internally to manage a list and provided a view of that by converting it to an array? Or maybe you've exposed an array externally? ReadOnlyCollection means that you have an option other than an array with the added benefit of being truly read-only i.e. it doesn't allow something like list[1] = 5;

Here are some tests I used to learn about BindingList<T>and ReadOnlyCollection<T> behaviour.

BindingListTests.cs…

using System;

using System.Collections;

using System.ComponentModel.Collections.Generic;

using NUnit.Framework;

namespace GenericsExamples

{

[TestFixture]

public class BindingListTests

{

bool _EventFired;

[Test]

public void TestBindingListEvents()

{

//Add to a bound list and fail if events are not triggered or triggered incorrectly.

BindingList<int> bindingList = new BindingList<int>();

bindingList.Add(1);

bindingList.ListChanged += new System.ComponentModel.ListChangedEventHandler(bindingList_ListChangedItemAdded);

_EventFired = false;

bindingList.Add(2);

if (!_EventFired) Assert.Fail("BindingList event not triggered");

bindingList.ListChanged -= new System.ComponentModel.ListChangedEventHandler(bindingList_ListChangedItemAdded);

bindingList.ListChanged += new System.ComponentModel.ListChangedEventHandler(bindingList_ListChangedItemDeleted);

_EventFired = false;

bindingList.Remove(2);

if (!_EventFired) Assert.Fail("BindingList event not triggered");

bindingList.ListChanged -= new System.ComponentModel.ListChangedEventHandler(bindingList_ListChangedItemDeleted);

Assert.AreEqual(1, bindingList.Count);

bindingList.ListChanged += new System.ComponentModel.ListChangedEventHandler(bindingList_ListChangedItemAddedButRejected);

bindingList.Add(5);

bindingList.ListChanged -= new System.ComponentModel.ListChangedEventHandler(bindingList_ListChangedItemAddedButRejected);

Assert.AreEqual(1, bindingList.Count);

}

void bindingList_ListChangedItemAdded(object sender, System.ComponentModel.ListChangedEventArgs e)

{

if (e.ListChangedType != System.ComponentModel.ListChangedType.ItemAdded)

{

Assert.Fail("Expected ItemAdded event but got: " + e.ListChangedType.ToString());

}

_EventFired = true;

}

void bindingList_ListChangedItemDeleted(object sender, System.ComponentModel.ListChangedEventArgs e)

{

if (e.ListChangedType != System.ComponentModel.ListChangedType.ItemDeleted)

{

Assert.Fail("Expected ItemDeleted event but got: " + e.ListChangedType.ToString());

}

_EventFired = true;

}

void bindingList_ListChangedItemAddedButRejected(object sender, System.ComponentModel.ListChangedEventArgs e)

{

if (e.ListChangedType == System.ComponentModel.ListChangedType.ItemAdded)

{

//Do some validation and if it fails then I might need to remove the added item

((IList)sender).RemoveAt(e.NewIndex);

}

ReadOnlyCollectionTests.cs…

using System;

using System.Collections.Generic;

using NUnit.Framework;

namespace GenericsExamples

{

[TestFixture]

public class ReadOnlyCollectionTests

{

[Test]

public void TestReadOnlyCollectionCreation()

{

List<int> list = new List<int>();

list.Add(1);

list.Add(2);

System.Collections.Generic.ReadOnlyCollection<int> roList = new ReadOnlyCollection<int>(list);

//roList.Add(3); //Operation isn't available!

//roList[1] = 3; //Operation isn't available!

Assert.AreEqual(2, list.Count);

Assert.AreEqual(2, roList.Count);

}

I wonder if they'll improve BindingList<T> before RTM by getting ListChangedEventHandler to pull the generic type from the BindingList rather than simply providing a parameter of "object sender"? We'll just have to wait and see.

For more about handling different situations with Generics, have a read of the Generics Design Guidelines from Krzysztof Cwalina.

Presentation: Refactoring

chrisgarty — Wed, 30 Jun 2004 22:00:00 GMT

Last week I gave a presentation at the Melbourne Microsoft Developer Group (MDNUG) on Refactoring with code examples in C# (.Net) and using Visual Studio 2005 for some live demonstrations.

The slide deck for my Refactoring presentation is available here.

OJB.Net and Generics

chrisgarty — Tue, 08 Jun 2004 21:57:00 GMT

I posted a little while ago about trying to use reflection with generic types. I have been trying to use a generic list type within OJB.Net (an object relational mapper for .Net).

I finished investigating this and thought I'd post a write-up about it here in case anyone else is using or wants to use OJB.Net and Generics together: http://weblogs.asp.net/chrisgarty/articles/150558.aspx.

Generics in OJB.Net (a.k.a. Generics Type Madness)

chrisgarty — Wed, 02 Jun 2004 22:50:00 GMT

At iP3 we are using OJB.Net for object relational persistence. It is really easy to use, but it was using an ArrayList by default and we wanted to use the new Whidbey Generics List<> type.

When OJB.Net creates objects out of the relational data, it uses reflection to generate the IList collection object which is ArrayList by default.

When we tried to change this to the Generics List<> type OJB.Net didn't seem to be able to handle it and reported that it couldn't find the type in the assembly. My collegue Lance and I sat and worked through the problem for about half an hour until he did a GetType().ToString() on a List<> object. To our surprise we found that the type name we needed to Reflect for was System.Collections.Generic.List'1 linstead of System.Collections.Generic.List.

The full line for getting the type for List<String> using reflection then becomes:

Type classType = Type.GetType(“System.Collections.Generic.List'1[[System.String,Mscorlib]],Mscorlib“,true);

Don Box has a good post about Generics reflection under the heading Generics as Type Constructors from August 2003, but it doesn't mention anything about adding a suffix to the type name.

If someone has seen this suffix notation explained previously then please shoot me a link.

Read more about the craziness on Lance's blog.

Safer C# Constructor-based Dependency Injection with readonly

chrisgarty — Mon, 31 May 2004 23:25:00 GMT

Most people would have used the const keyword while doing C# development, but I had never heard of the readonly keyword before. Well, this weekend I had a friend point out this keyword and the first usage that came to mind was constructor-based dependency injection.

Here is the clarification of the differences between readonly and const from MSDN:

The readonly keyword is different from the const keyword. A const field can only be initialized at the declaration of the field. A readonly field can be initialized either at the declaration or in a constructor. Therefore, readonly fields can have different values depending on the constructor used. Also, while a const field is a compile-time constant, the readonly field can be used for runtime constants e.g. public static readonly DateTime _creationTime = DateTime.Now;

So now I can create a class with a dependency (reference) that is injected in the constructor and I can be sure that no method in the class will change that injected dependency.

Using Martin Fowler's MovieLister example, I can now have this:

public class MovieLister
{
    private readonly MovieFinder finder;
    public MovieLister(MovieFinder finder)
    {
        this.finder = finder;
    }
}

And if anyone tries to change that readonly local member variable in a method like...

public class MovieLister...
    public void MethodThatWontCompile()
    {
        this.finder = null; //Error because a readonly field cannot be assigned to
    }

...they'll get an error on compilation: 'A readonly field cannot be assigned to (except in a constructor or a variable initializer)'

So in summary, the readonly keyword provides us with a facility for ensuring that our constructor injected dependencies are not tampered with by other methods in the class.