Code First Approach using Entity Framework 4.1, Inversion of Control, Unity Framework, Repository & Unit of Work Pattern and MVC3 Razor View


Download Source Code

Introduction :
In my previous article I discussed about developing a simple basic multilayered architecture for a .Net application.However there were few points that I skipped considering that the article was for beginners.When we talk about an application architecture there are certain points that need to be put into consideration before initiating,
  • Is the architecture loosely coupled?
  • Is it to be service based?
  • Where should the entities reside?
  • What should be Mode of Communication with the database?
  • Do it require design patterns? If yes,What patterns should be implemented?
  • Should it be based on Seperation of Concerns?
To answer these type of questions, .Net 4 has come up with a generic solution,making use of Entity Framework.
My effort in this article would be to put some light on building a generic multilayered architecture using Entity Framework 4.1 and MVC3 razor view engine.We’ll use inversion of control to resolve dependency of layers.The points to be covered in this article would be as follows,
  • Use of Seperation of Concerns,
  • Use of Code First approach,
  • POCO objects,
  • Repository Pattern,
  • Dependency Injection and Inversion of Control.
Architecture Overview:
I have created an architecture to explaing all the above mentioned points, and we’ll stick to this architecture till the end of article thus implementing practically our understanding.
I have created a very simple application to add student details in database, To edit it and to delete it,My first page shows list of all added student.
The arcitecture is service based, following are the components and pictorial representation (fig1) of it, we’ll discuss each component in detail,
  1. CodeFirstData layer.
  2. CodeFirstEntities layer.
  3. CodeFirstServices layer.
  4. MVC Portal layer.


    Architecture components:

    Let’s discuss each and every component of the defined architecture in detail,
    1. CodeFirstData layer :
    The data layer is the class library defining a layer which is responsible for interacting with database, contains context classes and a factory pattern implementation to interact with database.The layer contains the repository for each entity to map with database,thus making a complete ORM (Object Resource Model) solution.The class library references EntityFramework dll to implement the dbcontext classes.
    1. CodeFirstEntities layer:
    Entity layer acts as a model to MVC application,and also responsible for creation of DataBase objects when the dbset is first executed.It contains Entity classes in POCO form, having relations and data annotations(Rules/Constraints to be put on Database table/columns).
    The properties of the class results in column name in database and name osf the class in Dtaabase table.Primary key is either defined by the property named Id or “Classname[Id]”,in our case “StudentId”,this is default protocol set by entityframework to keep in mind while creating entities.Since this application is codefirest,we need to create entities first.
    1. CodeFirstServices layer:
    The layer contains services which uses repositories to fetch data from database. The interaction between Services and Repositories is kept loosely coupled thus implementing Inversion of Control using Dependency Injection.Its constructor based dependency injection and do not allow service to make direct instance of our repositories.Service layer acts as an interface between controllers and repositories,passes request of controller to repositories.
    1. MVCPortal layer:
    MVCPortal layer is our UI layer, it contains Model/ViewModels,Views and Controllers.I am not going into details of MVC as its not our primary target,I assume that you already know how to create and run MVC application,Lets have a quick revision of MVC,
      1. Model / Viewmodel:
    Model classea are responsible for holding up and manipulating data,we bind model/viewmodel classes to views to display model specific data.model classes are prepopulated by controllers to show data with the lehp of views.
      1. Views :
    Views holds up our UI templates, We have controller methods defined for every view, which populates View Design with data, and requests particular type of view to be rendered at user’s end as per requirement.
      1. Controllers :
    Web-based MVC frameworks map URLs to server code in a bit different fashion. Instead of mapping incoming URLs to html/aspx files, they instead map URLs to methods on classes. These classes are called “Controllers” and they are responsible for processing incoming HTTP requests, handling user input, retrieving and saving data, and determining the response to send back to the client (display HTML, download a file, redirect to a different URL, etc.).
    The layer makes use of Dependency injection to achieve Inversion of Control for services, thus not allowing controllers to directly acces services instances,The IOC is acheived using global.asax file using UnityFramework library of Microsoft.
    5. Dlls : I have created DLLs folder and given the output build path for every class library to that folder, for ease of access to Dll’s to add reference.Now each Dll will be created in the Dlls folder and we can access the desired Dll from the same folder. Also keep the EntityFramework,UnityConfiguration Dlls into it.
    IOC and DI :
    Dependency Injection is an important component in my application . All the services are required to be late bound with Model layer with Dependency Injection. In addition, the IoC container manages the lifetime of service objects. For example the Context object. I set lifetime type as PerThreadLifetimeManager in Unity configuration. This makes one and only one context object created in a single request and the different request has a different context object. Another thing I want to mention is ASP.NET MVC3 has its own way to provide Dependency Inject for controller via implementing DependencyResolver interface. The IoC container I used in the demo is Unity.
    Container :
    The “Container” or “IOC Container” is the main object that is used to create objects and inject dependencies into them. Whenever you want an object to be open to IoC, you have to use the container to create the instance using container.Resolve() method instead of the “new” keyword.
    IService service = unityContainer.Resolve();
    I have added following references to acheive the same,
    Microsoft.Practices.Unity
    Microsoft.Practices.Unity.Configuration
    The code for IOC is implemented in global.asax file.
    Step by Step Process to create the Application using EntityFramework Architecture :
    Application Overview :
    We’ll try to develop a simple studentDetails application with the help of discusses architecture,The application’s main module will be to Create a new student, Edit existing student,Delete existing student, and to show list of all students.Looking into a wider/generic perspective, the application performs CRUD operations on database with the help of EF .
    Note that we’ll not create databse by our own,we just write classes and defing connection configuration of our database server in web.config file, and let EntityFramework do rest of the job of creating database, managing database and Mapping database with our entities.
    Step1. Creating a solution and blank projects/seperating them logically/physically as layers :
    Our first initiative is to prepare our initial level architecture there by creating solution and adding project files to it, We create a solution named CodeFirstEntities and add three class libraries to it thus defining our three layers which are Entity,Data and Service, the names of the class libraries which i chose are CodeFirstEntities,CodeFirstData and CodeFirstServices respectively.
    Now add an MVC3 application to the solution called MvcPortal, that will act as a UI layer for our application. Refer fig2 for implementing the first step.


                                                                       ( fig2 )

    Step 2. Creating Entities :
    Add Student.cs class to CodeFirstEntities project , this class will contain the student details specific properties that will take the shape of database table and columns . The class makes use of DataAnnotation dll to put data annotations (rules/constraints) over the properties that will be reflected in database table.The constraints like max length and required parameter are provided as attributes over the properties of the class as shown in fig3 and fig4,

                                                                                ( fig3 )

                                                                             ( fig4)
    The above entities is very simple POCO (Plain Old CLR Object) class and the entity Student is decorated with validation attributes in the System.ComponentModel.DataAnnotations namespace. Now we want to use these entities for defining model objects for the Entity Framework 4. Using the Code First approach of Entity Framework, we can first define the entities by simply writing POCO classes without any coupling with any API or database library. This approach lets you focus on domain model which will enable Domain-Driven Development for applications. EF code first support is currently enabled with a separate API that is runs on top of the Entity Framework 4.
    Step 3. Creating Repositories/Contexts :
    Our next step is to create the contexts/repositories for our application and classes that will interact with the database.
    A. Create Context Class for Entity Framework :
    We have already prepared our domain model now let’s create a class in order to working with Entity Framework Code First. I have added reference to EntitFramework.dll CTP 4.1 to this class library project. We create two folders DBInteractions and EntityRepositories to segregate our classes as in fig5, we’ll come to that later, first let me explain you the context class.
                                                                (fig 5)


                                                                                   (fig 6)

    The above class CodeFirstContext in fig 6 is derived from DbContext that can connect your model classes to a database. The CodeFirstContext class is mapping our Student class to
    database tables Student use DbSet where TEntity is any POCO class. When we arerunning the application at first time, it will automatically create the database. EF code-first look for a connection string in web.config or app.config that has the same name as the dbcontext class. If it is not find any connection string with the convention, it will automatically create database in local SQL Express database by default and the name of the database will be same name as the dbcontext class. You can also define the name of database in constructor of the the dbcontext class. The model classes of Code First are working on the basis of conventions and we can also use a fluent API to refine our model. The convention for primary key is ‘Id’ or ‘Id’ as I discussed before. If primary key properties are detected with type ‘int’, ‘long’ or ‘short’, they will automatically registered as identity columns in the database by default. Primary key detection is not case sensitive. We can define our model classes with validation attributes in the System.ComponentModel.DataAnnotations namespace and it automatically enforces validation rules when a model object is updated or saved.
    I ) DBInteractions :
    B. Generic Repository for EntityFramework Code First:
    We have now created model class and dbcontext class. Now we create a generic repository pattern for data persistence with EF code first. Let’s create a generic repository to working with DbContext and DbSet as follows,The following classes will be added to DBInteractions folder for ease of understanding logic.


                            
                                                                            (fig 7)

    1. DataBase Factory:
    We have our database factory class defined as follows,


                                                                (fig 8)

                                                                     (fig 9)
    Where IDBFactory is the interface implemented by our factory class DBFactory.The factory class is inherited from Disposable class as shown below in fig 10,Responsible for releasing disposing database resources.
    (fig 10)
    1. RepositoryBase – The Generic Entity Repository base class :


      Above is the repository base class that contains all the methods to be implemented for CRUD DB operations, we can define more of our generic methods here, for now considering our application, these are eough for proper understanding of the working.

      E. Unit of Work
      The Unit of Work pattern maintains a list of objects affected by a business transaction and coordinates the writing out of changes and the resolution of concurrency problems.We create a class for handling Unit of Work pattern,
      Interface :


      Class :



      The Commit method written in of the UnitOfWork will call the commit method of our Context class and it will execute the SaveChanges method of DbContext class.

      II ) Repository :
      In this article, we will be primarily focus on the persistence against Student entity . Let’s create a repository for handling CRUD operations for Student
      using derive from a generic Repository EntityRepositoryBase.
      Repository class for Student :
      Interface :

      Class :

       

    Step 4. Creating a Service layer :
    Service Layer defines an application’s scope and its available set of operations from the perspective of interfacing client layers. It encapsulates the application’s business logic,
    controlling transactions and coordinating responses in the implementation of its operations. Controller classes should be made light and do not put much of business logic onto it. We can use
    the service layer as the business logic layer and can encapsulate the rules of the application.
    We define interfaces and corresponding student service for our application business logic,Since we are targetting CRUD operations, so the methods are quite simple in implementation,
    Interface :

     
    As we can see in abve interface the methods are to Get Student Details,List,Update and Delete Student.
    Class :
    usingSystem.Collections.Generic;
    usingCodeFirstData.DBInteractions;
    usingCodeFirstData.EntityRepositories;
    usingCodeFirstEntities;
    usingCodeFirstServices.Interfaces;
    namespaceCodeFirstServices.Services
    {
    publicclassStudentService: IStudentService
    {
    privatereadonlyIStudentRepository_studentRepository;
    privatereadonlyIUnitOfWork_unitOfWork;
    publicStudentService(IStudentRepositorystudentRepository, IUnitOfWorkunitOfWork)
    {
    this._studentRepository = studentRepository;
    this._unitOfWork = unitOfWork;
    }
    #regionIStudentService Members
    publicIEnumerable<Student> GetStudents()
    {
    varstudents = _studentRepository.GetAll();
    returnstudents;
    }
    publicStudentGetStudentById(intid)
    {
    varstudent = _studentRepository.GetById(id);
    returnstudent;
    }
    publicvoidCreateStudent(Studentstudent)
    {
    _studentRepository.Add(student);
    _unitOfWork.Commit();
    }
    publicvoidDeleteStudent(intid)
    {
    varstudent = _studentRepository.GetById(id);
    _studentRepository.Delete(student);
    _unitOfWork.Commit();
    }
    publicvoidUpdateStudent(Studentstudent)
    {
    _studentRepository.Update(student);
    _unitOfWork.Commit();
    }
    publicvoidSaveStudent()
    {
    _unitOfWork.Commit();
    }
    #endregion
    }
    }
    Class uses refernces of Repositories and Entities, and Dependency of Repositories is resolved in Constructor of the service itself.
    Step 5. The MVC Portal :
    Before we start MVC portal,Lets clear our logic for IOC and DI.I have already discussed IOC in the article.For resolving Dependency we create certain classes as discussed below, to get independent service request,
    We also create a custom lifetime manager for Unity to store container in the current HttpContext.
    publicclassHttpContextLifetimeManager : LifetimeManager, IDisposable
    {
    publicoverrideobjectGetValue()
    {
    varassemblyQualifiedName = typeof(T).AssemblyQualifiedName;
    if(assemblyQualifiedName != null)
    returnHttpContext.Current.Items[assemblyQualifiedName];
    returnnull;
    }
    publicoverridevoidRemoveValue()
    {
    varassemblyQualifiedName = typeof(T).AssemblyQualifiedName;
    if(assemblyQualifiedName != null)
    HttpContext.Current.Items.Remove(assemblyQualifiedName);
    }
    publicoverridevoidSetValue(objectnewValue)
    {
    varassemblyQualifiedName = typeof(T).AssemblyQualifiedName;
    if(assemblyQualifiedName != null)
    HttpContext.Current.Items[assemblyQualifiedName] = newValue;
    }
    publicvoidDispose()
    {
    RemoveValue();
    }
    }
    }
    We create a dependency resolver for resolving service dependency as follows,
    ASP.NET MVC 3 has introduced a new interface IControllerActivator which lets you activate controllers with custom behavior and can be use it for dependency injection purpose.The
    IControllerActivator interface is discoverable using the dependency resolver. Let’s create a custom controller activator class by deriving from IControllerActivator intreface
    usingSystem;
    usingSystem.Web.Mvc;
    namespaceCodeFirstPortal.IoC
    {
    publicclassCustomControllerActivator: IControllerActivator
    {
    IControllerIControllerActivator.Create(
    System.Web.Routing.RequestContextrequestContext,
    TypecontrollerType){
    returnDependencyResolver.Current
    .GetService(controllerType) asIController;
    }
    }
    }
    We also create a UnityController Factory and Configure contract and concrete types of unity in global.asax file.
    ASP.NET MVC 3 has also introduced a new interface IDependencyResolver which exposes two methods – GetService and GetServices.The GetService method resolves singly registered services
    that support arbitrary object creation and the GetServices resolves multiply registered services. Implementations of the IDependencyResolver interface should delegate to the underlying
    dependency injection container to provide the registered service for the requested type. When there are no registered services of the requested type, the ASP.NET MVC framework expects
    implementations of this interface to return null from GetService and to return an empty collection from GetServices. Let’s create a custom dependency resolver class by deriving from
    IDependencyResolver intreface in order to working with Unity to providing dependency injection.
    usingSystem;
    usingSystem.Web;
    usingSystem.Web.Mvc;
    usingSystem.Web.Routing;
    usingMicrosoft.Practices.Unity;
    namespaceCodeFirstPortal.IoC
    {
    publicclassUnityControllerFactory: DefaultControllerFactory
    {
    IUnityContainercontainer;
    publicUnityControllerFactory(IUnityContainercontainer)
    {
    this.container = container;
    }
    protectedoverrideIControllerGetControllerInstance(RequestContextreqContext, TypecontrollerType)
    {
    IControllercontroller;
    if(controllerType == null)
    thrownewHttpException(
    404, String.Format(
    “The controller for ‘{0}‘ could not be found”+ “or it does not implement IController.”,
    reqContext.HttpContext.Request.Path));
    if(!typeof(IController).IsAssignableFrom(controllerType))
    thrownewArgumentException(
    string.Format(
    “Requested type is not a controller: {0}“,
    controllerType.Name),
    “controllerType”);
    try
    {
    controller= container.Resolve(controllerType) asIController;
    }
    catch(Exceptionex)
    {
    thrownewInvalidOperationException(String.Format(
    “Error resolving the controller {0}“,
    controllerType.Name), ex);
    }
    returncontroller;
    }
    }
    Resolving Service Dependency :
    usingSystem;
    usingSystem.Collections.Generic;
    usingSystem.Web.Mvc;
    usingMicrosoft.Practices.Unity;
    namespaceCodeFirstPortal.IoC
    {
    publicclassUnityDependencyResolver: IDependencyResolver
    {
    IUnityContainercontainer;
    publicUnityDependencyResolver(IUnityContainercontainer)
    {
    this.container = container;
    }
    publicobjectGetService(TypeserviceType)
    {
    try
    {
    returncontainer.Resolve(serviceType);
    }
    catch
    {
    returnnull;
    }
    }
    publicIEnumerable<object> GetServices(TypeserviceType)
    {
    try
    {
    returncontainer.ResolveAll(serviceType);
    }
    catch
    {
    returnnewList<object>();
    }
    }
    }
    }
    global.asax :
    Add service project reference , entity project reference and data project reference to the portal.
    The SetResolver method of DependencyResolver class provides a registration point for dependency injection containers. In this method, we configure the UnityDependencyResolver class for
    providing dependency injection with Unity 2.0. The SetResolver method will be working with any dependency injection container.If you want to use StructureMap as the dependency injection
    container, you can create a dependency resolver class in order to working with StructureMap by deriving IDependencyResolver intreface and later you can configure this class with SetResolver
    method. The ASP.NET MVC 3 is providing a good support for working with dependency injection containers.
    usingSystem.Web.Mvc;
    usingSystem.Web.Routing;
    usingCodeFirstData.DBInteractions;
    usingCodeFirstData.EntityRepositories;
    usingCodeFirstPortal.IoC;
    usingCodeFirstServices.Interfaces;
    usingCodeFirstServices.Services;
    usingMicrosoft.Practices.Unity;
    namespaceMvcPortal
    {
    publicclassMvcApplication: System.Web.HttpApplication
    {
    publicstaticvoidRegisterGlobalFilters(GlobalFilterCollectionfilters)
    {
    filters.Add(newHandleErrorAttribute());
    }
    publicstaticvoidRegisterRoutes(RouteCollectionroutes)
    {
    routes.IgnoreRoute(“{resource}.axd/{*pathInfo}”);
    routes.MapRoute(
    “Default”, // Route name
    “{controller}/{action}/{id}”, // URL with parameters
    new{ controller = “Home”, action = “Index”, id = UrlParameter.Optional } // Parameter defaults
    );
    }
    protectedvoidApplication_Start()
    {
    AreaRegistration.RegisterAllAreas();
    RegisterGlobalFilters(GlobalFilters.Filters);
    RegisterRoutes(RouteTable.Routes);
    IUnityContainercontainer = GetUnityContainer();
    DependencyResolver.SetResolver(newUnityDependencyResolver(container));
    }
    privateIUnityContainerGetUnityContainer()
    {
    //Create UnityContainer
    IUnityContainercontainer = newUnityContainer()
    .RegisterType<IDBFactory, DBFactory>(newHttpContextLifetimeManager<IDBFactory>())
    .RegisterType<IUnitOfWork, UnitOfWork>(newHttpContextLifetimeManager<IUnitOfWork>())
    .RegisterType<IStudentService, StudentService>(newHttpContextLifetimeManager<IStudentService>())
    .RegisterType<IStudentRepository, StudentRepository>(newHttpContextLifetimeManager<IStudentRepository>());
    returncontainer;
    }
    }
    }
    To Start with MVC our first step is to define our connection string as follows in the web.config file.
    Steps to Create Controllers and Views :
    1. We start with home Controller, as it is the default controller set in global.asax to be called first.
      When the Index action of the controller is called we redirect it to our Student Controller,which straight away returns view to show listy of students if exist,since its first time we are creating the controller,it shows an empty list, the controller method of Student fetches student list from database , but first it creates the database, thus acheiving our objective.
    1. We create Student Controller, We define actions in the controller for each operation we want to perform as follows,
    usingSystem;
    usingSystem.Linq;
    usingSystem.Web.Mvc;
    usingCodeFirstEntities;
    usingCodeFirstServices.Interfaces;
    namespaceCodeFirstPortal.Controllers
    {
    publicclassStudentController: Controller
    {
    privatereadonlyIStudentService_studentService;
    publicStudentController(IStudentServicestudentService)
    {
    this._studentService = studentService;
    }
    [HttpGet]
    publicActionResultDetails(int? id)
    {
    varstudentDetails = _studentService.GetStudentById((int) id);
    if(studentDetails == null) thrownewArgumentNullException(“Not Found”);
    returnView(studentDetails);
    }
    [HttpGet]
    publicActionResultDelete(int? id)
    {
    varstudentDetails = _studentService.GetStudentById((int) id);
    if(studentDetails == null) thrownewArgumentNullException(“Not Found”);
    returnView(studentDetails);
    }
    [HttpPost]
    publicActionResultDelete(Studentstudent)
    {
    _studentService.DeleteStudent(student.StudentId);
    returnRedirectToAction(“List”, “Student”);
    }
    [HttpGet]
    publicActionResultEdit(int? id)
    {
    varstudentDetails = _studentService.GetStudentById((int) id);
    if(studentDetails == null) thrownewArgumentNullException(“Not Found”);
    returnView(studentDetails);
    }
    [HttpPost]
    publicActionResultEdit(Studentstudent)
    {
    _studentService.UpdateStudent(student);
    returnRedirectToAction(“List”, “Student”);
    }
    [HttpGet]
    publicActionResultCreate()
    {
    returnView();
    }
    [HttpPost]
    publicActionResultCreate(Studentstudent)
    {
    varstudentModel = newStudent()
    {
    Address = student.Address,
    Country = student.Country,
    Name = student.Name,
    Age = student.Age,
    Email = student.Email
    };
    _studentService.CreateStudent(studentModel);
    returnRedirectToAction(“List”, “Student”);
    }
    [HttpGet]
    publicActionResultList()
    {
    varstudents = _studentService.GetStudents();
    if(students.Any())
    {
    returnView(“List”, students);
    }
    returnView(“List”);
    }
    }
    }
    There are get and corresponding Posts for each method responsible for Data Updations. The Constructor of the controller initializes the Service,we can see it do not create direct instance.
    1. We Create Views for every Action,Its easy if we right click the controller action and create view,It automatically create a view with a Default folder named in the name of Constructor,So we can create all the views for our operations, and our solution looks like,
      4. Now we are ready with our application to be executed,keep your fingers crossed and see the magic, I have used _layout as master page to give some meaningful look and feel to my application,U can customize the same.When u run the application by pressing F5, We get redirected to the Index view of Student Controller,which shows list of students,since we are running it first time,we dont have existing list, and our application shows,



      1. No wonder , just have a look at your DataBase, My case I am using Sql Server 2008,


        I got a Database created automativcally with the name CodeFirstApp having Student Table, Now you can cross verify the table with your entity,its the same.So we have hit the target and our database is successfully created.

        1. Further Operations :
        You can now test the application and perform further CRUD operations in the application and see the DataBase getting updated.e.g. Create Student,


        after Submit by pressing Create, we get,


        therefore one student created.

        We can edit the same student by pressing edit link , we get the view,


        Likewise we can see the details of already created student,


        and delete the student will redirect to ,


        I had created 3 students in the same manner, You can create more and play with the application.

        Risk Factor : There is also a Risk Factor in implementing EntityFramework, If we do any change in the entity, like deleting,changing property,The context will drop and recreate the database, which may clearly lead to loss of your existing data.To avoid this critical situation, we code some more, we call SetInitializer method of DataBase class and set it to null in our dataBase Factory Class.

        usingSystem.Data.Entity;
        namespaceCodeFirstData.DBInteractions
        {
        publicclassDBFactory: Disposable, IDBFactory
        {
        publicDBFactory()
        {
        Database.SetInitializer<CodeFirstContext>(null);
        }
        privateCodeFirstContextdataContext;
        publicCodeFirstContextGet()
        {
        returndataContext ?? (dataContext = newCodeFirstContext());
        }
        protectedoverridevoidDisposeCore()
        {
        if(dataContext != null)
        dataContext.Dispose();
        }
        }
        }
        Database class is from namespace System.Data.Entity, whcih provides such feature.
        Conclusion :
        In this article we discussed about creating an application using EntityFramework 4.1 Code First Approach, We used Inversion of control and Dependency Injection to Resolve Dependency between layers.We used MVC 3 razor view engine as our UI and integrated the layers to acheive our objective.The application was a description of simple CRUD operations on Database.We learned how to use Repository Pattern,Unit of Work pattern and Unity Framework.You can download the codebase and further enhance/extend it according to your need.Happy Coding.

        Articles : http://www.codeproject.com/script/Articles/BlogFeedList.aspx?amid=7869570

Advertisements

Understanding Multilayered Architecture in .Net


     Introduction :
     This article focussses on understanding a basic multilayered architecture in C#.Net,
The article starts with introduction to one tier, two tier and n-tier architectures,their pros and cons,  and later describes how we can acheive a simple basic multilayered architecture in .Net.
My effort in this article would be to focus on next level programming in .Net for developing an enterprise application.
     Layered Architecture :
When the different components in a system are organized systematically we call it a system architecture. The architecture is the enterprise-scale division of a system into layers or tiers, each having responsibility for a major part of the system and with as little direct influence
on other layers.
One, two, three and n-tier applications :
There are plenty of ways where a system can be split into no. of  logical tiers.
  One-tier applications
Single-tier applications are basically simple standalone programs.
It’s not necessary to take network communication and the risk of network failure
into consideration in these type of cases as they do not have the network access.
Since all the data resides within the same application,so these programs do not focus on synchronization of data. When separating the tiers physically the application get slower due to the  fact that communication over network will result in a loss of performance, therefore one-tier applications certainly have high performance.
Two-tier applications
A two-tier application, in comparison to the one-tier application as described, does not
combine all functions into a single process but separate different functions. For example
a chat application. This kind of application contains two separated tiers, client and a server.
The client has the responsibility of capturing user input and displaying the actual messages.
The server is responsible of the communication between the people that uses the chat client.
Three-tier applications
A three-tier application, adds another tier to the previous mentioned chat application, this
could be in the form of a database. One could think of a three-tier application as a dynamic
web application, which has a user interface, business logic,services and a database each placed in different tiers, as illustrated in Figure 1. As mentioned in the previous section a two-tier architecture   separates the user interface from the business logic, in the same way the three tier architecture separates the  database from the business logic.
N-tier applications
A logical n-tier application is an application where all logical parts are separated into discrete classes. In a typical business application, this generally involves a presentation layer, business logic layer and a data access layer. This separation makes the application easier to maintain. The advantages of this architecture are that all business rules are centralized which make them easy to create, use and re-use. The data access is also centralized, which has the same advantage as the centralization of the business rules. Centralizing the data access routines are also good when it comes to maintenance since changes only has to be implemented at one location. There are really not that many disadvantages of this kind of architecture, however, it
takes a bit longer to get up and running since several separate components has to be
developed, which also might make the code a bit more complicated to grasp for less
experienced developers.
A Practical Approach :
Lets start developing a simple multilayered architecture in .Net, I take c# as my programming language,however programming language is not a bar at all , one can choose the same as per comfort of programming.The architecture which we are to implement has the following design as mentioned in Figure 2.We will start creating the architecture for a web application , later it could be converted into a windows application too.
We will make use of class libraries to physically seperate our layers.There for one Web Application/Project, one Business logic layer class library , one Data access layer class library and one Common layer class library can be included in the solution.
Lets follow the implementation Step by Step,

 

 
Step 1 : Add a Web Project (Presentation layer).
             Open your Visual Studio and add a simple website to the solution, name it Presentation Layer.
 

 

Your Development Environment may look like,
 
 
Our Presentation Layer is the Web application, that will be exposed to the end user,
The Web application includes Web Forms i.e. aspx pages, User Controls i.e. Ascx pages,
Scrips (client side java scripts),Styles (css and custom styles for styling the page),Master Page(.master extension, for providing common functionality to group of desired pages,Configuration Files like web.config and app.config etc.).
Lets setup our next projects and define them in seperate layers, Add three folders to your solution,Folders named, BusinessLogicLayer, DataAccessLayer and CommonLayer.Your solution will look like as below,
 
 
   Step 2 : Add a Business Logic layer, Data Access Layer and Common Layer :
                Right click the Business Logic Layer folder and add a c# class library project to it, call it BLL.csproj,
 
 
  Doing this will ad a c# class library project to our solution in the Businee Logic Layer Folder.
  Like wise add two more projects to Common Layer and DataAccessLayer folder respectively and call them Common.csproj and DAL.csproj projects.
  The Data Access Layer Project Contains the entities classes and objects to communicate with database, where as our common project contains properties, helper classes to communicate with all the three layers commonly.It contains the objects to be passed to and fro from presentation layer to data access layer commonly, and also acts as a mode of message passing between the layers.

   Now our solution would look like as below,

 
Step 3 : Create a database with a sample table and put some default values in it, for example i have created a database named “EkuBase” and created a siple Student table with following fields, StudentId,Name,Email,Address,Age,Country.The Create script of the table is as follows,
<!–[if gte vml 1]>

     USE [EkuBase]

GO

 

/****** Object:  Table [dbo].[Student]    Script Date: 12/24/2011 14:53:14 ******/

SET ANSI_NULLS ON

GO

 

SET QUOTED_IDENTIFIER ON

GO

 

CREATE TABLE [dbo].[Student](

   [StudentID] [int] NOT NULL,

   [Name] [nvarchar](50) NULL,

   [Email] [nvarchar](50) NULL,

   [Address] [nvarchar](50) NULL,

   [Age] [int] NULL,

   [Country] [nvarchar](50) NULL,

 CONSTRAINT [PK_Student] PRIMARY KEY CLUSTERED

(

   [StudentID] ASC

)WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON) ON [PRIMARY]

) ON [PRIMARY]

 

