bug fixed

src/Plus.EntityFramework/Linq/EfCoreAsyncQueryableExecuter.cs

+using Microsoft.EntityFrameworkCore;
+using Plus.Dependency;
+using Plus.Linq;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace Plus.EntityFramework.Linq
+{
+    public class EfCoreAsyncQueryableExecuter : IAsyncQueryableExecuter, ISingletonDependency
+    {
+        public Task<int> CountAsync<T>(IQueryable<T> queryable)
+        {
+            return EntityFrameworkQueryableExtensions.CountAsync<T>(queryable, default);
+        }
+
+        public Task<List<T>> ToListAsync<T>(IQueryable<T> queryable)
+        {
+            return EntityFrameworkQueryableExtensions.ToListAsync<T>(queryable, default);
+        }
+
+        public Task<T> FirstOrDefaultAsync<T>(IQueryable<T> queryable)
+        {
+            return EntityFrameworkQueryableExtensions.FirstOrDefaultAsync<T>(queryable, default);
+        }
+    }
+}
\ No newline at end of file

src/Plus.EntityFramework/Plus.EntityFramework.csproj

@@ -17,7 +17,7 @@
     <PackageLicenseUrl>https://raw.githubusercontent.com/Meowv/.netcoreplus/master/LICENSE</PackageLicenseUrl>
     <PackageTags>plus;plus.entityframework;.netcoreplus;</PackageTags>
     <PackageReleaseNotes>Plus.EntityFramework</PackageReleaseNotes>
-    <Version>1.0.0.1</Version>
+    <Version>1.0.0.2</Version>
   </PropertyGroup>
 
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">

src/Plus/Configuration/DefaultSettings.cs

@@ -4,7 +4,7 @@
     {
         public string GetDefaultNameOrConnectionString()
         {
-            return Config["DefaultNameOrConnectionString"] ?? "";
+            return Config["DefaultNameOrConnectionString"];
         }
     }
 }
\ No newline at end of file

src/Plus/Configuration/DictionaryBasedConfig.cs

@@ -24,7 +24,7 @@ namespace Plus.Configuration
         public T Get<T>(string name)
         {
             object obj = this[name];
-            return (obj == null) ? default(T) : ((T)Convert.ChangeType(obj, typeof(T)));
+            return (obj == null) ? default : ((T)Convert.ChangeType(obj, typeof(T)));
         }
 
         public void Set<T>(string name, T value)

src/Plus/Dependency/BasicConventionalRegistrar.cs

 using Castle.DynamicProxy;
 using Castle.MicroKernel.Registration;
+using Plus.Event;
 using System.Reflection;
 
 namespace Plus.Dependency
@@ -42,6 +43,16 @@ namespace Plus.Dependency
                     .WithService.Self()
                     .LifestyleTransient()
                 );
+
+            //IConsumer
+            context.IocManager.IocContainer.Register(
+                Classes.FromAssembly(context.Assembly)
+                    .IncludeNonPublicTypes()
+                    .BasedOn(typeof(IConsumer<>))
+                    .If(type => !type.GetTypeInfo().IsGenericTypeDefinition)
+                    .WithService.Self()
+                    .LifestyleTransient()
+                );
         }
     }
 }
\ No newline at end of file

src/Plus/Event/Bus/Entities/EntityChangeEventHelper.cs

