public ServerNativeInterceptor(IServiceProvider serviceProvider, IServerCallInterceptorFactory callInterceptorFactory)
{
serviceProvider.AssertNotNull(nameof(serviceProvider));
callInterceptorFactory.AssertNotNull(nameof(callInterceptorFactory));
_interceptor = callInterceptorFactory.CreateInterceptor(serviceProvider);
}
public IServerCallInterceptor CreateInterceptor(IServiceProvider serviceProvider)
{
serviceProvider.AssertNotNull(nameof(serviceProvider));
var errorHandler = _errorHandlerFactory(serviceProvider);
return(new ServerCallErrorInterceptor(errorHandler, _marshallerFactory));
}
public static void Initialize(IServiceProvider serviceProvider, object providerPropertyKey)
{
serviceProvider.AssertNotNull(nameof(serviceProvider));
providerPropertyKey.AssertNotNull(nameof(providerPropertyKey));
AppProperty.Set(providerPropertyKey, serviceProvider);
_providerPropertyKey = providerPropertyKey;
}
public static InjectableObject <T> Create([NotNull] IServiceProvider serviceProvider)
{
serviceProvider.AssertNotNull("serviceProvider != null");
object[] services;
object instance = CreateInstance(typeof(T), serviceProvider, out services);
return(new InjectableObject <T>((T)instance, serviceProvider, services));
}
public static object GetServiceRequired(this IServiceProvider provider, Type serviceType)
{
provider.AssertNotNull(nameof(provider));
serviceType.AssertNotNull(nameof(serviceType));
var service = provider.GetService(serviceType);
if (service == null)
{
throw new InvalidOperationException("No service for type '{0}' has been registered.".FormatWith(serviceType.FullName));
}
return(service);
}
public static InjectableObject <T> Create([NotNull] Type type, [NotNull] IServiceProvider serviceProvider)
{
type.AssertNotNull("type != null");
serviceProvider.AssertNotNull("serviceProvider != null");
#if PORTABLE
Debug.Assert(typeof(T).GetTypeInfo().IsAssignableFrom(type.GetTypeInfo()));
#else
Debug.Assert(typeof(T).IsAssignableFrom(type));
#endif
object[] services;
object instance = CreateInstance(type, serviceProvider, out services);
return(new InjectableObject <T>((T)instance, serviceProvider, services));
}
public ServiceModelServiceMethodProvider(
IOptions <ServiceModelGrpcServiceOptions> rootConfiguration,
IOptions <ServiceModelGrpcServiceOptions <TService> > serviceConfiguration,
ILogger <ServiceModelServiceMethodProvider <TService> > logger,
IServiceProvider serviceProvider)
{
rootConfiguration.AssertNotNull(nameof(rootConfiguration));
serviceConfiguration.AssertNotNull(nameof(serviceConfiguration));
logger.AssertNotNull(nameof(logger));
serviceProvider.AssertNotNull(nameof(serviceProvider));
_rootConfiguration = rootConfiguration.Value;
_serviceConfiguration = serviceConfiguration.Value;
_logger = logger;
_serviceProvider = serviceProvider;
}
/// <summary>
/// Registers a ServiceModel.Grpc service in the <see cref="Server.ServiceDefinitionCollection"/>.
/// </summary>
/// <typeparam name="TService">The implementation type of ServiceModel.Grpc service.</typeparam>
/// <param name="services">The <see cref="Server.ServiceDefinitionCollection"/>.</param>
/// <param name="serviceProvider">See <see cref="IServiceProvider"/>.</param>
/// <param name="configure">The optional configuration action to provide a configuration the service.</param>
/// <returns><see cref="Server.ServiceDefinitionCollection"/>.</returns>
public static Server.ServiceDefinitionCollection AddServiceModel <TService>(
this Server.ServiceDefinitionCollection services,
IServiceProvider serviceProvider,
Action <ServiceModelGrpcServiceOptions>?configure = default)
{
services.AssertNotNull(nameof(services));
serviceProvider.AssertNotNull(nameof(serviceProvider));
Func <TService> serviceFactory = serviceProvider.GetServiceRequired <TService>;
var options = new ServiceModelGrpcServiceOptions
{
ServiceProvider = serviceProvider
};
BindService(services, serviceFactory, null, configure, options);
return(services);
}
