Introduction
In this article, we'll show you how to use Entity Framework to construct a WEB API in ASP.Net core 6. ASP.NET Web API makes it easier to create HTTP(s) services that connect to various clients such as browsers and mobile devices. Building RESTful apps is best accomplished on the ASP.NET Web API platform. Use the HTTP verbs GET, POST, PUT, and DELETE and test it using Swagger.
What is WebAPI and Why do we need it
API stands for Application Programming Interface. The HTTP Protocol is utilized by Web API, a concept that is used to increase an application's capabilities. A web-based application alone is no longer sufficient to reach all of its users or clients. People today are incredibly intelligent, which means they use technology like the iPhone, mobile phones, tablets, etc. in their daily life. Various useful apps are available for these devices that can simplify users' life. Actually, we can state that we are migrating from the web to the world of apps. Therefore, if we want to quickly, securely, and simply expose our service data to browsers and all of these current device apps, we need to use an API that works with both.
On the left, as you can see in the picture below, are the three applications, and on the right, as you can see in the picture below, is the database.
Our objective is to develop communication between the database and all three of these applications. A new Web API project will be added. The database will be used in this Web API Project's interactions. Also, as can be seen in the picture below, all three applications will only communicate with the database via the Web API Project.
As a result, the database is not directly accessible through these websites, Android, or iOS applications. They just need to communicate with the Web API project; the Web API project is in charge of dealing with database interactions. We require a Web API for our project because all of the business logic will be written in the Web API project alone. Web API serves as a bridge between the front-end and back-end results.
Describe HTTP Methods
Every time a client sends a request to a server, it includes an HTTP method that specifies what the client wants the server to do with the requested resource. These requested actions are represented by HTTP methods. Typical HTTP methods, for instance, can fetch data from a server, submit data to a server for processing, delete something from the server's database server, etc. The term CRUD, which stands for Create, Read, Update, and Delete, can be used to summarise a large portion of application functionality. Each of these actions has a corresponding four HTTP method which is given below
POST-Create
GET-Read
PUT-Update
DELETE-Delete
How to create Web API
Step 1
Create a new project in visual studio and firstly we will install some packages from the manage Nuget package.
MicroMicrosoft.Entity Frameworkcore.InMemory
MicroMicrosoft.Entity Frameworkcore.sql server
MicroMicrosoft.Entity Frameworkcore.Tools
Step 2
In the solution create a new folder and name its model inside a model to create a class and name as Contacts inside the Contacts we have a few properties the first property is a Guit id and after that, we have a string of name which will have the contacts name after that we have an email address for the contact and that to be of type string as well and then we have a phone number which is for the contact will be of type long and lastly we have a property of address which will store the physical address of the contact and that will be of type string
public class Contact {
public Guid id {
get;
set;
}
public string name {
get;
set;
}
public string email {
get;
set;
}
public long phone {
get;
set;
}
public string address {
get;
set;
}
}
C#
Copy
Step 3
it's now time to create a class file that will connect to our database and will act like a domain access layer because we are using an entity framework for we use the concept of the context which acts as a class that talks to the database no matter what type it is and it also features and retrieves data for us so.
Let's create a DB contact click on a solution in a new folder call its data and insert data create a new class file name this is the contacts API which is the API name followed by the word DB contact so ContactsAPIDbContext inside the class this class will actually inherit from the class Db context.
Click the control that imports the dependencies using microsoft.net Framework installed when we install the in-memory database package after that generate a constructor with which we are passing the options and the options are being passed to the base class after that in any context
We have to create properties which will act as tables for entity framework core so create a property only need one property which is our contacts model. We only want to retrieve update delete and add contacts so we have a Dbset property of type contact.
public class ContactsAPIDbContext: DbContext {
public ContactsAPIDbContext(DbContextOptions options): base(options) {}
public DbSet < Contact > Contacts {
get;
set;
}
}
C#
Copy
Step 4
The program. cs file and inject this contacts API Db context into the services of the solution on to that injected service into a controller that we can connect to a database file and write below this line were injecting the service for swagger use the Builder.services and write at Db context because we want to add the Db context gives the type which is the contactsAPIDBcontext click control and import from contacts API data the one we created and after that, give some options to it which shows it to UseInMemoryDatabase so use InMemory database after that we have to give the database name ContactsDb
builder.Services.AddDbContext<ContactsAPIDbContext>(option =>
option.options.UseInMemoryDatabase("ContactsDb"));
C#
Copy
Step 5
We add a new controller in the Controller folder and select MVC Controller_empty name as Contacts now we annotate our controller with the key Api controller telling this is an API controller which shows this is not an MVC controller after that we Route our controller
[ApiController]
[Route("api/[Controller]")]
C#
Copy
Step 6
We use this private readonly field DbContext to connect to my in-memory database and will use this dot DbContext field to connect the contacts table
private ContactsAPIDbContext dbContext;
public ContactsController(ContactsAPIDbContext dbContext) {
this.dbContext = dbContext;
}
C#
Copy
Step 7
Because we've given the Db set property inside the contact, it understands that contacts are a table in a database, so connect to the contact table and return a list. Use this Db context to put a dot to connect to the contacts table. If it states that we are unable to convert type generic lists to IActionResults automatically, so we put in ok inside an ok response and its shows all the data stored in the contact table
[HttpGet]
public async Task < IActionResult > GetContacts() {
return Ok(await dbContext.Contacts.ToListAsync());
}
C#
Copy
Output
Step 8
In this step, we will add a contact using the AddContact method using the below C# code for HttpPost.
[HttpPost]
public async Task < IActionResult > AddContact(AddContactRequest addContactRequest) {
var contact = new Contact() {
id = Guid.NewGuid(),
name = addContactRequest.Name,
address = addContactRequest.Address,
email = addContactRequest.Email,
phone = addContactRequest.Phone,
};
await dbContext.Contacts.AddAsync(contact);
await dbContext.SaveChangesAsync();
return Ok(contact);
}
C#
Copy
Output
Step 9
In the GetContact method, we only retrieve single data with the key parameter Guid id.
[HttpGet]
[Route("{id:guid}")]
public async Task < IActionResult > GetContact([FromRoute] Guid id) {
var contact = await dbContext.Contacts.FindAsync(id);
if (contact == null) {
return NotFound();
}
return Ok(contact);
}
C#
Copy
Output
Step 10
Now we will update the contact table with key parameter guide id and UpdateContactRequest model class firstly we store the value of Guid id in the contact variable check if it is null then shows not found result if the contact is not null then update the data of the contact and show 200 response.
[HttpPut]
[Route("{id:guid}")]
public async Task < IActionResult > UpdateContact([FromRoute] Guid id, UpdateContactRequest updateContactRequest) {
var contact = await dbContext.Contacts.FindAsync(id);
if (contact != null) {
contact.name = updateContactRequest.name;
contact.phone = updateContactRequest.phone;
contact.address = updateContactRequest.address;
contact.email = updateContactRequest.email;
await dbContext.SaveChangesAsync();
return Ok(contact);
}
return NotFound();
}
C#
Copy
Output
Step 11
In this step, we will delete a contact with key parameter Guid id. Define a var type variable contact and store the parameter value check conditions if contact is null then shows not found, if contact is not null then remove a contact from the contact table and save the changes then return 200 response
[HttpDelete]
[Route("{id:guid}")]
public async Task < IActionResult > DeleteContact(Guid id) {
var contact = await dbContext.Contacts.FindAsync(id);
if (contact != null) {
dbContext.Remove(contact);
dbContext.SaveChanges();
return Ok(contact);
}
return NotFound();
}
C#
Copy
output
Step 12
Now implementing connection with SQL server, by adding connection string in appsettings.json
, "ConnectionStrings": {
"ContactAPIConnectionString": "Server=LAPTOP-L9APCEGG\\MSSSQLSERVER; Database=ContactAPIDb; User id=sa; password=Password$2; Trusted_Connection=True; MultipleActiveResultSets=true"
}
C#
Copy
Conclusion
In this article, we covered the topic of how we can create ASP.NET Core 6 Web API CRUD using Entity Framework.
If you have any queries/suggestions on the article, please leave your questions and thoughts in the comment section below. Follow C# Corner to learn more new and amazing things about ASP.NET Core or to explore more technologies.
Thanks for reading and I hope you like it.