public static void AddEventServer(IEventServer eventServer)
{
lock (serviceLock)
{
var exposedTypes = Discovery.GetTypesFromAttribute(typeof(ServiceExposedAttribute));
foreach (var type in exposedTypes)
{
if (type.IsClass)
{
if (TypeAnalyzer.GetTypeDetail(type).Interfaces.Any(x => x == typeof(IEvent)))
{
var interfaceStack = ProviderLayers.GetProviderInterfaceStack();
var hasHandler = Discovery.HasImplementationType(TypeAnalyzer.GetGenericType(typeof(IEventHandler <>), type), interfaceStack, interfaceStack.Length - 1);
if (hasHandler)
{
if (eventClients.Keys.Contains(type))
{
throw new InvalidOperationException($"Cannot create loopback. Event Client already registered for type {type.GetNiceName()}");
}
if (!eventServerTypes.Contains(type))
{
eventServerTypes.Add(type);
}
eventServer.RegisterEventType(type);
}
}
}
}
eventServer.SetHandler(HandleRemoteEventDispatchAsync);
eventServers.Add(eventServer);
eventServer.Open();
}
}
public override Type Generate(Type type)
{
var aggregateTypeDetails = TypeAnalyzer.GetTypeDetail(aggregateType);
if (!aggregateTypeDetails.BaseTypes.Contains(aggregateRootType))
{
throw new Exception($"{nameof(TransactStoreEntityAttribute)} {nameof(aggregateType)} argument {type.Name} does not inherit {aggregateRootType.Name}");
}
var typeDetail = TypeAnalyzer.GetTypeDetail(type);
if (!typeDetail.BaseTypes.Contains(dataContextType))
{
throw new Exception($"{nameof(TransactStoreEntityAttribute)} is not placed on a {dataContextType.Name}");
}
var baseType = TypeAnalyzer.GetGenericType(eventProviderType, type, aggregateType);
var typeSignature = $"{aggregateType.Name}_{type.Name}_Provider";
var moduleBuilder = GeneratedAssembly.GetModuleBuilder();
var typeBuilder = moduleBuilder.DefineType(typeSignature, TypeAttributes.Public | TypeAttributes.Class | TypeAttributes.AutoClass | TypeAttributes.AnsiClass | TypeAttributes.BeforeFieldInit | TypeAttributes.AutoLayout, baseType);
_ = typeBuilder.DefineDefaultConstructor(MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName);
var objectType = typeBuilder.CreateTypeInfo();
return(objectType);
}
private static Task HandleEventAsync(IEvent @event, Type eventType, bool throwError)
{
Type interfaceType = TypeAnalyzer.GetGenericType(iEventHandlerType, eventType);
var providerType = Discovery.GetImplementationType(interfaceType, ProviderLayers.GetProviderInterfaceStack(), 0, throwError);
if (providerType == null)
{
return(Task.CompletedTask);
}
var method = TypeAnalyzer.GetMethodDetail(providerType, nameof(IEventHandler <IEvent> .Handle), new Type[] { eventType });
var provider = Instantiator.GetSingleInstance(providerType);
var task = (Task)method.Caller(provider, new object[] { @event });
LogMessage(eventType, @event);
return(task);
}
private static Task HandleCommandAsync(ICommand command, Type commandType, bool throwError)
{
var interfaceType = TypeAnalyzer.GetGenericType(iCommandHandlerType, commandType);
var providerType = Discovery.GetImplementationType(interfaceType, ProviderLayers.GetProviderInterfaceStack(), 0, throwError);
if (providerType == null)
{
return(Task.CompletedTask);
}
var method = TypeAnalyzer.GetMethodDetail(providerType, nameof(ICommandHandler <ICommand> .Handle), new Type[] { commandType });
var provider = Instantiator.GetSingleInstance(providerType);
var task = (Task)method.Caller(provider, new object[] { command });
LogMessage(commandType, command);
return(task);
}
private IEventStoreEngine GetEngine()
{
if (engineCache == null)
{
lock (engineCacheLock)
{
if (engineCache == null)
{
var aggregateType = GetAggregateType();
var iEventStoreContextProviderType = typeof(IAggregateRootContextProvider <>);
var iEventStoreContextProviderGenericType = TypeAnalyzer.GetGenericType(iEventStoreContextProviderType, aggregateType);
var providerType = Discovery.GetImplementationType(iEventStoreContextProviderGenericType);
var provider = (IContextProvider)Instantiator.CreateInstance(providerType);
var context = provider.GetContext();
engineCache = context.InitializeEngine <IEventStoreEngine>();
}
}
}
return(engineCache);
}
public static Task DispatchAsync(IEvent message)
{
Type messageType = message.GetType();
var messageTypeInfo = TypeAnalyzer.GetTypeDetail(messageType);
if (commandClients.Count > 0)
{
//Not a local call so apply cache layer at Bus level
var handlerType = TypeAnalyzer.GetGenericType(iEventHandlerType, messageType);
var providerCacheType = Discovery.GetImplementationType(handlerType, iCacheProviderType, false);
if (providerCacheType != null)
{
var methodSetNextProvider = TypeAnalyzer.GetMethodDetail(providerCacheType, nameof(BaseLayerProvider <IBaseProvider> .SetNextProvider));
if (methodSetNextProvider != null)
{
var providerCache = Instantiator.GetSingleInstance($"{providerCacheType.FullName}_Bus.DispatchAsync_Cache", () =>
{
var instance = Instantiator.CreateInstance(providerCacheType);
var methodGetProviderInterfaceType = TypeAnalyzer.GetMethodDetail(providerCacheType, nameof(BaseLayerProvider <IBaseProvider> .GetProviderInterfaceType));
Type interfaceType = (Type)methodGetProviderInterfaceType.Caller(instance, null);
object messageHandlerToDispatchProvider = BusRouters.GetEventHandlerToDispatchInternalInstance(interfaceType);
methodSetNextProvider.Caller(instance, new object[] { messageHandlerToDispatchProvider });
return(instance);
});
var method = TypeAnalyzer.GetMethodDetail(providerCacheType, nameof(IEventHandler <IEvent> .Handle), new Type[] { messageType });
method.Caller(providerCache, new object[] { message });
return(Task.CompletedTask);
}
}
}
return(_DispatchEventInternalAsync(message, messageType));
}
private static Type Generate(MemberInfo memberInfo, CoreType?coreType, bool isByteArray)
{
var interfaceType = TypeAnalyzer.GetGenericType(iCoreTypeSetterType, memberInfo.ReflectedType);
string typeSignature = $"{interfaceType.FullName}_{memberInfo.Name}_CoreTypeSetterGenerator";
var moduleBuilder = GeneratedAssembly.GetModuleBuilder();
var typeBuilder = moduleBuilder.DefineType(typeSignature, TypeAttributes.Public | TypeAttributes.Class | TypeAttributes.AutoClass | TypeAttributes.AnsiClass | TypeAttributes.BeforeFieldInit | TypeAttributes.AutoLayout, null);
typeBuilder.AddInterfaceImplementation(interfaceType);
_ = typeBuilder.DefineDefaultConstructor(MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName);
var methods = interfaceType.GetMethods().ToList();
var properties = interfaceType.GetProperties().ToList();
foreach (var @interface in interfaceType.GetInterfaces())
{
methods.AddRange(@interface.GetMethods());
properties.AddRange(@interface.GetProperties());
}
foreach (var method in methods)
{
if (method.Name.StartsWith("get_") || method.Name.StartsWith("set_"))
{
continue;
}
Type[] parameterTypes = method.GetParameters().Select(x => x.ParameterType).ToArray();
var methodBuilder = typeBuilder.DefineMethod(
method.Name,
MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.NewSlot | MethodAttributes.Virtual | MethodAttributes.Final,
CallingConventions.HasThis,
null,
parameterTypes
);
methodBuilder.SetImplementationFlags(MethodImplAttributes.Managed);
var il = methodBuilder.GetILGenerator();
CoreType?methodCoreType;
bool methodIsByteArray;
if (TypeLookup.CoreTypeLookup(parameterTypes[1], out CoreType coreTypeLookup))
{
methodCoreType = coreTypeLookup;
methodIsByteArray = false;
}
else
{
methodCoreType = null;
methodIsByteArray = parameterTypes[1] == byteArrayType;
}
if (coreType == methodCoreType && isByteArray == methodIsByteArray)
{
if (memberInfo.MemberType == MemberTypes.Property)
{
var propertyInfo = (PropertyInfo)memberInfo;
var setMethod = propertyInfo.GetSetMethod(true);
if (!setMethod.IsStatic)
{
il.Emit(OpCodes.Ldarg_1);
}
il.Emit(OpCodes.Ldarg_2);
if (setMethod.IsFinal || !setMethod.IsVirtual)
{
il.Emit(OpCodes.Call, setMethod);
}
else
{
il.Emit(OpCodes.Callvirt, setMethod);
}
il.Emit(OpCodes.Ret);
}
else if (memberInfo.MemberType == MemberTypes.Field)
{
var fieldInfo = (FieldInfo)memberInfo;
if (!fieldInfo.IsStatic)
{
il.Emit(OpCodes.Ldarg_1);
if (fieldInfo.ReflectedType.IsValueType)
{
il.Emit(OpCodes.Unbox, fieldInfo.ReflectedType);
}
}
il.Emit(OpCodes.Ldarg_2);
if (!fieldInfo.IsStatic)
{
il.Emit(OpCodes.Stfld, fieldInfo);
}
else
{
il.Emit(OpCodes.Stsfld, fieldInfo);
}
il.Emit(OpCodes.Ret);
}
else
{
throw new NotImplementedException();
}
}
else
{
il.Emit(OpCodes.Newobj, notSupportedExceptionConstructor);
il.Emit(OpCodes.Throw);
}
typeBuilder.DefineMethodOverride(methodBuilder, method);
}
foreach (var property in properties)
{
var propertyBuilder = typeBuilder.DefineProperty(
property.Name,
PropertyAttributes.HasDefault,
property.PropertyType,
null
);
var getMethodName = "get_" + property.Name;
var getMethodBuilder = typeBuilder.DefineMethod(
getMethodName,
MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig | MethodAttributes.NewSlot | MethodAttributes.Virtual | MethodAttributes.Final,
property.PropertyType,
Type.EmptyTypes
);
var getMethodBuilderIL = getMethodBuilder.GetILGenerator();
if (property.Name == nameof(ICoreTypeSetter <object> .CoreType))
{
if (coreType.HasValue)
{
getMethodBuilderIL.Emit(OpCodes.Ldc_I4, (int)coreType.Value);
getMethodBuilderIL.Emit(OpCodes.Newobj, coreTypeNullableConstructor);
}
else
{
getMethodBuilderIL.Emit(OpCodes.Ldnull);
}
}
else if (property.Name == nameof(ICoreTypeSetter <object> .IsByteArray))
{
if (isByteArray)
{
getMethodBuilderIL.Emit(OpCodes.Ldc_I4_1);
}
else
{
getMethodBuilderIL.Emit(OpCodes.Ldc_I4_0);
}
}
else
{
throw new NotImplementedException();
}
getMethodBuilderIL.Emit(OpCodes.Ret);
var getMethod = methods.FirstOrDefault(x => x.Name == getMethodName);
typeBuilder.DefineMethodOverride(getMethodBuilder, getMethod);
propertyBuilder.SetGetMethod(getMethodBuilder);
}
Type objectType = typeBuilder.CreateTypeInfo();
return(objectType);
}
public override Type Generate(Type type)
{
var entityTypeDetail = TypeAnalyzer.GetTypeDetail(entityType);
if (!entityTypeDetail.Attributes.Select(x => x.GetType()).Contains(entityAttributeType))
{
throw new Exception($"{nameof(TransactStoreEntityAttribute)} {nameof(entityType)} argument {type.Name} does not inherit {entityAttributeType.Name}");
}
var typeDetail = TypeAnalyzer.GetTypeDetail(type);
if (!typeDetail.BaseTypes.Contains(dataContextType))
{
throw new Exception($"{nameof(TransactStoreEntityAttribute)} is not placed on a {dataContextType.Name}");
}
var baseType = TypeAnalyzer.GetGenericType(providerType, type, entityType);
var typeSignature = $"{entityType.Name}_{type.Name}_Provider";
var moduleBuilder = GeneratedAssembly.GetModuleBuilder();
var typeBuilder = moduleBuilder.DefineType(typeSignature, TypeAttributes.Public | TypeAttributes.Class | TypeAttributes.AutoClass | TypeAttributes.AnsiClass | TypeAttributes.BeforeFieldInit | TypeAttributes.AutoLayout, baseType);
_ = typeBuilder.DefineDefaultConstructor(MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName);
var properties = new HashSet <Tuple <PropertyInfo, bool> >();
var transactProviderTypeDetails = TypeAnalyzer.GetTypeDetail(baseType);
var methods = transactProviderTypeDetails.MethodDetails.Select(x => x.MethodInfo).ToArray();
if (eventLinking.HasValue)
{
var eventLinkingProperty = transactProviderTypeDetails.GetMember("EventLinking");
properties.Add(new Tuple <PropertyInfo, bool>((PropertyInfo)eventLinkingProperty.MemberInfo, eventLinking.Value));
}
if (queryLinking.HasValue)
{
var queryLinkingProperty = transactProviderTypeDetails.GetMember("QueryLinking");
properties.Add(new Tuple <PropertyInfo, bool>((PropertyInfo)queryLinkingProperty.MemberInfo, queryLinking.Value));
}
if (persistLinking.HasValue)
{
var eventLinkingProperty = transactProviderTypeDetails.GetMember("PersistLinking");
properties.Add(new Tuple <PropertyInfo, bool>((PropertyInfo)eventLinkingProperty.MemberInfo, persistLinking.Value));
}
foreach (var prop in properties)
{
var property = prop.Item1;
var value = prop.Item2;
var propertyBuilder = typeBuilder.DefineProperty(
property.Name,
PropertyAttributes.HasDefault,
property.PropertyType,
null
);
var getMethodName = "get_" + property.Name;
var getMethod = methods.FirstOrDefault(x => x.Name == getMethodName);
var getMethodBuilder = typeBuilder.DefineMethod(
getMethodName,
MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig | MethodAttributes.ReuseSlot | MethodAttributes.Virtual | MethodAttributes.Final,
property.PropertyType,
Type.EmptyTypes
);
var getMethodBuilderIL = getMethodBuilder.GetILGenerator();
if (value)
{
getMethodBuilderIL.Emit(OpCodes.Ldc_I4_1);
}
else
{
getMethodBuilderIL.Emit(OpCodes.Ldc_I4_0);
}
getMethodBuilderIL.Emit(OpCodes.Ret);
typeBuilder.DefineMethodOverride(getMethodBuilder, getMethod);
propertyBuilder.SetGetMethod(getMethodBuilder);
}
var objectType = typeBuilder.CreateTypeInfo();
return(objectType);
}
