Access Modifier In C# With Example

Example 2

class ProtectedSample2
{
    protected string Name = string.Empty;

    static void Initialize(ProtectedSample2 objA, Drive objDrive)
    {
        objA.Name = "Mike";
        objDrive.Name = "Clark";
    }
}

class Drive : ProtectedSample2
{
    static void Initialize(ProtectedSample2 objA, Drive objDrive)
    {
        objA.Name = "Mike"; // Error: Cannot access protected member via a qualifier of type
                            // 'ProtectedSample2', the qualifier must be of type 'Drive'
        objDrive.Name = "John";
    }
}

Internal

Using Internal, access is limited to the current assembly not by other assembly. A common use of internal access is in component-based development because it enables a group of components to cooperate in a private manner without being exposed to the rest of the application code.

namespace Cons.Accessibility
{
    internal class InternalSample
    {
        public void Display()
        {
            Console.WriteLine("In InternalSample.Display");
        }
    }
}

namespace Cons.Other
{
    class Test
    {
        Cons.Accessibility.InternalSample obj = new Cons.Accessibility.InternalSample();

        public void Display()
        {
            obj.Display();  // Valid
        }
    }
}

// In different Assembly
using Cons.Accessibility;

namespace TestingApplication
{
    class Program
    {
        static void Main(string[] args)
        {
            InternalSample obj = new Cons.Accessibility.InternalSample();  // Error: Inaccessible due
                                                                           // to protection level
        }
    }
}

Protected Internal

Using Protected Internal, accessibility is limited to the code in assembly in which it is declared, or from within a drive class in another assembly. Access from another assembly must take place within a class declaration that derives from the class in which the protected internal element is declared, and it must take place through an instance of the derived class type.

namespace Cons.Accessibility
{
    public class ProtectedInternalSample
    {
        protected internal string Name = string.Empty;

        protected void Display()
        {
            Console.WriteLine("Name: " + this.Name); // Valid
        }
    }

    public class PIDrived : ProtectedInternalSample
    {
        PIDrived()
        {
            this.Name = "John"; // Valid
        }
    }
}

// Other Namespace but same assembly
namespace Others
{
    class Other
    {
        Other()
        {
            Cons.Accessibility.ProtectedInternalSample obj = new Cons.Accessibility.ProtectedInternalSample();
            obj.Name = "Mike";
        }
    }
}

// Diff assembly
using Cons.Accessibility;

namespace TestingApplication
{
    class Program : ProtectedInternalSample
    {
        public void UpdateName()
        {
            Name = "Clark"; // Valid
        }
    }
}

In the above example, if we remove Protected keyword from the Name variable, then it will not be accessible in diff assembly.

Private

Using Private, accessibility is limited to the code that are only in containted type.

class PrivateSample
{
    private string Name = string.Empty;

    public void Initialize()
    {
        this.Name = "John";
    }
}

class POther
{
    public void Initialize()
    {
        PrivateSample obj = new PrivateSample();
        obj.Name = "Mike";    // Error: Inaccessible due to protection level
        obj.Initialize();     // Valid
    }
}

Hope this will add some knowledge to your knowledge base.