bool TryGenerate(TypeDefinition typeDef, List <DiagnosticMessage> diagnosticMessages)
        {
            var type = Type.GetType($"{typeDef.FullName}, {module.Assembly.FullName}");

            if (type == null || !NeedsInjectType(type))
            {
                return(false);
            }

            InjectTypeInfo injectTypeInfo;

            try
            {
                injectTypeInfo = TypeAnalyzer.Analyze(type);
            }
            catch (Exception ex)
            {
                diagnosticMessages.Add(new DiagnosticMessage
                {
                    DiagnosticType = DiagnosticType.Warning,
                    MessageData    = $"Failed to analyze {type.FullName} : {ex.Message}"
                });
                return(false);
            }

            GenerateInnerInjectorType(typeDef, injectTypeInfo);
            return(true);
        }
Пример #2
0
        TReturn IQueryClient.Call <TReturn>(Type interfaceType, string methodName, object[] arguments)
        {
            try
            {
                var returnType = typeof(TReturn);

                var returnTypeDetails = TypeAnalyzer.GetTypeDetail(returnType);

                if (returnTypeDetails.IsTask)
                {
                    var isStream = returnTypeDetails.InnerTypeDetails[0].BaseTypes.Contains(streamType);
                    var callRequestMethodGeneric = TypeAnalyzer.GetGenericMethodDetail(callRequestAsyncMethod, returnTypeDetails.InnerTypes.ToArray());
                    return((TReturn)callRequestMethodGeneric.Caller(this, new object[] { isStream, interfaceType, methodName, arguments }));
                }
                else
                {
                    var isStream = returnTypeDetails.BaseTypes.Contains(streamType);
                    var model    = CallInternal <TReturn>(isStream, interfaceType, methodName, arguments);
                    return(model);
                }
            }
            catch (Exception ex)
            {
                _ = Log.ErrorAsync($"Call Failed", ex);
                throw;
            }
        }
Пример #3
0
    private static string GenerateNiceName(Type type, bool ns)
    {
        var sb = new StringBuilder();

        var typeDetails = TypeAnalyzer.GetTypeDetail(type);

        if (ns && !String.IsNullOrWhiteSpace(type.Namespace))
        {
            sb.Append(type.Namespace).Append('.');
        }

        if (type.IsArray)
        {
            var rank            = type.GetArrayRank();
            var elementType     = typeDetails.InnerTypes[0];
            var elementTypeName = elementType.GetNiceName();
            sb.Append(elementTypeName);
            sb.Append('[');
            var getter  = GetTypeGetIsZSArrayGetter();
            var szArray = getter != null && (bool)getter(type);
            if (!szArray)
            {
                if (rank == 1)
                {
                    sb.Append('*');
                }
                else if (rank > 1)
                {
                    for (var i = 0; i < rank - 1; i++)
                    {
                        sb.Append(',');
                    }
                }
            }
            sb.Append(']');
        }
        else
        {
            sb.Append(type.Name);

            if (type.IsGenericType)
            {
                var genericTypes = typeDetails.InnerTypes;
                sb.Append('[');
                bool first = true;
                foreach (var genericType in genericTypes)
                {
                    if (!first)
                    {
                        sb.Append(',');
                    }
                    first = false;
                    sb.Append(genericType.GetNiceFullName());
                }
                sb.Append(']');
            }
        }

        return(sb.ToString());
    }
Пример #4
0
        public static object Call(Type interfaceType)
        {
            var callerProvider = BusRouters.GetProviderToCallInternalInstance(interfaceType);

            if (queryClients.Count > 0)
            {
                if (queryClients.Keys.Contains(interfaceType))
                {
                    //Not a local call so apply cache layer at Bus level
                    var providerCacheType = Discovery.GetImplementationType(interfaceType, iCacheProviderType, false);
                    if (providerCacheType != null)
                    {
                        var methodSetNextProvider = TypeAnalyzer.GetMethodDetail(providerCacheType, nameof(BaseLayerProvider <IBaseProvider> .SetNextProvider)).MethodInfo;
                        if (methodSetNextProvider != null)
                        {
                            var providerCache = Instantiator.GetSingleInstance($"{providerCacheType.FullName}_Bus.Call_Cache", () =>
                            {
                                var instance = Instantiator.CreateInstance(providerCacheType);
                                methodSetNextProvider.Invoke(instance, new object[] { callerProvider });
                                return(instance);
                            });

                            return(providerCache);
                        }
                    }
                }
            }

            return(callerProvider);
        }
