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); }