Sunday, November 29, 2015

Angularjs Routing Recipe with classic asp.net mvc application

Introduction
In the last two years, I have been learning angular js Module Pattern. The power of the AngularJS Framework, It’s really amazing and the good stuff is that you can do quickly. One of the thing in AngularJS is impressed me is the routing Framework. Now I want to try and share some of the knowledge that I have found what is Routing and how to configure and work with classic asp.net mvc application.

Source Code Here 

Background

In a classic ASP.NET MVC application, stepping between parts of the application usually requires a trip to the web server to refresh the entire contents of the page. However, in a Single Page Application (SPA), only elements within the page are updated giving the user a better, more responsive experience.
In classic asp.net mvc implementation may still make transitions to other sections of the application with a full page refresh,but generally a single page manages the application’s functionality through dynamic views and web service (AJAX) calls.AngularJS supports dynamic views through routes and the ngView directive and your MVC application would provide the partial views that the ngView directive will dynamically load.

Using the code

In this example, the views, called Home, About, and Contact, are simple partial views rendered by the MVC controller.


 public class HomeController : Controller  
   {  
     public ActionResult Index()  
     {  
       return View();  
     }  
     public ActionResult Home()  
     {  
       return PartialView();  
     }  
     public ActionResult About()  
     {  
       return PartialView();  
     }  
     public ActionResult Contact()  
     {  
       return PartialView();  
     }  
   }  



App.js this is the file which is going to have the AngularJS application module declared in it. Also the state navigation declared.Ok, let us see the configurations one by one.

Routes are used by the ngView directive which has the responsibility of loading the route’s content. As the routes change, the content gets automatically updated.

<div ng-view></div>.


 'use strict';  
 var app = angular.module('App',['ngRoute']);  
 app.config(['$routeProvider', '$locationProvider', function ($routeProvider, $locationProvider) {  
     $routeProvider.when('/', {  
       templateUrl: '/Home/Home',  
       controller: 'homeCtrl',  
     });  
     $routeProvider.when('/About', {  
       templateUrl: '/Home/About',  
       controller: 'aboutCtrl',  
     });  
     $routeProvider.when('/Contact', {  
       templateUrl: '/Home/Contact',  
       controller: 'contactCtrl'  
     });  
     $routeProvider.otherwise({  
       redirectTo: '/'  
     });  
   }]);  

This line delcares the AngularJS module and the 'ngRoute' module injected into it.


 App.config(function ($stateProvider, $urlRouterProvider) {  
 }  



The above line is the state routing configuration which will be declared using the .config function
the $routeProvider and $locationProviderare the services which are available to handle the state navigation. The state navigation declaration has the following parameters,
stateName, Template or TemplateURL and the Controller




Friday, November 27, 2015

Design Pattern Overview

Many people teach design patterns as a fundamental step to Object Oriented Programming.
In this post we are going to discussing ideas design pattern more details step by step
with my fellow code junkies.

Now question what actually design patterns represent in software development?
Design patterns represent the best practices used by experienced object-oriented software developers.Design patterns are solutions to general problems that software developers faced during software development.

Design Patterns have two main usages in software development. This are the common platform for developers and best practices.

In this article post discussion will be covering...

1)What they are?
2)Where they came form?
3)Why they matter?

Software professionals may be familiar with the term "Design Patterns," but many have no idea of where they come from and what they truly are.Consequently, some do not see the value and benefits design patterns bring to the software development process.

What Design Patterns are?


  1. General and reusable solutions or template to common problems in software design
  2. Not a finished solution
  3. A template or recipe for solving certain problems
  4. With names to identify them


Patterns deal with:


  1. Application and system design
  2. Abstractions on top of code
  3. Relactionships between classes or other collaborators
  4. Problems that have already been solved


Patterns are not concerned with:


  • Algorithms
  • Specific implementations or classes...


Design Patterns History:
 Design Patterns: Elements of Reusable Object-Oriented Software in 1994 by Gang of Four: Eric Gamma,Richard Helm, Ralph Johnson, and John Vlissides.
This book is considered to be the "coming out" of design patterns to the software community.
In 1998, the Gang Of Four were awarded Dr Dobbs Journal 1998 Excellence in Programming Award.


Design Patterns Structure:

Term Descrition
Pattern Name     Describes the essence of the pattern in a short
Intent Describes what the pattern does
Also Known As   List any synonyms for the pattern
Motivation Provides an example of a problem and how the pattern solves that problem
Applicability                Lists the situations where the pattern is applicable
Structure                     Set of diagrams of the classes and objects that depict the pattern
Collaborations Describes how the participants collaborate to carry out their responsibilities


Design Patterns Benefits
Design patterns have two major benefits. First one, they provide you with a way to solve issues related to software development using a proven solution.
Second one, design patterns make communication between designers more efficient.

Wednesday, November 11, 2015

What are the different types of Assembly?

There are two types of assemblies are there in .net. They are, 
1. Private Assemblies and 
2. Public/Shared Assemblies. 

Private Assembly:- An assembly is used only for a particular application. It is stored in the application's directory other wise in the application's sub directory. There is no version constraint in private assembly. 

Public Assembly:- It has version constraint. This public assembly is stored inside the global assembly cache or GAC.GAC contains a collection of shared assemblies.

What is a Assembly?


In more simple terms Assembly is unit of deployment like EXE or a DLL.
Precompiled code that can be executed by the .NET runtime environment.

Multiple versions can be deployed side by side in different folders. These different
versions can execute at the same time without interfering with each other.
Assemblies can be private or shared. For private assembly deployment, the
assembly is copied to the same directory as the client program that references it. No
registration is needed, and no fancy installation program is required. When the
component is removed, no registry cleanup is needed, and no uninstall program is
required. Just delete it from the hard drive.

In shared assembly deployment, an assembly is installed in the Global Assembly
Cache (or GAC). The GAC contains shared assemblies that are globally accessible
to all .NET applications on the machine.

What is a Managed Code?

Managed code runs inside the environment of CLR that is .NET runtime. In short, all IL i mean Intermediate Language  are managed code.

However, if you are using some third party software example VB6 or VC++
component they are unmanaged code, as .NET runtime (CLR) does not have control over the
source code execution of these languages.

Sunday, November 8, 2015

Remove duplicate from list c#




list.Sort();  
Int32 index = 0;  
while (index < list.Count - 1)  
{  
if (list[index] == list[index + 1])  
list.RemoveAt(index); 
        else index++; 
}

Thursday, October 29, 2015

What is an IL?

What is an IL?

(IL)Intermediate Language is also known as MSIL (Microsoft Intermediate Language) or CIL
(Common Intermediate Language). All .NET source code is compiled to IL. IL is then converted
to machine code at the point where the software is installed, or at run-time by a Just-In-Time
(JIT) compiler.

What is a CLR?

What Is CLR?

Full form of CLR is Common Language Runtime and it forms the heart of the .NET framework.
All Languages have runtime and it is the responsibility of the runtime to take care of the code
execution of the program. For example, VC++ has MSCRT40.DLL, VB6 has MSVBVM60.DLL,
and Java has Java Virtual Machine etc. Similarly, .NET has CLR. Following are the
responsibilities of CLR
• Garbage Collection: - CLR automatically manages memory thus eliminating
memory leaks. When objects are not referred, GC automatically releases those
memories thus providing efficient memory management.
• Code Access Security: - CAS grants rights to program depending on the security
configuration of the machine. Example the program has rights to edit or create a
new file but the security configuration of machine does not allow the program to
delete a file. CAS will take care that the code runs under the environment of
machines security configuration.
• Code Verification: - This ensures proper code execution and type safety while the
code runs. It prevents the source code to perform illegal operation such as accessing
invalid memory locations etc.
• IL (Intermediate language)-to-native translators and optimizer’s:- CLR uses
JIT, compiles the IL code to machine code, and then executes. CLR also determines
depending on platform what is optimized way of running the IL code.

Persistence concept in Objects of C#

 What is Persistence concept?

Persistence is the capability of an object to save and restore data. The object can be saved to the disk with its current state. You can use it later from the disk, with the attributes with which it was saved. Without this capability of saving and restoring we would have to re-configure object every time we quit an application.

How Can you do it Programmatically in objects of C# and your own Objects ?

