ashish

ASP.NET Core dependency injection

August 26, 2019 by ashish Leave a Comment

What is Dependency Injection in ASP.NET Core

ASP.NET Core provides a simple prebuilt DI container.We need to register the dependencies in this container.Dependencies could be the custom classes or the framework classes

Once you have registered the dependency in the container you can inject it anywhere you need.The DI container will automatically inject the dependencies where you have injected the dependencies For example if you registered the dependency as below,then the DI container will automatically create the object corresponding to the IEmployee and inject it into the constructor

void SimpleMethod(IEmployee employee)
{
}

How do you register dependencies

You add the dependency using the ConfigureServices method of the Startup class

public void ConfigureServices(IServiceCollection services)
{
//Add dependency to the services collection
}

One common extension method that you use for working with MVC application is services.AddMvc() ,this method adds the required dependencies for working with MVC.
You can either write the extension method of a library,if it provides one or you can register the dependency in the container as:

services.AddScoped<IEmailSender, EmailSender>();

When a dependency is injected in a component ,either a new instance of the dependent object is created or an existing object is reused.This depends upon the service lifetime we define for the dependency.We can define the following lifetimes of a dependency:

You can add services as:

Scoped new object will be created for every client request
Singleton same object will be used every time
Transient dependent objects are created every time they are requested and are never shared.

How do you use it

You just need to specify the dependency as a constructor parameter,and the required dependency will be created and injected by the .net core framework:

public class TestController : Controller
{
IEmailSender _emailSender;
public HomeController(IEmailSender emailSender)
{
_emailSender= emailSender;
}
}

ashish

Follow on:

Creating WebAPI in ASP.NET Core

August 26, 2019 by ashish Leave a Comment

What is WebAPI

WebAPI in .NET Core is used for creating RESTful services.WebAPI in .NET Core is a class which derives from the ControllerBase class.This is unlike MVC controller which derives from Controller class.Controller class adds support for working with views.

Different return types

we can return the following from the controller action method:

Specific type primitive or complex data type
IActionResult interface
ActionResult<T> for returning a type deriving from ActionResult or specific type

We can return either IActionResult or ActionResult<T>,either synchronously or asynchronously.To call these methods asynchronously follow the below steps:

Add the async modifier in the method definition
Return Task<IActionResult> or Task<ActionResult<T>>
Call the asynchronous method using the await keyword

If the requests are processed asynchronously then the server resources are not blocked and can be used to serve other request.Threads can be used serve other requests.
To create an async action method:

public async Task<IActionResult> SimeMethodAsync()
{
await asyncOperation.method1();
return OK();
}

Controller class provides additional functionality for working with MVC applicaitons.Some of the properties and methods provided by ControllerBase are:

BadRequest Returns 400 status code.
NotFound Returns 404 status code.
PhysicalFile for returning a file.
TryUpdateModelAsync for invoking model binding.

For example to return a response when a value is not found:

[HttpGet]
public IActionResult FindValue(int id)
{
...
return NotFound();
}

How to create WebAPI in ASP.NET Core

To create a WebAPI controller class create a normal class and add the [ApiController] attribute to the class.This attributes enables API specific behaviours.
Add a method to the Contoller class deriving from ControllerBase
Add the HttpPost or HttpGet attribute to the method
Call the CreatedAtAction prebuilt method The CreatedAtAction method created ActionResult object that returns 201 response.The 201 response type denotes that the resource is created

[HttpPost]
public IActionResult Create(Employee employee)
{
...
return Ok();
}

or if you want to create a resource and provide access to it you use CreatedAtAction method.This method adds location header in the response which can be used to access the newly created resource:

[HttpPost] 
public IActionResult ActionResult<Employee> Create(Employee employee) { 
return CreatedAtAction("createEmployee", new { id = 1 });
 }

Some of the useful attributes while developing APIs are:

[Produces] specifies the expected return Types from action method
[Consumes] specifies the expected input Types by action method
[Route] for defining routes.
[HttpGet] for defining get verb routes
[HttpPost] for defining post verb routes

To return an employee using Get:

[HttpGet("{id}")]
public async Task<ActionResult<Employee>> GetEmployee(int id)
{
//fetch employee

return employee;
}

We are calling this method asynchronously and returning task.

ashish

Follow on:

Overview of Entity Framework Core

August 22, 2019 by ashish Leave a Comment

When working in any application a common requirement is accessing the database.Writing the database access code could be tedious,as you need to take care of multiple things such as:

Implementing logic for connecting to database
Writing SQL queries for working with tables and columns
Mapping the values in database to the classes in our application.

EF Core is an ORM library and so it provides the benefits when retrieving and storing data in the database.Some of the benefits of using EF Core are:

Abstracting the underlying data access logic You don’t have to write low level SQL statements to work with the databases.
Allows working with database columns and tables as objects in our application.This allows to work with the database using the same code which you use to write your application.
Change Tracking

EF Core is cross platform and supports different databases such as

SQL Server
MySQL
Postgre
SQLite
In-memory

Like .NET Core,EF Core is cross platform.You can work with any database for which there is a provider.It’s also faster than previous versions.

For using Entity Framework Core in your application,you define the Entity classes which are normal classes which represents the Entities and class deriving from the DbContext class.The class deriving from the DbContext class defines the DbSet<T> properties.

Following are some of the main steps for using Entity Framework in your application:

1.Install the EF Core NuGet packages.For example to install nuget for SQL Server:

Install-Package Microsoft.EntityFrameworkCore.SqlServer

2.Decide development approach , Code-First or Database-First.Implement model classes,if you are using code first approach the you define your classes for which you want to generate the database.

Code first approach EF Core creates the database and tables from the model classes.You use migration to achieve this.
Database first approach EF Core creates the model classes from the database

3.Define Model classes,for example we are declaring a model class Employee:-

public class Employee
{
public int EmployeeId { get; set; }
}

In the above example we have implemented property named EmployeeId,this is how EF Core uniquely identifies an object,this is the primary key.Any property having name ClassName+Id is the primary key.

3.Implement DbContext for the entities .For example you implement Employee DbContext as:

public partial class EmployeeDBContext : DbContext
{
public virtual DbSet<Employee> Employees{ get; set; }
}

Once you define the DbContext you can add and save records using the context as:

context.Employees.Add(employee);
context.SaveChanges();

EF Core supports various commands for creating or updating the database ,based on the model you can add migration as:

add-migration name

then you need to execute the appropriate database commands

update-database

ashish

Follow on:

Pseudo classes in CSS

August 22, 2019 by ashish Leave a Comment

CSS rules defines the properties and values of the attributes of html elements.You can apply the css rules to different html elements.You specify different html elements to which you want to apply the css rules using selectors.For example to apply the background color to table you define the following selector:

table {
background-color: pink;
}

Similarly to define the rule for anchor element you use

a {
color: blue;
}

Now if you want to specify the style of the link when user hover over it you use:

a:hover {
color: red;
}

The hover class we are using here is called the pseudo class.Pseudo classes are applied when the state of the element matches the state specified in the pseudo class.

Pseudo class has the following syntax:

selector:pseudo-class {
property: value;
}

some of the common pseudo-class are:

:active when the user activates the element such as by pressing the mouse button
:hover when the mouse hovers over the element
:link when element such as anchor(‘a’) has not been visited
:focus element which has the focus
:enabled enabled element
:disabled disabled element

ashish

Follow on:

HTML5 doctype declaration

August 21, 2019 by ashish Leave a Comment

The <!DOCTYPE> is a declaration which must appear before any other html markup.This is an instruction to the browser about interpreting the html markup by specifying the version of the markup.The doctype declaration specifies the DTD to be used for HTML document.

In the case of previous versions of html the dtd to use needs to be specified in the doctype declaration.In the case of html 5 only following should be specified:

<!DOCTYPE html>

Contrast this with previous versions of html in which you need to specify dtd along in the doctype declaration:

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

DTD is Document Type Definition.It specifies the elements and attributes of a document.It is often used in different documents based on SGML such as xml.SGL is meta language on which other languages such as XML and HTML are based.For example you can specify valid elements in xml as:

<!DOCTYPE valid elements>

This was the case in earlier versions of html but in html5 there is no dtd.This is becasue html 5 is not based on SGML.Since browsers have rendering engine for correctly displaying html the support for dtd has been dropped in html5.

ashish

Follow on: