.Net Mvc Web Api Unity Dependency Injection

Merhaba sevgili arkadaşlar, güzel ve ilginizi çekebileceğini düşündüğüm bir konuyla karşınızdayım. .Net Mvc Web Api projesinde yazdığımız servislerimizi Unity Container’ı ile Dependency Injection ayarlarını kolayca ve profesyonel bir şekilde sağlayabiliriz. Ayrıca ek olarak bu yazımda sizlerle bir Mvc Web Api projesinde Asp.Net Identity Manager sınıflarınında ayağa kaldırılmasını göstermek istiyorum.

1.Adım .loC Katmanını Oluşturmak

Business servislerinizin ve ASP.Net Identity manager sınıflarınızın var olduğunu düşünerek .loC katmanını oluşturalım. Daha sonrasında bu katmana Nuget Package Manager’dan Unity’i ve Unity WebApi adlı paketleri kuralım, zaten bu paketleri kurduğunuzda Unity App_Start adlı bir klasör oluşturup içerisinde iki tane konfigürasyonları ayarlamak için sınıf oluşturacaktır.

Fakat biz kendi sınıfımızı oluşturalım ve bu sınıfı UnityConfigApi olarak adlandıralım. UnityConfigApi adlı sınıfımızın kodları şu şekildedir. Dediğim gibi Business servislerinizin ve ASP.Net Identity sınıflarınızın olduğunu kabul ediyorum.

using Microsoft.AspNet.Identity;
using Microsoft.AspNet.Identity.EntityFramework;
using Microsoft.Owin.Security;
using System.Web;
using System.Web.Http;
using ToDoApp.Business.Abstract;
using ToDoApp.Business.Concrete.IdentityManagers;
using ToDoApp.Business.Concrete.Managers;
using ToDoApp.DataAccess.Abstract.EntityFramework;
using ToDoApp.DataAccess.Concrete.EntityFramework;
using ToDoApp.Entities.Identity;
using ToDoApp.Entities.Identity.Entities;
using Unity;
using Unity.AspNet.Mvc;
using Unity.Injection;


namespace ToDoApp.loC
{
    public static class UnityConfigApi
    {
        public static void RegisterComponents()
        {
           var container = new UnityContainer();


            /* DEPENDENCY INJECTION FOR ASP.NET IDENTITY */

            /* For more information about these implementations please 
          * check out my website https://ismaildogaan.com/2019/08/15/asp-net-mvc-identity-icin-unity-dependency-injection-konfigurasyonu/ */


            container.RegisterType<IdentityContext>(new PerRequestLifetimeManager());
            container.RegisterType<ApplicationSignInManager>(new PerRequestLifetimeManager());
            container.RegisterType<ApplicationRoleManager>(new PerRequestLifetimeManager());
            container.RegisterType<ApplicationUserManager>(new PerRequestLifetimeManager());
            container.RegisterType<EmailService>();

            container.RegisterType<IAuthenticationManager>(
              injectionMembers: new InjectionFactory(c => HttpContext.Current.GetOwinContext().Authentication));

            container.RegisterType<IRoleStore<Roles, string>, RoleStore<Roles, string, IdentityUserRole>>(
              new InjectionConstructor(typeof(IdentityContext)));

            container.RegisterType<IUserStore<User>, UserStore<User>>(
                new InjectionConstructor(typeof(IdentityContext)));


            /* For more information about these implementations please 
          * check out my website https://ismaildogaan.com/2019/08/15/asp-net-mvc-identity-icin-unity-dependency-injection-konfigurasyonu/ */

            container.RegisterType<ITaskService, TaskManager>();
            container.RegisterType<ITaskDal, EfTaskDal>();

            container.RegisterType<IUserTaskService, UserTaskManager>();
            container.RegisterType<IUserTaskDal, EfUserTaskDal>();

            container.BindInRequstScope<ITaskService, TaskManager>();
            container.BindInRequstScope<ITaskDal, EfTaskDal>();

            container.BindInRequstScope<IUserTaskService, UserTaskManager>();
            container.BindInRequstScope<IUserTaskDal, EfUserTaskDal>();

            GlobalConfiguration.Configuration.DependencyResolver = new Unity.WebApi.UnityDependencyResolver(container);
        }
    }
}

2.Adım Web Api Katmanı Global.asax Konfigürasyonu

UnityConfigApi sınıfındaki optimasyonları şimdi Api katmanına inject etmeliyiz. Bunun için Api katmanındaki Global.asax sınıfına geliyoruz ve UnityConfigApi.RegisterComponents(); yazıyoruz.

using System.Web.Http;
using System.Web.Mvc;
using System.Web.Optimization;
using System.Web.Routing;
using ToDoApp.loC;

namespace ToDoApp.Api
{
    public class WebApiApplication : 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);

            //Unity Settings For Api
            UnityConfigApi.RegisterComponents();
        }
    }
}

3.Adım ApiController Yazımı

.NET Web Api için Dependency Injection konfigürasyonlarını sağlamış bulunmaktayız ve geriye kalan adım ise bir api controller oluşturmak ve son olarak business servislerimizi constructor vasıtasıyla dependency injection ayarlarını set etmek olacaktır.

ASP.NET Identity İçin Örnek bir Api Controller

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using System.Web.Http;
using System.Web.Http.Cors;
using ToDoApp.Business.Concrete.IdentityManagers;
using ToDoApp.Core.Aspects.PostsSharp.CacheAspects;
using ToDoApp.Core.Aspects.PostsSharp.TransactionAspects;
using ToDoApp.Core.CrossCuttingConcers.Caching.Microsoft;
using ToDoApp.DataDomain.Api;
using ToDoApp.DataDomain.Dto;
using ToDoApp.Entities.Identity.Entities;

namespace ToDoApp.Api.Controllers
{
[RoutePrefix(“api/users”)]
[AllowAnonymous]
[EnableCors(““, ““, “*”)]
public class UsersController : ApiController
{
#region Ctor
private ApplicationUserManager _userManager;
private ApplicationRoleManager _roleManager;

    public UsersController(ApplicationUserManager userManager, ApplicationRoleManager roleManager)
    {
        _userManager = userManager;
        _roleManager = roleManager;
    }

    #endregion

    #region CRUD
    [Route("getusers")]
    [HttpGet]
    [CacheAspect(typeof(MemoryCacheManager), 30)]
    public List<UsersDto> GetUsers()
    {
        List<UsersDto> users = _userManager.Users.Select(p => new UsersDto
        {
            Id = p.Id,
            UserName = p.UserName,
            Email = p.Email
        }).ToList();

        return users;
    }


    [Route("getuser")]
    [HttpGet]
    [CacheAspect(typeof(MemoryCacheManager), 30)]
    public UsersDto GetUserById(string id)
    {
        UsersDto user = _userManager.Users.Where(x => x.Id == id).Select(p => new UsersDto
        {
            Id = p.Id,
            UserName = p.UserName,
            Email = p.Email
        }).FirstOrDefault();

        return user;
    }


    [Route("createuser")]
    [HttpPost]
    public async Task<IHttpActionResult> CreateUser([FromBody]UserApi model)
    {
        try
        {
            User newUser = new User
            {
                UserName = model.UserName,
                Email = model.Email
            };

            //Creates a user without no password.
            var result = await _userManager.CreateAsync(newUser); 
            if (result.Succeeded)
            {
                var user = await _userManager.FindByNameAsync(model.UserName);
                //Adding a password to the user that has just been created.
                var addResult = await _userManager.AddPasswordAsync(user.Id, model.Password);
                var roleResult = await _userManager.AddToRoleAsync(user.Id, "Admin");

                if (result.Succeeded)
                {
                    return Ok(200);
                }
                else
                {
                    return BadRequest(addResult.Errors.ToString());
                }
            }              
            else
            {
                return BadRequest(result.Errors.ToString());
            }
        }
        catch (Exception ex)
        {
            return BadRequest(ex.Message.ToString());
        }

    }


    [Route("deleteuser")]
    [HttpPost]
    public async Task<IHttpActionResult> DeleteUser([FromBody]UserApi model)
    {
        try
        {
            var getUser = await _userManager.FindByIdAsync(model.Id);
            var result = await _userManager.DeleteAsync(getUser);
            if (result.Succeeded)
            {
                return Ok(200);
            }
            else
            {
                return BadRequest(result.Errors.ToString());
            }
        }
        catch (Exception ex)
        {
            return BadRequest(ex.Message.ToString());
        }

    }


    [Route("updateUser")]
    [HttpPost]
    public async Task<IHttpActionResult> UpdateUser([FromBody] UserApi model)
    {
        try
        {
            var getUser = await _userManager.FindByIdAsync(model.Id);
            getUser.Email = model.Email;
            getUser.UserName = model.UserName;

            var result = await _userManager.UpdateAsync(getUser);
            if (result.Succeeded)
            {
                return Ok(200);
            }
            else
            {
                return BadRequest(result.Errors.ToString());
            }
        }
        catch (Exception ex)
        {

            return BadRequest(ex.Message.ToString());
        }

    }

    #endregion
}
}

Business Servisleri İçin Örnek Bir Api Controller


using System;
using System.Collections.Generic;
using System.Linq;
using System.Web.Http;
using System.Web.Http.Cors;
using ToDoApp.Business.Abstract;
using ToDoApp.Core.Aspects.PostsSharp.CacheAspects;
using ToDoApp.Core.CrossCuttingConcers.Caching.Microsoft;
using ToDoApp.Core.Utilities.Mappings;
using ToDoApp.DataDomain.Api;
using ToDoApp.DataDomain.Dto;
using ToDoApp.Entities.EntityFramework;

namespace ToDoApp.Api.Controllers
{
    [RoutePrefix("api/tasks")]
    [AllowAnonymous]
    [EnableCors("*", "*", "*")]
    public class TasksController : ApiController
    {
        #region Ctor
        private readonly ITaskService _taskService;

        public TasksController(ITaskService taskService)
        {
            _taskService = taskService;
        }

        #endregion

        #region CRUD

        [Route("gettasks")]
        [HttpGet]
        [CacheAspect(typeof(MemoryCacheManager), 30)]
        public List<TaskDto> GetTasks()
        {
            List<TaskDto> tasks = _taskService.GetTasks().Select(p => new TaskDto
            {
                TaskId = p.TaskId,
                TaskName = p.TaskName,
                TaskTitle = p.TaskTitle,
                TaskDescription = p.TaskDescription,
                Deadline = p.Deadline,
                CreatedDate = p.CreatedDate,
                IsCompleted = p.IsCompleted
            }).ToList();

            return tasks;
        }

        [Route("gettaskbyid")]
        [HttpGet]
        [CacheAspect(typeof(MemoryCacheManager), 30)]
        public Tasks GetTaskById(int id)
        {
            Tasks tasks = AutoMapperHelper.MapToSameType(_taskService.GetById(id));

            return tasks;
        }

        [Route("checktasks")]
        [HttpGet]
        public List<TaskDto> CheckTasks()
        {
            var result = _taskService.GetTasks().Where(x => x.Deadline.Value.Year == DateTime.Now.Year
            && x.Deadline.Value.Month == DateTime.Now.Month
            && x.Deadline.Value.Day == DateTime.Now.Day && x.IsCompleted == false).ToList();

            if (result.Count > 0)
            {
                List<TaskDto> taks = result.Select(p => new TaskDto
                {
                    TaskId = p.TaskId,
                    TaskName = p.TaskName,
                    TaskTitle = p.TaskTitle,
                    TaskDescription = p.TaskDescription,
                    Deadline = p.Deadline,
                    CreatedDate = p.CreatedDate
                }).ToList();

                return taks;
            }
            return null;
        }

        [Route("createtask")]
        [HttpPost]
        public IHttpActionResult CreateTask([FromBody]TaskApi model)
        {
            try
            {
                Tasks newTask = new Tasks
                {
                    TaskName = model.TaskName,
                    TaskTitle = model.TaskTitle,
                    TaskDescription = model.TaskDescription,
                    CreatedDate = DateTime.Now,
                    Deadline = model.Deadline,
                    IsCompleted = false
                };

                _taskService.Create(newTask);
                return Ok(200);
            }
            catch (Exception ex)
            {
                return BadRequest(ex.Message.ToString());
            }

        }

        [Route("updatetask")]
        [HttpPost]
        public IHttpActionResult UpdateTask([FromBody]TaskApi model)
        {
            try
            {
                Tasks getTask = _taskService.GetById(model.TaskId);
                getTask.TaskName = model.TaskName;
                getTask.TaskTitle = model.TaskTitle;
                getTask.TaskDescription = model.TaskDescription;
                getTask.ModifiedDate = DateTime.Now;
                getTask.Deadline = model.Deadline;
                getTask.IsCompleted = model.IsCompleted;
                _taskService.Update(getTask);
                return Ok(200);
            }
            catch (Exception ex)
            {
                return BadRequest(ex.Message.ToString());
            }

        }

        [Route("deletetask")]
        [HttpPost]
        public IHttpActionResult DeleteTask([FromBody] TaskApi model)
        {
            try
            {
                Tasks getTask = _taskService.GetById(model.TaskId);
                _taskService.Delete(getTask);
                return Ok(200);
            }
            catch (Exception ex)
            {
                return BadRequest(ex.Message.ToString());
            }

        }

        #endregion
    }
}

ÖRNEK PROJE

https://github.com/dogaanismail/ToDoApp
Reklamlar
Bu yazı Asp.net MVC, Bilişim, Dependency Injection kategorisine gönderilmiş ve , , , ile etiketlenmiş. Kalıcı bağlantıyı yer imlerinize ekleyin.

Bir Cevap Yazın