C#

When we create objects in .NET we don’t need to explicitly release these objects after we have used them.This is because the garbage collector takes care of releasing the memory occupied by the object once that object goes out of scope.

This is really helpful because we are not required to explicitly delete the objects.Garbage collector takes care of releasing only the managed objects.This means that if our object is accessing some unmanaged resources then these resources will not be garbage collected by the garbage collector.

Since these resources are not automatically garbage collected like the other resources it is the responsibility of the programmer to release these resources .Framework provides IDisposable interface to release such unmanaged resources.This interface defines a single Dispose method ,the job of which is to release the unmanaged resources.

So if we are creating an object of SqlConnection class ,which is used for connecting to databases then we can call Dispose method on this object as:

SqlConnection conn = new SqlConnection(connString);

conn.Open();
//use the conn object
conn.Dispose();

Though the above code disposes the connection object yet it can fail when an exception occurs.To handle this situation we can use the exception handler.So we can use the following code to properly dispose the connection object even in the case of exceptions.

SqlConnection conn = new SqlConnection(connString);

try
{
conn.Open();
}
finally
{
conn.Close();
}

Using statement in C#

Since calling the Dispose method is such a common scenario ,so framework provides us with a short form for calling the Dispose method.

“using” statement in C# is a compact form of writing the Disposable object in a try finally block. .We can write the above code with  “using” statement as:

using(SqlConnection conn = new SqlConnection(connString))
{
//use the conn object
}

We can generalise this syntax as:

using(create object of type implementing IDisposable)
{
//use the object
}

The object created in the using() goes out of scope once the using() block ends.So we can not access the object outside the using() block.

Following are the advantages of creating an object in a using statement:

• It provides a compact syntax for calling the Dispose method.
• While if call the Dispose method explicitly we can forget to call the method ,”using” statement ensures that the Dispose method is always called.
• It prevents accidentally accessing the disposed objects.

If create an object and call the Dispose method explicitly and then try to access that object we will exception.For example following is a valid statement:

SqlConnection connectionObj = new SqlConnection();
connectionObj.Dispose();
var state=connectionObj.State;

Though the above statement is valid but we will get exception at line number 3 since we are trying to access an object after calling the Dispose method.

If we create the object in a using statement then the scope of the object is limited to the using block so such errors will not occur.

Below we are creating SqlConnection object in a using statement.After the using block ends we are trying to access the same object.But we can not see it in the intellisense.This is because the scope of the object is limited to the using block so we are not allowed to access the object outside the block.

 

Follow on:

Optional parameters and named arguments were added to C# in version 4.0.They are an important feature of the language which makes working with methods easier in many scenarios.

Named arguments

Often we need to call methods which have lot of parameters.So if a method has 10 parameters and many of them are of the same data type then it is really cumbersome to understand which
argument would map to which method parameter.This is where named arguments are useful.
For example we have a method defined as:

public static void Calculate(int a,int b,int c,int d,string e,int f,double g,int h )
{
//method body
}

if we try to call the above method then it can be challenging to identify which argument will map to which parameter.

Calculate(1, 44,346, 8, "hello", 433, 1.0, 67);

Though we are calling the Calculate method using the correct arguments but if look at the above method call it is not easy to understand the use of each argument.We can not say just looking at the above method call to which parameter value 67 will map to.

Instead of matching the arguments to the method parameters using the position as above we can
use the named arguments which maps the method argument to the parameter using the name
of the parameter.

Below we are calling the same method using the same arguments but this time we are using
the named arguments instead of positional arguments

Calculate(d:8, c:44,a:1,e:"hello",f:433,h:67,g:1.0,b:44);

The above method call is much easier to understand as we are easily able to identify which arguments will map to which method parameters.For example we can easily say that value 67 will be assigned to the method parameter “h”.

Optional parameters
Many times when we create a method we want some default parameter value to be used if
the caller of the method doesn’t provide any valid value for a method parameter.In such
a scenario instead of letting the caller of the method provide any dummy value for the
parameter we can let the caller of the method omit the value for such a parameter.

For example without using the optional parameters the caller of the UpdateDetails method is required to pass null value or empty string for the designation parameter.As the caller don’t know what value to pass for the designation parameter he is forced to pass  null or it is empty string.

If the value of the designation parameter is null or empty string then a default value is assigned to the designation parameter.

public void UpdateDetails(string name, string designation, string address)
{
if (string.IsNullOrEmpty(designation))
{
designation = "Application developer";
}
//method body
}

Instead of assigning the value of the designation parameter based on its value passed by the caller we can just assign a default value to the designation parameter

public static void UpdateDetails(string name, string address, string designation = "application developer")
{
//method body
}

Now the caller of the method is not required to pass empty or null value to designation parameter. Caller can just call the UpdateDetails method without passing any value for the designation parameter.

UpdateDetails("Mark", "France");

The important thing to understand while using the optional parameters is that once we declare a method parameter as optional the parameters declared in the parameter list after the optional parameter should also be optional.

For example the following is invalid and compiler will not compile the below code

public static void UpdateDetails(string name,string designation = "application developer", string address)
{
//method body
}

Optional parameters and named arguments in C# 4.0 are useful to easily implement some common scenarios.

Named arguments can be useful for scenarios which otherwise requires method overloading.For example we can replace the following overloaded methods

public int Add(int a, int b)
{
return a + b;
}

public int Add(int a, int b, int c)
{
return a + b + c;
}

with the below method using optional parameters

public int Add(int a, int b, int c=0)
{
return a + b + c;
}

So optional parameters in C# 4.0  are useful for avoiding redundant  code.Instead of defining lots of method overloads we can define just a single method with default parameter values.

Follow on:

Extension methods in C# are used to add methods to an existing type without modifying the type.If there is some existing type then for adding some new functionality to the type we can either modify the type or derive a new type that extends the original type.Both of these approaches requires recompiling the source code.Since the source code is required to be modified hence this approach suffers from the following disadvantages

• Many times we don’t have access to the source code such as while using the code written by other developers.
• Modifying the original type requires recompilation and retesting of the existing functionality

Suppose we have a class called Calculate which defines a method called Sum.

class Calculate
{
public int Sum(int a,int b)
{
return a + b;
}
}

Now we have a requirement to add Substract method to this class.We don’t have access to the source code of this class as this was developed by another developer.So we can not modify this class to add the Substract method.This is where we can use extension method to add  the Substract method to the Calculate class.

Defining extension methods is easy ,we just need to do the following for defining an extension method:

• We have to define our method as static in a static class.
• The first parameter to the extension method should be declared with the “this” keyword.

So we can add Substract method to the Calculate class as:

static class CalculateExtension
{
public static int Substract(this Calculate cal, int a, int b)
{
return a - b;
}
}

We can consume the Substract extension method just like the Calculate method.So for the client of the Calculate class there is no difference between the method defined in the class and the extension method:

static void Main(string[] args)
{
Calculate cal=new Calculate();
int total=cal.Sum(1,8);
Console.WriteLine("Total={0}",total);

int difference=cal.Substract(5,2);
Console.WriteLine("Difference={0}",difference);

Console.ReadLine();
}

To use the extension method defined on a type we should import the namespace in which the class containing the extension method is defined.Mostly the class in which we define the extension method will be in a different namespace then the class for which the extension method is defined.

For example the Calculate class and the CalculateExtension class in the above example could be defined in a separate namespaces.So we can define the CalculateExtension class in a namespace called Extension

namespace Extension
{
static class CalculateExtension
{
public static int Substract(this Calculate cal, int a, int b)
{
return a - b;
}
}
}

Now to use the above extension method we just need to import the Extension namespace.Once we import the Extension namespace through the using Extension;  import statement we can call the Substract method using an object of the  Calculate class as if it is defined by the Calculate class.

A common example where extension methods are used in c# are the LINQ query operators.These query operators are defined in the System.Linq namespace and extend the collection classes.To use these query operators we need to bring the System.Linq namespace in scope:

using System.Linq;

