public void Register(IDIContainer container)
{
container.Register <ILocalization, Localization>();
container.Register(typeof(IRelayCommand <>), typeof(RelayCommand <>));
Setup(container);
}
public DependencyHolder(IDIContainer container, Type dependencyType)
{
this.Container = container;
this.DependencyType = dependencyType;
this.InstanceType = InstanceType.Static;
this.LifetimeManager = InstanceLifetimeManager.GetInstanceLifetimeManager(this.Container, DependencyType, this.InstanceType);
}
public Task ExecutePostRegistrationStep(IDIContainer container, CancellationToken cancellationToken = default(CancellationToken))
{
var config = container.Resolve <IConfiguration>();
var server = container.Resolve <IServer>();
server.Location = container.Resolve <ILocation>();
server.Location.Lat.Point = config.GetValueOrDefault("Server:Location:Lat", 0.0);
server.Location.Lon.Point = config.GetValueOrDefault("Server:Location:Lon", 0.0);
if (server.Location.Lat.Point != 0 && server.Location.Lon.Point != 0)
{
var ss = container.Resolve <ISunriseSunset>();
server.Sunrise = ss.GetSunrise(server.Location.Lat.Point, server.Location.Lon.Point);
server.Sunrset = ss.GetSunset(server.Location.Lat.Point, server.Location.Lon.Point);
}
if (container.IsRegistered <IScheduler>())
{
var scheduler = container.Resolve <IScheduler>();
var updateJob = container.Resolve <IUpdateServerPropertiesJob>();
var cron = container.Resolve <ICronExpressions>();
scheduler.RecurringJobAddOrUpdate(() => updateJob.UpdateServerProperties(), cron.Daily(12), TimeZoneInfo.Local);
}
return(Task.CompletedTask);
}
public static void Populate(this IDIContainer container, IServiceCollection services)
{
foreach (var service in services)
{
container.AddService(service);
}
}
public DashboardViewModel(IDIContainer container, IAuthorizationManager authManager, INavigationService navigationService, ILocationHelper locationHelper, ILog log)
{
_authManager = authManager;
_navigationService = navigationService;
_locationHelper = locationHelper;
_log = log;
Client.Me().ContinueWith(t => { Me = t.Result.Response; });
Client.Vehicles().ContinueWith(t =>
{
foreach (var v in t?.Result?.Response?.Data)
{
OnNext(v);
}
});
_vehicleObservable = Client.WatchVehicles();
_vehicleObservable.Subscribe(this);
LogoutCommand = container.Resolve <IRelayCommand <object> >();
LogoutCommand.ExecuteAction = async b =>
{
await authManager.Logout();
_navigationService.Navigate(this, "Logout", null);
};
MapZoomLevel = 7;
}
static void Main(string[] args)
{
IDIContainer di = CreateDI();
di.Register <IWCFConfigManager>(() => new WCFConfigManager());
IRemoteOperationHandler roh = new RemoteOperationHandler(di);
RemoteSideCommunicator roc = new RemoteSideCommunicator(roh);
di.Register <IRemoteSideCommunicationContract>(() => roc);
di.Register <IRemoteSideCommunicationHandler>(() => roc);
WCFServiceClientFactory factory = new WCFServiceClientFactory(di);
var rs = factory.CreateInstance();
System.Console.WriteLine("Client started!");
System.Console.WriteLine("Press Enter to call server side Add method.");
System.Console.ReadLine();
RemoteOperationDescriptor rod = new RemoteOperationDescriptor(typeof(ICalc).AssemblyQualifiedName, "Add", 1, 2);
int sum = roc.ExecuteOnRemoteSide <int>(rs.ID, rod);
System.Console.WriteLine("Add(1,2) = {0}", sum);
System.Console.WriteLine("Press Enter to stop service client!");
System.Console.ReadLine();
}
private void RegisterJobs(IDIContainer container)
{
container.Register <ILoggingJob, LoggingJob>();
container.Register <LoggingJob, LoggingJob>();
container.Register <IUpdateServerPropertiesJob, UpdateServerPropertiesJob>();
container.Register <UpdateServerPropertiesJob, UpdateServerPropertiesJob>();
}
public async Task Start(IDIContainer container, IDictionary <string, object> environment = null)
{
Container = container;
container.InjectRegistrationModule(
"NeonTetra.DI.Containers.DefaultDeploymentRegistrationContainer,NeonTetra.DI");
await ExecutePostRegistrationStep(container);
}
protected InstanceLifetimeManager(IDIContainer container, Type type)
{
this._type = type;
this._factory = InstanceFactory.GetFactory();
this._autoInjectionStrategy = AutoInjectionStrategy.GetStrategy(AutoInjectionStrategies.FMPCAutoInjection, container, type);
this.Container = container;
}
static IEnumerator <ResolutionStepResult> injectExporters(IDIContainer container, object scope)
{
while (true)
{
var exporters = CommonUtils.TryOrNull <ICurvesExporterVM[], ServiceIsNotYetAwailableException>(() => instantiate().ToArray());
if (exporters == null)
{
yield return(ResolutionStepResult.WAITING_FOR_SERVICE);
}
else
{
foreach (var exporter in exporters)
{
container.Register <ICurvesExporterVM>(exporter, scope);
}
yield return(ResolutionStepResult.RESOLVED);
}
}
IEnumerable <ICurvesExporterVM> instantiate()
{
var storage = container.ResolveSingle <IPointsStorageProvider>(scope);
yield return(new LasCurvesExporterVM(storage));
}
}
public RegisteredTypeContainer(IDIContainer diContainer, Type registeredType, Func <object> getInstanceFunc, List <Type> typesWeAreDependingOn)
{
if (diContainer == null)
{
throw new ArgumentNullException("diContainer");
}
if (registeredType == null)
{
throw new ArgumentNullException("registeredType");
}
if (getInstanceFunc == null)
{
throw new ArgumentNullException("getInstanceFunc");
}
this.diContainer = diContainer;
this.registeredType = registeredType;
this.getInstanceFunc = getInstanceFunc;
this.unregisteredTypesWeAreDependingOn = typesWeAreDependingOn;
if (typesWeAreDependingOn != null && typesWeAreDependingOn.Any())
{
diContainer.NewTypesRegistered += diContainer_NewTypesRegistered;
}
}
public void Register(IDIContainer container)
{
container.Register <IPage, MainPage>("MainPage");
container.Register <IPage, Dashboard>("Dashboard");
#if OAUTH
container.Register <IPage, OAuthLogin>("Login");
#else
container.Register <IPage, Login>("Login");
#endif
container.Register <INavigationService, DefaultNavigationService>();
container.Register <IDispatchService, UniversalDispatchService>();
container.Register <ILoginViewModel, LoginViewModel>();
container.Register <IDashboardViewModel, DashboardViewModel>();
container.Register <IMainPageViewModel, MainPageViewModel>();
container.Register <IActivityStreamViewModel, ActivityStreamViewModel>();
container.Register <IActivityViewModel, ActivityViewModel>();
#if CACHE_ENABLED
container.Unregister <ICache>();
container.Register <ICache, StorageCache>();
#endif
}
protected override void Initialize(IDIContainer container)
{
base.Initialize(container);
var cm = container.GetInstance<IConfigurationManager<IStepMapConfig>>();
cm.LoadConfiguation();
container.RegisterInstance(cm.Config);
}
public static void AddDependency <TInterface, TImplementation>(this IDIContainer container, ServiceLifetime lifetime = ServiceLifetime.Transient)
where TInterface : class
where TImplementation : class, TInterface
{
var service = new ServiceDescriptor(typeof(TInterface), typeof(TImplementation), lifetime);
container.AddService(service);
}
public SimpleCacheFactory(IDIContainer container, IKnownCacheConfiguration knownCacheConfiguration,
ILogFactory logFactory)
{
_container = container;
_knownCacheConfiguration = knownCacheConfiguration;
_log = logFactory.CreateLog(GetType());
}
private void ApplyServiceBehaviors(IDIContainer container)
{
var registeredServiceBehaviors = container.GetAllInstance<IServiceBehavior>();
foreach (var serviceBehavior in registeredServiceBehaviors)
{
Description.Behaviors.Add(serviceBehavior);
}
}
public void Register(IDIContainer container)
{
container.RegisterInstance(container, typeof(IDIContainer));
container.RegisterInstance(container, typeof(IRegister));
container.RegisterInstance(container, typeof(IResolve));
container.Register <ISerializerFactory, SerializerFactory>();
container.Register <ISerialize, JsonSerializer>();
container.Register <ISerializer, JsonSerializer>();
container.Register <IDeserialize, JsonSerializer>();
JsonConvert.DefaultSettings = () =>
{
var settings = new JsonSerializerSettings();
settings.ContractResolver = new ContractResolver(container);
// do something with settings
return(settings);
};
container.Register <ISerialize, JsonSerializer>(KnownSerializerFormats.JSON.ToString());
container.Register <ISerializer, JsonSerializer>(KnownSerializerFormats.JSON.ToString());
container.Register <IDeserialize, JsonSerializer>(KnownSerializerFormats.JSON.ToString());
container.Register <ISerialize, JsonSerializer>(KnownSerializerIntents.Logging.ToString());
container.Register <ISerializer, JsonSerializer>(KnownSerializerIntents.Logging.ToString());
container.Register <IDeserialize, JsonSerializer>(KnownSerializerIntents.Logging.ToString());
container.Register <IEncryptionFactory, BasicEncryptionFactory>();
container.Register <IEncryption, BasicEncryption>();
container.Register <IEncrypter, BasicEncryption>();
container.RegisterInstance(EncryptionAlgorithm.Rijndael, typeof(EncryptionAlgorithm));
container.Register <IDecrypter, BasicEncryption>();
container.Register <IEncryptionKeyReadProvider, ConfigurationBasedEncryptionKeyProvider>();
container.Register <IEncryptionKey, EncryptionKey>();
container.Register <IValidateEncryptionKeys, ValidateEncryptionKeys>();
container.RegisterSingleton <IVersionProvider, AssemblyInfoVersionProvider>();
container.Register <IContractResolver, ContractResolver>();
container.Register <ICompressionFactory, CompressionFactory>();
container.Register <ICompression, Compression>();
container.Register <ICharacterEncodingConverter, CharacterEncodingConverter>();
container.Register(typeof(IProgress <>), typeof(Progress <>));
container.Register(typeof(ITimedBufferBatch <>), typeof(TimedBufferBatch <>));
container.Register(typeof(ITimedBufferBatchWithErrorRetries <>), typeof(TimedBufferBatchWithErrorRetries <>));
container.Register <IFeatureFlagProvider, ConfigurationBasedFeatureFlagProvider>();
container.Register <IDomainDataLoader, DomainDataLoader>();
container.Register <IUser, User>();
RegisterActorMessageTypes(container);
}
public static DependencyRegistrar BuildRegistrarChain(IDIContainer dIContainer)
{
return(new InjectableDependencyRegistrar(
new InjectForDependencyRegistrar(
new CanBeInjectedDependencyRegistrar(
null, dIContainer)
, dIContainer)
, dIContainer));
}
private async Task ExecutePostRegistrationStep(IDIContainer container)
{
var defaultInstance = container.Resolve <IPostRegistrationStep>("DefaultDeploymentRegistrationContainer");
if (defaultInstance != null)
{
await defaultInstance.ExecutePostRegistrationStep(container, CancellationToken.None);
}
}
public ActorSystemCore(IDIContainer container, string name = "MyActorSystem")
{
_container = container;
_name = name;
var configManager = new ActorSystemConfiguration();
var config = configManager.LoadHoconConfigPriority(_name);
RootActorSystem = SetupActorSystem(_name, config);
}
public JSONSerializer(IDIContainer resolver)
{
if (Settings.ContractResolver?.GetType() != typeof(ContractResolver))
{
Settings.ContractResolver = new ContractResolver(resolver);
Settings.Formatting = Formatting.Indented;
Settings.NullValueHandling = NullValueHandling.Ignore;
}
}
public MojioHttpClient(IAuthorization authorization, IConfiguration configuration, ISerializer serializer, IDIContainer container, ILog log)
{
_configuration = configuration;
_serializer = serializer;
_container = container;
_log = log;
handler.AllowAutoRedirect = true;
Authorization = authorization;
}
public JsonSerializer(IDIContainer container)
{
_contractResolver = new ContractResolver(container);
_settings = new JsonSerializerSettings();
MutateSerializerSettings(_settings);
_serializer = Newtonsoft.Json.JsonSerializer.Create(_settings);
}
public RemoteOperationHandler(IDIContainer diContainer)
{
if (diContainer == null)
{
throw new ArgumentNullException("diContainer");
}
this.diContainer = diContainer;
}
static IEnumerator <ResolutionStepResult> injectCalibrationWidgets(IDIContainer container, ICalibrator calibrator)
{
//Skip(1) because the first item is calibration widget itself
foreach (var calibrationDataWidget in calibrator.Widgets.Skip(1))
{
container.Register <IWidget>(calibrationDataWidget);
}
yield return(ResolutionStepResult.RESOLVED);
}
public void Register(IDIContainer container)
{
container.Register(typeof(ICache <,>), typeof(NonStaticImmutableInMemoryCache <,>));
container.Register(typeof(ICache <,>), typeof(NonStaticImmutableInMemoryCache <,>), "DEFAULT");
container.Register(typeof(ICache <,>), typeof(NonStaticImmutableInMemoryCache <,>), "INMEMORY_REQUESTS");
container.Register <ICacheFactory, SimpleCacheFactory>();
container.Register <IKnownCacheSetup, KnownCacheSetup>();
container.Register <IKnownCacheConfiguration, KnownCacheConfiguration>();
}
public void Register(IDIContainer container)
{
if (!container.IsRegistered <IConfiguration>())
{
container.Register <IConfiguration, Configuration>();
var config = container.Resolve <IConfiguration>();
config.Build();
container.RegisterInstance(config, typeof(IConfiguration));
}
}
public StorageCache(ISerializer serializer, IDIContainer container)
{
_serializer = serializer;
_container = container;
_storage = IsolatedStorageFile.GetUserStoreForApplication();
if (!_storage.DirectoryExists("cache"))
{
_storage.CreateDirectory("cache");
}
}
public MvcApplication()
{
m_Container = new DIContainer();
var configSection = (CompilationSection)ConfigurationManager.GetSection("system.web/compilation");
if (!configSection.Debug)
Error += new EventHandler(MvcApplication_Error);
BeginRequest += new EventHandler(MvcApplication_BeginRequest);
this.GetLogger().Trace(m => m("Application startup"));
}
private void RegisterActorMessageTypes(IDIContainer container)
{
container.Register <ICommandToEventAdapter, CommandToEventAdapter>();
//messages/commands/events
container.Register <IRespondActorStateEvent, RespondActorStateEvent>();
container.Register <IUpdateUserActorStateCommand, UpdateUserActorStateCommand>();
container.Register <IRequestTrackUserCommand, RequestTrackUserCommand>();
container.Register <IUserTrackingEvent, UserTrackingEvent>();
container.Register <IUserUpdatedEvent, UserUpdatedEvent>();
}
public void Register(IDIContainer container)
{
container.Register <ILogFactory, InjectedLogFactory>();
container.Register <ILog, BroadcastLogger>();
container.Register <ILog, SerilogLogger>(typeof(SerilogLogger).FullName);
container.Register <IEventTimingFactory, EventTimingRecorderFactory>();
container.Register <IInlineEventTimer, InlineEventTimer>();
container.Register <IInstrumentationEntity, InstrumentationEntity>();
container.Register <ICaptureAndAggregate, TimerCaptureAndAggregate>();
container.Register <IMetricAggregator, MetricAggregator>();
}
private void ApplyContractBehaviors(IDIContainer container)
{
var registeredContractBehaviors = container.GetAllInstance<IContractBehavior>();
foreach (var contractBehavior in registeredContractBehaviors)
{
foreach (var contractDescription in ImplementedContracts.Values)
{
contractDescription.Behaviors.Add(contractBehavior);
}
}
}
/// <summary>
/// 设置新的依赖注入容器
/// </summary>
/// <param name="container">依赖注入容器</param>
/// <param name="configFileName">配置文件名称</param>
/// <returns>依赖注入上下文</returns>
public DiContext SetContainer(IDIContainer container, string configFileName = "")
{
if (container != null)
{
Container = container;
if (!string.IsNullOrEmpty(configFileName))
{
container.Init(_name, configFileName);
}
}
return(this);
}
/// <summary>
/// <para>创建依赖注入上下文</para>
/// <para>默认上下文名称为Default</para>
/// <para>在默认依赖注入容器中需要注册IDependencyInjectionContainer</para>
/// <para>用于创建子容器时生成容器</para>
/// </summary>
/// <param name="name">上下文名称</param>
/// <param name="container">依赖注入容器</param>
/// <param name="configFileName">配置文件名</param>
/// <returns>依赖注入上下文</returns>
public static DiContext Create(string name = "Default", IDIContainer container = null, string configFileName = "")
{
//是否为创建默认依赖注入上下文
if (string.IsNullOrWhiteSpace(name) || name.Equals("DEFAULT", StringComparison.CurrentCultureIgnoreCase))
{
//依赖注入上下文不允许重复创建
if (Instance != null)
{
throw new NotSupportedException("Could not create Default instance twice.");
}
Instance = new DiContext();
TypeFinder = new ContainerTypeFinder();
Instance.SetContainer(container);
return(Instance);
}
//下级依赖注入上下文创建之前必须创建默认依赖注入上下文
if (Instance?.Container == null)
{
throw new NullReferenceException("Could not create configuration instance with base instance is null.");
}
var diContext = Instance.Container.ServiceProvider.GetServices <DiContext>();
if (false)
{
throw new NotSupportedException("Could not create configuration instance twice.");
}
var instance = new DiContext
{
_name = name
};
if (container == null)
{
//var newContainer = Instance.Container.ServiceProvider.GetService.Resolve<IDIContainer>();
//if (newContainer != null)
//{
// instance.SetContainer(newContainer);
// Instance.Container.RegisterInstanceWithKeyed(instance, name);
// return instance;
//}
//else
//{
// throw new NullReferenceException("Could not create instance.");
//}
}
instance.SetContainer(container);
//Instance.Container.RegisterInstanceWithKeyed(instance, name);
return(instance);
}
public DIContainerInstanceProvider(IDIContainer container, Type contractType)
{
if (container == null)
{
throw new ArgumentNullException("container");
}
if (contractType == null)
{
throw new ArgumentNullException("contractType");
}
this.container = container;
this.contractType = contractType;
}
private void Initialize(IDIContainer container)
{
if (container == null)
{
throw new ArgumentNullException("container");
}
this.container = container;
ApplyServiceBehaviors(container);
ApplyContractBehaviors(container);
foreach (var contractDescription in ImplementedContracts.Values)
{
var contractBehavior = new DIContainerContractBehavior(new DIContainerInstanceProvider(container, contractDescription.ContractType));
contractDescription.Behaviors.Add(contractBehavior);
}
}
private static void LoadSerializarion(IDIContainer container)
{
container.RegisterType<ISerialization, NetSerialization>("EncryptionSerializer", TypeInstancingMode.Singleton);
container.RegisterType<ISerialization, XmlSerialization>("DefaultSerializer", TypeInstancingMode.Singleton);
}
private static void LoadDebug(IDIContainer container, IConfigService configService)
{
var debug = DebugFactory.Create(configService);
container.RegistryInstance<IDebug>(debug);
}
private static void LoadInstrumentation(IDIContainer container, IConfigService configService)
{
var instrumentation = InstrumentationFactory.Create(configService);
container.RegistryInstance<IInstrumentation>(instrumentation);
}
public DIContainerServiceHost(IDIContainer container, object instance, params Uri[] baseAddresses)
: base(instance, baseAddresses)
{
Initialize(container);
}
public DIContainerServiceHost(IDIContainer container, Type serviceType, params Uri[] baseAddresses)
: base(serviceType, baseAddresses)
{
Initialize(container);
}
protected virtual void Initialize(IDIContainer container) { }
private static void LoadConfigService(IDIContainer container)
{
var configService = ConfigServiceFactory.Create();
container.RegistryInstance<IConfigService>(configService, TypeInstancingMode.Singleton);
}
public History(IRepository repository, IDIContainer container)
{
_repository = repository;
_container = container;
}
private static void LoadCompression(IDIContainer container)
{
BallyTech.Infrastructure.Compression.Compression compression = new BallyTech.Infrastructure.Compression.Compression();
container.RegistryInstance<ICompression>(compression, TypeInstancingMode.Singleton);
}
private static void LoadUtil(IDIContainer container)
{
var util = new Util(container) as IUtil;
container.RegistryInstance<IUtil>(util);
}
private DIContainer()
{
Container = new NinjectContainer();
}
private static void LoadRNG(IDIContainer container)
{
container.RegisterType<Int32RNGGenerator>(RNGType.Int32.ToString(), TypeInstancingMode.Instance);
container.RegisterType<Int64RNGGenerator>(RNGType.Int64.ToString(), TypeInstancingMode.Instance);
}
public ControllerFactory(IDIContainer container)
{
m_Container = container;
}
private static void LoadLogger(IDIContainer container, IConfigService configService)
{
var logger = LoggerFactory.Create(configService, null);
container.RegistryInstance<ILogger>(logger);
}
