Tag Archives: Microsoft

Getting Started with ASP.NET vNext

Article posted on Asp.Net vNext Overview

Getting Started with ASP.NET vNext
By
Mike Wasson |

The next version of ASP.NET (“ASP.NET vNext”) has been re-designed from the ground up. The goal is to create a lean and composable .NET stack for building modern cloud-based apps.

Here are some of the features of ASP.NET vNext:

  • vNext includes new cloud-optimized versions of MVC, Web API, Web Pages, SignalR, and Entity Framework.
  • MVC, Web API, and Web Pages will be merged into one framework, called MVC 6. The new framework removes a lot of overlap between the existing MVC and Web API frameworks. It uses a common set of abstractions for routing, action selection, filters, model binding, and so on. You can use the framework to create both UI (HTML) and web APIs.
  • ASP.NET vNext apps can use a cloud-optimized subset of .NET vNext. This subset is factored for server and web workloads, has a smaller footprint than the full .NET vNext, and supports side-by-side deployment.
  • MVC 6 has no dependency on System.Web. The result is a leaner framework, with faster startup time and lower memory consumption.
  • vNext will support true side-by-side deployment. If your app uses the cloud-optimized subset of .NET vNext, you can bin deploy all of your dependencies, including the .NET vNext (cloud optimized) packages. That means you can update your app without affecting other applications on the same server.
  • vNext is host agnostic. You can host your app in IIS, or self-host in a custom process. (Web API 2 and SignalR 2 already support self-hosting; ASP.NET vNext brings this same capability to MVC.)
  • Dependency injection is built into the framework. Use your preferred IoC container to register dependencies.
  • vNext uses the Rosyln compiler to compile code dynamically. You will be able to edit a code file, refresh the browser, and see the changes without rebuilding the project.
  • vNext is open source and cross platform.

In order to accomplish these goals, ASP.NET vNext contains breaking changes. The current frameworks (Web Forms 5, MVC 5, Web API 2, Web Pages 3, SignalR 2, and Entity Framework 6) will continue to ship in Visual Studio, and will be fully supported in .NET vNext.

This overview is designed to get you started with ASP.NET vNext. Because vNext is still an early preview, I won’t walk through creating an entire real-world application. Instead, I want to highlight some of the features and show enough code to get you started.

The overview assumes you are familiar with either MVC 5 or Web API 2. If not, here is some terminology that is used in ASP.NET MVC.

  • A controller handles HTTP requests and executes application logic.
  • Actions are methods on a controller that get invoked to handle HTTP requests. The return value from an action is used to construct the HTTP response.
  • Routing is the mechanism that selects which action to invoke for a particular HTTP request, usually based on the URL path and the HTTP verb.
  • A view is a component that renders HTML. Controllers can use views when the HTTP response contains HTML.
  • A model is an object that represents the domain data in your application. Typically an app either renders the model as HTML, or serializes the model into a data format such as JSON.
  • Razor syntax is a simple programming syntax for embedding server-based code in a web page.

I’ve defined some of these terms in a way that is specific to ASP.NET. For example, controllers have a particular purpose in ASP.NET MVC, but “model-view-controller” is a more general pattern, used by many frameworks.

Getting Started with ASP.NET vNext

Currently, there is no Visual Studio integration for ASP.NET vNext, so you will build and run applications from the command line.

Use kvm (the version manager) to get the latest version of the runtime. Follow the instructions on the project wiki.

A minimal vNext project contains two files:

  • project.json. This file lists the dependencies for the application.
  • A startup class.

For now, the best way to create a project.json file is to copy the example from HelloMvc sample.

The startup class is where you configure the HTTP request pipeline for your application. Here is a simple example.

using Microsoft.AspNet.Builder;

public class Startup
{
    public void Configure(IBuilder app)
    {
        app.UseWelcomePage();
    }
}

By default , the hosting environment expects the startup class to be named Startup. The startup class must contain a method named Configure with the signature shown here. Inside this method, use the IBuilder interface to configure the application.

The UseWelcomePage methods adds a middleware component that just displays a welcome page. The welcome page is useful for diagnostic purposes, to make sure your project is configured and running correctly.

To start the application, open a command prompt and type the following commands:

kpm restore
k web

