Question

I have the following code working in Silverlight 5:

public void Send(Notification notification)
{
    // Because the variable is passed as Notification, we have to trick the
    // type-inference feature of the runtime so the message will be sent using
    // the actual type of the object.
    // Using the dynamic keyword, we can convert the type of the object passed
    // to the Send method.
    // This allows subscribers to register for messages using the generic interface.
    dynamic stronglyTypedNotification = Convert.ChangeType(notification,
                                                           notification.GetType(),
                                                           CultureInfo.InvariantCulture);

    SendCore(stronglyTypedNotification);
}

private void SendCore<T>(T notification)
    where T : Notification
{
    foreach (var handlerFactory in Handlers)
    {
        var handler = handlerFactory.Value as INotificationHandler<T>;

        if (handler != null)
        {
            handler.Handle(notification);
        }
    }
}

I have to port this code over to run in a WPF application.

When I run it in my WPF application and set a breakpoint inside the SendCore method, T is not the correct type. I can only assume this is because generics are supposed to be staticly defined so the compiler has created the version of SendCore it thinks it will need at runtime. I guess Silverlight handles this differently because this code works perfectly in SL.

The goal of this code is to locate any of the objects contained in the Handlers collection that implement INotificationHandler where T is the type of the object passed to the Send method (subclassing the base Notification class) then call the Handle(T n) method on those objects.

How can I do this in my WPF app?

UPDATE

After some additional testing, I am finding more peculiar results. When I set a breakpoint on the first line of the SendCore method and inspect T and notification, I find:

• Intellisense indicates that T is “GenericNotification” which is
  legitimate class in the assembly.
• Intellisense indicates that “notification” is the correct,
  strongly-typed class (DataChangedNotification).
• DataChangedNotification does NOT subclass GenericNotification in any
  way. Both subclass Notification.
• Because T is resolving to GenericNotification, attempting to cast
  each handler to INotificationHandler<T> will fail because none
  implement INotificationHandler<GenericNotification>

Given that this exact code works in Silverlight, a Console application and another WPF application (as well as David’s test in LINQpad), what in the world could be going on?

The only thing I can think of mentioning is that the code actually exists in a Class Library that is referenced by the WPF application. Not sure that matters because I tested that scenario in another (new) WPF application and had the correct results.

Answer 1

It works for me and that’s expected. I would have been surprised if it was different.

void Main()
{
    Send(new NA());
    Send(new NB());
}

public class Notification {}
public class NA : Notification {}
public class NB : Notification {}

public void Send(Notification notification)
{
    dynamic stronglyTypedNotification
        = Convert.ChangeType(notification,
                             notification.GetType(),
                             CultureInfo.InvariantCulture);

    SendCore(stronglyTypedNotification);
}

public void SendCore<T>(T notification) where T : Notification
{
    Console.WriteLine(typeof(T));
}

This outputs

typeof (NA) 
typeof (NB)