GO

<![endif]–>

      USE [EkuBase]
GO
/****** Object:  Table [dbo].[Student]    Script Date: 12/24/2011 14:53:14 ******/
SET ANSI_NULLSON
GO
SET QUOTED_IDENTIFIERON
GO
CREATE TABLE[dbo].[Student](
   [StudentID] [int] NOT NULL,
   [Name] [nvarchar](50) NULL,
   [Email] [nvarchar](50) NULL,
   [Address] [nvarchar](50) NULL,
   [Age] [int] NULL,
   [Country] [nvarchar](50) NULL,
 CONSTRAINT[PK_Student] PRIMARY KEYCLUSTERED
(
   [StudentID] ASC
)WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON) ON [PRIMARY]
) ON[PRIMARY]
     Therefore making studentid as primary key.
   Step 4: Lets add classes to our projetcs,Add StudentBLL.cs,StudentDAL.cs,StudentEntity.cs to BLL,DAl and Common Layer respectively,make sure you qualify them with logical namespaces,so that its easy to recognize and use them.
      BLL:            
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace BLL
{
    public class StudentBLL
    {
    }
}
     DAL:                
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace DAL
{
    public class StudentDAL
    {
    }
}
  Common:        
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace Common
{
    public class StudentEntity
    {
    }
}
  Step 5: Add Connection String in web.config and a Helper class to DAL to interact with DataBase,In my case i am using SQL helper for ease.
         
  Web.Config :
                <connectionStrings>