The kpm restore command resolves the dependencies listed in the project.json file, and downloads the necessary NuGet packages. The k web command starts the HTTP listener.
Notice there is no explicit build step. The k web command compiles the code on the fly. After you install the NuGet packages, you can make changes to the code and run k web again, without running kpm restore.

Next, launch a browser and navigate to http://localhost:5001. You should see the welcome page.

The web command is defined in the project.json file:

  "commands": {
    "web": "Microsoft.AspNet.Hosting server=Microsoft.AspNet.Server.WebListener server.urls=http://localhost:5001"
  },

This command starts the hosting environment and listens on the specified localhost address. You can edit the project.json file to use a different port number.

Serving Static Files

The welcome page is not too interesting, so lets’s enable the app to serve static files. Add the following entry to the “dependencies” section of the project.json file:

"Microsoft.AspNet.StaticFiles": "0.1-alpha-build-0402"

Modify the Startup class as follows.

using Microsoft.AspNet.Builder;
using Microsoft.AspNet.StaticFiles;

public class Startup
{
    public void Configure(IBuilder app)
    {
        app.UseStaticFiles();
    }
}

Getting Started with MVC 6

In the rest of this overview, we’ll explore some of the features of MVC 6. To enable MVC, modify the Startup class as follows.

using Microsoft.AspNet.Routing;
using Microsoft.AspNet.Builder;
using Microsoft.Framework.DependencyInjection;

public class Startup
{
    public void Configure(IBuilder app)
    {
        app.UseServices(services =>
        {
            services.AddMvc();
        });

        app.UseMvc(routes =>
        {
            routes.MapRoute(
                name: "Default",
                template: "{controller}/{action}/{id?}",
                defaults: new { controller = "Home", action = "Index" });
        });

    }
}

This code enables MVC and defines a route. If you’ve used earlier versions of MVC, the MapRoute method should look familiar. For comparison, here are the same routes defined in MVC 5 and MVC 6:

// MVC 5 route
routes.MapRoute(
    name: "Default",
    url: "{controller}/{action}/{id}",
    defaults: new { controller = "Home", action = "Index",
        id = UrlParameter.Optional }
);

// MVC 6 route
routes.MapRoute(
    name: "Default",
    template: "{controller}/{action}/{id?}",
    defaults: new { controller = "Home", action = "Index" }
);

The ‘?’ character in the template means the {id} segment is optional.

Next, add a controller class. The following controller defines a single action named Index that returns a view.

using Microsoft.AspNet.Mvc;

public class HomeController : Controller
{
    public ActionResult Index()
    {
        return View();
    }
}

Except for the namespace, this code would compile in MVC 5.

Now add a view. Create a file named ./Views/Home/index.cshtml and paste in the following code.

@{
  var message = "Hello World";
}

<!DOCTYPE html>

<html lang="en">
<head>
  <meta charset="utf-8" />
  <title>Index Page</title>
</head>
<body>
  <h1>@message</h1>
  <p>Index page</p>
</body>
</html>

I included a @message variable just to show that this is a Razor file and not just static HTML.

Here is the file structure for the project:

.\HomeController.cs
.\project.json
.\Startup.cs
.\Views\Home\Index.cshtml

Run the app by using the k web command, and then navigate to http://localhost:5001. You should see the HTML that is rendered by the Index view.

View Models

You can pass a model to the view. Let’s add a model class:

public class MessageModel
{
    public string Message { get; set; }
}

Modify the action by passing an instance of MessageModel to the View method:

public class HomeController : Controller
{
    public ActionResult Index()
    {
        var model = new MessageModel { Message = "Hello ASP.NET" };
        return View(model);
    }
}

Update index.cshtml to refer to the model.

<!DOCTYPE html>

<html lang="en">
<head>
  <meta charset="utf-8" />
  <title>Hello World Page</title>
</head>
<body>
  <h1>@Model.Message</h1>
</body>
</html>

Now when you run the app, “Hello ASP.NET” is rendered inside the H1 tag.

Creating Web APIs and REST-Style Actions

If the route template does not include {action}, the framework uses the HTTP verb to select the action name. This style of routing is similar to convention-based routing in the current version of ASP.NET Web API, and is useful for REST-style APIs.

Here is an example of a route template without an {action} variable.

app.UseMvc(routes =&gt;
{
    routes.MapRoute("ApiRoute", "{controller}/{id?}");
});