To see these query operators in action we can use a normal array.We create an array object and see the methods defined by the array object we can see the following methods

But now if we bring the query operators in scope by using the  using System.Linq; statement we are able to see the following methods on the same array object

The extra methods which we are able to see are the extension methods provided by the classes in the System.Linq namespace.

 

Follow on:

SOLID is an acronym for the five design principles.These design principles help create more maintainable and bug free applications.The five design principles in SOLID are:

• S  stands for the Single Responsibility Principle
• O stands for the Open Closed Principle
• L stands for the Liskov Substitution Principle
• I stands for the Interface Segregation Principle
• D  stands for the Dependency Inversion Principle

For other design priciples please refer

• Single responsibility principle
• Liskov substitution principle
• Interface segregation principle
• Dependency Inversion Principle

Here we will look into the Open closed principle.According to the open closed principle we are allowed to add behaviour to a class but not able to modify it.In other words whatever functionality is already implemented by a class we should be able to extend that functionality through inheritance but not allowed to change its existing implementation.

Lets understand this with an example.Suppose we are developing a software application for a college.A college have lots of students in different standards.Different Standards have different subjects,a student in class 10th will have different subjects then the one in class 1st.So to calculate the percentage of marks for students different criteria can be used.For example a subject such as maths can carry more weightage than a subject such as craft.

In the following example we have defined two classes

• Student  Represents the Student
• Subject   Represents a subject such as Maths.

The Student class declares a method called score which will calculate the average score of the student.In this method we are using a different logic for score calculation of students in Category1 and students in Category2 which are based on the class such as High school.

class Student
{
public string Name { get; set; }
public string Address { get; set; }
public string RollNo { get; set; }
public int Class { get; set; }
public float Score { get;set;}
public List<Subject> Subjects { get; set; }
  public float CalculateScore()
 {
 float totalScore=0;
 //calculation logic for students in Category 1
 if(Category==1)
 {
 //calcualte percentage
 float sum=Subjects.Sum(x => x.Score);
 int total=Subjects.Count();
 totalScore=sum / total * 100;
 }
////calculation logic for students in Category 2
 else if (Category==2)
 {
 //calcualte percentage based on weightage
 float sum = Subjects.Sum(x => (x.Score * x.weightage) );
 int total = Subjects.Count();
 totalScore = sum / total * 100;

 }

 return totalScore;
 }
}

class Subject
{
public string Name { get; set; }
public float Score { get; set; }
public float weightage { get; set; }
}

So our application works fine now and is able to calculate the score of students based on his class or standard.

But if the score calculation logic changes tomorrow for students between class 6 to class 8th ,called Category 3,to include only the top 5 scoring subjects,then we may again have to modify the Student class.

else if (Category==3)
{
//calcualte percentage based on weightage and top 5 scoring subjects
float sum = student.Subjects.OrderBy(x=>x.Score).Take(5).Sum(x => (x.Score * x.weightage));
int total = student.Subjects.Count();
totalScore = sum / total * 100;

}

Every time there is change in score calculation logic our Student class needs to be modified.

Not only we have to modify the Student class we need to retest all the existing functionality and also have to redeploy the entire application.This doesn’t sound very logical.After all we should only test and deploy the new functionality and not all the existing functionality.The solution to this problem is the Open closed principle.

Instead of defining the functionality for all the Students in the common Student class we will add a new abstract class called BaseStudent .Every time we need to add a new category of Students we add a new class instead of modifying the existing Student class.The class for students in Category1 can be defined as:

public abstract class BaseStudent
{
public abstract float Score();
}

class StudentCategory1 : BaseStudent
{
public string Name { get; set; }
public string Address { get; set; }
public string RollNo { get; set; }
public int Class { get; set; }
public float Score { get;set;}
public List<Subject> Subjects { get; set; }
//calculation logic for students in standards less than 8th
public float CalculateScore()
{
float totalScore=0;
//calcualte percentage
float sum=Subjects.Sum(x => x.Score);
int total=Subjects.Count();
totalScore=sum / total * 100;
return totalScore;
}

}