Пример #5
0
        private static object GetGeneric(Type type, Type providerInterfaceType, bool throwException)
        {
            var genericMethodProviderManagerTryGet = TypeAnalyzer.GetGenericMethodDetail(methodProviderManagerGet, type);
            var provider = genericMethodProviderManagerTryGet.Caller(providerInterfaceType, new object[] { providerInterfaceType, throwException });

            return(provider);
        }
        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);
        }
Пример #7
0
        public void AnalyzeCombinedConstructor()
        {
            var injectTypeInfo = TypeAnalyzer.Analyze(typeof(HasInjectAndNoInjectConstructor));

            Assert.That(injectTypeInfo.InjectConstructor.ConstructorInfo.GetCustomAttribute <InjectAttribute>(), Is.Not.Null);
            Assert.That(injectTypeInfo.InjectConstructor.ConstructorInfo.GetParameters().Length, Is.EqualTo(1));
        }
Пример #8
0
        public void should_correctly_identify_generic_collection(Type collectionType, bool shouldMatch)
        {
            var typeAnalyzer        = new TypeAnalyzer();
            var isGenericCollection = typeAnalyzer.IsGenericCollection(collectionType);

            Assert.Equal(isGenericCollection, shouldMatch);
        }
Пример #9
0
 public InitializationManager(TypeAnalyzer typeAnalyzer,
                              PrimitiveExpressionGenerator primitiveExpressionGenerator,
                              DictionaryExpressionGenerator dictionaryExpressionGenerator,
                              ComplexTypeInitializationGenerator complexTypeInitializationGenerator,
                              ArrayInitializationGenerator arrayInitializationGenerator,
                              AssignmentExpressionGenerator assignmentExpressionGenerator,
                              ArgumentListManager argumentListManager,
                              EnumExpressionGenerator enumExpressionGenerator,
                              ImmutableInitializationGenerator immutableInitializationGenerator,
                              ObjectInicializationExpressionGenerator objectInicializationExpressionGenerator,
                              GuidInitializationManager guidInitializationManager,
                              RegexInitializationManager regexInitializationManager,
                              PrimitiveNullableExpressionGenerator primitiveNullableExpressionGenerator)
 {
     _typeAnalyzer = typeAnalyzer;
     _primitiveExpressionGenerator       = primitiveExpressionGenerator;
     _dictionaryExpressionGenerator      = dictionaryExpressionGenerator;
     _complexTypeInitializationGenerator = complexTypeInitializationGenerator;
     _arrayInitializationGenerator       = arrayInitializationGenerator;
     _assignmentExpressionGenerator      = assignmentExpressionGenerator;
     _argumentListManager                     = argumentListManager;
     _enumExpressionGenerator                 = enumExpressionGenerator;
     _immutableInitializationGenerator        = immutableInitializationGenerator;
     _objectInicializationExpressionGenerator = objectInicializationExpressionGenerator;
     _guidInitializationManager               = guidInitializationManager;
     _regexInitializationManager              = regexInitializationManager;
     _primitiveNullableExpressionGenerator    = primitiveNullableExpressionGenerator;
 }
Пример #10
0
 public void AnalyzeDuplicateAttributeConstructor()
 {
     Assert.Throws <VContainerException>(() =>
     {
         TypeAnalyzer.Analyze(typeof(HasMultipleInjectConstructor));
     });
 }
Пример #11
0
        TReturn IQueryClient.Call <TReturn>(Type interfaceType, string methodName, object[] arguments)
        {
            var providerName    = interfaceType.Name;
            var stringArguments = arguments.Select(x => JsonSerializer.Serialize(x)).ToArray();

            var returnType = typeof(TReturn);

            var data = new CQRSRequestData()
            {
                ProviderType   = providerName,
                ProviderMethod = methodName,
            };

            data.AddProviderArguments(arguments);

            var returnTypeDetails = TypeAnalyzer.GetTypeDetail(returnType);

            if (returnTypeDetails.IsTask)
            {
                var callRequestAsyncMethodGeneric = TypeAnalyzer.GetGenericMethodDetail(requestAsyncMethod, returnTypeDetails.InnerTypes.ToArray());
                return((TReturn)callRequestAsyncMethodGeneric.Caller(this, new object[] { endpointAddress, providerName, requestContentType, data, true }));
            }
            else
            {
                var model = Request <TReturn>(endpointAddress, providerName, requestContentType, data, true);
                return(model);
            }
        }
