Question

I read other threads like this but they didn’t work for me.

I got two classes:

public class ClassA 
{
    public string _shouldBeInteger;
    public string _shouldBeBool;
    public string _shouldBeDateTime;
}

public class ClassB : ClassA
{
   public int? shouldBeInteger
    {
        get { return (_shouldBeInteger != null) ? Convert.ToInt32(Convert.ToDouble(_shouldBeInteger)) : new int?(); }
        set { _shouldBeInteger = Convert.ToString(value); }
    } 

  //... same thing with datetime etc.


}

If I now create a new object of ClassB I get

 _shouldBeInteger, _shouldBeBool, _shouldBeDateTime;
 shouldBeInteger,shouldBeBool,shouldBeDateTime

But I want to hide the _variables to the User.
Setting them private in ClassB will override them, but I need to access them in order to parse there string values.

Update

There is a ClassC filling ClassAs’ values, which mainly is the reason why they have to be writeable. There is no way for me to change the way that works, but I’m fully in Control of ClassA and ClassB

ClassC //not changeAble for me
{
 //infomagic filling values of ClassA    
}

Setting ClassA variables to private won’t work, because programmer of ClassA produced it in a strange way.

Solution

Because ClassA needs to be writeable, but not readable to other classes than inheritated, I finally got this:

ClassA 
{ 
  public string _shouldBeInteger { protected get; set; } 
  //and so on
} 

which causes ClassB to work with theese properties, without giving them outside.
Intellisense still shows them, but you might consider using:

 [EditorBrowsable(EditorBrowsableState.Never)]

to solve that.

Thanks to all.

Answer 1

I think you can solve your problem using:

public class ClassA 
{
    protected string _shouldBeInteger;
    protected string _shouldBeBool;
    protected string _shouldBeDateTime;
}

so those variables are accessible to derived classes but not to user.

EDITED after user update:
I don’t know if this could be a vali solution for you, but try:

public class ClassB : ClassA
{
    public new int? _shouldBeInteger
    {
        get { return (base._shouldBeInteger != null) ?
                     Convert.ToInt32(Convert.ToDouble(base._shouldBeInteger)) : 
                     new int?(); }
        set { base._shouldBeInteger = Convert.ToString(value); }
    }
}