Each time there is a requirement to add a new category of students we add a new StudentCategory class deriving from BaseStudent class which defines the abstract method CalculateScore.

So we have applied the open closed principle in our existing design and have got the following advantages:

• We don’t need to modify the existing Student class ,which has already been tested.
• There is less chance of breaking the existing functionality because of change in requirement.
• The new requirement can easily be accommodated as we don’t have to struggle to modify an already existing class.

Follow on:

Before implementing Repository pattern in C# ,it would be useful to first understand what is Repository Design Pattern.It is about how an application stores and retrieves data from the data stores which actually stores the application data.

In a single line we can say “Repository pattern allows development of applications which are decoupled from the underlying data storage mechanisms”. Here we will understand the need of repository pattern and how to implement repository pattern in C#

In many applications the data access logic is mixed with the business logic.This results in tight coupling of the business logic and data access logic.Any change in data access logic should not affect any other part of the application.

Application without Repository pattern

Most of the software applications follow some common architectural guidelines and consists of different layers.This is called a n-tier architecture. So an  n-tier application usually consists of different tiers such as presentation tier, middle tier and the data tier.

Presentation tier provides the interface by which user interacts with the application.Middle tier includes the business functionality and also interacts with the database.Data tier defines the data storage or persistence mechanism used such as the SQL Server or the Oracle database.

Since most of the applications use a separate data storage mechanism such as SQL Server , there should be some mechanism in the application which allows the application to access the data store.This data interaction logic is commonly included in the data tier component.

Problems in Data Layer directly accessing the data store

There are few problem of including the data access functionality in the middle tier.Some of these are:

• Since the data access logic is mixed with business logic so the data access code is very likely to get duplicated in the middle tier.
• Difficulty in unit testing and automation testing of the business logic and the data access logic.
• Difficulty in implementing a common data access policy.
• If the data access code is dispersed in the business logic layer then it is very difficult to make even a small change in the data access logic.
• Code is difficult to maintain and even simple business logic change could affect other parts of the applications.Similarly change in the back end store could break the business logic.

Solution is Repository Pattern

Repository Pattern is used to create an abstract layer through which the application communicates with the data store.Examples of data stores are SQL Server ,Oracle,XML ,Lists in Sharepoint.So instead of directly accessing these data storage systems ,application communicates through this abstract Repository.

 What is Repository Pattern

Repository pattern provides a solution to these problems.It acts as a mediator between the business logic layer and the data source.By implementing repository our application becomes persistent mechanism ignorant.The business logic layer directly communicates only with the repository and is not aware of the data source being used by the application.

The business logic layer makes requests for the entities to the repository,repository retrieves the entities from the database and returns them to the business layer.Business layer may also request the repository to update the entities.In this process the mapping of the database values to the entities is also taken care of by the repository so the business layer is aware of just the entities.

The repository creates an abstraction with which our business logic layer needs to deal with.What this means is that we can easily swipe specific implementation of a repository with another one easily and with no modification to our code.
The data access logic is defined in a repository rather than being mixed with the business logic layer or presentation layer so we can easily reuse the repository across the different business logic classes.

How Repository Pattern is implemented in C#

The way to implement repository pattern in our application is as:

1. Define an interface for the repository.The interface declares the database operations.
2. Create a class which implements the above interface and provides the implementation
   for the interface methods.
3. Access the repository from the business layer through the interface.

It is the third step which helps create decoupled architecture and helps in unit testing.Since we are accessing the repository using the interface rather than through concrete classes we can easily point the interface to a different implementation without changing any of the business layer logic.This also helps in mocking as we can create a mock object for the repository.

In the following example we will implement repository pattern in c#.

If we have defined a Student class as:

class Student
{
public string Name { get; set; }
public string Address { get; set; }
public string RollNo { get; set; }
public string Class { get; set; }
}

We can  define an interface for Student repository as:

interface IRepository
{
void Insert(Student student);
void Delete(Student student);
void Update(Student student);
Student GetById(Student RollNo);
IQueryable<Student> FetchAll();
}

