Tuesday, 13 January 2015

MVC3 Vs MVC4 Vs MVC5 Vs MVC6

Microsoft has added exciting features in every new version of ASP.NET MVC that make developers more comfortable building scalable web applications easily. In this ASP.NET MVC tutorial, we will have a quick look into new and important features introduced in major versions of Microsoft ASP.NET MVC starting fromMVC3 to MVC6 (the latest one so far).

ASP.NET MVC3

  1. New Project Templates having support for HTML 5 and CSS 3.
  2. Razor View Engine introduced with a bundle of new features.
  3. Having support for Multiple View Engines i.e. Web Forms view engine, Razor or open source.

ASP.NET MVC 4

  1. ASP.NET Web API
  2. Refreshed and modernized default project templates
  3. New mobile project template
  4. Many new features to support mobile apps
  5. Display Modes
  6. Bundling and Minification
  7. Enabling Logins from Facebook and Other Sites Using OAuth and OpenID

ASP.NET MVC 5

  1. Attribute based routing such as [Route("Empolyee/{EmpID}")].
  2. ASP.NET Identity for authentication and identity management.ASP.NET Identity is a new Membership provider to handle the authentication and authorization for social networking site just like Google, twitter, face-book etc.
  3. Bootstrap replaced the default MVC template.
  4. Authentication Filters for authenticating user by custom or third-party authentication provider.

ASP.NET MVC6 | ASP.NET vNext

  1. MVC 6 added new cloud computing optimization system of MVC , web API, SignalR and entity framework.
  2. The Microsoft  make a bundle of MVC, Web API, WebPages, SignalR , That bundle we called MVC 6.
  3. In MVC 6, Microsoft removed the dependency of system.web.dll from MVC 6  because it's so expensive. Typically  it consume 30K memory per request/response.
  4. Right now, in MVC 6 consume 2K  memory per request response. It's too small memory  consume.
  5. Most of the problem solved using the Roslyn Compiler.
  6. The ASP .Net  vNext used the Roslyn Compiler,  By using Roslyn compiler do not need to compile the application Its  compile automatically the application code.
  7. The .Net vNext is a cross platform and open source.
  8. The .Net vNext has the new project extension project.json. Basically project.json contain the all dependency dll of the application.
  9. In MVC 5.1 and 5.2 support to Enum and EnumHelper in  razor views.
Continue Reading →

Monday, 12 January 2015

Generics - C#

First of all, let's take an example where generics can be of great help.
Suppose you are writing a class for Stack with methods Push() and Pop(). You have to implement this class in such a way that it works for any data type. Now you will have two options if generic was not there to help you.
  • Define classes for each data types. You can achieve the solution using this approach. However there are many disadvantages of this approach:
    1. You are writing redundant code.
    2. If you need to support a new data type, then you need to add a new class for that.
    3. You are discouraging code reusability.
  • Defined class for data type as object. This is somewhat better than the first approach. However, it has its own disadvantages.
    1. Performance would be degraded because of boxing and un-boxing.
    2. TypeSafety is lost. Your solution will not be type safe.
Generic solves all the above problems. It:
  • allows you to define type-safe data structures, without providing actual data types.
  • allows you to write a class or method that can work with any data type.

Generic Constraints

As you know, you can use any data type with generic classes. Like you can use intfloatdouble data types with generic Stack class. However, sometimes we need to restrict the data types which can be used with particular generic class or methods. We can achieve this using generic constraints.

Generic Constraints are Categorized as Below

Derivation constraints – Restrict the generic type parameter to be derivative of specified interface or class.

public class LinkedList<K,T> where K : IComparable
// K data type must implement IComparable

public class LinkedList<K,T> where K : IComparable<K>
// K data type must implement IComparable<T>

public class LinkedList<K,T> : IEnumerable<T> where K : IComparable<K>
// Derive from IEnumerable<T> and K data type must implement IComparable<K>

public class LinkedList<K,T> where K : IComparable<K>,IConvertible
// K data type must implement IComparable<K> and IConvertible

public class LinkedList where K : IComparable,IConvertible
// K data type must implement both IComparable and IConvertible

Example : 

using System;
using System.Collections.Generic;

namespace GenericApplication
{
    public class MyGenericArray<T>
    {
        private T[] array;
        public MyGenericArray(int size)
        {
            array = new T[size + 1];
        }
        public T getItem(int index)
        {
            return array[index];
        }
        public void setItem(int index, T value)
        {
            array[index] = value;
        }
    }
          
