Inheritance and access modifier

Private is the most restrictive access for a field. It means that no other class has access to it, only the current one. Each class has its own set of private fields.

The reason why your application behaves like this is because your mymethod() member is declared public. That means that any class can call it. Since you are inheriting it, you automatically get that method in myParent. It is not copied into myparent, it is inherited. And since it is not overridden by myChild a call to myChild.mymethod() will invoke it on myParent, which accesses the only private name field it can (the one inside myParent).

If you want to inherit the name field, so it will act more like you are expecting, you need to make the field protected instead of private.

class myParent { public int id = 3; protected string name = "Parent class private string"; public void mymethod() { Console.WriteLine("{0} & {1}", name, id); } } class myChild : myParent { public myChild() { name = "Child class private string"; } } 

Now the variable in myParent is overwritten by myChild when it is instantiated. So, when you make a call to myChild.mymethod() it has access to the new value.

From C# specification:

Here is how Inhertiance is defined:

Inheritance means that a class implicitly contains all members of its direct base class type, except for the instance constructors, destructors and static constructors of the base class.

Now about extending base class.

A derived class extends its direct base class. A derived class can add new members to those it inherits, but it cannot remove the definition of an inherited member.

In other word you can extended base class by adding new definitions (or overriding existing ones), but you can't remove any.

And to get it more cleaner:

A derived class can hide (§3.7.1.2) inherited members by declaring new members with the same name or signature. Note however that hiding an inherited member does not remove that member—it merely makes that member inaccessible directly through the derived class.

What you do in your derived class is called hiding and as you can see from quote it doesnt remove that member.

And because in your MyParent class you are using name field defined in same class it will always print what it does. For changing this behaviour you should have look at Virtual properties.

Your new field name in the myChild class does not make the inherited field name from the base class go away! It just hides in. OK, it was hidden already because it was private, but introducing a new field in the derived class still does not make the hidden field go away.

If you want a name that is read-only, you can use a protected virtual property with no set accessor, and override it in the deriving class:

class myParent { public int id = 3; protected virtual string name => "Parent class private string"; public void mymethod() { Console.WriteLine("{0} & {1}", name, id); } } class myChild : myParent { protected override string name => "Child class private string"; } 

If you want to keep it as a private field, offer a constructor that the deriving class can chain:

class myParent { public int id = 3; private string name; public myParent() : this("Parent class private string") { } protected myParent(string name) { this.name = name; } public void mymethod() { Console.WriteLine("{0} & {1}", name, id); } } class myChild : myParent { public myChild() : base("Child class private string") { } } 

This happens because you have used a method inside the parent's context. As you have not overridden myMethod() it will get executed using the private field in that parent's context. if you use method overriding here when you want to get the name of the child's context you can create a child object.

namespace ConsoleApplication2 { class myParent { public int id = 3; private string name = "Parent class private string"; public void mymethod() { Console.WriteLine("{0} & {1}", name, id); } } class myChild : myParent { private string name = "Child class private string"; public new void mymethod() { Console.WriteLine("{0} & {1}", name, id); } } class Program { static void Main(string[] args) { myChild c1 = new myChild(); c1.mymethod(); Console.ReadLine(); } //Output //Parent class private string & 3 } } 

If you want to get the name of the parent's context you can get that using a parent object.

static void Main(string[] args) { myParent c1 = new myChild(); c1.mymethod(); Console.ReadLine(); } 

If you want to access a field in the derived class, you can define it as protected.

class myParent { public int id = 3; protected string name = "Parent class private string"; public void mymethod() { Console.WriteLine("{0} & {1}", name, id); } } 

and set it in the child constructor

class myChild : myParent { public myChild() { name = "Child class private string"; } } 

Alternatively you can use the virtual/override keyworkds if you define name as a property { get; set; }

class myParent { public int id = 3; protected virtual string name { get; set; } = "Parent class private string"; public void mymethod() { Console.WriteLine("{0} & {1}", name, id); } } class myChild : myParent { protected override string name { get; set; } = "Child class private string"; } 

I never created an instance of the base class.

It is created internally when you instantiate the derived class.

When I invoke c1.mymethod(), why is string name in the myParent class used instead of string name in myChild class since I am invoking a method on myChild object which has a defined string name variable?

Basically your original code is equivalent - in terms of its output - to the above case of a virtual name with a new keyword in the derived class

class myChild : myParent { new string name { get; set; } = "Child class private string"; } 

In that case, the parent's method will display the parent's name, since the child's name is now a different, new variable and it's no longer the one used in the parent's method.