Introduction

We have successfully completed Day 1  before coming here.

Day 2 Agenda

1. Namespaces
   
2. Classes
   
3. Abstraction
   
4. Encapsulation
   
5. Inheritance
   
6. Properties
   
7. Access Modifiers
   

If would recommend watching videos from below image for full in depth topics. Just click on the below image you would be navigated to the Videos.

Namespaces

Why Namespace?

• Namespace help us organize our programs.
  
• They help us to avoid name clashing.
  
• To control the scope of the class and method name in our Projects.
  

Syntax: Namespace nameofNamespace

“Namespace is a collection of classes and are used to organize them.”

System.Console.WriteLine(“Learn C# in 7 days!”);

Here System is a Namespace and Console is a class present in System.

Fig 1.0 Represent a Shape Namespace and its corresponding Classes

Let’s take example where we have two teams which are working on same project with same class so in order to organize them we create namespace with project name and then the namespace for subclasses as shown below:

namespace ProjectA //project name
 {
  namespace PromoTeam //to signify whose Team class is this
 {
 class A
 {
 public static void print()
 {
 System.Console.WriteLine("heelo i am PromoTeam");
 Console.ReadLine();
 }
 } }
}
 namespace ProjectA//project name
{
  namespace OMSTeam //to signify whose Team class is this
 {
  class B
 {
 public static void print()
 {
 Console.WriteLine("heelo i am OMSTeam");
 Console.ReadLine();
 }
 }
 }
}

So now when we want to access the print function of OMSTeam we will just use below code

class Program
 {
  static void Main(string[] args)
 {
  ProjectA.OMSTeam.B.print(); //Namespace.Namespace.ClassName.Method
 }
  }

Else we can use using statement for the same.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using ProjectA.OMSTeam;
using ProjectA.PromoTeam;

class Program
 
 {
 static void Main(string[] args)
 {
 A.print();
 }
 }
namespace ProjectA
{
 namespace PromoTeam
 {
  class A
 {
 public static void print()
 {
 System.Console.WriteLine("heelo i am PromoTeam");
 Console.ReadLine();
 }
 }
 }
}
 
namespace ProjectA
{
 namespace OMSTeam
 {
  class A
 {
 public static void print()
 {
 Console.WriteLine("heelo i am OMSTeam");
  Console.ReadLine();
 }
 }
 }
 } 

But when we try to access the OMSTeam class the compiler shows following error

In order to resolve this we can use fully qualified name.

class Program
 {
  static void Main(string[] args)
 {
 ProjectA.OMSTeam.A.print();
  ProjectA.PromoTeam.A.print();
 }
  }

Namespace Aliases

We can create alias name of the Namespace by using the using Statement through which we can resolve this problem using alias name of Namespace as shown below:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Omsteam=ProjectA.OMSTeam;//giving alias name to Namespace
using PromoTeam = ProjectA.PromoTeam; //giving alias name to Namespace
class Program
 {
 static void Main(string[] args)
 {
 Omsteam.A.print();
  Omsteam.A.print();
 }
  }

Now we can do the same using class Libraries as shown below:

And name the class as article.

*note I have changed the class name so that it will look more Business related.

namespace ProjectA.OmsTeam
{
 public class Article
 {
 public static void print()

 {
 Console.WriteLine("heelo i am OMSTeam");
 Console.ReadLine();
 }
 }
}

And same we will create for PromoTeam

namespace ProjectA.PromoTeam
{
  public class Article
 {
  public static void print()
 {
  System.Console.WriteLine("heelo i am PromoTeam");
 Console.ReadLine();
 }
 }
 }

Now in order to use these Namespace we need to add them in our project by adding them in references.

We will check the checkbox and select both of them to be used in our project.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using OmsTeam= ProjectA.OmsTeam; //using the namespace with alias name
using PromoTeam=ProjectA.PromoTeam; //using the namespace with alias name
 class Program
 {
  static void Main(string[] args)
  {
  OmsTeam.Article.print(); //calling the print method
  PromoTeam.Article.print();//calling the print method
 Console.ReadLine();
 }
 }

Classes and Objects in C#

When we store the list of Information regarding a type we make use of classes e.g. Employee so Employee has the varieties of Information that are needed to be stored i.e. EmployeeName, EmployeeId, EmployeePhoneNo, EmployeeAddress, Gender, Jobtitle etc. A class is a template for creating object. Class can also contain methods to perform operations related to Employee that is termed as behavior. Class is basically a template which is a repository of information and that information can be called using a Class Objects.

A class consists of state and behavior. Class data is represented by Properties/Fields and behavior is represented by methods.

Syntax: Class ClassName

Go to your project and right click and add NewItem, select class and give your Class name.

using System;

namespace ClassDef
{
 class Employee
 {
 }
}

Now add some fields and methods to an Employee class. Now I declare some data as shown below and I am using Constructor to set the value to the class data.

*note- Constructor is creation of object at run time, as soon as the object is created the Class Constructor is called. Constructors are used for object initialization and memory, field’s allocation of its class.

using System;

namespace ClassDef
{
 class Employee
 {
  string _Name;
 int _Age;
 public Employee( string Name,int Age
 {
 this._Name = Name; //this is points towards object of this classs
  this._Age = Age;
 }
  public void Information()
  {
  Console.WriteLine("The Information of the Employee is Name={0} and Age={1}",_Name,_Age);
  Console.ReadLine();
 }
 }
}

Passing the field values to the object.

using System;
 
 namespace ClassDef
{
 class Program
 {
 static void Main(string[] args)
 {
 Employee obj = new
 Employee("Saillesh",26);
 obj.Information();
 }
 }
}

As we go ahead we will see how to use properties and assigning value to the properties.

Objects

An object is instance of a class, i.e. an instance has properties for identifying its state (attributes) and methods for behavior and event for depicting the change of state defined by the class

Object Entity

Object Entity means that every object is unique and can be differentiated from other, each time the object is created an Object entity is defined. What we always see and are able to distinguish from each other is an Object.

When we talk about Saillesh Desktop, we are referring to an object of Class Desktop that can subdivide in to child classes like Desktop of Hp or Sony etc. But as here we are talking about Saillesh Desktop us talking about only this desktop and its attributes and methods.

We can see below diagram to see Saillesh Desktop behavior and Attributes.

As I said the object is instance of a class, i.e. we can say that a birth or creation of object is called instantiation.

Sample examples of a class : Girl

Circle Class

Static Classes – A static class is same as non-static class, the only difference is we cannot create object of Static class.

Note: Static class should have all the methods, fields and properties as static

Benefits:

• We don’t need to make instance of the class all the methods, fields and properties are easily accessible using Class name.
  
• No OOP principles are applicable to Static class.
  
• Do not map to Real world objects, it’s just a collection of unrelated methods or logic so that we can increase the reusability in our project.
  
• If you want cache data.
  

*Note: Constructor runs only once in Static class.

Declaration:

A static class is created by using keyword ‘Static’ as shown here:

Static class ClassName
{
//list of  properties and methods

}

Abstraction

“A view of a problem that extracts the essential information
relevant to a particular purpose and ignores the remainder of
 the information.”

 — [IEEE, 1983]

“Abstraction is the selective examination of certain aspects of
    a problem. The goal of abstraction is to isolate those aspects
    that are important for some purpose and suppress those aspects
    that are unimportant.”

        — [Rumbaugh et al, 1991]

“[A] simplified description, or specification, of a system that
    emphasizes some of the system’s details or properties while
    suppressing others. A good abstraction is one that emphasizes
    details that are significant to the reader or user and suppress
    details that are, at least for the moment, immaterial or
    diversionary.”

        — [Shaw, 1984]

Source: http://www.tonymarston.co.uk/php-mysql/abstraction.txt

Encapsulation

“Encapsulation is used as a generic term for techniques which
  realize data abstraction. Encapsulation therefore implies the
    provision of mechanisms to support both modularity and information
    hiding. There is therefore a one to one correspondence in this
    case between the technique of encapsulation and the principle of
    data abstraction.”

        — [Blair et al, 1991]

“Data hiding is sometimes called encapsulation because the data
    and its code are put together in a package or ‘capsule.’”
  — [Smith, 1991]

"Encapsulation -- also known as information hiding --
prevents clients from seeing its inside view, were the behavioof the
abstraction is implemented."

        -- [Booch, 1991]

Source: http://www.tonymarston.co.uk/php-mysql/abstraction.txt

From the above definitions, we figured out that Abstraction is more collective thing the principle of Object oriented programming and denotes to show something in simpler way e.g. Building blocks of Building, such as color or shapes.
What is necessary to the User and essential feature of the object to the End User and ignoring the inessential details? While Encapsulation is a strategy used as part of abstraction to implement the abstraction, wrap data in a unit or capsule i.e. Class. It keeps the data safe from outside code. It refers to the object of the class. We access the class by instantiating the class object. Object properties and method can be hidden from the end user.

Note* Here end user is perspective to the User who references your DLL File. Now we use reference of object then it will show only necessary methods and properties and hide methods which are not necessary which we have hided from the external User.

For Example I have Meeting Management System App

Where when I create the MOM Minutes of the Meeting and insert the Meetings details to the DB for e.g. using Function

• CreateMOM()
  

When this function executes it first it adds the Meeting Name, Segments (Retails, Audit, Operational etc.) creates the MeetingId for the MOM and then based on the Meeting Id after that based upon the MeetingId it internally calls other methods that creates the child of Meeting as shown below:

• Participants in the Meeting (Employees who participated in the Meeting)
  
• Agenda Covered in the Meeting
  
• File uploaded (any excel file)
  
• Format Function Covered
  
• Sending mail to all the participants related what action was taken in the meeting.
  

So we can imagine that there is couple of step it does.

• Now imagine we have another User or Client who is consuming our class rather than telling him all the things we just tell him the method name CreateMOM(), as Abstraction we are hiding the user only the necessary function and encapsulation is hiding the other complex things from it. (Adding participants to other sub tables, agenda covered in the meeting etc.) We implement the encapsulation using Access Modifiers (Private).
  

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using System.Data.SqlClient;

//Abstraction Namespace

namespace Abstraction

{

///
<summary>

/// Meeting Class contains list of Properties and functions for the Meeting Creation

///
</summary>

class
Meeting

{

private
int _Id;

private
string _Name;

public
string Name

{

get

{

return _Name;

}

set

{

_Name = value;

}

}

private
string _Format;

public
string Format {

get

{

return _Format;

}

set

{

_Format=value;

}

}

private
string _Location;

public
string Location {

get

{

return _Location;

}

set

{

_Location=value;

}

}

private
string _FileUploaded;

public
string FileUploaded

{

get

{

return _FileUploaded;

}

set

{

_FileUploaded = value;

}

}

public
bool InsertToDb()

{

try

{

this._Id = AddandGetMeetingId(_Name, _Format, _Location);

bool Status = AdduploadedFiles(this._Id,_FileUploaded);

if(Status ==true)

{

return
true;

}

else

{

return
false;

}

}

catch(Exception ex)

{

throw
new
Exception(ex.Message.ToString());

}

}

private
int AddandGetMeetingId(string MeetingName,string FormatName,string MeetingLocation)

{

try

{

DAL objDal=new
DAL();

int Id= objDal.CreateMom(MeetingName,FormatName,MeetingLocation);

return Id;

}

catch (Exception ex)

{

throw
new
Exception(ex.Message.ToString());

}

}

private
bool AdduploadedFiles(int id,string FileName)

{

try

{

DAL objDal = new
DAL();

bool status = objDal.CreateMom(id,FileName);

return
true;

}

catch (Exception ex)

{

throw
new
Exception(ex.Message.ToString());

}

}

}

}

Now here I have set the Class properties _id private and function AddandGetMeetingId and AdduploadedFiles as private because I don’t want end user to see these methods and Properties. Now when I am consuming this class I am only able to see methods and properties which I want User to see hiding the complexities from him and only showing the necessary information that is necessary.

We can see from above diagram that only required information is shown the User. User access the class method as shown below

try

{

Console.WriteLine(“Enter the Meeting Name”);

objMeeting.Name = Console.ReadLine();

Console.WriteLine(“Enter the Format Name”);

objMeeting.Format = Console.ReadLine();

Console.WriteLine(“Enter the Meeting Location”);

objMeeting.Location = Console.ReadLine();

Console.WriteLine(“Enter the file Uploaded”);

objMeeting.FileUploaded = Console.ReadLine();

bool status = objMeeting.InsertToDb();

if(status==true)

{

Console.WriteLine(“Minutes of Meeting Created Successfully”);

}

else

{

Console.WriteLine(“Failed to Created Minutes of the Meeting”);

}

Console.ReadLine();

}

catch (Exception ex)

{

Console.WriteLine(ex.Message.ToString() +” “+ex.StackTrace.ToString());

}

And DAL Layer which will insert data to the Database

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using System.Data.SqlClient;

using System.Configuration;

namespace Abstraction

{

public
class
DAL

{

public
static
SqlConnection con;

static DAL()

{

con=new
SqlConnection( ConfigurationManager.ConnectionStrings[“DBclass”].ConnectionString);

}

public
int CreateMom(string MtngName,string FrmtName,string Location)

{

try

{

string query = “insert into tblMeetingMaster values (‘” + MtngName + “‘,’” + FrmtName + “‘,’” + Location + “‘)”;

SqlCommand cmd = new
SqlCommand(query, DAL.con);

con.Open();

cmd.ExecuteScalar();

string query2 = “select IDENT_CURRENT(‘tblMeetingMaster’)”;

SqlCommand cmd1 = new
SqlCommand(query2,DAL.con);

decimal value = (decimal)cmd1.ExecuteScalar();

return
Convert.ToInt32(value);

}

catch (Exception ex)

{

throw
new
Exception(ex.Message.ToString());

}

finally

{

con.Close();

}

}

public
bool CreateMom(int MeetingId, string FileName)

{

try

{

string query = “insert into tblFileUploaded values (‘” + MeetingId + “‘,’” + FileName + “‘)”;

SqlCommand cmd = new
SqlCommand(query, DAL.con);

con.Open();

cmd.ExecuteNonQuery();

return
true;

}

catch (Exception ex)

{

return
false;

throw
new
Exception(ex.Message);

}

finally

{

con.Close();

con.Dispose();

}

}

}

}

End User Inputs the Details

Values inserted in DB

Inheritance

From the above Diagram you can predict there are two Classes Football Player, Cricket player both of them are having lots of common properties and methods. So in order to duplicate code in both the classes we move all duplicate code into base class called Player.

Inheritance is a parent child relationship in an object oriented programming where we can create a Parent class and extend the functionality of parent class by creating child class.

While talking about above classes the specific code that left respective two them is football is in football we have Goals Scored, while in Cricket we Run Scored etc. Let go ahead and implement the same as written below.

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace Inheritance

{

public
class
Player

{

public
string PlayerName;

public
string ClubName;

public
string PlayGround;

public
void PlayerDetails()

{

Console.WriteLine(“THE Player details are PlayerName {0}, Registered to{1} playing in {2}”,PlayerName,ClubName,PlayGround);

Console.ReadLine();

}

}

public
class
CricketPlayer:Player

{

public
int Runscored;

}

public
class
FootballPlayer : Player

{

public
int GoalScored;

}

}

• In this above example derived class inherits from the Parent class
  
• C# Supports only single class inheritance.
  
• Child class is a specialization of base class.
  
• Parent classes are automatically instantiated before derived class.
  
• Parent class constructs executes before child class.
  

In interview sometimes Interviewer asks us which constructor will be called first when we call a child class constructor?

Parent classes are automatically instantiated before derived class, as soon as we create an object of child class the parent class Constructor is called as shown below.

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace ParentClassConstructor

{

public
class
Parent

{

public Parent()

{

Console.WriteLine(“Parent class constructor called”);

Console.ReadLine();

}

}

public
class
Child : Parent

{

public Child()

{

Console.WriteLine(“Child class constructor called”);

Console.ReadLine();

}

}

class
Program

{

static
void Main(string[] args)

{

Child objChild = new
Child();

}

}

}

Properties

Property is a member that provides the mechanism to what gets assigned and what gets returned from your fields/classes variables. In simple terms we can say that properties help us to inject the logic inside the fields /classes variables. By using the Access modifiers we can make it possible to what gets assigned and what gets returned from your fields. Properties implements Encapsulation because it hides the complexity from the User.

Why Properties:

• As discussed earlier if we make our class fields public we will not have any control on what gets assigned and what gets returned from your fields.
• Below are the scenarios which we face when our fields are public

Below is a class called Employee Class with public fields ID.

• Our Business rule say that ID should not be less than 1
• Name cannot be set to NULL
• Marks Should be Read only

But as we can see below we are able to change the values and assigned the same to our fields.

public class Employee

{

public int ID;

}

public class Program

{

static void Main(string[] args)

{

Employee obj = new Employee ();

obj.ID = -100; // ID should not be less than 1

obj.NAME = null; // name should not be empty

obj.MARKS = 20; //Marks should be a read only property but here we are able to change it

Console.WriteLine(“the values of the new object are ID {0} ,NAME {1}, MARKS {2} “, obj.ID, obj.NAME,obj.MARKS);

Console.ReadLine();

}

}

When I execute the application we will see that all are Business rules has been violated and there is no message to the user for the same.

So in order to validate the Business rule we use get and set methods properties in C#. The programming language that before properties they use Getter and Setter(for better understanding) method as shown below.

Firstly we create our property to be private so that they won’t be accessible to the external world.

Now we write to methods for set and get i.e. SetId, GetId to control what’s get into the fields and what set into the fields of class.

Now I initialize the object of Employee class we find that we are not able get access to our fields rather we are able to access SetId and GetId methods. Now I set the value to the _id field as shown below

Now I as I set the value of id as -100 and than call the obj.Getid we see how the flow of program goes.

STEP1. Once the object is created we try to set the value of _id=-100

STEP2. As the id value passed is less than 1 it enters the exception and throw a new exception for the same.

STEP 3. It enters the catch block and will print the exception message as shown below.

Now we input a correct value which is greater than 1 and print the value using getId function as shown below.

Now we are following the business rules so the output will be

So now we can see that these methods are allowing us to control over what gets assigned and returned.

Now we will see how we in C# we implement Properties in order to hide complexity from the User (Encapsulation).

In order to use a property you have to write

Or we can use code snippet shortcut prop and press tab for the same.

And then create your get and set accessor as above.

Now before as we created the object of Employee class and we called the function getID and setId but now we will not get any method beside no will get ID Property as shown below.

Now how will it be checked once the value of property ID is passed to the set accessor it has keyword called (value)

Once the value of is assigned to property ID it calls the set accessor as shown below:

And for getting the values of the id we have to just write object name than property name, it invokes the id provide and it invokes the get accessor of this property and returns a value which is present in private.

As we can see get and set are Read Write properties, user can write a value to the fields and same he can read the value from the fields.

So what if want an only read only field like pi in math’s that is 3.14 or other ready only fields as per business logics.

For this we need to make our property with only get accessor

Eg. Here I am taking an example of bonus which is same for all employees in order to make it a read property will assign only get accessor to it as shown below.

Now if I try and change the property to something else

It shows that it value cannot be assigned as it’s a read only property i.e. we can only read the value, not assign them.

And if in case you want to make a property you want to write only than you have to use only set accessor.

Auto Implemented Properties: As earlier discussed short cut for property prop, actually
Microsoft introduces auto implemented properties in C# 3.0 for scenarios where we don’t
want to inject any logic Eg. City etc. In Auto Implemented we don’t have to create private fields because compiler will automatically create for us private field and the public property will be used to read and write to that property

Eg. Of Auto Implemented Property

public
int MyProperty { get; set; }
//Just one line

Note: In the end I want to end this article saying that the advantage of using properties is that we don’t have to create function for what gets and set in the fields. In properties the compiler on its own generates getter and setter methods as we did earlier before properties when it parses the C# property syntax as per the algorithm defined.

Access Modifiers

All Class members’ behavior, data and class have their accessibility level, which specify that whether they can accessed from other code in your Assembly.

There are 5 types of different Access Modifiers in C#:

• Private
  
• Protected
  
• Friend
  
• Protected Friend(Protected Internal)
  
• Public
  

Image Source:
http://dotnethints.com/blogs/public-vs-protected-vs-private

In Private
Access modifier only the members of class can access to the function or variable or it accessibility level is within the containing class.

For ex.

We have a Customer Class with two properties

CustomerID and CustomerName as shown below

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace AccessModifier

{

public
class
Customer

{

private
int _id;//declared with private

private
string _CustomerName;

public
int id //public property with get and set accessor

{

get

{

return id;

}

set

{

id = value;

}

}

public
string CustomerName

{

get

{

return _CustomerName;

}

set

{

CustomerName = value;

}

}

}

}

Now once I try to access the private property outside the class I wouldn’t be able to access them due to its protection level.

We can only access the Public Properties not private fields.

If I try to access the public members there are no errors and we can easily access them.

namespace AccessModifier

{

class
Program

{

static
void Main(string[] args)

{

Customer c1 = new
Customer();

c1.id = 1;

c1.CustomerName = “saillesh”;

}

}

}

So here we also learnt about Public access modifier all members are accessible in all classes and projects. I.e. Any where

Protected: In Protected access modifiers all the members of the class are accessible to the class member and to the derived classes.

Now I create two classes one Customer and GoldCustomer. Gold Customer inherits from Customer class as shown below

using System;

namespace AccessModifier

{

public
class
Customer

{

protected
int _id;

protected
string _CustomerName;

public
int id

{

get

{

return id;

}

set

{

id = value;

}

}

public
string CustomerName

{

get

{

return _CustomerName;

}

set

{

CustomerName = value;

}

}

}

public
class
GoldCustomer : Customer

{

private
float _Discount;

public
float Discount

{

get

{

return _Discount;

}

set

{

_Discount = value;

}

}

public
void PrintDetails()

{

GoldCustomer cust = new
GoldCustomer();//creating object of child class

cust._id = 1; ///we can access the protected value of parent class

cust._CustomerName = “Nishant”; //same goes here

}

}

}

Calling Program.cs

If I try to access it from outside the class we can see that it is inaccessible due to its protection level. So if you want to access the protected class member you can access it from child class using child class object inside a class or using Base
keyword.

Friend (Internal): The members with internal access modifiers are available anywhere in the containing project or assembly.

To demonstrate the same we need to add one more project as mentioned below.

Add Class library and Name it Project1

using System;

namespace Project1

{

public
class
SilverCustomer

{

internal
string CustomerName = “saillesh”; //internal

}

public
class
BronzeCustomer

{

public
void details()

{

SilverCustomer obj = new
SilverCustomer(); //we create an instance of Silver Customer

Console.WriteLine(obj.CustomerName);//we can easily access the member of SilverCustomer

}

}

}

Now once I try it from other main project let see what happens so for the same I have added Project1 class to main project to use the same

As shown below

using System;

using Project1;//using the Namespace

namespace InternalExample

{

class
Program

{

static
void Main(string[] args)

{

SilverCustomer objSilver = new
SilverCustomer();

}

}

}

Now as soon as I try to access the Internal member we would not be able to access the member and if try to input the member name we will face the compile time error.

Now Protected Internal it’s the combination of both Internal and Protection. All members in current project and all members in derived class in any other project /assembly can access the members. Don’t get confused it means that the class of different project who is inheriting this class will be able to access the member. You can see that as shown below.

Main class of Project1 named as SilverCustomer

using System;

namespace Project1

{

public
class
SilverCustomer

{

protected
internal
string CustomerName = “saillesh”;

}

}

Now in other project I create Platinum Customer Class

using System;

using Project1;//using the project1 namespace

namespace InternalExample

{

public
class
PlatinumCustomer: SilverCustomer //inheriting the SilverCustomer Class

{

public
void details()

{

PlatinumCustomer obj = new
PlatinumCustomer();

obj.CustomerName = “Ankit Negi”; we can see that SilverCustomer protected Intenal member is accessible to other project

}

}

}

Conclusion

Here we complete our day 2. In Day 3 we will take our C# class to next Contents. If any confusion you can comment for the same. Add on information is heartily welcomed.