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); }
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; } }
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()); }
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); }
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); }
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)); }
public void should_correctly_identify_generic_collection(Type collectionType, bool shouldMatch) { var typeAnalyzer = new TypeAnalyzer(); var isGenericCollection = typeAnalyzer.IsGenericCollection(collectionType); Assert.Equal(isGenericCollection, shouldMatch); }
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; }
public void AnalyzeDuplicateAttributeConstructor() { Assert.Throws <VContainerException>(() => { TypeAnalyzer.Analyze(typeof(HasMultipleInjectConstructor)); }); }
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); } }
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)); } }
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)); }
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); }
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(); }
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); } } }
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); }
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); } }
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); }
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); }
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); }
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(); } }
/// <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); } } }
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); }
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 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)); } }