using System;

public class Program

{

    public static void Main()

    {

        Console.WriteLine("Hello World");

    }

    // I created a generic CreateCommand, DeleteCommand, EditCommand, FindQuery, GetAllQuery, GetQuery

    // Here is the GetQuery 

​

    public interface IGetQuery<T> : IRequest<T> where T : Model, new()

    {

        int Id { get; set; }

    }

​

    public class GetQuery<T> : IGetQuery<T> where T : Model, new()

    {

        public int Id { get; set; }

    }

​

​

    internal class GetQueryHandler<TEntity, TModel> : IRequestHandler<GetQuery<TModel>, TModel>

        where TEntity : Entity

        where TModel : Model, new()

    {

        private readonly IRepository<TEntity> _repository;

        private readonly IMapper _mapper;

​

        public GetQueryHandler(IRepository<TEntity> repository, IMapper mapper)

        {

            _repository = repository;

            _mapper = mapper;

        }

​

​

        public async Task<TModel> Handle(GetQuery<TModel> request, CancellationToken cancellationToken)

        {

            var entity = await _repository.Get(request.Id);

            return _mapper.Map<TModel>(entity);

        }

    }

    // When building the container, I use reflection to add the concrete IRequest and IRequestHandler classes to the container.

    // I don't have to have separate files for each entity GetById for example. The concrete IRequest, IRequestHandler, and IRepository classes get created and put into the container automatically.

    // Here is the VB Code that builds the container

​

    //

    //    Dim builder = New ContainerBuilder()

​

    //    Dim mappers = (From a In GetType(mPower.Application.Model).Assembly.GetTypes

    //                   Where GetType(Profile).IsAssignableFrom(a) And a.ContainsGenericParameters = False

    //                   Select CType(Activator.CreateInstance(a), Profile)).ToList

​

    //    Dim mapperTypes = (From a In GetType(mPower.Application.Model).Assembly.GetTypes

    //                       Where GetType(Profile).IsAssignableFrom(a) And a.ContainsGenericParameters = False

    //                       Select a).ToList

​

    //    Dim entityTypes = (From a In GetType(Entity).Assembly.GetTypes

    //                       Where GetType(Entity).IsAssignableFrom(a) And a.IsAbstract = False

    //                       Select a).ToList

​

    //    Dim modelTypes = (From a In GetType(mPower.Application.Model).Assembly.GetTypes

    //                      Where GetType(mPower.Application.Model).IsAssignableFrom(a) And a.IsAbstract = False

    //                      Select a).ToList

​

    //    Dim specTypes = (From a In GetType(Entity).Assembly.GetTypes

    //                     Where a.GetInterfaces.Any(Function(i) i.IsGenericType AndAlso i.GetGenericTypeDefinition = GetType(ISpecification(Of)))

    //                     Select a).ToList

​

    //    For Each entityType In entityTypes

    //        Dim modelType = modelTypes.Where(Function(m) m.Name = $"{entityType.Name}Model").FirstOrDefault

​

    //        If Not IsNothing(modelType) Then

​

    //            If entityType.GetCustomAttributes(Of CacheAttribute).Count > 0 Then

    //                Dim cacheRepository = GetType(CacheRepository(Of )).MakeGenericType(entityType)

    //                Dim cacheRepositoryInterface = GetType(mPower.Repository.Interfaces.IRepository(Of)).MakeGenericType(entityType)

    //                builder.RegisterType(cacheRepository).As(cacheRepositoryInterface).SingleInstance()

​

    //                Dim noCacheRepository = GetType(Repository(Of )).MakeGenericType(entityType)

    //                Dim noCacheRepositoryInterface = GetType(mPower.Repository.Interfaces.INoCacheRepository(Of)).MakeGenericType(entityType)

    //                builder.RegisterType(noCacheRepository).As(noCacheRepositoryInterface).SingleInstance()

    //            Else

    //                Dim repository = GetType(Repository(Of )).MakeGenericType(entityType)

    //                Dim repositoryInterface = GetType(mPower.Repository.Interfaces.IRepository(Of)).MakeGenericType(entityType)

    //                builder.RegisterType(repository).As(repositoryInterface).SingleInstance()

    //            End If

​

    //            Dim editCommandHandler = GetType(EditCommandHandler(Of ,)).MakeGenericType(entityType, modelType)

    //            Dim editCommand = GetType(EditCommand(Of )).MakeGenericType(modelType)

    //            Dim requestHandler = GetType(IRequestHandler(Of , )).MakeGenericType(editCommand, GetType(Integer))

    //            builder.RegisterType(editCommandHandler).As(requestHandler)

​

    //            Dim createCommandHandler = GetType(CreateCommandHandler(Of ,)).MakeGenericType(entityType, modelType)

    //            Dim createCommand = GetType(CreateCommand(Of )).MakeGenericType(modelType)