    class Tester
    {
        static void Main(string[] args)
        {
            //declaring an int array
            MyGenericArray<int> intArray = new MyGenericArray<int>(5);
            //setting values
            for (int c = 0; c < 5; c++)
            {
                intArray.setItem(c, c*5);
            }
            //retrieving the values
            for (int c = 0; c < 5; c++)
            {
                Console.Write(intArray.getItem(c) + " ");
            }
            Console.WriteLine();
            //declaring a character array
            MyGenericArray<char> charArray = new MyGenericArray<char>(5);
            //setting values
            for (int c = 0; c < 5; c++)
            {
                charArray.setItem(c, (char)(c+97));
            }
            //retrieving the values
            for (int c = 0; c< 5; c++)
            {
                Console.Write(charArray.getItem(c) + " ");
            }
            Console.WriteLine();
            Console.ReadKey();
        }
    }
}

When the above code is compiled and executed, it produces the following result:
0 5 10 15 20
a b c d e

Generic Methods

In the previous example, we have used a generic class; we can declare a generic method with a type parameter. The following program illustrates the concept:


using System;
using System.Collections.Generic;

namespace GenericMethodAppl
{
    class Program
    {
        static void Swap<T>(ref T lhs, ref T rhs)
        {
            T temp;
            temp = lhs;
            lhs = rhs;
            rhs = temp;
        }
        static void Main(string[] args)
        {
            int a, b;
            char c, d;
            a = 10;
            b = 20;
            c = 'I';
            d = 'V';

            //display values before swap:
            Console.WriteLine("Int values before calling swap:");
            Console.WriteLine("a = {0}, b = {1}", a, b);
            Console.WriteLine("Char values before calling swap:");
            Console.WriteLine("c = {0}, d = {1}", c, d);

            //call swap
            Swap<int>(ref a, ref b);
            Swap<char>(ref c, ref d);

            //display values after swap:
            Console.WriteLine("Int values after calling swap:");
            Console.WriteLine("a = {0}, b = {1}", a, b);
            Console.WriteLine("Char values after calling swap:");
            Console.WriteLine("c = {0}, d = {1}", c, d);
            Console.ReadKey();
        }
    }
}

When the above code is compiled and executed, it produces the following result:
Int values before calling swap:
a = 10, b = 20
Char values before calling swap:
c = I, d = V
Int values after calling swap:
a = 20, b = 10
Char values after calling swap:
c = V, d = I

Generic Delegate

You can define a generic delegate with type parameters. For example:
delegate T NumberChanger<T>(T n);

The following example shows use of this delegate:

using System;
using System.Collections.Generic;

delegate T NumberChanger<T>(T n);
namespace GenericDelegateAppl
{
    class TestDelegate
    {
        static int num = 10;
        public static int AddNum(int p)
        {
            num += p;
            return num;
        }

        public static int MultNum(int q)
        {
            num *= q;
            return num;
        }
        public static int getNum()
        {
            return num;
        }

        static void Main(string[] args)
        {
            //create delegate instances
            NumberChanger<int> nc1 = new NumberChanger<int>(AddNum);
            NumberChanger<int> nc2 = new NumberChanger<int>(MultNum);
            //calling the methods using the delegate objects
            nc1(25);
            Console.WriteLine("Value of Num: {0}", getNum());
            nc2(5);
            Console.WriteLine("Value of Num: {0}", getNum());
            Console.ReadKey();
        }
    }
}

When the above code is compiled and executed, it produces the following result:
Value of Num: 35
Value of Num: 175

Features of Generics

Using generics is a technique that enriches your programs in the following ways:
  • It helps you to maximize code reuse, type safety, and performance.
  • You can create generic collection classes. The .NET Framework class library contains several new generic collection classes in the System.Collections.Generic namespace. You may use these generic collection classes instead of the collection classes in the System.Collectionsnamespace.
  • You can create your own generic interfaces, classes, methods, events and delegates.
  • You may create generic classes constrained to enable access to methods on particular data types.
  • You may get information on the types used in a generic data type at run-time by means of reflection.
Continue Reading →

WCF Services - Choosing the appropriate WCF binding

Windows Communication Foundation is a programming model that enables us to develop and then expose our services in a variety of different ways. It means a single WCF service can be exposed with different wire formats and message protocols. Bindings in WCF actually defines that how to communicate with the service. So, binding specifies that what communicate protocol as well as encoding method will be used. Optionally, it can specify other important factors like transactions, reliable sessions and security.

WCF comes with a number of built-in bindings that we can use to expose our service, but WCF is extensible so we can define our own custom bindings to fulfill specific needs.

In this article, we will keep our focus on learning about existing bindings available in WCF.

Types of Binding

Let us see more detailed on predefined binding

BasicHttpBinding

  • It is suitable for communicating with ASP.NET Web services (ASMX)-based services that comfort with WS-Basic Profile conformant Web services.
  • This binding uses HTTP as the transport and text/XML as the default message encoding.
  • Security is disabled by default
  • This binding does not support WS-* functionalities like WS- Addressing, WS-Security, WS-ReliableMessaging
  • It is fairly weak on interoperability.


 WSHttpBinding

  • Defines a secure, reliable, interoperable binding suitable for non-duplex service contracts.
  • It offers lot more functionality in the area of interoperability.
  • It supports WS-* functionality and distributed transactions with reliable and secure sessions using SOAP security.
  • It uses HTTP and HTTPS transport for communication.
  • Reliable sessions are disabled by default.


 WSDualHttpBinding

This binding is same as that of WSHttpBinding, except it supports duplex service. Duplex service is a service which uses duplex message pattern, which allows service to communicate with client via callback.
In WSDualHttpBinding reliable sessions are enabled by default. It also supports communication via SOAP intermediaries.


 WSFederationHttpBinding

This binding support federated security. It helps implementing federation which is the ability to flow and share identities across multiple enterprises or trust domains for authentication and authorization. It supports WS-Federation protocol.


NetTcpBinding
This binding provides secure and reliable binding environment for .Net to .Net cross machine communication. By default it creates communication stack using WS-ReliableMessaging protocol for reliability, TCP for message delivery and windows security for message and authentication at run time. It uses TCP protocol and provides support for security, transaction and reliability.


NetNamedPipeBinding
This binding provides secure and reliable binding environment for on-machine cross process communication. It uses NamedPipe protocol and provides full support for SOAP security, transaction and reliability. By default it creates communication stack with WS-ReliableMessaging for reliability, transport security for transfer security, named pipes for message delivery and binary encoding.


 NetMsmqBinding

  • This binding provides secure and reliable queued communication for cross-machine environment.
  • Queuing is provided by using MSMQ as transport.
  • It enables for disconnected operations, failure isolation and load leveling


 NetPeerTcpBinding

  • This binding provides secure binding for peer-to-peer environment and network applications.
  • It uses TCP protocol for communication
  • It provides full support for SOAP security, transaction and reliability.
Continue Reading →

ViewData VS ViewBag Vs TempData in MVC

Introduction
In Asp.Net MVC there are three ways to pass/store data between the controllers and views.

ViewData
  1. ViewData is used to pass data from controller to view
  2. It is derived from ViewDataDictionary class
  3. It is available for the current request only
  4. Requires typecasting for complex data type and checks for null values to avoid error
  5. If redirection occurs, then its value becomes null
ViewBag
  1. ViewBag is also used to pass data from the controller to the respective view
  2. ViewBag is a dynamic property that takes advantage of the new dynamic features in C# 4.0
  3. It is also available for the current request only
  4. If redirection occurs, then its value becomes null
  5. Doesn’t require typecasting for complex data type
TempData
  1. TempData is derived from TempDataDictionary class
  2. TempData is used to pass data from the current request to the next request
  3. It keeps the information for the time of an HTTP Request. This means only from one page to another. It helps to maintain the data when we move from one controller to another controller or from one action to another action
  4. It requires typecasting for complex data type and checks for null values to avoid error. Generally, it is used to store only one time messages like the error messages and validation messages

Example :   
 
Controller Action: 
public ActionResult Index()
    {
      var model = new LoginModel()
      {
          UserName = "hello",
          Password="1",
          RememberMe =true
      };
      List<LoginModel> log = new List<Models.LoginModel>();
      log.Add(model);
      TempData["ModelName"] = log;
      ViewBag.Name = log;
      ViewData["Name"] = log;
      return View();
    }

View : 
<ul>
    @foreach (var item in TempData["ModelName"] as List<mvc1.Models.LoginModel>)
    {
        <li>
            @item.UserName
        </li>
    }

</ul>
<br />
<ul>
    @foreach (dynamic item in ViewBag.Name)  @*No Typecast*@
    {
        <li>
            @item.UserName
        </li>
    }

</ul>
<br />
<ul>
    @foreach (var item in ViewData["Name"] as List<mvc1.Models.LoginModel>) @*Typecast*@
    {
        <li>
            @item.UserName
        </li>
    }
</ul>


Continue Reading →

Topics

ADO .Net (2) Ajax (1) Angular Js (17) Angular2 (24) ASP .Net (14) Azure (1) Breeze.js (1) C# (49) CloudComputing (1) CMS (1) CSS (2) Design_Pattern (3) DI (3) Dotnet (21) Entity Framework (3) ExpressJS (4) Html (3) IIS (1) Javascript (6) Jquery (9) Lamda (3) Linq (11) Mongodb (1) MVC (48) NodeJS (7) RDLC (1) Report (1) Sql Server (29) SSIS (3) SSRS (2) UI (1) WCF (12) Web Api (10) Web Service (1) XMl (1)