regenerate C# sources

src/csharp/Grpc.Examples/MathGrpc.cs

@@ -1,5 +1,35 @@
 // Generated by the protocol buffer compiler.  DO NOT EDIT!
 // source: math.proto
+// Original file comments:
+// Copyright 2015, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 #region Designer generated code
 
 using System;
@@ -45,56 +75,140 @@ namespace Math {
         __Marshaller_Num,
         __Marshaller_Num);
 
-    // service descriptor
+    /// <summary>Service descriptor</summary>
     public static global::Google.Protobuf.Reflection.ServiceDescriptor Descriptor
     {
       get { return global::Math.MathReflection.Descriptor.Services[0]; }
     }
 
-    // client interface
+    /// <summary>Client for Math</summary>
     [System.Obsolete("Client side interfaced will be removed in the next release. Use client class directly.")]
     public interface IMathClient
     {
+      /// <summary>
+      ///  Div divides args.dividend by args.divisor and returns the quotient and
+      ///  remainder.
+      /// </summary>
       global::Math.DivReply Div(global::Math.DivArgs request, Metadata headers = null, DateTime? deadline = null, CancellationToken cancellationToken = default(CancellationToken));
+      /// <summary>
+      ///  Div divides args.dividend by args.divisor and returns the quotient and
+      ///  remainder.
+      /// </summary>
       global::Math.DivReply Div(global::Math.DivArgs request, CallOptions options);
+      /// <summary>
+      ///  Div divides args.dividend by args.divisor and returns the quotient and
+      ///  remainder.
+      /// </summary>
       AsyncUnaryCall<global::Math.DivReply> DivAsync(global::Math.DivArgs request, Metadata headers = null, DateTime? deadline = null, CancellationToken cancellationToken = default(CancellationToken));
+      /// <summary>
+      ///  Div divides args.dividend by args.divisor and returns the quotient and
+      ///  remainder.
+      /// </summary>
       AsyncUnaryCall<global::Math.DivReply> DivAsync(global::Math.DivArgs request, CallOptions options);
+      /// <summary>
+      ///  DivMany accepts an arbitrary number of division args from the client stream
+      ///  and sends back the results in the reply stream.  The stream continues until
+      ///  the client closes its end; the server does the same after sending all the
+      ///  replies.  The stream ends immediately if either end aborts.
+      /// </summary>
       AsyncDuplexStreamingCall<global::Math.DivArgs, global::Math.DivReply> DivMany(Metadata headers = null, DateTime? deadline = null, CancellationToken cancellationToken = default(CancellationToken));
+      /// <summary>
+      ///  DivMany accepts an arbitrary number of division args from the client stream
+      ///  and sends back the results in the reply stream.  The stream continues until
+      ///  the client closes its end; the server does the same after sending all the
+      ///  replies.  The stream ends immediately if either end aborts.
+      /// </summary>
       AsyncDuplexStreamingCall<global::Math.DivArgs, global::Math.DivReply> DivMany(CallOptions options);
+      /// <summary>
+      ///  Fib generates numbers in the Fibonacci sequence.  If args.limit > 0, Fib
+      ///  generates up to limit numbers; otherwise it continues until the call is
+      ///  canceled.  Unlike Fib above, Fib has no final FibReply.
+      /// </summary>
       AsyncServerStreamingCall<global::Math.Num> Fib(global::Math.FibArgs request, Metadata headers = null, DateTime? deadline = null, CancellationToken cancellationToken = default(CancellationToken));
+      /// <summary>
+      ///  Fib generates numbers in the Fibonacci sequence.  If args.limit > 0, Fib
+      ///  generates up to limit numbers; otherwise it continues until the call is
+      ///  canceled.  Unlike Fib above, Fib has no final FibReply.
+      /// </summary>
       AsyncServerStreamingCall<global::Math.Num> Fib(global::Math.FibArgs request, CallOptions options);
+      /// <summary>
+      ///  Sum sums a stream of numbers, returning the final result once the stream
+      ///  is closed.
+      /// </summary>
       AsyncClientStreamingCall<global::Math.Num, global::Math.Num> Sum(Metadata headers = null, DateTime? deadline = null, CancellationToken cancellationToken = default(CancellationToken));
+      /// <summary>
+      ///  Sum sums a stream of numbers, returning the final result once the stream
+      ///  is closed.
+      /// </summary>
       AsyncClientStreamingCall<global::Math.Num, global::Math.Num> Sum(CallOptions options);
     }
 
-    // server-side interface
+    /// <summary>Interface of server-side implementations of Math</summary>
     [System.Obsolete("Service implementations should inherit from the generated abstract base class instead.")]
     public interface IMath
     {
+      /// <summary>
+      ///  Div divides args.dividend by args.divisor and returns the quotient and
+      ///  remainder.
+      /// </summary>
       Task<global::Math.DivReply> Div(global::Math.DivArgs request, ServerCallContext context);
+      /// <summary>
+      ///  DivMany accepts an arbitrary number of division args from the client stream
+      ///  and sends back the results in the reply stream.  The stream continues until
+      ///  the client closes its end; the server does the same after sending all the
+      ///  replies.  The stream ends immediately if either end aborts.
+      /// </summary>
       Task DivMany(IAsyncStreamReader<global::Math.DivArgs> requestStream, IServerStreamWriter<global::Math.DivReply> responseStream, ServerCallContext context);
+      /// <summary>
+      ///  Fib generates numbers in the Fibonacci sequence.  If args.limit > 0, Fib
+      ///  generates up to limit numbers; otherwise it continues until the call is
+      ///  canceled.  Unlike Fib above, Fib has no final FibReply.
+      /// </summary>
       Task Fib(global::Math.FibArgs request, IServerStreamWriter<global::Math.Num> responseStream, ServerCallContext context);
+      /// <summary>
+      ///  Sum sums a stream of numbers, returning the final result once the stream
+      ///  is closed.
+      /// </summary>
       Task<global::Math.Num> Sum(IAsyncStreamReader<global::Math.Num> requestStream, ServerCallContext context);
     }
 
-    // server-side abstract class
+    /// <summary>Base class for server-side implementations of Math</summary>
     public abstract class MathBase
     {
+      /// <summary>
+      ///  Div divides args.dividend by args.divisor and returns the quotient and
+      ///  remainder.
+      /// </summary>
       public virtual Task<global::Math.DivReply> Div(global::Math.DivArgs request, ServerCallContext context)
       {
         throw new RpcException(new Status(StatusCode.Unimplemented, ""));
       }
 
+      /// <summary>
+      ///  DivMany accepts an arbitrary number of division args from the client stream
+      ///  and sends back the results in the reply stream.  The stream continues until
+      ///  the client closes its end; the server does the same after sending all the
+      ///  replies.  The stream ends immediately if either end aborts.
+      /// </summary>
       public virtual Task DivMany(IAsyncStreamReader<global::Math.DivArgs> requestStream, IServerStreamWriter<global::Math.DivReply> responseStream, ServerCallContext context)
       {
         throw new RpcException(new Status(StatusCode.Unimplemented, ""));
       }
 
+      /// <summary>
+      ///  Fib generates numbers in the Fibonacci sequence.  If args.limit > 0, Fib
+      ///  generates up to limit numbers; otherwise it continues until the call is
+      ///  canceled.  Unlike Fib above, Fib has no final FibReply.
+      /// </summary>
       public virtual Task Fib(global::Math.FibArgs request, IServerStreamWriter<global::Math.Num> responseStream, ServerCallContext context)
       {
         throw new RpcException(new Status(StatusCode.Unimplemented, ""));
       }
 
+      /// <summary>
+      ///  Sum sums a stream of numbers, returning the final result once the stream
+      ///  is closed.
+      /// </summary>
       public virtual Task<global::Math.Num> Sum(IAsyncStreamReader<global::Math.Num> requestStream, ServerCallContext context)
       {
         throw new RpcException(new Status(StatusCode.Unimplemented, ""));
@@ -102,7 +216,7 @@ namespace Math {
 
     }
 
-    // client stub
+    /// <summary>Client for Math</summary>
     #pragma warning disable 0618
     public class MathClient : ClientBase<MathClient>, IMathClient
     #pragma warning restore 0618
@@ -122,42 +236,88 @@ namespace Math {
       {
       }
 
+      /// <summary>
+      ///  Div divides args.dividend by args.divisor and returns the quotient and
+      ///  remainder.
+      /// </summary>
       public virtual global::Math.DivReply Div(global::Math.DivArgs request, Metadata headers = null, DateTime? deadline = null, CancellationToken cancellationToken = default(CancellationToken))
       {
         return Div(request, new CallOptions(headers, deadline, cancellationToken));
       }
+      /// <summary>
+      ///  Div divides args.dividend by args.divisor and returns the quotient and
+      ///  remainder.
+      /// </summary>
       public virtual global::Math.DivReply Div(global::Math.DivArgs request, CallOptions options)
       {
         return CallInvoker.BlockingUnaryCall(__Method_Div, null, options, request);
       }
+      /// <summary>
+      ///  Div divides args.dividend by args.divisor and returns the quotient and
+      ///  remainder.
+      /// </summary>
       public virtual AsyncUnaryCall<global::Math.DivReply> DivAsync(global::Math.DivArgs request, Metadata headers = null, DateTime? deadline = null, CancellationToken cancellationToken = default(CancellationToken))
       {
         return DivAsync(request, new CallOptions(headers, deadline, cancellationToken));
       }
+      /// <summary>
+      ///  Div divides args.dividend by args.divisor and returns the quotient and
+      ///  remainder.
+      /// </summary>
       public virtual AsyncUnaryCall<global::Math.DivReply> DivAsync(global::Math.DivArgs request, CallOptions options)
       {
         return CallInvoker.AsyncUnaryCall(__Method_Div, null, options, request);
       }
+      /// <summary>
+      ///  DivMany accepts an arbitrary number of division args from the client stream
+      ///  and sends back the results in the reply stream.  The stream continues until
+      ///  the client closes its end; the server does the same after sending all the
+      ///  replies.  The stream ends immediately if either end aborts.
+      /// </summary>
       public virtual AsyncDuplexStreamingCall<global::Math.DivArgs, global::Math.DivReply> DivMany(Metadata headers = null, DateTime? deadline = null, CancellationToken cancellationToken = default(CancellationToken))
       {
         return DivMany(new CallOptions(headers, deadline, cancellationToken));
       }
+      /// <summary>
+      ///  DivMany accepts an arbitrary number of division args from the client stream
+      ///  and sends back the results in the reply stream.  The stream continues until
+      ///  the client closes its end; the server does the same after sending all the
+      ///  replies.  The stream ends immediately if either end aborts.
+      /// </summary>
       public virtual AsyncDuplexStreamingCall<global::Math.DivArgs, global::Math.DivReply> DivMany(CallOptions options)
       {
         return CallInvoker.AsyncDuplexStreamingCall(__Method_DivMany, null, options);
       }
+      /// <summary>
+      ///  Fib generates numbers in the Fibonacci sequence.  If args.limit > 0, Fib
+      ///  generates up to limit numbers; otherwise it continues until the call is
+      ///  canceled.  Unlike Fib above, Fib has no final FibReply.
+      /// </summary>
       public virtual AsyncServerStreamingCall<global::Math.Num> Fib(global::Math.FibArgs request, Metadata headers = null, DateTime? deadline = null, CancellationToken cancellationToken = default(CancellationToken))
       {
         return Fib(request, new CallOptions(headers, deadline, cancellationToken));
       }
+      /// <summary>
+      ///  Fib generates numbers in the Fibonacci sequence.  If args.limit > 0, Fib
+      ///  generates up to limit numbers; otherwise it continues until the call is
+      ///  canceled.  Unlike Fib above, Fib has no final FibReply.
+      /// </summary>
       public virtual AsyncServerStreamingCall<global::Math.Num> Fib(global::Math.FibArgs request, CallOptions options)
       {
         return CallInvoker.AsyncServerStreamingCall(__Method_Fib, null, options, request);
       }
+      /// <summary>
+      ///  Sum sums a stream of numbers, returning the final result once the stream
+      ///  is closed.
+      /// </summary>
       public virtual AsyncClientStreamingCall<global::Math.Num, global::Math.Num> Sum(Metadata headers = null, DateTime? deadline = null, CancellationToken cancellationToken = default(CancellationToken))
       {
         return Sum(new CallOptions(headers, deadline, cancellationToken));
       }
+      /// <summary>
+      ///  Sum sums a stream of numbers, returning the final result once the stream
+      ///  is closed.
+      /// </summary>
       public virtual AsyncClientStreamingCall<global::Math.Num, global::Math.Num> Sum(CallOptions options)
       {
         return CallInvoker.AsyncClientStreamingCall(__Method_Sum, null, options);
@@ -168,13 +328,13 @@ namespace Math {
       }
     }
 
-    // creates a new client
+    /// <summary>Creates a new client for Math</summary>
     public static MathClient NewClient(Channel channel)
     {
       return new MathClient(channel);
     }
 
-    // creates service definition that can be registered with a server
+    /// <summary>Creates service definition that can be registered with a server</summary>
     #pragma warning disable 0618
     public static ServerServiceDefinition BindService(IMath serviceImpl)
     #pragma warning restore 0618
@@ -186,7 +346,7 @@ namespace Math {
           .AddMethod(__Method_Sum, serviceImpl.Sum).Build();
     }
 
-    // creates service definition that can be registered with a server
+    /// <summary>Creates service definition that can be registered with a server</summary>
     #pragma warning disable 0618
     public static ServerServiceDefinition BindService(MathBase serviceImpl)
     #pragma warning restore 0618

src/csharp/Grpc.HealthCheck/HealthGrpc.cs

@@ -1,5 +1,35 @@
 // Generated by the protocol buffer compiler.  DO NOT EDIT!
 // source: health.proto
+// Original file comments:
+// Copyright 2015, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
 #region Designer generated code
 
 using System;
@@ -22,13 +52,13 @@ namespace Grpc.Health.V1 {
         __Marshaller_HealthCheckRequest,
         __Marshaller_HealthCheckResponse);
 
-    // service descriptor
+    /// <summary>Service descriptor</summary>
     public static global::Google.Protobuf.Reflection.ServiceDescriptor Descriptor
     {
       get { return global::Grpc.Health.V1.HealthReflection.Descriptor.Services[0]; }
     }
 
-    // client interface
+    /// <summary>Client for Health</summary>
     [System.Obsolete("Client side interfaced will be removed in the next release. Use client class directly.")]
     public interface IHealthClient
     {
@@ -38,14 +68,14 @@ namespace Grpc.Health.V1 {
       AsyncUnaryCall<global::Grpc.Health.V1.HealthCheckResponse> CheckAsync(global::Grpc.Health.V1.HealthCheckRequest request, CallOptions options);
     }
 
-    // server-side interface
+    /// <summary>Interface of server-side implementations of Health</summary>
     [System.Obsolete("Service implementations should inherit from the generated abstract base class instead.")]
     public interface IHealth
     {
       Task<global::Grpc.Health.V1.HealthCheckResponse> Check(global::Grpc.Health.V1.HealthCheckRequest request, ServerCallContext context);
     }
 
-    // server-side abstract class
+    /// <summary>Base class for server-side implementations of Health</summary>
     public abstract class HealthBase
     {
       public virtual Task<global::Grpc.Health.V1.HealthCheckResponse> Check(global::Grpc.Health.V1.HealthCheckRequest request, ServerCallContext context)
@@ -55,7 +85,7 @@ namespace Grpc.Health.V1 {
 
     }
 
-    // client stub
+    /// <summary>Client for Health</summary>
     #pragma warning disable 0618
     public class HealthClient : ClientBase<HealthClient>, IHealthClient
     #pragma warning restore 0618
@@ -97,13 +127,13 @@ namespace Grpc.Health.V1 {
       }
     }
 
-    // creates a new client
+    /// <summary>Creates a new client for Health</summary>
     public static HealthClient NewClient(Channel channel)
     {
       return new HealthClient(channel);
     }
 
-    // creates service definition that can be registered with a server
+    /// <summary>Creates service definition that can be registered with a server</summary>
     #pragma warning disable 0618
     public static ServerServiceDefinition BindService(IHealth serviceImpl)
     #pragma warning restore 0618
@@ -112,7 +142,7 @@ namespace Grpc.Health.V1 {
           .AddMethod(__Method_Check, serviceImpl.Check).Build();
     }
 
-    // creates service definition that can be registered with a server
+    /// <summary>Creates service definition that can be registered with a server</summary>
     #pragma warning disable 0618
     public static ServerServiceDefinition BindService(HealthBase serviceImpl)
     #pragma warning restore 0618

src/csharp/Grpc.IntegrationTesting/MetricsGrpc.cs

@@ -1,5 +1,41 @@
 // Generated by the protocol buffer compiler.  DO NOT EDIT!
 // source: src/proto/grpc/testing/metrics.proto
+// Original file comments:
+// Copyright 2015-2016, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Contains the definitions for a metrics service and the type of metrics
+// exposed by the service.
+//
+// Currently, 'Gauge' (i.e a metric that represents the measured value of
+// something at an instant of time) is the only metric type supported by the
+// service.
 #region Designer generated code
 
 using System;
@@ -30,40 +66,74 @@ namespace Grpc.Testing {
         __Marshaller_GaugeRequest,
         __Marshaller_GaugeResponse);
 
-    // service descriptor
+    /// <summary>Service descriptor</summary>
     public static global::Google.Protobuf.Reflection.ServiceDescriptor Descriptor
     {
       get { return global::Grpc.Testing.MetricsReflection.Descriptor.Services[0]; }
     }
 
-    // client interface
+    /// <summary>Client for MetricsService</summary>
     [System.Obsolete("Client side interfaced will be removed in the next release. Use client class directly.")]
     public interface IMetricsServiceClient
     {
+      /// <summary>
+      ///  Returns the values of all the gauges that are currently being maintained by
+      ///  the service
+      /// </summary>
       AsyncServerStreamingCall<global::Grpc.Testing.GaugeResponse> GetAllGauges(global::Grpc.Testing.EmptyMessage request, Metadata headers = null, DateTime? deadline = null, CancellationToken cancellationToken = default(CancellationToken));
+      /// <summary>
+      ///  Returns the values of all the gauges that are currently being maintained by
+      ///  the service
+      /// </summary>
       AsyncServerStreamingCall<global::Grpc.Testing.GaugeResponse> GetAllGauges(global::Grpc.Testing.EmptyMessage request, CallOptions options);
+      /// <summary>
+      ///  Returns the value of one gauge
+      /// </summary>
       global::Grpc.Testing.GaugeResponse GetGauge(global::Grpc.Testing.GaugeRequest request, Metadata headers = null, DateTime? deadline = null, CancellationToken cancellationToken = default(CancellationToken));
+      /// <summary>
+      ///  Returns the value of one gauge
+      /// </summary>
       global::Grpc.Testing.GaugeResponse GetGauge(global::Grpc.Testing.GaugeRequest request, CallOptions options);
+      /// <summary>
+      ///  Returns the value of one gauge
+      /// </summary>
       AsyncUnaryCall<global::Grpc.Testing.GaugeResponse> GetGaugeAsync(global::Grpc.Testing.GaugeRequest request, Metadata headers = null, DateTime? deadline = null, CancellationToken cancellationToken = default(CancellationToken));
+      /// <summary>
+      ///  Returns the value of one gauge
+      /// </summary>
       AsyncUnaryCall<global::Grpc.Testing.GaugeResponse> GetGaugeAsync(global::Grpc.Testing.GaugeRequest request, CallOptions options);
     }
 
-    // server-side interface
+    /// <summary>Interface of server-side implementations of MetricsService</summary>
     [System.Obsolete("Service implementations should inherit from the generated abstract base class instead.")]
     public interface IMetricsService
     {
+      /// <summary>
+      ///  Returns the values of all the gauges that are currently being maintained by
+      ///  the service
+      /// </summary>
       Task GetAllGauges(global::Grpc.Testing.EmptyMessage request, IServerStreamWriter<global::Grpc.Testing.GaugeResponse> responseStream, ServerCallContext context);
+      /// <summary>
+      ///  Returns the value of one gauge
+      /// </summary>
       Task<global::Grpc.Testing.GaugeResponse> GetGauge(global::Grpc.Testing.GaugeRequest request, ServerCallContext context);
     }
 
-    // server-side abstract class
+    /// <summary>Base class for server-side implementations of MetricsService</summary>
     public abstract class MetricsServiceBase
     {
+      /// <summary>
+      ///  Returns the values of all the gauges that are currently being maintained by
+      ///  the service
+      /// </summary>
       public virtual Task GetAllGauges(global::Grpc.Testing.EmptyMessage request, IServerStreamWriter<global::Grpc.Testing.GaugeResponse> responseStream, ServerCallContext context)
       {
         throw new RpcException(new Status(StatusCode.Unimplemented, ""));
       }
 
+      /// <summary>
+      ///  Returns the value of one gauge
+      /// </summary>
       public virtual Task<global::Grpc.Testing.GaugeResponse> GetGauge(global::Grpc.Testing.GaugeRequest request, ServerCallContext context)
       {
         throw new RpcException(new Status(StatusCode.Unimplemented, ""));
@@ -71,7 +141,7 @@ namespace Grpc.Testing {
 
     }
 
-    // client stub
+    /// <summary>Client for MetricsService</summary>
     #pragma warning disable 0618
     public class MetricsServiceClient : ClientBase<MetricsServiceClient>, IMetricsServiceClient
     #pragma warning restore 0618
@@ -91,26 +161,46 @@ namespace Grpc.Testing {
       {
       }
 
+      /// <summary>
+      ///  Returns the values of all the gauges that are currently being maintained by
+      ///  the service
+      /// </summary>
       public virtual AsyncServerStreamingCall<global::Grpc.Testing.GaugeResponse> GetAllGauges(global::Grpc.Testing.EmptyMessage request, Metadata headers = null, DateTime? deadline = null, CancellationToken cancellationToken = default(CancellationToken))
       {
         return GetAllGauges(request, new CallOptions(headers, deadline, cancellationToken));
       }
+      /// <summary>
+      ///  Returns the values of all the gauges that are currently being maintained by
+      ///  the service
+      /// </summary>
       public virtual AsyncServerStreamingCall<global::Grpc.Testing.GaugeResponse> GetAllGauges(global::Grpc.Testing.EmptyMessage request, CallOptions options)
       {
         return CallInvoker.AsyncServerStreamingCall(__Method_GetAllGauges, null, options, request);
       }
+      /// <summary>
+      ///  Returns the value of one gauge
+      /// </summary>
       public virtual global::Grpc.Testing.GaugeResponse GetGauge(global::Grpc.Testing.GaugeRequest request, Metadata headers = null, DateTime? deadline = null, CancellationToken cancellationToken = default(CancellationToken))
       {
         return GetGauge(request, new CallOptions(headers, deadline, cancellationToken));
       }
+      /// <summary>
+      ///  Returns the value of one gauge
+      /// </summary>
       public virtual global::Grpc.Testing.GaugeResponse GetGauge(global::Grpc.Testing.GaugeRequest request, CallOptions options)
       {
         return CallInvoker.BlockingUnaryCall(__Method_GetGauge, null, options, request);
       }
+      /// <summary>
+      ///  Returns the value of one gauge
+      /// </summary>
       public virtual AsyncUnaryCall<global::Grpc.Testing.GaugeResponse> GetGaugeAsync(global::Grpc.Testing.GaugeRequest request, Metadata headers = null, DateTime? deadline = null, CancellationToken cancellationToken = default(CancellationToken))
       {
         return GetGaugeAsync(request, new CallOptions(headers, deadline, cancellationToken));
       }
+      /// <summary>
+      ///  Returns the value of one gauge
+      /// </summary>
       public virtual AsyncUnaryCall<global::Grpc.Testing.GaugeResponse> GetGaugeAsync(global::Grpc.Testing.GaugeRequest request, CallOptions options)
       {
         return CallInvoker.AsyncUnaryCall(__Method_GetGauge, null, options, request);
@@ -121,13 +211,13 @@ namespace Grpc.Testing {
       }
     }
 
-    // creates a new client
+    /// <summary>Creates a new client for MetricsService</summary>
     public static MetricsServiceClient NewClient(Channel channel)
     {
       return new MetricsServiceClient(channel);
     }
 
-    // creates service definition that can be registered with a server
+    /// <summary>Creates service definition that can be registered with a server</summary>
     #pragma warning disable 0618
     public static ServerServiceDefinition BindService(IMetricsService serviceImpl)
     #pragma warning restore 0618
@@ -137,7 +227,7 @@ namespace Grpc.Testing {
           .AddMethod(__Method_GetGauge, serviceImpl.GetGauge).Build();
     }
 
-    // creates service definition that can be registered with a server
+    /// <summary>Creates service definition that can be registered with a server</summary>
     #pragma warning disable 0618
     public static ServerServiceDefinition BindService(MetricsServiceBase serviceImpl)
     #pragma warning restore 0618

src/csharp/Grpc.IntegrationTesting/ServicesGrpc.cs

@@ -1,5 +1,37 @@
 // Generated by the protocol buffer compiler.  DO NOT EDIT!
 // source: src/proto/grpc/testing/services.proto
+// Original file comments:
+// Copyright 2015, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// An integration test service that covers all the method signature permutations
+// of unary/streaming requests/responses.
 #region Designer generated code
 
 using System;
@@ -29,40 +61,80 @@ namespace Grpc.Testing {
         __Marshaller_SimpleRequest,
         __Marshaller_SimpleResponse);
 
-    // service descriptor
+    /// <summary>Service descriptor</summary>
     public static global::Google.Protobuf.Reflection.ServiceDescriptor Descriptor
     {
       get { return global::Grpc.Testing.ServicesReflection.Descriptor.Services[0]; }
     }
 
-    // client interface
+    /// <summary>Client for BenchmarkService</summary>
     [System.Obsolete("Client side interfaced will be removed in the next release. Use client class directly.")]
     public interface IBenchmarkServiceClient
     {
+      /// <summary>
+      ///  One request followed by one response.
+      ///  The server returns the client payload as-is.
+      /// </summary>
       global::Grpc.Testing.SimpleResponse UnaryCall(global::Grpc.Testing.SimpleRequest request, Metadata headers = null, DateTime? deadline = null, CancellationToken cancellationToken = default(CancellationToken));
+      /// <summary>
+      ///  One request followed by one response.
+      ///  The server returns the client payload as-is.
+      /// </summary>
       global::Grpc.Testing.SimpleResponse UnaryCall(global::Grpc.Testing.SimpleRequest request, CallOptions options);
+      /// <summary>
+      ///  One request followed by one response.
+      ///  The server returns the client payload as-is.
+      /// </summary>
       AsyncUnaryCall<global::Grpc.Testing.SimpleResponse> UnaryCallAsync(global::Grpc.Testing.SimpleRequest request, Metadata headers = null, DateTime? deadline = null, CancellationToken cancellationToken = default(CancellationToken));
+      /// <summary>
+      ///  One request followed by one response.
+      ///  The server returns the client payload as-is.
+      /// </summary>
       AsyncUnaryCall<global::Grpc.Testing.SimpleResponse> UnaryCallAsync(global::Grpc.Testing.SimpleRequest request, CallOptions options);
+      /// <summary>
+      ///  One request followed by one response.
+      ///  The server returns the client payload as-is.
+      /// </summary>
       AsyncDuplexStreamingCall<global::Grpc.Testing.SimpleRequest, global::Grpc.Testing.SimpleResponse> StreamingCall(Metadata headers = null, DateTime? deadline = null, CancellationToken cancellationToken = default(CancellationToken));
+      /// <summary>
+      ///  One request followed by one response.
+      ///  The server returns the client payload as-is.
+      /// </summary>
       AsyncDuplexStreamingCall<global::Grpc.Testing.SimpleRequest, global::Grpc.Testing.SimpleResponse> StreamingCall(CallOptions options);
     }
 
-    // server-side interface
+    /// <summary>Interface of server-side implementations of BenchmarkService</summary>
     [System.Obsolete("Service implementations should inherit from the generated abstract base class instead.")]
     public interface IBenchmarkService
     {
+      /// <summary>
+      ///  One request followed by one response.
+      ///  The server returns the client payload as-is.
+      /// </summary>
       Task<global::Grpc.Testing.SimpleResponse> UnaryCall(global::Grpc.Testing.SimpleRequest request, ServerCallContext context);
+      /// <summary>
+      ///  One request followed by one response.
+      ///  The server returns the client payload as-is.
+      /// </summary>
       Task StreamingCall(IAsyncStreamReader<global::Grpc.Testing.SimpleRequest> requestStream, IServerStreamWriter<global::Grpc.Testing.SimpleResponse> responseStream, ServerCallContext context);
     }
 
-    // server-side abstract class
+    /// <summary>Base class for server-side implementations of BenchmarkService</summary>
     public abstract class BenchmarkServiceBase
     {
+      /// <summary>
+      ///  One request followed by one response.
+      ///  The server returns the client payload as-is.
+      /// </summary>
       public virtual Task<global::Grpc.Testing.SimpleResponse> UnaryCall(global::Grpc.Testing.SimpleRequest request, ServerCallContext context)
       {
         throw new RpcException(new Status(StatusCode.Unimplemented, ""));
       }
 
+      /// <summary>
+      ///  One request followed by one response.
+      ///  The server returns the client payload as-is.
+      /// </summary>
       public virtual Task StreamingCall(IAsyncStreamReader<global::Grpc.Testing.SimpleRequest> requestStream, IServerStreamWriter<global::Grpc.Testing.SimpleResponse> responseStream, ServerCallContext context)
       {
         throw new RpcException(new Status(StatusCode.Unimplemented, ""));
@@ -70,7 +142,7 @@ namespace Grpc.Testing {
 
     }
 
-    // client stub
+    /// <summary>Client for BenchmarkService</summary>
     #pragma warning disable 0618
     public class BenchmarkServiceClient : ClientBase<BenchmarkServiceClient>, IBenchmarkServiceClient
     #pragma warning restore 0618
@@ -90,26 +162,50 @@ namespace Grpc.Testing {
       {
       }
 
+      /// <summary>
+      ///  One request followed by one response.
+      ///  The server returns the client payload as-is.
+      /// </summary>
       public virtual global::Grpc.Testing.SimpleResponse UnaryCall(global::Grpc.Testing.SimpleRequest request, Metadata headers = null, DateTime? deadline = null, CancellationToken cancellationToken = default(CancellationToken))
       {
         return UnaryCall(request, new CallOptions(headers, deadline, cancellationToken));
       }
+      /// <summary>
+      ///  One request followed by one response.
+      ///  The server returns the client payload as-is.
+      /// </summary>
       public virtual global::Grpc.Testing.SimpleResponse UnaryCall(global::Grpc.Testing.SimpleRequest request, CallOptions options)
       {
         return CallInvoker.BlockingUnaryCall(__Method_UnaryCall, null, options, request);
       }
+      /// <summary>
+      ///  One request followed by one response.
+      ///  The server returns the client payload as-is.
+      /// </summary>
       public virtual AsyncUnaryCall<global::Grpc.Testing.SimpleResponse> UnaryCallAsync(global::Grpc.Testing.SimpleRequest request, Metadata headers = null, DateTime? deadline = null, CancellationToken cancellationToken = default(CancellationToken))
       {
         return UnaryCallAsync(request, new CallOptions(headers, deadline, cancellationToken));
       }
+      /// <summary>
+      ///  One request followed by one response.
+      ///  The server returns the client payload as-is.
+      /// </summary>
       public virtual AsyncUnaryCall<global::Grpc.Testing.SimpleResponse> UnaryCallAsync(global::Grpc.Testing.SimpleRequest request, CallOptions options)
       {
         return CallInvoker.AsyncUnaryCall(__Method_UnaryCall, null, options, request);
       }
+      /// <summary>
+      ///  One request followed by one response.
+      ///  The server returns the client payload as-is.
+      /// </summary>
       public virtual AsyncDuplexStreamingCall<global::Grpc.Testing.SimpleRequest, global::Grpc.Testing.SimpleResponse> StreamingCall(Metadata headers = null, DateTime? deadline = null, CancellationToken cancellationToken = default(CancellationToken))
       {
         return StreamingCall(new CallOptions(headers, deadline, cancellationToken));
       }
+      /// <summary>
+      ///  One request followed by one response.
+      ///  The server returns the client payload as-is.
+      /// </summary>
       public virtual AsyncDuplexStreamingCall<global::Grpc.Testing.SimpleRequest, global::Grpc.Testing.SimpleResponse> StreamingCall(CallOptions options)
       {
         return CallInvoker.AsyncDuplexStreamingCall(__Method_StreamingCall, null, options);
@@ -120,13 +216,13 @@ namespace Grpc.Testing {
       }
     }
 
-    // creates a new client
+    /// <summary>Creates a new client for BenchmarkService</summary>
     public static BenchmarkServiceClient NewClient(Channel channel)
     {
       return new BenchmarkServiceClient(channel);
     }
 
-    // creates service definition that can be registered with a server
+    /// <summary>Creates service definition that can be registered with a server</summary>
     #pragma warning disable 0618
     public static ServerServiceDefinition BindService(IBenchmarkService serviceImpl)
     #pragma warning restore 0618
@@ -136,7 +232,7 @@ namespace Grpc.Testing {
           .AddMethod(__Method_StreamingCall, serviceImpl.StreamingCall).Build();
     }
 
-    // creates service definition that can be registered with a server
+    /// <summary>Creates service definition that can be registered with a server</summary>
     #pragma warning disable 0618
     public static ServerServiceDefinition BindService(BenchmarkServiceBase serviceImpl)
     #pragma warning restore 0618
@@ -187,58 +283,158 @@ namespace Grpc.Testing {
         __Marshaller_Void,
         __Marshaller_Void);
 
-    // service descriptor
+    /// <summary>Service descriptor</summary>
     public static global::Google.Protobuf.Reflection.ServiceDescriptor Descriptor
     {
       get { return global::Grpc.Testing.ServicesReflection.Descriptor.Services[1]; }
     }
 
-    // client interface
+    /// <summary>Client for WorkerService</summary>
     [System.Obsolete("Client side interfaced will be removed in the next release. Use client class directly.")]
     public interface IWorkerServiceClient
     {
+      /// <summary>
+      ///  Start server with specified workload.
+      ///  First request sent specifies the ServerConfig followed by ServerStatus
+      ///  response. After that, a "Mark" can be sent anytime to request the latest
+      ///  stats. Closing the stream will initiate shutdown of the test server
+      ///  and once the shutdown has finished, the OK status is sent to terminate
+      ///  this RPC.
+      /// </summary>
       AsyncDuplexStreamingCall<global::Grpc.Testing.ServerArgs, global::Grpc.Testing.ServerStatus> RunServer(Metadata headers = null, DateTime? deadline = null, CancellationToken cancellationToken = default(CancellationToken));
+      /// <summary>
+      ///  Start server with specified workload.
+      ///  First request sent specifies the ServerConfig followed by ServerStatus
+      ///  response. After that, a "Mark" can be sent anytime to request the latest
+      ///  stats. Closing the stream will initiate shutdown of the test server
+      ///  and once the shutdown has finished, the OK status is sent to terminate
+      ///  this RPC.
+      /// </summary>
       AsyncDuplexStreamingCall<global::Grpc.Testing.ServerArgs, global::Grpc.Testing.ServerStatus> RunServer(CallOptions options);
+      /// <summary>
+      ///  Start client with specified workload.
+      ///  First request sent specifies the ClientConfig followed by ClientStatus
+      ///  response. After that, a "Mark" can be sent anytime to request the latest
+      ///  stats. Closing the stream will initiate shutdown of the test client
+      ///  and once the shutdown has finished, the OK status is sent to terminate
+      ///  this RPC.
+      /// </summary>
       AsyncDuplexStreamingCall<global::Grpc.Testing.ClientArgs, global::Grpc.Testing.ClientStatus> RunClient(Metadata headers = null, DateTime? deadline = null, CancellationToken cancellationToken = default(CancellationToken));
+      /// <summary>
+      ///  Start client with specified workload.
+      ///  First request sent specifies the ClientConfig followed by ClientStatus
+      ///  response. After that, a "Mark" can be sent anytime to request the latest
+      ///  stats. Closing the stream will initiate shutdown of the test client
+      ///  and once the shutdown has finished, the OK status is sent to terminate
+      ///  this RPC.
+      /// </summary>
       AsyncDuplexStreamingCall<global::Grpc.Testing.ClientArgs, global::Grpc.Testing.ClientStatus> RunClient(CallOptions options);
+      /// <summary>
+      ///  Just return the core count - unary call
+      /// </summary>
       global::Grpc.Testing.CoreResponse CoreCount(global::Grpc.Testing.CoreRequest request, Metadata headers = null, DateTime? deadline = null, CancellationToken cancellationToken = default(CancellationToken));
+      /// <summary>
+      ///  Just return the core count - unary call
+      /// </summary>
       global::Grpc.Testing.CoreResponse CoreCount(global::Grpc.Testing.CoreRequest request, CallOptions options);
+      /// <summary>
+      ///  Just return the core count - unary call
+      /// </summary>
       AsyncUnaryCall<global::Grpc.Testing.CoreResponse> CoreCountAsync(global::Grpc.Testing.CoreRequest request, Metadata headers = null, DateTime? deadline = null, CancellationToken cancellationToken = default(CancellationToken));
+      /// <summary>
+      ///  Just return the core count - unary call
+      /// </summary>
       AsyncUnaryCall<global::Grpc.Testing.CoreResponse> CoreCountAsync(global::Grpc.Testing.CoreRequest request, CallOptions options);
+      /// <summary>
+      ///  Quit this worker
+      /// </summary>
       global::Grpc.Testing.Void QuitWorker(global::Grpc.Testing.Void request, Metadata headers = null, DateTime? deadline = null, CancellationToken cancellationToken = default(CancellationToken));
+      /// <summary>
+      ///  Quit this worker
+      /// </summary>
       global::Grpc.Testing.Void QuitWorker(global::Grpc.Testing.Void request, CallOptions options);
+      /// <summary>
+      ///  Quit this worker
+      /// </summary>
       AsyncUnaryCall<global::Grpc.Testing.Void> QuitWorkerAsync(global::Grpc.Testing.Void request, Metadata headers = null, DateTime? deadline = null, CancellationToken cancellationToken = default(CancellationToken));
+      /// <summary>
+      ///  Quit this worker
+      /// </summary>
       AsyncUnaryCall<global::Grpc.Testing.Void> QuitWorkerAsync(global::Grpc.Testing.Void request, CallOptions options);
     }
 
-    // server-side interface
+    /// <summary>Interface of server-side implementations of WorkerService</summary>
     [System.Obsolete("Service implementations should inherit from the generated abstract base class instead.")]
     public interface IWorkerService
     {
+      /// <summary>
+      ///  Start server with specified workload.
+      ///  First request sent specifies the ServerConfig followed by ServerStatus
+      ///  response. After that, a "Mark" can be sent anytime to request the latest
+      ///  stats. Closing the stream will initiate shutdown of the test server
+      ///  and once the shutdown has finished, the OK status is sent to terminate
+      ///  this RPC.
+      /// </summary>
       Task RunServer(IAsyncStreamReader<global::Grpc.Testing.ServerArgs> requestStream, IServerStreamWriter<global::Grpc.Testing.ServerStatus> responseStream, ServerCallContext context);
+      /// <summary>
+      ///  Start client with specified workload.
+      ///  First request sent specifies the ClientConfig followed by ClientStatus
+      ///  response. After that, a "Mark" can be sent anytime to request the latest
+      ///  stats. Closing the stream will initiate shutdown of the test client
+      ///  and once the shutdown has finished, the OK status is sent to terminate
+      ///  this RPC.
+      /// </summary>
       Task RunClient(IAsyncStreamReader<global::Grpc.Testing.ClientArgs> requestStream, IServerStreamWriter<global::Grpc.Testing.ClientStatus> responseStream, ServerCallContext context);
+      /// <summary>
+      ///  Just return the core count - unary call
+      /// </summary>
       Task<global::Grpc.Testing.CoreResponse> CoreCount(global::Grpc.Testing.CoreRequest request, ServerCallContext context);
+      /// <summary>
+      ///  Quit this worker
+      /// </summary>
       Task<global::Grpc.Testing.Void> QuitWorker(global::Grpc.Testing.Void request, ServerCallContext context);
     }
 
-    // server-side abstract class
+    /// <summary>Base class for server-side implementations of WorkerService</summary>
     public abstract class WorkerServiceBase
     {
+      /// <summary>
+      ///  Start server with specified workload.
+      ///  First request sent specifies the ServerConfig followed by ServerStatus
+      ///  response. After that, a "Mark" can be sent anytime to request the latest
+      ///  stats. Closing the stream will initiate shutdown of the test server
+      ///  and once the shutdown has finished, the OK status is sent to terminate
+      ///  this RPC.
+      /// </summary>
       public virtual Task RunServer(IAsyncStreamReader<global::Grpc.Testing.ServerArgs> requestStream, IServerStreamWriter<global::Grpc.Testing.ServerStatus> responseStream, ServerCallContext context)
       {
         throw new RpcException(new Status(StatusCode.Unimplemented, ""));
       }
 
+      /// <summary>
+      ///  Start client with specified workload.
+      ///  First request sent specifies the ClientConfig followed by ClientStatus
+      ///  response. After that, a "Mark" can be sent anytime to request the latest
+      ///  stats. Closing the stream will initiate shutdown of the test client
+      ///  and once the shutdown has finished, the OK status is sent to terminate
+      ///  this RPC.
+      /// </summary>
       public virtual Task RunClient(IAsyncStreamReader<global::Grpc.Testing.ClientArgs> requestStream, IServerStreamWriter<global::Grpc.Testing.ClientStatus> responseStream, ServerCallContext context)
       {
         throw new RpcException(new Status(StatusCode.Unimplemented, ""));
       }
 
+      /// <summary>
+      ///  Just return the core count - unary call
+      /// </summary>
       public virtual Task<global::Grpc.Testing.CoreResponse> CoreCount(global::Grpc.Testing.CoreRequest request, ServerCallContext context)
       {
         throw new RpcException(new Status(StatusCode.Unimplemented, ""));
       }
 
+      /// <summary>
+      ///  Quit this worker
+      /// </summary>
       public virtual Task<global::Grpc.Testing.Void> QuitWorker(global::Grpc.Testing.Void request, ServerCallContext context)
       {
         throw new RpcException(new Status(StatusCode.Unimplemented, ""));
@@ -246,7 +442,7 @@ namespace Grpc.Testing {
 
     }
 
-    // client stub
+    /// <summary>Client for WorkerService</summary>
     #pragma warning disable 0618
     public class WorkerServiceClient : ClientBase<WorkerServiceClient>, IWorkerServiceClient
     #pragma warning restore 0618
@@ -266,50 +462,106 @@ namespace Grpc.Testing {
       {
       }
 
+      /// <summary>
+      ///  Start server with specified workload.
+      ///  First request sent specifies the ServerConfig followed by ServerStatus
+      ///  response. After that, a "Mark" can be sent anytime to request the latest
+      ///  stats. Closing the stream will initiate shutdown of the test server
+      ///  and once the shutdown has finished, the OK status is sent to terminate
+      ///  this RPC.
+      /// </summary>
       public virtual AsyncDuplexStreamingCall<global::Grpc.Testing.ServerArgs, global::Grpc.Testing.ServerStatus> RunServer(Metadata headers = null, DateTime? deadline = null, CancellationToken cancellationToken = default(CancellationToken))
       {
         return RunServer(new CallOptions(headers, deadline, cancellationToken));
       }
+      /// <summary>
+      ///  Start server with specified workload.
+      ///  First request sent specifies the ServerConfig followed by ServerStatus
+      ///  response. After that, a "Mark" can be sent anytime to request the latest
+      ///  stats. Closing the stream will initiate shutdown of the test server
+      ///  and once the shutdown has finished, the OK status is sent to terminate
+      ///  this RPC.
+      /// </summary>
       public virtual AsyncDuplexStreamingCall<global::Grpc.Testing.ServerArgs, global::Grpc.Testing.ServerStatus> RunServer(CallOptions options)
       {
         return CallInvoker.AsyncDuplexStreamingCall(__Method_RunServer, null, options);
       }
+      /// <summary>
+      ///  Start client with specified workload.
+      ///  First request sent specifies the ClientConfig followed by ClientStatus
+      ///  response. After that, a "Mark" can be sent anytime to request the latest
+      ///  stats. Closing the stream will initiate shutdown of the test client
+      ///  and once the shutdown has finished, the OK status is sent to terminate
+      ///  this RPC.
+      /// </summary>
       public virtual AsyncDuplexStreamingCall<global::Grpc.Testing.ClientArgs, global::Grpc.Testing.ClientStatus> RunClient(Metadata headers = null, DateTime? deadline = null, CancellationToken cancellationToken = default(CancellationToken))
       {
         return RunClient(new CallOptions(headers, deadline, cancellationToken));
       }
+      /// <summary>
+      ///  Start client with specified workload.
+      ///  First request sent specifies the ClientConfig followed by ClientStatus
+      ///  response. After that, a "Mark" can be sent anytime to request the latest
+      ///  stats. Closing the stream will initiate shutdown of the test client
+      ///  and once the shutdown has finished, the OK status is sent to terminate
+      ///  this RPC.
+      /// </summary>
       public virtual AsyncDuplexStreamingCall<global::Grpc.Testing.ClientArgs, global::Grpc.Testing.ClientStatus> RunClient(CallOptions options)
       {
         return CallInvoker.AsyncDuplexStreamingCall(__Method_RunClient, null, options);
       }
+      /// <summary>
+      ///  Just return the core count - unary call
+      /// </summary>
       public virtual global::Grpc.Testing.CoreResponse CoreCount(global::Grpc.Testing.CoreRequest request, Metadata headers = null, DateTime? deadline = null, CancellationToken cancellationToken = default(CancellationToken))
       {
         return CoreCount(request, new CallOptions(headers, deadline, cancellationToken));
       }
+      /// <summary>
+      ///  Just return the core count - unary call
+      /// </summary>
       public virtual global::Grpc.Testing.CoreResponse CoreCount(global::Grpc.Testing.CoreRequest request, CallOptions options)
       {
         return CallInvoker.BlockingUnaryCall(__Method_CoreCount, null, options, request);
       }
+      /// <summary>
+      ///  Just return the core count - unary call
+      /// </summary>
       public virtual AsyncUnaryCall<global::Grpc.Testing.CoreResponse> CoreCountAsync(global::Grpc.Testing.CoreRequest request, Metadata headers = null, DateTime? deadline = null, CancellationToken cancellationToken = default(CancellationToken))
       {
         return CoreCountAsync(request, new CallOptions(headers, deadline, cancellationToken));
       }
+      /// <summary>
+      ///  Just return the core count - unary call
+      /// </summary>
       public virtual AsyncUnaryCall<global::Grpc.Testing.CoreResponse> CoreCountAsync(global::Grpc.Testing.CoreRequest request, CallOptions options)
       {
         return CallInvoker.AsyncUnaryCall(__Method_CoreCount, null, options, request);
       }
+      /// <summary>
+      ///  Quit this worker
+      /// </summary>
       public virtual global::Grpc.Testing.Void QuitWorker(global::Grpc.Testing.Void request, Metadata headers = null, DateTime? deadline = null, CancellationToken cancellationToken = default(CancellationToken))
       {
         return QuitWorker(request, new CallOptions(headers, deadline, cancellationToken));
       }
+      /// <summary>
+      ///  Quit this worker
+      /// </summary>
       public virtual global::Grpc.Testing.Void QuitWorker(global::Grpc.Testing.Void request, CallOptions options)
       {
         return CallInvoker.BlockingUnaryCall(__Method_QuitWorker, null, options, request);
       }
+      /// <summary>
+      ///  Quit this worker
+      /// </summary>
       public virtual AsyncUnaryCall<global::Grpc.Testing.Void> QuitWorkerAsync(global::Grpc.Testing.Void request, Metadata headers = null, DateTime? deadline = null, CancellationToken cancellationToken = default(CancellationToken))
       {
         return QuitWorkerAsync(request, new CallOptions(headers, deadline, cancellationToken));
       }
+      /// <summary>
+      ///  Quit this worker
+      /// </summary>
       public virtual AsyncUnaryCall<global::Grpc.Testing.Void> QuitWorkerAsync(global::Grpc.Testing.Void request, CallOptions options)
       {
         return CallInvoker.AsyncUnaryCall(__Method_QuitWorker, null, options, request);
@@ -320,13 +572,13 @@ namespace Grpc.Testing {
       }
     }
 
-    // creates a new client
+    /// <summary>Creates a new client for WorkerService</summary>
     public static WorkerServiceClient NewClient(Channel channel)
     {
       return new WorkerServiceClient(channel);
     }
 
-    // creates service definition that can be registered with a server
+    /// <summary>Creates service definition that can be registered with a server</summary>
     #pragma warning disable 0618
     public static ServerServiceDefinition BindService(IWorkerService serviceImpl)
     #pragma warning restore 0618
@@ -338,7 +590,7 @@ namespace Grpc.Testing {
           .AddMethod(__Method_QuitWorker, serviceImpl.QuitWorker).Build();
     }
 
-    // creates service definition that can be registered with a server
+    /// <summary>Creates service definition that can be registered with a server</summary>
     #pragma warning disable 0618
     public static ServerServiceDefinition BindService(WorkerServiceBase serviceImpl)
     #pragma warning restore 0618

src/csharp/Grpc.IntegrationTesting/TestGrpc.cs

@@ -1,5 +1,38 @@
 // Generated by the protocol buffer compiler.  DO NOT EDIT!
 // source: src/proto/grpc/testing/test.proto
+// Original file comments:
+// Copyright 2015-2016, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// An integration test service that covers all the method signature permutations
+// of unary/streaming requests/responses.
+//
 #region Designer generated code
 
 using System;
@@ -8,6 +41,10 @@ using System.Threading.Tasks;
 using Grpc.Core;
 
 namespace Grpc.Testing {
+  /// <summary>
+  ///  A simple service to test the various types of RPCs and experiment with
+  ///  performance with various types of payload.
+  /// </summary>
   public static class TestService
   {
     static readonly string __ServiceName = "grpc.testing.TestService";
@@ -62,74 +99,186 @@ namespace Grpc.Testing {
         __Marshaller_StreamingOutputCallRequest,
         __Marshaller_StreamingOutputCallResponse);
 
-    // service descriptor
+    /// <summary>Service descriptor</summary>
     public static global::Google.Protobuf.Reflection.ServiceDescriptor Descriptor
     {
       get { return global::Grpc.Testing.TestReflection.Descriptor.Services[0]; }
     }
 
-    // client interface
+    /// <summary>Client for TestService</summary>
     [System.Obsolete("Client side interfaced will be removed in the next release. Use client class directly.")]
     public interface ITestServiceClient
     {
+      /// <summary>
+      ///  One empty request followed by one empty response.
+      /// </summary>
       global::Grpc.Testing.Empty EmptyCall(global::Grpc.Testing.Empty request, Metadata headers = null, DateTime? deadline = null, CancellationToken cancellationToken = default(CancellationToken));
+      /// <summary>
+      ///  One empty request followed by one empty response.
+      /// </summary>
       global::Grpc.Testing.Empty EmptyCall(global::Grpc.Testing.Empty request, CallOptions options);
+      /// <summary>
+      ///  One empty request followed by one empty response.
+      /// </summary>
       AsyncUnaryCall<global::Grpc.Testing.Empty> EmptyCallAsync(global::Grpc.Testing.Empty request, Metadata headers = null, DateTime? deadline = null, CancellationToken cancellationToken = default(CancellationToken));
+      /// <summary>
+      ///  One empty request followed by one empty response.
+      /// </summary>
       AsyncUnaryCall<global::Grpc.Testing.Empty> EmptyCallAsync(global::Grpc.Testing.Empty request, CallOptions options);
+      /// <summary>
+      ///  One request followed by one response.
+      /// </summary>
       global::Grpc.Testing.SimpleResponse UnaryCall(global::Grpc.Testing.SimpleRequest request, Metadata headers = null, DateTime? deadline = null, CancellationToken cancellationToken = default(CancellationToken));
+      /// <summary>
+      ///  One request followed by one response.
+      /// </summary>
       global::Grpc.Testing.SimpleResponse UnaryCall(global::Grpc.Testing.SimpleRequest request, CallOptions options);
+      /// <summary>
+      ///  One request followed by one response.
+      /// </summary>
       AsyncUnaryCall<global::Grpc.Testing.SimpleResponse> UnaryCallAsync(global::Grpc.Testing.SimpleRequest request, Metadata headers = null, DateTime? deadline = null, CancellationToken cancellationToken = default(CancellationToken));
+      /// <summary>
+      ///  One request followed by one response.
+      /// </summary>
       AsyncUnaryCall<global::Grpc.Testing.SimpleResponse> UnaryCallAsync(global::Grpc.Testing.SimpleRequest request, CallOptions options);
+      /// <summary>
+      ///  One request followed by a sequence of responses (streamed download).
+      ///  The server returns the payload with client desired type and sizes.
+      /// </summary>
       AsyncServerStreamingCall<global::Grpc.Testing.StreamingOutputCallResponse> StreamingOutputCall(global::Grpc.Testing.StreamingOutputCallRequest request, Metadata headers = null, DateTime? deadline = null, CancellationToken cancellationToken = default(CancellationToken));
+      /// <summary>
+      ///  One request followed by a sequence of responses (streamed download).
+      ///  The server returns the payload with client desired type and sizes.
+      /// </summary>
       AsyncServerStreamingCall<global::Grpc.Testing.StreamingOutputCallResponse> StreamingOutputCall(global::Grpc.Testing.StreamingOutputCallRequest request, CallOptions options);
+      /// <summary>
+      ///  A sequence of requests followed by one response (streamed upload).
+      ///  The server returns the aggregated size of client payload as the result.
+      /// </summary>
       AsyncClientStreamingCall<global::Grpc.Testing.StreamingInputCallRequest, global::Grpc.Testing.StreamingInputCallResponse> StreamingInputCall(Metadata headers = null, DateTime? deadline = null, CancellationToken cancellationToken = default(CancellationToken));
+      /// <summary>
+      ///  A sequence of requests followed by one response (streamed upload).
+      ///  The server returns the aggregated size of client payload as the result.
+      /// </summary>
       AsyncClientStreamingCall<global::Grpc.Testing.StreamingInputCallRequest, global::Grpc.Testing.StreamingInputCallResponse> StreamingInputCall(CallOptions options);
+      /// <summary>
+      ///  A sequence of requests with each request served by the server immediately.
+      ///  As one request could lead to multiple responses, this interface
+      ///  demonstrates the idea of full duplexing.
+      /// </summary>
       AsyncDuplexStreamingCall<global::Grpc.Testing.StreamingOutputCallRequest, global::Grpc.Testing.StreamingOutputCallResponse> FullDuplexCall(Metadata headers = null, DateTime? deadline = null, CancellationToken cancellationToken = default(CancellationToken));
+      /// <summary>
+      ///  A sequence of requests with each request served by the server immediately.
+      ///  As one request could lead to multiple responses, this interface
+      ///  demonstrates the idea of full duplexing.
+      /// </summary>
       AsyncDuplexStreamingCall<global::Grpc.Testing.StreamingOutputCallRequest, global::Grpc.Testing.StreamingOutputCallResponse> FullDuplexCall(CallOptions options);
+      /// <summary>
+      ///  A sequence of requests followed by a sequence of responses.
+      ///  The server buffers all the client requests and then serves them in order. A
+      ///  stream of responses are returned to the client when the server starts with
+      ///  first request.
+      /// </summary>
       AsyncDuplexStreamingCall<global::Grpc.Testing.StreamingOutputCallRequest, global::Grpc.Testing.StreamingOutputCallResponse> HalfDuplexCall(Metadata headers = null, DateTime? deadline = null, CancellationToken cancellationToken = default(CancellationToken));
+      /// <summary>
+      ///  A sequence of requests followed by a sequence of responses.
+      ///  The server buffers all the client requests and then serves them in order. A
+      ///  stream of responses are returned to the client when the server starts with
+      ///  first request.
+      /// </summary>
       AsyncDuplexStreamingCall<global::Grpc.Testing.StreamingOutputCallRequest, global::Grpc.Testing.StreamingOutputCallResponse> HalfDuplexCall(CallOptions options);
     }
 
-    // server-side interface
+    /// <summary>Interface of server-side implementations of TestService</summary>
     [System.Obsolete("Service implementations should inherit from the generated abstract base class instead.")]
     public interface ITestService
     {
+      /// <summary>
+      ///  One empty request followed by one empty response.
+      /// </summary>
       Task<global::Grpc.Testing.Empty> EmptyCall(global::Grpc.Testing.Empty request, ServerCallContext context);
+      /// <summary>
+      ///  One request followed by one response.
+      /// </summary>
       Task<global::Grpc.Testing.SimpleResponse> UnaryCall(global::Grpc.Testing.SimpleRequest request, ServerCallContext context);
+      /// <summary>
+      ///  One request followed by a sequence of responses (streamed download).
+      ///  The server returns the payload with client desired type and sizes.
+      /// </summary>
       Task StreamingOutputCall(global::Grpc.Testing.StreamingOutputCallRequest request, IServerStreamWriter<global::Grpc.Testing.StreamingOutputCallResponse> responseStream, ServerCallContext context);
+      /// <summary>
+      ///  A sequence of requests followed by one response (streamed upload).
+      ///  The server returns the aggregated size of client payload as the result.
+      /// </summary>
       Task<global::Grpc.Testing.StreamingInputCallResponse> StreamingInputCall(IAsyncStreamReader<global::Grpc.Testing.StreamingInputCallRequest> requestStream, ServerCallContext context);
+      /// <summary>
+      ///  A sequence of requests with each request served by the server immediately.
+      ///  As one request could lead to multiple responses, this interface
+      ///  demonstrates the idea of full duplexing.
+      /// </summary>
       Task FullDuplexCall(IAsyncStreamReader<global::Grpc.Testing.StreamingOutputCallRequest> requestStream, IServerStreamWriter<global::Grpc.Testing.StreamingOutputCallResponse> responseStream, ServerCallContext context);
+      /// <summary>
+      ///  A sequence of requests followed by a sequence of responses.
+      ///  The server buffers all the client requests and then serves them in order. A
+      ///  stream of responses are returned to the client when the server starts with
+      ///  first request.
+      /// </summary>
       Task HalfDuplexCall(IAsyncStreamReader<global::Grpc.Testing.StreamingOutputCallRequest> requestStream, IServerStreamWriter<global::Grpc.Testing.StreamingOutputCallResponse> responseStream, ServerCallContext context);
     }
 
-    // server-side abstract class
+    /// <summary>Base class for server-side implementations of TestService</summary>
     public abstract class TestServiceBase
     {
+      /// <summary>
+      ///  One empty request followed by one empty response.
+      /// </summary>
       public virtual Task<global::Grpc.Testing.Empty> EmptyCall(global::Grpc.Testing.Empty request, ServerCallContext context)
       {
         throw new RpcException(new Status(StatusCode.Unimplemented, ""));
       }
 
+      /// <summary>
+      ///  One request followed by one response.
+      /// </summary>
       public virtual Task<global::Grpc.Testing.SimpleResponse> UnaryCall(global::Grpc.Testing.SimpleRequest request, ServerCallContext context)
       {
         throw new RpcException(new Status(StatusCode.Unimplemented, ""));
       }
 
+      /// <summary>
+      ///  One request followed by a sequence of responses (streamed download).
+      ///  The server returns the payload with client desired type and sizes.
+      /// </summary>
       public virtual Task StreamingOutputCall(global::Grpc.Testing.StreamingOutputCallRequest request, IServerStreamWriter<global::Grpc.Testing.StreamingOutputCallResponse> responseStream, ServerCallContext context)
       {
         throw new RpcException(new Status(StatusCode.Unimplemented, ""));
       }
 
+      /// <summary>
+      ///  A sequence of requests followed by one response (streamed upload).
+      ///  The server returns the aggregated size of client payload as the result.
+      /// </summary>
       public virtual Task<global::Grpc.Testing.StreamingInputCallResponse> StreamingInputCall(IAsyncStreamReader<global::Grpc.Testing.StreamingInputCallRequest> requestStream, ServerCallContext context)
       {
         throw new RpcException(new Status(StatusCode.Unimplemented, ""));
       }
 
+      /// <summary>
+      ///  A sequence of requests with each request served by the server immediately.
+      ///  As one request could lead to multiple responses, this interface
+      ///  demonstrates the idea of full duplexing.
+      /// </summary>
       public virtual Task FullDuplexCall(IAsyncStreamReader<global::Grpc.Testing.StreamingOutputCallRequest> requestStream, IServerStreamWriter<global::Grpc.Testing.StreamingOutputCallResponse> responseStream, ServerCallContext context)
       {
         throw new RpcException(new Status(StatusCode.Unimplemented, ""));
       }
 
+      /// <summary>
+      ///  A sequence of requests followed by a sequence of responses.
+      ///  The server buffers all the client requests and then serves them in order. A
+      ///  stream of responses are returned to the client when the server starts with
+      ///  first request.
+      /// </summary>
       public virtual Task HalfDuplexCall(IAsyncStreamReader<global::Grpc.Testing.StreamingOutputCallRequest> requestStream, IServerStreamWriter<global::Grpc.Testing.StreamingOutputCallResponse> responseStream, ServerCallContext context)
       {
         throw new RpcException(new Status(StatusCode.Unimplemented, ""));
@@ -137,7 +286,7 @@ namespace Grpc.Testing {
 
     }
 
-    // client stub
+    /// <summary>Client for TestService</summary>
     #pragma warning disable 0618
     public class TestServiceClient : ClientBase<TestServiceClient>, ITestServiceClient
     #pragma warning restore 0618
@@ -157,66 +306,128 @@ namespace Grpc.Testing {
       {
       }
 
+      /// <summary>
+      ///  One empty request followed by one empty response.
+      /// </summary>
       public virtual global::Grpc.Testing.Empty EmptyCall(global::Grpc.Testing.Empty request, Metadata headers = null, DateTime? deadline = null, CancellationToken cancellationToken = default(CancellationToken))
       {
         return EmptyCall(request, new CallOptions(headers, deadline, cancellationToken));
       }
+      /// <summary>
+      ///  One empty request followed by one empty response.
+      /// </summary>
       public virtual global::Grpc.Testing.Empty EmptyCall(global::Grpc.Testing.Empty request, CallOptions options)
       {
         return CallInvoker.BlockingUnaryCall(__Method_EmptyCall, null, options, request);
       }
+      /// <summary>
+      ///  One empty request followed by one empty response.
+      /// </summary>
       public virtual AsyncUnaryCall<global::Grpc.Testing.Empty> EmptyCallAsync(global::Grpc.Testing.Empty request, Metadata headers = null, DateTime? deadline = null, CancellationToken cancellationToken = default(CancellationToken))
       {
         return EmptyCallAsync(request, new CallOptions(headers, deadline, cancellationToken));
       }
+      /// <summary>
+      ///  One empty request followed by one empty response.
+      /// </summary>
       public virtual AsyncUnaryCall<global::Grpc.Testing.Empty> EmptyCallAsync(global::Grpc.Testing.Empty request, CallOptions options)
       {
         return CallInvoker.AsyncUnaryCall(__Method_EmptyCall, null, options, request);
       }
+      /// <summary>
+      ///  One request followed by one response.
+      /// </summary>
       public virtual global::Grpc.Testing.SimpleResponse UnaryCall(global::Grpc.Testing.SimpleRequest request, Metadata headers = null, DateTime? deadline = null, CancellationToken cancellationToken = default(CancellationToken))
       {
         return UnaryCall(request, new CallOptions(headers, deadline, cancellationToken));
       }
+      /// <summary>
+      ///  One request followed by one response.
+      /// </summary>
       public virtual global::Grpc.Testing.SimpleResponse UnaryCall(global::Grpc.Testing.SimpleRequest request, CallOptions options)
       {
         return CallInvoker.BlockingUnaryCall(__Method_UnaryCall, null, options, request);
       }
+      /// <summary>
+      ///  One request followed by one response.
+      /// </summary>
       public virtual AsyncUnaryCall<global::Grpc.Testing.SimpleResponse> UnaryCallAsync(global::Grpc.Testing.SimpleRequest request, Metadata headers = null, DateTime? deadline = null, CancellationToken cancellationToken = default(CancellationToken))
       {
         return UnaryCallAsync(request, new CallOptions(headers, deadline, cancellationToken));
       }
+      /// <summary>
+      ///  One request followed by one response.
+      /// </summary>
       public virtual AsyncUnaryCall<global::Grpc.Testing.SimpleResponse> UnaryCallAsync(global::Grpc.Testing.SimpleRequest request, CallOptions options)
       {
         return CallInvoker.AsyncUnaryCall(__Method_UnaryCall, null, options, request);
       }
+      /// <summary>
+      ///  One request followed by a sequence of responses (streamed download).
+      ///  The server returns the payload with client desired type and sizes.
+      /// </summary>
       public virtual AsyncServerStreamingCall<global::Grpc.Testing.StreamingOutputCallResponse> StreamingOutputCall(global::Grpc.Testing.StreamingOutputCallRequest request, Metadata headers = null, DateTime? deadline = null, CancellationToken cancellationToken = default(CancellationToken))
       {
         return StreamingOutputCall(request, new CallOptions(headers, deadline, cancellationToken));
       }
+      /// <summary>
+      ///  One request followed by a sequence of responses (streamed download).
+      ///  The server returns the payload with client desired type and sizes.
+      /// </summary>
       public virtual AsyncServerStreamingCall<global::Grpc.Testing.StreamingOutputCallResponse> StreamingOutputCall(global::Grpc.Testing.StreamingOutputCallRequest request, CallOptions options)
       {
         return CallInvoker.AsyncServerStreamingCall(__Method_StreamingOutputCall, null, options, request);
       }
+      /// <summary>
+      ///  A sequence of requests followed by one response (streamed upload).
+      ///  The server returns the aggregated size of client payload as the result.
+      /// </summary>
       public virtual AsyncClientStreamingCall<global::Grpc.Testing.StreamingInputCallRequest, global::Grpc.Testing.StreamingInputCallResponse> StreamingInputCall(Metadata headers = null, DateTime? deadline = null, CancellationToken cancellationToken = default(CancellationToken))
       {
         return StreamingInputCall(new CallOptions(headers, deadline, cancellationToken));
       }
+      /// <summary>
+      ///  A sequence of requests followed by one response (streamed upload).
+      ///  The server returns the aggregated size of client payload as the result.
+      /// </summary>
       public virtual AsyncClientStreamingCall<global::Grpc.Testing.StreamingInputCallRequest, global::Grpc.Testing.StreamingInputCallResponse> StreamingInputCall(CallOptions options)
       {
         return CallInvoker.AsyncClientStreamingCall(__Method_StreamingInputCall, null, options);
       }
+      /// <summary>
+      ///  A sequence of requests with each request served by the server immediately.
+      ///  As one request could lead to multiple responses, this interface
+      ///  demonstrates the idea of full duplexing.
+      /// </summary>
       public virtual AsyncDuplexStreamingCall<global::Grpc.Testing.StreamingOutputCallRequest, global::Grpc.Testing.StreamingOutputCallResponse> FullDuplexCall(Metadata headers = null, DateTime? deadline = null, CancellationToken cancellationToken = default(CancellationToken))
       {
         return FullDuplexCall(new CallOptions(headers, deadline, cancellationToken));
       }
+      /// <summary>
+      ///  A sequence of requests with each request served by the server immediately.
+      ///  As one request could lead to multiple responses, this interface
+      ///  demonstrates the idea of full duplexing.
+      /// </summary>
       public virtual AsyncDuplexStreamingCall<global::Grpc.Testing.StreamingOutputCallRequest, global::Grpc.Testing.StreamingOutputCallResponse> FullDuplexCall(CallOptions options)
       {
         return CallInvoker.AsyncDuplexStreamingCall(__Method_FullDuplexCall, null, options);
       }
+      /// <summary>
+      ///  A sequence of requests followed by a sequence of responses.
+      ///  The server buffers all the client requests and then serves them in order. A
+      ///  stream of responses are returned to the client when the server starts with
+      ///  first request.
+      /// </summary>
       public virtual AsyncDuplexStreamingCall<global::Grpc.Testing.StreamingOutputCallRequest, global::Grpc.Testing.StreamingOutputCallResponse> HalfDuplexCall(Metadata headers = null, DateTime? deadline = null, CancellationToken cancellationToken = default(CancellationToken))
       {
         return HalfDuplexCall(new CallOptions(headers, deadline, cancellationToken));
       }
+      /// <summary>
+      ///  A sequence of requests followed by a sequence of responses.
+      ///  The server buffers all the client requests and then serves them in order. A
+      ///  stream of responses are returned to the client when the server starts with
+      ///  first request.
+      /// </summary>
       public virtual AsyncDuplexStreamingCall<global::Grpc.Testing.StreamingOutputCallRequest, global::Grpc.Testing.StreamingOutputCallResponse> HalfDuplexCall(CallOptions options)
       {
         return CallInvoker.AsyncDuplexStreamingCall(__Method_HalfDuplexCall, null, options);
@@ -227,13 +438,13 @@ namespace Grpc.Testing {
       }
     }
 
-    // creates a new client
+    /// <summary>Creates a new client for TestService</summary>
     public static TestServiceClient NewClient(Channel channel)
     {
       return new TestServiceClient(channel);
     }
 
-    // creates service definition that can be registered with a server
+    /// <summary>Creates service definition that can be registered with a server</summary>
     #pragma warning disable 0618
     public static ServerServiceDefinition BindService(ITestService serviceImpl)
     #pragma warning restore 0618
@@ -247,7 +458,7 @@ namespace Grpc.Testing {
           .AddMethod(__Method_HalfDuplexCall, serviceImpl.HalfDuplexCall).Build();
     }
 
-    // creates service definition that can be registered with a server
+    /// <summary>Creates service definition that can be registered with a server</summary>
     #pragma warning disable 0618
     public static ServerServiceDefinition BindService(TestServiceBase serviceImpl)
     #pragma warning restore 0618
@@ -262,6 +473,10 @@ namespace Grpc.Testing {
     }
 
   }
+  /// <summary>
+  ///  A simple service NOT implemented at servers so clients can test for
+  ///  that case.
+  /// </summary>
   public static class UnimplementedService
   {
     static readonly string __ServiceName = "grpc.testing.UnimplementedService";
@@ -275,32 +490,50 @@ namespace Grpc.Testing {
         __Marshaller_Empty,
         __Marshaller_Empty);
 
-    // service descriptor
+    /// <summary>Service descriptor</summary>
     public static global::Google.Protobuf.Reflection.ServiceDescriptor Descriptor
     {
       get { return global::Grpc.Testing.TestReflection.Descriptor.Services[1]; }
     }
 
-    // client interface
+    /// <summary>Client for UnimplementedService</summary>
     [System.Obsolete("Client side interfaced will be removed in the next release. Use client class directly.")]
     public interface IUnimplementedServiceClient
     {
+      /// <summary>
+      ///  A call that no server should implement
+      /// </summary>
       global::Grpc.Testing.Empty UnimplementedCall(global::Grpc.Testing.Empty request, Metadata headers = null, DateTime? deadline = null, CancellationToken cancellationToken = default(CancellationToken));
+      /// <summary>
+      ///  A call that no server should implement
+      /// </summary>
       global::Grpc.Testing.Empty UnimplementedCall(global::Grpc.Testing.Empty request, CallOptions options);
+      /// <summary>
+      ///  A call that no server should implement
+      /// </summary>
       AsyncUnaryCall<global::Grpc.Testing.Empty> UnimplementedCallAsync(global::Grpc.Testing.Empty request, Metadata headers = null, DateTime? deadline = null, CancellationToken cancellationToken = default(CancellationToken));
+      /// <summary>
+      ///  A call that no server should implement
+      /// </summary>
       AsyncUnaryCall<global::Grpc.Testing.Empty> UnimplementedCallAsync(global::Grpc.Testing.Empty request, CallOptions options);
     }
 
-    // server-side interface
+    /// <summary>Interface of server-side implementations of UnimplementedService</summary>
     [System.Obsolete("Service implementations should inherit from the generated abstract base class instead.")]
     public interface IUnimplementedService
     {
+      /// <summary>
+      ///  A call that no server should implement
+      /// </summary>
       Task<global::Grpc.Testing.Empty> UnimplementedCall(global::Grpc.Testing.Empty request, ServerCallContext context);
     }
 
-    // server-side abstract class
+    /// <summary>Base class for server-side implementations of UnimplementedService</summary>
     public abstract class UnimplementedServiceBase
     {
+      /// <summary>
+      ///  A call that no server should implement
+      /// </summary>
       public virtual Task<global::Grpc.Testing.Empty> UnimplementedCall(global::Grpc.Testing.Empty request, ServerCallContext context)
       {
         throw new RpcException(new Status(StatusCode.Unimplemented, ""));
@@ -308,7 +541,7 @@ namespace Grpc.Testing {
 
     }
 
-    // client stub
+    /// <summary>Client for UnimplementedService</summary>
     #pragma warning disable 0618
     public class UnimplementedServiceClient : ClientBase<UnimplementedServiceClient>, IUnimplementedServiceClient
     #pragma warning restore 0618
@@ -328,18 +561,30 @@ namespace Grpc.Testing {
       {
       }
 
+      /// <summary>
+      ///  A call that no server should implement
+      /// </summary>
       public virtual global::Grpc.Testing.Empty UnimplementedCall(global::Grpc.Testing.Empty request, Metadata headers = null, DateTime? deadline = null, CancellationToken cancellationToken = default(CancellationToken))
       {
         return UnimplementedCall(request, new CallOptions(headers, deadline, cancellationToken));
       }
+      /// <summary>
+      ///  A call that no server should implement
+      /// </summary>
       public virtual global::Grpc.Testing.Empty UnimplementedCall(global::Grpc.Testing.Empty request, CallOptions options)
       {
         return CallInvoker.BlockingUnaryCall(__Method_UnimplementedCall, null, options, request);
       }
+      /// <summary>
+      ///  A call that no server should implement
+      /// </summary>
       public virtual AsyncUnaryCall<global::Grpc.Testing.Empty> UnimplementedCallAsync(global::Grpc.Testing.Empty request, Metadata headers = null, DateTime? deadline = null, CancellationToken cancellationToken = default(CancellationToken))
       {
         return UnimplementedCallAsync(request, new CallOptions(headers, deadline, cancellationToken));
       }
+      /// <summary>
+      ///  A call that no server should implement
+      /// </summary>
       public virtual AsyncUnaryCall<global::Grpc.Testing.Empty> UnimplementedCallAsync(global::Grpc.Testing.Empty request, CallOptions options)
       {
         return CallInvoker.AsyncUnaryCall(__Method_UnimplementedCall, null, options, request);
@@ -350,13 +595,13 @@ namespace Grpc.Testing {
       }
     }
 
-    // creates a new client
+    /// <summary>Creates a new client for UnimplementedService</summary>
     public static UnimplementedServiceClient NewClient(Channel channel)
     {
       return new UnimplementedServiceClient(channel);
     }
 
-    // creates service definition that can be registered with a server
+    /// <summary>Creates service definition that can be registered with a server</summary>
     #pragma warning disable 0618
     public static ServerServiceDefinition BindService(IUnimplementedService serviceImpl)
     #pragma warning restore 0618
@@ -365,7 +610,7 @@ namespace Grpc.Testing {
           .AddMethod(__Method_UnimplementedCall, serviceImpl.UnimplementedCall).Build();
     }
 
-    // creates service definition that can be registered with a server
+    /// <summary>Creates service definition that can be registered with a server</summary>
     #pragma warning disable 0618
     public static ServerServiceDefinition BindService(UnimplementedServiceBase serviceImpl)
     #pragma warning restore 0618
@@ -375,6 +620,9 @@ namespace Grpc.Testing {
     }
 
   }
+  /// <summary>
+  ///  A service used to control reconnect server.
+  /// </summary>
   public static class ReconnectService
   {
     static readonly string __ServiceName = "grpc.testing.ReconnectService";
@@ -397,13 +645,13 @@ namespace Grpc.Testing {
         __Marshaller_Empty,
         __Marshaller_ReconnectInfo);
 
-    // service descriptor
+    /// <summary>Service descriptor</summary>
     public static global::Google.Protobuf.Reflection.ServiceDescriptor Descriptor
     {
       get { return global::Grpc.Testing.TestReflection.Descriptor.Services[2]; }
     }
 
-    // client interface
+    /// <summary>Client for ReconnectService</summary>
     [System.Obsolete("Client side interfaced will be removed in the next release. Use client class directly.")]
     public interface IReconnectServiceClient
     {
@@ -417,7 +665,7 @@ namespace Grpc.Testing {
       AsyncUnaryCall<global::Grpc.Testing.ReconnectInfo> StopAsync(global::Grpc.Testing.Empty request, CallOptions options);
     }
 
-    // server-side interface
+    /// <summary>Interface of server-side implementations of ReconnectService</summary>
     [System.Obsolete("Service implementations should inherit from the generated abstract base class instead.")]
     public interface IReconnectService
     {
@@ -425,7 +673,7 @@ namespace Grpc.Testing {
       Task<global::Grpc.Testing.ReconnectInfo> Stop(global::Grpc.Testing.Empty request, ServerCallContext context);
     }
 
-    // server-side abstract class
+    /// <summary>Base class for server-side implementations of ReconnectService</summary>
     public abstract class ReconnectServiceBase
     {
       public virtual Task<global::Grpc.Testing.Empty> Start(global::Grpc.Testing.ReconnectParams request, ServerCallContext context)
@@ -440,7 +688,7 @@ namespace Grpc.Testing {
 
     }
 
-    // client stub
+    /// <summary>Client for ReconnectService</summary>
     #pragma warning disable 0618
     public class ReconnectServiceClient : ClientBase<ReconnectServiceClient>, IReconnectServiceClient
     #pragma warning restore 0618
@@ -498,13 +746,13 @@ namespace Grpc.Testing {
       }
     }
 
-    // creates a new client
+    /// <summary>Creates a new client for ReconnectService</summary>
     public static ReconnectServiceClient NewClient(Channel channel)
     {
       return new ReconnectServiceClient(channel);
     }
 
-    // creates service definition that can be registered with a server
+    /// <summary>Creates service definition that can be registered with a server</summary>
     #pragma warning disable 0618
     public static ServerServiceDefinition BindService(IReconnectService serviceImpl)
     #pragma warning restore 0618
@@ -514,7 +762,7 @@ namespace Grpc.Testing {
           .AddMethod(__Method_Stop, serviceImpl.Stop).Build();
     }
 
-    // creates service definition that can be registered with a server
+    /// <summary>Creates service definition that can be registered with a server</summary>
     #pragma warning disable 0618
     public static ServerServiceDefinition BindService(ReconnectServiceBase serviceImpl)
     #pragma warning restore 0618