entity framework api with database

Question

User-1933134441 posted
in mvc how to create web api and also with entity framework 4.7.1

Answer 1

User1120430333 posted

in mvc how to create web api and also with entity framework 4.7.1

IMO, you should use a classlib project that the WebAPI has reference to like a Data Access Layer using the DAO pattern and the DTO pattern.

An example code of MVC client using the WebAPI for CRUD operations using EF with the DAO and the DTO patterns. This example happens to be in VB.NET.

https://docs.microsoft.com/en-us/aspnet/web-api/overview/data/using-web-api-with-entity-framework/part-5

https://www.codeproject.com/Articles/1050468/Data-Transfer-Object-Design-Pattern-in-Csharp

https://www.tutorialspoint.com/design_pattern/data_access_object_pattern.htm

The DTO(s) are kept in a classlib project called Entities and all project s have reference to Entitles and know what the DTO(s) are about. Also the norm is to use Httpclient(), but it didnt't work to weel with VB and Webclientt() did work well in VB.

Imports System.Net
Imports Entities
Imports Newtonsoft.Json

Namespace WebApi
    Public Class WebApi
        Implements IWebApi

        #Region "Project"
        public Function  GetProjsByUserIdApi(userid As String) as List(of DtoProject) Implements IWebApi.GetProjsByUserIdApi

            dim dtoprojects = new List(Of DtoProject)

            dim url = "http://localhost/WebApiVB/api/project/GetProjectsByUserId?userid=" & userid

            Using webclient As New WebClient
                dim json  = webclient.DownloadString(url)
                Dim projects = JsonConvert.DeserializeObject(of List(Of DtoProject))(json)
                dtoprojects = projects
            End Using

            Return dtoprojects

        End Function
       
        public Function GetProjByIdApi(id As int32) as DtoProject Implements IWebApi.GetProjByIdApi

            dim dto as DtoProject

            dim url = "http://localhost/WebApiVB/api/project/GetProjectById?id=" & id

            Using webclient As New WebClient
                dim json  = webclient.DownloadString(url)
                Dim project = JsonConvert.DeserializeObject(of DtoProject)(json)
                dto = project
            End Using
           
            Return dto

        End Function

        public sub CreateProjectApi(dto As DtoProject) Implements IWebApi.CreateProjectApi

            Dim reqString As byte()

            Using webclient As New WebClient

                dim url as string = "http://localhost/WebApiVB/api/project/CreateProject"
                webClient.Headers("content-type") = "application/json"
                reqString = Encoding.Default.GetBytes(JsonConvert.SerializeObject(dto, Formatting.Indented))
                webClient.UploadData(url, "post", reqString)

            End Using
            
        End sub
        
        public sub UpdateProjectApi(dto As DtoProject) Implements IWebApi.UpdateProjectApi

            Dim reqString As byte()

            Using webclient As New WebClient

                dim url as string = "http://localhost/WebApiVB/api/project/UpdateProject"
                webClient.Headers("content-type") = "application/json"
                reqString = Encoding.Default.GetBytes(JsonConvert.SerializeObject(dto, Formatting.Indented))
                webClient.UploadData(url, "post", reqString)

            End Using

        End sub

        public sub DeleteProjectApi(dto As DtoId) Implements IWebApi.DeleteProjectApi

            Dim reqString As byte()

            Using webclient As New WebClient

                dim url as string = "http://localhost/WebApiVB/api/project/DeleteProject"
                webClient.Headers("content-type") = "application/json"
                reqString = Encoding.Default.GetBytes(JsonConvert.SerializeObject(dto, Formatting.Indented))
                webClient.UploadData(url, "post", reqString)

            End Using

        End sub
        #End Region
end class

Imports System.Web.Http
Imports DAL
Imports Entities

Namespace Controllers

    <CustomExceptionFilter>
    Public Class ProjectController
        Inherits ApiController

        Private ReadOnly _daoproject As IDaoProject

        public sub New (daoproject As IDaoProject)
            _daoproject = daoproject
        End sub

        <HttpGet>
        <ActionName("GetProjectById")>
        public Function GetProjectById(ByVal id As Int32) As DtoProject
            return _daoproject.GetProjectById(id)
        End Function


        <HttpGet>
        <ActionName("GetProjectsByUserId")>
        public Function GetProjectsByUserId(ByVal userid As String) As List(Of DtoProject)
            return _daoproject.GetProjectsByUserId(userid)
        End Function

        <HttpPost>
        <ActionName("CreateProject")>
        public sub CreateProject(ByVal dto As DtoProject)
            Call _daoproject.CreateProject(dto)
        End sub
        
        <HttpPost>
        <ActionName("UpdateProject")>
        public sub UpdateProject(ByVal dto As DtoProject)
            Call _daoproject.UpdateProject(dto)
        End sub

        <HttpPost>
        <ActionName("DeleteProject")>
        public sub  DeleteProject(ByVal dto As DtoId)
            Call _daoproject.DeleteProject(dto.Id)
        End sub
        
    End Class
End Namespace

Public Interface IDaoProject
    Function GetProjectById(ByVal id As Int32) As DtoProject
    Function GetProjectsByUserId(ByVal userid As String) As List(Of DtoProject)
    Sub CreateProject(ByVal dto As DtoProject)
    Sub UpdateProject(ByVal dto As DtoProject)
    Sub DeleteProject(ByVal id As Int32)
End Interface

===========================================================================


Imports System.Data.Entity
Imports Entities

Public Class DaoProject
    Implements IDaoProject

    Private ReadOnly context As ProjectManagementEntities

    public sub New (dbcontext As ProjectManagementEntities)
        context = dbcontext
    End sub

    Public Function GetProjectById(ByVal id As Int32) As DtoProject Implements IDaoProject.GetProjectById

        Dim dto = New DtoProject()
   
        Dim project = (context.Projects.Where(Function(a) a.ProjectId = id)).SingleOrDefault()

        If IsNothing(project) Then
            Return dto
        End If

        dto.ProjectId = project.ProjectId
        dto.ClientName = project.ClientName
        dto.ProjectName = project.ProjectName
        dto.Technology = project.Technology
        dto.ProjectType = project.ProjectType
        dto.UserId = project.UserId
        dto.StartDate = project.StartDate
        dto.EndDate = project.EndDate
        dto.Cost = project.Cost

        Return dto

    End Function

    Public Function GetProjectsByUserId(ByVal userid As String) As List(Of DtoProject) Implements IDaoProject.GetProjectsByUserId

        Dim dtos = New List(Of DtoProject)

        dtos = (From a In context.Projects.Where(Function(a) a.UserId.Contains(userid))
                Select New DtoProject With {.ProjectId = a.ProjectId,
                                            .ClientName = a.ClientName,
                                            .ProjectName = a.ProjectName,
                                            .Technology = a.Technology,
                                            .ProjectType = a.ProjectType,
                                            .UserId = a.UserId,
                                            .StartDate = a.StartDate,
                                            .EndDate = a.EndDate,
                                            .Cost = a.Cost}).ToList()
       

        Return dtos

    End Function

    Public Sub CreateProject(ByVal dto As DtoProject) Implements IDaoProject.CreateProject

        Dim project = New Project() With {.ClientName = dto.ClientName,
                                            .ProjectName = dto.ProjectName,
                                            .Technology = dto.Technology,
                                            .ProjectType = dto.ProjectType,
                                            .UserId = dto.UserId,
                                            .StartDate = dto.StartDate,
                                            .EndDate = dto.EndDate,
                                            .Cost = dto.Cost}
        context.Projects.Add(project)
        context.SaveChanges()

       
    End Sub

    Public Sub UpdateProject(ByVal dto As DtoProject) Implements IDaoProject.UpdateProject

        Dim project = New Project()
       
        project = (context.Projects.Where(Function(a) a.ProjectId = dto.ProjectId)).SingleOrDefault()
       
        If Not IsNothing(project) Then
            project.ClientName = dto.ClientName
            project.ProjectName = dto.ProjectName
            project.Technology = dto.Technology
            project.ProjectType = dto.ProjectType
            project.UserId = dto.UserId
            project.StartDate = dto.StartDate
            project.EndDate = dto.EndDate
            project.Cost = dto.Cost
        End If

      
        If IsNothing(project) Then
            Exit Sub
        End If

        context.Entry(project).State = EntityState.Modified
        context.SaveChanges()
       
    End Sub

    Public Sub DeleteProject(ByVal id As Int32) Implements IDaoProject.DeleteProject

        Dim project As Project
        
        project = (context.Projects.Where(Function(a) a.ProjectId = id)).Include("Tasks").SingleOrDefault()
       
        If IsNothing(project) Then
            Exit Sub
        End If

        For i As Integer = 0 To  project.Tasks.Count - 1
            Dim task = project.Tasks(i)
            context.Entry(task).State = EntityState.Deleted
        Next
        
        context.Entry(project).State = EntityState.Deleted
        context.SaveChanges()
       
    End Sub

    End Class

