/// <summary> /// Initializes a new instance of the <see cref="GameSystemBase" /> class. /// </summary> /// <param name="registry">The registry.</param> /// <remarks>The GameSystem is expecting the following services to be registered: <see cref="IGame" /> and <see cref="AssetManager" />.</remarks> public ScriptSystem(IServiceRegistry registry) : base(registry) { Enabled = true; Scheduler = new Scheduler(); Services.AddService(typeof(ScriptSystem), this); }
/// <summary> /// Initializes a new instance of the <see cref="DynamicEffectCompiler" /> class. /// </summary> /// <param name="services">The services.</param> /// <param name="effectName">Name of the effect.</param> /// <param name="asyncDynamicEffectCompiler">if set to <c>true</c> it can compile effect asynchronously.</param> /// <exception cref="System.ArgumentNullException">services /// or /// effectName</exception> public DynamicEffectCompiler(IServiceRegistry services, string effectName, int taskPriority = 0) { if (services == null) throw new ArgumentNullException("services"); if (effectName == null) throw new ArgumentNullException("effectName"); Services = services; this.effectName = effectName; this.taskPriority = taskPriority; EffectSystem = Services.GetSafeServiceAs<EffectSystem>(); GraphicsDevice = Services.GetSafeServiceAs<IGraphicsDeviceService>().GraphicsDevice; parameterCollections = new FastList<ParameterCollection>(); // Default behavior for fallback effect: load effect with same name but empty compiler parameters ComputeFallbackEffect = (dynamicEffectCompiler, type, name, parameters) => { ParameterCollection usedParameters; var compilerParameters = new CompilerParameters(); // We want high priority compilerParameters.TaskPriority = -1; var effect = dynamicEffectCompiler.EffectSystem.LoadEffect(effectName, compilerParameters, out usedParameters).WaitForResult(); return new ComputeFallbackEffectResult(effect, usedParameters); }; }
/// <summary> /// Initializes a new instance of the <see cref="GameSystemBase" /> class. /// </summary> /// <param name="registry">The registry.</param> /// <remarks> /// The GameSystem is expecting the following services to be registered: <see cref="IGame"/> and <see cref="IAssetManager"/>. /// </remarks> protected GameSystemBase(IServiceRegistry registry) { if (registry == null) throw new ArgumentNullException("registry"); this.registry = registry; game = (GameBase)Services.GetServiceAs<IGame>(); assetManager = Services.GetSafeServiceAs<IAssetManager>(); }
void ICompositionRoot.Compose(IServiceRegistry serviceRegistry) { CallCount++; serviceRegistry.Register<IFoo,Foo>(); serviceRegistry.RegisterFallback((type, s) => type == typeof(IBar), request => new Bar()); }
/// <summary> /// Initializes a new instance of the <see cref="GameSystem" /> class. /// </summary> /// <param name="registry">The registry.</param> public YamlManager(IServiceRegistry registry) : base(registry) { Services.AddService(this); yamlSettings = new SerializerSettings(); attributeRegistry = yamlSettings.Attributes; serializer = new Serializer(yamlSettings); }
public void Compose(IServiceRegistry serviceRegistry) { serviceRegistry.Register<ILogFactory, Log4NetLogFactory>(new PerContainerLifetime()); serviceRegistry.Register<Type, ILog>((factory, type) => factory.GetInstance<ILogFactory>().GetLogger(type)); serviceRegistry.RegisterConstructorDependency( (factory, info) => factory.GetInstance<Type, ILog>(info.Member.DeclaringType)); }
/// <summary> /// Create an new instance of AudioSystem /// </summary> /// <param name="registry">The service registry in which to register the <see cref="AudioSystem"/> services</param> public AudioSystem(IServiceRegistry registry) : base(registry) { Enabled = true; registry.AddService(typeof(AudioSystem), this); }
private static void addServices(IServiceRegistry registry) { var pipeline = new AssetPipeline(); registry.SetServiceIfNone<IAssetPipeline>(pipeline); registry.SetServiceIfNone<IAssetFileRegistration>(pipeline); registry.SetServiceIfNone(new AssetGraph()); registry.SetServiceIfNone(new AssetLogsCache()); registry.SetServiceIfNone<IAssetTagWriter, AssetTagWriter>(); registry.SetServiceIfNone<ICombinationDeterminationService, CombinationDeterminationService>(); registry.SetServiceIfNone<IAssetCombinationCache, AssetCombinationCache>(); registry.SetServiceIfNone<IAssetDependencyFinder, AssetDependencyFinderCache>(); registry.SetServiceIfNone<IAssetTagPlanner, AssetTagPlanner>(); registry.SetServiceIfNone<IAssetTagBuilder, AssetTagBuilder>(); registry.SetServiceIfNone<IAssetRequirements, AssetRequirements>(); registry.SetServiceIfNone<IMissingAssetHandler, TraceOnlyMissingAssetHandler>(); registry.SetServiceIfNone<IAssetTagPlanCache, AssetTagPlanCache>(); registry.SetServiceIfNone<ITransformerPolicyLibrary, TransformerPolicyLibrary>(); registry.SetServiceIfNone<IContentPlanner, ContentPlanner>(); registry.SetServiceIfNone<IContentPlanCache, ContentPlanCache>(); registry.SetServiceIfNone<IContentPipeline, ContentPipeline>(); registry.SetServiceIfNone<IContentWriter, ContentWriter>(); registry.SetServiceIfNone<IETagGenerator<IEnumerable<AssetFile>>, AssetFileEtagGenerator>(); }
/// <summary> /// Initializes a new instance of the <see cref="GameSystemBase" /> class. /// </summary> /// <param name="registry">The registry.</param> /// <remarks>The GameSystem is expecting the following services to be registered: <see cref="IGame" /> and <see cref="IAssetManager" />.</remarks> public SceneSystem(IServiceRegistry registry) : base(registry) { registry.AddService(typeof(SceneSystem), this); Enabled = true; Visible = true; }
public void Compose(IServiceRegistry serviceRegistry) { // Register the app repository serviceRegistry.Register<IAppRepository, AppRepository>(); // Register the app resource types serviceRegistry.Register<IAppSprite, AppSprite>(); serviceRegistry.Register<IAppSound, AppSound>(); serviceRegistry.Register<IAppBackground, AppBackground>(); serviceRegistry.Register<IAppPath, AppPath>(); serviceRegistry.Register<IAppScript, AppScript>(); serviceRegistry.Register<IAppDataFile, AppDataFile>(); serviceRegistry.Register<IAppFont, AppFont>(); serviceRegistry.Register<IAppTimeline, AppTimeline>(); serviceRegistry.Register<IAppObject, AppObject>(); serviceRegistry.Register<IAppRoom, AppRoom>(); // Register teh resource managers serviceRegistry.Register<IIndexedResourceManager<IAppSprite>, IndexedResourceManager<IAppSprite>>(); serviceRegistry.Register<IIndexedResourceManager<IAppSound>, IndexedResourceManager<IAppSound>>(); serviceRegistry.Register<IIndexedResourceManager<IAppBackground>, IndexedResourceManager<IAppBackground>>(); serviceRegistry.Register<IIndexedResourceManager<IAppPath>, IndexedResourceManager<IAppPath>>(); serviceRegistry.Register<IIndexedResourceManager<IAppScript>, IndexedResourceManager<IAppScript>>(); serviceRegistry.Register<IIndexedResourceManager<IAppDataFile>, IndexedResourceManager<IAppDataFile>>(); serviceRegistry.Register<IIndexedResourceManager<IAppFont>, IndexedResourceManager<IAppFont>>(); serviceRegistry.Register<IIndexedResourceManager<IAppTimeline>, IndexedResourceManager<IAppTimeline>>(); serviceRegistry.Register<IIndexedResourceManager<IAppObject>, IndexedResourceManager<IAppObject>>(); serviceRegistry.Register<IIndexedResourceManager<IAppRoom>, IndexedResourceManager<IAppRoom>>(); }
private void configureServices(IServiceRegistry services) { var configuration = new TemplateServiceConfiguration {BaseTemplateType = typeof (FubuRazorView)}; services.ReplaceService<ITemplateRegistry<IRazorTemplate>>(_templateRegistry); services.ReplaceService<IFubuTemplateService>(new FubuTemplateService(_templateRegistry, new TemplateService(configuration), new FileSystem())); services.ReplaceService<ITemplateServiceConfiguration>(configuration); services.ReplaceService<IParsingRegistrations<IRazorTemplate>>(_parsings); services.SetServiceIfNone<ITemplateDirectoryProvider<IRazorTemplate>, TemplateDirectoryProvider<IRazorTemplate>>(); services.SetServiceIfNone<ISharedPathBuilder>(new SharedPathBuilder()); var graph = new SharingGraph(); services.SetServiceIfNone(graph); services.SetServiceIfNone<ISharingGraph>(graph); services.FillType<IActivator, RazorActivator>(); services.FillType<ISharedTemplateLocator<IRazorTemplate>, SharedTemplateLocator<IRazorTemplate>>(); services.FillType<ISharingAttacher<IRazorTemplate>, MasterAttacher<IRazorTemplate>>(); services.FillType<ITemplateSelector<IRazorTemplate>, RazorTemplateSelector>(); services.FillType<IActivator, SharingAttacherActivator<IRazorTemplate>>(); services.FillType<IRenderStrategy, AjaxRenderStrategy>(); services.FillType<IRenderStrategy, DefaultRenderStrategy>(); services.SetServiceIfNone<IViewModifierService<IFubuRazorView>, ViewModifierService<IFubuRazorView>>(); services.FillType<IViewModifier<IFubuRazorView>, LayoutActivation>(); services.FillType<IViewModifier<IFubuRazorView>, PartialRendering>(); services.FillType<IViewModifier<IFubuRazorView>, FubuPartialRendering>(); }
/// <summary> /// Creates a new instance of <see cref="SpriteAnimationSystem"/> and register it in the services. /// </summary> /// <param name="registry"></param> public SpriteAnimationSystem(IServiceRegistry registry) : base(registry) { registry.AddService(typeof(SpriteAnimationSystem), this); DefaultFramesPerSecond = 30; }
/// <summary> /// Initializes a new instance of the <see cref="GraphicsDeviceServiceLocal"/> class. /// </summary> /// <param name="registry">The registry.</param> /// <param name="graphicsDevice">The graphics device.</param> public GraphicsDeviceServiceLocal(IServiceRegistry registry, GraphicsDevice graphicsDevice) { if (registry != null) { registry.AddService(typeof(IGraphicsDeviceService), this); } GraphicsDevice = graphicsDevice; }
private static void Register(this Container container, IServiceRegistry registry) { container.Register(registry.TypeRegistrations); container.Register(registry.CollectionTypeRegistrations); container.Register(registry.InstanceRegistrations); }
public Bullet2PhysicsSystem(IServiceRegistry registry) : base(registry) { UpdateOrder = -1000; //make sure physics runs before everything registry.AddService(typeof(IPhysicsSystem), this); Enabled = true; //enabled by default }
private void ConfigureContainer(IServiceRegistry registry) { registry.RegisterInstance<IFodyLogger>(this); registry.RegisterInstance<ModuleWeaver>(this); registry.RegisterInstance<ModuleDefinition>(this.ModuleDefinition); registry.RegisterAssembly(GetType().Assembly , (serviceType, implementingType) => typeof(IModuleProcessor).IsAssignableFrom(implementingType)); }
private static InputManager NewInputManagerWinforms(IServiceRegistry registry) { #if SILICONSTUDIO_PLATFORM_WINDOWS_DESKTOP && SILICONSTUDIO_XENKO_UI_WINFORMS return new InputManagerWinforms(registry); #else return null; #endif }
private static InputManager NewInputManagerWpf(IServiceRegistry registry) { #if SILICONSTUDIO_PLATFORM_WINDOWS_DESKTOP && SILICONSTUDIO_XENKO_UI_WPF && !SILICONSTUDIO_XENKO_GRAPHICS_API_OPENGL return new InputManagerWpf(registry); #else return null; #endif }
public void Compose(IServiceRegistry serviceRegistry) { serviceRegistry.RegisterFrom<CommonCompositionRoot>(); serviceRegistry.RegisterFrom<ThreeProducibleUnitsCompositionRoot>(); serviceRegistry.Register<IWorldAge, LinearWorldAge>(new PerContainerLifetime()); serviceRegistry.Register<IWinnerStrategy, RedWinsIn3000Bce>(new PerContainerLifetime()); }
public void Compose(IServiceRegistry serviceRegistry) { serviceRegistry.Register<IAspectSerializer, AspectDataContractSerializer>(typeof(AspectDataContractSerializer).FullName, new PerContainerLifetime()); serviceRegistry.Register<IAspectSerializer, AspectXmlSerializer>(typeof(AspectXmlSerializer).FullName, new PerContainerLifetime()); serviceRegistry.Register<IAspectSerializerFactory, AspectSerializerFactory>(new PerContainerLifetime()); }
public GameFontSystem(IServiceRegistry registry) : base(registry) { Visible = true; FontSystem = new FontSystem(); Services.AddService(typeof(FontSystem), FontSystem); Services.AddService(typeof(IFontFactory), FontSystem); }
public void Load(IServiceRegistry registry) { if (!registry.IsRegistered(typeof (IEventAggregator))) { registry.Register<IEventAggregator, EventAggregator>(true); } registry.Register<IMessageBus, PrismMessageBus>(true); }
/// <summary> /// Create an new instance of AudioSystem /// </summary> /// <param name="registry">The service registry in which to register the <see cref="AudioSystem"/> services</param> public AudioSystem(IServiceRegistry registry) : base(registry) { Enabled = true; AudioEngine = AudioEngineFactory.NewAudioEngine(); registry.AddService(typeof(AudioSystem), this); }
public void Compose(IServiceRegistry serviceRegistry) { serviceRegistry.RegisterFrom<CommonCompositionRoot>(); serviceRegistry.RegisterFrom<FourProducibleUnitsCompositionRoot>(); serviceRegistry.Register<IWorldAge, DeceleratingWorldAge>(new PerContainerLifetime()); serviceRegistry.Register<IWinnerStrategy, CityConquerorWins>(new PerContainerLifetime()); }
private static void Add(this IProfileRegistry registry, IServiceRegistry serviceRegistry) { registry.Add(serviceRegistry.TypeRegistrations); registry.Add(serviceRegistry.CollectionTypeRegistrations); registry.Add(serviceRegistry.InstanceRegistrations); }
public DebugConsoleSystem(IServiceRegistry registry) : base(registry) { registry.AddService(typeof(DebugConsoleSystem), this); Visible = true; DrawOrder = 0xffffff; UpdateOrder = -100100; //before script }
public void Compose(IServiceRegistry serviceRegistry) { serviceRegistry.RegisterAssembly("DrawPub*.dll"); serviceRegistry.Register<IInterceptor, LogInterceptor>("LogInterceptor"); serviceRegistry.Intercept(sr => sr.ServiceType == typeof(IUserAppplicationService), DefineProxyType); serviceRegistry.Intercept(sr => sr.ServiceType == typeof(IUserRepository), DefineProxyType); serviceRegistry.Intercept(sr => sr.ServiceType == typeof(IConnectionProvider), DefineProxyType); }
public void Compose(IServiceRegistry serviceRegistry) { var players = new[] { new Player("Red"), new Player("Blue") }; serviceRegistry.Register(_ => players, new PerContainerLifetime()); serviceRegistry.Register<RoundRobinTurns>(new PerContainerLifetime()); serviceRegistry.Register<ITurnTaking>(c => c.GetInstance<RoundRobinTurns>()); serviceRegistry.Register<INotifyBeginningNextRound>(c => c.GetInstance<RoundRobinTurns>()); }
public void Compose(IServiceRegistry serviceRegistry) { serviceRegistry.Register<IFileParserFactory, FileParserFactory>(new PerContainerLifetime()); serviceRegistry.Register<FIleParserManagerFactory>(); serviceRegistry.Register<IFileParserManager>((serviceFactory) => new LoggingFileParserManager(serviceFactory.GetInstance<FIleParserManagerFactory>().Create())); serviceRegistry.Register<ICharacteristicBuilder, CharacteristicBuilder>(new PerContainerLifetime()); serviceRegistry.Register<ICharacteristicManagerFactory, CharacteristicManagerFactory>(); serviceRegistry.Register<ISignalProcessorServiceFactory, SignalProcessorServiceFactory>(new PerRequestLifeTime()); }
public void Scan(Assembly assembly, IServiceRegistry serviceRegistry, Func<LightInject.ILifetime> lifetimeFactory, Func<Type, Type, bool> shouldRegister) { var serviceTypes = namedTypeExtractor.Execute(assembly); foreach (var type in serviceTypes) { foreach (NamedAttribute attr in type.GetCustomAttributes(typeof(NamedAttribute), false)) { Type serviceType = attr.ServiceType; if (serviceType == null) { var interfaces = type.GetInterfaces(); if (interfaces.Length != 1) { throw new ArgumentException("As service type not specified, a unique interface is required to be implemented or inherited by the type, or a base class is required to be inherited by the type, please supply the parameter value explicitly.", "ServiceType"); } serviceType = interfaces[0]; } LightInject.ILifetime lifetime; if (attr.LifetimeType != null) { if (!typeof(ILifetime).IsAssignableFrom(attr.LifetimeType)) { throw new ArgumentException("Type is not an implementation of the ILifetime interface.", "LifetimeType"); } if (attr.LifetimeType == typeof(PerContainerLifetime)) { lifetime = new LightInject.PerContainerLifetime(); } else if (attr.LifetimeType == typeof(PerLookupLifetime)) { lifetime = null; } else { lifetime = new AdapterLifetime((ILifetime)Activator.CreateInstance(attr.LifetimeType)); } } else { lifetime = new LightInject.PerContainerLifetime(); } if (attr.ServiceName == null) { serviceRegistry.Register(serviceType, type, lifetime); } else { serviceRegistry.Register(serviceType, type, attr.ServiceName, lifetime); } } } }
/// <summary> /// Registers a scoped service of type <typeparamref name="TService"/> as a concrete service. /// </summary> /// <param name="serviceRegistry">The target <see cref="IServiceRegistry"/>.</param> /// <typeparam name="TService">The type of service to register.</typeparam> /// <returns>The <see cref="IServiceRegistry"/>, for chaining calls.</returns> public static IServiceRegistry RegisterScoped <TService>(this IServiceRegistry serviceRegistry) => serviceRegistry.Register <TService>(new PerScopeLifetime());
/// <summary> /// Registers a singleton service of type <typeparamref name="TService"/> using a factory function. /// </summary> /// <param name="serviceRegistry">The target <see cref="IServiceRegistry"/>.</param> /// <param name="factory">The factory function used to create the service instance.</param> /// <param name="serviceName">The name of the service to register.</param> /// <typeparam name="TService">The type of service to register.</typeparam> /// <returns>The <see cref="IServiceRegistry"/>, for chaining calls.</returns> public static IServiceRegistry RegisterSingleton <TService>(this IServiceRegistry serviceRegistry, Func <IServiceFactory, TService> factory, string serviceName) => serviceRegistry.Register <TService>(factory, serviceName, new PerContainerLifetime());
public LoadWallPostLookupsAction(IServiceRegistry serviceRegistry) { Guard.ArgumentNotNull(serviceRegistry, "serviceRegistry"); this.serviceRegistry = serviceRegistry; }
/// <summary> /// Registers all <see cref="ApiController"/> implementations found in this assembly. /// </summary> /// <param name="serviceRegistry">The target <see cref="IServiceRegistry"/>.</param> public static void RegisterApiControllers(this IServiceRegistry serviceRegistry) { RegisterApiControllers(serviceRegistry, Assembly.GetCallingAssembly()); }
protected GamePlatform(Game game) { this.game = game; Services = game.Services; Services.AddService(typeof(IGraphicsDeviceFactory), this); }
private void RegisterGlobeServices(IServiceRegistry serviceRegistry) { serviceRegistry.Register <IWorldGenerator, WorldGenerator>(); }
/// <summary> /// Registers the <paramref name="serviceType"/> with a given <paramref name="lifetime"/> using the non-generic <paramref name="factory"/> to resolve the instance. /// </summary> /// <param name="serviceRegistry">The target <see cref="IServiceRegistry"/>.</param> /// <param name="serviceType">The type of service to register.</param> /// <param name="factory">The factory used to resolve the instance.</param> /// <param name="lifetime">The <see cref="ILifetime"/> used to control the lifetime of the service.</param> /// <returns>The <see cref="IServiceRegistry"/>, for chaining calls.</returns> public static IServiceRegistry Register(this IServiceRegistry serviceRegistry, Type serviceType, Func <IServiceFactory, object> factory, ILifetime lifetime) => Register(serviceRegistry, serviceType, factory, string.Empty, lifetime);
/// <summary> /// Registers a transient <paramref name="serviceType"/> using the non-generic <paramref name="factory"/> to resolve the instance. /// </summary> /// <param name="serviceRegistry">The target <see cref="IServiceRegistry"/>.</param> /// <param name="serviceType">The type of service to register.</param> /// <param name="factory">The factory used to resolve the instance.</param> /// <param name="serviceName">The name the service to register.</param> /// <returns>The <see cref="IServiceRegistry"/>, for chaining calls.</returns> public static IServiceRegistry RegisterTransient(this IServiceRegistry serviceRegistry, Type serviceType, Func <IServiceFactory, object> factory, string serviceName) { return(serviceRegistry.Register(serviceType, factory, serviceName)); }
public void RegisterServices(IServiceRegistry serviceRegistry) { RegisterSchemeService(serviceRegistry); RegisterAuxServices(serviceRegistry); RegisterGlobeServices(serviceRegistry); }
/// <summary> /// Registers a singleton service of type <typeparamref name="TService"/> with an implementing type of <typeparamref name="TImplementation"/>. /// </summary> /// <param name="serviceRegistry">The target <see cref="IServiceRegistry"/>.</param> /// <param name="serviceName">The name of the service to register.</param> /// <typeparam name="TService">The type of service to register.</typeparam> /// <typeparam name="TImplementation">The type implementing the service type.</typeparam> /// <returns>The <see cref="IServiceRegistry"/>, for chaining calls.</returns> public static IServiceRegistry RegisterSingleton <TService, TImplementation>(this IServiceRegistry serviceRegistry, string serviceName) where TImplementation : TService => serviceRegistry.Register <TService, TImplementation>(serviceName, new PerContainerLifetime());
/// <summary> /// Registers a singleton service of type <typeparamref name="TService"/> as a concrete service. /// </summary> /// <param name="serviceRegistry">The target <see cref="IServiceRegistry"/>.</param> /// <typeparam name="TService">The type of service to register.</typeparam> /// <returns>The <see cref="IServiceRegistry"/>, for chaining calls.</returns> public static IServiceRegistry RegisterSingleton <TService>(this IServiceRegistry serviceRegistry) => serviceRegistry.Register <TService>(new PerContainerLifetime());
/// <summary> /// Registers a scoped service of type <typeparamref name="TService"/> with an implementing type of <typeparamref name="TImplementation"/>. /// </summary> /// <param name="serviceRegistry">The target <see cref="IServiceRegistry"/>.</param> /// <param name="serviceName">The name of the service to register.</param> /// <typeparam name="TService">The type of service to register.</typeparam> /// <typeparam name="TImplementation">The type implementing the service type.</typeparam> /// <returns>The <see cref="IServiceRegistry"/>, for chaining calls.</returns> public static IServiceRegistry RegisterScoped <TService, TImplementation>(this IServiceRegistry serviceRegistry, string serviceName) where TImplementation : TService => serviceRegistry.Register <TService, TImplementation>(serviceName, new PerScopeLifetime());
/// <summary> /// Registers the <paramref name="serviceType"/> using the non-generic <paramref name="factory"/> to resolve the instance. /// </summary> /// <param name="serviceRegistry">The target <see cref="IServiceRegistry"/>.</param> /// <param name="serviceType">The type of service to register.</param> /// <param name="factory">The factory used to resolve the instance.</param> /// <returns>The <see cref="IServiceRegistry"/>, for chaining calls.</returns> public static IServiceRegistry Register(this IServiceRegistry serviceRegistry, Type serviceType, Func <IServiceFactory, object> factory) => Register(serviceRegistry, serviceType, factory, string.Empty, null);
/// <summary> /// Registers a singleton service of type <paramref name="serviceType"/> as a concrete service type. /// </summary> /// <param name="serviceRegistry">The target <see cref="IServiceRegistry"/>.</param> /// <param name="serviceType">The type of service to register.</param> /// <returns>The <see cref="IServiceRegistry"/>, for chaining calls.</returns> public static IServiceRegistry RegisterSingleton(this IServiceRegistry serviceRegistry, Type serviceType) => serviceRegistry.Register(serviceType, new PerContainerLifetime());
public void SetUp() { theServices = new FubuRegistry().BuildGraph().Services; }
/// <summary> /// Sets the registry instance ServiceManager works with /// </summary> /// <param name="registry"></param> public static void SetRegistry(IServiceRegistry registry) { Registry = registry ?? throw new ArgumentNullException(nameof(registry)); }
/// <summary> /// Подготовка дополнительных сервисов /// </summary> private void RegisterAuxServices(IServiceRegistry container) { var dice = new LinearDice(); container.Register <IDice>(factory => dice, LightInjectWrapper.CreateSingleton()); }
/// <summary> /// Installs the specified service registry. /// </summary> /// <param name="serviceRegistry">The service registry.</param> public void Install(IServiceRegistry serviceRegistry) { serviceRegistry.RegisterAssembly(typeof(BaseApplication <,>).Assembly, (s, _) => s.GetInterfaces().Any(i => i.IsGenericType && i.GetGenericTypeDefinition() == typeof(IBaseApplication <,>))); }
/// <summary> /// Registers a scoped <paramref name="serviceType"/> using the non-generic <paramref name="factory"/> to resolve the instance. /// </summary> /// <param name="serviceRegistry">The target <see cref="IServiceRegistry"/>.</param> /// <param name="serviceType">The type of service to register.</param> /// <param name="factory">The factory used to resolve the instance.</param> /// <param name="serviceName">The name the service to register.</param> /// <returns>The <see cref="IServiceRegistry"/>, for chaining calls.</returns> public static IServiceRegistry RegisterScoped(this IServiceRegistry serviceRegistry, Type serviceType, Func <IServiceFactory, object> factory, string serviceName) { return(serviceRegistry.Register(serviceType, factory, serviceName, new PerScopeLifetime())); }
public DefaultSliderRenderer(IServiceRegistry services) : base(services) { }
public DefaultTextBlockRenderer(IServiceRegistry services) : base(services) { }
public InputManager(IServiceRegistry registry) : base(registry) { HasKeyboard = true; HasMouse = false; HasPointer = true; }
/// <summary> /// Resets ServiceManager to its initial state just like right /// after the framework invokes its static constructor /// </summary> public static void Reset() { Registry = new ServiceRegistry(); }
public SceneEditorView(IServiceRegistry services) : base(services) { }
public ResumeManager(IServiceRegistry services) { GraphicsDevice = services.GetServiceAs <IGraphicsDeviceService>().GraphicsDevice; }
/// <summary> /// Initializes a new instance of the <see cref="GameWindowRenderer" /> class. /// </summary> /// <param name="registry">The registry.</param> /// <param name="gameContext">The window context.</param> public GameWindowRenderer(IServiceRegistry registry, GameContext gameContext = null) : base(registry) { GameContext = gameContext ?? new GameContext(); }
public HierarchyView(IServiceRegistry service) : base(service) { }
public CameraScript(IServiceRegistry registry) : base(registry) { Speed = 10.0f; MoveSpeed = 2.0f; }
/// <summary> /// Registers a scoped service of type <paramref name="serviceType"/> as a concrete service type. /// </summary> /// <param name="serviceRegistry">The target <see cref="IServiceRegistry"/>.</param> /// <param name="serviceType">The type of service to register.</param> /// <returns>The <see cref="IServiceRegistry"/>, for chaining calls.</returns> public static IServiceRegistry RegisterScoped(this IServiceRegistry serviceRegistry, Type serviceType) => serviceRegistry.Register(serviceType, new PerScopeLifetime());
/// <summary> /// Registers a singleton service of type <paramref name="serviceType"/> with an implementing type of <paramref name="implementingType"/>. /// </summary> /// <param name="serviceRegistry">The target <see cref="IServiceRegistry"/>.</param> /// <param name="serviceType">The type of service to register.</param> /// <param name="implementingType">The type implementing the service type.</param> /// <param name="serviceName">The name of the service to register.</param> /// <returns>The <see cref="IServiceRegistry"/>, for chaining calls.</returns> public static IServiceRegistry RegisterSingleton(this IServiceRegistry serviceRegistry, Type serviceType, Type implementingType, string serviceName) => serviceRegistry.Register(serviceType, implementingType, serviceName, new PerContainerLifetime());