Access modifier in C#

                                                                                                                Previous...

                                                                                                                        Next..

Access modifiers are an integral part of object-oriented programming. They support the concept of encapsulation, which promotes the idea of hiding functionality. Access modifiers allow you to define who does or doesn't have access to certain features.

In C# there are 5 different types of Access Modifiers.

Modifier	Description
public	There are no restrictions on accessing public members.
private	Access is limited to within the class definition. This is the default access modifier type if none is formally specified
protected	Access is limited to within the class definition and any class that inherits from the class
internal	Access is limited exclusively to classes defined within the current project assembly
protected internal	Access is limited to the current assembly and types derived from the containing class. All members in current project and all members in derived class can access the variables.

Public Modifiers: 

The public keyword is an access modifier for types and type members. Public access is the most permissive access level.

There are no restrictions on accessing public members.

Accessibility: 

• Can be accessed by objects of the class
• Can be accessed by derived classes

Example: In the following example num1 is direct access.

using System;



namespace AccessModifiers

{

    class Program

    {

        class AccessMod

        {

            public int num1;

        }

        static void Main(string[] args)

        {

            AccessMod ob1 = new AccessMod();



            //Direct access to public members

            ob1.num1 = 100;



            Console.WriteLine("Number one value in main {0}", ob1.num1);

            Console.ReadLine();

        }

    }

}

Private Modifiers:

Private access is the least permissive access level.

Private members are accessible only within the body of the class or the struct in which they are declared.

Accessibility: 

• Cannot be accessed by object
• Cannot be accessed by derived classes

Example: In the following example num2 is not accessible outside the class.

using System;



namespace AccessModifiers

{

    class Program

    {

        class AccessMod

        {

            public int num1;

            int num2;

        }

        static void Main(string[] args)

        {

            AccessMod ob1 = new AccessMod();



            //Direct access to public members

            ob1.num1 = 100;



            //Access to private member is not permitted



            ob1.num2 = 20;

            Console.WriteLine("Number one value in main {0}", ob1.num1);

            Console.ReadLine();

        }

    }

}

The above program will give compilation error, as access to private is not permissible. In the below figure you can see the private member num2 is not available.

Protected Modifiers:

A protected member is accessible from within the class in which it is declared, and from within any class derived from the class that declared this member.

A protected member of a base class is accessible in a derived class only if the access takes place through the derived class type.

Accessibility: 

• Cannot be accessed by object
• By derived classes

using System;



namespace AccessModifiers

{

    class Program

    {

        class Base

        {

            protected int num1;

        }



        class Derived : Base

        {

            public int num2;

            static void Main(string[] args)

            {

                Base ob1 = new Base();

                Derived ob2 = new Derived();

                ob2.num1 = 20;



                // Access to protected member as it is inhertited by the Derived class

                ob2.num2 = 90;



                Console.WriteLine("Number2 value {0}", ob2.num2);

                Console.WriteLine("Number1 value which is protected {0}", ob2.num1);

                Console.ReadLine();

            }

        }

    }

}

In the above program we try to access protected member in main it is not available as shown in the picture below that num1 is not listed in intellisense.

internal modifier 

The internal keyword is an access modifier for types and type members. We can declare a class as internal or its member as internal. Internal members are accessible only within files in the same assembly (.dll).

In other words, access is limited exclusively to classes defined within the current project assembly.

Accessibility:

In same assembly (public) 

• Can be accessed by objects of the class
• Can be accessed by derived classes

In other assembly (internal) 

• Cannot be accessed by object
• Cannot be accessed by derived classes

protected internal 

The protected internal accessibility means protected OR internal, not protected AND internal.

In other words, a protected internal member is accessible from any class in the same assembly, including derived classes.

The protected internal access modifier seems to be a confusing but is a union of protected and internal in terms of providing access but not restricting. It allows:  

• Inherited types, even though they belong to a different assembly, have access to the protected internal members.
• Types that reside in the same assembly, even if they are not derived from the type, also have access to the protected internal members.

                                                                                                                Previous...

                                                                                                                        Next..

Difference between Types and Type Members in C#

                                                                                                                                           Previous....
                                                                                                                                                   Next.....



In the example below Customer is the Type and private fields(_id, _firstName, _lastName), Properties(Id, FirstName, LastName) and GetFullName() method are type members.

public class Customer

{
   

 #region Private Fields
   

 private int _id;
   

 private string _firstName;
   

 private string _lastName;
   

 #endregion

   

 #region Properties
   

 public int Id
  

  {
      

 get

 {

 return _id;

 }
     

  set

 {

 _id = value;

 }
   

 }
   

 public string FirstName
  

  {
      

  get { return _firstName;

 }
        

set

 { _firstName = value;

 }
  

  }
 

   public string LastName
  

  {
      

  get

 {

 return _lastName;

 }
        

set

 { 

_lastName = value;

 }
   

 }
   #endregion

    

#region Methods
 

public string GetFullName()
  

  {
      

  return this._firstName + " " + this._lastName;
   

 }
   

 #endregion

}

                                                                                                                                           Previous....
                                                                                                                                                   Next.....

Method Parameters in C#

                                                                                                                                             Previous.....
                                                                                                                                                       Next....

When method with parameters is called, you need to pass the parameters to the method. In C#, there are 4 ways that parameters can be passed to a method:

Mechanism	Description
Value parameters	Create a copy of the parameters passed, So modification doesn't effect each other.
Reference parameters	This method copies the reference to the memory location of an argument into the formal parameter. This means that changes made to the parameter affect the argument.
Output parameters	This method helps in returning more than one value.
Parameter array	It use "params" Keyword.

Value Parameters :-

The values of the actual parameters are copied into them. So, the changes made to the parameter inside the method have no effect on the argument. The following example demonstrates the concept:

using System;

namespace CalculatorApplication
{
    class NumberManipulator
    {
        public void swap(int x, int y)
        {
            int temp;

            temp = x; /* save the value of x */
            x = y;    /* put y into x */
            y = temp; /* put temp into y */
        }
    
        static void Main(string[] args)
        {
            NumberManipulator n = new NumberManipulator();
            /* local variable definition */
            int a = 100;
            int b = 200;

            Console.WriteLine("Before swap, value of a : {0}", a);
            Console.WriteLine("Before swap, value of b : {0}", b);

            /* calling a function to swap the values */
            n.swap(a, b);

            Console.WriteLine("After swap, value of a : {0}", a);
            Console.WriteLine("After swap, value of b : {0}", b);
 
            Console.ReadLine();
        }
    }
}

When the above code is compiled and executed, it produces the following result:

Before swap, value of a :100
Before swap, value of b :200
After swap, value of a :100
After swap, value of b :200

It shows that there is no change in the values though they had been changed inside the function.

Reference parameters

A reference parameter is a reference to a memory location of a variable. When you pass parametersby reference, unlike value parameters, a new storage location is not created for these parameters. The reference parameters represent the same memory location as the actual parameters that are supplied to the method.

In C#, you declare the reference parameters using the ref keyword. The following example demonstrates this:

using System;
namespace CalculatorApplication
{
   class NumberManipulator
   {
      public void swap(ref int x, ref int y)
      {
         int temp;

         temp = x; /* save the value of x */
         x = y;   /* put y into x */
         y = temp; /* put temp into y */
       }
   
      static void Main(string[] args)
      {
         NumberManipulator n = new NumberManipulator();
         /* local variable definition */
         int a = 100;
         int b = 200;

         Console.WriteLine("Before swap, value of a : {0}", a);
         Console.WriteLine("Before swap, value of b : {0}", b);

         /* calling a function to swap the values */
         n.swap(ref a, ref b);

         Console.WriteLine("After swap, value of a : {0}", a);
         Console.WriteLine("After swap, value of b : {0}", b);
 
         Console.ReadLine();

      }
   }
}

When the above code is compiled and executed, it produces the following result:

Before swap, value of a : 100
Before swap, value of b : 200
After swap, value of a : 200
After swap, value of b : 100

It shows that the values have been changed inside the swap function and this change reflects in theMain function.

Output parameters

A return statement can be used for returning only one value from a function. However, using output parameters, you can return two values from a function. Output parameters are like reference parameters, except that they transfer data out of the method rather than into it.

The following example illustrates this:

using System;

namespace CalculatorApplication
{
   class NumberManipulator
   {
      public void getValue(out int x )
      {
         int temp = 5;
         x = temp;
      }
   
      static void Main(string[] args)
      {
         NumberManipulator n = new NumberManipulator();
         /* local variable definition */
         int a = 100;
         
         Console.WriteLine("Before method call, value of a : {0}", a);
         
         /* calling a function to get the value */
         n.getValue(out a);

         Console.WriteLine("After method call, value of a : {0}", a);
         Console.ReadLine();

      }
   }
}

When the above code is compiled and executed, it produces the following result:

Before method call, value of a : 100
After method call, value of a : 5

The variable supplied for the output parameter need not be assigned a value the method call. Output parameters are particularly useful when you need to return values from a method through the parameters without assigning an initial value to the parameter. Look at the following example, to understand this:

using System;

namespace CalculatorApplication
{
   class NumberManipulator
   {
      public void getValues(out int x, out int y )
      {
          Console.WriteLine("Enter the first value: ");
          x = Convert.ToInt32(Console.ReadLine());
          Console.WriteLine("Enter the second value: ");
          y = Convert.ToInt32(Console.ReadLine());
      }
   
      static void Main(string[] args)
      {
         NumberManipulator n = new NumberManipulator();
         /* local variable definition */
         int a , b;
         
         /* calling a function to get the values */
         n.getValues(out a, out b);

         Console.WriteLine("After method call, value of a : {0}", a);
         Console.WriteLine("After method call, value of b : {0}", b);
         Console.ReadLine();
      }
   }
}

When the above code is compiled and executed, it produces the following result (depending upon the user input):

Enter the first value:
7
Enter the second value:
8
After method call, value of a : 7
After method call, value of b : 8

Parameter array

It use "param" keyword

using System;

   class Programme
   {
      public static void ParamsMethod(params int[] Numbers)
      {
          Console.WriteLine("there are {0} element ":, numbers.length);
          foreach ( int i in numbers)
          Console.WriteLine(i);                                                  
          } 
      }
   }                                                                                        public static void Main()
      {
         Number[0] = 101
         Number[1] = 102         Number[2] = 103
         ParamsMethod(1,2,3,4,5);// param method or param method(number)
         }
         
        
      }
   }
}

we can not use    "public static void ParamsMethod(params int[] Numbers, Int number) because param keyword should be last keyword.
we can not use    "public static void ParamsMethod(params int[] Numbers, Params number) because param keyword should be one.



                                                                                                                                             Previous.....
                                                                                                                                                       Next....