/// <summary>
/// Creates an <see cref="ServiceProxy"/>
/// </summary>
/// <typeparam name="TServiceInterface">The type of service to create</typeparam>
/// <param name="serviceUri">The uri of the service</param>
/// <param name="customHeaders">A <see cref="CustomHeaders"/> instance with data passed to the service</param>
/// <param name="partitionKey"></param>
/// <param name="targetReplicaSelector"></param>
/// <param name="listenerName"></param>
/// <returns>A service proxy object that implements IServiceProxy and TServiceInterface.</returns>
public static TServiceInterface Create <TServiceInterface>(Uri serviceUri, CustomHeaders customHeaders = null,
ServicePartitionKey partitionKey = null,
TargetReplicaSelector targetReplicaSelector = TargetReplicaSelector.Default, string listenerName = null)
where TServiceInterface : IService
{
return(Create <TServiceInterface>(serviceUri, () => customHeaders, partitionKey, targetReplicaSelector, listenerName));
}
private IStore CreateStoreProxy(TargetReplicaSelector targetReplicaSelector)
{
// The matchmaking service only store the matchmaking members in a single partition.
return(ServiceProxy.Create <IStore>(
new Uri("fabric:/SFKV/SFKV.Store"),
new ServicePartitionKey(0),
targetReplicaSelector));
}
public ValidationServiceClient(
ICommunicationClientFactory <WcfCommunicationClient <IValidationServiceStateful> > communicationClientFactory,
Uri serviceUri, ServicePartitionKey partitionKey = null,
TargetReplicaSelector targetReplicaSelector = TargetReplicaSelector.Default, string listenerName = null,
OperationRetrySettings retrySettings = null) : base(communicationClientFactory, serviceUri, partitionKey,
targetReplicaSelector, listenerName, retrySettings)
{
}
public static TServiceInterface CreateServiceProxy <TServiceInterface>(
Uri serviceUri,
ServicePartitionKey partitionKey = null,
TargetReplicaSelector targetReplicaSelector = TargetReplicaSelector.Default,
string listenerName = null)
where TServiceInterface : IService
{
return(DefaultServiceProxyFactory.CreateServiceProxy <TServiceInterface>(serviceUri, partitionKey, targetReplicaSelector, listenerName));
}
public async Task <IServiceRemotingClient> GetClientAsync(ResolvedServicePartition previousRsp,
TargetReplicaSelector targetReplicaSelector,
string listenerName,
OperationRetrySettings retrySettings,
CancellationToken cancellationToken)
{
var client = await serviceRemotingClientFactory.GetClientAsync(previousRsp, targetReplicaSelector, listenerName, retrySettings, cancellationToken);
return(new ServiceRemotingClientWrapper(client, traceId));
}
/// <summary>
/// Re-resolves a partition of the specified service containing one or more communication listeners and returns a client to communicate
/// to the endpoint corresponding to the given listenerName.
/// The endpoint of the service is of the form - {"Endpoints":{"Listener1":"Endpoint1","Listener2":"Endpoint2" ...}}
/// </summary>
/// <param name="previousRsp">Previous ResolvedServicePartition value</param>
/// <param name="targetReplicaSelector">Specifies which replica in the partition identified by the partition key, the client should connect to</param>
/// <param name="listenerName">Specifies which listener in the endpoint of the chosen replica, to which the client should connect to</param>
/// <param name="retrySettings">Specifies the retry policy that should be used for exceptions that occur when creating the client.</param>
/// <param name="cancellationToken">Cancellation token</param>
/// <returns>
/// A <see cref="System.Threading.Tasks.Task">Task</see> that represents outstanding operation. The result of the Task is
/// the CommunicationClient(<see cref="ICommunicationClient" />) object.
/// </returns>
public async Task <IServiceRemotingClient> GetClientAsync(ResolvedServicePartition previousRsp,
TargetReplicaSelector targetReplicaSelector,
string listenerName, OperationRetrySettings retrySettings, CancellationToken cancellationToken)
{
return(await this.clientFactoryImpl.GetClientAsync(previousRsp,
targetReplicaSelector,
listenerName,
retrySettings,
cancellationToken));
}
public MockActorProxy(
ActorId actorId,
Uri serviceUri,
ServicePartitionKey partitionKey,
TargetReplicaSelector replicaSelector,
string listenerName,
ICommunicationClientFactory <IServiceRemotingClient> factory)
{
ActorId = actorId;
ActorServicePartitionClient = new MockActorServicePartitionClient(actorId, serviceUri, partitionKey, replicaSelector, listenerName, factory);
}
public async Task <IServiceRemotingClient> GetClientAsync(
ResolvedServicePartition previousRsp,
TargetReplicaSelector targetReplicaSelector,
string listenerName,
OperationRetrySettings retrySettings,
CancellationToken cancellationToken)
{
var client = await this._wrapped.GetClientAsync(previousRsp, targetReplicaSelector, listenerName, retrySettings, cancellationToken);
return(new CustomServiceRemotingClient(client));
}
/// <summary>
/// Resolves a partition of the specified service containing one or more communication listeners and returns a client to communicate
/// to the endpoint corresponding to the given listenerName.
/// The endpoint of the service is of the form - {"Endpoints":{"Listener1":"Endpoint1","Listener2":"Endpoint2" ...}}
/// </summary>
/// <param name="serviceUri">Uri of the service to resolve</param>
/// <param name="partitionKey">Key that identifies the partition to resolve</param>
/// <param name="targetReplicaSelector">Specifies which replica in the partition identified by the partition key, the client should connect to</param>
/// <param name="listenerName">Specifies which listener in the endpoint of the chosen replica, to which the client should connect to</param>
/// <param name="retrySettings">Specifies the retry policy that should be used for exceptions that occur when creating the client.</param>
/// <param name="cancellationToken">Cancellation token</param>
/// <returns>
/// A <see cref="System.Threading.Tasks.Task">Task</see> that represents outstanding operation. The result of the Task is
/// the CommunicationClient(<see cref="ICommunicationClient" />) object.
/// </returns>
public async Task <IServiceRemotingClient> GetClientAsync(Uri serviceUri, ServicePartitionKey partitionKey,
TargetReplicaSelector targetReplicaSelector,
string listenerName, OperationRetrySettings retrySettings, CancellationToken cancellationToken)
{
return(await this.clientFactoryImpl.GetClientAsync(serviceUri,
partitionKey,
targetReplicaSelector,
listenerName,
retrySettings,
cancellationToken));
}
/// <summary>
/// Creates a proxy to communicate to the specified service using the remoted interface TServiceInterface that
/// the service implements.
/// <typeparam name="TServiceInterface">Interface that is being remoted</typeparam>
/// <param name="serviceUri">Uri of the Service.</param>
/// <param name="partitionKey">The Partition key that determines which service partition is responsible for handling requests from this service proxy</param>
/// <param name="targetReplicaSelector">Determines which replica or instance of the service partition the client should connect to.</param>
/// <param name="listenerName">This parameter is Optional if the service has a single communication listener. The endpoints from the service
/// are of the form {"Endpoints":{"Listener1":"Endpoint1","Listener2":"Endpoint2" ...}}. When the service exposes multiple endpoints, this parameter
/// identifies which of those endpoints to use for the remoting communication.
/// </param>
/// <returns>The proxy that implement the interface that is being remoted. The returned object also implement <see cref="IServiceProxy"/> interface.</returns>
/// </summary>
public TServiceInterface CreateNonIServiceProxy <TServiceInterface>(
Uri serviceUri,
ServicePartitionKey partitionKey = null,
TargetReplicaSelector targetReplicaSelector = TargetReplicaSelector.Default,
string listenerName = null)
{
var serviceInterfaceType = typeof(TServiceInterface);
var proxyGenerator = ServiceCodeBuilder.GetOrCreateProxyGeneratorForNonServiceInterface(serviceInterfaceType);
return(this.CreateServiceProxy <TServiceInterface>(serviceUri, partitionKey, targetReplicaSelector, listenerName, serviceInterfaceType, proxyGenerator));
}
public static TServiceInterface CreateServiceProxy <TServiceInterface>(
Uri serviceUri,
ServicePartitionKey partitionKey = null,
TargetReplicaSelector targetReplicaSelector = TargetReplicaSelector.Default,
string listenerName = null,
Action <CallSummary> raiseSummary = null,
string remoteServiceName = null) where TServiceInterface : IService
{
var proxyFactory = new CorrelatingServiceProxyFactory <TServiceInterface>(raiseSummary: raiseSummary, remoteServiceName: remoteServiceName);
return(proxyFactory.CreateServiceProxy <TServiceInterface>(serviceUri, partitionKey, targetReplicaSelector, listenerName));
}
public async Task <IServiceRemotingClient> GetClientAsync(
Uri serviceUri,
ServicePartitionKey partitionKey,
TargetReplicaSelector targetReplicaSelector,
string listenerName,
OperationRetrySettings retrySettings,
CancellationToken cancellationToken)
{
IServiceRemotingClient innerClient = await innerClientFactory.GetClientAsync(serviceUri, partitionKey, targetReplicaSelector, listenerName, retrySettings, cancellationToken).ConfigureAwait(false);
return(new CorrelatingServiceRemotingClient(innerClient, serviceUri, methodNameProvider));
}
public TServiceInterface CreateServiceProxy <TServiceInterface>(Uri serviceUri,
ServicePartitionKey partitionKey = null,
TargetReplicaSelector targetReplicaSelector = TargetReplicaSelector.Default, string listenerName = null)
where TServiceInterface : IService
{
MockServiceProxy serviceProxy = new MockServiceProxy();
serviceProxy.Supports <TServiceInterface>((mockUri) => mockServiceLookupTable[serviceUri]);
return(serviceProxy.Create <TServiceInterface>(serviceUri, partitionKey, targetReplicaSelector,
listenerName));
}
public async Task <IServiceRemotingClient> GetClientAsync(
Uri serviceUri,
ServicePartitionKey partitionKey,
TargetReplicaSelector targetReplicaSelector,
string listenerName,
OperationRetrySettings retrySettings,
CancellationToken cancellationToken)
{
var client = await this._wrapped.GetClientAsync(serviceUri, partitionKey, targetReplicaSelector, listenerName, retrySettings, cancellationToken);
return(new CustomServiceRemotingClient(client));
}
public TServiceInterface CreateServiceProxy <TServiceInterface>(
Uri serviceUri,
ServicePartitionKey partitionKey = null,
TargetReplicaSelector targetReplicaSelector = TargetReplicaSelector.Default,
string listenerName = null
) where TServiceInterface : IService
{
GetOrDiscoverServiceMethodDispatcher(typeof(TServiceInterface));
var proxy = GetInnerServiceProxyFactory(typeof(TServiceInterface)).CreateServiceProxy <TServiceInterface>(serviceUri, partitionKey, targetReplicaSelector, listenerName);
UpdateRequestContext(serviceUri);
return(proxy);
}
public static TServiceInterface Create <TServiceInterface>(
Uri serviceUri, ServicePartitionKey partitionKey = null, TargetReplicaSelector targetReplicaSelector = TargetReplicaSelector.Default,
string listenerName = null) where TServiceInterface : IService
{
var proxyFactory = new CorrelatingServiceProxyFactory(callbackClient =>
new FabricTransportServiceRemotingClientFactory(callbackClient: callbackClient));
TServiceInterface proxy =
proxyFactory.CreateServiceProxy <TServiceInterface>(serviceUri, partitionKey, targetReplicaSelector,
listenerName);
return(proxy);
}
public static T Create <T>(
Uri serviceUri,
TelemetryClient telemetryClient,
ServiceContext context,
ServicePartitionKey partitionKey = null,
TargetReplicaSelector targetReplicaSelector = TargetReplicaSelector.Default) where T : class, IService
{
var service = CreateFactory().CreateServiceProxy <T>(serviceUri, partitionKey, targetReplicaSelector);
T proxy = Generator.CreateInterfaceProxyWithTargetInterface(
service,
new LoggingServiceProxyInterceptor(telemetryClient, context, serviceUri.ToString()));
return(proxy);
}
/// <summary>
/// Creates an <see cref="ServiceProxy"/>
/// </summary>
/// <typeparam name="TServiceInterface">The type of service to create</typeparam>
/// <param name="serviceUri">The uri of the service</param>
/// <param name="customHeaderProvider">A factory to create a <see cref="CustomHeaders"/> instance with data passed to the service</param>
/// <param name="partitionKey"></param>
/// <param name="targetReplicaSelector"></param>
/// <param name="listenerName"></param>
/// <returns>A service proxy object that implements IServiceProxy and TServiceInterface.</returns>
public static TServiceInterface Create <TServiceInterface>(Uri serviceUri, Func <CustomHeaders> customHeaderProvider,
ServicePartitionKey partitionKey = null,
TargetReplicaSelector targetReplicaSelector = TargetReplicaSelector.Default, string listenerName = null)
where TServiceInterface : IService
{
var methodNameProvider = new MethodNameProvider();
var proxyFactory = new ServiceProxyFactory(handler =>
new ExtendedServiceRemotingClientFactory(
new FabricTransportServiceRemotingClientFactory(remotingCallbackMessageHandler: handler), customHeaderProvider, methodNameProvider));
var proxy = proxyFactory.CreateServiceProxy <TServiceInterface>(serviceUri, partitionKey, targetReplicaSelector, listenerName);
methodNameProvider.AddMethodsForProxyOrService(proxy.GetType().GetInterfaces(), typeof(IService));
return(proxy);
}
internal MockActorServicePartitionClient(
ActorId actorId,
Uri serviceUri,
ServicePartitionKey partitionKey,
TargetReplicaSelector replicaSelector,
string listenerName,
ICommunicationClientFactory <IServiceRemotingClient> factory)
{
ActorId = actorId;
ServiceUri = serviceUri;
PartitionKey = partitionKey;
TargetReplicaSelector = replicaSelector;
ListenerName = listenerName;
Factory = factory;
}
public ServiceRemotingPartitionClient(
IServiceRemotingClientFactory remotingClientFactory,
Uri serviceUri,
ServicePartitionKey partitionKey = null,
TargetReplicaSelector targetReplicaSelector = TargetReplicaSelector.Default,
string listenerName = null,
OperationRetrySettings retrySettings = null)
: base(
remotingClientFactory,
serviceUri,
partitionKey,
targetReplicaSelector,
listenerName,
retrySettings)
{
}
public async Task <IServiceRemotingClient> GetClientAsync(
ResolvedServicePartition previousRsp,
TargetReplicaSelector targetReplicaSelector,
string listenerName,
OperationRetrySettings retrySettings,
CancellationToken cancellationToken)
{
var client = await _InnerClientFactory.GetClientAsync(
previousRsp,
targetReplicaSelector,
listenerName,
retrySettings,
cancellationToken).ConfigureAwait(false);
return(new TrackingFabricTransportServiceRemotingClient(client));
}
public async Task <IServiceRemotingClient> GetClientAsync(
ResolvedServicePartition previousRsp,
TargetReplicaSelector targetReplicaSelector,
string listenerName,
OperationRetrySettings retrySettings,
CancellationToken cancellationToken)
{
var client = await serviceRemotingClientFactory.GetClientAsync(
previousRsp,
targetReplicaSelector,
listenerName,
retrySettings,
cancellationToken);
return(new ServiceRemotingClientWrapper(client, customHeadersProvider, BeforeSendRequestResponseAsync, AfterSendRequestResponseAsync));
}
public async Task <IServiceRemotingClient> GetClientAsync(
ResolvedServicePartition previousRsp,
TargetReplicaSelector targetReplicaSelector,
string listenerName,
OperationRetrySettings retrySettings,
CancellationToken cancellationToken)
{
IServiceRemotingClient inner = await _inner.GetClientAsync(
previousRsp,
targetReplicaSelector,
listenerName,
retrySettings,
cancellationToken);
return(new ActivityServiceRemotingClient(inner));
}
/// <summary>
/// Re-resolves a partition of the specified service containing one or more communication listeners and returns a client to communicate
/// to the endpoint corresponding to the given listenerName.
/// The endpoint of the service is of the form - {"Endpoints":{"Listener1":"Endpoint1","Listener2":"Endpoint2" ...}}
/// </summary>
/// <param name="previousRsp">Previous ResolvedServicePartition value</param>
/// <param name="targetReplicaSelector">Specifies which replica in the partition identified by the partition key, the client should connect to</param>
/// <param name="listenerName">Specifies which listener in the endpoint of the chosen replica, to which the client should connect to</param>
/// <param name="retrySettings">Specifies the retry policy that should be used for exceptions that occur when creating the client.</param>
/// <param name="cancellationToken">Cancellation token</param>
/// <returns>
/// A <see cref="System.Threading.Tasks.Task">Task</see> that represents outstanding operation. The result of the Task is
/// the CommunicationClient(<see cref="ICommunicationClient" />) object.
/// </returns>
async Task <IServiceRemotingClient> ICommunicationClientFactory <IServiceRemotingClient> .GetClientAsync(
ResolvedServicePartition previousRsp,
TargetReplicaSelector targetReplicaSelector,
string listenerName,
OperationRetrySettings retrySettings,
CancellationToken cancellationToken)
{
var client = await this.impl.GetClientAsync(
previousRsp,
targetReplicaSelector,
listenerName,
retrySettings,
cancellationToken);
return(client);
}
/// <summary>
/// Creates a proxy to communicate to the specified service using the remoted interface TServiceInterface that
/// the service implements.
/// <typeparam name="TServiceInterface">Interface that is being remoted . Service Interface does not need to be inherited from IService.</typeparam>
/// <param name="serviceUri">Uri of the Service.</param>
/// <param name="partitionKey">The Partition key that determines which service partition is responsible for handling requests from this service proxy</param>
/// <param name="targetReplicaSelector">Determines which replica or instance of the service partition the client should connect to.</param>
/// <param name="listenerName">This parameter is Optional if the service has a single communication listener. The endpoints from the service
/// are of the form {"Endpoints":{"Listener1":"Endpoint1","Listener2":"Endpoint2" ...}}. When the service exposes multiple endpoints, this parameter
/// identifies which of those endpoints to use for the remoting communication.
/// </param>
/// <returns>The proxy that implement the interface that is being remoted. The returned object also implement <see cref="IServiceProxy"/> interface.</returns>
/// </summary>
public TServiceInterface CreateNonIServiceProxy <TServiceInterface>(Uri serviceUri,
ServicePartitionKey partitionKey = null,
TargetReplicaSelector targetReplicaSelector = TargetReplicaSelector.Default, string listenerName = null)
{
var serviceInterfaceType = typeof(TServiceInterface);
if (this.proxyFactoryV2 == null)
{
var provider = this.GetProviderAttribute(serviceInterfaceType);
this.proxyFactoryV2 = new V2.Client.ServiceProxyFactory(provider.CreateServiceRemotingClientFactoryV2, retrySettings);
}
return(this.proxyFactoryV2.CreateNonIServiceProxy <TServiceInterface>(serviceUri,
partitionKey,
targetReplicaSelector,
listenerName));
}
/// <summary>
/// Re-resolves a partition of the specified service containing one or more communication listeners and returns a client to communicate
/// to the endpoint corresponding to the given listenerName.
///
/// The endpoint of the service is of the form - {"Endpoints":{"Listener1":"Endpoint1","Listener2":"Endpoint2" ...}}
/// </summary>
/// <param name="previousRsp">Previous ResolvedServicePartition value</param>
/// <param name="targetReplicaSelector">Specifies which replica in the partition identified by the partition key, the client should connect to</param>
/// <param name="listenerName">Specifies which listener in the endpoint of the chosen replica, to which the client should connect to</param>
/// <param name="retrySettings">Specifies the retry policy that should be used for exceptions that occur when creating the client.</param>
/// <param name="cancellationToken">Cancellation token</param>
/// <returns>
/// A <see cref="System.Threading.Tasks.Task">Task</see> that represents outstanding operation. The result of the Task is
/// the CommunicationClient(<see cref="ICommunicationClient" />) object.
/// </returns>
async Task <IServiceRemotingClient> ICommunicationClientFactory <IServiceRemotingClient> .GetClientAsync(
ResolvedServicePartition previousRsp,
TargetReplicaSelector targetReplicaSelector,
string listenerName,
OperationRetrySettings retrySettings,
CancellationToken cancellationToken)
{
var wcfClient = await this.wcfFactory.GetClientAsync(
previousRsp,
targetReplicaSelector,
listenerName,
retrySettings,
cancellationToken);
return(new WcfServiceRemotingClient(wcfClient,
this.serializersManager));
}
/// <summary>
/// Gets or Creates the CommunicationClient for the specified listener name by resolving based on the given previousRsp.
/// </summary>
/// <param name="previousRsp">Previous ResolvedServicePartition value</param>
/// <param name="targetReplica">Specifies which replica in the partition identified by the partition key, the client should connect to</param>
/// <param name="listenerName">Specifies which listener in the endpoint of the chosen replica, to which the client should connect to</param>
/// <param name="retrySettings">Specifies the retry policy that should be used for exceptions that occur when creating the client.</param>
/// <param name="cancellationToken">Cancellation token</param>
/// <returns>
/// A <see cref="System.Threading.Tasks.Task">Task</see> that represents outstanding operation. The result of the Task is
/// the CommunicationClient(<see cref="ICommunicationClient" />) object.
/// </returns>
public async Task <TCommunicationClient> GetClientAsync(
ResolvedServicePartition previousRsp,
TargetReplicaSelector targetReplica,
string listenerName,
OperationRetrySettings retrySettings,
CancellationToken cancellationToken)
{
var newClient = await this.CreateClientWithRetriesAsync(
previousRsp,
targetReplica,
listenerName,
retrySettings,
true,
cancellationToken);
return(newClient);
}
private TServiceInterface CreateServiceProxy <TServiceInterface>(Uri serviceUri, ServicePartitionKey partitionKey,
TargetReplicaSelector targetReplicaSelector, string listenerName, Type serviceInterfaceType,
ServiceProxyGenerator proxyGenerator)
{
var clientFactory = this.GetOrCreateServiceRemotingClientFactory(serviceInterfaceType);
var serviceRemotingPartitionClient = new ServiceRemotingPartitionClient(
clientFactory,
serviceUri,
partitionKey,
targetReplicaSelector,
listenerName,
this.retrySettings);
return((TServiceInterface)(object)proxyGenerator.CreateServiceProxy(serviceRemotingPartitionClient,
clientFactory.GetRemotingMessageBodyFactory()
));
}
/// <summary>
/// Resolves a partition of the specified service containing one or more communication listeners and returns a client to communicate
/// to the endpoint corresponding to the given listenerName.
/// The endpoint of the service is of the form - {"Endpoints":{"Listener1":"Endpoint1","Listener2":"Endpoint2" ...}}
/// </summary>
/// <param name="serviceUri">Uri of the service to resolve</param>
/// <param name="partitionKey">Key that identifies the partition to resolve</param>
/// <param name="targetReplicaSelector">Specifies which replica in the partition identified by the partition key, the client should connect to</param>
/// <param name="listenerName">Specifies which listener in the endpoint of the chosen replica, to which the client should connect to</param>
/// <param name="retrySettings">Specifies the retry policy that should be used for exceptions that occur when creating the client.</param>
/// <param name="cancellationToken">Cancellation token</param>
/// <returns>
/// A <see cref="System.Threading.Tasks.Task">Task</see> that represents outstanding operation. The result of the Task is
/// the CommunicationClient(<see cref="ICommunicationClient" />) object.
/// </returns>
async Task <IServiceRemotingClient> ICommunicationClientFactory <IServiceRemotingClient> .GetClientAsync(
Uri serviceUri,
ServicePartitionKey partitionKey,
TargetReplicaSelector targetReplicaSelector,
string listenerName,
OperationRetrySettings retrySettings,
CancellationToken cancellationToken)
{
var client = await this.impl.GetClientAsync(
serviceUri,
partitionKey,
targetReplicaSelector,
listenerName,
retrySettings,
cancellationToken);
return(client);
}
/// <summary>
/// Creates a proxy to communicate to the specified service using the remoted interface TServiceInterface that
/// the service implements.
/// <typeparam name="TServiceInterface">Interface that is being remoted</typeparam>
/// <param name="serviceUri">Uri of the Service.</param>
/// <param name="partitionKey">The Partition key that determines which service partition is responsible for handling requests from this service proxy</param>
/// <param name="targetReplicaSelector">Determines which replica or instance of the service partition the client should connect to.</param>
/// <param name="listenerName">This parameter is Optional if the service has a single communication listener. The endpoints from the service
/// are of the form {"Endpoints":{"Listener1":"Endpoint1","Listener2":"Endpoint2" ...}}. When the service exposes multiple endpoints, this parameter
/// identifies which of those endpoints to use for the remoting communication.
/// </param>
/// <returns>The proxy that implement the interface that is being remoted. The returned object also implement <see cref="Microsoft.ServiceFabric.Services.Remoting.Client.IServiceProxy"/> interface.</returns>
/// </summary>
public TServiceInterface CreateServiceProxy <TServiceInterface>(
Uri serviceUri,
ServicePartitionKey partitionKey = null,
TargetReplicaSelector targetReplicaSelector = TargetReplicaSelector.Default,
string listenerName = null) where TServiceInterface : IService
{
var serviceInterfaceType = typeof(TServiceInterface);
var proxyGenerator = ServiceCodeBuilder.GetOrCreateProxyGenerator(serviceInterfaceType);
var serviceRemotingPartitionClient = new ServiceRemotingPartitionClient(
this.GetOrCreateServiceRemotingClientFactory(serviceInterfaceType),
serviceUri,
partitionKey,
targetReplicaSelector,
listenerName,
this.retrySettings);
return((TServiceInterface)(object)proxyGenerator.CreateServiceProxy(serviceRemotingPartitionClient));
}