The .NET framework ships with two serialization systems. One is represented by the System.Xml.Serialization.XmlSerializer class and is intended for saving and loading objects to and from human-readable XML. The other is represented by System.Runtime.Serialization.Formatter, and is designed to save and load arbitrary objects in binary or SOAP format (or any other custom formats you may want to provide, but you probably won't need that), mainly for remoting, but useful for saving and loading to and from files, as well. Both are useful in different situations -- if you have a relatively simple object and want to have a lot of control over the format in which it's saved, use XmlSerializer. If you have a complex object (especially if it has recursive object references -- that is, a property that points to an object that has a back-reference to the parent object), and don't really care what format you use, use Formatter (specifically, BinaryFormatter, as it's more concise than SoapFormatter). The Formatter classes can serialize and deserialize any object that has a SerializableAttribute applied to it, or implements ISerializable. 99 out of 100 times, you won't need special support for ISerializable -- just put SerializableAttribute on your class, and it'll usually work (the exception being if your object has members that can't be persisted properly, such as GDI+ objects like Brush or Pen -- if you need this support, post back with some details, and I can give you examples of how to do it). Here's an example of how to use BinaryFormatter (System.Runtime.Serialization.Formatters.Binary.BinaryFormatter) to save and load an object:
public void SerializeObject(object o, string fileName)
{
 using (Stream s = File.OpenWrite(fileName))
 {
  BinaryFormatter bf = new BinaryFormatter();
  bf.Serialize(s, o);
 }
}


public object DeserializeObject(string fileName)
{
 using (Stream s = File.OpenRead(fileName))
 {
  BinaryFormatter bf = new BinaryFormatter();
  return bf.Deserialize(s);
 }
}
XmlSerializer is a bit less robust, in that it is more limited in the objects it's able to handle (for example, it can't handle recursive references or, in fact, any kind of strongly-typed reference to another object in the graph other than a simple parent/child relationship), but it's useful when you need your data to be human-readable (or human-editable), and even more so if you have an already-established XML format that you have to use. If you have an XSD schema for your format, you can use the xsd.exe tool included in the .NET framework to generate a class which the XmlSerializer can use to read and write the XML described in the schema. Here are the same two functions described above, implemented using the XmlSerializer:
public void SerializeObject(object o, string fileName)
{
 using (TextWriter tw = new StreamWriter(File.OpenWrite(fileName)))
 {
  XmlSerializer xs = new XmlSerializer(o.GetType());
  xs.Serialize(tw, o);
 }
}

public object DeserializeObject(string fileName, Type t)
{
 using (TextReader tr = new StreamReader(File.OpenRead(fileName)))
 {
  XmlSerializer xs = new XmlSerializer(t);
  return xs.Deserialize(tr);
 }
}
Notice that the major differences in usage between the two serializers are that Formatter uses Streams while XmlSerializer can use readers and writers (or streams, but it simply creates a reader/writer to wrap around the stream internally), and that Formatter can get all the information it needs from the serialized stream, but XmlSerializer needs to be told the type of the root object.

Difference between Co-related Sub-Query and Sub-query

Below example is not Co-related Sub-Query. It is Derived Table / Inline-View since i.e, a Sub-query within FROM Clause.

A Corelated Sub-query should refer its parent(main Query) Table in it. For example See find the Nth max salary by Co-related Sub-query:

SELECT Salary
FROM Employee E1
WHERE N-1 = (SELECT COUNT(*)
             FROM Employee E2
             WHERE E1.salary <E2.Salary)
Co-Related Vs Nested-SubQueries.

Technical difference between Normal Sub-query and Co-related sub-query are:

1. Looping: Co-related sub-query loop under main-query; whereas nested not; therefore co-related sub-query executes on each iteration of main query. Whereas in case of Nested-query; subquery executes first then outer query executes next. Hence, the maximum no. of executes are NXM for correlated subquery and N+M for subquery.

2. Dependency(Inner to Outer vs Outer to Inner): In the case of co-related subquery, inner query depends on outer query for processing whereas in normal sub-query, Outer query depends on inner query.

3.Performance: Using Co-related sub-query performance decreases, since, it performs NXM iterations instead of N+M iterations. ¨ Co-related Sub-query Execution.

How IIS Process ASP.NET Request

Introduction

When request come from client to the server a lot of operation is performed before sending response to the client. This is all about how IIS Process the request.  Here I am not going to describe the Page Life Cycle and there events, this article is all about the operation of IIS Level.  Before we start with the actual details, let’s start from the beginning so that each and everyone understand it’s details easily.  Please provide your valuable feedback and suggestion to improve this article.

What is Web Server ?

When we run our ASP.NET Web Application from visual studio IDE, VS Integrated ASP.NET Engine is responsible to execute all kind of asp.net requests and responses.  The process name is“WebDev.WebServer.Exe” which actually takw care of all request and response of an web application which is running from Visual Studio IDE.
Now, the name “Web Server” comes into picture when we want to host the application on a centralized location and wanted to access from many locations. Web server is responsible for handle all the requests that are coming from clients, process them and provide the responses.

What is IIS ?

IIS (Internet Information Server) is one of the most powerful web servers from Microsoft that is used to host your ASP.NET Web application. IIS has it’s own ASP.NET Process Engine  to handle the ASP.NET request. So, when a request comes from client to server, IIS takes that request and  process it and send response back to clients.