Пример #12
0
        private static Task Dispatch(CQRSRequestData data)
        {
            var commandType = Discovery.GetTypeFromName(data.MessageType);
            var typeDetail  = TypeAnalyzer.GetTypeDetail(commandType);

            if (!typeDetail.Interfaces.Contains(typeof(ICommand)))
            {
                throw new Exception($"Type {data.MessageType} is not a command");
            }

            bool exposed = typeDetail.Attributes.Any(x => x is ServiceExposedAttribute attribute && (!attribute.NetworkType.HasValue || attribute.NetworkType == NetworkType.Api)) &&
                           !typeDetail.Attributes.Any(x => x is ServiceBlockedAttribute attribute && (!attribute.NetworkType.HasValue || attribute.NetworkType == NetworkType.Api));

            if (!exposed)
            {
                throw new Exception($"Command {data.MessageType} is not exposed to {NetworkType.Api}");
            }

            var command = (ICommand)JsonSerializer.Deserialize(data.MessageData, commandType);

            if (data.MessageAwait)
            {
                return(Bus.HandleRemoteCommandDispatchAwaitAsync(command));
            }
            else
            {
                return(Bus.HandleRemoteCommandDispatchAsync(command));
            }
        }
Пример #13
0
        private static Task <RemoteQueryCallResponse> Call(CQRSRequestData data)
        {
            var providerType = Discovery.GetTypeFromName(data.ProviderType);

            if (!providerType.IsInterface)
            {
                throw new ArgumentException($"Provider {data.ProviderType} is not an interface type");
            }

            var  typeDetail = TypeAnalyzer.GetTypeDetail(providerType);
            bool exposed    = typeDetail.Attributes.Any(x => x is ServiceExposedAttribute attribute && (!attribute.NetworkType.HasValue || attribute.NetworkType == NetworkType.Api)) &&
                              !typeDetail.Attributes.Any(x => x is ServiceBlockedAttribute attribute && (attribute.NetworkType == NetworkType.Api || !attribute.NetworkType.HasValue));

            MethodBase method = null;

            foreach (var methodInfo in typeDetail.MethodDetails)
            {
                if (methodInfo.MethodInfo.Name == data.ProviderMethod && methodInfo.ParametersInfo.Count == (data.ProviderArguments != null ? data.ProviderArguments.Length : 0))
                {
                    if (!exposed && (!methodInfo.Attributes.Any(x => x is ServiceExposedAttribute attribute && (!attribute.NetworkType.HasValue || attribute.NetworkType == NetworkType.Api)) || methodInfo.Attributes.Any(x => x is ServiceBlockedAttribute attribute && (!attribute.NetworkType.HasValue || attribute.NetworkType == NetworkType.Api))))
                    {
                        throw new Exception($"Method {data.ProviderType}.{data.ProviderMethod} is not exposed to {NetworkType.Api}");
                    }
                    method = methodInfo.MethodInfo;
                    break;
                }
            }
            if (method == null)
            {
                throw new Exception($"Method {data.ProviderType}.{data.ProviderMethod} does not exsist");
            }

            return(Bus.HandleRemoteQueryCallAsync(providerType, data.ProviderMethod, data.ProviderArguments));
        }
Пример #14
0
        public static Type GetHighestProviderInterface(Type providerType)
        {
            if (providerType == null)
            {
                throw new ArgumentNullException(nameof(providerType));
            }
            var highestProviderInterface = highestProviderInterfaces.GetOrAdd(providerType, (t) =>
            {
                Type highest         = null;
                var providerTypeInfo = TypeAnalyzer.GetTypeDetail(t);

                foreach (var providerInterface in providerInterfaceLayersStack)
                {
                    foreach (var thisInterface in providerTypeInfo.Interfaces)
                    {
                        if (providerInterface == thisInterface)
                        {
                            highest = providerInterface;
                            break;
                        }
                    }
                    if (highest != null)
                    {
                        break;
                    }
                }
                return(highest);
            });

            return(highestProviderInterface);
        }
