public override void Register(IServiceRegister register)
{
//Register the protobufnet serializers
register.Register <ProtobufnetSerializerStrategy>(this.getFlags(), typeof(ISerializerStrategy));
register.Register <ProtobufnetDeserializerStrategy>(this.getFlags(), typeof(IDeserializerStrategy));
register.Register <ProtobufnetRegistry>(this.getFlags(), typeof(ISerializerRegistry));
}
public void RegisterDependencies(IServiceRegister serviceRegister)
{
if (serviceRegister is null)
{
throw new System.ArgumentNullException(nameof(serviceRegister));
}
serviceRegister.Register(typeof(IUserSession), typeof(UserSession), ServiceLifetime.Scoped);
serviceRegister.Register(typeof(UserSession), typeof(UserSession), ServiceLifetime.Scoped);
}
public void RegisterDependencies(IServiceRegister serviceRegister)
{
if (serviceRegister is null)
{
throw new System.ArgumentNullException(nameof(serviceRegister));
}
serviceRegister.Register(typeof(ISendTemplates), typeof(EmailTemplateRepository), ServiceLifetime.Scoped);
serviceRegister.Register(typeof(IQueueAndSendMail), typeof(EmailService), ServiceLifetime.Scoped);
serviceRegister.Register(typeof(IQueueAndSendMail), typeof(EmailService), ServiceLifetime.Scoped);
serviceRegister.Register(typeof(ISendMail), typeof(EmailService), ServiceLifetime.Scoped);
serviceRegister.Register(typeof(EmailRenderer), typeof(EmailRenderer), ServiceLifetime.Scoped);
}
public void RegisterDependencies(IServiceRegister serviceRegister)
{
if (serviceRegister is null)
{
throw new ArgumentNullException(nameof(serviceRegister));
}
serviceRegister.Register(typeof(MessageBus), typeof(MessageBus), ServiceLifetime.Transient);
foreach (Type t in TypeFactory.GetAllImplementations(typeof(IMessageHandler <>)))
{
serviceRegister.Register(t, t, ServiceLifetime.Scoped);
}
}
public void RegisterDependencies(IServiceRegister serviceRegister)
{
if (serviceRegister is null)
{
throw new ArgumentNullException(nameof(serviceRegister));
}
foreach (Type t in TypeFactory.GetDerivedTypes(typeof(Entity)))
{
Type genericProviderType = typeof(ISecurityProvider <>).MakeGenericType(t);
serviceRegister.Register(genericProviderType, typeof(PermissionableEntitySecurityProvider), ServiceLifetime.Scoped);
}
serviceRegister.Register(typeof(ISecurityProvider <Entity>), typeof(PermissionableEntitySecurityProvider), ServiceLifetime.Scoped);
}
public override void Register(IServiceRegister register)
{
//Just create a new collection and register it
NetworkEntityCollection entityCollection = new NetworkEntityCollection();
register.Register(entityCollection, this.getFlags());
}
public void RegisterDependencies(IServiceRegister serviceRegister)
{
if (serviceRegister is null)
{
throw new ArgumentNullException(nameof(serviceRegister));
}
serviceRegister.Register((IServiceProvider ServiceProvider) =>
{
CookieOptions option = new CookieOptions
{
Expires = DateTime.Now.AddDays(-10)
};
HttpContext context = ServiceProvider.GetService <HttpContext>();
ISession session = context.Session;
TeaEncryptor tea = new TeaEncryptor(session.Get(SecurityService.SECURITY_TOKEN_PASSWORD_NAME));
string fingerPrintJson = tea.Decrypt(context.Request.Cookies["X-Session"]);
SecurityToken securityToken = JsonConvert.DeserializeObject <SecurityToken>(fingerPrintJson);
context.Response.Cookies.Append("X-Session", "", option);
return(securityToken);
}, ServiceLifetime.Singleton);
}
/// <summary>
/// Enables support of using multiple channels for clients operations
/// </summary>
/// <param name="serviceRegister">The register</param>
/// <param name="channelsCount">Max count of channels</param>
public static IServiceRegister EnableMultiChannelClientCommandDispatcher(
this IServiceRegister serviceRegister, int channelsCount
)
{
return(serviceRegister.Register <IClientCommandDispatcher>(
x => new MultiChannelClientCommandDispatcher(channelsCount, x.Resolve <IPersistentChannelFactory>())
));
}
public override void Register(IServiceRegister register)
{
//Let's supply an instance of some made-up Resource management class that is a singleton.
//get flags is a protected method that supplies the flag enum setup in the inspector for registering.
register.Register(ResourceLoader.instance, this.getFlags()); //This is all that is needed.
//The below is an example of another way to register a depedency. It is not another line that is required when the above exists.
//Optionally you may want to register it like this, indicating specifically the Type to register the service as.
register.Register(ResourceLoader.instance, this.getFlags(), typeof(ICharacterModelService));
//The below is an example of another way to register a depedency. It is not another line that is required when the above exists.
//Alternatively you can register a Type, without an instance, as a depedency. This will be created by the container on-demand.
//If you set a flag to indicate one per dependency or only a single instance it will adhere to those flags.
register.Register <SkyBoxController>(this.getFlags(), typeof(IWeatherService)); //This type parameter is optional as well. Without a type or a proper flag it will assume you want to register AsSelf.
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.Configure <CookiePolicyOptions>(options =>
{
// This lambda determines whether user consent for non-essential cookies is needed for a given request.
options.CheckConsentNeeded = context => true;
options.MinimumSameSitePolicy = SameSiteMode.None;
});
////？？？需要注入的服务在 InjectionService.AdmServiceRegister.Register方法内注入即可
/// //services.AddScoped<IParaReferRepository（接口）, ParaReferRepository（实现类）>();
services.Configure <CookiePolicyOptions>(options =>
{
// This lambda determines whether user consent for non-essential cookies is needed for a given request.
options.CheckConsentNeeded = context => true;
options.MinimumSameSitePolicy = SameSiteMode.None;
});
//数据库连接
var conStr = new ConfigurationBuilder().AddJsonFile("appsettings.json").Build()["ConnectionStrings:SqlServerConnectiion"];
services.AddDbContext <DccyDbContext>(options => options.UseSqlServer(conStr), ServiceLifetime.Scoped);
//注入配置类
services.AddOptions();
services.Configure <AppSetting>(Configuration.GetSection("AppSetting"));
#region 批量注入
//外部注入
string strValue = Configuration.GetSection("Appsetings").GetSection("key").Value;
foreach (var item in GetClassName(strValue))
{
foreach (var typeArray in item.Value)
{
services.AddScoped(typeArray, item.Key);
}
}
//内部注入
IEnumerable <Type> serviceList = AppDomain.CurrentDomain.GetAssemblies()
.SelectMany(m => m.GetTypes()).Select(m => m.GetTypeInfo())
.Where(m => !m.IsAbstract &&
!m.IsInterface &&
typeof(IServiceRegister).GetTypeInfo().IsAssignableFrom(m));
foreach (Type type in serviceList)
{
IServiceRegister register = Activator.CreateInstance(type, true) as IServiceRegister;
register.Register(services);
}
#endregion
services.AddDistributedMemoryCache();
services.AddSession();
services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_1);
}
/// <summary>
/// Registers dependencies for this assembly
/// </summary>
public void RegisterDependencies(IServiceRegister serviceRegister)
{
if (serviceRegister is null)
{
throw new System.ArgumentNullException(nameof(serviceRegister));
}
serviceRegister.Register <IViewRenderService, ViewRenderService>(ServiceLifetime.Scoped);
}
public static IServiceRegister EnableDeadLetterExchangeAndMessageTtlScheduler(this IServiceRegister serviceRegister)
{
return(serviceRegister.Register <IScheduler>(
x => new DeadLetterExchangeAndMessageTtlScheduler(
x.Resolve <IAdvancedBus>(),
x.Resolve <IConventions>(),
x.Resolve <IMessageDeliveryModeStrategy>()
)
));
}
public override void Register(IServiceRegister register)
{
//Chain handling semantics are preferable on the client.
//No reason multiple handlers should be consuming the same packets, complications things
//Put it infront of the handling process if you want that functionality
ChainMessageHandlerStrategy <InstanceClientSession, IRequestMessage> chainHandler = new ChainMessageHandlerStrategy <InstanceClientSession, IRequestMessage>(FindHandlersInScene());
//generics are semi-limited in .Net when trying to construct an instance of the type so we put the requirement for inheritors to create the instance.
register.Register <RequestMessageHandlerService <InstanceClientSession> >(new RequestMessageHandlerService <InstanceClientSession>(chainHandler), getFlags(), typeof(IRequestMessageHandlerService <InstanceClientSession>));
}
public override void Register(IServiceRegister register)
{
//Chain handling semantics are preferable on the client.
//No reason multiple handlers should be consuming the same packets, complications things
//Put it infront of the handling process if you want that functionality
ChainMessageHandlerStrategy<TPeerType, TNetworkMessageType> chainHandler = new ChainMessageHandlerStrategy<TPeerType, TNetworkMessageType>(FindHandlersInScene());
//generics are semi-limited in .Net when trying to construct an instance of the type so we put the requirement for inheritors to create the instance.
register.Register<THandlerServiceTypeConcrete>(CreateConcreteService(chainHandler), ComputeFlags(), typeof(THandlerServiceTypeServiceInterface));
}
private static void RecursiveRegisterRepository(IServiceRegister serviceRegister, Type RepositoryType)
{
serviceRegister.Register(RepositoryType, RepositoryType, ServiceLifetime.Transient);
RegisterInterfaces(serviceRegister, RepositoryType);
Type baseType = RepositoryType.BaseType;
while (baseType != null)
{
if (!baseType.IsGenericTypeDefinition)
{
StaticLogger.Log($"PPDI: Registering repository for {baseType} => {RepositoryType}", StaticLogger.LoggingLevel.Call);
serviceRegister.Register(baseType, RepositoryType, ServiceLifetime.Transient);
}
baseType = baseType.BaseType;
}
}
public void RegisterDependencies(IServiceRegister serviceRegister)
{
if (serviceRegister is null)
{
throw new ArgumentNullException(nameof(serviceRegister));
}
foreach (Type workerType in TypeFactory.GetAllImplementations <IWorker>())
{
serviceRegister.Register(workerType, workerType, ServiceLifetime.Scoped);
}
}
public void RegisterDependencies(IServiceRegister serviceRegister)
{
if (serviceRegister is null)
{
throw new ArgumentNullException(nameof(serviceRegister));
}
foreach (Type controllerType in TypeFactory.GetDerivedTypes(typeof(Controller)))
{
serviceRegister.Register(controllerType, controllerType, ServiceLifetime.Scoped);
}
}
private static void RegisterInterfaces(IServiceRegister serviceRegister, Type RepositoryType)
{
foreach (Type i in RepositoryType.GetInterfaces())
{
if (i.IsGenericType && i.IsAssignableFrom(RepositoryType))
{
StaticLogger.Log($"PPDI: Registering repository for {i} => {RepositoryType}", StaticLogger.LoggingLevel.Call);
serviceRegister.Register(i, RepositoryType, ServiceLifetime.Transient);
}
}
}
//We should try to locate this object in the scene
public override void Register(IServiceRegister register)
{
//It should be in the scene hopefully
LoginDetailsSceneData loginDetails = MonoBehaviour.FindObjectOfType <LoginDetailsSceneData>();
if (loginDetails == null)
{
throw new Exception($"{nameof(loginDetails)} of type {nameof(LoginDetailsSceneData)} could not be found in the scene.");
}
register.Register(loginDetails, getFlags(), typeof(ILoginDetails));
}
/// <summary>
/// Registers the default EasyNetQ components
/// </summary>
/// <param name="serviceRegister">The register</param>
public static void RegisterDefaultServices(this IServiceRegister serviceRegister)
{
Preconditions.CheckNotNull(serviceRegister, "container");
// Note: IConnectionConfiguration gets registered when RabbitHutch.CreateBus(..) is run.
// default service registration
serviceRegister
.Register <IConnectionStringParser, ConnectionStringParser>()
.Register <ISerializer>(_ => new JsonSerializer())
.Register <IConventions, Conventions>()
.Register <IEventBus, EventBus>()
.Register <ITypeNameSerializer, DefaultTypeNameSerializer>()
.Register <ICorrelationIdGenerationStrategy, DefaultCorrelationIdGenerationStrategy>()
.Register <IMessageSerializationStrategy, DefaultMessageSerializationStrategy>()
.Register <IMessageDeliveryModeStrategy, MessageDeliveryModeStrategy>()
.Register(new AdvancedBusEventHandlers())
.Register <IProduceConsumeInterceptor, DefaultInterceptor>()
.Register <IConsumerDispatcherFactory, ConsumerDispatcherFactory>()
.Register <IExchangeDeclareStrategy, DefaultExchangeDeclareStrategy>()
.Register <IConsumerErrorStrategy, DefaultConsumerErrorStrategy>()
.Register <IErrorMessageSerializer, DefaultErrorMessageSerializer>()
.Register <IHandlerRunner, HandlerRunner>()
.Register <IInternalConsumerFactory, InternalConsumerFactory>()
.Register <IConsumerFactory, ConsumerFactory>()
.Register(c =>
{
var connectionConfiguration = c.Resolve <ConnectionConfiguration>();
return(ConnectionFactoryFactory.CreateConnectionFactory(connectionConfiguration));
})
.Register <IClientCommandDispatcher, SingleChannelClientCommandDispatcher>()
.Register <IPersistentConnection, PersistentConnection>()
.Register <IPersistentChannelFactory, PersistentChannelFactory>()
.Register <IPublishConfirmationListener, PublishConfirmationListener>()
.Register <IHandlerCollectionFactory, HandlerCollectionFactory>()
.Register <IPullingConsumerFactory, PullingConsumerFactory>()
.Register <IAdvancedBus, RabbitAdvancedBus>()
.Register <IPubSub, DefaultPubSub>()
.Register <IRpc, DefaultRpc>()
.Register <ISendReceive, DefaultSendReceive>()
.Register <IScheduler>(
x => new DeadLetterExchangeAndMessageTtlScheduler(
x.Resolve <ConnectionConfiguration>(),
x.Resolve <IAdvancedBus>(),
x.Resolve <IConventions>(),
x.Resolve <IMessageDeliveryModeStrategy>(),
x.Resolve <IExchangeDeclareStrategy>()
)
)
.Register <IBus, RabbitBus>();
}
public static IServiceRegister UseMessageHandlerPolicy(this IServiceRegister registrar, Policy policy)
{
if (registrar == null)
{
throw new ArgumentNullException(nameof(registrar));
}
if (policy == null)
{
throw new ArgumentNullException(nameof(policy));
}
registrar.Register <IHandlerRunner>(services => new PollyHandlerRunner(services.Resolve <IConsumerErrorStrategy>(), policy));
return(registrar);
}
public override void Register(IServiceRegister register)
{
#if DEBUG || DEBUGBUILD
Debug.Log(ptcLoginUrlDetails.ToString());
#endif
//create the details map
Dictionary <AuthType, LoginUrlDetails> authDetailsMap = new Dictionary <AuthType, LoginUrlDetails>()
{
{ AuthType.PTC, ptcLoginUrlDetails },
{ AuthType.Google, googleLoginUrlDetails }
};
UserAuthServiceFactory factory = new UserAuthServiceFactory(authDetailsMap);
register.Register(factory, getFlags(), typeof(IUserAuthServiceFactory));
}
public static IServiceRegister EnableMessageMetaDataBinding(this IServiceRegister registrar)
{
if (registrar == null)
{
throw new ArgumentNullException("registrar");
}
registrar.Register <IMessageSerializationStrategy>(services =>
new MetaDataMessageSerializationStrategy(
services.Resolve <ITypeNameSerializer>(),
services.Resolve <ISerializer>(),
services.Resolve <ICorrelationIdGenerationStrategy>()
)
);
return(registrar);
}
/// <summary>
/// Registers components of a <see cref="RabbitBus"/>.
/// </summary>
/// <param name="serviceRegister"/>
/// <param name="connectionConfigurationFactory">
/// A factory of <see cref="ConnectionConfiguration"/> instance.
/// </param>
/// <param name="registerServices">
/// Override default services. For example, to override the default <see cref="ISerializer"/>:
/// RabbitHutch.CreateBus("host=localhost", x => x.Register{ISerializer}(mySerializer));
/// </param>
/// <returns>
/// A new <see cref="RabbitBus"/> instance.
/// </returns>
public static void RegisterBus(IServiceRegister serviceRegister,
Func <IServiceResolver, ConnectionConfiguration> connectionConfigurationFactory,
Action <IServiceRegister> registerServices)
{
Preconditions.CheckNotNull(serviceRegister, "serviceRegister");
Preconditions.CheckNotNull(connectionConfigurationFactory, "connectionConfiguration");
Preconditions.CheckNotNull(registerServices, "registerServices");
serviceRegister.Register(c =>
{
var connectionConfiguration = connectionConfigurationFactory.Invoke(c);
connectionConfiguration.Validate();
return(connectionConfiguration);
});
serviceRegister.RegisterDefaultServices();
registerServices(serviceRegister);
}
public static IServiceRegister EnableElasticApmTracing(this IServiceRegister serviceRegister)
{
if (serviceRegister == null)
{
throw new ArgumentNullException(nameof(serviceRegister));
}
serviceRegister.Register <IAdvancedBus>(c =>
new ElasticApmAdvancedBus(c.Resolve <IConnectionFactory>(), c.Resolve <IConsumerFactory>(),
c.Resolve <IClientCommandDispatcherFactory>(), c.Resolve <IPublishConfirmationListener>(),
c.Resolve <IEventBus>(), c.Resolve <IHandlerCollectionFactory>(),
c.Resolve <IServiceResolver>(), c.Resolve <ConnectionConfiguration>(),
c.Resolve <IProduceConsumeInterceptor>(), c.Resolve <IMessageSerializationStrategy>(),
c.Resolve <IConventions>(), c.Resolve <AdvancedBusEventHandlers>(),
c.Resolve <IPersistentConnectionFactory>(), c.Resolve <ILogProvider>()));
return(serviceRegister);
}
public static void RegisterDefaultServices(this IServiceRegister container)
{
Preconditions.CheckNotNull(container, "container");
// Note: IConnectionConfiguration gets registered when RabbitHutch.CreateBus(..) is run.
// default service registration
container
.Register <IConnectionStringParser, ConnectionStringParser>()
.Register <ISerializer>(_ => new JsonSerializer())
.Register <IConventions, Conventions>()
.Register <IEventBus, EventBus>()
.Register <ITypeNameSerializer, DefaultTypeNameSerializer>()
.Register <ICorrelationIdGenerationStrategy, DefaultCorrelationIdGenerationStrategy>()
.Register <IMessageSerializationStrategy, DefaultMessageSerializationStrategy>()
.Register <IMessageDeliveryModeStrategy, MessageDeliveryModeStrategy>()
.Register <ITimeoutStrategy, TimeoutStrategy>()
.Register <IClusterHostSelectionStrategy <ConnectionFactoryInfo>, RandomClusterHostSelectionStrategy <ConnectionFactoryInfo> >()
.Register(AdvancedBusEventHandlers.Default)
.Register <IProduceConsumeInterceptor, DefaultInterceptor>()
.Register <IConsumerDispatcherFactory, ConsumerDispatcherFactory>()
.Register <IExchangeDeclareStrategy, DefaultExchangeDeclareStrategy>()
.Register <IConsumerErrorStrategy, DefaultConsumerErrorStrategy>()
.Register <IErrorMessageSerializer, DefaultErrorMessageSerializer>()
.Register <IHandlerRunner, HandlerRunner>()
.Register <IInternalConsumerFactory, InternalConsumerFactory>()
.Register <IConsumerFactory, ConsumerFactory>()
.Register <IConnectionFactory, ConnectionFactoryWrapper>()
.Register <IPersistentChannelFactory, PersistentChannelFactory>()
.Register <IPersistentConnectionFactory, PersistentConnectionFactory>()
.Register <IClientCommandDispatcherFactory, ClientCommandDispatcherFactory>()
.Register <IPublishConfirmationListener, PublishConfirmationListener>()
.Register <IHandlerCollectionFactory, HandlerCollectionFactory>()
.Register <IAdvancedBus, RabbitAdvancedBus>()
.Register <IRpc, Rpc>()
.Register <ISendReceive, SendReceive>()
.Register <IScheduler>(
x => new DeadLetterExchangeAndMessageTtlScheduler(
x.Resolve <IAdvancedBus>(), x.Resolve <IConventions>(), x.Resolve <IMessageDeliveryModeStrategy>()
)
)
.Register <IBus, RabbitBus>();
}
/// <summary>
/// Enable reporting message consumer errors to Exceptionless.
/// </summary>
/// <param name="serviceRegister">Extension instance.</param>
/// <param name="client">Optional Exceptionless client. Defaults to ExceptionlessClient.Default.</param>
/// <param name="intercept">Optional interceptor hook, allowing you to customize the exceptionless event.</param>
/// <returns>Extension instance.</returns>
/// <exception cref="ArgumentNullException">
/// Thrown if the value passed to the <paramref name="serviceRegister"/> parameter is <c>null</c>.
/// </exception>
public static IServiceRegister EnableExceptionless(this IServiceRegister serviceRegister, ExceptionlessClient client = null, Action <EventBuilder, ConsumerExecutionContext> intercept = null)
{
if (serviceRegister == null)
{
throw new ArgumentNullException(nameof(serviceRegister));
}
serviceRegister.Register <IConsumerErrorStrategy>(services => new ExceptionlessConsumerErrorStrategy(
services.Resolve <IConnectionFactory>(),
services.Resolve <ISerializer>(),
services.Resolve <IEasyNetQLogger>(),
services.Resolve <IConventions>(),
services.Resolve <ITypeNameSerializer>(),
services.Resolve <IErrorMessageSerializer>(),
client,
intercept
));
return(serviceRegister);
}
public override void Register(IServiceRegister register)
{
//Just create a new collection and register it
NetworkEntityCollection entityCollection = new NetworkEntityCollection();
IncrementalNetworkGuidFactory guidFactory = new IncrementalNetworkGuidFactory();
NetPeerCollection peerCollection = new NetPeerCollection();
ConnectionToPlayerGuidLookupService lookupService = new ConnectionToPlayerGuidLookupService();
register.Register(entityCollection, RegistrationType.SingleInstance, null);
register.Register(guidFactory, RegistrationType.SingleInstance, typeof(INetworkGuidFactory));
register.Register(peerCollection, RegistrationType.SingleInstance, typeof(IReadonlyPeerCollection));
register.Register(peerCollection, RegistrationType.SingleInstance, typeof(IPeerCollection));
register.Register(lookupService, RegistrationType.SingleInstance, typeof(IConnectionToGuidLookupService));
register.Register(lookupService, RegistrationType.SingleInstance, typeof(IConnectionToGuidRegistry));
}
public static IServiceRegister EnableExternalScheduler(this IServiceRegister serviceRegister)
{
return(serviceRegister.Register <IScheduler, ExternalScheduler.ExternalScheduler>());
}
public static void Transient <TService>(this IServiceRegister register)
{
register.Register(typeof(TService), typeof(TService), ServiceLifetime.Transient);
}