The above interface defines just the signature of the methods and the different implementations of the interface can implement them differently.For example if we want to persist the Students class details in a SQL Server database then we can use the following SQLRepository class:

class SQLRepository : IRepository
{

public bool Insert(Student student)
{
//Insert logic in sql server db
}

public bool Delete(Student student)
{
//logic to delete in sql server db
}

public bool Update(Student student)
{
//logic to update in sql server db
}

public IQueryable<Student> GetAll()
{
//logic to Retreive from sql server db
}


public Student GetById(Student RollNo)
{
//logic to Retreive by id from sql server db
}
}

Now if a client wants to use any repository class which implements the IRepository interface then it needs to reference just the IRepository interface.

For example the below Student class defines a field of type IRepository.Since the IRepository type is being passed using constructor injection ,so the Student class is not aware of the specific class implementing the IRepository interface.

class Student
{
public string Name { get; set; }
public string Address { get; set; }
public string RollNo { get; set; }
public string Class { get; set; }

private IRepository _respository;
 
public Student(IRepository repository)
{
_repository = respository;
}
 
public bool AddStudent(Student student)
{
_respository.Insert(student);
 }
public void DeleteStudent(Student student)
{
_respository.Delete(student);
 }
public void UpdateStudent(Student student)
{
_respository.Delete(student);
 }
}

We can have several implementations of the same repository class.But what matters is that our business logic which is defined by the student class is oblivious to all the low level implementation details.

One of the implementations of IRepository is SQLRepository as defined above.This implementation may use ADO.NET command object.

class SQLRepository:IRepository{
private SQLComamnd  _cmd;

public StudentRepository(string connectionString)
{
_cmd=new SQLComamnd(connectionString);
}

public void AddStudent(Student student)
{

//map student properties
_cmd.ExecuteNonQuery();
}

public void Delete(Student student)
{
_cmd.ExecuteNonQuery(SQL Statement);
}

public void Update(Student student)
{

//map student properties
_cmd.ExecuteNonQuery(SQL Statement);
}

public IQueryable<Student> GetAll()
{
DataTable dt=cmd.ExecuteReader(SQL Statement);

//create  IQueryable<Student> from datatable

return IQueryableStudent;
}

}

Another implementation of  IRepository  is DBRepository .This uses Entity Framework for performing database CRUD operations.So we can easily replace any of these implementations in the Student class.

class DBRepository:IRepository 
{
StudentDbContext studentDbContext;

public StudentRepository(StudentDbContext  db)
    {
        this.studentDbContext = db;
    }

public void AddStudent(Student student)
{
studentDbContext.Students.Add(student);
}

public void Delete(Student student)
{
studentDbContext.Students.Remove(student);
}

public Student GetById(Student RollNo)
{
return studentDbContext.Students.Find(RollNo);
}


public bool Update(Student student)
{
 studentDbContext.Entry(student).State = EntityState.Modified;
}

}

Generic Repository

If we use the above approach then we will be implementing a separate repository for every entity used in our application.A better approach is to use generic repository.When we create a generic repository then we define a generic class.Different entities use the same generic class.

We define a generic repository class using the following structure:

public interface IRepository<T> {

List<T> GetAll();
List<T> FindById(int id);
void Add(T entity);
void Delete(T entity);
void Edit(T entity);
}

We can modify the above generic repository depending on the scenario.We can add methods as required ,in the repository.

Advantages of Repository pattern

As you can see in the above example the advantage of using the repository to access the database is that the repository class ,such as the one being referenced from the Student class above ,can be easily replaced with a a different implementation as long as it implements the IRepository interface.

So we can easily move the data persistence logic from SQL Server to Oracle without any changes to the client or the consumer class.

Since the data access logic is decoupled from the rest of the application this provides the following advantages:

• Since the data access code is located in a single place this makes it easy to change the application data access policies
• Easier to unit test.Business logic can be easily unit tested by replacing the repository with a mock.
• Persistence layer can be updated according to the current application needs without impacting the rest of the application.

 

Follow on: