public void RegisterPackage(IDependencyCollection collection) { collection.LoadPackage(new XPike.Caching.Package()); collection.LoadPackage(new XPike.Redis.Package()); collection.RegisterSingleton <IRedisCachingConnectionProvider, RedisCachingConnectionProvider>(); }
public DeserializationResult Read(ISerializationManager serializationManager, ValueDataNode node, IDependencyCollection dependencies, bool skipHook, ISerializationContext?context = null) { return(new DeserializedValue <Regex>(new Regex(node.Value, RegexOptions.Compiled))); }
public ValidationNode Validate(ISerializationManager serializationManager, ValueDataNode node, IDependencyCollection dependencies, ISerializationContext?context = null) { return(ushort.TryParse(node.Value, out _) ? new ValidatedValueNode(node) : new ErrorNode(node, $"Failed parsing unsigned short value: {node.Value}")); }
DeserializationResult ITypeReader <SpriteSpecifier, MappingDataNode> .Read( ISerializationManager serializationManager, MappingDataNode node, IDependencyCollection dependencies, bool skipHook, ISerializationContext?context) { return(((ITypeReader <Rsi, MappingDataNode>) this).Read(serializationManager, node, dependencies, skipHook, context)); }
public DeserializationResult Read(ISerializationManager serializationManager, ValueDataNode node, IDependencyCollection dependencies, bool skipHook, ISerializationContext?context = null) { var constType = serializationManager.GetConstantTypeFromTag(typeof(TTag)); return(new DeserializedValue((int)Enum.Parse(constType, node.Value))); }
ValidationNode ITypeValidator <Texture, ValueDataNode> .Validate(ISerializationManager serializationManager, ValueDataNode node, IDependencyCollection dependencies, ISerializationContext?context) { return(serializationManager.ValidateNode(typeof(ResourcePath), new ValueDataNode($"{SharedSpriteComponent.TextureRoot / node.Value}"), context)); }
ValidationNode ITypeValidator <Rsi, MappingDataNode> .Validate(ISerializationManager serializationManager, MappingDataNode node, IDependencyCollection dependencies, ISerializationContext?context) { if (!node.TryGet("sprite", out var pathNode) || pathNode is not ValueDataNode valuePathNode) { return(new ErrorNode(node, "Missing/Invalid sprite node")); } if (!node.TryGet("state", out var stateNode) || stateNode is not ValueDataNode) { return(new ErrorNode(node, "Missing/Invalid state node")); } var path = serializationManager.ValidateNode(typeof(ResourcePath), new ValueDataNode($"{SharedSpriteComponent.TextureRoot / valuePathNode.Value}"), context); if (path is ErrorNode) { return(path); } return(new ValidatedValueNode(node)); }
/// <summary> /// Registers XPike.RequestContext.Http.WebApi with the DI provider. /// </summary> /// <param name="dependencyCollection">The IDependencyCollection to register with.</param> public void RegisterPackage(IDependencyCollection dependencyCollection) { /* Load the XPike.RequestContext.Http package which we depend on */ dependencyCollection.LoadPackage(new XPike.RequestContext.Http.Package()); dependencyCollection.RegisterSingleton <IHttpRequestContextProvider, WebApiRequestContextProvider>(); }
/// <summary> /// Registers XPike.Configuration with the DI container with a custom-built IConfigurationService. /// Uses an optional IDictionary to obtain default configuration values. /// /// The collection of configuration providers registered with the DI container will not be used. /// </summary> /// <param name="dependencyCollection"></param> /// <param name="providerSetup"></param> /// <param name="staticConfig"></param> /// <returns></returns> public static IDependencyCollection AddXPikeConfiguration(this IDependencyCollection dependencyCollection, Action <IXPikeConfigBuilder> providerSetup) { dependencyCollection.AddXPikeConfiguration() .RegisterSingleton(new XPikeConfigBuilder(providerSetup).Build()); return(dependencyCollection); }
public void RegisterPackage(IDependencyCollection dependencyCollection) { // NOTE: No need to load the IoC package. This is a responsibility of the IoC Provider. dependencyCollection.RegisterSingleton <IEnvironmentConfigurationProvider, EnvironmentConfigurationProvider>(); dependencyCollection.RegisterSingleton <INullConfigurationProvider, NullConfigurationProvider>(); // NOTE: This is not valid, because MemoryConfigurationProvider's constructor expects a Dictionary<string, string>. // dependencyCollection.RegisterSingleton<IMemoryConfigurationProvider, MemoryConfigurationProvider>(); // NOTE: But this is valid: //dependencyCollection.RegisterSingleton<IMemoryConfigurationProvider>(provider => new MemoryConfigurationProvider(new Dictionary<string, string> //{ // {"key", "value"} //})); if (_configuration != null) { dependencyCollection.RegisterSingleton <IMemoryConfigurationProvider>(new MemoryConfigurationProvider(_configuration)); dependencyCollection.AddSingletonToCollection <IConfigurationProvider, IMemoryConfigurationProvider>(provider => provider.ResolveDependency <IMemoryConfigurationProvider>()); } dependencyCollection.AddSingletonToCollection <IConfigurationProvider, IEnvironmentConfigurationProvider>((provider) => { return(provider.ResolveDependency <IEnvironmentConfigurationProvider>()); }); dependencyCollection.RegisterSingleton <IConfigurationService, ConfigurationService>(); dependencyCollection.RegisterSingleton(typeof(IConfigManager <>), typeof(DefaultConfigManager <>)); dependencyCollection.RegisterSingleton(typeof(IConfig <>), typeof(ConfigLoader <>)); }
public void RegisterPackage(IDependencyCollection dependencyCollection) { dependencyCollection.LoadPackage(new XPike.Configuration.Package()); dependencyCollection.RegisterSingleton <IAzureConfigurationProvider>(new AzureConfigurationProvider(_connectionString)); dependencyCollection.AddSingletonToCollection <IConfigurationProvider, IAzureConfigurationProvider>(provider => provider.ResolveDependency <IAzureConfigurationProvider>()); }
/// <summary> /// Adds Microsoft Extensions Configuration as the only provider for XPike Configuration after removing any previous registrations. /// Uses an optional IDictionary to retrieve default configuration values. /// Obtains XPike Configuration Providers from the DI container. /// If no IConfiguration is specified, this will also be retrieved from the DI container. /// </summary> /// <param name="collection"></param> /// <param name="staticConfig"></param> /// <param name="configuration"></param> /// <returns></returns> public static IDependencyCollection UseMicrosoftConfigurationForXPike(this IDependencyCollection collection, IDictionary <string, string> staticConfig = null, IConfiguration configuration = null) { collection.ResetCollection <IConfigurationProvider>(); return(collection.AddXPikeMicrosoftConfiguration(staticConfig, configuration)); }
/// <summary> /// Adds Microsoft Extensions Configuration as a provider for XPike Configuration. /// Uses an optional IDictionary to retrieve default configuration values. /// Obtains XPike Configuration Providers from the DI container. /// If no IConfiguration is specified, this will also be retrieved from the DI container. /// </summary> /// <param name="collection"></param> /// <param name="staticConfig"></param> /// <param name="configuration"></param> /// <returns></returns> public static IDependencyCollection AddXPikeMicrosoftConfiguration(this IDependencyCollection collection, IDictionary <string, string> staticConfig = null, IConfiguration configuration = null) { collection.LoadPackage(new XPike.Configuration.Microsoft.Package(configuration, staticConfig)); return(collection); }
public void RegisterPackage(IDependencyCollection dependencyCollection) { dependencyCollection.LoadPackage(new XPike.DataStores.Package()); dependencyCollection.LoadPackage(new XPike.MultiTenant.Package()); dependencyCollection.RegisterSingleton <IMultiTenantConnectionStringManager, MultiTenantConnectionStringManager>(); }
protected internal override void InternalRegisterDependencies(IDependencyCollection dependencies) { if (m_address.OffsetElement != null) { dependencies.Add(m_address.OffsetElement); } }
public IDependencyCollection Register(IDependencyCollection services) { // member services.AddScoped <IUmbracoMemberCreatedEventService, MemberEventService>(); services.AddScoped <IUmbracoMemberAssignedRolesEventService, MemberEventService>(); services.AddScoped <IUmbracoMemberRemovedRolesEventService, MemberEventService>(); services.AddScoped <IUmbracoMemberDeletingEventService, MemberEventService>(); services.AddScoped <IUmbracoMemberGroupDeletingEventService, MemberGroupEventService>(); services.AddScoped <IUmbracoMemberGroupSavedEventService, MemberGroupEventService>(); // media services.AddScoped <IUmbracoMediaSavedEventService, VideoConvertEventService>(); //services.AddScoped<IUmbracoMediaTrashedEventService, SearchMediaEventService>(); //services.AddScoped<IUmbracoMediaSavedEventService, SearchMediaEventService>(); //services.AddScoped<IUmbracoMediaSavingEventService, SearchMediaEventService>(); //content services.AddScopedToCollection <IUmbracoContentTrashedEventService, ArticlePageEventService>(); services.AddScopedToCollection <IUmbracoContentPublishedEventService, ArticlePageEventService>(); services.AddScopedToCollection <IUmbracoContentUnPublishedEventService, ArticlePageEventService>(); //user tags services.AddScopedToCollection <IUmbracoContentTrashedEventService, UserTagsEventService>(); services.AddScopedToCollection <IUmbracoContentPublishedEventService, UserTagsEventService>(); services.AddScopedToCollection <IUmbracoContentUnPublishedEventService, UserTagsEventService>(); return(services); }
public DeserializationResult Read(ISerializationManager serializationManager, MappingDataNode node, IDependencyCollection dependencies, bool skipHook, ISerializationContext?context = null) { if (!node.TryGet("type", out var typeNode)) { throw new InvalidMappingException("No type specified for AppearanceVisualizer!"); } if (typeNode is not ValueDataNode typeValueDataNode) { throw new InvalidMappingException("Type node not a value node for AppearanceVisualizer!"); } var type = IoCManager.Resolve <IReflectionManager>() .YamlTypeTagLookup(typeof(AppearanceVisualizer), typeValueDataNode.Value); if (type == null) { throw new InvalidMappingException( $"Invalid type {typeValueDataNode.Value} specified for AppearanceVisualizer!"); } var newNode = (MappingDataNode)node.Copy(); newNode.Remove("type"); return(serializationManager.Read(type, newNode, context, skipHook)); }
public static void AddScoped <TDefinition, TImplementation>(this IDependencyCollection collection, Binding binding = Binding.Bound) where TImplementation : TDefinition { collection.Register <TImplementation>() .DefineAs <TDefinition>() .AsScoped() .SetBinding(binding); }
ValidationNode ITypeValidator <SpriteSpecifier, MappingDataNode> .Validate( ISerializationManager serializationManager, MappingDataNode node, IDependencyCollection dependencies, ISerializationContext?context) { return(((ITypeReader <Rsi, MappingDataNode>) this).Validate(serializationManager, node, dependencies, context)); }
public static void AddSingleton <TDefinition, TImplementation>(this IDependencyCollection collection, Func <TImplementation> builder, Binding binding = Binding.Bound) where TImplementation : TDefinition { collection.Register(builder) .DefineAs <TDefinition>() .AsSingleton() .SetBinding(binding); }
DeserializationResult ITypeReader <EntityPrototype, ValueDataNode> .Read( ISerializationManager serializationManager, ValueDataNode node, IDependencyCollection dependencies, bool skipHook, ISerializationContext?context) { return(new DeserializedValue <EntityPrototype>(new EntityPrototype(node.Value))); }
public static void AddTransient <TDefinition, TImplementation>(this IDependencyCollection collection, Func <IDependencyProvider, TImplementation> builder, Binding binding = Binding.Bound) where TImplementation : TDefinition { collection.Register(builder) .DefineAs <TDefinition>() .AsTransient() .SetBinding(binding); }
public ValidationNode Validate(ISerializationManager serializationManager, ValueDataNode node, IDependencyCollection dependencies, ISerializationContext?context = null) { var constType = serializationManager.GetConstantTypeFromTag(typeof(TTag)); return(Enum.TryParse(constType, node.Value, out _) ? new ValidatedValueNode(node) : new ErrorNode(node, "Failed parsing constant.", false)); }
DeserializationResult ITypeReader <IReadOnlyList <string>, SequenceDataNode> .Read( ISerializationManager serializationManager, SequenceDataNode node, IDependencyCollection dependencies, bool skipHook, ISerializationContext?context) { var list = new List <string>(); var mappings = new List <DeserializationResult>(); foreach (var dataNode in node.Sequence) { var result = _prototypeSerializer.Read( serializationManager, (ValueDataNode)dataNode, dependencies, skipHook, context); list.Add((string)result.RawValue !); mappings.Add(result); } return(new DeserializedCollection <IReadOnlyList <string>, string>(list, mappings, elements => new List <string>(elements))); }
public ValidationNode Validate(ISerializationManager serializationManager, ValueDataNode node, IDependencyCollection dependencies, ISerializationContext?context = null) { var path = new ResourcePath(node.Value); if (path.Extension.Equals("rsi")) { path /= "meta.json"; } if (!path.EnumerateSegments().First().Equals("Textures", StringComparison.InvariantCultureIgnoreCase)) { path = SharedSpriteComponent.TextureRoot / path; } path = path.ToRootedPath(); try { return(IoCManager.Resolve <IResourceManager>().ContentFileExists(path) ? new ValidatedValueNode(node) : new ErrorNode(node, $"File not found. ({path})")); } catch (Exception e) { return(new ErrorNode(node, $"Failed parsing filepath. ({path}) ({e.Message})")); } }
public ValidationNode Validate(ISerializationManager serializationManager, ValueDataNode node, IDependencyCollection dependencies, ISerializationContext?context = null) { return(dependencies.Resolve <IPrototypeManager>().HasIndex <TPrototype>(node.Value) ? new ValidatedValueNode(node) : new ErrorNode(node, $"PrototypeID {node.Value} for type {typeof(TPrototype)} not found")); }
public DeserializationResult Read(ISerializationManager serializationManager, ValueDataNode node, IDependencyCollection dependencies, bool skipHook, ISerializationContext?context = null) { return(new DeserializedValue <string>(node.Value)); }
public static void BindHeatMapServices(this IDependencyCollection dc, IServicesSettings settings) { var bidAskRepository = new BidAskRepository(new MyNoSqlServerClient <BidAskMySqlTableEntity>(settings.CacheUrl, "bidask")); dc.AddSingleton <IBidAskRepository, BidAskRepository>(bidAskRepository); var bidAskHistoryRepository = new BidAskHistoryRepository(new MyNoSqlServerClient <BidAskHistoryTableEntity>(settings.CacheUrl, "bidaskhistory")); dc.AddSingleton <IBidAskHistoryRepository, BidAskHistoryRepository>(bidAskHistoryRepository); var bidAskCache = new BidAskCache(bidAskRepository); dc.AddSingleton <IBidAskCache, BidAskCache>(bidAskCache); var indexInfoRepo = new IndexInformationRepository(new MyNoSqlServerClient <IndexInformationTableEntity>(settings.CacheUrl, "indexinfo")); dc.AddSingleton <IIndexInformationRepository, IndexInformationRepository>(indexInfoRepo); var overshootInfoRepo = new OvershootIndicatorsDataRepository(new MyNoSqlServerClient <OvershootIndicatorNoSqlEntity>(settings.CacheUrl, "overshoots")); dc.AddSingleton <IOvershootIndicatorsDataRepository, OvershootIndicatorsDataRepository>(overshootInfoRepo); TimerExecutor = new TimerExecutor(1000) .RegisterTimer(nameof(bidAskCache), bidAskCache); TimerExecutor.Start(); }
public DeserializationResult Read(ISerializationManager serializationManager, MappingDataNode node, IDependencyCollection dependencies, bool skipHook, ISerializationContext?context = null) { var type = GetType(node); return(serializationManager.Read(type, node, context, skipHook)); }
public ValidationNode Validate(ISerializationManager serializationManager, ValueDataNode node, IDependencyCollection dependencies, ISerializationContext?context = null) { return(float.TryParse(node.Value, NumberStyles.Float | NumberStyles.AllowThousands, CultureInfo.InvariantCulture, out _) ? new ValidatedValueNode(node) : new ErrorNode(node, $"Failed parsing float value: {node.Value}")); }