+using Plus.Dependency;
+using Plus.Domain.Uow;
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+
+namespace Plus.Event.Bus.Entities
+{
+    public class EntityChangeEventHelper : ITransientDependency, IEntityChangeEventHelper
+    {
+        private readonly IUnitOfWorkManager _unitOfWorkManager;
+
+        public IEventBus EventBus
+        {
+            get;
+            set;
+        }
+
+        public EntityChangeEventHelper(IUnitOfWorkManager unitOfWorkManager)
+        {
+            _unitOfWorkManager = unitOfWorkManager;
+            EventBus = NullEventBus.Instance;
+        }
+
+        public virtual void TriggerEvents(EntityChangeReport changeReport)
+        {
+            TriggerEventsInternal(changeReport);
+            if (!changeReport.IsEmpty() && _unitOfWorkManager.Current != null)
+            {
+                _unitOfWorkManager.Current.SaveChanges();
+            }
+        }
+
+        public Task TriggerEventsAsync(EntityChangeReport changeReport)
+        {
+            TriggerEventsInternal(changeReport);
+            if (changeReport.IsEmpty() || _unitOfWorkManager.Current == null)
+            {
+                return Task.FromResult(0);
+            }
+            return _unitOfWorkManager.Current.SaveChangesAsync();
+        }
+
+        public virtual void TriggerEntityCreatingEvent(object entity)
+        {
+            TriggerEventWithEntity(typeof(EntityCreatingEventData<>), entity, triggerInCurrentUnitOfWork: true);
+        }
+
+        public virtual void TriggerEntityCreatedEventOnUowCompleted(object entity)
+        {
+            TriggerEventWithEntity(typeof(EntityCreatedEventData<>), entity, triggerInCurrentUnitOfWork: false);
+        }
+
+        public virtual void TriggerEntityUpdatingEvent(object entity)
+        {
+            TriggerEventWithEntity(typeof(EntityUpdatingEventData<>), entity, triggerInCurrentUnitOfWork: true);
+        }
+
+        public virtual void TriggerEntityUpdatedEventOnUowCompleted(object entity)
+        {
+            TriggerEventWithEntity(typeof(EntityUpdatedEventData<>), entity, triggerInCurrentUnitOfWork: false);
+        }
+
+        public virtual void TriggerEntityDeletingEvent(object entity)
+        {
+            TriggerEventWithEntity(typeof(EntityDeletingEventData<>), entity, triggerInCurrentUnitOfWork: true);
+        }
+
+        public virtual void TriggerEntityDeletedEventOnUowCompleted(object entity)
+        {
+            TriggerEventWithEntity(typeof(EntityDeletedEventData<>), entity, triggerInCurrentUnitOfWork: false);
+        }
+
+        public virtual void TriggerEventsInternal(EntityChangeReport changeReport)
+        {
+            TriggerEntityChangeEvents(changeReport.ChangedEntities);
+            TriggerDomainEvents(changeReport.DomainEvents);
+        }
+
+        protected virtual void TriggerEntityChangeEvents(List<EntityChangeEntry> changedEntities)
+        {
+            foreach (EntityChangeEntry changedEntity in changedEntities)
+            {
+                switch (changedEntity.ChangeType)
+                {
+                    case EntityChangeType.Created:
+                        TriggerEntityCreatingEvent(changedEntity.Entity);
+                        TriggerEntityCreatedEventOnUowCompleted(changedEntity.Entity);
+                        break;
+                    case EntityChangeType.Updated:
+                        TriggerEntityUpdatingEvent(changedEntity.Entity);
+                        TriggerEntityUpdatedEventOnUowCompleted(changedEntity.Entity);
+                        break;
+                    case EntityChangeType.Deleted:
+                        TriggerEntityDeletingEvent(changedEntity.Entity);
+                        TriggerEntityDeletedEventOnUowCompleted(changedEntity.Entity);
+                        break;
+                    default:
+                        throw new PlusException("Unknown EntityChangeType: " + changedEntity.ChangeType);
+                }
+            }
+        }
+
+        protected virtual void TriggerDomainEvents(List<DomainEventEntry> domainEvents)
+        {
+            foreach (DomainEventEntry domainEvent in domainEvents)
+            {
+                EventBus.Trigger(domainEvent.EventData.GetType(), domainEvent.SourceEntity, domainEvent.EventData);
+            }
+        }
+
+        protected virtual void TriggerEventWithEntity(Type genericEventType, object entity, bool triggerInCurrentUnitOfWork)
+        {
+            Type type = entity.GetType();
+            Type eventType = genericEventType.MakeGenericType(type);
+            if (triggerInCurrentUnitOfWork || _unitOfWorkManager.Current == null)
+            {
+                EventBus.Trigger(eventType, (IEventData)Activator.CreateInstance(eventType, entity));
+            }
+            else
+            {
+                _unitOfWorkManager.Current.Completed += delegate
+                {
+                    EventBus.Trigger(eventType, (IEventData)Activator.CreateInstance(eventType, entity));
+                };
+            }
+        }
+    }
+}
\ No newline at end of file

src/Plus/Event/Bus/Entities/EntityChangingEventData.cs

+using System;
+
+namespace Plus.Event.Bus.Entities
+{
+    [Serializable]
+    public class EntityChangingEventData<TEntity> : EntityEventData<TEntity>
+    {
+        public EntityChangingEventData(TEntity entity)
+            : base(entity)
+        {
+        }
+    }
+}
\ No newline at end of file

src/Plus/Event/Bus/Entities/EntityCreatedEventData.cs

+using System;
+
+namespace Plus.Event.Bus.Entities
+{
+    [Serializable]
+    public class EntityCreatedEventData<TEntity> : EntityChangedEventData<TEntity>
+    {
+        public EntityCreatedEventData(TEntity entity)
+            : base(entity)
+        {
+        }
+    }
+}
\ No newline at end of file

src/Plus/Event/Bus/Entities/EntityCreatingEventData.cs

+using System;
+
+namespace Plus.Event.Bus.Entities
+{
+    [Serializable]
+    public class EntityCreatingEventData<TEntity> : EntityChangingEventData<TEntity>
+    {
+        public EntityCreatingEventData(TEntity entity)
+            : base(entity)
+        {
+        }
+    }
+}
\ No newline at end of file

src/Plus/Event/Bus/Entities/EntityDeletedEventData.cs

+using System;
+
+namespace Plus.Event.Bus.Entities
+{
+    [Serializable]
+    public class EntityDeletedEventData<TEntity> : EntityChangedEventData<TEntity>
+    {
+        public EntityDeletedEventData(TEntity entity)
+            : base(entity)
+        {
+        }
+    }
+}
\ No newline at end of file

src/Plus/Event/Bus/Entities/EntityDeletingEventData.cs

