Encalsulation vs Abstraction

• Encapsulation is a procedure of covering up of the data & functions into a single unit called as class
• An encapsulated object is often called an abstract data type.
• Encapsulation can protect your data from accidental corruption.
• Rather than defining the data in the form of public, we can declare those fields as private.

 public class School
{
 private string Schooldepartname;
 public string SchoolDepartname
 {
  get
  {
   return Schooldepartname;
  }
  set
  {
   Schooldepartname =value;
  }
 }
}
public class Departmentmain
{
 public static int Main(string[] args)
 {
  School d= new School();
  d.SchoolDepartname="Communication";
  Console.WriteLine("The Dept. Name is :{0}",d.SchoolDepartname);
  return 0;
 }
}
Output:
The Dept. Name is : Communication

Benefits of Encapsulation :

• In Encapsulation fields of a class can be read-only or can be write-only.
• A class can have control over in its fields.
• A class can change data type of its fields anytime but users of this class do not need to change any code.

From the above we can see the use of Encapsulation by using properties. The property has two accessor get and set. The get accessor returns the value of the some property field. The set accessor sets the value of the some property field with the contents of "value". Properties can be made read-only. This is accomplished by having only a get accessor in the property implementation.

• Abstraction refers to the act of representing essential features without including the background details or explanations.
• Abstraction defines way to abstract or hide your data and members from outside world.
• Classes use the concept of abstraction and are defined as a list of abstract attributes.
• Simply speaking Abstraction is hiding the complexities of your class or struct or in a generic term Type from outer world.
• This is achieved by means of access specifiers.

Access Modifier	Description (who can access)
Private	Only members within the same type.  (default for type members)
Protected	Only derived types or members of the same type.
Internal	Only code within the same assembly. Can also be code external to object as long as it is in the same assembly.  (default for types)
Protected internal	Either code from derived type or code in the same assembly. Combination of protected OR internal.
Public	Any code. No inheritance, external type, or external assembly restrictions.

namespace AbstractionExample
{
public abstract class Shape
        {
            private float _area;
            private float _perimeter;
            public float Area
            {
                get
                {
                    return _area;
                }
                set
                {
                    _area = value;
                }
            }
            public float Perimeter
            {
                get
                {
                    return _perimeter;
                }
                set
                {
                    _perimeter = value;
                }
            }
            public abstract void CalculateArea();
            public abstract void CalculatePerimeter();
        }
}

Advantages of abstraction are the hiding of implementation details, component reuse, extensibility, and testability. When we hide implementation details, we reveal a cleaner, more comprehensible and usable interface to our users. We are separating our interface from our implementation, and this makes component reuse more practical.