<add name=“Connections” connectionString=“Data Source=69B5ZR1\SQLEXPRESS;Initial Catalog=EkuBase;Persist Security Info=True;User ID=akhil;Password=akhil” providerName=“System.Data.SqlClient“/>
                </connectionStrings>
  and define the Connection String in your Sql Helper so that you dnt have to again and again create a connection and pass it to your method when you interact with database.
            publicstatic readonlystring CONN_STRING = ConfigurationManager.ConnectionStrings[“Connections”].ConnectionString;
        add reference of System.Configuration to DAL project before reading the above connection string.
    Step 6:Configure the solution and add dll’s to dependent layers,

            Since we need to seperate the business logic,presentation and data access,and we do not want presentation layer to directly interact with database nor the business logic,we add reference of business logic layer to our presentation layer and data access layer to the business logic layer and common layer to all the three layers,To acheive the same add a commonn DLL folder to the physical location of the Solution and give build path of all the three class projects to that DLL folder,doing this we can directly get access to DLL’s of all the layers to the layers needed that DLL.We’ll get the dll’s in that folder once we complite our project,   

 
 
 
 
Do this for DAL and Common Layer as shown in Figure 8.Aftre compling all the projects we get dll’s in DLL folder created.

 

 

 

 
Now add reference of Common.dll,BLL.dll to Presentation Layer, Common.dll,DAL.dll to BLL Layer,
Common.dll to DAL layer and compile your solution.
Now the code of BLL is accessible to Presentation Layer,and DAL is accessible to BLL, and Common is accessible to all three layers.
Step 7: Write methods to get the flow.
             Now we need to write some code to our layers to get the feel of flow between all the layers, Let’s create a scenarion, Suppose we need to get the details of all the students whose student id is less than 5.For that add some sample data to your Student table,about 7 rows would work(Figure 11),and add a gridview to Default.aspx in presentation layer to show the data.
 
 
                                                             Figure 11
           
