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