static CloudInfrastructureProviders CloudInfrastructureProviders(IComponentContext c) { return new CloudInfrastructureProviders( c.Resolve<CloudStorageProviders>(), c.ResolveOptional<IProvisioningProvider>(), c.ResolveOptional<ILog>()); }
static RuntimeProviders RuntimeProviders(IComponentContext c) { return CloudStorage .ForAzureAccount(c.Resolve<CloudStorageAccount>()) .WithObserver(c.Resolve<ICloudStorageObserver>()) .WithRuntimeFinalizer(c.ResolveOptional<IRuntimeFinalizer>()) .BuildRuntimeProviders(c.ResolveOptional<ILog>()); }
static IQueueStorageProvider QueueStorageProvider(IComponentContext c) { return CloudStorage .ForAzureAccount(c.Resolve<CloudStorageAccount>()) .WithDataSerializer(c.Resolve<IDataSerializer>()) .WithObserver(c.Resolve<ICloudStorageObserver>()) .WithRuntimeFinalizer(c.ResolveOptional<IRuntimeFinalizer>()) .BuildQueueStorage(); }
protected virtual TransactionalBus BuildMessageBus(IComponentContext c) { var bus = new MessageBus( c.Resolve <ITransportMessages>(), c.Resolve <IStoreSubscriptions>(), this.endpoints, c.ResolveOptional <IMessageContext>() ?? c.Resolve <NullMessageContext>(), c.Resolve <MessageBuilder>(), c.Resolve <IDiscoverMessageTypes>()); return(new TransactionalBus(c.Resolve <IHandleUnitOfWork>(), bus)); }
protected virtual TransactionalBus BuildMessageBus(IComponentContext c) { var bus = new MessageBus( c.Resolve<ITransportMessages>(), c.Resolve<IStoreSubscriptions>(), this.endpoints, c.ResolveOptional<IMessageContext>() ?? c.Resolve<NullMessageContext>(), c.Resolve<MessageBuilder>(), c.Resolve<IDiscoverMessageTypes>()); return new TransactionalBus(c.Resolve<IHandleUnitOfWork>(), bus); }
public IEnumerable <string> Resolve(string moduleName, string fromModule) { var configuration = _componentContext.ResolveOptional <IRequireConfiguration>(); if (configuration == null) { return(Enumerable.Empty <string>()); } var candidates = ResolveCandidates(configuration, moduleName); return(candidates.Select(c => ApplyMaps(configuration, fromModule, c))); }
public virtual object ResolveOptional(Type type, string name = null) { if (string.IsNullOrEmpty(name)) { return(context.ResolveOptional(type)); } else { object obj = null; context.TryResolveNamed(name, type, out obj); return(obj); } }
public static ConsumerConsumeContext <TConsumer, TMessage> GetConsumer <TConsumer, TMessage>(this IComponentContext componentContext, ConsumeContext <TMessage> consumeContext) where TConsumer : class where TMessage : class { var consumer = componentContext.ResolveOptional <TConsumer>(); if (consumer == null) { throw new ConsumerException($"Unable to resolve consumer type '{TypeMetadataCache<TConsumer>.ShortName}'."); } return(consumeContext.PushConsumer(consumer)); }
private ContextConnection LookupContextConnection(IComponentContext componentContext, Type contextType) { var contextSettings = componentContext.ResolveOptional <ContextSettings>() ?? new ContextSettings(); ContextConnection connection = contextSettings.Connections? .FirstOrDefault(c => c.ContextName == contextType.Name); if (connection == null) { throw new InvalidOperationException( $"Context connection could not be found for the following entity context type: {contextType}."); } return(connection); }
public object Create(object request, ISpecimenContext context) { object result = new NoSpecimen(); if (request is Type) { var type = request as Type; if (!type.IsAssignableTo <IEnumerable>() && _context.IsRegistered(type)) { result = _context.ResolveOptional(type) ?? result; } } return(result); }
public static void LoadFrom(this IReceiveEndpointConfigurator configurator, IComponentContext context, string name = "message", Action <ContainerBuilder, ConsumeContext> configureScope = null) { var registration = context.ResolveOptional <IRegistration>(); if (registration != null) { registration.ConfigureConsumers(configurator); registration.ConfigureSagas(configurator); return; } LoadFrom(configurator, context.Resolve <ILifetimeScope>(), name, configureScope); }
private object GetHandler(IMessage message) { object handler = null; var messageType = message.GetType(); if (message is IQueryBase) { var handlerType = typeof(IQueryHandler <,>).MakeGenericType(messageType, new QueryInfo(messageType).ResultType); handler = _serviceLocator.ResolveOptional(handlerType); } if (message is ICommand) { var handlerType = typeof(ICommandHandler <>).MakeGenericType(messageType); handler = _serviceLocator.ResolveOptional(handlerType); } if (handler == null) { throw new Exception($"Handler for message: {messageType.FullName} not found."); } return(handler); }
object[] GetParameters <T>(IComponentContext context) where T : class { ParameterInfo[] parameters = _cache.GetOrAdd(typeof(T), t => GetParameterInfos(t, context)); var result = new object[parameters.Length]; for (var i = 0; i < parameters.Length; i++) { var parameter = parameters[i]; result[i] = parameter.IsOptional ? context.ResolveOptional(parameter.ParameterType) ?? parameter.DefaultValue : context.Resolve(parameter.ParameterType); } return(result); }
public RouteAction Handle(ICall call) { var property = call.GetMethodInfo().GetPropertyFromGetterCallOrNull(); if (property is null) { return(RouteAction.Continue()); } var service = _context.ResolveOptional(call.GetReturnType()); if (service is null) { return(RouteAction.Continue()); } return(RouteAction.Return(service)); }
public async Task <TResult> DispatchInternal <TMessage, TResult>(TMessage command) where TMessage : IMessage <TResult> { var validator = _context.ResolveOptional <IValidator <TMessage, TResult> >(); var handler = _context.Resolve <IMessageHandler <TMessage, TResult> >(); if (validator == null) { return(await handler.Handle(command)); } var validationResult = await validator.Validate(command); if (validationResult != string.Empty) { Console.WriteLine(string.Format("Validation for message {0} did not pass. Message: {1}", typeof(TMessage), validationResult)); } return(await handler.Handle(command)); }
public override IValidator CreateInstance(Type validatorType) { return((IValidator)_componentContext.ResolveOptional(validatorType)); }
public override T ResolveOptional <T>() { return(componentContext.ResolveOptional <T>()); }
protected SchedulerTaskScriptDependencies ResolveScriptDependency(ISchedulerTaskScript script, IComponentContext context) { if (script.DependencyClassType == null || script.DependencyClassType == typeof(void)) { //TODO: return some default dependency return null; } var result = context.ResolveOptional(script.DependencyClassType) as SchedulerTaskScriptDependencies; //creating instance manually if (result == null) { result = Activator.CreateInstance(script.DependencyClassType) as SchedulerTaskScriptDependencies; if (result == null) throw new Exception("Script Dependency can not be resolved. Check the dependency type"); context.InjectProperties(result); } if(result==null) throw new Exception("Script Dependency can not be resolved"); return result; }
public T Resolve <T>() where T : class => _context.ResolveOptional <T>();
public static object ResolveOptional(this IComponentContext context, Type serviceType) { return(context.ResolveOptional(serviceType, NoParameters)); }
public override void InitializePhysics(bool force, IComponentContext engineRegistrations) { if (force || !initialized) { var cache = engineRegistrations.Resolve<IResourceCache<Texture2D>>(); var world = engineRegistrations.Resolve<PhysicsManager>().World; engine = engineRegistrations.ResolveOptional<EngineGame>(); Physics = BodyFactory.CreateBody(world, Position, this); if (engine != null && engine.GamepadEnabled) { ACTION_POPUP = InputManager.Instance.GamepadTextures[InputManager.ButtonActions.Interact]; } float spriteWidthMeters = PhysicsConstants.PixelsToMeters(Width); float spriteHeightMeters = PhysicsConstants.PixelsToMeters(Height); var rect = FixtureFactory.AttachRectangle( spriteWidthMeters, PhysicsConstants.PixelsToMeters(10), 1.4f, Vector2.Zero, Physics); Physics.BodyType = BodyType.Static; Physics.IgnoreGravity = true; Physics.IsSensor = false; Physics.RegisterOnCollidedListener<UserControlledCharacter>(OnCollidedWith); Physics.RegisterOnSeparatedListener<UserControlledCharacter>(OnSeparation); popupTrigger = new ItemPopup( ACTION_POPUP, new Vector2(Physics.Position.X, Physics.Position.Y - PhysicsConstants.PixelsToMeters(100)), cache); initialized = true; } base.InitializePhysics(false, engineRegistrations); }
public virtual void InitializePhysics(bool force, IComponentContext engineRegistrations) { TextureCache = engineRegistrations.Resolve<IResourceCache<Texture2D>>(); Engine = engineRegistrations.ResolveOptional<EngineGame>(); }
/// <summary> /// Retrieve a service from the context, or null if the service is not /// registered. /// </summary> /// <param name="context">The context from which to resolve the service.</param> /// <param name="parameters">Parameters for the service.</param> /// <typeparam name="TService">The service to resolve.</typeparam> /// <returns> /// The component instance that provides the service, or null. /// </returns> /// <exception cref="DependencyResolutionException"/> public static TService ResolveOptional <TService>(this IComponentContext context, params Parameter[] parameters) where TService : class { return(context.ResolveOptional <TService>((IEnumerable <Parameter>)parameters)); }
public object CreateInstance(Type type) { return(_container.ResolveOptional(type) ?? Activator.CreateInstance(type)); }
protected virtual NullMessageContext BuildNullMessageContext(IComponentContext c) { return new NullMessageContext(c.ResolveOptional<IReceiveFromEndpoints>().EndpointAddress); }
public override IValidator CreateInstance(Type validatorType) { // NOTE: componentContext.Resolve would error if the type wasn't registered (e.g. a dto) return(_componentContext.ResolveOptional(validatorType) as IValidator); }
/// <inheritdoc /> public object Resolve(Type serviceType) => _container.ResolveOptional(serviceType);
public static TService ResolveOptional <TService>(this IComponentContext context) where TService : class { return(context.ResolveOptional <TService>(NoParameters)); }
public override void InitializePhysics(bool force, IComponentContext engineRegistrations) { if (force || !initialized) { var world = engineRegistrations.Resolve<PhysicsManager>().World; levelManager = engineRegistrations.Resolve<LevelManager>(); engineGame = engineRegistrations.ResolveOptional<EngineGame>(); Physics = BodyFactory.CreateRectangle( world, PhysicsConstants.PixelsToMeters(Width), PhysicsConstants.PixelsToMeters(Height), 1, Position, this); Physics.BodyType = BodyType.Static; Physics.IsSensor = true; _geom = Physics.FixtureList; RegisterCollisions(); initialized = true; } base.InitializePhysics(false, engineRegistrations); }
protected virtual NullMessageContext BuildNullMessageContext(IComponentContext c) { return(new NullMessageContext(c.ResolveOptional <IReceiveFromEndpoints>().EndpointAddress)); }
protected virtual IClock ResolveClock(IComponentContext context) { return(context.ResolveOptional <IClock>() ?? SystemClock.Instance); }
/// <summary> /// Retrieve a service from the context, or null if the service is not /// registered. /// </summary> /// <param name="context">The context from which to resolve the service.</param> /// <param name="parameters">Parameters for the service.</param> /// <param name="serviceType">The type of the service.</param> /// <returns> /// The component instance that provides the service, or null. /// </returns> /// <exception cref="DependencyResolutionException"/> public static object ResolveOptional(this IComponentContext context, Type serviceType, params Parameter[] parameters) { return(context.ResolveOptional(serviceType, (IEnumerable <Parameter>)parameters)); }
public override IValidator CreateInstance(Type validatorType) { return(_context.ResolveOptional(validatorType) as IValidator); }
public override void InitializePhysics(bool force, IComponentContext engineRegistrations) { if (force || !initialized) { var cache = engineRegistrations.Resolve<IResourceCache<Texture2D>>(); var texture = cache.GetResource(TextureName); var world = engineRegistrations.Resolve<PhysicsManager>().World; game = engineRegistrations.ResolveOptional<EngineGame>(); if (game != null && game.GamepadEnabled) { ACTION_POPUP = InputManager.Instance.GamepadTextures[InputManager.ButtonActions.Pickup]; } //Width = texture.Width; //Height = texture.Height; Physics = BodyFactory.CreateRectangle( world, PhysicsConstants.PixelsToMeters(Width), PhysicsConstants.PixelsToMeters(Height), 1, Position); Physics.FixedRotation = true; Physics.BodyType = BodyType.Static; Physics.UserData = this; var fix = Physics.FixtureList[0]; fix.CollisionCategories = Category.Cat3; fix.CollidesWith = Category.Cat1; HitSensor = BodyFactory.CreateRectangle( world, PhysicsConstants.PixelsToMeters(Width) * 2, PhysicsConstants.PixelsToMeters(Height), 1, Position); HitSensor.IsSensor = true; HitSensor.CollisionCategories = Category.Cat2; HitSensor.CollidesWith = Category.Cat2; HitSensor.RegisterOnCollidedListener<UserControlledCharacter>(OnCollidedWith); HitSensor.RegisterOnSeparatedListener<UserControlledCharacter>(OnSeparation); popup = new ItemPopup(ACTION_POPUP, Physics.Position + new Vector2(0, -PhysicsConstants.PixelsToMeters(Height / 2 + POPUP_OFFSET)), cache); initialized = true; } base.InitializePhysics(false, engineRegistrations); }
/// <summary> /// Resolve instance of type. /// </summary> /// <typeparam name="T">Instance of type we want to resolve.</typeparam> /// <param name="parameters">Parameters for resolving.</param> /// <returns></returns> public T Resolve <T>(params IResolverParameter[] parameters) where T : class => componentContext.ResolveOptional <T>(GetParams(parameters));
public object GetService(Type t, params Parameter[] parameters) { return(_componentContext.ResolveOptional(t, GetResolvedParameters(parameters))); }
public override void InitializePhysics(bool force, IComponentContext engineRegistrations) { if (force || !initialized) { var cache = engineRegistrations.Resolve<IResourceCache<Texture2D>>(); var world = engineRegistrations.Resolve<PhysicsManager>().World; engine = engineRegistrations.ResolveOptional<EngineGame>(); Physics = BodyFactory.CreateBody(world, Position, this); if (engine != null && engine.GamepadEnabled) { UP_POPUP = InputManager.Instance.GamepadTextures[InputManager.ButtonActions.UpAction]; DOWN_POPUP = InputManager.Instance.GamepadTextures[InputManager.ButtonActions.DownAction]; } float spriteWidthMeters = PhysicsConstants.PixelsToMeters(Width); float spriteHeightMeters = PhysicsConstants.PixelsToMeters(Height); var rect = FixtureFactory.AttachRectangle( spriteWidthMeters, spriteHeightMeters, 1.4f, Vector2.Zero, Physics); Physics.BodyType = BodyType.Static; Physics.IsSensor = true; Physics.RegisterOnCollidedListener<UserControlledCharacter>(OnCollidedWith); Physics.RegisterOnSeparatedListener<UserControlledCharacter>(OnSeparation); if (DoorType == DoorType.Up) { popup = new ItemPopup( UP_POPUP, Physics.Position + new Vector2(0, -PhysicsConstants.PixelsToMeters(Height / 2)), cache); } else if (DoorType == DoorType.Down) { popup = new ItemPopup( DOWN_POPUP, Physics.Position + new Vector2(0, -PhysicsConstants.PixelsToMeters(Height / 2)), cache); } else { popup = null; } initialized = true; } base.InitializePhysics(false, engineRegistrations); }
public object GetService(Type serviceType) { return(_componentContext.ResolveOptional(serviceType)); }
public override void InitializePhysics(bool force, IComponentContext engineRegistrations) { if (force || !initialized) { var cache = engineRegistrations.Resolve<IResourceCache<Texture2D>>(); var world = engineRegistrations.Resolve<PhysicsManager>().World; engine = engineRegistrations.ResolveOptional<EngineGame>(); var texture = cache.GetResource(EDITOR_PREVIEW); previewScale = new Vector2(Width / texture.Width, Height / texture.Height); Physics = BodyFactory.CreateBody(world, Position, this); float spriteWidthMeters = PhysicsConstants.PixelsToMeters(Width); float spriteHeightMeters = PhysicsConstants.PixelsToMeters(Height); string texture1 = InputTextureLookup(Key1, engine); if (Key2 != 999) { string texture2 = InputTextureLookup(Key2, engine); display2 = new ItemPopup(texture2, Vector2.Zero, cache, new Vector2(40, -90)); plusCombine = new ItemPopup("Textures/Keys/plusCombine", Vector2.Zero, cache, new Vector2(0, -90)); display1 = new ItemPopup(texture1, Vector2.Zero, cache, new Vector2(-40, -90)); } else { display2 = null; display1 = new ItemPopup(texture1, Vector2.Zero, cache, new Vector2(0, -90)); } var rect = FixtureFactory.AttachRectangle( spriteWidthMeters, spriteHeightMeters, 1.4f, Vector2.Zero, Physics); Physics.BodyType = BodyType.Static; Physics.IsSensor = true; Physics.RegisterOnCollidedListener<UserControlledCharacter>(OnCollidedWith); Physics.RegisterOnSeparatedListener<UserControlledCharacter>(OnSeparation); initialized = true; } base.InitializePhysics(false, engineRegistrations); }