CODEWITHSUNDEEP
c#inheritance
test
test

Reputation: 2639

How can I add a property to a class through inheritance and then cast the base class to the new class?

I'm wondering if there is a way to do this inheritance situation in C#:

public class Item
{
    public string Name { get; set; }
}

public class ItemExtended : Item
{
    public int ExtendedProp { get; set; }
}

And let's say I have a method that returns objects of type Item:

public Item[] GetItems();

How can I make code like this run?

ItemExtended[] itemsExt = GetItems().Cast(i => (ExtendedItem)i).ToArray();

Where the cast wouldn't fail, the Name property value would be preserved and I would have an additional property ExtendedProp that I could access?

Edit (hopefully to clear some confusion)

In this situation the GetItems method would only ever return items of type Item. I was wondering if there was a casting method that could convert a base type to an inherited type such that all base member values are conserved (without the use of cloning).

Upvotes: 1

Views: 891

Answers (3)

Rytmis
Rytmis

Reputation: 32047

If the runtime type of your object is Item, you can not cast it to an ItemExtended -- not unless there's a user-defined conversion that can create an ItemExtended from an Item. Note, however, that even then, you'll be creating a new instance of ItemExtended.

Inheritance in general doesn't work that way. In managed languages, downcasting only works if the runtime type of your object already is of the derived type. Instances of derived classes inherit all the data and behavior of their ancestor classes, but there's an ancestor doesn't have any knowledge of derived classes. Consider an example, where a derived class introduces a single new field. Firstly, the base class instance is smaller in size, so at the very least, a type cast would require allocating new memory. Second, you would have to decide between changing the runtime type of the original instance (which would be very weird indeed) or making a copy of the old data. The latter way would be very similar to the user-defined conversion scenario, except an user-defined conversion is explicitly invoked, and IMO better that way.

In unmanaged languages, you can of course make any arbitrary conversion you want -- but that just results in catastrophic failures if you do it wrong. In the example above, you would try to access the new field, but since it would not have been allocated for the instance, you would go beyond the boundaries of the object's memory space and access... whatever was in there, be it sensical or not.

If you want to introduce new behavior to existing classes, the C# way is via extension methods. Extension properties aren't there yet, and may never be, so you don't get the property syntax. You may or may not be able to live with that.

You may also find it interesting, that in XAML, the concept of attached properties sort of fits what you are trying to do: you can define arbitrary new properties for whatever -- but if you look at the implementation, what you are really doing is creating a dictionary that maps objects to their associated property values, and the XAML compiler sugarcoats this by making the markup look like you've added the properties to those objects.

Upvotes: 5

André
André

Reputation: 121

You're on the right track with a few adjustments,

  • use Select() instead of Cast() and
  • i as ItemExtended rather than (ItemExtended)i

This line should cast it correctly:

ItemExtended[] itemsExt = GetItems().Select(i => i as ItemExtended).ToArray();

Upvotes: 0

Sergey Mozhaykin
Sergey Mozhaykin

Reputation: 192

You can use OfType instead of Cast:

ItemExtended[] itemsExt = GetItems().OfType<ItemExtended>().ToArray();

Upvotes: 1

Related Questions