Using this route template, the action name maps to the HTTP verb in the request. For example, a GET request will invoke a method named Get, a PUT request will invoke a method named Put, and so forth. The {controller} variable still maps to the controller name.

The following controller uses this style of routing.

using Microsoft.AspNet.Mvc;

public class ValuesController : Controller
{
    // GET /values
    public string Get()
    {
        return "Values";
    }

    // GET /values/1
    public string Get(int id)
    {
        return "Value " + id.ToString();
    }

    // POST /values
    public ActionResult Post()
    {
        return new HttpStatusCodeResult(201);
    }
}

The following table shows the web API that is defined by ValuesController.

Request Method URI Path Controller Action
GET /values Get
GET /values/1 Get(id)
POST /values Post

The two Get actions both return strings. In that case, the framework writes the string into the body of the HTTP response, and sets the Content-Type header to “text/plain”. For example, if you send a GET request to /values/1, the response will look similar to the following.

HTTP/1.1 200 OK
Content-Type: text/plain
Server: Microsoft-HTTPAPI/2.0
Date: Wed, 30 Apr 2014 00:16:38 GMT
Content-Length: 7

Value 1

The Post action returns an HttpStatusCodeResult. The framework translates this into an HTTP status code.

HTTP/1.1 201 Created
Content-Length: 0
Server: Microsoft-HTTPAPI/2.0
Date: Wed, 30 Apr 2014 00:18:58 GMT

If you are familiar with ASP.NET Web API, you may have noticed that ValuesController derives from Controller, not ApiController. That’s because vNext does not have a separate controller class for web APIs.

In the current ASP.NET framework, MVC 5 and Web API 2 use completely different classes and namespaces. That means a controller is either an MVC controller or a Web API controller. Web API controllers use separate routes, and they can’t use MVC filters or MVC model binders.

One goal of ASP.NET vNext is to merge MVC and Web API into a single framework, which shares a single pipeline and uses the same routing, action selection, filters, model binding, and so forth. The result will be a more consistent programming model, and code that is more re-usable.

Returning JSON

To serialize an object into JSON format, call Controller.Json. This method returns a JsonResult, which is an action result that serializes an object to JSON format. For example, let’s add a model class named Movie.

public class Movie
{
    public string Title { get; set; }
    public int Year { get; set; }
    public string Genre { get; set; }
}

Here is a controller that returns a list of movies in JSON format.

using Microsoft.AspNet.Mvc;

public class MoviesController : Controller
{
    public ActionResult Get()
    {
        var movie = new Movie
        {
            Title = "Maximum Payback", Year = 1990, Genre = "Action"
        };
        return Json(movie);
    }
}

The response from the Get action will look similar to the following.

HTTP/1.1 200 OK
Content-Type: application/json
Server: Microsoft-HTTPAPI/2.0
Date: Fri, 02 May 2014 20:39:25 GMT
Content-Length: 120

[{"Title":"Maximum Payback","Year":1990,"Genre":"Action"},{"Title":"Fatal Vengeance 2","Year":2012,"Genre":"Action"}]

Note: The preview release does not support content negotiation yet.

Areas

Areas are a way to group controllers, models, and views. In previous versions of MVC, you register areas by calling AreaRegistration.RegisterAllAreas. Area controllers are placed in a special Areas folder.

In MVC 6, you create a route template with an {area} parameter, and then decorate area controllers with the [Area] attribute. The following code defines an area route.

app.UseMvc(routes =&gt;
{
    routes.MapRoute(
        name: "AreasRoute",
        template: "{area}/{controller}/{action}");

    routes.MapRoute(
        name: "Default",
        template: "{controller}/{action}/{id?}",
        defaults: new { controller = "Home", action = "Index" });
});

Given these routes, you could define two Home controllers, as follows:

namespace MyApp.Controllers
{
    public class HomeController : Controller
    {
        // Home/Index
        public ActionResult Index()
        {
            return View();
        }
    }
}
namespace MyApp.Areas.Controllers
{
    [Area("Books")]
    public class HomeController : Controller
    {
        // Books/Home/Index
        public ActionResult Index()
        {
            return View();
        }
    }
}

The second controller is assigned to the Books area.

URI Controller
/Home/Index MyApp.Controllers.HomeController
/Books/Home/Index MyApp.Areas.Controllers.HomeController

Views for an area go into a folder named “Areas/{area name}/Views/{controller}”. So in this example, the view for the Books/Home/Index action would go in a file named “Areas\Books\Views\Home\index.cshtml”.

Previously, the Web API framework did not support areas. Because MVC 6 merges the two frameworks, you can now organize web API-style controllers into areas.

View Components and Child Views

View components are similar to child actions in previous versions of MVC. They allow a view to invoke an action and render the result within the view. The following code shows a simple view component that writes a text string.

[ViewComponent(Name = "MyViewComponent")]
public class SimpleViewComponent : ViewComponent
{
    public IViewComponentResult Invoke(int num)
    {
        var message = String.Format("The secret code is: {0}", num);
        return Result.Content(message);
    }
}

To include this view component in a view, call Html.Component.

<html lang="en">
<head>
  <meta charset="utf-8" />
  <title>Index Page</title>
</head>
<body>
  <p>@Component.Invoke("MyViewComponent", 42)</p>
</body>
</html>

When the view is rendered, the p tag will contain the string “The secret code is 42”. Notice that you can pass parameters to the view component’s Invoke method.

POCO Controllers

In MVC 6, controllers do not need to derive from Microsoft.AspNet.Mvc.Controller. You can write a controller as a simple class or “POCO” (plain old CLR object).
Here is an example.

public class HomeController
{
    // Helpers can be dependency injected into the controller
    public HomeController(IActionResultHelper resultHelper)
    {
        Result = resultHelper;
    }

    private IActionResultHelper Result { get; set; }

    public ActionResult Index()
    {
        return Result.Json(new { message = "Poco controllers!" });
    }
}

IActionResultHelper is a helper for creating action results. Notice that the IActionResultHelper instance is injected into the controller via the constructor. The framework provides a default IActionResultHelper implementation, and automatically injects it. You could also provide your own implementation of IActionResultHelper.

Previously, I showed a controller calls Controller.Json to return JSON data. That method is really just syntactic sugar for calling IActionResultHelper.Json.

The Controller class also gives you convenient access to the HTTP request context, the current principal (IPrincipal), a view bag, and other useful properties. So the Controller class is certainly useful, but it’s not required. For a light-weight controller, you might prefer a POCO controller.

Service and Operation behaviors in WCF

Behaviors in WCF are used to say how it’s going to behave at the service level, endpoint level or operation level. ServiceBehaviorAttribute  is used to apply behaviors at the service level. To apply behaviors at operation level use OperationBehaviorAttribute.

ServiceBehaviorAttribute: This attribute can be applied only to service implementations. It has properties that are useful in enabling a specified feature for the service.

  •  AddressFilterMode: specifies the type of filter that the dispatcher system uses to locate the endpoint that handles requests.

  1. Any:  matches on any address of an incoming message
  2. Exact: exact match on the address of an incoming message
  3. Prefix: prefix match on the address of an incoming message
  • AutomaticSessionShutdown: allows to automatically close the session when the channel is closed and the service has finished processing any remaining messages.(true/false)
  • ConcurrencyMode: controls the internal threading model, enabling support for reentrant or multithreaded services.

  1. Single: Service instance is single-threaded and does not accept reentrant calls (other messages must wait)
  2. Reentrant:Service instance is single-threaded accepts reentrant calls. the reentrant service accepts calls when you call another service (make the object state consistent before callouts and make operation-local data is valid after callouts.)
  3. Multiple: service is a multi-threaded. (Synchronization need to be maintained).
  • ConfigurationName: used to declare a name for use in the name attribute of the <service> element in the config file.
  • IgnoreExtensionDataObject: enables the run time to ignore extra serialization informatin that is not required to process the message.(true/false).
  • IncludeExceptionDetailInFaults: enables the unhandled exceptions in a service to return in SOAP faults. Used for debugging purposes.(true/false)
  • InstanceContextMode: specifies whether and when services and their service objects are to be recycled during an exchange with a client.

  1. persession: new instance object is created for each session.
  2. percall: new instance object is created prior to and recycled subsequent to each call.(defaults for no session)
  3. Single: only one instance object is used for all incoming calls.
  • MaxItemsInObjectGraph: used to limit on the number of items in an object graph that are serialized.(number)
  • Name and Namespace: controls the name and namespace for WSDL.
  • ReleaseServiceInstanceOnTransactionComplete: specifies whether the service object is recycled when a transaction completes.(true/false)
  • TransactionAutoCompleteSessionClose: specifies whether outstanding transactions are completed when the session closes.(true/false)
  • TransactionIsolationLevel: specifies the transaction isolation level that the contract supports.(isolationlevel of)

  1. Serializable: volatile data can be read but not modified, and no new dat can be added during the transaction.
  2. RepeatableRead:volatile data can be read but not modified during the transaction. New data can be added during the transaction.
  3. ReadCommitted: volatile data cannot be read during the transaction, but can be modified.
  4. ReadUncommitted: volatile data can be read and modified during the transaction.
  5. snapshot:volatile data can be read. Before a transaction modified data, it verified if another transaction has changed the data after it was intitially read. If the data has been updated, an error is raised. This allows a transaction to get to the previously committed value of the data.
  6. chaos: pending changes from more highly isolated transactions cannot be overwritten.
  7. upspecified:a different isolation level than the one specified is being used, but the level cannot be determined. An exception is thrown if this value is set.
  • TransactionTimeout: specifies the time period within which a transaction must complete or it aborts.
  • UseSynchronizationContext: indicates whether to synchronize inbound method calls with the user interface thread automatically.
  • ValidateMustUnderstand: informs the system whether it should confirm that SOAP headers marked as MustUnderstand have, in fact, been understood.

 

Windows Communication Foundation

Since WCF has been introduced in .Net 3.0, it’s keep growing and the features available are also improving. Lets see how WCF works.

Actually there are many reasons to communicate one application to another or utilize resources available in the market. There are different connection scenarios for this. Webservices is one such where one application exposes a service which can consumed by clients which are able access that. There can be one-way, request-reply or duplex types of communications.
Earlier Microsoft shipped different tools for each type of communications. So it’s really a correct solution. So they introduced WCF which is able to perform all the major communication types available in the market.
The process of WCF is simple:
Typically, for any client to consume the service what it needs is
1. Where to find the service?
2. How to connect the service?
3. And What are the operations available from the service?
With the WCF, they have provided different bindings(System Provided) to define the connectivity part

BindingConfiguration ElementDescription
BasicHTTPBinding<basicHttpBinding>This binding is more suitable for communication with basic WS-Basic profile webservices. Similar to ASP.Net Webservices (ASMX). This uses HTTP as transport protocol and MTOM(xml) as default message encoding. Supports Transport, Message and Mixed security modes. Will not support Sessions and Transactions. Supports buffered streaming.
WSHTTPBinding<wsHttpBinding>Provides secure and interoperable communication (WS*), suitable for non duplex connections. Uses SOAP protocol, and text as default encoding. Supports security (Transport, Mixed, Message modes), by default at message mode. Supports Sessions (Reliable, Security) by default none.
WSDualHttpBinding<wsDualHttpBinding>Provides secure, interoperable, reliable and duplex communication contract with text encoding by default. Supports Security at message level by default and only security mode available. Supports sessions(Reliable, Security) with reliablesession as default.
WSFederationHttpBinding<wsFederationHttpBinding>This binding is basically used federation communication. supports security(Message, Mixed, none) at Message level by default. Supports sessions (Reliable, Security). Transactions are allowed.
NetHttpBinding<netHttpBinding>This binding is basically designed for consuming HTTP or websocket services and uses binary encoding by default. Websockets are only supported on Windows 8. NetHttpBinding will check for request-reply or duplex contract and change its behavior accordingly. It will use HTTP for request-reply and websockets for duplex.
NetHttpsBinding<netHttpsBinding>A secure netHttpBinding.
NetTcpBinding<netTcpBinding>This binding replaces the earlier .net remoting. This secure way of communicating between two WCF capable services.
NetNamedPipeBinding<netNamedPipeBinding>This binding generates a run-time communication stack by default, which uses transport security, named pipes for message delivery and a binary message encoding. This is appropriate for on machine WCF communications. It also supports transactions.
NetMsmqBinding<netMsmqBinding>This binding provides support for queuing by using Message Queuing (MSMQ) as a transport and enables support for loosely-coupled applications, failure isolation, load leveling and disconnected operations.
NetPeerTcpBinding<netPeerTcpBinding>This binding provides a secure connection for multiple machine communication. provides support for the creation of peer networking applications that use a TCP-level peer-to-peer mesh infrastructure. Each PeerNode instance can host multiple peer channels defined with this binding type.
MsmqIntegrationBinding<msmqIntegrationBinding>This binding is suitable for cross-machine communication between a WCF application and existing MSMQ applications.
WebHttpBinding<webHttpBinding>WCF allows to expose WCF web services through HTTP requests that use "plan old XML" (POX) style messaging instead of SOAP-based messaging. For clients to communicate with a service using HTTP requests, an endpoint of the service must be configured with the WebHttpBinding that has the WebHttpBehavior attached to it. The WCF also requires that the individual service operations are annotated with WebGet or WebInvoke attributes.

CLR Profiler – message “Waiting for application to start common languange runtime”

Sometimes you may get this message when you start CLR profiler, this means that you don’t have enough permissions to run clr profiler or wrong clr version selected

You can start the clr profiler as “Run as Administrator” if that could solve then fine else check the proper clr version mostly for silverlight applications use “Core CLR version”.

Most of the microsoft products run the 32-bit so try using 32 bit binaries.

IronScheme

Out of curiosity I installed IronScheme and started writing some code. Its fun. It is a scheme based language built on Microsoft Dynamic language. We can call microsoft.net libraries and use them, I liked it. At the moment it is based on R6RS.

I wrote some hello world, factorial and some basic mathematical functions using loops. Learning new language is fun. Need to see what else I can do with it, may be reading some assemblies….:-)

Connecting WebService from SQL stored procedure

When I wanted to connect a web service and perform some tasks in database at regular intervals of time, my first choice was going for windows service. That was easy and I was familiar with the process. Due to some constraints in my organization, I had to look for alternatives.I was able to access the webservice from sql clr.Steps:1. Create a wsdl class file of the webservice.using in command prompt

 wsdl http://www.test.com/WebService/Testsvc.asmx /language:vb /out:C:\TestSvc.vb 

 Include this class file in the application where you are creating a sql clr. Below is an example:
Imports Microsoft.VisualBasic
Imports System
Imports System.data
Imports System.Data.Sql
Imports System.Data.SqlClient
Imports Microsoft.SqlServer.Server
Imports System.Data.SqlTypes
Imports System.Runtime.InteropServices
Imports System.XmlPartial 

Public Class StoredProcedures_

  Public Shared Sub GetTest( ByRef value1 As SqlInt32, ByRef value2 As SqlString)
    Dim Connection As New SqlConnection("Context Connection = true")
    Dim iWeb As New com.WSMainTestDim result as Integer = iWeb.GetAdditionTest(value1, value2)Connection.Open()
    Dim insert As String = "Insert into tblResponse (Text) Values ('" + result + "')"
    Dim command1 As New SqlCommand(insert, Connection)
    command1.ExecuteNonQuery()
    Connection.Close()
    Connection.Dispose()
  End Sub
End Class3.

Once I created the clr built the application and turned this class into a dll and also web service is also created as dll. create sgen for webservice.4.Add all 3 dlls to the database on which you wanted to attach the sql and access the webservice. Get to the database, in the assembly folder add these 3 dlls. The main clr file which connects to dll need to have external access permission set.5.Once you add these 3 dlls to the assembly folder, create procedure for the stored procedure clr.

Create PROC [Stored Procedure definition]([Parameters])
   With EXECUTE AS CALLERASEXTERNAL NAME (dll name of the stored procedure).     (class name).(method name)

For my purpose I created a job to perform certain tasks at regular intervals of time.Hope this could help someone.Thanks,Kishore Patil

Windows Azure

Nowadays we are hearing a lot about cloud computing. Cloud computing is like providing softwares, infrastructure as a service. To manage data on the diversified datacenters, microsoft has introduced Windows Azure. It is an operating system to manage applications, data on the microsoft datacenters with no worry about infrastructure. One can create applications in their own language (.net, php or windows native code ) using visual studio or even eclipse.
It allows the developer to perform
Development. An environment for developers based on familiar concepts and frameworks. Computation. A virtualized service execution environment running on cloud-based hardware. Management. A policy-based infrastructure for controlling the way services operate. Storage. A scalable set of cloud storage services for data.
Its important to note that there is no big difference to a developer between the local environment and cloud based environment.
The user can manage web roles on Azure with IIS, and can manage load balancing on the web site. SQL Azure as a storage service, user can store data as Blobs for large items of data, tables and queues to manage data.
AppFabric allows the user to connect to loosely coupled applications securely.