ASP.NET

What is ASP.NET Core 1.0

ASP.NET Core 1.0 is a new version of ASP.NET.If you have not worked in previous versions of ASP.NET even then you can learn ASP.NET.Core.Until now we have seen many releases of the .NET framework such as .NET framework 1.0,.NET framework 2.0 and so on.But one thing has been consistent across all these releases.It is that there
always has been a single new release of .NET framework.This will change from now since beginning with .NET framework 4.6 there are two releases .NET framework 4.6 and ASP.NET Core 1.0.

Earlier names of ASP.NET Core were ASP.NET vNext, ASP.NET 5.0.

Which Web frameworks it includes

ASP.NET Core doesn’t include web forms and web pages.It just inlcudes just MVC and WebAPI.So we can use these two technologies in ASP.NET Core as of now.

It is important to understand that ASP.NET Core is an optimized version of ASP.NET Framework.This means that ASP.NET Core doesn’t inlcude all the features of ASP.NET.This makes it lightweight than the ASP.NET framework.

ASP.NET Core Runtime

ASP.NET Core runs on .NET Core runtime and also on .NET framework.So we can target the same code for both the frameworks when developing ASP.NET Core applications.ASP.NET Core applications can target modern applications for the cloud,mobile apps and Iot.

ASP.NET Core is Modular and lightweight

It has no dependency on System.Web.dll.System.Web.dll includes all the web functionality in one monolithic dll.Compared to it ASP.NET Core includes functionality in independent nuget packages.features or libraries are implemented in the form of nuget packages.This makes the applications lightweight.ASP.NET core applications have better performance ,better security because of this.Also developer can include just the required nuget packages instead of all the features as in the case of eaerlier versions of ASP.NET framework.

ASP.NET Core is open source

It is truly open source and has an active community.Unlike previous versions of ASP.NET ,ASP.NET Core is totally community driven.

When to select ASP.NET

Latest version of ASP.NET is ASP.NET 4.6 which can run on either .NET framework or .NET core.If we are targetting windows platform then we use ASP.NET 4.6 .For cross platform applications we can select .NET core.

Code changes are auto compiled

Thanks to dot net watch which runs commands when our source code changes.Because of this whenever we change our source code it is compiled on the fly and we can refresh browser to reflect the changes.

we can save our code and refresh the browser to see the changes

Visual Studio Code

We can develop .net core applications using visual studio code.Visual Studio Code runs ov Windows,Mac and Linux.One good thing is that it is open source and is free.

Follow on:

Action methods are selected in WebAPI based on the HTTP method used to make the request.This means that if HTTP GET method is used to make the request then action methods whose names are beginning with Get are selected.For example following action method will handle HTTP GET requests :

public Product GetStudentById(id) {
}

However sometimes we need to name our action methods differently.In such a scenario we can include specific attributes while declaring action methods.In this case action method will be selected based on the attribute used to declare the action method.Following are some of the useful attributes :

HttpGet	Maps the HTTP get requests to the action method
HttpPut	Maps the HTTP put requests to the action method
HttpPost	Maps the HTTP post requests to the action method
HttpDelete	Maps the HTTP delete requests to the action method
AcceptVerbs	Maps the specified HTTP methods to the action method

In the following example action method is called FindStudentById. Though the action method does not include get in its name it will still handle the HTTP GET requests because it is declared with the attribute [HttpGet]

[HttpGet]
public Product FindStudentById(id) {
}

Below action method will handle the POST requests :

[HttpPost]
public Product FindStudentById(id) {
}

Specifying multiple HTTP verbs

We can specify multiple HTTP verbs for a single action method using AcceptVerbs attribute.We pass the verbs to the attribute as a comma separated values.

Following action method will handle both the put and post requests.This is because the get and put values are specified while declaring the attribute

[AcceptVerbs("POST", "PUT")]
public Product UpdateStudent(StudentViewModel vm) {

}

 

Follow on:

Web applications are more vulnerable to security risks.Browsers impose some restrictions to make web applications secure.One such security measure is called same origin policy.Same origin policy prevents a web page to make AJAX requests to different domain.

This means the web page in the following website
http://www.SampleSite1.com/

can not make ajax requests to
http://www.SampleSite2.com/

Same origin policy is useful as it helps prevents security vulnerabilities such as cross site scripting attack.But in some scenarios we may want to allow our service or method to be called by method or web page in a different domain.In such cases we can allow cross domain requests by using CORS or Cross Origin Resource Sharing which allows server to receive requests from another origin

Origin for two urls is considered same if the two urls have the same:

• domain
• port
• protocol(http/https)

CORS can be enabled in WebAPI 2.

Enabling CORS in WebAPI

To enable CORS follow the below steps

1.Add the nuget package for CORS using the following command

Install-Package Microsoft.AspNet.WebApi.Cors

2.Enable CORS by calling the EnableCors() method of HttpConfiguration class in the WebApiConfig.Register() method as:

config.EnableCors();

3.Add the [EnableCors] attribute to the Controller class as:

[EnableCors(origins: "http://www.SampleSite2.com", headers: "*", methods: "*")]
public class SampleController : ApiController
{}

In the EnableCors attribute we specify the domain which we want to enable for CORS.In this example action methods in SampleController can be called through AJAX in www.SampleSite2.com.

Follow on:

IHttpActionResult  is an interface which was introduced in WebAPI 2.It is used to create HttpResponseMessage which is one of the return types in WebAPI.

Use of IHttpActionResult

Using IHttpActionResult  to return HttpResponseMessage object instead of directly returning the HttpResponseMessage object has the following advantages:

Since we return an interface from the action method ,it makes it easier to unit test our action methods.

It promotes separation of concerns since the logic to create the HttpResponseMessage object is moved to different class.This class implements the IHttpActionResult  interface.

public class HTMLResponse : IHttpActionResult
{
string _html;
HttpRequestMessage _requestMessage;

public HTMLResponse(string html, HttpRequestMessage requestMessage)
{
_html = value;
_requestMessage = requestMessage;
}
public Task<HttpResponseMessage> ExecuteAsync(CancellationToken cancellationToken)
{
var response = new HttpResponseMessage()
{
Content = new StringContent(_html),
RequestMessage = _requestMessage
};
return Task.FromResult(response);
}
}

We can use the above HTMLResponse  as:

public IHttpActionResult Get()
{
return new HTMLResponse ("HTML Response", Request);
}

So as you can see in the above Get method ,it just creates an instance of HTMLResponse  and returns it.This makes the Get method cleaner since the responsibility of creating HTMLResponse  object is moved to separate class.

System.Web.Http.Results namespace

System.Web.Http.Results namespace contains different implementations of the IHttpActionResult  interface.For example JsonResult<T> is a generic class which is used to return JSON data and status code of OK.

ApiController class defines several helper methods which can be used to create implementations of IHttpActionResult  interface.

For example the following will return the generic Json<T> object.

public IHttpActionResult Get()
{
obj=studentRespository.Get(id);
return Json<Student>(obj);
}

 

 

 

Follow on:

Media Type or MIME type specifies the data being transfered between the client and server in HTTP request or response.
The MIME type for image is image/png.So if the MIME type is specified as image/png for Content-Type of the response then the client will know that the response is an image and will render it appropriately.
There are many other MIME types such as:

• text/html
• image/png
• application/xml

Once the type of request or response is determined WebAPI needs to serialize or deserialize the data. WebAPI uses media formatter to serialize or deserialize the data.

For example if action method returns an object as:

public Students Get()
{
return studentRespository.Get();
}

As the students data needs to be send in response body so serialization of students data is required.This serialization is
performed by the MediaTypeFoarmatter.Two of the inbuilt MediaTypeFoarmatters are:

• JsonMediaTypeFormatter For performing JSON serialization
• XmlMediaTypeFormatter For performing XML serialization

The base class for all Formatters is MediaTypeFormatter.If we want to create a new media type formatter then we need to create a new class which derives from MediaTypeFormatter or BufferedMediaTypeFormatter.BufferedMediaTypeFormatter dervies from MediaTypeFormatter class.

These classes are defined in the System.Net.Http.Formatting namespace in System.Net.Http.Formatting.dll assembly.

So to create a new media type formatter we can declare a class as:

public class CustomFormatter : MediaTypeFormatter
{
}

then in the constructor we add the media type as:

public class CustomFormatter : MediaTypeFormatter
{

public CustomFormatter()
{
// Add the supported media type.
SupportedMediaTypes.Add(new MediaTypeHeaderValue("application/javascript"));
}
}

Override the CanWriteType and CanReadType methods

To specify that Formatter supports serialization

public override bool CanWriteType(System.Type type)
{
return true;
}

To specify that Formatter supports deserialization

public override bool CanReadType(Type type)
{
return true;
}

Override the WriteToStream and ReadFromStream methods.

public override void WriteToStream(Type type, object value, Stream writeStream, HttpContent content)
{
using (var writer = new StreamWriter(writeStream))
{
Serialize(value,writeStream);
}
}

Similarly to perform deserialization override ReadFromStream method.

Follow on: