Question

I have a object graph that is setup like this

Clients
    string Name
    List[Address] Addresses

I would like to cast this to

MyClients: Clients
    string Name
    List[MyAddress] Addresses

MyAddress: Address
    String City

I know that I can cast this by walking the whole object graph and in the given example that would not be to bad. But if you have a large object graph it gets hairy very fast and secondly it just seems plain wrong to have to walk the whole object graph.

I am looking for a solution that

Does not modify the Clients or Address objects

Does not walk the object graph

Can be implemented with very little code changes required.

Answer 1

In a comment under your original question, you say:

The reason for the cast is that the
object graph starts in application A
the object graph gets serialized and
passed to appliaction B or application
C. Appplication B and C extend the
object graph for its own purposes.
Application A is not aware of
Application B or C or what Application
B and C are doing to the object graph.
Application B and C are vastly
different applications

And yet in the question you say a good solution:

Does not modify the Clients or Address
objects

A cast isn’t able to add capabilities to an object. The object already has to have those capabilities.

So it sounds like you don’t want to change the types, you just want to add extra facilities to those types within certain areas of your solution.

So you need extension methods.

You’d keep the types Client and Address, but add additional facilities via extension methods:

public static class MyExtensions
{
    public static void SendLetter(this Address address, string messageBody)
    {
        // blah
    }
}

This allows you to write:

someClient.Addresses[0].SendLetter("Dear Sir, K THX BAI");

You may need to store extra data along with each Address object. Probably the most convenient off-the-shelf solution to this is to make Address derive from DependencyObject, which allows you to stash extra data, using an instance of DependencyProperty as the key:

public static class MyExtensionsWithData
{
    // declare one of these for each "data slot" you'll be using
    public static readonly DependencyProperty PhoneProperty = 
        RegisterAttached("PhoneNumber", 
                         typeof(string), 
                         typeof(MyExtensionsWithData));

    public static void SetPhoneNumber(this Address address, string phone)
    {
        address.SetValue(PhoneProperty, phone);
    }

    public static string GetPhoneNumber(this Address address)
    {
        return (string)address.GetValue(PhoneProperty);
    }
}

This way, you can effectively add new properties to existing object, and can use them like this:

// set
someClient.Addresses[0].SetPhoneNumber("5550945793847");

// get
string phoneNum = someClient.Addresses[0].GetPhoneNumber();