/// <summary>
/// Support version 0.0.6 before
/// </summary>
/// <param name="method"></param>
/// <param name="parameter"></param>
/// <param name="namespaceName"></param>
/// <param name="codeBuilder"></param>
/// <param name="bindServicesCode"></param>
private void GenerateGrpcCallCodeForOldVersion(MethodInfo method, RpcParameterInfo parameter, string namespaceName,
string serviceName, CodeBuilder codeBuilder, ref StringBuilder bindServicesCode)
{
var serviceDefName = $"{namespaceName}.{serviceName}";
var methodDefName = method.Name.Replace("Async", "");
var key = $"{serviceDefName}.{methodDefName}";
if (_oldVersionGrpcMethods.ContainsKey(key))
{
return;
}
bindServicesCode.AppendLine($@"
.AddMethod(new Method<{parameter.ParameterType.Name}, {GrpcServiceBuilder.GetMethodReturn(method).Name}>(
MethodType.Unary,
""{serviceDefName}"",
""{methodDefName}"",
new Marshaller<{parameter.ParameterType.Name}>(
_binarySerializer.Serialize,
_binarySerializer.Deserialize<{parameter.ParameterType.Name}>
),
new Marshaller<{GrpcServiceBuilder.GetMethodReturn(method).Name}>(
_binarySerializer.Serialize,
_binarySerializer.Deserialize<{GrpcServiceBuilder.GetMethodReturn(method).Name}>)
),
{method.Name.Replace("Async", "")})");
_oldVersionGrpcMethods.Add(key, key);
}
private void GenerateProtoCode(MethodInfo method, RpcParameterInfo parameter, ref StringBuilder protoServiceCode, ref StringBuilder protoMessageCode)
{
var str = $"rpc {method.Name.Replace("Async", "")}({parameter.ParameterType.Name}) returns({GrpcServiceBuilder.GetMethodReturn(method).Name});";
protoServiceCode.AppendLine();
protoServiceCode.AppendLine(str);
if (!_messages.Contains(parameter.ParameterType.Name))
{
protoMessageCode.AppendLine(GenerateProtoMessageCode(parameter.ParameterType));
_messages.Add(parameter.ParameterType.Name);
}
if (_messages.Contains(GrpcServiceBuilder.GetMethodReturn(method).Name))
{
return;
}
protoMessageCode.AppendLine(GenerateProtoMessageCode(GrpcServiceBuilder.GetMethodReturn(method).ReturnType));
_messages.Add(GrpcServiceBuilder.GetMethodReturn(method).Name);
}
private ClassDescripter GenerateGrpcMethod(ClassDescripter @class, MethodInfo method, RpcParameterInfo parameter, Type[] baseInterfaces)
{
var className = method.DeclaringType.Name;
var messageName = parameter.ParameterType.Name;
var messageResultType = GrpcServiceBuilder.GetMethodReturn(method);
var messageResultName = messageResultType.Name;
var requestCode = "messageEnvelope.Message";
var responseCode = "var result = ";
var setResponseCode = "result";
if (parameter.IsEmpty)
{
requestCode = string.Empty;
}
if (messageResultType.IsEmpty)
{
responseCode = string.Empty;
setResponseCode = "new EmptyMessageResult()";
}
var code = $@"
var envelope = new MessageEnvelope<{messageName}>();
envelope.Message = request;
var grpcContext = new GrpcContext(envelope, context);
Func<IMessageEnvelope, IServiceScope, Task<IMessageResultEnvelope>> handler = async (imsgEnvelope, scope) =>
{{
var messageEnvelope = (MessageEnvelope<{messageName}>) imsgEnvelope;
{responseCode}await scope.ServiceProvider.GetService<{className}>().{method.Name}({requestCode});
return new MessageResultEnvelope<{messageResultName}>() {{ MessageResult = {setResponseCode} }};
}};
var resultEnvelope = await _messageServicer.ProcessAsync(grpcContext, handler);
return ((MessageResultEnvelope<{messageResultName}>)resultEnvelope).MessageResult;";
return(@class.CreateMember(
new MethodDescripter(method.Name.Replace("Async", "") ?? "", true)
.SetAccess(AccessType.Public)
.AppendCode(code).SetReturn($"Task<{GrpcServiceBuilder.GetMethodReturn(method).Name}>")
.SetParams(
new ParameterDescripter(parameter.ParameterType.Name, "request"),
new ParameterDescripter("ServerCallContext", "context")))
.AddUsing($"using {parameter.ParameterType.Namespace};")
.AddUsing($"using {method.DeclaringType.Namespace};")
.AddUsing($"using {GrpcServiceBuilder.GetMethodReturn(method).Namespace};"));
}
public static IServiceCollection AddKadderGrpcServer(
this IServiceCollection services, Action <GrpcServerBuilder> builderAction)
{
var builder = new GrpcServerBuilder();
builderAction(builder);
var serviceBuilder = new GrpcServiceBuilder();
services.AddSingleton(builder);
services.RegSerializer(builder.JsonSerializer, builder.BinarySerializer);
services.AddSingleton <GrpcHandlerBuilder>();
services.AddSingleton(serviceBuilder);
services.AddSingleton <GrpcMessageServicer>();
foreach (var item in builder.Middlewares)
{
Middlewares.GrpcHandlerDirector.AddMiddleware(item);
}
foreach (var interceptor in builder.Interceptors)
{
services.AddSingleton(interceptor);
}
var namespaces = "Kadder.CodeGeneration";
var codeBuilder = new CodeBuilder(namespaces, namespaces);
var grpcClasses = serviceBuilder.GenerateGrpcProxy(builder.Options, codeBuilder);
// var proxyCode = serviceBuilder.GenerateHandlerProxy(builder.Options.GetScanAssemblies(), codeBuilder);
var codeAssembly = codeBuilder.BuildAsync().Result;
foreach (var grpcClass in grpcClasses)
{
namespaces = $"{grpcClass.Namespace}.{grpcClass.Name}";
var grpcType = codeAssembly.Assembly.GetType(namespaces);
services.AddSingleton(grpcType);
builder.Services.Add(grpcType);
}
services.AddSingleton <GrpcServer>();
return(services);
}
private void GenerateGrpcCallCode(MethodInfo method, RpcParameterInfo parameter, string namespaceName,
CodeBuilder codeBuilder, ref StringBuilder bindServicesCode)
{
bindServicesCode.AppendLine($@"
.AddMethod(new Method<{parameter.ParameterType.Name}, {GrpcServiceBuilder.GetMethodReturn(method).Name}>(
MethodType.Unary,
""{namespaceName}.{method.DeclaringType.Name}"",
""{method.Name.Replace("Async", "")}"",
new Marshaller<{parameter.ParameterType.Name}>(
_binarySerializer.Serialize,
_binarySerializer.Deserialize<{parameter.ParameterType.Name}>
),
new Marshaller<{GrpcServiceBuilder.GetMethodReturn(method).Name}>(
_binarySerializer.Serialize,
_binarySerializer.Deserialize<{GrpcServiceBuilder.GetMethodReturn(method).Name}>)
),
{method.Name.Replace("Async", "")})");
codeBuilder
.AddAssemblyRefence(parameter.ParameterType.Assembly)
.AddAssemblyRefence(GrpcServiceBuilder.GetMethodReturn(method).Assembly);
}
