Пример #1
0
        /// <summary>
        /// Generates the RPC method definitions and stub handlers and adds them to the provided methodBinder.
        /// </summary>
        /// <returns></returns>
        public RpcStub <TService> GenerateOperationHandlers(IRpcServerCore server, TMethodBinder methodBinder)
        {
            this.serviceStub = this.CreateServiceStub(server);

            foreach (var memberInfo in RpcBuilderUtil.EnumOperationHandlers(this.ServiceInfo, true))
            {
                if (memberInfo is RpcEventInfo eventInfo)
                {
                    this.AddEventHandler(this.serviceStub, eventInfo, methodBinder);
                }
                else if (memberInfo is RpcOperationInfo opInfo)
                {
                    switch (opInfo.MethodType)
                    {
                    case RpcMethodType.Unary:
                        this.CheckMethod(opInfo);
                        this.AddUnaryMethod(this.serviceStub, opInfo, methodBinder);
                        break;

                    case RpcMethodType.ServerStreaming:
                        this.CheckMethod(opInfo);
                        if (opInfo.CallbackParameterIndex == null)
                        {
                            // No callback. Implement using IAsyncEnumerable
                            this.AddServerStreamingMethod(this.serviceStub, opInfo, methodBinder);
                        }
                        else
                        {
                            // Implement using callback
                            this.AddCallbackMethod(this.serviceStub, opInfo, methodBinder);
                        }
                        break;

                    default:
                        throw new NotImplementedException();
                    }
                }
                else
                {
                    throw new NotImplementedException();
                }
            }

            return(this.serviceStub);
        }
Пример #2
0
        private void WriteProto(Assembly assembly, TextWriter output)
        {
            var dynamicModuleBuilder = CreateModuleBuilder("RequestResponseTypes", "RequestResponseTypes.dll", false);

            StringBuilder serviceBuilder = new StringBuilder();

            RuntimeTypeModel typeModel = RuntimeTypeModel.Create();

            foreach (var exportedType in assembly.GetExportedTypes())
            {
                var serviceInfo = RpcBuilderUtil.TryGetServiceInfoFromType(exportedType);
                if (serviceInfo != null && serviceInfo.DefinitionSide != RpcServiceDefinitionSide.Client)
                {
                    serviceBuilder.AppendLine();
                    serviceBuilder.AppendLine($"service {serviceInfo.Name} {{");

                    foreach (var rpcMemberInfo in RpcBuilderUtil.EnumOperationHandlers(serviceInfo, true))
                    {
                        if (rpcMemberInfo is RpcOperationInfo rpcOpInfo)
                        {
                            var namedRequestType  = this.CreateRequestType(dynamicModuleBuilder, rpcOpInfo);
                            var namedResponseType = this.CreateResponseType(dynamicModuleBuilder, rpcOpInfo);
                            if (namedRequestType == null || namedResponseType == null)
                            {
                                continue;   // Should probably stop generator.
                            }

                            typeModel.Add(namedRequestType, true);
                            typeModel.Add(namedResponseType, true);

                            serviceBuilder.AppendLine(
                                $"\trpc {rpcOpInfo.Name} ({namedRequestType.Name}) returns ({namedResponseType.Name});");
                        }
                    }

                    serviceBuilder.AppendLine("}");
                }
            }

            string schema = typeModel.GetSchema(null, ProtoSyntax.Proto3);

            output.WriteLine(schema);
            output.WriteLine(serviceBuilder.ToString());
        }