Question

Potentially an argumentative topic, but… I really hate that I can’t do the following:

class User 
{
   public string ImageURL {get;set;}
}

class UserUI : User 
{
   public Brush ImageBrush {get;set;}
}

User user = GetFromUserFromServer(); //returns User type object, not UserUI
UserUI userUI = user;
userUI.ImageBrush = CreateBrush(userUI.ImageURL);

Instead, I use something like following:

class User 
{
   public virtual string ImageURL {get;set;}
}

class UserUI : User 
{
   public override string ImageURL 
    {
        get
        {
            return base.ImageURL ;
        }
        set
        {
            if (value != base.ImageURL )
            {                    
                base.ImageURL = value;
                ImageBrush = CreateBrush(value);
            }
        }
    }

   public Brush ImageBrush {get;set;}

   public UserUI(User user)
   {
       ImageURL = user.ImageURL;
   }
}

User user = GetFromServer();
UserUI userUI = new UserUI(user);

It’s a lot more verbose and any time I add fields to User, I need to make sure to copy them over in the UserUI constructor.

Is it fair to say that allowing down-casting would make all of this a lot easier and less error-prone?

Answer 1

Err…no. What do you think should happen when you do this, after all, this is just as valid as your example:

string whatever = "";
UserUI userUI = whatever;
userUI.ImageBrush = CreateBrush(userUI.ImageURL);

After all, both inherit from object. Does userUI.ImageURL throw an exception since that property doesn’t exist? Or…what? This is madness. 🙂

Edit: You say in a comment above:

“Yeah. My argument is that there should maybe be a way of casting to a
derived type, and the framework would automatically copy fields that
exist in both types, and leave the others empty. In this case ImageURL
would be copied.

If that’s what you want, then use Automapper: https://github.com/AutoMapper/AutoMapper/wiki