Request Processing :

Hope, till now it’s clear to you that what is Web server and IIS is and what is the use of them. Now let’s have a look how they do things internally. Before we move ahead, you have to know about two main concepts
1.    Worker Process
2.   Application Pool
Worker Process:  Worker Process (w3wp.exe) runs the ASP.Net application in IIS. This process is responsible to manage all the request and response that are coming from client system.  All the ASP.Net functionality runs under the scope of worker process.  When a request comes to the server from a client worker process is responsible to generate the request and response. In a single word we can say worker process is the heart of ASP.NET Web Application which runs on IIS.
Application Pool: Application pool is the container of worker process.  Application pools is used to separate sets of IIS worker processes that share the same configuration.  Application pools enables a better security, reliability, and availability for any web application.  The worker process serves as the process boundary that separates each application pool so that when one worker process or application is having an issue or recycles, other applications or worker processes are not affected. This makes sure that a particular web application doesn’t not impact other web application as they they are configured into different application pools.
Application Pool with multiple worker process is called “Web Garden”.
Now, I have covered all the basic stuff like Web server, Application Pool, Worker process. Now let’s have look how IIS process the request when a new request comes up from client.
If we look into the IIS 6.0 Architecture, we can divided them into Two Layer
1.    Kernel Mode
2.    User Mode
Now, Kernel mode is introduced with IIS 6.0, which contains the HTTP.SYS.  So whenever a request comes from Client to Server, it will hit HTTP.SYS First.
Now, HTTP.SYS is Responsible for pass the request to particular Application pool. Now here is one questionHow HTTP.SYS comes to know where to send the request?  This is not a random pickup. Whenever we creates a new Application Pool, the ID of the Application Pool is being generated and it’s registered with the HTTP.SYS. So whenever HTTP.SYS Received the request from any web application, it checks for the Application Pool and based on the application pool it send the request.
So, this was the first steps of IIS Request Processing.
Till now, Client Requested for some information and request came to the Kernel level of IIS means at HTTP.SYS. HTTP.SYS has been identified the name of the application pool where to send. Now, let’s see how this request moves from HTTP.SYS to Application Pool.
In User Level of IIS, we have Web Admin Services (WAS) which takes the request from HTTP.SYS and pass it to the respective application pool.
When Application pool receive the request, it simply pass the request to worker process (w3wp.exe) . The worker process “w3wp.exe” looks up the URL of the request in order to load the correct ISAPI extension. ISAPI extensions are the IIS way to handle requests for different resources. Once ASP.NET is installed, it installs its own ISAPI extension (aspnet_isapi.dll) and adds the mapping into IIS.
Note : Sometimes if we install IIS after installing asp.net, we need to register the extension with IIS using aspnet_regiis command.
When Worker process loads the aspnet_isapi.dll, it start an HTTPRuntime, which is the entry point of an application. HTTPRuntime is a class which calls the ProcessRequest method to start Processing.
When this methods called, a new instance of HTTPContext is been created.  Which is accessible using HTTPContext.Current  Properties. This object still remains alive during life time of object request.  Using HttpContext.Current we can access some other objects like Request, Response, Session etc.
After that HttpRuntime load an HttpApplication object with the help of  HttpApplicationFactoryclass.. Each and every request should pass through the corresponding HTTPModule to reach to HTTPHandler, this list of module are configured by the HTTPApplication.
Now, the concept comes called “HTTPPipeline”. It is called a pipeline because it contains a set of HttpModules ( For Both Web.config and Machine.config level) that intercept the request on its way to the HttpHandler. HTTPModules are classes that have access to the incoming request. We can also create our own HTTPModule if we need to handle anything during upcoming request and response.
HTTP Handlers are the endpoints in the HTTP pipeline. All request that are passing through the HTTPModule should reached to HTTPHandler.  Then  HTTP Handler  generates the output for the requested resource. So, when we requesting for any aspx web pages,   it returns the corresponding HTML output.
All the request now passes from  httpModule to  respective HTTPHandler then method and the ASP.NET Page life cycle starts.  This ends the IIS Request processing and start the ASP.NET Page Lifecycle.

Conclusion

When client request for some information from a web server, request first reaches to HTTP.SYS of IIS. HTTP.SYS then send the request to respective  Application Pool. Application Pool then forward the request to worker process to load the ISAPI Extension which will create an HTTPRuntime Object to Process the request via HTTPModule and HTTPHanlder. After that the ASP.NET Page LifeCycle events starts.