Пример #15
0
        private Task ApplyEvent(IEvent @event, Type eventType)
        {
            var methodDetail = methodCache.GetOrAdd(eventType, (t) =>
            {
                var aggregateType         = GetAggregateType();
                var aggregateTypeDetail   = TypeAnalyzer.GetTypeDetail(aggregateType);
                MethodDetail methodDetail = null;
                foreach (var method in aggregateTypeDetail.MethodDetails)
                {
                    if (!method.MethodInfo.IsStatic && method.ParametersInfo.Count == 1 && method.ParametersInfo[0].ParameterType == t)
                    {
                        if (methodDetail != null)
                        {
                            throw new Exception($"Multiple aggregate event methods found in {aggregateType.Name} to accept {t.Name}");
                        }
                        methodDetail = method;
                    }
                }
                if (methodDetail == null)
                {
                    throw new Exception($"No aggregate event methods found in {aggregateType.Name} to accept {t.Name}");
                }
                return(methodDetail);
            });

            return(methodDetail.CallerAsync(this, new object[] { @event }));
        }
        public void GetAllInstancesWithInjectSplit(
            InjectContext context, List <TypeValuePair> args, out Action injectAction, List <object> buffer)
        {
            Assert.IsEmpty(args);
            Assert.IsNotNull(context);

            Assert.That(typeof(TReturn).DerivesFromOrEqual(context.MemberType));

            injectAction = null;
            if (_container.IsValidating && !TypeAnalyzer.ShouldAllowDuringValidation(context.MemberType))
            {
                buffer.Add(new ValidationMarker(typeof(TReturn)));
            }
            else
            {
                var result = _method(context);

                if (result == null)
                {
                    throw Assert.CreateException(
                              "Method '{0}' returned null when list was expected. Object graph:\n {1}",
                              _method.ToDebugString(), context.GetObjectGraphString());
                }

                foreach (var obj in result)
                {
                    buffer.Add(obj);
                }
            }
        }
        public void collectTypeInfo(string path)
        {
            TypeAnalyzer analyzer = new TypeAnalyzer();

            analyzer.AddFileColeection(path);
            analyzer.AnalyzeFiles();
        }
Пример #18
0
        public void should_correctly_identify_implemented_generic_dictionary(Type collectionType, bool shouldMatch)
        {
            var typeAnalyzer        = new TypeAnalyzer();
            var isGenericCollection = typeAnalyzer.HasImplementedGenericDictionary(collectionType);

            Assert.Equal(isGenericCollection, shouldMatch);
        }
 public void ConstructDependency()
 {
     foreach (string filepath in files_)
     {
         Semi semi = new Semi();
         if (!semi.open(filepath))
         {
             Console.WriteLine("Cannot open file {0}", filepath);
             continue;
         }
         string filename = TypeAnalyzer.Filename(filepath);
         //Console.WriteLine(" - Processing file {0}", filename);
         BuildDependencyAnalyzer depAnalyzer = new BuildDependencyAnalyzer(semi, filename);
         Parser depParser = depAnalyzer.build();
         //Console.WriteLine("Size of graph: {0}", graph_.Count);
         try
         {
             while (semi.get().Count > 0)
             {
                 depParser.parse(semi);
             }
         }
         catch (Exception ex)
         {
             Console.Write("\n\n  {0}\n", ex.Message);
         }
     }
 }
