Class inheritance: recreate base class items (or instance) from a property of the inherited class

• I have a class A that is inherited from B.
  • A as some readonly properties that I want to modify from B
  • Hiding those properties with new is not a suitable option, cause the base class has some functions that use its own properties...
  • Can't use the override keyword, cause the properties are not marked as abstract, virtual nor override

So I'd like to know whether from the inherited class (B) I can totally recreate the actual instance of my object to access those readonly properties.

For example and for a better explaination, for a class inheriting Tuple, if it was possible, I would do something like this:

    public new T3 Item3
    {
        get { return item3; }
        set 
        {
            item3 = value;
         开发者_运维百科   base = new Tuple<T1, T2, T3>(Item1, Item2, Item3); // Not valid
        }
    }

I can't see how to do this?

A tuple is immutable, so you can't change its values. When you have immutable objects, the way to change them is to return a new object with the desired properties changed. So if you want to stick with tuples, you could do something like this:

public static class TupleExtensions {
  public static Tuple<T1, T2, T3> 
    WhereItem3Is<T1, T2, T3>(this Tuple<T1, T2, T3> self, T3 newValue) {
    return Tuple.Create(self.Item1, self.Item2, newValue);
  }
  // other methods for Tuple<,,> or other Tuples...
}

And use it like this:

var t = Tuple.Create(1, 2, 3);
// ...
t = t.WhereItem3Is(4);

But it's a little bit painful to write all those methods. So if you need many of them, better just do this:

var t = Tuple.Create(1, 2, 3);
t = Tuple.Create(t1.Item1, t1.Item2, 4);

You could even have a wrapper type that you'd use to reference the tuple from different places in your code, so that any "changes" could be visible:

var t = Tuple.Create(1, 2, 3);
var r = new Ref<Tuple<int, int, int>>(t);
// share r ...
r.Value = Tuple.Create(r.Value.Item1, r.Value.Item2, 4);

...

public class Ref<T> {
  public T Value { get; set; }
  public Ref(T value) { Value = value; } 
}

All this, though, feels very awkward. Maybe you could better explain the essential problem you're having so that better answers could be provided. Maybe you don't really need a tuple after all, just something more specific to your domain.