Default.aspx:
        <%@ PageTitle=”Home Page” Language=”C#” MasterPageFile=”~/Site.master” AutoEventWireup=”true”
    CodeFile=”Default.aspx.cs” Inherits=”_Default” %>
<asp:Content ID=”HeaderContent”runat=”server”ContentPlaceHolderID=”HeadContent”>
</asp:Content>
<asp:Content ID=”BodyContent”runat=”server”ContentPlaceHolderID=”MainContent”>
    <h2>
        Welcome to ASP.NET!
    </h2>
    <p>
        To learn more about ASP.NET visit <ahref=”http://www.asp.net&#8221;title=”ASP.NET Website”>http://www.asp.net</a>.
    </p>
    <p>
        You can also find <a href=”http://go.microsoft.com/fwlink/?LinkID=152368&clcid=0x409&#8243;
            title=”MSDN ASP.NET Docs”>documentation on ASP.NET at MSDN</a>.
    </p>
    <div>
    <asp:GridView runat =”server” ID=”grdStudent”></asp:GridView>
    </div>
    <div>
                   <asp:Label runat=”server” ID=”lblError” Font-Bold=true ForeColor=red ></asp:Label>
                  </div>
   
</asp:Content>
Now decorate your StudentEntity Class in Common layer with following code, to make properties for each column we are going to access from Student table,
using System;
usingSystem.Collections.Generic;
using System.Linq;
using System.Text;
namespace Common
{
    publicclass StudentEntity
    {
        int studentID;
        public int StudentID
        {
            get { return studentID; }
            set { studentID = value; }
        }
        string name;
        public string Name
        {
            get { return name; }
            set { name = value; }
        }
        string email;
        public string Email
        {
            get { return email; }
            set { email = value; }
        }
        string address;
        public string Address
        {
            get { return address; }
            set { address = value; }
        }
        int age;
        public int Age
        {
            get { return age; }
            set { age = value; }
        }
        string country;
        public string Country
        {
            get { return country; }
            set { country = value; }
        }
    }
}
and StudentDAL with following code to call the data from database,We always write data interaction code in this layer only,making it as a protocol.
using System;
usingSystem.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data;
namespace DAL
{
    publicclass StudentDAL
    {
        public DataSetFetchSelectedStudents()
        {
            string sqlCommand = “select * from Student where Studentid<5”;
            DataSet dataSet = SqlHelper.ExecuteDataset(SqlHelper.CONN_STRING, CommandType.Text, sqlCommand);
            return dataSet;
        }
    }
}
  Here we simply make a call to database to get studutents having id less than 5.
   We write following code to BLL class,where we perform validation check for the id whether it is less or greater that 5, and correspondigly throw error is its greater than 5,which we show at our default.aspx page by setting the message to error label text.BLL makes call to DAL to fetch the students,and passes to Presentation Layer, where data is shown in GridView.
using System;
usingSystem.Collections.Generic;
using System.Linq;
using System.Text;
using DAL;
using System.Data;
using Common;
namespace BLL
{
    publicclass StudentBLL
    {
        public DataTable GetStudentBelow5(StudentEntity student)
        {
            StudentDAL studentDAL = newStudentDAL();
            if (ValidateID(student.StudentID))
            {
                return studentDAL.FetchSelectedStudents().Tables[0];
            }
            return null;
        }
        private bool ValidateID(int studentID)
        {
            if (studentID > 5)
            {
                throw new ApplicationException(“Id Should be less than 5”);
            }
            return true;
        }
    }
}
  and in Presentation layer we write code to bind our gridview else show error message in case of error returned from BLL.
  Default.aspx.cs:
using System;
usingSystem.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
usingSystem.Web.UI.WebControls;
using System.Data;
using BLL;
using Common;
public partial class _Default : System.Web.UI.Page
{
    protectedvoid Page_Load(objectsender, EventArgs e)
    {
        StudentBLL studentBLL = new StudentBLL();
        StudentEntity studentEntity=newStudentEntity();
        studentEntity.StudentID=6;
        DataTable dTable = new DataTable();
        try
        {
            dTable = studentBLL.GetStudentBelow5(studentEntity);
            grdStudent.DataSource = dTable;
            grdStudent.DataBind();
        }
        catch (ApplicationExceptionapplicationException)
        {
            lblError.Text = applicationException.Message;
        }
    }
}
  In the above code we specify student id as 6 in Student Entity and pass it to BLL,when we run the code we get the following page with our error label set with the error message,
 
 
It clearly states that id should be less than 5.Note that we do not get to DAL before the data is validated.
Now change the student id to 5 and see the result,We get the following page,
 
Thus we get the clear result.
Here we have seen how we communicated through different layers performing different roles to fetch the data.
General advantages of layered applications:
There are various advantages of developing applications that are split up into different tiers or
layers. Most importantly this form of architecture helps to enforce the principles of high
cohesion within system components and low coupling between different components. A
system built on these principles will be more robust, easier to adjust, easier to maintain and
understand and it allows different software components to be developed in parallel.
The key point is that a system should be split into different smaller parts that are as
cohesive and self-governing as possible. Each part has distinct responsibilities and interacts
with other parts of the system to accomplish its tasks and responsibilities. This also ensures
that the systems can corporate across different platforms and communication protocols and
makes it easier to reuse existing solutions to problems often encountered.
All in all these advantages are desirable because they work in the direction of low
coupling and high cohesion. The hard part is, however, to implement this in practice and to
know when and how it should be implemented. What objects should have responsibility for
the different tasks and how do they interact.
Summary :
In this article I discussed about what are layered applications,different types of layered applications and how to create a multilayered application in .Net.We can handle the Exceptions more intelligently at DAL and BLL,however that was not the scope of the article so that part is skipped and i’ll surely discuss this in my forthcoming articles.The article was a focus on development for beginners, who face challenges to create an architecture before starting development.Happy Coding 🙂 .
Download Source Code

Read more:

Other Series

My other series of articles:

For more technical articles you can reach out to my personal blog CodeTeddy.

Creating an MSI Package for C# Windows Application Using a Visual Studio Setup Project


Introduction

There are number of ways provided by Microsoft to create a setup project for windows application.
But when I started to create one, I got nothing but queries and confusions of how to start and where to start. There are numerous articles I found over network, explaining to create a setup project, but some does not work as they say, and some do not have a live example to follow.
The driving force for me to write this article is my QC team, who except the main application to test also verified my setup installer with their 100% effort L. And guess what, they were successful to find bugs in that too.
In this article I would like to explain a step by step process to create a windows application and a setup installer for the same in a very simple manner, that is easy to understand and follow, alternatively there are n no. of ways to do so.

Start the Show
Firstly let’s create a simple one form windows application, having a text box and a button only.
Creating windows application is just for the sake of having one to install.
I gave the name CreatingInstaller to my windows application, obviously you can have your own.
Thus adding a new Windows Form Application in my solution and adding a text box and button to the default form resulted in the figure as shown below. Decorate the control properties as per your will.


Just wanted to write few lines of code, so I binded button’s click event to show text box’s text,


Primary Objective
So far so good. Now let’s create a installer for the same windows application. Right click on solution and add a new project to your solution like in following figure,

And add a setup project by Other project Types->Setup and Deployment->Visual Studio Installer


The project will be added to the solution , now open file system editor by clicking on the project and selection the option to open file system editor, like shown in below figure,
You’ll get to see Application Folder, User’s Desktop and User’s Program Menu.





Right click on Application Folder and add an output project. Out project specifies the project we are creating an installer to, like in the following figure:



Select CreatingInstaller i.e. the windows application project name in Add output project window, select it as a primary output as shown below and click ok.


The Primary output will be added as shown below, having type defined as Output. 


In the meanwhile lets add some more functionality to our windows application, lets read a file and show its output in a message box on button click. Therefore just add a text file, I called it Sample.txt to the bin\debug\Input folder, Input is the custom folder I created to place my txt file.
Write few lines of code just to read the txt file from Startup path, in my case bin\debug, it could also be bin\release as per project build, and specify the file folder name and file name to tead the content.I chose to keep my txt file at startup path so that I could explain how we can create files and folders at the time of installation. Now we also need this Input folder and a Sample.txt file at the time of installation to be located at the location of installed application.
For file operations I added the namespace System.IO, needless to specify this though.



Therefor running the application will show two message boxes one after another showing text box text and text from Sample.txt file.


Now this folder creation logic has to be implemented in out setup project, so that when the application installs, it has all the pre-requisites required to run the application, like the Input folder and the Sample.txt file.
So, right click on Application Folder in File system editor and add a folder. The folder will be created just below the Application Folder, name that folder Input.


Right click on folder, select properties and mark Always Create property to True.That means folder will always be created whenever we run the installer, after a fresh build release.


Create Shortcuts

You can decorate your form to add an icon to it, that icon will also be required at the time of installation to create a shortcut icon to our application. Add an icon to the form like in below mentioned figure,



Time to add Sample.txt file. Right click the Input folder created and Add file to it, browse for the Sample.txt file in the Windows Application project we created earlier.


To create a shortcut to the application, right click on Primary output in middle window pane and select Create shortcut to Primary output, name that shortcut as CreatingInstaller.
Select the properties of the shortcut, by right clicking it and add an icon to it. This icon will be created at desktop when the application will launch. Below figures explain how to add an icon.


Cut the shortcut created at Application Folder and Paste it under User’s Desktop Folder.Job done to create a shortcut to user’s desktop.


For shortcuts to be created at User’s Program Menu, add a new folder to User’s Program Menu, that will be created at program’s menu location, in that folder create a new shortcut pointing the primary output as done for creating desktop shortcut. The three images as following describes the process,



Name the folder CreatingInstaller.
Right click on middle window pane to create a new shortcut.


Select shortcut source to primary output selected.
Also add icon to shortcut, as done for Desktop shortcut.


Right click Application folder to set the properties of where to install the application,


Uninstall
We always have an option to uninstall the application from control panel’s Programs and Features list as simple as that but how about creating our own uninstaller, that too under programs menu so that we do not have to disturb control panel.
Step1:
Right click on File System on target Machine and Add Special Folder->System Folder as shown in below figure.


Step2:
Right click on newly created system folder and browse for msiexec.exe file in local System.Windows32 folder. This file takes responsibility to install and uninstall the application based on certain parameters specified.

Set the properties of the file exactly as shown in the figure,


Step4:
Now create a new shortcut under User’s program Menu and point its source to msiexec as shown below. You can add icons and name to your shortcut. I have given it the name “Uninstall”.

Step5:
Press F4 key by selecting the setup project, we see a list of properties, we can customize these properties as per out installation needs, like set Product name, Author, Installation location, I’ll not go into a deep discussion about all this, as they are quite easy to understand and set.
Just take a note of product code shown below in the list of properties. We would need product code as a parameter to msiexec for uninstallation.

Step6:
Right click the Uninstall shortcut and set the arguments property as shown in below figure,
/x {product code} /qr
/x is for uninstalltion.
You can get the whole detaild list of parameters and their use at http://technet.microsoft.com/en-us/library/cc759262(v=ws.10).aspx , chose the one you like to.