    //            requestHandler = GetType(IRequestHandler(Of , )).MakeGenericType(createCommand, GetType(Integer))

    //            builder.RegisterType(createCommandHandler).As(requestHandler)

​

    //            Dim deleteCommandHandler = GetType(DeleteCommandHandler(Of )).MakeGenericType(entityType)

    //            Dim deleteCommand = GetType(DeleteCommand(Of )).MakeGenericType(entityType)

    //            requestHandler = GetType(IRequestHandler(Of , )).MakeGenericType(deleteCommand, GetType(Integer))

    //            builder.RegisterType(deleteCommandHandler).As(requestHandler)

​

    //            Dim getAllQueryHandler = GetType(GetAllQueryHandler(Of ,)).MakeGenericType(entityType, modelType)

    //            Dim getAllQuery = GetType(GetAllQuery(Of )).MakeGenericType(modelType)

    //            Dim listModel = GetType(IEnumerable(Of )).MakeGenericType(modelType)

    //            requestHandler = GetType(IRequestHandler(Of , )).MakeGenericType(getAllQuery, listModel)

    //            builder.RegisterType(getAllQueryHandler).As(requestHandler)

​

    //            Dim getQueryHandler = GetType(GetQueryHandler(Of ,)).MakeGenericType(entityType, modelType)

    //            Dim getQuery = GetType(GetQuery(Of )).MakeGenericType(modelType)

    //            requestHandler = GetType(IRequestHandler(Of , )).MakeGenericType(getQuery, modelType)

    //            builder.RegisterType(getQueryHandler).As(requestHandler)

​

    //            Dim mapperType = mapperTypes.Where(Function(x) x.Name = $"{entityType.Name}Mapper").FirstOrDefault

    //            If IsNothing(mapperType) Then

    //                Dim profile = GetType(Mapper(Of , )).MakeGenericType(entityType, modelType)

    //                mappers.Add(CType(Activator.CreateInstance(profile), Profile))

​

    //                Dim specModelType = modelTypes.Where(Function(m) m.Name = $"{entityType.Name}SpecModel").FirstOrDefault

    //                Dim specType = specTypes.Where(Function(x) x.Name = $"{entityType.Name}Spec").FirstOrDefault

​

    //                If Not IsNothing(specType) And Not IsNothing(specModelType) Then

    //                    Dim findQueryHandler = GetType(FindQueryHandler(Of , , ,)).MakeGenericType(modelType, specModelType, entityType, specType)

    //                    Dim findQuery = GetType(FindQuery(Of , )).MakeGenericType(modelType, specModelType)

    //                    requestHandler = GetType(IRequestHandler(Of , )).MakeGenericType(findQuery, listModel)

    //                    builder.RegisterType(findQueryHandler).As(requestHandler)

​

    //                    profile = GetType(Mapper(Of , )).MakeGenericType(specType, specModelType)

    //                    mappers.Add(CType(Activator.CreateInstance(profile), Profile))

    //                End If

    //            End If

    //        End If

    //    Next

    //If we decocorate the entity with [Cache(Seconds)] then it automatically adds it to the CacheRepository and loads it on launch so it doesn't have to hit the database.

    namespace mPower.Domain.Items

    {

        [Cache(15)]

        [Table("Item")]

        public class Item : Entity

        {

            public int Id { get; set; }

            [MaxLength(50)]

            public string Name { get; set; }

        }

    }       

    // The domain project has the Entity and EntitySpec files. Here is an example of a specification.

    // The specification defines what can be searched on using the FindQuery. It creates an expression that can be used by the ORM.

    // I'm probably going into too much detail here, so I'll wrap up. In the application project we create Model, SpecModel, Validator, Notification, and Mapper (if needed) classes. If we are mapping one for one entity to model,

    // we just use a generic mapper (added to the container).

    // We add Non-generic Queries and Models to the application layer as needed. Let me know if you are interested in seeing some more examples. You might not like the idea of creating the concrete classes dynamically in the container. :)

    public class EmployeeSpec : ISpecification<Employee>

    {

        public EmployeeSpec()

        {

            Ids = new List<int>();

        }

​

        public EmployeeSpec(int id) : base()

        {

            Ids.Add(id);

        }

​

        public List<int> Ids { get; set; }

        public string Name { get; set; }

        public int? Id { get; set; }

        public Expression<Func<Employee, bool>> Criteria

        {

            get

            {

                var searchStrings = Name.Split(new[] { " ", "%" }, StringSplitOptions.RemoveEmptyEntries);

                Expression<Func<Employee, bool>> expression;

                    expression = e => (Name == null || searchStrings.Contains(e.FirstName + e.LastName)) &&

                                      (Ids.Count == 0 || Ids.Contains(e.Id)) &&

                                      (Id == null || Id == e.Id);

                return expression;

            }

        }

        public bool HasCriteria

        {

            get

            {

                return Ids.Count != 0 || Name != null || Id != null;

            }

        }

   }

}

​

}