src/compiler/csharp_generator.cc

   1 /*
   2  *
   3  * Copyright 2015 gRPC authors.
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *     http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  *
  17  */
  18
  19 #include <cctype>
  20 #include <map>
  21 #include <sstream>
  22 #include <vector>
  23
  24 #include "src/compiler/config.h"
  25 #include "src/compiler/csharp_generator.h"
  26 #include "src/compiler/csharp_generator_helpers.h"
  27
  28 using google::protobuf::compiler::csharp::GetClassName;
  29 using google::protobuf::compiler::csharp::GetFileNamespace;
  30 using google::protobuf::compiler::csharp::GetReflectionClassName;
  31 using grpc::protobuf::Descriptor;
  32 using grpc::protobuf::FileDescriptor;
  33 using grpc::protobuf::MethodDescriptor;
  34 using grpc::protobuf::ServiceDescriptor;
  35 using grpc::protobuf::io::Printer;
  36 using grpc::protobuf::io::StringOutputStream;
  37 using grpc_generator::GetMethodType;
  38 using grpc_generator::METHODTYPE_BIDI_STREAMING;
  39 using grpc_generator::METHODTYPE_CLIENT_STREAMING;
  40 using grpc_generator::METHODTYPE_NO_STREAMING;
  41 using grpc_generator::METHODTYPE_SERVER_STREAMING;
  42 using grpc_generator::MethodType;
  43 using grpc_generator::StringReplace;
  44 using std::map;
  45 using std::vector;
  46
  47 namespace grpc_csharp_generator {
  48 namespace {
  49
  50 // This function is a massaged version of
  51 // https://github.com/google/protobuf/blob/master/src/google/protobuf/compiler/csharp/csharp_doc_comment.cc
  52 // Currently, we cannot easily reuse the functionality as
  53 // google/protobuf/compiler/csharp/csharp_doc_comment.h is not a public header.
  54 // TODO(jtattermusch): reuse the functionality from google/protobuf.
  55 bool GenerateDocCommentBodyImpl(grpc::protobuf::io::Printer* printer,
  56                                 grpc::protobuf::SourceLocation location) {
  57   grpc::string comments = location.leading_comments.empty()
  58                               ? location.trailing_comments
  59                               : location.leading_comments;
  60   if (comments.empty()) {
  61     return false;
  62   }
  63   // XML escaping... no need for apostrophes etc as the whole text is going to
  64   // be a child
  65   // node of a summary element, not part of an attribute.
  66   comments = grpc_generator::StringReplace(comments, "&", "&amp;", true);
  67   comments = grpc_generator::StringReplace(comments, "<", "&lt;", true);
  68
  69   std::vector<grpc::string> lines;
  70   grpc_generator::Split(comments, '\n', &lines);
  71   // TODO: We really should work out which part to put in the summary and which
  72   // to put in the remarks...
  73   // but that needs to be part of a bigger effort to understand the markdown
  74   // better anyway.
  75   printer->Print("/// <summary>\n");
  76   bool last_was_empty = false;
  77   // We squash multiple blank lines down to one, and remove any trailing blank
  78   // lines. We need
  79   // to preserve the blank lines themselves, as this is relevant in the
  80   // markdown.
  81   // Note that we can't remove leading or trailing whitespace as *that's*
  82   // relevant in markdown too.
  83   // (We don't skip "just whitespace" lines, either.)
  84   for (std::vector<grpc::string>::iterator it = lines.begin();
  85        it != lines.end(); ++it) {
  86     grpc::string line = *it;
  87     if (line.empty()) {
  88       last_was_empty = true;
  89     } else {
  90       if (last_was_empty) {
  91         printer->Print("///\n");
  92       }
  93       last_was_empty = false;
  94       printer->Print("///$line$\n", "line", *it);
  95     }
  96   }
  97   printer->Print("/// </summary>\n");
  98   return true;
  99 }
 100
 101 template <typename DescriptorType>
 102 bool GenerateDocCommentBody(grpc::protobuf::io::Printer* printer,
 103                             const DescriptorType* descriptor) {
 104   grpc::protobuf::SourceLocation location;
 105   if (!descriptor->GetSourceLocation(&location)) {
 106     return false;
 107   }
 108   return GenerateDocCommentBodyImpl(printer, location);
 109 }
 110
 111 void GenerateDocCommentServerMethod(grpc::protobuf::io::Printer* printer,
 112                                     const MethodDescriptor* method) {
 113   if (GenerateDocCommentBody(printer, method)) {
 114     if (method->client_streaming()) {
 115       printer->Print(
 116           "/// <param name=\"requestStream\">Used for reading requests from "
 117           "the client.</param>\n");
 118     } else {
 119       printer->Print(
 120           "/// <param name=\"request\">The request received from the "
 121           "client.</param>\n");
 122     }
 123     if (method->server_streaming()) {
 124       printer->Print(
 125           "/// <param name=\"responseStream\">Used for sending responses back "
 126           "to the client.</param>\n");
 127     }
 128     printer->Print(
 129         "/// <param name=\"context\">The context of the server-side call "
 130         "handler being invoked.</param>\n");
 131     if (method->server_streaming()) {
 132       printer->Print(
 133           "/// <returns>A task indicating completion of the "
 134           "handler.</returns>\n");
 135     } else {
 136       printer->Print(
 137           "/// <returns>The response to send back to the client (wrapped by a "
 138           "task).</returns>\n");
 139     }
 140   }
 141 }
 142
 143 void GenerateDocCommentClientMethod(grpc::protobuf::io::Printer* printer,
 144                                     const MethodDescriptor* method,
 145                                     bool is_sync, bool use_call_options) {
 146   if (GenerateDocCommentBody(printer, method)) {
 147     if (!method->client_streaming()) {
 148       printer->Print(
 149           "/// <param name=\"request\">The request to send to the "
 150           "server.</param>\n");
 151     }
 152     if (!use_call_options) {
 153       printer->Print(
 154           "/// <param name=\"headers\">The initial metadata to send with the "
 155           "call. This parameter is optional.</param>\n");
 156       printer->Print(
 157           "/// <param name=\"deadline\">An optional deadline for the call. The "
 158           "call will be cancelled if deadline is hit.</param>\n");
 159       printer->Print(
 160           "/// <param name=\"cancellationToken\">An optional token for "
 161           "canceling the call.</param>\n");
 162     } else {
 163       printer->Print(
 164           "/// <param name=\"options\">The options for the call.</param>\n");
 165     }
 166     if (is_sync) {
 167       printer->Print(
 168           "/// <returns>The response received from the server.</returns>\n");
 169     } else {
 170       printer->Print("/// <returns>The call object.</returns>\n");
 171     }
 172   }
 173 }
 174
 175 std::string GetServiceClassName(const ServiceDescriptor* service) {
 176   return service->name();
 177 }
 178
 179 std::string GetClientClassName(const ServiceDescriptor* service) {
 180   return service->name() + "Client";
 181 }
 182
 183 std::string GetServerClassName(const ServiceDescriptor* service) {
 184   return service->name() + "Base";
 185 }
 186
 187 std::string GetCSharpMethodType(MethodType method_type) {
 188   switch (method_type) {
 189     case METHODTYPE_NO_STREAMING:
 190       return "grpc::MethodType.Unary";
 191     case METHODTYPE_CLIENT_STREAMING:
 192       return "grpc::MethodType.ClientStreaming";
 193     case METHODTYPE_SERVER_STREAMING:
 194       return "grpc::MethodType.ServerStreaming";
 195     case METHODTYPE_BIDI_STREAMING:
 196       return "grpc::MethodType.DuplexStreaming";
 197   }
 198   GOOGLE_LOG(FATAL) << "Can't get here.";
 199   return "";
 200 }
 201
 202 std::string GetCSharpServerMethodType(MethodType method_type) {
 203   switch (method_type) {
 204     case METHODTYPE_NO_STREAMING:
 205       return "grpc::UnaryServerMethod";
 206     case METHODTYPE_CLIENT_STREAMING:
 207       return "grpc::ClientStreamingServerMethod";
 208     case METHODTYPE_SERVER_STREAMING:
 209       return "grpc::ServerStreamingServerMethod";
 210     case METHODTYPE_BIDI_STREAMING:
 211       return "grpc::DuplexStreamingServerMethod";
 212   }
 213   GOOGLE_LOG(FATAL) << "Can't get here.";
 214   return "";
 215 }
 216
 217 std::string GetServiceNameFieldName() { return "__ServiceName"; }
 218
 219 std::string GetMarshallerFieldName(const Descriptor* message) {
 220   return "__Marshaller_" +
 221          grpc_generator::StringReplace(message->full_name(), ".", "_", true);
 222 }
 223
 224 std::string GetMethodFieldName(const MethodDescriptor* method) {
 225   return "__Method_" + method->name();
 226 }
 227
 228 std::string GetMethodRequestParamMaybe(const MethodDescriptor* method,
 229                                        bool invocation_param = false) {
 230   if (method->client_streaming()) {
 231     return "";
 232   }
 233   if (invocation_param) {
 234     return "request, ";
 235   }
 236   return GetClassName(method->input_type()) + " request, ";
 237 }
 238
 239 std::string GetAccessLevel(bool internal_access) {
 240   return internal_access ? "internal" : "public";
 241 }
 242
 243 std::string GetMethodReturnTypeClient(const MethodDescriptor* method) {
 244   switch (GetMethodType(method)) {
 245     case METHODTYPE_NO_STREAMING:
 246       return "grpc::AsyncUnaryCall<" + GetClassName(method->output_type()) +
 247              ">";
 248     case METHODTYPE_CLIENT_STREAMING:
 249       return "grpc::AsyncClientStreamingCall<" +
 250              GetClassName(method->input_type()) + ", " +
 251              GetClassName(method->output_type()) + ">";
 252     case METHODTYPE_SERVER_STREAMING:
 253       return "grpc::AsyncServerStreamingCall<" +
 254              GetClassName(method->output_type()) + ">";
 255     case METHODTYPE_BIDI_STREAMING:
 256       return "grpc::AsyncDuplexStreamingCall<" +
 257              GetClassName(method->input_type()) + ", " +
 258              GetClassName(method->output_type()) + ">";
 259   }
 260   GOOGLE_LOG(FATAL) << "Can't get here.";
 261   return "";
 262 }
 263
 264 std::string GetMethodRequestParamServer(const MethodDescriptor* method) {
 265   switch (GetMethodType(method)) {
 266     case METHODTYPE_NO_STREAMING:
 267     case METHODTYPE_SERVER_STREAMING:
 268       return GetClassName(method->input_type()) + " request";
 269     case METHODTYPE_CLIENT_STREAMING:
 270     case METHODTYPE_BIDI_STREAMING:
 271       return "grpc::IAsyncStreamReader<" + GetClassName(method->input_type()) +
 272              "> requestStream";
 273   }
 274   GOOGLE_LOG(FATAL) << "Can't get here.";
 275   return "";
 276 }
 277
 278 std::string GetMethodReturnTypeServer(const MethodDescriptor* method) {
 279   switch (GetMethodType(method)) {
 280     case METHODTYPE_NO_STREAMING:
 281     case METHODTYPE_CLIENT_STREAMING:
 282       return "global::System.Threading.Tasks.Task<" +
 283              GetClassName(method->output_type()) + ">";
 284     case METHODTYPE_SERVER_STREAMING:
 285     case METHODTYPE_BIDI_STREAMING:
 286       return "global::System.Threading.Tasks.Task";
 287   }
 288   GOOGLE_LOG(FATAL) << "Can't get here.";
 289   return "";
 290 }
 291
 292 std::string GetMethodResponseStreamMaybe(const MethodDescriptor* method) {
 293   switch (GetMethodType(method)) {
 294     case METHODTYPE_NO_STREAMING:
 295     case METHODTYPE_CLIENT_STREAMING:
 296       return "";
 297     case METHODTYPE_SERVER_STREAMING:
 298     case METHODTYPE_BIDI_STREAMING:
 299       return ", grpc::IServerStreamWriter<" +
 300              GetClassName(method->output_type()) + "> responseStream";
 301   }
 302   GOOGLE_LOG(FATAL) << "Can't get here.";
 303   return "";
 304 }
 305
 306 // Gets vector of all messages used as input or output types.
 307 std::vector<const Descriptor*> GetUsedMessages(
 308     const ServiceDescriptor* service) {
 309   std::set<const Descriptor*> descriptor_set;
 310   std::vector<const Descriptor*>
 311       result;  // vector is to maintain stable ordering
 312   for (int i = 0; i < service->method_count(); i++) {
 313     const MethodDescriptor* method = service->method(i);
 314     if (descriptor_set.find(method->input_type()) == descriptor_set.end()) {
 315       descriptor_set.insert(method->input_type());
 316       result.push_back(method->input_type());
 317     }
 318     if (descriptor_set.find(method->output_type()) == descriptor_set.end()) {
 319       descriptor_set.insert(method->output_type());
 320       result.push_back(method->output_type());
 321     }
 322   }
 323   return result;
 324 }
 325
 326 void GenerateMarshallerFields(Printer* out, const ServiceDescriptor* service) {
 327   std::vector<const Descriptor*> used_messages = GetUsedMessages(service);
 328   for (size_t i = 0; i < used_messages.size(); i++) {
 329     const Descriptor* message = used_messages[i];
 330     out->Print(
 331         "static readonly grpc::Marshaller<$type$> $fieldname$ = "
 332         "grpc::Marshallers.Create((arg) => "
 333         "global::Google.Protobuf.MessageExtensions.ToByteArray(arg), "
 334         "$type$.Parser.ParseFrom);\n",
 335         "fieldname", GetMarshallerFieldName(message), "type",
 336         GetClassName(message));
 337   }
 338   out->Print("\n");
 339 }
 340
 341 void GenerateStaticMethodField(Printer* out, const MethodDescriptor* method) {
 342   out->Print(
 343       "static readonly grpc::Method<$request$, $response$> $fieldname$ = new "
 344       "grpc::Method<$request$, $response$>(\n",
 345       "fieldname", GetMethodFieldName(method), "request",
 346       GetClassName(method->input_type()), "response",
 347       GetClassName(method->output_type()));
 348   out->Indent();
 349   out->Indent();
 350   out->Print("$methodtype$,\n", "methodtype",
 351              GetCSharpMethodType(GetMethodType(method)));
 352   out->Print("$servicenamefield$,\n", "servicenamefield",
 353              GetServiceNameFieldName());
 354   out->Print("\"$methodname$\",\n", "methodname", method->name());
 355   out->Print("$requestmarshaller$,\n", "requestmarshaller",
 356              GetMarshallerFieldName(method->input_type()));
 357   out->Print("$responsemarshaller$);\n", "responsemarshaller",
 358              GetMarshallerFieldName(method->output_type()));
 359   out->Print("\n");
 360   out->Outdent();
 361   out->Outdent();
 362 }
 363
 364 void GenerateServiceDescriptorProperty(Printer* out,
 365                                        const ServiceDescriptor* service) {
 366   std::ostringstream index;
 367   index << service->index();
 368   out->Print("/// <summary>Service descriptor</summary>\n");
 369   out->Print(
 370       "public static global::Google.Protobuf.Reflection.ServiceDescriptor "
 371       "Descriptor\n");
 372   out->Print("{\n");
 373   out->Print("  get { return $umbrella$.Descriptor.Services[$index$]; }\n",
 374              "umbrella", GetReflectionClassName(service->file()), "index",
 375              index.str());
 376   out->Print("}\n");
 377   out->Print("\n");
 378 }
 379
 380 void GenerateServerClass(Printer* out, const ServiceDescriptor* service) {
 381   out->Print(
 382       "/// <summary>Base class for server-side implementations of "
 383       "$servicename$</summary>\n",
 384       "servicename", GetServiceClassName(service));
 385   out->Print("public abstract partial class $name$\n", "name",
 386              GetServerClassName(service));
 387   out->Print("{\n");
 388   out->Indent();
 389   for (int i = 0; i < service->method_count(); i++) {
 390     const MethodDescriptor* method = service->method(i);
 391     GenerateDocCommentServerMethod(out, method);
 392     out->Print(
 393         "public virtual $returntype$ "
 394         "$methodname$($request$$response_stream_maybe$, "
 395         "grpc::ServerCallContext context)\n",
 396         "methodname", method->name(), "returntype",
 397         GetMethodReturnTypeServer(method), "request",
 398         GetMethodRequestParamServer(method), "response_stream_maybe",
 399         GetMethodResponseStreamMaybe(method));
 400     out->Print("{\n");
 401     out->Indent();
 402     out->Print(
 403         "throw new grpc::RpcException("
 404         "new grpc::Status(grpc::StatusCode.Unimplemented, \"\"));\n");
 405     out->Outdent();
 406     out->Print("}\n\n");
 407   }
 408   out->Outdent();
 409   out->Print("}\n");
 410   out->Print("\n");
 411 }
 412
 413 void GenerateClientStub(Printer* out, const ServiceDescriptor* service) {
 414   out->Print("/// <summary>Client for $servicename$</summary>\n", "servicename",
 415              GetServiceClassName(service));
 416   out->Print("public partial class $name$ : grpc::ClientBase<$name$>\n", "name",
 417              GetClientClassName(service));
 418   out->Print("{\n");
 419   out->Indent();
 420
 421   // constructors
 422   out->Print(
 423       "/// <summary>Creates a new client for $servicename$</summary>\n"
 424       "/// <param name=\"channel\">The channel to use to make remote "
 425       "calls.</param>\n",
 426       "servicename", GetServiceClassName(service));
 427   out->Print("public $name$(grpc::Channel channel) : base(channel)\n", "name",
 428              GetClientClassName(service));
 429   out->Print("{\n");
 430   out->Print("}\n");
 431   out->Print(
 432       "/// <summary>Creates a new client for $servicename$ that uses a custom "
 433       "<c>CallInvoker</c>.</summary>\n"
 434       "/// <param name=\"callInvoker\">The callInvoker to use to make remote "
 435       "calls.</param>\n",
 436       "servicename", GetServiceClassName(service));
 437   out->Print(
 438       "public $name$(grpc::CallInvoker callInvoker) : base(callInvoker)\n",
 439       "name", GetClientClassName(service));
 440   out->Print("{\n");
 441   out->Print("}\n");
 442   out->Print(
 443       "/// <summary>Protected parameterless constructor to allow creation"
 444       " of test doubles.</summary>\n");
 445   out->Print("protected $name$() : base()\n", "name",
 446              GetClientClassName(service));
 447   out->Print("{\n");
 448   out->Print("}\n");
 449   out->Print(
 450       "/// <summary>Protected constructor to allow creation of configured "
 451       "clients.</summary>\n"
 452       "/// <param name=\"configuration\">The client configuration.</param>\n");
 453   out->Print(
 454       "protected $name$(ClientBaseConfiguration configuration)"
 455       " : base(configuration)\n",
 456       "name", GetClientClassName(service));
 457   out->Print("{\n");
 458   out->Print("}\n\n");
 459
 460   for (int i = 0; i < service->method_count(); i++) {
 461     const MethodDescriptor* method = service->method(i);
 462     MethodType method_type = GetMethodType(method);
 463
 464     if (method_type == METHODTYPE_NO_STREAMING) {
 465       // unary calls have an extra synchronous stub method
 466       GenerateDocCommentClientMethod(out, method, true, false);
 467       out->Print(
 468           "public virtual $response$ $methodname$($request$ request, "
 469           "grpc::Metadata "
 470           "headers = null, global::System.DateTime? deadline = null, "
 471           "global::System.Threading.CancellationToken "
 472           "cancellationToken = "
 473           "default(global::System.Threading.CancellationToken))\n",
 474           "methodname", method->name(), "request",
 475           GetClassName(method->input_type()), "response",
 476           GetClassName(method->output_type()));
 477       out->Print("{\n");
 478       out->Indent();
 479       out->Print(
 480           "return $methodname$(request, new grpc::CallOptions(headers, "
 481           "deadline, "
 482           "cancellationToken));\n",
 483           "methodname", method->name());
 484       out->Outdent();
 485       out->Print("}\n");
 486
 487       // overload taking CallOptions as a param
 488       GenerateDocCommentClientMethod(out, method, true, true);
 489       out->Print(
 490           "public virtual $response$ $methodname$($request$ request, "
 491           "grpc::CallOptions options)\n",
 492           "methodname", method->name(), "request",
 493           GetClassName(method->input_type()), "response",
 494           GetClassName(method->output_type()));
 495       out->Print("{\n");
 496       out->Indent();
 497       out->Print(
 498           "return CallInvoker.BlockingUnaryCall($methodfield$, null, options, "
 499           "request);\n",
 500           "methodfield", GetMethodFieldName(method));
 501       out->Outdent();
 502       out->Print("}\n");
 503     }
 504
 505     std::string method_name = method->name();
 506     if (method_type == METHODTYPE_NO_STREAMING) {
 507       method_name += "Async";  // prevent name clash with synchronous method.
 508     }
 509     GenerateDocCommentClientMethod(out, method, false, false);
 510     out->Print(
 511         "public virtual $returntype$ "
 512         "$methodname$($request_maybe$grpc::Metadata "
 513         "headers = null, global::System.DateTime? deadline = null, "
 514         "global::System.Threading.CancellationToken "
 515         "cancellationToken = "
 516         "default(global::System.Threading.CancellationToken))\n",
 517         "methodname", method_name, "request_maybe",
 518         GetMethodRequestParamMaybe(method), "returntype",
 519         GetMethodReturnTypeClient(method));
 520     out->Print("{\n");
 521     out->Indent();
 522
 523     out->Print(
 524         "return $methodname$($request_maybe$new grpc::CallOptions(headers, "
 525         "deadline, "
 526         "cancellationToken));\n",
 527         "methodname", method_name, "request_maybe",
 528         GetMethodRequestParamMaybe(method, true));
 529     out->Outdent();
 530     out->Print("}\n");
 531
 532     // overload taking CallOptions as a param
 533     GenerateDocCommentClientMethod(out, method, false, true);
 534     out->Print(
 535         "public virtual $returntype$ "
 536         "$methodname$($request_maybe$grpc::CallOptions "
 537         "options)\n",
 538         "methodname", method_name, "request_maybe",
 539         GetMethodRequestParamMaybe(method), "returntype",
 540         GetMethodReturnTypeClient(method));
 541     out->Print("{\n");
 542     out->Indent();
 543     switch (GetMethodType(method)) {
 544       case METHODTYPE_NO_STREAMING:
 545         out->Print(
 546             "return CallInvoker.AsyncUnaryCall($methodfield$, null, options, "
 547             "request);\n",
 548             "methodfield", GetMethodFieldName(method));
 549         break;
 550       case METHODTYPE_CLIENT_STREAMING:
 551         out->Print(
 552             "return CallInvoker.AsyncClientStreamingCall($methodfield$, null, "
 553             "options);\n",
 554             "methodfield", GetMethodFieldName(method));
 555         break;
 556       case METHODTYPE_SERVER_STREAMING:
 557         out->Print(
 558             "return CallInvoker.AsyncServerStreamingCall($methodfield$, null, "
 559             "options, request);\n",
 560             "methodfield", GetMethodFieldName(method));
 561         break;
 562       case METHODTYPE_BIDI_STREAMING:
 563         out->Print(
 564             "return CallInvoker.AsyncDuplexStreamingCall($methodfield$, null, "
 565             "options);\n",
 566             "methodfield", GetMethodFieldName(method));
 567         break;
 568       default:
 569         GOOGLE_LOG(FATAL) << "Can't get here.";
 570     }
 571     out->Outdent();
 572     out->Print("}\n");
 573   }
 574
 575   // override NewInstance method
 576   out->Print(
 577       "/// <summary>Creates a new instance of client from given "
 578       "<c>ClientBaseConfiguration</c>.</summary>\n");
 579   out->Print(
 580       "protected override $name$ NewInstance(ClientBaseConfiguration "
 581       "configuration)\n",
 582       "name", GetClientClassName(service));
 583   out->Print("{\n");
 584   out->Indent();
 585   out->Print("return new $name$(configuration);\n", "name",
 586              GetClientClassName(service));
 587   out->Outdent();
 588   out->Print("}\n");
 589
 590   out->Outdent();
 591   out->Print("}\n");
 592   out->Print("\n");
 593 }
 594
 595 void GenerateBindServiceMethod(Printer* out, const ServiceDescriptor* service) {
 596   out->Print(
 597       "/// <summary>Creates service definition that can be registered with a "
 598       "server</summary>\n");
 599   out->Print(
 600       "/// <param name=\"serviceImpl\">An object implementing the server-side"
 601       " handling logic.</param>\n");
 602   out->Print(
 603       "public static grpc::ServerServiceDefinition BindService($implclass$ "
 604       "serviceImpl)\n",
 605       "implclass", GetServerClassName(service));
 606   out->Print("{\n");
 607   out->Indent();
 608
 609   out->Print("return grpc::ServerServiceDefinition.CreateBuilder()");
 610   out->Indent();
 611   out->Indent();
 612   for (int i = 0; i < service->method_count(); i++) {
 613     const MethodDescriptor* method = service->method(i);
 614     out->Print("\n.AddMethod($methodfield$, serviceImpl.$methodname$)",
 615                "methodfield", GetMethodFieldName(method), "methodname",
 616                method->name());
 617   }
 618   out->Print(".Build();\n");
 619   out->Outdent();
 620   out->Outdent();
 621
 622   out->Outdent();
 623   out->Print("}\n");
 624   out->Print("\n");
 625 }
 626
 627 void GenerateBindServiceWithBinderMethod(Printer* out,
 628                                          const ServiceDescriptor* service) {
 629   out->Print(
 630       "/// <summary>Register service method with a service "
 631       "binder with or without implementation. Useful when customizing the  "
 632       "service binding logic.\n"
 633       "/// Note: this method is part of an experimental API that can change or "
 634       "be "
 635       "removed without any prior notice.</summary>\n");
 636   out->Print(
 637       "/// <param name=\"serviceBinder\">Service methods will be bound by "
 638       "calling <c>AddMethod</c> on this object."
 639       "</param>\n");
 640   out->Print(
 641       "/// <param name=\"serviceImpl\">An object implementing the server-side"
 642       " handling logic.</param>\n");
 643   out->Print(
 644       "public static void BindService(grpc::ServiceBinderBase serviceBinder, "
 645       "$implclass$ "
 646       "serviceImpl)\n",
 647       "implclass", GetServerClassName(service));
 648   out->Print("{\n");
 649   out->Indent();
 650
 651   for (int i = 0; i < service->method_count(); i++) {
 652     const MethodDescriptor* method = service->method(i);
 653     out->Print(
 654         "serviceBinder.AddMethod($methodfield$, serviceImpl == null ? null : "
 655         "new $servermethodtype$<$inputtype$, $outputtype$>("
 656         "serviceImpl.$methodname$));\n",
 657         "methodfield", GetMethodFieldName(method), "servermethodtype",
 658         GetCSharpServerMethodType(GetMethodType(method)), "inputtype",
 659         GetClassName(method->input_type()), "outputtype",
 660         GetClassName(method->output_type()), "methodname", method->name());
 661   }
 662
 663   out->Outdent();
 664   out->Print("}\n");
 665   out->Print("\n");
 666 }
 667
 668 void GenerateService(Printer* out, const ServiceDescriptor* service,
 669                      bool generate_client, bool generate_server,
 670                      bool internal_access) {
 671   GenerateDocCommentBody(out, service);
 672   out->Print("$access_level$ static partial class $classname$\n",
 673              "access_level", GetAccessLevel(internal_access), "classname",
 674              GetServiceClassName(service));
 675   out->Print("{\n");
 676   out->Indent();
 677   out->Print("static readonly string $servicenamefield$ = \"$servicename$\";\n",
 678              "servicenamefield", GetServiceNameFieldName(), "servicename",
 679              service->full_name());
 680   out->Print("\n");
 681
 682   GenerateMarshallerFields(out, service);
 683   for (int i = 0; i < service->method_count(); i++) {
 684     GenerateStaticMethodField(out, service->method(i));
 685   }
 686   GenerateServiceDescriptorProperty(out, service);
 687
 688   if (generate_server) {
 689     GenerateServerClass(out, service);
 690   }
 691   if (generate_client) {
 692     GenerateClientStub(out, service);
 693   }
 694   if (generate_server) {
 695     GenerateBindServiceMethod(out, service);
 696     GenerateBindServiceWithBinderMethod(out, service);
 697   }
 698
 699   out->Outdent();
 700   out->Print("}\n");
 701 }
 702
 703 }  // anonymous namespace
 704
 705 grpc::string GetServices(const FileDescriptor* file, bool generate_client,
 706                          bool generate_server, bool internal_access) {
 707   grpc::string output;
 708   {
 709     // Scope the output stream so it closes and finalizes output to the string.
 710
 711     StringOutputStream output_stream(&output);
 712     Printer out(&output_stream, '$');
 713
 714     // Don't write out any output if there no services, to avoid empty service
 715     // files being generated for proto files that don't declare any.
 716     if (file->service_count() == 0) {
 717       return output;
 718     }
 719
 720     // Write out a file header.
 721     out.Print("// <auto-generated>\n");
 722     out.Print(
 723         "//     Generated by the protocol buffer compiler.  DO NOT EDIT!\n");
 724     out.Print("//     source: $filename$\n", "filename", file->name());
 725     out.Print("// </auto-generated>\n");
 726
 727     // use C++ style as there are no file-level XML comments in .NET
 728     grpc::string leading_comments = GetCsharpComments(file, true);
 729     if (!leading_comments.empty()) {
 730       out.Print("// Original file comments:\n");
 731       out.PrintRaw(leading_comments.c_str());
 732     }
 733
 734     out.Print("#pragma warning disable 0414, 1591\n");
 735
 736     out.Print("#region Designer generated code\n");
 737     out.Print("\n");
 738     out.Print("using grpc = global::Grpc.Core;\n");
 739     out.Print("\n");
 740
 741     grpc::string file_namespace = GetFileNamespace(file);
 742     if (file_namespace != "") {
 743       out.Print("namespace $namespace$ {\n", "namespace", file_namespace);
 744       out.Indent();
 745     }
 746     for (int i = 0; i < file->service_count(); i++) {
 747       GenerateService(&out, file->service(i), generate_client, generate_server,
 748                       internal_access);
 749     }
 750     if (file_namespace != "") {
 751       out.Outdent();
 752       out.Print("}\n");
 753     }
 754     out.Print("#endregion\n");
 755   }
 756   return output;
 757 }
 758
 759 }  // namespace grpc_csharp_generator