Encapsulation In C#

Encapsulation in C# - OOPS concept

The wrapping up of data and functions into a single unit (called class) is known as an encapsulation.

Encapsulation is

• Hiding complexity.
• Binding the data and the function together.
• Making complicated methods private.
• Making an instance variables private.
• Hiding an unnecessary data and the functions from the end user.

A class can be public or an internal but not a private, protected or protected internal.

Why a class cannot be private or protected

A protected declaration at the namespace level is meaningless. Protected for, or from, what? Access from other namespaces i.e. what 'internal' does.

A namespace has no class hierarchy. Can you inherit from a namespace? No.

Nested class can have all access modifiers. 

class parent {
    private class Child1 {}
    protected class Child2 {}
    protected internal class Child3 {}
}

Note

I have created a console Application and a class library (i.e. 2 assemblies) to show the difference between the 5 access modifiers in C# to achieve an encapsulation

private 

namespace ConsoleApplication1 {
    public class demo {
        private string name = "some name";
    }
    public class Program: demo {
        static void Main(string[] args) {
            demo d = new demo();
            d.name //compile time error, we can’t access the private member
            ReadLine();
        }
    }
}

public 

namespace ConsoleApplication1 {
    public class demo {
        public string name = "some name";
    }
    public class Program: demo {
        static void Main(string[] args) {
            demo d = new demo();
            WriteLine(d.name); // output “some name”
            ReadLine();
        }
    }
}

Protected

Protected is only accessible in the same class and in the derived class. This supports cross assembly i.e. if our class is in one assembly and we derive it in another assembly’s class, then we can have access to the protected access modifier members.

Scenario 1 - within same assembly 

namespace ConsoleApplication1 {
    public class Demo {
        protected string name = "demo";
    }
    public class Program: Demo {
        static void Main(string[] args) {
            Demo d = new Demo();
            WriteLine(d.name); // complie error, we cannot call the protected member by base class reference
            Program p = new Program();
            WriteLine(p.name); // we will get the "demo" as output
            ReadLine();
        }
    }
}

Scenario 2 - with cross assembly

namespace ClassLibrary1 {
    public class Demo {
        protected string name = "demo";
    }
}

It is another assembly, where we are going to inherit it and try to use the variable. 

namespace ConsoleApplication1 {
    public class Program: Demo {
        static void Main(string[] args) {
            Demo d = new Demo();
            WriteLine(d.name); // complie error, we cannot call the protected member by base class reference
            Program p = new Program();
            WriteLine(p.name); // we will get the "demo" as output
            ReadLine();
        }
    }
}

Internal

Scenario 1 - within same assembly 

namespace ConsoleApplication1 {
    public class Demo {
        internal string name = "demo";
    }
    public class Program: Demo {
        static void Main(string[] args) {
            Demo d = new Demo();
            WriteLine(d.name); // we will get the "demo" as output
            ReadLine();
        }
    }
}

Scenario 2 - with different assembly 

First assembly
namespace ClassLibrary1 {
    public class Demo {
        internal string name = "demo";
    }
}

Second assembly 

namespace ConsoleApplication1 {
    public class Program: Demo {
        static void Main(string[] args) {
            Demo d = new Demo();
            WriteLine(d.name); // we will get the compile error
            ReadLine();
        }
    }
}

Protected Internal

Scenario 1 - within same assembly 

namespace ConsoleApplication1 {
    public class Demo {
        protected internal string name = "demo";
    }
    public class Program: Demo {
        static void Main(string[] args) {
            Program d = new Program();
            WriteLine(d.name); // we will get the "demo" as output
            ReadLine();
        }
    }
}

Scenario 2 - with different assembly 

First assembly
namespace ClassLibrary1 {
    public class Demo {
        protected internal string name = "demo";
    }
}
Second assembly
namespace ConsoleApplication1 {
    public class Program: Demo {
        static void Main(string[] args) {
            Program d = new Program();
            WriteLine(d.name); // we will get the "demo" as output
            ReadLine();
        }
    }
}