\[global::System.Diagnostics.DebuggerNonUserCodeAttribute\]  
public static pbr::MessageDescriptor Descriptor {  
  get { return global::Routeguide.RouteGuideReflection.Descriptor.MessageTypes\[\]; }  
}

\[global::System.Diagnostics.DebuggerNonUserCodeAttribute\]  
pbr::MessageDescriptor pb::IMessage.Descriptor {  
  get { return Descriptor; }  
}

\[global::System.Diagnostics.DebuggerNonUserCodeAttribute\]  
public RouteSummary() {  
  OnConstruction();  
}

partial void OnConstruction();

\[global::System.Diagnostics.DebuggerNonUserCodeAttribute\]  
public RouteSummary(RouteSummary other) : this() {  
  pointCount\_ = other.pointCount\_;  
  featureCount\_ = other.featureCount\_;  
  distance\_ = other.distance\_;  
  elapsedTime\_ = other.elapsedTime\_;  
  \_unknownFields = pb::UnknownFieldSet.Clone(other.\_unknownFields);  
}

\[global::System.Diagnostics.DebuggerNonUserCodeAttribute\]  
public RouteSummary Clone() {  
  return new RouteSummary(this);  
}

/// <summary>Field number for the "point\_count" field.</summary>  
public const int PointCountFieldNumber = ;  
private int pointCount\_;  
/// <summary>  
/// The number of points received.  
/// </summary>  
\[global::System.Diagnostics.DebuggerNonUserCodeAttribute\]  
public int PointCount {  
  get { return pointCount\_; }  
  set {  
    pointCount\_ = value;  
  }  
}

/// <summary>Field number for the "feature\_count" field.</summary>  
public const int FeatureCountFieldNumber = ;  
private int featureCount\_;  
/// <summary>  
/// The number of known features passed while traversing the route.  
/// </summary>  
\[global::System.Diagnostics.DebuggerNonUserCodeAttribute\]  
public int FeatureCount {  
  get { return featureCount\_; }  
  set {  
    featureCount\_ = value;  
  }  
}

/// <summary>Field number for the "distance" field.</summary>  
public const int DistanceFieldNumber = ;  
private int distance\_;  
/// <summary>  
/// The distance covered in metres.  
/// </summary>  
\[global::System.Diagnostics.DebuggerNonUserCodeAttribute\]  
public int Distance {  
  get { return distance\_; }  
  set {  
    distance\_ = value;  
  }  
}

/// <summary>Field number for the "elapsed\_time" field.</summary>  
public const int ElapsedTimeFieldNumber = ;  
private int elapsedTime\_;  
/// <summary>  
/// The duration of the traversal in seconds.  
/// </summary>  
\[global::System.Diagnostics.DebuggerNonUserCodeAttribute\]  
public int ElapsedTime {  
  get { return elapsedTime\_; }  
  set {  
    elapsedTime\_ = value;  
  }  
}

\[global::System.Diagnostics.DebuggerNonUserCodeAttribute\]  
public override bool Equals(object other) {  
  return Equals(other as RouteSummary);  
}

\[global::System.Diagnostics.DebuggerNonUserCodeAttribute\]  
public bool Equals(RouteSummary other) {  
  if (ReferenceEquals(other, null)) {  
    return false;  
  }  
  if (ReferenceEquals(other, this)) {  
    return true;  
  }  
  if (PointCount != other.PointCount) return false;  
  if (FeatureCount != other.FeatureCount) return false;  
  if (Distance != other.Distance) return false;  
  if (ElapsedTime != other.ElapsedTime) return false;  
  return Equals(\_unknownFields, other.\_unknownFields);  
}

\[global::System.Diagnostics.DebuggerNonUserCodeAttribute\]  
public override int GetHashCode() {  
  int hash = ;  
  if (PointCount != ) hash ^= PointCount.GetHashCode();  
  if (FeatureCount != ) hash ^= FeatureCount.GetHashCode();  
  if (Distance != ) hash ^= Distance.GetHashCode();  
  if (ElapsedTime != ) hash ^= ElapsedTime.GetHashCode();  
  if (\_unknownFields != null) {  
    hash ^= \_unknownFields.GetHashCode();  
  }  
  return hash;  
}

\[global::System.Diagnostics.DebuggerNonUserCodeAttribute\]  
public override string ToString() {  
  return pb::JsonFormatter.ToDiagnosticString(this);  
}