Step7:
Save all and Rebuild the setup project.
Job Done !
Now our setup is ready to install our windows application.
Just browse the debug folder location of Setup project, we find a msi and a setup.exe, one can run either of two to initiate setup.
When started we see a setup wizard, having screens which welcome’s user, which asks for location to install(already showing default location set.)



After completing the wizard,Click the close button.

 Now Job is done, we can see our shortcuts to the application created at desktop and User’s Program Menu like in below given figure. 

Now if we navigate to out installation location we can also see the Input folder created and Sample.txt file resting inside it.
Run the application and see the output, works perfectly as was when executed from visual studio.

Click on uninstall to remove the application, the wizard launches as shown below,


Custom Actions
Just wanted to give a glimpse of Custom Actions we can define, while making setup.
Custom actions are the actions which contains customized functionality apart from default one at the time of installation and uninstallation. For e.g. My QC team reported a bug that when the run the application and in background uninstall the application, the application still keeps on running. As per them it should show a message or close while uninstallation. Hard to explain them the reason, I opted for implementing their desire in setup project.
1.Just add an installer class to the windows application we created earlier. When we open the installer class we can see the events specified for each custom action i.e. for Installation, Uninstallation, Rollback,Commit.


My need was to write code for uninstallation, so I wrote few lines to fulfill the need,
The code contains the logic to find the running exe name at the time of uninstallation, if it matches my application exe name, just kill the process. Not going into more details to it.Just want to explain the use of custom actions.
using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Configuration.Install;
using System.Diagnostics;
using System.Linq;
namespace CreatingInstaller
{
    [RunInstaller(true)]
    public partial class Installer1 : System.Configuration.Install.Installer
    {
        public override void Install(IDictionarysavedState)
        {
            base.Install(savedState);
            //Add custom code here
        }
        public override void Rollback(IDictionarysavedState)
        {
            base.Rollback(savedState);
            //Add custom code here
        }
        public override void Commit(IDictionarysavedState)
        {
            base.Commit(savedState);
            //Add custom code here
        }
        public override voidUninstall(IDictionary savedState)
        {
            Processapplication = null;
            foreach(var process inProcess.GetProcesses())
            {
                if(!process.ProcessName.ToLower().Contains(“creatinginstaller”)) continue;
                application = process;
                break;
            }
            if(application != null && application.Responding)
            {
                application.Kill();
                base.Uninstall(savedState);
            }
        }
    }
}
2. Click on Custom Actions Editor after selecting CreatingInstallerSetupproject.

3. We see custom action editor pane on left window, right click it to add custom action and select primary output in Application Folder.


4. We see primary output added as custom actions now. Now at the time of uninstallation my custom action will be fired, and application will be closed while uninstalling it.


.Net Framework
What if installation machine do not have .net framework. We can specify our own package supplied with installation, so that our application do not depend on the .net framework of client machine, but points to the package we supplied to it to run.
Right click on Setup project, to open properties window.
Here we can specify pre-requisites for the application to install. Just click on Prerequisites button and, in the opened prerequisites window, select checkbox for the .net framework application needs to follow, and select radio button at no. 2 i.e. Download prerequisites from the same location as my application. Press OK save the project and re-build it.

Now when we browse to Debug folder of Setup project we see two more folders as a result of actions we did just now.
Now this whole package has to be supplied to the client machine for installation of the application.

Now re-install the application from setup.exe, and launch it using shortcuts.
Conclusion
The tutorial covers the basic steps for creating the installation project. I did not go very deep explaining registry, license agreements though. There are many things to be explored yet to understand and master this topic. However, this article was just a start for a developer to play around with setup and deployments. Happy Coding J
Download source code

Articles: http://www.codeproject.com/script/Articles/BlogFeedList.aspx?amid=7869570

Ref and Out in C# (The Inside Story)


Introduction

One might incorporate n number of methods to return or pass parameters while method calling. Most of the time a developer try to escape using c# feature of parameter passing by reference.Had he know the power of ref and out, a developer will certainly make full use of this feature of parameter passing. My effort in this article would be to make this understanding simpler and focus on internal logic of ref and out.

Value Types vs Reference Types (Quick Overview)

As we know that in C# .NET there are two type of “types”: reference types and value types. Since they act in their own special way, so they must always be used according to the real need and not by force.

Reference type variables have their value a reference to the appropriate data rather than the data itself.Its ByRef in VB6,& in c++.

Value type directly contain the data and not the reference.And when assigned the copy of that data is made to the assingment.To elaborate, a new storage space is created for the variable in the function member declaration, and it starts off with the value that we specify in the member method calling. If we change that value, it doesn’t affect any variable involved in that call.

Why Pass by Reference ?

While writing a code, we often come across situations where in we need to return multiple values from a single function/method. But a method can only return a single value.The question is how do we overcome such situation.Answer is simple, use reference types, but how?

Let’s throw some light on when to use the methodology . When you pass in a variable to a method, the value of that variable gets copied to the method by default. For values types, it means that the object itself gets copied on the other end for reference types, it means that only the thing that points at the object gets copied.

It is one way to save performance, else as larger as the reference type would be as more performance it would cost. So we can also refer this as “Call by Sharing”. In a call by reference situation, if the variable of a reference type is changed inside the method, the caller variable also gets affected. If we change a the value of a value type, when passed to a method, it will never affect the caller variable.

Our Target (Ref and Out)

Parameters are always passed by value to a method by default.If we want to pass them by reference then we can use either out or ref keyword.

Reference parameters basically never pass the value of a variable used in the method calling,instead they use the variable themselves. Rather than creating a new storage for that variable in the method declaration, the vaery same storage space is used, so the value of the variable in the member method and the value of the reference parameter will always be the same. Reference parameters require ref modifier as part of both the declaration and the calling.

Output parameters are very much like reference parameters.The variable specified at the time of calling doesn’t need to have been assigned a value before it is passed to the called method. When the method is invoked completely ,We can read that variable as it is assigned by now.

Like reference parameters, output parameters don’t create a new storage location, but use the storage location of the variable specified on the invocation. Output parameters need the out modifier as part of both the declaration and the invocation – that means it’s always clear when you’re passing something as an output parameter.
Consider the following scenario,

I have developed a simple console application to clarify the logic with the following code in Program.cs class,   

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace ref_and_out
{
class Program
{
static void Main(string[] args)
{
string name1 = “Akhil”;
string name2=“Akhil”;
Program program=new Program();
Console.WriteLine(“Name Before Calling RefMethod : “+ name1);
program.RefMethod(ref name1);
Console.WriteLine(“Name After Calling RefMethod : “ + name1);
Console.WriteLine(“Name Before Calling OutMethod : “ + name2);
program.OutMethod(out name2);
Console.WriteLine(“Name After Calling OutMethod : “ + name2);
Console.ReadLine();
}
private void RefMethod(ref string nameRef)
{
  nameRef = “Akhil Mittal”;
}

private void OutMethod(out string nameOut)
{
  Console.WriteLine(nameOut);
}
}
}
As we can see in the above easy to understand code, I have created two methods RefMethod and OutMethod to handle passed parameter into their invocation.Just to check what were the values of my variables before and after assignment ,When i compiled the code i got the following compile time error,




Certainly the error helped me to discover some new facts about out and ref,
The parameter initially is considered not assigned in case of out .
The variable specified at the time of calling doesn’t need to have been assigned a value before it is passed to the function member. Its the responsibility of called method to assign it before completing the execution so that we can read it.
I changed the code to ,
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ref_and_out
{
    class Program
    {
        static void Main(string[] args)
        {
            string name1 = “Akhil”;
            string name2;
            Program program=new Program();
            Console.WriteLine(“Name Before Calling RefMethod : “+ name1);
            program.RefMethod(ref name1);
            Console.WriteLine(“Name After Calling RefMethod : ” + name1);
            program.OutMethod(out name2);
            Console.WriteLine(“Name After Calling OutMethod : ” + name2);
            Console.ReadLine();
        }

        private void RefMethod(ref string nameRef)
        {
            nameRef = “Akhil Mittal”;
        }

        private void OutMethod(out string nameOut)
        {
            nameOut = “Akhil Mittal in out method”;
        }
    }
}
and as expected,it worked fine.
Then to check if same is the case with ref also, i again made some modifications as,

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace ref_and_out
{
    class Program
    {
        static void Main(string[] args)
        {
            string name1;
            string name2;
            Program program=new Program();
            Console.WriteLine(“Name Before Calling RefMethod : “+ name1);
            program.RefMethod(ref name1);
            Console.WriteLine(“Name After Calling RefMethod : ” + name1);
            program.OutMethod(out name2);
            Console.WriteLine(“Name After Calling OutMethod : ” + name2);
            Console.ReadLine();
        }
        private void RefMethod(ref string nameRef)
        {
            nameRef = “Akhil Mittal”;
        }
        private void OutMethod(out string nameOut)
        {
            nameOut = “Akhil Mittal in out method”;
        }
    }
}
   and yes, i got the compile time error,


That means unlike out type, In ref,

Parameter must be initialized before calling the function.
Therefore Out and ref basically add something new to the the meaning of “pass by reference” by specifying that the variable must be initialized and will be modified (ref) and that the same will be initialized inside of the function (out).

The Inside Story (Some points to remember)

  • Several inbuilt methods as “TryParse” (one of my favourite) use out and not ref as the inside the internal implementation the library mainly uses ref. Therefore out is a special form of ref in which  the referenced memory should not be initialized before the call.

  •  Both the method definition and the calling method must explicitly use the ref / out keyword.

  • There is no “boxing” when a value type is passed by reference.

  • Properties cannot be passed via out or ref, as properties are actually methods.

  • ref / out are not considered to be a part of  method signature at compile time, so methods cannot be overloaded, if the only difference between them is that one of the methods takes a ref argument and the other takes an out argument.

And so the final (running) code  :
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ref_and_out
{
    class Program
    {
        static void Main(string[] args)
        {
            string name1=”Akhil”;
            string name2;
            Program program=new Program();
            Console.WriteLine(“Name Before Calling RefMethod : “+ name1);
            program.RefMethod(ref name1);
            Console.WriteLine(“Name After Calling RefMethod : ” + name1);
            program.OutMethod(out name2);
            Console.WriteLine(“Name After Calling OutMethod : ” + name2);
            Console.ReadLine();
        }
        private void RefMethod(ref string nameRef)
        {
            nameRef = “Akhil Mittal”;
        }
        private void OutMethod(out string nameOut)
        {
            nameOut = “Akhil Mittal”;
        }
    }
}

and the output,



Download the source code from,
https://docs.google.com/viewer?a=v&pid=explorer&chrome=true&srcid=0B6aCOfU3iep1OGU4Nzg2NzgtNjUzMS00NjExLWJlNTUtZGFkN2Q0YjY4NTRm&hl=en_US

Articles: http://www.codeproject.com/script/Articles/BlogFeedList.aspx?amid=7869570

Exception Handling and C#.Net (A Quick Start)


Download Source Code                                                                                                     

Before We Start :
Before you start reading this article you need to ensure you satisfy all the pre-requisites:You must ,

– be familiar with .Net Framework 2.0 or above,
– have c# coding skills,
– have knowledge of sql server 2005 or above,
– be familiar with Visual Studio 2005 or above.
– be familiar with creating web application in Visual Studio 2005 or above.

Overview:
Error Handling has always been crucial for an application in a number of ways. It may affect the execution state of the application, or expose sensitive information to a user.If the error handling is not strong,it may aid the attacker, as the errors returned may assist them in constructing correct attack factors.
An important part of secure application development is to prevent leakage of superfluous information to end user. Error messages if not proper, may give an attacker great insight into the inner workings of an application.

What are Exceptions :
Moving on to the definition,Exceptions are basically the unforeseen errors that happen in our programs. Most of the time, one can, and should, detect and handle application errors in the code. For example, validate user input data, check for null objects,verify the values returned from methods are what one expect, are all examples of good standard error handling that one should be taking care of all the time.

Handling the Anomalies :
Tracing and handling of execution time errors is one of the most crucial tasks ahead of any programmer. But, before discussing the same, let’s look at compile time errors, which are errors that occur during compilation of application. They may cause due to bad coding, misspelling of syntaxes, and so on.
On the other hand, runtime errors occur at the time the program executes and can’t be corrected. A developer can, however, take preventive measures while coding the program. To do so, he should first identify these two aspects:

– Discover the parts of a program that are most likely to emit errors at execution time.
– Handle those errors according to the language conventions. When an exception occurs the program flow for the executing method is interrupted. If the exception is not handled explicitly, the method exits and the exception is escalated to the calling function. This calling function has the opportunity to handle that error. The process continues until the exception is handled by the application or it reaches the Language’s runtime system.

An unhandled exception that reaches the Language’s runtime system causes the immediate, abnormal termination of the program. This can be a problem as the exception is reported to the end user in form of a message or dialog box containing standard information and technical details that may be misunderstood. During debugging this may be useful but in a production system it is generally considered unacceptable. It can also permit the user to attempt to continue to run a program that, due to errors, has become unstable.

A generic custom error page for most errors is recommended. This approach makes it more difficult for attackers to identify signatures of potentially successful attacks. There are methods which can circumvent systems with leading error handling practices which should be kept in mind; Attacks like SQL injection can be used to address such generic responses.

The other key area relating to error handling is the premise of “fail securely”. Errors induced should not leave the application in an insecure state. Resources should be locked down and released, sessions terminated (if required), and calculations or business logic should be halted (depending on the type of error, of course).

“The purpose of reviewing the Error Handling code is to assure that the application fails safely under all possible error conditions, expected and unexpected. No sensitive information is presented to the user when an error occurs.”

Exception handling in General :

C# provides an elegant way to handle runtime errors with the help of the try, catch, and finally keywords. No matter we write a code for a small application or a business level application, the exceptions could be categorized into 3 basic levels,

Level 1. Exception caused by failure of user data validation.

Level 2. Exceptions caused by anomaly in business logic.

Level 3. Application level Exceptions, caused due to application crash,Incorrect/Unexpected output from database, improper hosting of application,Framework level bugs etc.

Exception Handling and .Net :
Centralizing the Exception handling :
Level 3 exceptions commonly need to be centralized at application level, so that when an exception having such behaviour occurs, it is taken care of with immediate effects, In .Net this could be achieved by two methods,

A. Handling the Exception in Global.asax.
B. Handling the exception in web.config.

Since these are the exceptions thrown by Runtime Environment, the exact behaviour of this type of exception is hard to trace.

Right Approach :
This content focusses more on technical feasibility and implementation of the same, we see here how the points discussed above are disguised in the form of code and learn how to implement these points practically in our application.

The Building Blocks :
In .NET a System.Exception object exists. Mostly used child objects such as ApplicationException and SystemException are used. It’s not recommended that one throws or catches a SystemException as that is thrown by CLR automatically..

When an error occurs, the system or the currently executing application reports it by throwing an exception containing information about the error. Once exception thrown, it is handled by the application or by the default exception handler. This Exception object contains methods such as:

StackTrace of Exception,
Source of Exception,
Message in Exception,
InnerException of that object.

In .NET we need to look at the error handling strategy from the point of view of global error handling and handling of unexpected errors.

To avoid program to crash, the exceptions must be caught using a try-catch statement.

Consider the following live scenarios,
Let’s have an aspx page with the following controls, a textbox, a button and a gridview,

When user inputs a student id in the textbox and submits the form by clicking submit button(Populate Grid), the gridview gets populated with the details of the student as per student id.

Code to populate grid ,

aspx:

.cs :

Following are the points that need to be taken care of,

a) The text box value must be an integer value. (Input Validation)

b) The student id provided should be greater than 0 and less than 5. (Business Logic Validation)

These are the rules known to a developer,but what if end user uses the application?Let’s sneak peek into such scenario,

Scenario 1 : User inputs correct value and presses submit button,

  Scenario 2 : User inputs a string or junk character and presses submit button

results in,

 

As we can clearly see, whole of the code is exposed to end user which is ethically meaningless.

Instead one should display a meaningfull message to the user, so that next time he inputs correct info.

Therefore we need to wrap our code with a try, catch block.

and following piece of code in aspx page,

<div>
   <asp:Label runat=”server” ID=”lblErrorDisplay” ForeColor=”Red” FontBold=”true” Visible=”false” Font-  Size=”Medium” ></asp:Label>
</div>

now when user inputs value other than integer, he is shown a meaningfull message as,

Our application should not scare the end user with displaying yellow pages and complex codes but it should be informative and end-user friendly.

 

Scenario 3 : User inputs an integer but violates business logic by entering 5 or integer greater than 5,

Our case : No message is shown to the user, the page simply refreshes itself,

Ideal case : User should be shown a message that “no user exists with the specified id, please enter another id between 1 to 5”, after getting this message user will no longer sit idle thinking about what is wrong with the web site, he will take some other fruitfull action.

To overcome such issue we can again decorate our code as,

protected void btnSubmit_Click(object sender, EventArgs e){
try
{
string textValue = txtId.Text;
    int id;
if (!Int32.TryParse(textValue, out id)){

throw new ApplicationException(“Please provide correct student id.”);}

 

   if (id = 5){
throw new ApplicationException(“No user exists with the specified id, please enter                                               another id between 1 to 5”);}

 

string connectionString = ConfigurationManager.ConnectionStrings[“Connection”].ConnectionString;
SqlConnection sqlConnection = new SqlConnection(connectionString);
SqlCommand sqlCommand = new SqlCommand(“Select StudentID,Fnamn,Enamn,Email,Login,Password from egStudent where StudentId=” +
id.ToString(), sqlConnection);
DataSet dataSet = new DataSet();
SqlDataAdapter sqlDataAdapter = new SqlDataAdapter(sqlCommand);
sqlConnection.Open();
sqlDataAdapter.Fill(dataSet);
grdStudentView.DataSource = dataSet.Tables[0];
grdStudentView.DataBind();
sqlConnection.Close();
sqlDataAdapter.Dispose();
}
catch (ApplicationException exception){
lblErrorDisplay.Visible = true;
lblErrorDisplay.Text = exception.Message;
}
}

therefore the output, 

 


The Exceptions discussed above were the Level 1 and Level 2 type exceptions.

Next comes Level 3.For level 3 type exceptions a special setup needs to be established, so that the exceptions could be handled as desired, simple playing with try catch blocks sometimes does not work with these kind of exceptions,

Scenario 4 : Developer mistakingly writes a wrong query in select statement, suppose he makes a typo and changes table name to egstudents (correct : egstudent),let’s see what happens,

protected void btnSubmit_Click(object sender, EventArgs e)
{
try
{
string textValue = txtId.Text;
int id;
if (!Int32.TryParse(textValue, out id))
{
throw new ApplicationException(“Please provide correct student id.”);
}
if (id = 5)
{
throw new ApplicationException(“No user exists with the specified id, please enter another id between 1 to 5”);
}
string connectionString = ConfigurationManager.ConnectionStrings[“Connection”].ConnectionString;
SqlConnection sqlConnection = new SqlConnection(connectionString);
SqlCommand sqlCommand = new SqlCommand(“Select StudentID,Fnamn,Enamn,Email,Login,Password from egStudents where StudentId=” +
id.ToString(), sqlConnection);
DataSet dataSet = new DataSet();
SqlDataAdapter sqlDataAdapter = new SqlDataAdapter(sqlCommand);
sqlConnection.Open();
sqlDataAdapter.Fill(dataSet);
grdStudentView.DataSource = dataSet.Tables[0];
grdStudentView.DataBind();
sqlConnection.Close();
sqlDataAdapter.Dispose();
}
catch (ApplicationException exception)
{
lblErrorDisplay.Visible = true;
lblErrorDisplay.Text = exception.Message;
}
}

and so , the output :

In this special case, once the site is up,It becomes hard for developer too to trace the code, Moreover end user again is exposed to the unwanted yellow page.

Cure : These kind of Level 3 exceptions need to be centralized(as discussed before in the article),We can write the piece of code in Global.asax on Application_Error event (handles application level errors),one can write the code to log the specific error and show end user a custom error page, to overcome panic situation.

Step1 : Add code to Global.asax,

 

void Application_Error(object sender, EventArgs e)
{
Exception exception = Server.GetLastError();
LoggError.Write(exception);
}

Step2 : Create a Custom Error Page, and define its path in web.config with a key value pair in appsettings,

ErrorPage.aspx:
<!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0 Transitional//EN” “

 

< html xmlns=”http://www.w3.org/1999/xhtml”&gt;
<head>
<title></title>
</head>
<body>
<center>
<div><img src=”ErrorPage1.jpg” alt=”Error Page” /></div>
</center>
</body>
</html>
Page Path :
<appSettings>
<add key=“ErrorLog” value=“~/ErrorLog.txt“ />
</appSettings>
 

Step 3: Enable Custom error mode in web.config inside system.web node with path to your error page as default redirect,

<customErrors mode=“On” defaultRedirect=“Error/ErrorPage.htm“>
</customErrors>

Step 4: Add a class to your appCode folder, that logs the error into a text file.

using System;
using System.Configuration;
using System.IO;
using System.Web;

///
/// The Class Writes Exception and Error information into a log file named ErrorLog.txt.
///

public class LoggError
{
///
/// Writes error occured in log file,if log file does not exist,it creates the file first.
///

/// Exception
public static void Write(Exception exception)
{
string logFile = String.Empty;
StreamWriter logWriter;
try
{
logFile = HttpContext.Current.Server.MapPath(ConfigurationManager.AppSettings[“ErrorLog”].ToString());
if (File.Exists(logFile))
logWriter = File.AppendText(logFile);
else
logWriter = File.CreateText(logFile);
logWriter.WriteLine(“=>” + DateTime.Now + ” ” + ” An Error occured : ” +
exception.StackTrace + ” Message : ” + exception.Message + “\n\n”);
logWriter.Close();
throw exception;
}
catch (Exception e)
{
throw e;
}
finally
{
throw exception;
}
}
}

finally, when such error occurs, user is displayed an error page as below,

and for the sake of debugging and development,Actual error is logged in a text file (in my case located at root) as,

=>11/21/2011 7:42:02 PM An Error occured : at System.Web.UI.Page.HandleError(Exception e)
at System.Web.UI.Page.ProcessRequestMain(Boolean includeStagesBeforeAsyncPoint, Boolean includeStagesAfterAsyncPoint)  at System.Web.UI.Page.ProcessRequest(Boolean includeStagesBeforeAsyncPoint, Boolean includeStagesAfterAsyncPoint)
at System.Web.UI.Page.ProcessRequest()
at System.Web.UI.Page.ProcessRequestWithNoAssert(HttpContext context)
at System.Web.UI.Page.ProcessRequest(HttpContext context)
at ASP.default_aspx.ProcessRequest(HttpContext context) in c:\Users\akhil.mittal\AppData\Local\Temp\Temporary ASP.NET Files\exceptionhandling\327c9c5b\2858bbb8\App_Web_iexkgkvc.2.cs:line 0 at System.Web.HttpApplication.CallHandlerExecutionStep.System.Web.HttpApplication.IExecutionStep.Execute() at System.Web.HttpApplication.ExecuteStep(IExecutionStep step, Boolean& completedSynchronously) Message : System.Data.SqlClient.SqlException (0x80131904): Invalid object name ‘egStudents’.
at _Default.btnSubmit_Click(Object sender, EventArgs e) in d:\Akhil Mittal\Blogs\ExceptionHandling\Default.aspx.cs:line 56
at System.Web.UI.WebControls.Button.OnClick(EventArgs e)
at System.Web.UI.WebControls.Button.RaisePostBackEvent(String eventArgument)
at System.Web.UI.WebControls.Button.System.Web.UI.IPostBackEventHandler.RaisePostBackEv ent(String eventArgument)  at System.Web.UI.Page.RaisePostBackEvent(IPostBackEventHandler sourceControl, String eventArgument) at System.Web.UI.Page.RaisePostBackEvent(NameValueCollection postData)
at System.Web.UI.Page.ProcessRequestMain(Boolean includeStagesBeforeAsyncPoint, Boolean includeStagesAfterAsyncPoint)

The log gives full information about the type and source of exception.
There are many other ways to handle Level 3 Exceptions which we’ll discuss in next coming articles, but to  hit the floor running, this one is the beginning.

And last but not the least, the Finally block,

Finally block:

As the last clause in the try-catch statement a finally block can also be added. This block is used to clean up all the resources allocated in the try block and will always execute whether there is an exception or not. In the above scenarios for example, we can make use of this block to free sql connection as ,

sqlConnection.Close();
sqlDataAdapter.Dispose();

and thus the final code,

protected void btnSubmit_Click(object sender, EventArgs e)
{
string textValue = txtId.Text;
int id;
string connectionString = ConfigurationManager.ConnectionStrings[“Connection”].ConnectionString;
SqlConnection sqlConnection = new SqlConnection(connectionString);
SqlDataAdapter sqlDataAdapter = new SqlDataAdapter();
DataSet dataSet = new DataSet();
try {

 

if (!Int32.TryParse(textValue, out id))
      throw new ApplicationException(“Please provide correct student id.”);
      if (id = 5)
      throw new ApplicationException(“No user exists with the specified id, please enter another id between 1   to 5”);
     SqlCommand sqlCommand = new SqlCommand(“Select  StudentID,Fnamn,Enamn,Email,Login,Password from egStudents where StudentId=” +
id.ToString(), sqlConnection);
sqlDataAdapter = new SqlDataAdapter(sqlCommand);
sqlConnection.Open();
sqlDataAdapter.Fill(dataSet);
grdStudentView.DataSource = dataSet.Tables[0];
grdStudentView.DataBind();
}
   catch (ApplicationException exception)
{
lblErrorDisplay.Visible = true;
lblErrorDisplay.Text = exception.Message;
}
   catch (Exception exception)
{
    throw exception;
}
   finally
{
sqlConnection.Close();
sqlDataAdapter.Dispose();
}
}

For Source Code you can drop me a mail at akhil.mittal20@gmail.com.

or download it from ,
Github
In my next blog, we’ll discuss about Exception Handling in Multilayered .Net Application.

Read more:

Other Series

My other series of articles:

For more technical articles you can reach out to my personal blog CodeTeddy.


Happy Coding. 🙂