├── .gitignore
├── Basf.sln
├── Basf
    ├── AppRuntime.cs
    ├── Basf.csproj
    ├── Container
    │   ├── AopMatcher.cs
    │   ├── IAbsfRegistration.cs
    │   ├── IObjectContainer.cs
    │   ├── LifetimeStyle.cs
    │   └── ObjectContainerExtensions.cs
    ├── Data
    │   └── ActionResponse.cs
    ├── Domain
    │   ├── IAggRoot.cs
    │   ├── IAggRootEventHandler.cs
    │   ├── IAggRootState.cs
    │   ├── IAggRootStorage.cs
    │   ├── ICommand.cs
    │   ├── IDomainContext.cs
    │   ├── IDomainEvent.cs
    │   └── IUnitOfWork.cs
    ├── Logging
    │   └── ILogger.cs
    ├── Mq
    │   ├── IConsumer.cs
    │   ├── IConsumerManager.cs
    │   ├── IMessageHandler.cs
    │   ├── IProducer.cs
    │   └── Message.cs
    ├── Properties
    │   └── PublishProfiles
    │   │   └── FolderProfile.pubxml
    ├── Serializing
    │   ├── IBinarySerializer.cs
    │   ├── IJsonSerializer.cs
    │   └── ISerializer.cs
    └── Utilities
    │   ├── CityHash.cs
    │   └── uint128.cs
└── README.md


/.gitignore:
--------------------------------------------------------------------------------
 1 | obj
 2 | bin
 3 | build
 4 | packages
 5 | 
 6 | *.suo
 7 | *.user
 8 | *.sln.cache
 9 | *.nupkg
10 | *.testsettings
11 | *.vsmdi


--------------------------------------------------------------------------------
/Basf.sln:
--------------------------------------------------------------------------------
 1 | 
 2 | Microsoft Visual Studio Solution File, Format Version 12.00
 3 | # Visual Studio 15
 4 | VisualStudioVersion = 15.0.26403.3
 5 | MinimumVisualStudioVersion = 10.0.40219.1
 6 | Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Basf", "Basf\Basf.csproj", "{180D00C7-F0C0-48D9-9E86-331C6D426167}"
 7 | EndProject
 8 | Global
 9 | 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
10 | 		Debug|Any CPU = Debug|Any CPU
11 | 		Release|Any CPU = Release|Any CPU
12 | 	EndGlobalSection
13 | 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
14 | 		{180D00C7-F0C0-48D9-9E86-331C6D426167}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
15 | 		{180D00C7-F0C0-48D9-9E86-331C6D426167}.Debug|Any CPU.Build.0 = Debug|Any CPU
16 | 		{180D00C7-F0C0-48D9-9E86-331C6D426167}.Release|Any CPU.ActiveCfg = Release|Any CPU
17 | 		{180D00C7-F0C0-48D9-9E86-331C6D426167}.Release|Any CPU.Build.0 = Release|Any CPU
18 | 	EndGlobalSection
19 | 	GlobalSection(SolutionProperties) = preSolution
20 | 		HideSolutionNode = FALSE
21 | 	EndGlobalSection
22 | EndGlobal
23 | 


--------------------------------------------------------------------------------
/Basf/AppRuntime.cs:
--------------------------------------------------------------------------------
 1 | using Basf.Logging;
 2 | using System;
 3 | 
 4 | namespace Basf
 5 | {
 6 |     public sealed class AppRuntime
 7 |     {
 8 |         #region 私有字段
 9 |         private static AppRuntime Instance = new AppRuntime();
10 |         private IObjectContainer objContainer = null;
11 | 
12 |         //private List<InterceptorMatcher>
13 |         #endregion
14 | 
15 |         #region 构造方法
16 |         static AppRuntime()
17 |         {
18 |         }
19 |         private AppRuntime()
20 |         {
21 |         }
22 |         #endregion
23 | 
24 |         #region 属性
25 |         public static IObjectContainer Container => AppRuntime.Instance.objContainer;
26 |         public static ILogger Logger = (ILogger)AppRuntime.Container?.Resolve(typeof(ILogger));
27 |         #endregion
28 | 
29 |         #region 配置方法
30 |         public static void Configure(Action<AppRuntime> objBuilder)
31 |         {
32 |             objBuilder?.Invoke(AppRuntime.Instance);
33 |         }
34 |         //public AppRuntime MatchInterceptor(InterceptorMatchKind kind, string expression, Type interceptorType)
35 |         //{
36 |         //    if (objContainer == null) throw new ArgumentNullException("objContainer");
37 |         //    AppRuntime.Container = objContainer;
38 |         //    return AppRuntime.Instance;
39 |         //}
40 |         //public AppRuntime MatchInterceptor(InterceptorMatchKind kind, string expression, string interceptorName)
41 |         //{
42 |         //    if (objContainer == null) throw new ArgumentNullException("Container");
43 |         //    AppRuntime.Container = objContainer;
44 |         //    return AppRuntime.Instance;
45 |         //}
46 |         public AppRuntime UsingContainer(IObjectContainer container)
47 |         {
48 |             if (container == null) throw new ArgumentNullException("container");
49 |             AppRuntime.Instance.objContainer = container;
50 |             return AppRuntime.Instance;
51 |         }
52 |         public AppRuntime UsingLogger<TLogger>() where TLogger : class, ILogger
53 |         {
54 |             if (AppRuntime.Container == null) throw new ArgumentNullException("AppRuntime.Container");
55 |             AppRuntime.Container.RegisterType<ILogger, TLogger>(LifetimeStyle.Singleton);
56 |             return AppRuntime.Instance;
57 |         }
58 |         #endregion
59 |     }
60 | }
61 | 


--------------------------------------------------------------------------------
/Basf/Basf.csproj:
--------------------------------------------------------------------------------
 1 | <Project Sdk="Microsoft.NET.Sdk">
 2 |   <PropertyGroup>
 3 |     <TargetFrameworks>net45;net451;net46;net461;net462;netstandard1.6</TargetFrameworks>
 4 |     <GeneratePackageOnBuild>True</GeneratePackageOnBuild>
 5 |     <Authors>leaf kevin</Authors>
 6 |     <PackageProjectUrl>https://github.com/leafkevin/Basf</PackageProjectUrl>
 7 |     <GenerateAssemblyConfigurationAttribute>false</GenerateAssemblyConfigurationAttribute>
 8 |     <GenerateAssemblyCompanyAttribute>false</GenerateAssemblyCompanyAttribute>
 9 |     <GenerateAssemblyProductAttribute>false</GenerateAssemblyProductAttribute>
10 |     <AssemblyVersion>1.1.0.0</AssemblyVersion>
11 |     <FileVersion>1.1.0.0</FileVersion>
12 |     <Version>1.1.0.0</Version>
13 |     <PackageReleaseNotes>一个DDD+CQRS+Event Sourcing通用框架的接口，可以很容易的结合各种现有成熟框架来搭建。CQRS可以结合Orleans，Akka.net等Actor框架封装实现。目前支持.NET 4.5+,.NET Standard1.6+。</PackageReleaseNotes>
14 |     <Description>一个DDD+CQRS+Event Sourcing通用框架的接口，可以很容易的结合各种现有成熟框架来搭建。CQRS可以结合Orleans，Akka.net等Actor框架封装实现。目前支持.NET 4.5+,.NET Standard1.6+。</Description>
15 |   </PropertyGroup>
16 |   <PropertyGroup Condition="'$(TargetFramework)' == 'netstandard1.6'">
17 |     <DefineConstants>$(DefineConstants);COREFX</DefineConstants>
18 |   </PropertyGroup>
19 |   <ItemGroup Condition=" '$(TargetFramework)' == 'net45' ">
20 |     <Reference Include="System" />
21 |     <Reference Include="System.Runtime" />
22 |     <Reference Include="Microsoft.CSharp" />
23 |   </ItemGroup>
24 | </Project>


--------------------------------------------------------------------------------
/Basf/Container/AopMatcher.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | 
 3 | namespace Basf
 4 | {
 5 |     public class AopMatcher
 6 |     {
 7 |         public AopMatchKind Kind { get; set; }
 8 |         public string Expression { get; set; }
 9 |         public Type InterceptorType { get; set; }
10 |     }
11 |     public enum AopMatchKind
12 |     {
13 |         ClassName = 1,
14 |         InterfaceName = 2,
15 |         AssignableFrom = 3,
16 |         MethodName = 4
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/Basf/Container/IAbsfRegistration.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | 
 4 | namespace Basf
 5 | {
 6 |     public interface IAbsfRegistration
 7 |     {
 8 |         bool HasInterceptor { get; }
 9 |         IAbsfRegistrationTypeExpression RegisterType(Type objServiceType, Type objComponentType);
10 |         IAbsfRegistrationTypeExpression<TService> RegisterType<TService>() where TService : class;
11 |         IAbsfRegistrationTypeExpression RegisterType(Type objServiceType);
12 |         IAbsfRegistrationInstanceExpression<TService> RegisterType<TService>(TService objInstance) where TService : class;
13 |         IAbsfRegistrationTypeExpression<TComponent> RegisterType<TService, TComponent>()
14 |             where TService : class
15 |             where TComponent : class, TService;
16 |         IAbsfRegistrationGenericExpression RegisterGeneric(Type objService, Type objComponent);
17 |     }
18 |     public interface IAbsfRegistrationTypeExpression
19 |     {
20 |         IAbsfRegistrationTypeExpression Forward<TService>();
21 |         IAbsfRegistrationTypeExpression Forward<TService1, TService2>();
22 |         IAbsfRegistrationTypeExpression Forward<TService1, TService2, TService3>();
23 |         IAbsfRegistrationTypeExpression Forward(params Type[] objServiceTypes);
24 |         IAbsfRegistrationTypeExpression Named<TService>(string strName);
25 |         IAbsfRegistrationTypeExpression Named(string strName, Type objServiceType);
26 |         IAbsfRegistrationTypeExpression Lifetime(LifetimeStyle iLifetimeStyle);
27 |         IAbsfRegistrationTypeExpression OwnedLifetime(Type objServiceType);
28 |         IAbsfRegistrationTypeExpression OwnedLifetime<TService>();
29 |         IAbsfRegistrationTypeExpression UsingConstructor(params Type[] objTypes);
30 |         IAbsfRegistrationTypeExpression WithParameter(string strName, object objValue);
31 |         IAbsfRegistrationTypeExpression WithParameters(params object[] objParamters);
32 |         IAbsfRegistrationTypeExpression WithParameters(IDictionary<string, object> objParamters);
33 |         IAbsfRegistrationTypeExpression WithInterfaceInterceptor(Type interceptorType);
34 |         IAbsfRegistrationTypeExpression WithClassInterceptor(Type interceptorType);
35 |     }
36 |     public interface IAbsfRegistrationTypeExpression<TComponent>
37 |     {
38 |         IAbsfRegistrationTypeExpression<TComponent> Forward<TService>();
39 |         IAbsfRegistrationTypeExpression<TComponent> Forward<TService1, TService2>();
40 |         IAbsfRegistrationTypeExpression<TComponent> Forward<TService1, TService2, TService3>();
41 |         IAbsfRegistrationTypeExpression<TComponent> Forward(params Type[] objServiceTypes);
42 |         IAbsfRegistrationTypeExpression<TComponent> Named<TService>(string strName);
43 |         IAbsfRegistrationTypeExpression<TComponent> Named(string strName, Type objServiceType);
44 |         IAbsfRegistrationTypeExpression<TComponent> Lifetime(LifetimeStyle iLifetimeStyle);
45 |         IAbsfRegistrationTypeExpression<TComponent> OwnedLifetime(Type objServiceType);
46 |         IAbsfRegistrationTypeExpression<TComponent> OwnedLifetime<TService>();
47 |         IAbsfRegistrationTypeExpression<TComponent> UsingConstructor(params Type[] objTypes);
48 |         IAbsfRegistrationTypeExpression<TComponent> WithParameter(string strName, object objValue);
49 |         IAbsfRegistrationTypeExpression<TComponent> WithParameters(params object[] objParamters);
50 |         IAbsfRegistrationTypeExpression<TComponent> WithParameters(IDictionary<string, object> objParamters);
51 |         IAbsfRegistrationTypeExpression<TComponent> WithInterfaceInterceptor(Type interceptorType);
52 |         IAbsfRegistrationTypeExpression<TComponent> WithClassInterceptor(Type interceptorType);
53 |     }
54 |     public interface IAbsfRegistrationInstanceExpression<TComponent>
55 |     {
56 |         IAbsfRegistrationInstanceExpression<TComponent> Forward<TService>();
57 |         IAbsfRegistrationInstanceExpression<TComponent> Forward<TService1, TService2>();
58 |         IAbsfRegistrationInstanceExpression<TComponent> Forward<TService1, TService2, TService3>();
59 |         IAbsfRegistrationInstanceExpression<TComponent> Forward(params Type[] objServiceTypes);
60 |         IAbsfRegistrationInstanceExpression<TComponent> Named<TService>(string strName);
61 |         IAbsfRegistrationInstanceExpression<TComponent> Named(string strName, Type objServiceType);
62 |         IAbsfRegistrationInstanceExpression<TComponent> Lifetime(LifetimeStyle iLifetimeStyle);
63 |         IAbsfRegistrationInstanceExpression<TComponent> OwnedLifetime(Type objServiceType);
64 |         IAbsfRegistrationInstanceExpression<TComponent> OwnedLifetime<TService>();
65 |         IAbsfRegistrationInstanceExpression<TComponent> WithInterfaceInterceptor(Type interceptorType);
66 |     }
67 |     public interface IAbsfRegistrationGenericExpression
68 |     {
69 |         IAbsfRegistrationGenericExpression Forward<TService>();
70 |         IAbsfRegistrationGenericExpression Forward<TService1, TService2>();
71 |         IAbsfRegistrationGenericExpression Forward<TService1, TService2, TService3>();
72 |         IAbsfRegistrationGenericExpression Forward(params Type[] objServiceTypes);
73 |         IAbsfRegistrationGenericExpression Lifetime(LifetimeStyle iLifetimeStyle);
74 |         IAbsfRegistrationGenericExpression OwnedLifetime(Type objServiceType);
75 |         IAbsfRegistrationGenericExpression OwnedLifetime<TService>();
76 |         IAbsfRegistrationGenericExpression UsingConstructor(params Type[] objTypes);
77 |         IAbsfRegistrationGenericExpression WithParameter(string strName, object objValue);
78 |         IAbsfRegistrationGenericExpression WithParameters(params object[] objParamters);
79 |         IAbsfRegistrationGenericExpression WithParameters(IDictionary<string, object> objParamters);
80 |         IAbsfRegistrationGenericExpression WithInterfaceInterceptor(Type interceptorType);
81 |     }
82 | }
83 | 


--------------------------------------------------------------------------------
/Basf/Container/IObjectContainer.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | 
 4 | namespace Basf
 5 | {
 6 |     public interface IObjectContainer : IDisposable
 7 |     {
 8 |         #region ServiceRegistry组件注册
 9 |         void Register(Action<IAbsfRegistration> objRegisterBuilder);
10 |         #endregion
11 | 
12 |         #region ServiceFetcher组件获取
13 |         object Resolve(Type objServiceType, params object[] objArgs);
14 |         object Resolve(Type objServiceType, IDictionary<string, object> objArgs);
15 |         TService ResolveNamed<TService>(string strName, params object[] objArgs) where TService : class;
16 |         TService ResolveNamed<TService>(string strName, IDictionary<string, object> objArgs) where TService : class;
17 |         IEnumerable<object> ResolveAll(Type objServiceType);
18 |         IEnumerable<TService> ResolveAll<TService>() where TService : class;
19 |         #endregion
20 | 
21 |         #region Other
22 |         bool HasRegister(Type objServiceType, string strName = null);
23 |         #endregion
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/Basf/Container/LifetimeStyle.cs:
--------------------------------------------------------------------------------
 1 | namespace Basf
 2 | {
 3 |     public enum LifetimeStyle
 4 |     {
 5 |         /// <summary>
 6 |         /// 单件
 7 |         /// </summary>
 8 |         Singleton,
 9 |         /// <summary>
10 |         /// 线程内单件
11 |         /// </summary>
12 |         Thread,
13 |         /// <summary>
14 |         /// 瞬态
15 |         /// </summary>
16 |         Transient,
17 |         /// <summary>
18 |         /// 作用域
19 |         /// </summary>
20 |         Scoped,
21 |         /// <summary>
22 |         /// 对象池
23 |         /// </summary>
24 |         Pool,
25 |         /// <summary>
26 |         /// 请求
27 |         /// </summary>
28 |         Request
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/Basf/Container/ObjectContainerExtensions.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Collections.Generic;
  3 | 
  4 | namespace Basf
  5 | {
  6 |     public static class ObjectContainerExtensions
  7 |     {
  8 |         #region Register
  9 |         public static void RegisterType(this IObjectContainer objContainer, Type objServiceType, Type objComponentType)
 10 |         {
 11 |             objContainer.Register(f => f.RegisterType(objServiceType, objComponentType));
 12 |         }
 13 |         public static void RegisterType(this IObjectContainer objContainer, Type objServiceType, Type objComponentType, string strName)
 14 |         {
 15 |             objContainer.Register(f => f.RegisterType(objServiceType, objComponentType).Named(strName, objServiceType));
 16 |         }
 17 |         public static void RegisterType(this IObjectContainer objContainer, Type objServiceType, Type objComponentType, LifetimeStyle iLifetimeStyle)
 18 |         {
 19 |             objContainer.Register(f => f.RegisterType(objServiceType, objComponentType).Lifetime(iLifetimeStyle));
 20 |         }
 21 |         public static void RegisterType(this IObjectContainer objContainer, Type objServiceType, Type objComponentType, string strName, LifetimeStyle iLifetimeStyle)
 22 |         {
 23 |             objContainer.Register(f => f.RegisterType(objServiceType, objComponentType).Named(strName, objServiceType).Lifetime(iLifetimeStyle));
 24 |         }
 25 |         public static void RegisterType<TService>(this IObjectContainer objContainer) where TService : class
 26 |         {
 27 |             objContainer.Register(f => f.RegisterType<TService>());
 28 |         }
 29 |         public static void RegisterType<TService>(this IObjectContainer objContainer, string strName) where TService : class
 30 |         {
 31 |             objContainer.Register(f => f.RegisterType<TService>().Named<TService>(strName));
 32 |         }
 33 |         public static void RegisterType<TService>(this IObjectContainer objContainer, LifetimeStyle iLifetimeStyle) where TService : class
 34 |         {
 35 |             objContainer.Register(f => f.RegisterType<TService>().Lifetime(iLifetimeStyle));
 36 |         }
 37 |         public static void RegisterType<TService>(this IObjectContainer objContainer, string strName, LifetimeStyle iLifetimeStyle) where TService : class
 38 |         {
 39 |             objContainer.Register(f => f.RegisterType<TService>().Named<TService>(strName).Lifetime(iLifetimeStyle));
 40 |         }
 41 |         public static void RegisterType<TService, TComponent>(this IObjectContainer objContainer)
 42 |             where TService : class
 43 |             where TComponent : class, TService
 44 |         {
 45 |             objContainer.Register(f => f.RegisterType<TService, TComponent>());
 46 |         }
 47 |         public static void RegisterType<TService, TComponent>(this IObjectContainer objContainer, string strName)
 48 |             where TService : class
 49 |             where TComponent : class, TService
 50 |         {
 51 |             objContainer.Register(f => f.RegisterType<TService, TComponent>().Named<TService>(strName));
 52 |         }
 53 |         public static void RegisterType<TService, TComponent>(this IObjectContainer objContainer, LifetimeStyle iLifetimeStyle)
 54 |             where TService : class
 55 |             where TComponent : class, TService
 56 |         {
 57 |             objContainer.Register(f => f.RegisterType<TService, TComponent>().Lifetime(iLifetimeStyle));
 58 |         }
 59 |         public static void RegisterType<TService, TComponent>(this IObjectContainer objContainer, string strName, LifetimeStyle iLifetimeStyle)
 60 |             where TService : class
 61 |             where TComponent : class, TService
 62 |         {
 63 |             objContainer.Register(f => f.RegisterType<TService, TComponent>().Named<TService>(strName).Lifetime(iLifetimeStyle));
 64 |         }
 65 |         public static void RegisterInstance<TService>(this IObjectContainer objContainer, TService objInstance) where TService : class
 66 |         {
 67 |             objContainer.Register(f => f.RegisterType<TService>(objInstance));
 68 |         }
 69 |         public static void RegisterInstance<TService>(this IObjectContainer objContainer, TService objInstance, string strName) where TService : class
 70 |         {
 71 |             objContainer.Register(f => f.RegisterType<TService>(objInstance).Named<TService>(strName));
 72 |         }
 73 |         public static void RegisterInstance<TService>(this IObjectContainer objContainer, TService objInstance, LifetimeStyle iLifetimeStyle) where TService : class
 74 |         {
 75 |             objContainer.Register(f => f.RegisterType<TService>(objInstance).Lifetime(iLifetimeStyle));
 76 |         }
 77 |         public static void RegisterInstance<TService>(this IObjectContainer objContainer, TService objInstance, string strName, LifetimeStyle iLifetimeStyle) where TService : class
 78 |         {
 79 |             objContainer.Register(f => f.RegisterType<TService>(objInstance).Named<TService>(strName).Lifetime(iLifetimeStyle));
 80 |         }
 81 |         public static void RegisterGeneric(this IObjectContainer objContainer, Type objService, Type objComponent)
 82 |         {
 83 |             objContainer.Register(f => f.RegisterGeneric(objService, objComponent).Lifetime(LifetimeStyle.Transient));
 84 |         }
 85 |         public static void RegisterGeneric(this IObjectContainer objContainer, Type objService, Type objComponent, LifetimeStyle iLifetimeStyle)
 86 |         {
 87 |             objContainer.Register(f => f.RegisterGeneric(objService, objComponent).Lifetime(iLifetimeStyle));
 88 |         }
 89 |         #endregion
 90 | 
 91 |         #region Resolve      
 92 |         public static TService Resolve<TService>(this IObjectContainer objContainer, params object[] objArgs) where TService : class
 93 |         {
 94 |             return (TService)objContainer.Resolve(typeof(TService), objArgs);
 95 |         }
 96 |         public static TService Resolve<TService>(this IObjectContainer objContainer, IDictionary<string, object> objArgs) where TService : class
 97 |         {
 98 |             return (TService)objContainer.Resolve(typeof(TService), objArgs);
 99 |         }
100 |         public static bool HasRegister<TService>(this IObjectContainer objContainer)
101 |         {
102 |             return objContainer.HasRegister(typeof(TService));
103 |         }
104 |         public static bool HasRegister<TService>(this IObjectContainer objContainer, string strName)
105 |         {
106 |             return objContainer.HasRegister(typeof(TService), strName);
107 |         }
108 |         #endregion
109 |     }
110 | }
111 | 


--------------------------------------------------------------------------------
/Basf/Data/ActionResponse.cs:
--------------------------------------------------------------------------------
 1 | namespace Basf.Data
 2 | {
 3 |     public class ActionResponse
 4 |     {
 5 |         private static readonly ActionResponse successResponse = new ActionResponse(true);
 6 |         public bool IsSuccess { get; set; }
 7 |         public int Code { get; set; }
 8 |         public string Message { get; set; }
 9 |         public static ActionResponse Success { get { return successResponse; } }
10 |         protected ActionResponse(bool isSuccess, int code = 0, string message = null)
11 |         {
12 |             this.IsSuccess = isSuccess;
13 |             this.Code = code;
14 |             this.Message = message;
15 |         }
16 |         public static ActionResponse<T> Succeed<T>(T result = default(T))
17 |         {
18 |             return new ActionResponse<T>(true, result);
19 |         }
20 |         public static ActionResponse Fail(int code, string message)
21 |         {
22 |             return new ActionResponse(false, code, message);
23 |         }
24 |         public static ActionResponse<T> Fail<T>(int code, string message)
25 |         {
26 |             return new ActionResponse<T>(false, code, message, default(T));
27 |         }
28 |     }
29 |     public class ActionResponse<T> : ActionResponse
30 |     {
31 |         public T Result { get; private set; }
32 |         internal protected ActionResponse(bool isSuccess, T result)
33 |            : base(isSuccess)
34 |         {
35 |             this.Result = result;
36 |         }
37 |         internal protected ActionResponse(bool isSuccess, int code, string message, T result)
38 |             : base(isSuccess, code, message)
39 |         {
40 |             this.Result = result;
41 |         }
42 |     }
43 | }
44 | 


--------------------------------------------------------------------------------
/Basf/Domain/IAggRoot.cs:
--------------------------------------------------------------------------------
1 | namespace Basf.Domain
2 | {
3 |     public interface IAggRoot<TKey>
4 |     {
5 |         TKey UniqueId { get; }
6 |         int Version { get; }
7 |     }
8 | }
9 | 


--------------------------------------------------------------------------------
/Basf/Domain/IAggRootEventHandler.cs:
--------------------------------------------------------------------------------
1 | namespace Basf.Domain
2 | {
3 |     public interface IAggRootEventHandler<TKey>
4 |     {
5 |         void HandleEvent<TDomainEvent>(IAggRootState<TKey> state, TDomainEvent domainEvent) where TDomainEvent : IDomainEvent<TKey>;
6 |     }
7 | }
8 | 


--------------------------------------------------------------------------------
/Basf/Domain/IAggRootState.cs:
--------------------------------------------------------------------------------
1 | namespace Basf.Domain
2 | {
3 |     public interface IAggRootState<TKey>
4 |     {
5 |         TKey UniqueId { get; }
6 |         int Version { get; }
7 |     }
8 | }
9 | 


--------------------------------------------------------------------------------
/Basf/Domain/IAggRootStorage.cs:
--------------------------------------------------------------------------------
 1 | using System.Collections.Generic;
 2 | using System.Threading.Tasks;
 3 | 
 4 | namespace Basf.Domain
 5 | {
 6 |     public interface IAggRootStorage<TAggRootState, TKey> where TAggRootState : IAggRootState<TKey>
 7 |     {
 8 |         Task<TEvent> Get<TEvent>(TKey aggRootId, int version) where TEvent : IDomainEvent<TKey>;
 9 |         Task<bool> Add<TEvent>(TEvent domainEvent) where TEvent : IDomainEvent<TKey>;
10 |         Task<List<IDomainEvent<TKey>>> Find(TKey aggRootId, int startVersion);
11 |         Task<List<TEvent>> Find<TEvent>(TKey aggRootId, string eventType, int startVersion) where TEvent : IDomainEvent<TKey>;
12 |         Task<List<IDomainEvent<TKey>>> Find(string commandId);
13 |         Task<List<TEvent>> Find<TEvent>(string commandId, string eventType) where TEvent : IDomainEvent<TKey>;
14 |         Task Complete<TEvent>(TEvent domainEvent) where TEvent : IDomainEvent<TKey>;
15 |         Task<TAggRootState> GetSnapshot(TKey aggRootId);
16 |         Task SaveSnapshot(TAggRootState state);
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/Basf/Domain/ICommand.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | 
 3 | namespace Basf.Domain
 4 | {
 5 |     public interface ICommand
 6 |     {
 7 |         string UniqueId { get; }
 8 |         DateTime Timestamp { get; }
 9 |     }
10 | }
11 | 


--------------------------------------------------------------------------------
/Basf/Domain/IDomainContext.cs:
--------------------------------------------------------------------------------
 1 | using System.Threading.Tasks;
 2 | 
 3 | namespace Basf.Domain
 4 | {
 5 |     public interface IDomainContext
 6 |     {
 7 |         Task Create<TEntity, TKey>(TKey id) where TEntity : IAggRoot<TKey>;
 8 |         Task<TEntity> Get<TEntity, TKey>(TKey id) where TEntity : IAggRoot<TKey>;
 9 |     }
10 | }
11 | 


--------------------------------------------------------------------------------
/Basf/Domain/IDomainEvent.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | 
 3 | namespace Basf.Domain
 4 | {
 5 |     public interface IDomainEvent<TKey>
 6 |     {
 7 |         string UniqueId { get; }
 8 |         string CommandId { get; }
 9 |         string EventType { get; }
10 |         TKey AggRootId { get; set; }
11 |         int Version { get; set; }
12 |         DateTime Timestamp { get; }
13 |     }
14 |     public interface IDomainEvent : IDomainEvent<string>
15 |     {
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/Basf/Domain/IUnitOfWork.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | 
 3 | namespace Basf.Domain
 4 | {
 5 |     public interface IUnitOfWork : IDisposable
 6 |     {
 7 |         void Begin();
 8 |         void Commit();
 9 |         void Rollback();
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/Basf/Logging/ILogger.cs:
--------------------------------------------------------------------------------
 1 | namespace Basf.Logging
 2 | {
 3 |     public interface ILogger
 4 |     {
 5 |         void Debug(string message);
 6 |         void Debug(string format, params object[] objArgs);
 7 |         void Info(string message);
 8 |         void Info(string strFormat, params object[] objArgs);
 9 |         void Error(string message);
10 |         void Error(string strFormat, params object[] objArgs);
11 |         void Warn(string message);
12 |         void Warn(string strFormat, params object[] objArgs);
13 |         void Fatal(string message);
14 |         void Fatal(string strFormat, params object[] objArgs);
15 |     }
16 | }


--------------------------------------------------------------------------------
/Basf/Mq/IConsumer.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Threading.Tasks;
 3 | 
 4 | namespace Basf.Mq
 5 | {
 6 |     public interface IConsumer
 7 |     {
 8 |         void Subscribe(string routingKey);
 9 |         Task Execute(Message msg);
10 |         void AddHandler(string msgType, Func<object, Task> handler);
11 |     }
12 | }
13 | 


--------------------------------------------------------------------------------
/Basf/Mq/IConsumerManager.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | 
 3 | namespace Basf.Mq
 4 | {
 5 |     public interface IConsumerManager
 6 |     {
 7 |         void Start();
 8 |         void RegisterConsumer(string routingKey, Type consumerType);
 9 |     }
10 | }
11 | 


--------------------------------------------------------------------------------
/Basf/Mq/IMessageHandler.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Threading.Tasks;
 3 | 
 4 | namespace Basf.Mq
 5 | {
 6 |     public interface IMessageHandler
 7 |     {
 8 |         string RoutingKey { get; }
 9 |         Task Execute(Message msg);
10 |         string AddProcesser(string msgType, Func<object, Task> msgProcesser);
11 |     }
12 |     public interface IMessageHandler<TMsgBody>
13 |     {
14 |         string RoutingKey { get; }
15 |         Task Execute(Message<TMsgBody> msg);
16 |         string AddProcesser(string msgType, Func<TMsgBody, Task> msgProcesser);
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/Basf/Mq/IProducer.cs:
--------------------------------------------------------------------------------
1 | namespace Basf.Mq
2 | {
3 |     public interface IProducer
4 |     {
5 |         void Publish(string exchange, string routingKey, Message msg);
6 |     }
7 | }
8 | 


--------------------------------------------------------------------------------
/Basf/Mq/Message.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | 
 4 | namespace Basf.Mq
 5 | {
 6 |     public class Message<TBody>
 7 |     {
 8 |         public string CommandId { get; set; }
 9 |         public DateTime Timestamp { get; set; } = DateTime.Now;
10 |         public string MessageType { get; set; }
11 |         public Dictionary<string, object> Context { get; set; }
12 |         public TBody Body { get; set; }
13 |     }
14 |     public class Message : Message<byte[]>
15 |     {
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/Basf/Properties/PublishProfiles/FolderProfile.pubxml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <!--
 3 | This file is used by the publish/package process of your Web project. You can customize the behavior of this process
 4 | by editing this MSBuild file. In order to learn more about this please visit https://go.microsoft.com/fwlink/?LinkID=208121. 
 5 | -->
 6 | <Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
 7 |   <PropertyGroup>
 8 |     <PublishProtocol>FileSystem</PublishProtocol>
 9 |     <Configuration>Release</Configuration>
10 |     <TargetFramework>net45</TargetFramework>
11 |     <PublishDir>bin\Release\PublishOutput</PublishDir>
12 |   </PropertyGroup>
13 | </Project>


--------------------------------------------------------------------------------
/Basf/Serializing/IBinarySerializer.cs:
--------------------------------------------------------------------------------
1 | namespace Basf.Serializing
2 | {
3 |     public interface IBinarySerializer: ISerializer<byte[]>
4 |     {       
5 |     }
6 | }
7 | 


--------------------------------------------------------------------------------
/Basf/Serializing/IJsonSerializer.cs:
--------------------------------------------------------------------------------
1 | namespace Basf.Serializing
2 | {
3 |     public interface IJsonSerializer : ISerializer<string>
4 |     {
5 |     }
6 | }
7 | 


--------------------------------------------------------------------------------
/Basf/Serializing/ISerializer.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | 
 3 | namespace Basf.Serializing
 4 | {
 5 |     public interface ISerializer<T>
 6 |     {
 7 |         T Serialize(object obj);
 8 |         object Deserialize(T value, Type type);
 9 |         TObject Deserialize<TObject>(T value) where TObject : class;
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/Basf/Utilities/CityHash.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | #if !COREFX
  3 | using System.Runtime;
  4 | #endif
  5 | using System.Runtime.CompilerServices;
  6 | using System.Text;
  7 | 
  8 | namespace Basf.Utilities
  9 | {
 10 |     /// <summary>
 11 |     /// CityHash provides hash functions for stringsThe functions mix the
 12 |     /// input bits thoroughly but are not suitable for cryptography.
 13 |     /// </summary>
 14 |     /// <remarks>
 15 |     /// This class can be inherited and it exposes some internal functions (if you want to have fun)
 16 |     /// </remarks>
 17 |     public class CityHash
 18 |     {
 19 |         #region 私有常量
 20 |         // Some primes between 2^63 and 2^64 for various uses.
 21 |         private const ulong k0 = 0xc3a5c85c97cb3127UL;
 22 |         private const ulong k1 = 0xb492b66fbe98f273UL;
 23 |         private const ulong k2 = 0x9ae16a3b2f90404fUL;
 24 | 
 25 |         // Magic numbers for 32-bit hashing Copied from Murmur3.
 26 |         private const uint c1 = 0xcc9e2d51;
 27 |         private const uint c2 = 0x1b873593;
 28 |         #endregion
 29 | 
 30 |         #region 公共方法
 31 |         /// <summary>
 32 |         /// Computes a 32-bit city hash for the specified string.
 33 |         /// </summary>
 34 |         /// <param name="value">The string value.</param>
 35 |         /// <returns>A 32-bit city hash.</returns>
 36 |         /// <remarks>This function encodes the string using the unicode block (ISO/IEC 8859-1).</remarks>
 37 |         public static uint CityHash32(string value)
 38 |         {
 39 |             return CityHash32(Encoding.GetEncoding("ISO-8859-1").GetBytes(value));
 40 |         }
 41 |         /// <summary>
 42 |         /// Computes the 64-bit city hash for the specified string.
 43 |         /// </summary>
 44 |         /// <param name="value">The string value.</param>
 45 |         /// <returns>The 64-bit city hash.</returns>
 46 |         /// <remarks>This function encodes the string using the unicode block (ISO/IEC 8859-1).</remarks>
 47 |         public static ulong CityHash64(string value)
 48 |         {
 49 |             return CityHash64(Encoding.GetEncoding("ISO-8859-1").GetBytes(value));
 50 |         }
 51 |         /// <summary>
 52 |         /// Computes the 64-bit city hash for the specified string and seed.
 53 |         /// </summary>
 54 |         /// <param name="value">The string value.</param>
 55 |         /// <param name="seed">The seed used by the algorithm.</param>
 56 |         /// <returns>The 64-bit city hash.</returns>
 57 |         /// <remarks>This function encodes the string using the unicode block (ISO/IEC 8859-1).</remarks>
 58 |         public static ulong CityHash64(string value, ulong seed)
 59 |         {
 60 |             return CityHash64(Encoding.GetEncoding("ISO-8859-1").GetBytes(value), k2, seed);
 61 |         }
 62 |         /// <summary>
 63 |         /// Computes the 64-bit city hash for the specified string and seed.
 64 |         /// </summary>
 65 |         /// <param name="value">The string value.</param>
 66 |         /// <param name="seed0">The low-order 64-bits seed used by the algorithm.</param>
 67 |         /// <param name="seed1">The high-order 64-bits seed used by the algorithm.</param>
 68 |         /// <returns>The 64-bit city hash.</returns>
 69 |         /// <remarks>This function encodes the string using the unicode block (ISO/IEC 8859-1).</remarks>
 70 |         public static ulong CityHash64(string value, ulong seed0, ulong seed1)
 71 |         {
 72 |             return CityHash64(Encoding.GetEncoding("ISO-8859-1").GetBytes(value), seed0, seed1);
 73 |         }
 74 |         /// <summary>
 75 |         /// Computes the 128-bit city hash and are tuned for strings of at least a few hundred bytes.
 76 |         /// </summary>
 77 |         /// <param name="value">The string value.</param>
 78 |         /// <returns>The 128-bit city hash.</returns>
 79 |         /// <remarks>This function encodes the string using the unicode block (ISO/IEC 8859-1).</remarks>
 80 | #if !COREFX
 81 |         [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries.")]
 82 | #endif
 83 |         public static uint128 CityHash128(string value)
 84 |         {
 85 |             return CityHash128(Encoding.GetEncoding("ISO-8859-1").GetBytes(value));
 86 |         }
 87 |         /// <summary>
 88 |         /// Computes the 128-bit city hash and are tuned for strings of at least a few hundred bytes using 
 89 |         /// the specified <paramref name="seed"/>.
 90 |         /// </summary>
 91 |         /// <param name="value">The string value.</param>
 92 |         /// <param name="seed">The seed used by the city hash algorithm.</param>
 93 |         /// <returns>The 128-bit city hash.</returns>
 94 |         /// <remarks>This function encodes the string using the unicode block (ISO/IEC 8859-1).</remarks>
 95 | #if !COREFX
 96 |         [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries.")]
 97 | #endif
 98 |         public static uint128 CityHash128(string value, uint128 seed)
 99 |         {
100 |             return CityHash128(Encoding.GetEncoding("ISO-8859-1").GetBytes(value), seed, 0);
101 |         }
102 |         #endregion
103 | 
104 |         #region 私有方法
105 |         /// <summary>
106 |         /// A 32-bit to 32-bit integer hash copied from Murmur3.
107 |         /// </summary>
108 |         private static uint FMix(uint h)
109 |         {
110 |             h ^= h >> 16;
111 |             h *= 0x85ebca6b;
112 |             h ^= h >> 13;
113 |             h *= 0xc2b2ae35;
114 |             h ^= h >> 16;
115 |             return h;
116 |         }
117 |         /// <summary>
118 |         /// Bitwise right rotate
119 |         /// Normally this will compile to a single instruction, especially if the shift is a manifest constant.
120 |         /// </summary>
121 | #if !COREFX
122 |     [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries.")]
123 | #endif
124 |         private static ulong Rotate(ulong val, int shift)
125 |         {
126 |             // Avoid shifting by 64: doing so yields an undefined result.
127 |             return shift == 0 ? val : ((val >> shift) | (val << (64 - shift)));
128 |         }
129 | #if !COREFX
130 |     [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries.")]
131 | #endif
132 |         private static uint Rotate32(uint value, int shift)
133 |         {
134 |             return shift == 0 ? value : ((value >> shift) | (value << (32 - shift)));
135 |         }
136 |         [MethodImpl(MethodImplOptions.AggressiveInlining)]
137 |         private static uint Mur(uint a, uint h)
138 |         {
139 |             // Helper from Murmur3 for combining two 32-bit values.
140 |             a *= c1;
141 |             a = Rotate32(a, 17);
142 |             a *= c2;
143 |             h ^= a;
144 |             h = Rotate32(h, 19);
145 |             return h * 5 + 0xe6546b64;
146 |         }
147 | #if !COREFX
148 |         [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries.")]
149 | #endif
150 |         private static uint BSwap32(uint value)
151 |         {
152 |             return
153 |                 (value >> 24) |
154 |                 (value & 0x00ff0000) >> 8 |
155 |                 (value & 0x0000ff00) << 8 |
156 |                 (value << 24);
157 |         }
158 | #if !COREFX
159 |         [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries.")]
160 | #endif
161 |         private static ulong BSwap64(ulong value)
162 |         {
163 |             return
164 |                 (value >> 56) |
165 |                 (value & 0x00ff000000000000) >> 40 |
166 |                 (value & 0x0000ff0000000000) >> 24 |
167 |                 (value & 0x000000ff00000000) >> 8 |
168 |                 (value & 0x00000000ff000000) << 8 |
169 |                 (value & 0x0000000000ff0000) << 24 |
170 |                 (value & 0x000000000000ff00) << 40 |
171 |                 (value << 56);
172 |         }
173 |         /// <summary>
174 |         /// Returns a 32-bit unsigned integer converted from four bytes at a specified position in a byte array.
175 |         /// </summary>
176 |         /// <param name="value">An array of bytes.</param>
177 |         /// <param name="index">The starting position within value.</param>
178 |         /// <returns>A 32-bit unsigned integer formed by four bytes beginning at <paramref name="index"/>.</returns>
179 |         [MethodImpl(MethodImplOptions.AggressiveInlining)]
180 | #if !COREFX
181 |         [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries.")]
182 | #endif
183 |         private static uint Fetch32(byte[] value, int index = 0)
184 |         {
185 |             return BitConverter.ToUInt32(value, index);
186 |         }
187 |         /// <summary>
188 |         /// Returns a 32-bit unsigned integer converted from four bytes at a specified position in a byte array.
189 |         /// </summary>
190 |         /// <param name="value">An array of bytes.</param>
191 |         /// <param name="index">The starting position within value.</param>
192 |         /// <returns>A 32-bit unsigned integer formed by four bytes beginning at <paramref name="index"/>.</returns>
193 |         [MethodImpl(MethodImplOptions.AggressiveInlining)]
194 | #if !COREFX
195 |         [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries.")]
196 | #endif
197 |         private static uint Fetch32(byte[] value, uint index = 0)
198 |         {
199 |             return BitConverter.ToUInt32(value, (int)index);
200 |         }
201 |         /// <summary>
202 |         /// Returns a 64-bit unsigned integer converted from eight bytes at a specified position in a byte array.
203 |         /// </summary>
204 |         /// <param name="value">An array of bytes.</param>
205 |         /// <param name="index">The starting position within <paramref name="value"/>.</param>
206 |         /// <returns>A 64-bit unsigned integer formed by the eight bytes beginning at <paramref name="index"/>.</returns>
207 | #if !COREFX
208 |         [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries.")]
209 | #endif
210 |         private static ulong Fetch64(byte[] value, int index = 0)
211 |         {
212 |             return BitConverter.ToUInt64(value, index);
213 |         }
214 |         [MethodImpl(MethodImplOptions.AggressiveInlining)]
215 |         private static uint Hash32Len0to4(byte[] value)
216 |         {
217 |             var l = (uint)value.Length;
218 |             var b = 0u;
219 |             var c = 9u;
220 |             for (var i = 0; i < l; i++)
221 |             {
222 |                 b = b * c1 + (uint)((sbyte)value[i]);
223 |                 c ^= b;
224 |             }
225 |             return FMix(Mur(b, Mur(l, c)));
226 |         }
227 |         [MethodImpl(MethodImplOptions.AggressiveInlining)]
228 |         private static uint Hash32Len5to12(byte[] value)
229 |         {
230 |             uint a = (uint)value.Length, b = a * 5, c = 9, d = b;
231 | 
232 |             a += Fetch32(value, 0);
233 |             b += Fetch32(value, value.Length - 4);
234 |             c += Fetch32(value, (value.Length >> 1) & 4);
235 | 
236 |             return FMix(Mur(c, Mur(b, Mur(a, d))));
237 |         }
238 |         [MethodImpl(MethodImplOptions.AggressiveInlining)]
239 |         private static uint Hash32Len13to24(byte[] value)
240 |         {
241 |             var a = Fetch32(value, (value.Length >> 1) - 4);
242 |             var b = Fetch32(value, 4);
243 |             var c = Fetch32(value, value.Length - 8);
244 |             var d = Fetch32(value, value.Length >> 1);
245 |             var e = Fetch32(value, 0);
246 |             var f = Fetch32(value, value.Length - 4);
247 |             var h = (uint)value.Length;
248 | 
249 |             return FMix(Mur(f, Mur(e, Mur(d, Mur(c, Mur(b, Mur(a, h)))))));
250 |         }
251 |         [MethodImpl(MethodImplOptions.AggressiveInlining)]
252 | #if !COREFX
253 |         [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries.")]
254 | #endif
255 |         private static void Permute3<T>(ref T a, ref T b, ref T c)
256 |         {
257 |             var temp = a;
258 |             a = c; c = b; b = temp;
259 |         }
260 | #if !COREFX
261 |         [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries.")]
262 | #endif
263 |         private static ulong ShiftMix(ulong val)
264 |         {
265 |             return val ^ (val >> 47);
266 |         }
267 | #if !COREFX
268 |         [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries.")]
269 | #endif
270 |         private static void Swap<T>(ref T a, ref T b)
271 |         {
272 |             var temp = a;
273 |             a = b;
274 |             b = temp;
275 |         }
276 |         /// <summary>
277 |         /// A subroutine for CityHash128() Returns a decent 128-bit hash for strings
278 |         /// of any length representable in signed long Based on City and Murmur.
279 |         /// </summary>
280 |         [MethodImpl(MethodImplOptions.AggressiveInlining)]
281 |         protected static uint128 CityMurmur(byte[] value, uint128 seed, int offset)
282 |         {
283 |             var a = seed.Low;
284 |             var b = seed.High;
285 |             ulong c;
286 |             ulong d;
287 | 
288 |             var len = value.Length - offset;
289 |             var l = len - 16;
290 | 
291 |             if (l <= 0)
292 |             {  // len <= 16
293 |                 a = ShiftMix(a * k1) * k1;
294 |                 c = b * k1 + HashLen0to16(value, offset);
295 |                 d = ShiftMix(a + (len >= 8 ? Fetch64(value, offset) : c));
296 |             }
297 |             else
298 |             {  // len > 16
299 | 
300 |                 c = HashLen16(Fetch64(value, offset + len - 8) + k1, a);
301 |                 d = HashLen16(b + (ulong)len, c + Fetch64(value, offset + len - 16));
302 |                 a += d;
303 | 
304 |                 var p = offset;
305 |                 do
306 |                 {
307 |                     a ^= ShiftMix(Fetch64(value, p) * k1) * k1;
308 |                     a *= k1;
309 |                     b ^= a;
310 |                     c ^= ShiftMix(Fetch64(value, p + 8) * k1) * k1;
311 |                     c *= k1;
312 |                     d ^= c;
313 | 
314 |                     p += 16;
315 |                     l -= 16;
316 |                 } while (l > 0);
317 | 
318 |             }
319 |             a = HashLen16(a, c);
320 |             b = HashLen16(d, b);
321 |             return new uint128(a ^ b, HashLen16(b, a));
322 |         }
323 |         /// <summary>
324 |         /// Computes a 32-bit city hash for the given encoded string.
325 |         /// </summary>
326 |         /// <param name="value">The string value.</param>
327 |         /// <returns>A 32-bit city hash.</returns>
328 |         /// <exception cref="System.ArgumentNullException">value</exception>
329 |         /// <remarks>
330 |         /// The city hash is designed to compute hash for STRINGs only! 
331 |         /// The city hash "works" with other types of data, but keep in mind it was not built for it.
332 |         /// </remarks>
333 |         protected internal static uint CityHash32(byte[] value)
334 |         {
335 |             if (value == null)
336 |                 throw new ArgumentNullException("value");
337 | 
338 |             var len = (uint)value.Length;
339 | 
340 |             if (len <= 4)
341 |                 return Hash32Len0to4(value);
342 | 
343 |             if (len <= 12)
344 |                 return Hash32Len5to12(value);
345 | 
346 |             if (len <= 24)
347 |                 return Hash32Len13to24(value);
348 | 
349 |             // len > 24
350 |             uint h = len, g = c1 * len, f = g;
351 |             {
352 |                 uint a0 = Rotate32(Fetch32(value, len - 4) * c1, 17) * c2;
353 |                 uint a1 = Rotate32(Fetch32(value, len - 8) * c1, 17) * c2;
354 |                 uint a2 = Rotate32(Fetch32(value, len - 16) * c1, 17) * c2;
355 |                 uint a3 = Rotate32(Fetch32(value, len - 12) * c1, 17) * c2;
356 |                 uint a4 = Rotate32(Fetch32(value, len - 20) * c1, 17) * c2;
357 | 
358 |                 h ^= a0;
359 |                 h = Rotate32(h, 19);
360 |                 h = h * 5 + 0xe6546b64;
361 |                 h ^= a2;
362 |                 h = Rotate32(h, 19);
363 |                 h = h * 5 + 0xe6546b64;
364 | 
365 |                 g ^= a1;
366 |                 g = Rotate32(g, 19);
367 |                 g = g * 5 + 0xe6546b64;
368 |                 g ^= a3;
369 |                 g = Rotate32(g, 19);
370 |                 g = g * 5 + 0xe6546b64;
371 | 
372 |                 f += a4;
373 |                 f = Rotate32(f, 19);
374 |                 f = f * 5 + 0xe6546b64;
375 |             }
376 | 
377 |             for (var i = 0; i < (len - 1) / 20; i++)
378 |             {
379 |                 var a0 = Rotate32(Fetch32(value, 20 * i) * c1, 17) * c2;
380 |                 var a1 = Fetch32(value, 20 * i + 4);
381 |                 var a2 = Rotate32(Fetch32(value, 20 * i + 8) * c1, 17) * c2;
382 |                 var a3 = Rotate32(Fetch32(value, 20 * i + 12) * c1, 17) * c2;
383 |                 var a4 = Fetch32(value, 20 * i + 16);
384 | 
385 |                 h ^= a0;
386 |                 h = Rotate32(h, 18);
387 |                 h = h * 5 + 0xe6546b64;
388 | 
389 |                 f += a1;
390 |                 f = Rotate32(f, 19);
391 |                 f = f * c1;
392 | 
393 |                 g += a2;
394 |                 g = Rotate32(g, 18);
395 |                 g = g * 5 + 0xe6546b64;
396 | 
397 |                 h ^= a3 + a1;
398 |                 h = Rotate32(h, 19);
399 |                 h = h * 5 + 0xe6546b64;
400 | 
401 |                 g ^= a4;
402 |                 g = BSwap32(g) * 5;
403 | 
404 |                 h += a4 * 5;
405 |                 h = BSwap32(h);
406 | 
407 |                 f += a0;
408 | 
409 |                 Permute3(ref f, ref h, ref g);
410 |             }
411 | 
412 |             g = Rotate32(g, 11) * c1;
413 |             g = Rotate32(g, 17) * c1;
414 | 
415 |             f = Rotate32(f, 11) * c1;
416 |             f = Rotate32(f, 17) * c1;
417 | 
418 |             h = Rotate32(h + g, 19);
419 |             h = h * 5 + 0xe6546b64;
420 |             h = Rotate32(h, 17) * c1;
421 | 
422 |             h = Rotate32(h + f, 19);
423 |             h = h * 5 + 0xe6546b64;
424 |             h = Rotate32(h, 17) * c1;
425 | 
426 |             return h;
427 |         }
428 |         /// <summary>
429 |         /// Computes the 64-bit city hash for the encoded string.
430 |         /// </summary>
431 |         /// <param name="value">The encoded string.</param>
432 |         /// <returns>The 64-bit city hash.</returns>
433 |         /// <remarks>
434 |         /// The city hash is designed to compute hash for STRINGs only! 
435 |         /// The city hash "works" with other types of data, but keep in mind it was not built for it.
436 |         /// </remarks>
437 |         protected internal static ulong CityHash64(byte[] value)
438 |         {
439 |             if (value.Length <= 16)
440 |                 return HashLen0to16(value);
441 | 
442 |             if (value.Length <= 32)
443 |                 return HashLen17to32(value);
444 | 
445 |             if (value.Length <= 64)
446 |                 return HashLen33to64(value);
447 | 
448 |             // For strings over 64 bytes we hash the end first, and then as we
449 |             // loop we keep 56 bytes of state: v, w, x, y, and z.
450 | 
451 |             var x = Fetch64(value, value.Length - 40);
452 |             var y = Fetch64(value, value.Length - 16) + Fetch64(value, value.Length - 56);
453 |             var z = HashLen16(
454 |                 Fetch64(value, value.Length - 48) + (ulong)value.Length,
455 |                 Fetch64(value, value.Length - 24));
456 | 
457 |             var v = WeakHashLen32WithSeeds(value, value.Length - 64, (ulong)value.Length, z);
458 |             var w = WeakHashLen32WithSeeds(value, value.Length - 32, y + k1, x);
459 | 
460 |             x = x * k1 + Fetch64(value);
461 | 
462 |             // Decrease len to the nearest multiple of 64, and operate on 64-byte chunks.
463 | 
464 |             var pos = 0;
465 |             var len = (value.Length) - 1 & ~63;
466 |             do
467 |             {
468 |                 x = Rotate(x + y + v.Low + Fetch64(value, pos + 8), 37) * k1;
469 |                 y = Rotate(y + v.High + Fetch64(value, pos + 48), 42) * k1;
470 |                 x ^= w.High;
471 |                 y += v.Low + Fetch64(value, pos + 40);
472 |                 z = Rotate(z + w.Low, 33) * k1;
473 |                 v = WeakHashLen32WithSeeds(value, pos, v.High * k1, x + w.Low);
474 |                 w = WeakHashLen32WithSeeds(value, pos + 32, z + w.High, y + Fetch64(value, pos + 16));
475 |                 Swap(ref z, ref x);
476 | 
477 |                 pos += 64;
478 |                 len -= 64;
479 |             } while (len != 0);
480 | 
481 |             return HashLen16(HashLen16(v.Low, w.Low) + ShiftMix(y) * k1 + z, HashLen16(v.High, w.High) + x);
482 |         }
483 |         /// <summary>
484 |         /// Computes the 64-bit city hash for the specified string and seed.
485 |         /// </summary>
486 |         /// <param name="value">The encoded string.</param>
487 |         /// <param name="seed">The seed used by the algorithm.</param>
488 |         /// <returns>The 64-bit city hash.</returns>
489 |         protected static ulong CityHash64(byte[] value, ulong seed)
490 |         {
491 |             return CityHash64(value, k2, seed);
492 |         }
493 |         /// <summary>
494 |         /// Computes the 64-bit city hash for the specified string and seed.
495 |         /// </summary>
496 |         /// <param name="value">The encoded string.</param>
497 |         /// <param name="seed0">The low-order 64-bits seed used by the algorithm.</param>
498 |         /// <param name="seed1">The high-order 64-bits seed used by the algorithm.</param>
499 |         /// <returns>The 64-bit city hash.</returns>
500 |         protected static ulong CityHash64(byte[] value, ulong seed0, ulong seed1)
501 |         {
502 |             return HashLen16(CityHash64(value) - seed0, seed1);
503 |         }
504 |         /// <summary>
505 |         /// Computes a 128-bit city hash for the given encoded string.
506 |         /// </summary>
507 |         /// <param name="value">The encoded string.</param>
508 |         /// <returns>The 128-bit city hash.</returns>
509 |         /// <remarks>
510 |         /// The city hash is designed to compute hash for STRINGs only! 
511 |         /// The city hash "works" with other types of data, but keep in mind it was not built for it.
512 |         /// </remarks>
513 | #if !COREFX
514 |         [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries.")]
515 | #endif
516 |         protected static uint128 CityHash128(byte[] value)
517 |         {
518 |             return value.Length >= 16
519 |                 ? CityHash128(value, new uint128(Fetch64(value), Fetch64(value, 8) + k0), 16)
520 |                 : CityHash128(value, new uint128(k0, k1), 0);
521 |         }
522 |         /// <summary>
523 |         /// Computes the 128-bit city hash and are tuned for strings of at least a few hundred bytes using 
524 |         /// the specified <paramref name="seed"/> starting at a <paramref name="offset"/> position.
525 |         /// </summary>
526 |         /// <param name="value">The encoded string.</param>
527 |         /// <param name="seed">The seed used by the hash alrorithm.</param>
528 |         /// <param name="offset">The offset position in the byte array.</param>
529 |         /// <returns>The 128-bit city hash.</returns>
530 |         /// <remarks>
531 |         /// The city hash is designed to compute hash for STRINGs only! 
532 |         /// The city hash "works" with other types of data, but keep in mind it was not built for it.
533 |         /// </remarks>
534 |         [MethodImpl(MethodImplOptions.AggressiveInlining)]
535 |         protected static uint128 CityHash128(byte[] value, uint128 seed, int offset)
536 |         {
537 |             if (value.Length - offset < 128)
538 |                 return CityMurmur(value, seed, offset);
539 | 
540 |             // We expect len >= 128 to be the common case Keep 56 bytes of state:
541 |             // v, w, x, y, and z.
542 |             var len = value.Length - offset;
543 |             var x = seed.Low;
544 |             var y = seed.High;
545 |             var z = (ulong)len * k1;
546 |             var v = new uint128
547 |             {
548 |                 Low = Rotate(seed.High ^ k1, 49) * k1 + Fetch64(value, offset)
549 |             };
550 |             v.High = Rotate(v.Low, 42) * k1 + Fetch64(value, offset + 8);
551 | 
552 |             var w = new uint128
553 |             {
554 |                 Low = Rotate(y + z, 35) * k1 + x,
555 |                 High = Rotate(seed.Low + Fetch64(value, offset + 88), 53) * k1
556 |             };
557 | 
558 | 
559 |             // This is the same inner loop as CityHash64(), manually unrolled.
560 |             var s = offset;
561 |             do
562 |             {
563 |                 x = Rotate(x + y + v.Low + Fetch64(value, s + 8), 37) * k1;
564 |                 y = Rotate(y + v.High + Fetch64(value, s + 48), 42) * k1;
565 |                 x ^= w.High;
566 |                 y += v.Low + Fetch64(value, s + 40);
567 |                 z = Rotate(z + w.Low, 33) * k1;
568 |                 v = WeakHashLen32WithSeeds(value, s, v.High * k1, x + w.Low);
569 |                 w = WeakHashLen32WithSeeds(value, s + 32, z + w.High, y + Fetch64(value, s + 16));
570 | 
571 |                 Swap(ref z, ref x);
572 | 
573 |                 s += 64;
574 | 
575 |                 x = Rotate(x + y + v.Low + Fetch64(value, s + 8), 37) * k1;
576 |                 y = Rotate(y + v.High + Fetch64(value, s + 48), 42) * k1;
577 |                 x ^= w.High;
578 |                 y += v.Low + Fetch64(value, s + 40);
579 |                 z = Rotate(z + w.Low, 33) * k1;
580 |                 v = WeakHashLen32WithSeeds(value, s, v.High * k1, x + w.Low);
581 |                 w = WeakHashLen32WithSeeds(value, s + 32, z + w.High, y + Fetch64(value, s + 16));
582 | 
583 |                 Swap(ref z, ref x);
584 | 
585 |                 s += 64;
586 |                 len -= 128;
587 |             } while (len >= 128);
588 | 
589 |             x += Rotate(v.Low + z, 49) * k0;
590 |             y = y * k0 + Rotate(w.High, 37);
591 |             z = z * k0 + Rotate(w.Low, 27);
592 |             w.Low *= 9;
593 |             v.Low *= k0;
594 | 
595 |             // If 0 < len < 128, hash up to 4 chunks of 32 bytes each from the end of s.
596 |             for (var tail = 0; tail < len;)
597 |             {
598 |                 tail += 32;
599 | 
600 |                 y = Rotate(x + y, 42) * k0 + v.High;
601 |                 w.Low += Fetch64(value, s + len - tail + 16);
602 |                 x = x * k0 + w.Low;
603 |                 z += w.High + Fetch64(value, s + len - tail);
604 |                 w.High += v.Low;
605 |                 v = WeakHashLen32WithSeeds(value, s + len - tail, v.Low + z, v.High);
606 |                 v.Low *= k0;
607 |             }
608 | 
609 | 
610 |             // At this point our 56 bytes of state should contain more than
611 |             // enough information for a strong 128-bit hash We use two
612 |             // different 56-byte-to-8-byte hashes to get a 16-byte final result.
613 |             x = HashLen16(x, v.Low);
614 |             y = HashLen16(y + z, w.Low);
615 | 
616 |             return new uint128
617 |             {
618 |                 Low = HashLen16(x + v.High, w.High) + y,
619 |                 High = HashLen16(x + w.High, y + v.High)
620 |             };
621 |         }
622 |         [MethodImpl(MethodImplOptions.AggressiveInlining)]
623 |         private static ulong HashLen16(ulong u, ulong v)
624 |         {
625 |             return Hash128to64(new uint128(u, v));
626 |         }
627 |         [MethodImpl(MethodImplOptions.AggressiveInlining)]
628 |         private static ulong HashLen16(ulong u, ulong v, ulong mul)
629 |         {
630 |             // Murmur-inspired hashing.
631 |             var a = (u ^ v) * mul;
632 |             a ^= (a >> 47);
633 |             var b = (v ^ a) * mul;
634 |             b ^= (b >> 47);
635 |             b *= mul;
636 |             return b;
637 |         }
638 |         [MethodImpl(MethodImplOptions.AggressiveInlining)]
639 |         private static ulong HashLen0to16(byte[] value, int offset = 0)
640 |         {
641 |             var len = (uint)(value.Length - offset);
642 | 
643 |             if (len >= 8)
644 |             {
645 | 
646 |                 var mul = k2 + (ulong)len * 2;
647 |                 var a = Fetch64(value, offset) + k2;
648 |                 var b = Fetch64(value, value.Length - 8);
649 |                 var c = Rotate(b, 37) * mul + a;
650 |                 var d = (Rotate(a, 25) + b) * mul;
651 | 
652 |                 return HashLen16(c, d, mul);
653 |             }
654 | 
655 |             if (len >= 4)
656 |             {
657 |                 var mul = k2 + (ulong)len * 2;
658 |                 ulong a = Fetch32(value, offset);
659 |                 return HashLen16(len + (a << 3), Fetch32(value, (int)(offset + len - 4)), mul);
660 |             }
661 | 
662 |             if (len > 0)
663 |             {
664 |                 var a = value[offset];
665 |                 var b = value[offset + (len >> 1)];
666 |                 var c = value[offset + (len - 1)];
667 | 
668 |                 var y = a + ((uint)b << 8);
669 |                 var z = len + ((uint)c << 2);
670 | 
671 |                 return ShiftMix((y * k2 ^ z * k0)) * k2;
672 |             }
673 | 
674 |             return k2;
675 |         }
676 |         /// <summary>
677 |         /// This probably works well for 16-byte strings as well, but it may be overkill in that case.
678 |         /// </summary>
679 |         [MethodImpl(MethodImplOptions.AggressiveInlining)]
680 |         private static ulong HashLen17to32(byte[] value)
681 |         {
682 |             var len = (ulong)value.Length;
683 | 
684 |             var mul = k2 + len * 2ul;
685 |             var a = Fetch64(value) * k1;
686 |             var b = Fetch64(value, 8);
687 |             var c = Fetch64(value, value.Length - 8) * mul;
688 |             var d = Fetch64(value, value.Length - 16) * k2;
689 | 
690 |             return HashLen16(Rotate(a + b, 43) + Rotate(c, 30) + d, a + Rotate(b + k2, 18) + c, mul);
691 |         }
692 |         /// <summary>
693 |         /// Return an 8-byte hash for 33 to 64 bytes.
694 |         /// </summary>
695 |         [MethodImpl(MethodImplOptions.AggressiveInlining)]
696 |         private static UInt64 HashLen33to64(byte[] value)
697 |         {
698 |             var mul = k2 + (ulong)value.Length * 2ul;
699 |             var a = Fetch64(value) * k2;
700 |             var b = Fetch64(value, 8);
701 |             var c = Fetch64(value, value.Length - 24);
702 |             var d = Fetch64(value, value.Length - 32);
703 |             var e = Fetch64(value, 16) * k2;
704 |             var f = Fetch64(value, 24) * 9;
705 |             var g = Fetch64(value, value.Length - 8);
706 |             var h = Fetch64(value, value.Length - 16) * mul;
707 | 
708 |             var u = Rotate(a + g, 43) + (Rotate(b, 30) + c) * 9;
709 |             var v = ((a + g) ^ d) + f + 1;
710 |             var w = BSwap64((u + v) * mul) + h;
711 |             var x = Rotate(e + f, 42) + c;
712 |             var y = (BSwap64((v + w) * mul) + g) * mul;
713 |             var z = e + f + c;
714 | 
715 |             a = BSwap64((x + z) * mul + y) + b;
716 |             b = ShiftMix((z + a) * mul + d + h) * mul;
717 |             return b + x;
718 |         }
719 |         [MethodImpl(MethodImplOptions.AggressiveInlining)]
720 |         private static ulong Hash128to64(uint128 x)
721 |         {
722 |             const ulong kMul = 0x9ddfea08eb382d69UL;
723 | 
724 |             var a = (x.Low ^ x.High) * kMul;
725 |             a ^= (a >> 47);
726 | 
727 |             var b = (x.High ^ a) * kMul;
728 |             b ^= (b >> 47);
729 |             b *= kMul;
730 | 
731 |             return b;
732 |         }
733 |         /// <summary>
734 |         /// Return a 16-byte hash for 48 bytesQuick and dirty.
735 |         /// Callers do best to use "random-looking" values for a and b.
736 |         /// </summary>
737 |         private static uint128 WeakHashLen32WithSeeds(ulong w, ulong x, ulong y, ulong z, ulong a, ulong b)
738 |         {
739 |             a += w;
740 |             b = Rotate(b + a + z, 21);
741 | 
742 |             var c = a;
743 |             a += x;
744 |             a += y;
745 | 
746 |             b += Rotate(a, 44);
747 | 
748 |             return new uint128(a + z, b + c);
749 |         }
750 | #if !COREFX
751 |         [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries.")]
752 | #endif
753 |         private static uint128 WeakHashLen32WithSeeds(byte[] value, int offset, ulong a, ulong b)
754 |         {
755 |             return WeakHashLen32WithSeeds(
756 |                 Fetch64(value, offset),
757 |                 Fetch64(value, offset + 8),
758 |                 Fetch64(value, offset + 16),
759 |                 Fetch64(value, offset + 24),
760 |                 a,
761 |                 b);
762 |         }
763 |         #endregion
764 |     }
765 | }


--------------------------------------------------------------------------------
/Basf/Utilities/uint128.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | 
 3 | namespace Basf.Utilities
 4 | {
 5 |     /// <summary>
 6 |     /// Represents a 128-bit unsigned integer.
 7 |     /// </summary>
 8 |     public struct uint128 : IEquatable<uint128>
 9 |     {
10 |         /// <summary>
11 |         /// Initializes a new instance of the <see cref="T:uint128"/> struct.
12 |         /// </summary>
13 |         public uint128(ulong low, ulong high)
14 |             : this()
15 |         {
16 |             Low = low;
17 |             High = high;
18 |         }
19 |         /// <summary>
20 |         /// Gets or sets the low-order 64-bits.
21 |         /// </summary>
22 |         /// <value>The low-order 64-bits.</value>
23 |         public ulong Low { get; set; }
24 |         /// <summary>
25 |         /// Gets or sets the high-order 64-bits.
26 |         /// </summary>
27 |         /// <value>The high-order 64-bits.</value>
28 |         public ulong High { get; set; }
29 |         /// <summary>
30 |         /// Indicates whether the current object is equal to another object of the same type.
31 |         /// </summary>
32 |         /// <returns>
33 |         /// true if the current object is equal to the <paramref name="other"/> parameter; otherwise, false.
34 |         /// </returns>
35 |         /// <param name="other">An object to compare with this object.</param>
36 |         public bool Equals(uint128 other)
37 |         {
38 |             return Low == other.Low && High == other.High;
39 |         }
40 |         /// <summary>
41 |         /// Indicates whether this instance and a specified object are equal.
42 |         /// </summary>
43 |         /// <returns>
44 |         /// true if <paramref name="obj"/> and this instance are the same type and represent the same value; otherwise, false.
45 |         /// </returns>
46 |         /// <param name="obj">Another object to compare to. </param>
47 |         public override bool Equals(object obj)
48 |         {
49 |             if (ReferenceEquals(null, obj)) return false;
50 |             return obj is uint128 && Equals((uint128)obj);
51 |         }
52 |         /// <summary>
53 |         /// Returns the hash code for this instance.
54 |         /// </summary>
55 |         /// <returns>
56 |         /// A 32-bit signed integer that is the hash code for this instance.
57 |         /// </returns>
58 |         public override int GetHashCode()
59 |         {
60 |             unchecked
61 |             {
62 |                 return (Low.GetHashCode() * 397) ^ High.GetHashCode();
63 |             }
64 |         }
65 |     }
66 | }


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # Basf
2 | 一个DDD+CQRS+Event Sourcing通用框架的接口，可以很容易的结合各种现有成熟框架来搭建。CQRS可以结合Orleans，Akka.net等Actor框架封装实现。
3 | 目前支持.NET 4.61+,.NET Standard1.6+。
4 | 
5 | 


--------------------------------------------------------------------------------