Пример #20
0
        public void TypeAnalysis_CLRType_Int64()
        {
            // create syntax tree
            var syntaxTree = CSharpSyntaxTree.ParseText(@"
public class Test
{
    public long Id { get; set; }
}");

            // create compilation
            var compilation = RoslynTestHelpers.CreateTestCompilation(new[] { syntaxTree });

            // extract symbol
            var typeSymbol = RoslynTestHelpers.ExtractPropertyType(compilation, syntaxTree);

            // analyze
            var context  = new TestAnalysisContext(compilation);
            var analyzer = new TypeAnalyzer(context);

            var csTypeModel = analyzer.AnalyzeType(typeSymbol);

            // assert
            var expected = new CSharpTypeModel()
            {
                Name        = "Int64",
                TypeKind    = CSharpTypeKind.Struct,
                SpecialType = CSharpSpecialType.System_Int64
            };

            Assert.AreEqual(expected.Name, csTypeModel.Name);
            Assert.AreEqual(expected.TypeKind, csTypeModel.TypeKind);
            Assert.AreEqual(expected.SpecialType, csTypeModel.SpecialType);
        }
Пример #21
0
        public void GetAllInstancesWithInjectSplit(
            InjectContext context, List <TypeValuePair> args, out Action injectAction, List <object> buffer)
        {
            Assert.IsEmpty(args);
            Assert.IsNotNull(context);

            injectAction = null;
            if (_container.IsValidating && !TypeAnalyzer.ShouldAllowDuringValidation(context.MemberType))
            {
                buffer.Add(new ValidationMarker(context.MemberType));
            }
            else
            {
                var result = _method(context);

                if (result == null)
                {
                    Assert.That(!context.MemberType.IsPrimitive(),
                                "Invalid value returned from FromMethod.  Expected non-null.");
                }
                else
                {
                    Assert.That(result.GetType().DerivesFromOrEqual(context.MemberType));
                }

                buffer.Add(result);
            }
        }
Пример #22
0
        protected IReadOnlyList <IRegistration> BuildRegistrations()
        {
            var registrations = new IRegistration[registrationBuilders.Count + (ContainerExposed ? 1 : 0)];

#if VCONTAINER_PARALLEL_CONTAINER_BUILD
            Parallel.For(0, registrationBuilders.Count, i =>
            {
                registrations[i] = registrationBuilders[i].Build();
            });
#else
            for (var i = 0; i < registrationBuilders.Count; i++)
            {
                registrations[i] = registrationBuilders[i].Build();
            }
#endif
            if (ContainerExposed)
            {
                registrations[registrations.Length - 1] = ContainerRegistration.Default;
            }

#if VCONTAINER_PARALLEL_CONTAINER_BUILD
            Parallel.For(0, registrations.Count, i =>
            {
                TypeAnalyzer.CheckCircularDependency(registrations[i].ImplementationType);
            });
#else
            foreach (var x in registrations)
            {
                TypeAnalyzer.CheckCircularDependency(x.ImplementationType);
            }
#endif
            return(registrations);
        }
Пример #23
0
        public virtual void ProcessDeleteRequest <T>(CommandDefinition <T> commandDefinition) where T : class
        {
            var type             = CheckCommandConditions(commandDefinition, "delete");
            var entityTypeResult = EntityCache.GetEntity(type) ?? TypeAnalyzer.AnalyzeType(type);
            var keyColumns       = GetKeyColumns(type);

            if (!keyColumns.Any())
            {
                throw new ArgumentException("At least one key column property must be defined.");
            }

            var sql        = new StringBuilder();
            var parameters = new List <KeyValuePair <string, object> >();

            sql.Append("DELETE FROM ");
            sql.AppendLine(entityTypeResult.TableName);
            AppendWhereCondition(new WhereCondition
            {
                Query      = sql,
                TableName  = entityTypeResult.TableName,
                Parameters = parameters,
                Properties = keyColumns
            },
                                 commandDefinition.Entity);

            commandDefinition.UpdateCommand(sql.ToString(), parameters);
        }
        protected IReadOnlyList <IRegistration> BuildRegistrations()
        {
#if VCONTAINER_PARALLEL_CONTAINER_BUILD
            var a = new IRegistration[registrationBuilders.Count];
            Parallel.For(0, registrationBuilders.Count, i =>
            {
                a[i] = registrationBuilders[i].Build();
            });

            var registrations = new List <IRegistration>(a);
#else
            var registrations = new List <IRegistration>(registrationBuilders.Count);
            foreach (var registrationBuilder in registrationBuilders)
            {
                registrations.Add(registrationBuilder.Build());
            }
#endif

#if VCONTAINER_PARALLEL_CONTAINER_BUILD
            Parallel.For(0, registrations.Count, i =>
            {
                TypeAnalyzer.CheckCircularDependency(registrations[i].ImplementationType);
            });
#else
            foreach (var x in registrations)
            {
                TypeAnalyzer.CheckCircularDependency(x.ImplementationType);
            }
#endif
            if (containerRegistered)
            {
                registrations.Add(ContainerRegistration.Default);
            }
            return(registrations);
        }
Пример #25
0
        public static Graph Convert(Graph graph, Type type)
        {
            var   constructor  = TypeAnalyzer.GetGenericTypeDetail(typeof(Graph <>), type).GetConstructor(new Type[] { typeof(Graph) });
            Graph genericGraph = (Graph)constructor.Creator(new object[] { graph });

            return(genericGraph);
        }
Пример #26
0
        public static void AddQueryServer(IQueryServer queryServer)
        {
            lock (serviceLock)
            {
                var exposedTypes = Discovery.GetTypesFromAttribute(typeof(ServiceExposedAttribute));
                foreach (var type in exposedTypes)
                {
                    if (type.IsInterface && TypeAnalyzer.GetTypeDetail(type).Interfaces.Any(x => x == typeof(IBaseProvider)))
                    {
                        var interfaceStack    = ProviderLayers.GetProviderInterfaceStack();
                        var hasImplementation = Discovery.HasImplementationType(type, interfaceStack, interfaceStack.Length - 1);
                        if (hasImplementation)
                        {
                            if (queryClients.Keys.Contains(type))
                            {
                                throw new InvalidOperationException($"Cannot create loopback. Query Client already registered for type {type.GetNiceName()}");
                            }
                            if (!queryServerTypes.Contains(type))
                            {
                                queryServerTypes.Add(type);
                            }
                            queryServer.RegisterInterfaceType(type);
                        }
                    }
                }

                queryServer.SetHandler(HandleRemoteQueryCallAsync);
                queryServers.Add(queryServer);
                queryServer.Open();
            }
        }
Пример #27
0
 /// <summary>
 /// Extracts type information from the typeless rewritten programs.
 /// </summary>
 /// <param name="host"></param>
 /// <param name="ivs"></param>
 public void ReconstructTypes()
 {
     if (Project is null)
     {
         return;
     }
     foreach (var program in Project.Programs.Where(p => p.NeedsTypeReconstruction))
     {
         var analyzer = new TypeAnalyzer(eventListener);
         try
         {
             analyzer.RewriteProgram(program);
         }
         catch (Exception ex)
         {
             eventListener.Error(
                 new NullCodeLocation(program.Location.FilesystemPath),
                 ex,
                 "An internal error occurred while reconstructing data types in {0}.",
                 program.Location);
         }
         finally
         {
             host.WriteTypes(program, analyzer.WriteTypes);
         }
     }
 }
Пример #28
0
        public static TReturn _CallInternal <TInterface, TReturn>(string methodName, object[] arguments) where TInterface : IBaseProvider
        {
            var interfaceType = typeof(TInterface);

            if (queryClients.Count > 0)
            {
                if (queryClients.TryGetValue(interfaceType, out IQueryClient methodCaller))
                {
                    var result = methodCaller.Call <TReturn>(interfaceType, methodName, arguments);
                    return(result);
                }
            }

            var provider      = Resolver.Get <TInterface>();
            var methodDetails = TypeAnalyzer.GetMethodDetail(interfaceType, methodName);

            if (methodDetails.ParametersInfo.Count != (arguments != null ? arguments.Length : 0))
            {
                throw new ArgumentException("Invalid number of arguments for this method");
            }

            var localresult = (TReturn)methodDetails.Caller(provider, arguments);

            return(localresult);
        }
Пример #29
0
        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();
            }
        }
Пример #30
0
        public static async Task <RemoteQueryCallResponse> HandleRemoteQueryCallAsync(Type interfaceType, string method, string[] arguments)
        {
            var callerProvider = Call(interfaceType);
            var methodDetails  = TypeAnalyzer.GetMethodDetail(interfaceType, method);

            if (methodDetails.ParametersInfo.Count != (arguments != null ? arguments.Length : 0))
            {
                throw new ArgumentException("Invalid number of arguments for this method");
            }

            var returnTypeDetail = methodDetails.ReturnType;

            var args = new object[arguments != null ? arguments.Length : 0];

            if (arguments != null && arguments.Length > 0)
            {
                int i = 0;
                foreach (var argument in arguments)
                {
                    var parameter = JsonSerializer.Deserialize(argument, methodDetails.ParametersInfo[i].ParameterType);
                    args[i] = parameter;
                    i++;
                }
            }

            bool   isStream;
            object model;

            if (returnTypeDetail.IsTask)
            {
                isStream = returnTypeDetail.InnerTypeDetails[0].BaseTypes.Contains(streamType);
                var   result = (Task)methodDetails.Caller(callerProvider, args);
                await result;

                if (returnTypeDetail.Type.IsGenericType)
                {
                    model = returnTypeDetail.TaskResultGetter(result);
                }
                else
                {
                    model = null;
                }
            }
            else
            {
                isStream = returnTypeDetail.BaseTypes.Contains(streamType);
                model    = methodDetails.Caller(callerProvider, args);
            }

            if (isStream)
            {
                return(new RemoteQueryCallResponse((Stream)model));
            }
            else
            {
                return(new RemoteQueryCallResponse(model));
            }
        }