Public Class DtoProject

    Public Property ProjectId As Int32
    Public Property ClientName As String
    Public Property ProjectName As String
    Public Property Technology As String
    Public Property ProjectType As String
    Public Property UserId As String
    Public Property StartDate  As DateTime
    Public Property EndDate As DateTime? 
    Public Property Cost As Decimal
   
End Class

 

Answer 2

User61956409 posted

Hi DevTeams,

If you'd like to add Web API to your existing MVC project, you can manually add Api Controller to your project Controller folder, and then update Global.asax.cs like below.

public class MvcApplication : System.Web.HttpApplication
{
    protected void Application_Start()
    {
        AreaRegistration.RegisterAllAreas();
        GlobalConfiguration.Configure(WebApiConfig.Register);

        FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
        RouteConfig.RegisterRoutes(RouteTable.Routes);
        BundleConfig.RegisterBundles(BundleTable.Bundles);
    }
}

Besides, if you'd like to create a Web API with a MVC front end application in same project from scratch, you can create the project using following template from Visual Studio.

With Regards,

Fei Han

Answer 3

User-1038772411 posted

Hello, DevTeams

"This is a big concept i mean very long process to done mvc webapi project with entity. so i m providing you one reference link it will help you, and in that link also have one "CODE" file so you can downlod it and also apply same process  and steps in your code. you can achive your target.

https://www.c-sharpcorner.com/article/crud-Asp-Net-web-api-with-entity-framework-in-Asp-Net-mvc/

Thanks

Answer 4

User-1933134441 posted
Thanks you for giving answer but i need in c#

Answer 5

User1120430333 posted

Thanks you for giving answer but i need in c#

It's about the concept. It really makes no difference if it's C# or VB. I gave the VB.NET version in WebAPI 2.0 that is using the Unity IoC and dependency injection  in the MVC and WebAPI projects,  since there was no mentioning on what version of the WebAPI was needed or what .NET language was expected. 

However the below code is using C#  and .NET Core,  using the same concepts as the VB program and is using its own internal IoC in both projects.

My take on it is the WebAPI is it's  on standalone site that can be used by a number of clients such as a  Windows desktop, ASP.NET program or programs on other platforms like Android smartphone, Linux, Apple etc. and etc.

using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using Entities;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;

namespace ProgMgmntCore2UserIdentity.WebApi
{
    public class WebApi : IWebApi
    {
        #region ProjectApi
        
        public List<DtoProject> GetProjsByUserIdApi(string userid)
        {
            var dtoprojects = new List<DtoProject>();

            using (var client = new HttpClient())
            {
                var uri = new Uri("http://progmgmntcore2api.com/api/project/GetProjsByUserId?userid=" + userid);

                var response = client.GetAsync(uri).Result;

                if (!response.IsSuccessStatusCode)
                    throw new Exception(response.ToString());

                var responseContent = response.Content;
                var responseString = responseContent.ReadAsStringAsync().Result;

                dynamic projects = JArray.Parse(responseString) as JArray;

                foreach (var obj in projects)
                {
                    DtoProject dto = obj.ToObject<DtoProject>();

                    dtoprojects.Add(dto);
                }
            }

            return dtoprojects;
        }

        public DtoProject GetProjByIdApi(int id)
        {
            DtoProject dto;

            using (var client = new HttpClient())
            {
                var uri = new Uri("http://progmgmntcore2api.com/api/project/GetProjById?id=" + id);
                HttpResponseMessage getResponseMessage = client.GetAsync(uri).Result;

                if (!getResponseMessage.IsSuccessStatusCode)
                    throw new Exception(getResponseMessage.ToString());

                var responsemessage = getResponseMessage.Content.ReadAsStringAsync().Result;

                dynamic project = JsonConvert.DeserializeObject(responsemessage);

                dto = project.ToObject<DtoProject>();
            }

            return dto;
        }

        public void CreateProjectApi(DtoProject dto)
        {
            using (var client = new HttpClient { BaseAddress = new Uri("http://progmgmntcore2api.com") })
            {
                string serailizeddto = JsonConvert.SerializeObject(dto);

                var inputMessage = new HttpRequestMessage
                {
                    Content = new StringContent(serailizeddto, Encoding.UTF8, "application/json")
                };

                inputMessage.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));

                HttpResponseMessage message =
                    client.PostAsync("api/project/CreateProject", inputMessage.Content).Result;

                if (!message.IsSuccessStatusCode)
                    throw new Exception(message.ToString());
            }
        }

        public void UpdateProjectApi(DtoProject dto)
        {
            using (var client = new HttpClient { BaseAddress = new Uri("http://progmgmntcore2api.com") })
            {
                string serailizeddto = JsonConvert.SerializeObject(dto);

                var inputMessage = new HttpRequestMessage
                {
                    Content = new StringContent(serailizeddto, Encoding.UTF8, "application/json")
                };

                inputMessage.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));

                HttpResponseMessage message =
                    client.PostAsync("api/project/UpdateProject", inputMessage.Content).Result;

                if (!message.IsSuccessStatusCode)
                    throw new Exception(message.ToString());
            }
        }

        public void DeleteProjectApi(DtoId dto)
        {
            using (var client = new HttpClient { BaseAddress = new Uri("http://progmgmntcore2api.com") })
            {
                string serailizeddto = JsonConvert.SerializeObject(dto);

                var inputMessage = new HttpRequestMessage
                {
                    Content = new StringContent(serailizeddto, Encoding.UTF8, "application/json")
                };

                inputMessage.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));

                HttpResponseMessage message =
                    client.PostAsync("api/project/DeleteProject", inputMessage.Content).Result;

                if (!message.IsSuccessStatusCode)
                    throw new Exception(message.ToString());
            }
        }

        #endregion
    
    }
}

using System.Collections.Generic;
using DAL;
using Entities;
using Microsoft.AspNetCore.Mvc;

namespace ProgMgmntCore2Api.Controllers
{
    [Produces("application/json")]
    [Route("api/[controller]")]
    [ApiController]

    public class ProjectController : ControllerBase, IProjectController
    {
        private readonly IDaoProject _daoProject;

        public ProjectController(IDaoProject daoProject)
        {
            _daoProject = daoProject;
        }

        [HttpGet]
        [Route("GetProjById")]
        public DtoProject GetProjectById(int id)
        {
            return  _daoProject.GetProjectById(id);
        }
        
        [HttpGet]
        [Route("GetProjsByUserId")]
        public List<DtoProject> GetProjectsByUserId(string userid)
        {
            return _daoProject.GetProjectsByUserId(userid);
        }

        [HttpPost]
        [Route("CreateProject")]
        public void Post_CreateProject(DtoProject dto)
        {
            _daoProject.CreateProject(dto);
        }

        [HttpPost]
        [Route("DeleteProject")]
        public void Post_DeleteProject(DtoId dto)
        {
            _daoProject.DeleteProject(dto.Id);
        }

        [HttpPost]
        [Route("UpdateProject")]
        public void Post_UpdateProject(DtoProject dto)
        {
            _daoProject.UpdateProject(dto);
        }
    }
}

using System.Collections.Generic;
using System.Linq;
using System.Transactions;
using DAL.Models.DB;
using Entities;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Options;

namespace DAL
{
    public class DaoProject :IDaoProject
    {
        private readonly IOptions<ConnectionStrings> _options;
        
        public DaoProject(IOptions<ConnectionStrings> options)
        {
            _options = options;
        }

        public DtoProject GetProjectById(int id)
        {
            var dto = new DtoProject();

            using (var context = new ProjectManagementContext(_options))
            {
                var project = (context.Projects.Where(a => a.ProjectId == id)).SingleOrDefault();

                if (project == null) return dto;
                dto.ProjectId = project.ProjectId;
                dto.ClientName = project.ClientName;
                dto.ProjectName = project.ProjectName;
                dto.Technology = project.Technology;
                dto.ProjectType = project.ProjectType;
                dto.UserId = project.UserId;
                dto.StartDate = project.StartDate;
                dto.EndDate = project.EndDate;
                dto.Cost = project.Cost;
            }

            return dto;
        }

        public List<DtoProject> GetProjectsByUserId(string userid)
        {
            var dtos = new List<DtoProject>();

            using (var context = new ProjectManagementContext(_options))
            {
                
                dtos = (from a in context.Projects.Where(a => a.UserId.Contains(userid))
                    select new DtoProject
                    {
                        ProjectId = a.ProjectId,
                        ClientName = a.ClientName,
                        ProjectName = a.ProjectName,
                        Technology = a.Technology,
                        ProjectType = a.ProjectType,
                        UserId = a.UserId,
                        StartDate = a.StartDate,
                        EndDate = a.EndDate,
                        Cost = a.Cost
                    }).ToList();
            }

            return dtos;
        }

        public void CreateProject(DtoProject dto)
        {
            using (var context = new ProjectManagementContext(_options))
            {
                var project = new Projects
                {
                    ClientName = dto.ClientName,
                    ProjectName = dto.ProjectName,
                    Technology = dto.Technology,
                    ProjectType = dto.ProjectType,
                    UserId = dto.UserId,
                    StartDate = dto.StartDate,
                    EndDate = dto.EndDate,
                    Cost = dto.Cost
                };

                context.Projects.Add(project);
                context.SaveChanges();
           }
        }

        public void UpdateProject(DtoProject dto)
        {
            var project = new Projects();
            
            using (var context = new ProjectManagementContext(_options))
            {
               project = (context.Projects.Where(a => a.ProjectId == dto.ProjectId)).SingleOrDefault();
            }

            if (project != null)
            {
                project.ClientName = dto.ClientName;
                project.ProjectName = dto.ProjectName;
                project.Technology = dto.Technology;
                project.ProjectType = dto.ProjectType;
                project.UserId = dto.UserId;
                project.StartDate = dto.StartDate;
                project.EndDate = dto.EndDate;
                project.Cost = dto.Cost;
            }

            using (var dbcontext = new ProjectManagementContext(_options))
            {
                if (project == null) return;
                dbcontext.Entry(project).State = EntityState.Modified;
                dbcontext.SaveChanges();
            }
        }

        public void DeleteProject(int id)
        {
            Projects project;

            using (var context = new ProjectManagementContext(_options))
            {
               project = (context.Projects.Where(a => a.ProjectId == id)).SingleOrDefault();
            }

            if (project == null) return;

            using (var newContext = new ProjectManagementContext(_options))
            {
               
                var tasks = new DaoTask(_options).GetTasksByProjectId(project.ProjectId);
                using (TransactionScope scope = new TransactionScope())
                {
                    foreach (var task in tasks)
                    {
                        new DaoTask(_options).DeleteTask(task.TaskId);
                    }

                    newContext.Entry(project).State = EntityState.Deleted;
                    newContext.SaveChanges();

                    scope.Complete();
                }
            }
        }
    }
}

using System;

namespace Entities
{
    public class DtoProject
    {
        public int ProjectId { get; set; }
        public string ClientName { get; set; }
        public string ProjectName { get; set; }
        public string Technology { get; set; }
        public string ProjectType { get; set; }
        public string UserId { get; set; }
        public DateTime StartDate { get; set; }
        public DateTime EndDate { get; set; }
        public decimal Cost { get; set; }
    }
}