+using System;
+
+namespace Plus.Event.Bus.Entities
+{
+    [Serializable]
+    public class EntityDeletingEventData<TEntity> : EntityChangingEventData<TEntity>
+    {
+        public EntityDeletingEventData(TEntity entity)
+            : base(entity)
+        {
+        }
+    }
+}
\ No newline at end of file

src/Plus/Event/Bus/Entities/EntityUpdatedEventData.cs

+using System;
+
+namespace Plus.Event.Bus.Entities
+{
+    [Serializable]
+    public class EntityUpdatedEventData<TEntity> : EntityChangedEventData<TEntity>
+    {
+        public EntityUpdatedEventData(TEntity entity)
+            : base(entity)
+        {
+        }
+    }
+}
\ No newline at end of file

src/Plus/Event/Bus/Entities/EntityUpdatingEventData.cs

+using System;
+
+namespace Plus.Event.Bus.Entities
+{
+    [Serializable]
+    public class EntityUpdatingEventData<TEntity> : EntityChangingEventData<TEntity>
+    {
+        public EntityUpdatingEventData(TEntity entity)
+            : base(entity)
+        {
+        }
+    }
+}
\ No newline at end of file

src/Plus/Event/Bus/Exceptions/ExceptionData.cs

+using System;
+
+namespace Plus.Event.Bus.Exceptions
+{
+    public class ExceptionData : EventData
+    {
+        public Exception Exception
+        {
+            get;
+            private set;
+        }
+
+        public ExceptionData(Exception exception)
+        {
+            Exception = exception;
+        }
+    }
+}
\ No newline at end of file

src/Plus/Event/Bus/Exceptions/PlusHandledExceptionData.cs

+using System;
+
+namespace Plus.Event.Bus.Exceptions
+{
+    public class PlusHandledExceptionData : ExceptionData
+    {
+        public PlusHandledExceptionData(Exception exception) : base(exception)
+        {
+        }
+    }
+}
\ No newline at end of file

src/Plus/Event/EventPublisher.cs

@@ -10,11 +10,7 @@ namespace Plus.Event
     {
         private readonly ISubscriptionService _subscriptionService;
 
-        public ILogger Logger
-        {
-            get;
-            set;
-        }
+        public ILogger Logger { get; set; }
 
         public EventPublisher(ISubscriptionService subscriptionService)
         {

src/Plus/Plus.csproj

@@ -17,7 +17,7 @@
     <PackageLicenseUrl>https://raw.githubusercontent.com/Meowv/.netcoreplus/master/LICENSE</PackageLicenseUrl>
     <PackageTags>plus;.netcoreplus;</PackageTags>
     <PackageReleaseNotes>Plus</PackageReleaseNotes>
-    <Version>1.0.3.1</Version>
+    <Version>1.0.3.2</Version>
   </PropertyGroup>
 
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">

src/Plus/Reflection/AssemblyFinder.cs

-using Plus.Modules;
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
@@ -10,24 +10,37 @@ namespace Plus.Reflection
     /// </summary>
     public class AssemblyFinder : IAssemblyFinder
     {
-        private readonly IPlusModuleManager _moduleManager;
+        //private readonly IPlusModuleManager _moduleManager;
 
-        public AssemblyFinder(IPlusModuleManager moduleManager)
+        public static AssemblyFinder Instance
         {
-            _moduleManager = moduleManager;
+            get;
+            private set;
         }
 
+        static AssemblyFinder()
+        {
+            Instance = new AssemblyFinder();
+        }
+
+        //public AssemblyFinder(IPlusModuleManager moduleManager)
+        //{
+        //    _moduleManager = moduleManager;
+        //}
+
         public List<Assembly> GetAllAssemblies()
         {
-            var assemblies = new List<Assembly>();
+            //var assemblies = new List<Assembly>();
+
+            //foreach (var module in _moduleManager.Modules)
+            //{
+            //    assemblies.Add(module.Assembly);
+            //    assemblies.AddRange(module.Instance.GetAdditionalAssemblies());
+            //}
 
-            foreach (var module in _moduleManager.Modules)
-            {
-                assemblies.Add(module.Assembly);
-                assemblies.AddRange(module.Instance.GetAdditionalAssemblies());
-            }
+            //return assemblies.Distinct().ToList();
 
-            return assemblies.Distinct().ToList();
+            return AppDomain.CurrentDomain.GetAssemblies().ToList();
         }
     }
 }
\ No newline at end of file

src/Plus/Services/ICrudAppService.cs

+using Plus.Dependency;
+using Plus.Services.Dto;
+
+namespace Plus.Services
+{
+    public interface ICrudAppService<TEntityDto, TPrimaryKey, in TCreateInput, in TUpdateInput, in TDeleteInput> : IApplicationService, ITransientDependency where TEntityDto : IEntityDto<TPrimaryKey> where TUpdateInput : IEntityDto<TPrimaryKey> where TDeleteInput : IEntityDto<TPrimaryKey>
+    {
+        TEntityDto Create(TCreateInput input);
+
+        TEntityDto Update(TUpdateInput input);
+
+        void Delete(TDeleteInput input);
+    }
+}
\ No newline at end of file