\[global::System.Diagnostics.DebuggerNonUserCodeAttribute\]  
public void WriteTo(pb::CodedOutputStream output) {  
  if (PointCount != ) {  
    output.WriteRawTag();  
    output.WriteInt32(PointCount);  
  }  
  if (FeatureCount != ) {  
    output.WriteRawTag();  
    output.WriteInt32(FeatureCount);  
  }  
  if (Distance != ) {  
    output.WriteRawTag();  
    output.WriteInt32(Distance);  
  }  
  if (ElapsedTime != ) {  
    output.WriteRawTag();  
    output.WriteInt32(ElapsedTime);  
  }  
  if (\_unknownFields != null) {  
    \_unknownFields.WriteTo(output);  
  }  
}

\[global::System.Diagnostics.DebuggerNonUserCodeAttribute\]  
public int CalculateSize() {  
  int size = ;  
  if (PointCount != ) {  
    size +=  + pb::CodedOutputStream.ComputeInt32Size(PointCount);  
  }  
  if (FeatureCount != ) {  
    size +=  + pb::CodedOutputStream.ComputeInt32Size(FeatureCount);  
  }  
  if (Distance != ) {  
    size +=  + pb::CodedOutputStream.ComputeInt32Size(Distance);  
  }  
  if (ElapsedTime != ) {  
    size +=  + pb::CodedOutputStream.ComputeInt32Size(ElapsedTime);  
  }  
  if (\_unknownFields != null) {  
    size += \_unknownFields.CalculateSize();  
  }  
  return size;  
}

\[global::System.Diagnostics.DebuggerNonUserCodeAttribute\]  
public void MergeFrom(RouteSummary other) {  
  if (other == null) {  
    return;  
  }  
  if (other.PointCount != ) {  
    PointCount = other.PointCount;  
  }  
  if (other.FeatureCount != ) {  
    FeatureCount = other.FeatureCount;  
  }  
  if (other.Distance != ) {  
    Distance = other.Distance;  
  }  
  if (other.ElapsedTime != ) {  
    ElapsedTime = other.ElapsedTime;  
  }  
  \_unknownFields = pb::UnknownFieldSet.MergeFrom(\_unknownFields, other.\_unknownFields);  
}

\[global::System.Diagnostics.DebuggerNonUserCodeAttribute\]  
public void MergeFrom(pb::CodedInputStream input) {  
  uint tag;  
  while ((tag = input.ReadTag()) != ) {  
    switch(tag) {  
      default:  
        \_unknownFields = pb::UnknownFieldSet.MergeFieldFrom(\_unknownFields, input);  
        break;  
      case : {  
        PointCount = input.ReadInt32();  
        break;  
      }  
      case : {  
        FeatureCount = input.ReadInt32();  
        break;  
      }  
      case : {  
        Distance = input.ReadInt32();  
        break;  
      }  
      case : {  
        ElapsedTime = input.ReadInt32();  
        break;  
      }  
    }  
  }  
}

}

#endregion

}

#endregion Designer generated code

// // Generated by the protocol buffer compiler. DO NOT EDIT! // source: route_guide.proto //
// Original file comments:
// Copyright 2015 gRPC authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
#pragma warning disable 0414, 1591
#region Designer generated code

using grpc = global::Grpc.Core;

namespace Routeguide {
///

static readonly grpc::Marshaller<global::Routeguide.Point> \_\_Marshaller\_routeguide\_Point = grpc::Marshallers.Create((arg) => global::Google.Protobuf.MessageExtensions.ToByteArray(arg), global::Routeguide.Point.Parser.ParseFrom);  
static readonly grpc::Marshaller<global::Routeguide.Feature> \_\_Marshaller\_routeguide\_Feature = grpc::Marshallers.Create((arg) => global::Google.Protobuf.MessageExtensions.ToByteArray(arg), global::Routeguide.Feature.Parser.ParseFrom);  
static readonly grpc::Marshaller<global::Routeguide.Rectangle> \_\_Marshaller\_routeguide\_Rectangle = grpc::Marshallers.Create((arg) => global::Google.Protobuf.MessageExtensions.ToByteArray(arg), global::Routeguide.Rectangle.Parser.ParseFrom);  
static readonly grpc::Marshaller<global::Routeguide.RouteSummary> \_\_Marshaller\_routeguide\_RouteSummary = grpc::Marshallers.Create((arg) => global::Google.Protobuf.MessageExtensions.ToByteArray(arg), global::Routeguide.RouteSummary.Parser.ParseFrom);  
static readonly grpc::Marshaller<global::Routeguide.RouteNote> \_\_Marshaller\_routeguide\_RouteNote = grpc::Marshallers.Create((arg) => global::Google.Protobuf.MessageExtensions.ToByteArray(arg), global::Routeguide.RouteNote.Parser.ParseFrom);

static readonly grpc::Method<global::Routeguide.Point, global::Routeguide.Feature> \_\_Method\_GetFeature = new grpc::Method<global::Routeguide.Point, global::Routeguide.Feature>(  
    grpc::MethodType.Unary,  
    \_\_ServiceName,  
    "GetFeature",  
    \_\_Marshaller\_routeguide\_Point,  
    \_\_Marshaller\_routeguide\_Feature);

static readonly grpc::Method<global::Routeguide.Rectangle, global::Routeguide.Feature> \_\_Method\_ListFeatures = new grpc::Method<global::Routeguide.Rectangle, global::Routeguide.Feature>(  
    grpc::MethodType.ServerStreaming,  
    \_\_ServiceName,  
    "ListFeatures",  
    \_\_Marshaller\_routeguide\_Rectangle,  
    \_\_Marshaller\_routeguide\_Feature);

static readonly grpc::Method<global::Routeguide.Point, global::Routeguide.RouteSummary> \_\_Method\_RecordRoute = new grpc::Method<global::Routeguide.Point, global::Routeguide.RouteSummary>(  
    grpc::MethodType.ClientStreaming,  
    \_\_ServiceName,  
    "RecordRoute",  
    \_\_Marshaller\_routeguide\_Point,  
    \_\_Marshaller\_routeguide\_RouteSummary);

static readonly grpc::Method<global::Routeguide.RouteNote, global::Routeguide.RouteNote> \_\_Method\_RouteChat = new grpc::Method<global::Routeguide.RouteNote, global::Routeguide.RouteNote>(  
    grpc::MethodType.DuplexStreaming,  
    \_\_ServiceName,  
    "RouteChat",  
    \_\_Marshaller\_routeguide\_RouteNote,  
    \_\_Marshaller\_routeguide\_RouteNote);

/// <summary>Service descriptor</summary>  
public static global::Google.Protobuf.Reflection.ServiceDescriptor Descriptor  
{  
  get { return global::Routeguide.RouteGuideReflection.Descriptor.Services\[\]; }  
}

/// <summary>Base class for server-side implementations of RouteGuide</summary>  
public abstract partial class RouteGuideBase  
{  
  /// <summary>  
  /// A simple RPC.  
  ///  
  /// Obtains the feature at a given position.  
  ///  
  /// A feature with an empty name is returned if there's no feature at the given  
  /// position.  
  /// </summary>  
  /// <param name="request">The request received from the client.</param>  
  /// <param name="context">The context of the server-side call handler being invoked.</param>  
  /// <returns>The response to send back to the client (wrapped by a task).</returns>  
  public virtual global::System.Threading.Tasks.Task<global::Routeguide.Feature> GetFeature(global::Routeguide.Point request, grpc::ServerCallContext context)  
  {  
    throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));  
  }

  /// <summary>  
  /// A server-to-client streaming RPC.  
  ///  
  /// Obtains the Features available within the given Rectangle.  Results are  
  /// streamed rather than returned at once (e.g. in a response message with a  
  /// repeated field), as the rectangle may cover a large area and contain a  
  /// huge number of features.  
  /// </summary>  
  /// <param name="request">The request received from the client.</param>  
  /// <param name="responseStream">Used for sending responses back to the client.</param>  
  /// <param name="context">The context of the server-side call handler being invoked.</param>  
  /// <returns>A task indicating completion of the handler.</returns>  
  public virtual global::System.Threading.Tasks.Task ListFeatures(global::Routeguide.Rectangle request, grpc::IServerStreamWriter<global::Routeguide.Feature> responseStream, grpc::ServerCallContext context)  
  {  
    throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));  
  }

  /// <summary>  
  /// A client-to-server streaming RPC.  
  ///  
  /// Accepts a stream of Points on a route being traversed, returning a  
  /// RouteSummary when traversal is completed.  
  /// </summary>  
  /// <param name="requestStream">Used for reading requests from the client.</param>  
  /// <param name="context">The context of the server-side call handler being invoked.</param>  
  /// <returns>The response to send back to the client (wrapped by a task).</returns>  
  public virtual global::System.Threading.Tasks.Task<global::Routeguide.RouteSummary> RecordRoute(grpc::IAsyncStreamReader<global::Routeguide.Point> requestStream, grpc::ServerCallContext context)  
  {  
    throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));  
  }

  /// <summary>  
  /// A Bidirectional streaming RPC.  
  ///  
  /// Accepts a stream of RouteNotes sent while a route is being traversed,  
  /// while receiving other RouteNotes (e.g. from other users).  
  /// </summary>  
  /// <param name="requestStream">Used for reading requests from the client.</param>  
  /// <param name="responseStream">Used for sending responses back to the client.</param>  
  /// <param name="context">The context of the server-side call handler being invoked.</param>  
  /// <returns>A task indicating completion of the handler.</returns>  
  public virtual global::System.Threading.Tasks.Task RouteChat(grpc::IAsyncStreamReader<global::Routeguide.RouteNote> requestStream, grpc::IServerStreamWriter<global::Routeguide.RouteNote> responseStream, grpc::ServerCallContext context)  
  {  
    throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));  
  }

}

/// <summary>Client for RouteGuide</summary>  
public partial class RouteGuideClient : grpc::ClientBase<RouteGuideClient>  
{  
  /// <summary>Creates a new client for RouteGuide</summary>  
  /// <param name="channel">The channel to use to make remote calls.</param>  
  public RouteGuideClient(grpc::Channel channel) : base(channel)  
  {  
  }  
  /// <summary>Creates a new client for RouteGuide that uses a custom <c>CallInvoker</c>.</summary>  
  /// <param name="callInvoker">The callInvoker to use to make remote calls.</param>  
  public RouteGuideClient(grpc::CallInvoker callInvoker) : base(callInvoker)  
  {  
  }  
  /// <summary>Protected parameterless constructor to allow creation of test doubles.</summary>  
  protected RouteGuideClient() : base()  
  {  
  }  
  /// <summary>Protected constructor to allow creation of configured clients.</summary>  
  /// <param name="configuration">The client configuration.</param>  
  protected RouteGuideClient(ClientBaseConfiguration configuration) : base(configuration)  
  {  
  }

  /// <summary>  
  /// A simple RPC.  
  ///  
  /// Obtains the feature at a given position.  
  ///  
  /// A feature with an empty name is returned if there's no feature at the given  
  /// position.  
  /// </summary>  
  /// <param name="request">The request to send to the server.</param>  
  /// <param name="headers">The initial metadata to send with the call. This parameter is optional.</param>  
  /// <param name="deadline">An optional deadline for the call. The call will be cancelled if deadline is hit.</param>  
  /// <param name="cancellationToken">An optional token for canceling the call.</param>  
  /// <returns>The response received from the server.</returns>  
  public virtual global::Routeguide.Feature GetFeature(global::Routeguide.Point request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))  
  {  
    return GetFeature(request, new grpc::CallOptions(headers, deadline, cancellationToken));  
  }  
  /// <summary>  
  /// A simple RPC.  
  ///  
  /// Obtains the feature at a given position.  
  ///  
  /// A feature with an empty name is returned if there's no feature at the given  
  /// position.  
  /// </summary>  
  /// <param name="request">The request to send to the server.</param>  
  /// <param name="options">The options for the call.</param>  
  /// <returns>The response received from the server.</returns>  
  public virtual global::Routeguide.Feature GetFeature(global::Routeguide.Point request, grpc::CallOptions options)  
  {  
    return CallInvoker.BlockingUnaryCall(\_\_Method\_GetFeature, null, options, request);  
  }  
  /// <summary>  
  /// A simple RPC.  
  ///  
  /// Obtains the feature at a given position.  
  ///  
  /// A feature with an empty name is returned if there's no feature at the given  
  /// position.  
  /// </summary>  
  /// <param name="request">The request to send to the server.</param>  
  /// <param name="headers">The initial metadata to send with the call. This parameter is optional.</param>  
  /// <param name="deadline">An optional deadline for the call. The call will be cancelled if deadline is hit.</param>  
  /// <param name="cancellationToken">An optional token for canceling the call.</param>  
  /// <returns>The call object.</returns>  
  public virtual grpc::AsyncUnaryCall<global::Routeguide.Feature> GetFeatureAsync(global::Routeguide.Point request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))  
  {  
    return GetFeatureAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken));  
  }  
  /// <summary>  
  /// A simple RPC.  
  ///  
  /// Obtains the feature at a given position.  
  ///  
  /// A feature with an empty name is returned if there's no feature at the given  
  /// position.  
  /// </summary>  
  /// <param name="request">The request to send to the server.</param>  
  /// <param name="options">The options for the call.</param>  
  /// <returns>The call object.</returns>  
  public virtual grpc::AsyncUnaryCall<global::Routeguide.Feature> GetFeatureAsync(global::Routeguide.Point request, grpc::CallOptions options)  
  {  
    return CallInvoker.AsyncUnaryCall(\_\_Method\_GetFeature, null, options, request);  
  }  
  /// <summary>  
  /// A server-to-client streaming RPC.  
  ///  
  /// Obtains the Features available within the given Rectangle.  Results are  
  /// streamed rather than returned at once (e.g. in a response message with a  
  /// repeated field), as the rectangle may cover a large area and contain a  
  /// huge number of features.  
  /// </summary>  
  /// <param name="request">The request to send to the server.</param>  
  /// <param name="headers">The initial metadata to send with the call. This parameter is optional.</param>  
  /// <param name="deadline">An optional deadline for the call. The call will be cancelled if deadline is hit.</param>  
  /// <param name="cancellationToken">An optional token for canceling the call.</param>  
  /// <returns>The call object.</returns>  
  public virtual grpc::AsyncServerStreamingCall<global::Routeguide.Feature> ListFeatures(global::Routeguide.Rectangle request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))  
  {  
    return ListFeatures(request, new grpc::CallOptions(headers, deadline, cancellationToken));  
  }  
  /// <summary>  
  /// A server-to-client streaming RPC.  
  ///  
  /// Obtains the Features available within the given Rectangle.  Results are  
  /// streamed rather than returned at once (e.g. in a response message with a  
  /// repeated field), as the rectangle may cover a large area and contain a  
  /// huge number of features.  
  /// </summary>  
  /// <param name="request">The request to send to the server.</param>  
  /// <param name="options">The options for the call.</param>  
  /// <returns>The call object.</returns>  
  public virtual grpc::AsyncServerStreamingCall<global::Routeguide.Feature> ListFeatures(global::Routeguide.Rectangle request, grpc::CallOptions options)  
  {  
    return CallInvoker.AsyncServerStreamingCall(\_\_Method\_ListFeatures, null, options, request);  
  }  
  /// <summary>  
  /// A client-to-server streaming RPC.  
  ///  
  /// Accepts a stream of Points on a route being traversed, returning a  
  /// RouteSummary when traversal is completed.  
  /// </summary>  
  /// <param name="headers">The initial metadata to send with the call. This parameter is optional.</param>  
  /// <param name="deadline">An optional deadline for the call. The call will be cancelled if deadline is hit.</param>  
  /// <param name="cancellationToken">An optional token for canceling the call.</param>  
  /// <returns>The call object.</returns>  
  public virtual grpc::AsyncClientStreamingCall<global::Routeguide.Point, global::Routeguide.RouteSummary> RecordRoute(grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))  
  {  
    return RecordRoute(new grpc::CallOptions(headers, deadline, cancellationToken));  
  }  
  /// <summary>  
  /// A client-to-server streaming RPC.  
  ///  
  /// Accepts a stream of Points on a route being traversed, returning a  
  /// RouteSummary when traversal is completed.  
  /// </summary>  
  /// <param name="options">The options for the call.</param>  
  /// <returns>The call object.</returns>  
  public virtual grpc::AsyncClientStreamingCall<global::Routeguide.Point, global::Routeguide.RouteSummary> RecordRoute(grpc::CallOptions options)  
  {  
    return CallInvoker.AsyncClientStreamingCall(\_\_Method\_RecordRoute, null, options);  
  }  
  /// <summary>  
  /// A Bidirectional streaming RPC.  
  ///  
  /// Accepts a stream of RouteNotes sent while a route is being traversed,  
  /// while receiving other RouteNotes (e.g. from other users).  
  /// </summary>  
  /// <param name="headers">The initial metadata to send with the call. This parameter is optional.</param>  
  /// <param name="deadline">An optional deadline for the call. The call will be cancelled if deadline is hit.</param>  
  /// <param name="cancellationToken">An optional token for canceling the call.</param>  
  /// <returns>The call object.</returns>  
  public virtual grpc::AsyncDuplexStreamingCall<global::Routeguide.RouteNote, global::Routeguide.RouteNote> RouteChat(grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))  
  {  
    return RouteChat(new grpc::CallOptions(headers, deadline, cancellationToken));  
  }  
  /// <summary>  
  /// A Bidirectional streaming RPC.  
  ///  
  /// Accepts a stream of RouteNotes sent while a route is being traversed,  
  /// while receiving other RouteNotes (e.g. from other users).  
  /// </summary>  
  /// <param name="options">The options for the call.</param>  
  /// <returns>The call object.</returns>  
  public virtual grpc::AsyncDuplexStreamingCall<global::Routeguide.RouteNote, global::Routeguide.RouteNote> RouteChat(grpc::CallOptions options)  
  {  
    return CallInvoker.AsyncDuplexStreamingCall(\_\_Method\_RouteChat, null, options);  
  }  
  /// <summary>Creates a new instance of client from given <c>ClientBaseConfiguration</c>.</summary>  
  protected override RouteGuideClient NewInstance(ClientBaseConfiguration configuration)  
  {  
    return new RouteGuideClient(configuration);  
  }  
}

/// <summary>Creates service definition that can be registered with a server</summary>  
/// <param name="serviceImpl">An object implementing the server-side handling logic.</param>  
public static grpc::ServerServiceDefinition BindService(RouteGuideBase serviceImpl)  
{  
  return grpc::ServerServiceDefinition.CreateBuilder()  
      .AddMethod(\_\_Method\_GetFeature, serviceImpl.GetFeature)  
      .AddMethod(\_\_Method\_ListFeatures, serviceImpl.ListFeatures)  
      .AddMethod(\_\_Method\_RecordRoute, serviceImpl.RecordRoute)  
      .AddMethod(\_\_Method\_RouteChat, serviceImpl.RouteChat).Build();  
}

/// <summary>Register service method implementations with a service binder. Useful when customizing the service binding logic.  
/// Note: this method is part of an experimental API that can change or be removed without any prior notice.</summary>  
/// <param name="serviceBinder">Service methods will be bound by calling <c>AddMethod</c> on this object.</param>  
/// <param name="serviceImpl">An object implementing the server-side handling logic.</param>  
public static void BindService(grpc::ServiceBinderBase serviceBinder, RouteGuideBase serviceImpl)  
{  
  serviceBinder.AddMethod(\_\_Method\_GetFeature, serviceImpl.GetFeature);  
  serviceBinder.AddMethod(\_\_Method\_ListFeatures, serviceImpl.ListFeatures);  
  serviceBinder.AddMethod(\_\_Method\_RecordRoute, serviceImpl.RecordRoute);  
  serviceBinder.AddMethod(\_\_Method\_RouteChat, serviceImpl.RouteChat);  
}

}
}
#endregion

• 创建服务器

1. 通过继承从我们的服务定义生成的基类来实现服务功能：执行我们服务的实际“工作”。
2. 运行gRPC服务器以侦听来自客户端的请求并返回服务响应。

// Copyright 2015 gRPC authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

using Grpc.Core;
using Grpc.Core.Utils;

namespace Routeguide
{
///

    public RouteGuideImpl(List<Feature> features)  
    {  
        this.features = features;  
    }

    /// <summary>  
    /// Gets the feature at the requested point. If no feature at that location  
    /// exists, an unnammed feature is returned at the provided location.  
    /// </summary>  
    public override Task<Feature> GetFeature(Point request, ServerCallContext context)  
    {  
        return Task.FromResult(CheckFeature(request));  
    }

    /// <summary>  
    /// Gets all features contained within the given bounding rectangle.  
    /// </summary>  
    public override async Task ListFeatures(Rectangle request, IServerStreamWriter<Feature> responseStream, ServerCallContext context)  
    {  
        var responses = features.FindAll( (feature) => feature.Exists() && request.Contains(feature.Location) );  
        foreach (var response in responses)  
        {  
            await responseStream.WriteAsync(response);  
        }  
    }

    /// <summary>  
    /// Gets a stream of points, and responds with statistics about the "trip": number of points,  
    /// number of known features visited, total distance traveled, and total time spent.  
    /// </summary>  
    public override async Task<RouteSummary> RecordRoute(IAsyncStreamReader<Point> requestStream, ServerCallContext context)  
    {  
        int pointCount = ;  
        int featureCount = ;  
        int distance = ;  
        Point previous = null;  
        var stopwatch = new Stopwatch();  
        stopwatch.Start();

        while (await requestStream.MoveNext())  
        {  
            var point = requestStream.Current;  
            pointCount++;  
            if (CheckFeature(point).Exists())  
            {  
                featureCount++;  
            }  
            if (previous != null)  
            {  
                distance += (int) previous.GetDistance(point);  
            }  
            previous = point;  
        }

        stopwatch.Stop();

        return new RouteSummary  
        {  
            PointCount = pointCount,  
            FeatureCount = featureCount,  
            Distance = distance,  
            ElapsedTime = (int)(stopwatch.ElapsedMilliseconds / )  
        };  
    }

    /// <summary>  
    /// Receives a stream of message/location pairs, and responds with a stream of all previous  
    /// messages at each of those locations.  
    /// </summary>  
    public override async Task RouteChat(IAsyncStreamReader<RouteNote> requestStream, IServerStreamWriter<RouteNote> responseStream, ServerCallContext context)  
    {  
        while (await requestStream.MoveNext())  
        {  
            var note = requestStream.Current;  
            List<RouteNote> prevNotes = AddNoteForLocation(note.Location, note);  
            foreach (var prevNote in prevNotes)  
            {  
                await responseStream.WriteAsync(prevNote);  
            }  
        }  
    }

    /// <summary>  
    /// Adds a note for location and returns a list of pre-existing notes for that location (not containing the newly added note).  
    /// </summary>  
    private List<RouteNote> AddNoteForLocation(Point location, RouteNote note)  
    {  
        lock (myLock)  
        {  
            List<RouteNote> notes;  
            if (!routeNotes.TryGetValue(location, out notes)) {  
                notes = new List<RouteNote>();  
                routeNotes.Add(location, notes);  
            }  
            var preexistingNotes = new List<RouteNote>(notes);  
            notes.Add(note);  
            return preexistingNotes;  
        }  
    }

    /// <summary>  
    /// Gets the feature at the given point.  
    /// </summary>  
    /// <param name="location">the location to check</param>  
    /// <returns>The feature object at the point Note that an empty name indicates no feature.</returns>  
    private Feature CheckFeature(Point location)  
    {  
        var result = features.FirstOrDefault((feature) => feature.Location.Equals(location));  
        if (result == null)  
        {  
            // No feature was found, return an unnamed feature.  
            return new Feature { Name = "", Location = location };  
        }  
        return result;  
    }  
}  

        var features = RouteGuideUtil.ParseFeatures(RouteGuideUtil.DefaultFeaturesFile);

        Server server = new Server  
        {  
            Services = { RouteGuide.BindService(new RouteGuideImpl(features)) },  
            Ports = { new ServerPort("localhost", Port, ServerCredentials.Insecure) }  
        };  
        server.Start();

        Console.WriteLine("RouteGuide server listening on port " + Port);  
        Console.WriteLine("Press any key to stop the server...");  
        Console.ReadKey();

        server.ShutdownAsync().Wait();  
    }  
}  

        public RouteGuideClient(RouteGuide.RouteGuideClient client)  
        {  
            this.client = client;  
        }

        /// <summary>  
        /// Blocking unary call example.  Calls GetFeature and prints the response.  
        /// </summary>  
        public void GetFeature(int lat, int lon)  
        {  
            try  
            {  
                Log("\*\*\* GetFeature: lat={0} lon={1}", lat, lon);

                Point request = new Point { Latitude = lat, Longitude = lon };

                Feature feature = client.GetFeature(request);  
                if (feature.Exists())  
                {  
                    Log("Found feature called \\"{0}\\" at {1}, {2}",  
                        feature.Name, feature.Location.GetLatitude(), feature.Location.GetLongitude());  
                }  
                else  
                {  
                    Log("Found no feature at {0}, {1}",  
                        feature.Location.GetLatitude(), feature.Location.GetLongitude());  
                }  
            }  
            catch (RpcException e)  
            {  
                Log("RPC failed " + e);  
                throw;  
            }  
        }

        /// <summary>  
        /// Server-streaming example. Calls listFeatures with a rectangle of interest. Prints each response feature as it arrives.  
        /// </summary>  
        public async Task ListFeatures(int lowLat, int lowLon, int hiLat, int hiLon)  
        {  
            try  
            {  
                Log("\*\*\* ListFeatures: lowLat={0} lowLon={1} hiLat={2} hiLon={3}", lowLat, lowLon, hiLat,  
                    hiLon);

                Rectangle request = new Rectangle  
                {  
                    Lo = new Point { Latitude = lowLat, Longitude = lowLon },  
                    Hi = new Point { Latitude = hiLat, Longitude = hiLon }  
                };

                using (var call = client.ListFeatures(request))  
                {  
                    var responseStream = call.ResponseStream;  
                    StringBuilder responseLog = new StringBuilder("Result: ");

                    while (await responseStream.MoveNext())  
                    {  
                        Feature feature = responseStream.Current;  
                        responseLog.Append(feature.ToString());  
                    }  
                    Log(responseLog.ToString());  
                }  
            }  
            catch (RpcException e)  
            {  
                Log("RPC failed " + e);  
                throw;  
            }  
        }

        /// <summary>  
        /// Client-streaming example. Sends numPoints randomly chosen points from features  
        /// with a variable delay in between. Prints the statistics when they are sent from the server.  
        /// </summary>  
        public async Task RecordRoute(List<Feature> features, int numPoints)  
        {  
            try  
            {  
                Log("\*\*\* RecordRoute");  
                using (var call = client.RecordRoute())  
                {  
                    // Send numPoints points randomly selected from the features list.  
                    StringBuilder numMsg = new StringBuilder();  
                    Random rand = new Random();  
                    for (int i = ; i < numPoints; ++i)  
                    {  
                        int index = rand.Next(features.Count);  
                        Point point = features\[index\].Location;  
                        Log("Visiting point {0}, {1}", point.GetLatitude(), point.GetLongitude());

                        await call.RequestStream.WriteAsync(point);

                        // A bit of delay before sending the next one.  
                        await Task.Delay(rand.Next() + );  
                    }  
                    await call.RequestStream.CompleteAsync();

                    RouteSummary summary = await call.ResponseAsync;  
                    Log("Finished trip with {0} points. Passed {1} features. "  
                        + "Travelled {2} meters. It took {3} seconds.", summary.PointCount,  
                        summary.FeatureCount, summary.Distance, summary.ElapsedTime);

                    Log("Finished RecordRoute");  
                }  
            }  
            catch (RpcException e)  
            {  
                Log("RPC failed", e);  
                throw;  
            }  
        }

        /// <summary>  
        /// Bi-directional streaming example. Send some chat messages, and print any  
        /// chat messages that are sent from the server.  
        /// </summary>  
        public async Task RouteChat()  
        {  
            try  
            {  
                Log("\*\*\* RouteChat");  
                var requests = new List<RouteNote>  
                {  
                    NewNote("First message", , ),  
                    NewNote("Second message", , ),  
                    NewNote("Third message", , ),  
                    NewNote("Fourth message", , )  
                };

                using (var call = client.RouteChat())  
                {  
                    var responseReaderTask = Task.Run(async () =>  
                    {  
                        while (await call.ResponseStream.MoveNext())  
                        {  
                            var note = call.ResponseStream.Current;  
                            Log("Got message \\"{0}\\" at {1}, {2}", note.Message,  
                                note.Location.Latitude, note.Location.Longitude);  
                        }  
                    });

                    foreach (RouteNote request in requests)  
                    {  
                        Log("Sending message \\"{0}\\" at {1}, {2}", request.Message,  
                            request.Location.Latitude, request.Location.Longitude);

                        await call.RequestStream.WriteAsync(request);  
                    }  
                    await call.RequestStream.CompleteAsync();  
                    await responseReaderTask;

                    Log("Finished RouteChat");  
                }  
            }  
            catch (RpcException e)  
            {  
                Log("RPC failed", e);  
                throw;  
            }  
        }

        private void Log(string s, params object\[\] args)  
        {  
            Console.WriteLine(string.Format(s, args));  
        }

        private void Log(string s)  
        {  
            Console.WriteLine(s);  
        }

        private RouteNote NewNote(string message, int lat, int lon)  
        {  
            return new RouteNote  
            {  
                Message = message,  
                Location = new Point { Latitude = lat, Longitude = lon }  
            };  
        }  
    }

    static void Main(string\[\] args)  
    {  
        var channel = new Channel("127.0.0.1:50052", ChannelCredentials.Insecure);  
        var client = new RouteGuideClient(new RouteGuide.RouteGuideClient(channel));

        // Looking for a valid feature  
        client.GetFeature(, -);

        // Feature missing.  
        client.GetFeature(, );

        // Looking for features between 40, -75 and 42, -73.  
        client.ListFeatures(, -, , -).Wait();

        // Record a few randomly selected points from the features file.  
        client.RecordRoute(RouteGuideUtil.ParseFeatures(RouteGuideUtil.DefaultFeaturesFile), ).Wait();

        // Send and receive some notes.  
        client.RouteChat().Wait();

        channel.ShutdownAsync().Wait();  
        Console.WriteLine("Press any key to exit...");  
        Console.ReadKey();  
    }  
}