public static void Main(string[] args)
{
using (var container = new Unity.UnityContainer())
{
container.AddNewExtension <Interception>();
container.RegisterType(typeof(IDataContainer <string>), typeof(DataContainer)
, new Interceptor <InterfaceInterceptor>()
, new InterceptionBehavior <LoggingAspect>());
container.RegisterType(typeof(IDataManager <string>), typeof(DataManager)
, new Interceptor <InterfaceInterceptor>()
, new InterceptionBehavior <LoggingAspect>());
container.RegisterType <IProcessor, Processor>(
new Interceptor <InterfaceInterceptor>()
, new InterceptionBehavior <LoggingAspect>());
var processor = container.Resolve <IProcessor>();
var result = processor.DoWork();
}
/*
* Processor processor = DependencyInjector.Retrieve<Processor>();
* var result = processor.DoWork();
*/
}
public static void Register(HttpConfiguration config)
{
config.EnableCors();
var container = new Unity.UnityContainer();
/*
* Đăng ký service và Repository cho controller nhóm thực đơn
* Create by: nvcuong
*/
container.RegisterType <IMenuGroupService, MenuGroupService>();
container.RegisterType <IMenuGroupRepository, MenuGroupRepository>();
container.RegisterType <ITaskService, TaskService>();
container.RegisterType <ITaskRepository, TaskRepository>();
// Web API configuration and services
config.DependencyResolver = new UnityResolver(container);
GlobalConfiguration.Configuration.DependencyResolver = new UnityDependencyResolver(container);
// Web API routes
config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
}
static void Main(string[] args)
{
//Instantiate UnityContainer
IUnityContainer container = new Unity.UnityContainer();
//Register Type with Unity
container.RegisterType <Language>(new InjectionConstructor("pt-br"));
container.RegisterType <MovieLister>(new InjectionMethod("ConfigLanguage",
container.Resolve <Language>()));
//Resolve
Language language = container.Resolve <Language>();
//Register Type with Unity
container.RegisterType <IMovieFinder, ColonDelimitedMovieFinder>(
new InjectionProperty("Path", "movies1.txt"));
container.RegisterType <IMovieFinder, MemoryMovieFinder>("memory");
container.RegisterType <MovieLister>("default", new InjectionConstructor(container.Resolve <IMovieFinder>("memory")));
//Resolve
MovieLister movieLister = container.Resolve <MovieLister>("default");
Console.WriteLine($"Language {language.Type}");
string director = "Guillermo del Toro";
foreach (Movie movie in movieLister.MoviesDirectedBy(director))
{
Console.WriteLine($"Movie {movie.Title}");
}
}
static void Main()
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
using (var container = new Unity.UnityContainer().EnableDiagnostic())
{
string connectionInfo = @"Data Source=12.11.10.1\DATA;Initial Catalog=DATA;User ID=Data;Password=Data;Application Name=UI.NET";
string userName = "******";
container.RegisterType <IConfig, Config>(new InjectionProperty("ConnectionInfo", connectionInfo), new InjectionProperty("UserName", userName));
// -- DataAccess -
container.RegisterType <IDataAccess, DataAccess.DataAccess>();
//
// -- DataStore:
container.RegisterType <IDataStore, DataStoreManagemer>();
//
//
container.RegisterType <IViewContainer, UserInfoViewContainer>();
//
container.RegisterType <IView, formUserInfo>(new InjectionConstructor(typeof(UserInfoViewContainer)));
//
var ctorMainPresentation = new InjectionConstructor(typeof(formUserInfo));
container.RegisterType <IPresentation, MainPresentation>(ctorMainPresentation);
var obj = container.Resolve <MainPresentation>();
obj.Populate().GetAwaiter().GetResult();
obj.Show();
}
}
private void OwinStartup(IAppBuilder app)
{
HttpConfiguration config = new HttpConfiguration();
IDependencyResolver resolver;
#if true
Unity.IUnityContainer uc = new Unity.UnityContainer();
uc.RegisterInstance(typeof(IPlop), new Plop());
resolver = new UnityResolver(uc);
#else
Autofac.ContainerBuilder builder = new Autofac.ContainerBuilder();
builder.RegisterApiControllers(typeof(WorkerRole).Assembly);
builder.RegisterInstance(new Plop()).As <IPlop>();
Autofac.IContainer container = builder.Build();
app.UseAutofacMiddleware(container);
app.UseAutofacWebApi(config);
resolver = new AutofacWebApiDependencyResolver(container);
#endif
config.DependencyResolver = resolver;
config.MapHttpAttributeRoutes();
config.EnsureInitialized();
app.UseWebApi(config);
}
static void Main(string[] args)
{
Unity.IUnityContainer container = new Unity.UnityContainer();
ContainerMagic.RegisterElements(container);
var battery = container.Resolve <IBattery>();
Console.WriteLine($"Battery object: SerialNumber - {battery.SerialNumber()}");
var tuner = container.Resolve <ITuner>();
Console.WriteLine($"Tuner object: SerialNumber - {tuner.SerialNumber()}");
var dial = container.Resolve <Dial>();
Console.WriteLine($"Dial object: DialType - {dial.DialType()}");
var radio = container.Resolve <IRadio>(new Unity.Resolution.ParameterOverride("radioBattery", battery),
new Unity.Resolution.ParameterOverride("radioTuner", tuner),
new Unity.Resolution.ParameterOverride("radioName", "RocketRadio"));
radio.Start();
var cheapSpeaker = container.Resolve <ISpeaker>("Cheap");
var priceySpeaker = container.Resolve <ISpeaker>("Expensive");
cheapSpeaker.Start();
priceySpeaker.Start();
Console.ReadLine();
}
private void CreateUnityContainer()
{
container = new Unity.UnityContainer();
var section = GetSection();
section.Configure(container);
}
private static void RegisterTelemetryClient(Unity.UnityContainer container)
{
var telemetryClient = new TelemetryClient {
InstrumentationKey = Key
};
container.RegisterInstance(telemetryClient, new ContainerControlledLifetimeManager());
}
public MvcFixture()
{
defaultContainer = new UnityContainer();
defaultServiceProvider = new ServiceProvider(defaultContainer);
// Register SampleClassA, but not SampleClassB
defaultContainer.RegisterType<ISample, SampleClassA>();
}
private static void RegisterAutoMapper(Unity.UnityContainer container)
{
var config = new MapperConfiguration(cfg => { cfg.CreateMap <CustomerVehicle, SaveCustomerVehicleRequest>(); });
var mapper = config.CreateMapper();
container.RegisterInstance(mapper);
}
private static IUnityContainer setupDependencyInjection()
{
IUnityContainer c = new Unity.UnityContainer();
Trading.ContainerBootStrapper.RegisterTypes(c);
return(c);
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public IUser GetUserByAppConfiguration()
{
Unity.IUnityContainer unityContainer = new Unity.UnityContainer();
unityContainer.LoadConfiguration("unityContainer");
Strategy.IUser user = unityContainer.Resolve <Strategy.IUser>();
user = user.GetUserById();
return(user);
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public Strategy.IUser GetUser()
{
//IOC容器
Unity.UnityContainer unityContainer = new Unity.UnityContainer();
unityContainer.RegisterType(typeof(Strategy.IUser), typeof(Domain.User));
Strategy.IUser user = unityContainer.Resolve <Strategy.IUser>();
return(user);
}
private static async Task Run(string[] args)
{
using (var container = new Unity.UnityContainer().EnableDiagnostic())
{
container.RegisterSingleton <ILogger, Logger>();
Application.Run(container.Resolve <Form1>());
}
}
static UnityContainer()
{
InternalUnityContainer container = new InternalUnityContainer();
container.RegisterSingleton <IConfigProvider>(
ConfigProviderNames.UserSecrets,
new InjectionFactory(c => new UserSecretsConfigProvider()));
globalUnityContainer = container;
}
private static void RegisterAutoMapper(Unity.UnityContainer container)
{
var config = new MapperConfiguration(cfg =>
{
cfg.CreateMap <GetAppointmentSlotsRequest, CDKGetAppointmentSlotsRequest>();
});
var mapper = config.CreateMapper();
container.RegisterInstance(mapper);
}
private static IUnityContainer InitialiseUnityContainer()
{
var container = new Unity.UnityContainer();
container.RegisterType <IProfileRepository, ProfileRepository>(new ContainerControlledLifetimeManager(),
new InjectionConstructor(FilePath));
container.RegisterType <IProfileService, ProfileService>();
return(container);
}
private static IUnityContainer InitialiseUnityContainer()
{
var container = new Unity.UnityContainer();
container.RegisterType <IValidateRequest, ValidateRequest>();
container.RegisterType <IDealerConfigurationDAL, DealerConfigurationDAL>(new InjectionConstructor(ConnectionString));
container.RegisterType <IDealerConfigurationService, DealerConfigurationService>();
RegisterAutoMapper(container);
return(container);
}
public async Task <bool> ProcessXmlProducts(int sellerId)
{
var seller = await db.tblSellers.Where(x => x.SellerId == sellerId).FirstOrDefaultAsync();
var container = new Unity.UnityContainer();
var sst = container.Resolve <ImportService.Service.Service>();
var xmlData = sst.ReadCSV(sellerId);
var colorMappingList = sst.GetColorFamily("ColorMapping/COLOR_MAPPING.xml");
var result = false;
var vendor = xmlData.ProductAttributeGroups.ProductAttributeGroup.ProductAttributeGroupCode;
var plist = xmlData.Products.Product;
List <ImportService.Wrapper.Product> successList = new List <ImportService.Wrapper.Product>();
List <ImportService.Wrapper.Product> errorList = new List <ImportService.Wrapper.Product>();
foreach (var p in plist)
{
try
{
var _p = await CreateProduct(p, vendor, seller.MyShopifyDomain, seller.ShopifyAccessToken, colorMappingList);
successList.Add(p);
}
catch (Exception ex)
{
errorList.Add(p);
result = true;
Log.Error("Error in ProcessXmlProducts method", ex, vendor);
}
}
if (successList.Count > 0)
{
xmlData.Products.Product = new List <ImportService.Wrapper.Product>();
xmlData.Products.Product.AddRange(successList);
var sSetting = seller.tblSchedulerSettings.FirstOrDefault();
var filename = seller.MyShopifyDomain;
sst.CreateFileSFTP(sSetting.FtpHost, sSetting.FtpUserName, sSetting.FtpPassword, sSetting.FtpFilePath, "success", filename, xmlData);
}
if (errorList.Count > 0)
{
xmlData.Products.Product = new List <ImportService.Wrapper.Product>();
xmlData.Products.Product.AddRange(errorList);
var sSetting = seller.tblSchedulerSettings.FirstOrDefault();
var filename = seller.MyShopifyDomain;
sst.CreateFileSFTP(sSetting.FtpHost, sSetting.FtpUserName, sSetting.FtpPassword, sSetting.FtpFilePath, "error", filename, xmlData);
}
return(result);
}
private static IUnityContainer InitializeUnityContainer()
{
var container = new Unity.UnityContainer();
RegisterAutoMapper(container);
container.RegisterType <IValidateRequest, ValidateRequest>();
container.RegisterType <IAppointmentDAL, AppointmentDAL>(
new InjectionConstructor(new AppointmentContext(DatabaseConnectionString)));
container.RegisterType <IAppointmentService, Service.Implementation.AppointmentService>();
return(container);
}
private static void RegisterAutoMapper(Unity.UnityContainer container)
{
var config = new MapperConfiguration(cfg =>
{
cfg.CreateMap <DealerConfigurationCreateRequest, DealerConfiguration>();
cfg.CreateMap <DealerConfigurationUpdateRequest, DealerConfiguration>();
cfg.CreateMap <DealerConfiguration, DealerConfigurationResponse>();
cfg.CreateMap <DealerConfiguration, DealerInvitationContentResponse>();
});
var mapper = config.CreateMapper();
container.RegisterInstance(mapper);
}
private static IUnityContainer InitialiseUnityContainer()
{
var container = new Unity.UnityContainer();
RegisterTelemetryClient(container);
RegisterServiceClients(container);
RegisterAutoMapper(container);
RegisterSendGridClient(container);
container.RegisterType <ICustomerVehicleDAL, CustomerVehicleDAL>(
new InjectionConstructor(DatabaseConnectionString));
container.RegisterType <ICustomerServiceBooking, CustomerServiceBooking>(
new InjectionConstructor(container.Resolve <IRestfulClient>(Constants.CDKAutolineAPI),
container.Resolve <TelemetryClient>()));
container.RegisterType <ISMSGatewayClient, PlivoGatewayClient>(new ContainerControlledLifetimeManager(),
new InjectionConstructor(PilvoAuthId, PilvoAuthToken));
container.RegisterType <IEmailGatewayClient, EmailGatewayClient>(new ContainerControlledLifetimeManager(),
new InjectionConstructor(container.Resolve <ISendGridClient>()));
container.RegisterType <IDealerConfigurationService, DealerConfigurationService>(
new InjectionConstructor(container.Resolve <IRestfulClient>(Constants.DealerConfigurationAPI)));
container.RegisterType <ICustomerInvitationService, CustomerInvitationService>(
new InjectionConstructor(ServiceBookingAppUrl, Convert.ToInt32(InvitationExpiredDays),
InvitationFromPhoneNumber, container.Resolve <ISMSGatewayClient>(),
container.Resolve <IEmailGatewayClient>(), container.Resolve <TelemetryClient>(),
container.Resolve <IDealerConfigurationService>(), ServiceBookingUrlPlaceHolder,
RegistrationNoPlaceHolder
));
container.RegisterType <IEmailService, EmailService>(
new InjectionConstructor(container.Resolve <IEmailGatewayClient>(),
ServiceBookingEmail));
container.RegisterType <ICustomerRegistrationService, CustomerRegistrationService>(
new InjectionConstructor(container.Resolve <IMapper>(), container.Resolve <IRestfulClient>(Constants.CDKAutolineAPI),
container.Resolve <TelemetryClient>()));
container.RegisterType <IValidateRequest, ValidateRequest>();
container.RegisterType <ICustomerVehicleService, Service.Implementation.CustomerVehicleService>(
new InjectionConstructor(container.Resolve <ICustomerVehicleDAL>(), container.Resolve <IMapper>(),
container.Resolve <ICustomerRegistrationService>(), container.Resolve <ICustomerInvitationService>(),
container.Resolve <IEmailService>(), container.Resolve <ICustomerServiceBooking>(),
Convert.ToInt32(ServiceBookingExpiredDays)));
return(container);
}
public void IfAServiceIsNotRegisteredTryUsingAlternativeContainer()
{
UnityContainer container = new UnityContainer();
container.AlternativeServiceProvider = defaultServiceProvider;
Assert.NotNull(defaultContainer.Resolve<ISample>());
Assert.IsType<SampleClassA>(defaultContainer.Resolve<ISample>());
Assert.IsNotType<SampleClassB>(defaultContainer.Resolve<ISample>());
// Now with the other container
Assert.NotNull(container.Resolve<ISample>());
Assert.IsType<SampleClassA>(container.Resolve<ISample>());
Assert.IsNotType<SampleClassB>(container.Resolve<ISample>());
}
private static IUnityContainer InitialiseUnityContainer()
{
var container = new Unity.UnityContainer();
RegisterServiceClients(container);
RegisterTelemetryClient(container);
container.RegisterType <IRecommendedService, RecommendedService>();
container.RegisterType <IDealerService, DealerService>(
new InjectionConstructor(container.Resolve <IRestfulClient>(DealerConfigurationApiClient)));
container.RegisterType <ICDKAutolineService, CDKAutolineService>(
new InjectionConstructor(container.Resolve <IRestfulClient>(CdkAutolineApiClient), container.Resolve <TelemetryClient>()));
return(container);
}
static void Main(string[] args)
{
var container = new Unity.UnityContainer();
container.RegisterSingleton <IStringHelper, StringHelper>();
var newUsers = container.Resolve <Users>();
Console.WriteLine(newUsers.FormatUserName("cnf"));
// Unity.Injection.
Console.ReadKey();
}
private static void Run_UsingUnityDI(string[] args)
{
using (var container = new Unity.UnityContainer().EnableDiagnostic())
{
string environment = Settings.Environment();
string notificationRecipientList = Settings.NotificationRecipientList();
string sendEmailGateway = Settings.SendEmailGateway();
// -- httpclientfactory
Microsoft.Extensions.DependencyInjection.ServiceCollection serviceCollection = new Microsoft.Extensions.DependencyInjection.ServiceCollection();
serviceCollection.AddHttpClient("Sender", (c) =>
{
c.BaseAddress = new Uri(sendEmailGateway);
});
serviceCollection.BuildServiceProvider(container);
//var httpClientFactory = serviceProvider.GetService<IHttpClientFactory>();
IHttpClientFactory clientFactory = container.Resolve <IHttpClientFactory>();
HttpClient httpClient = clientFactory.CreateClient("Sender");
container.RegisterSingleton <IConfig, AppConfig>(
new InjectionProperty("Environment", environment)
, new InjectionProperty("NotificationRecipientList", notificationRecipientList)
, new InjectionProperty("SendEmailGateway", sendEmailGateway)
);
container.RegisterSingleton <ILogger, Logger>();
//Sender(IConfig config, IHttpClientFactory httpClientFactory, ILogger logger)
/*
* container.RegisterSingleton<ISender, Sender>(
* new InjectionConstructor(
* new ResolvedParameter(typeof(IConfig))
* , new ResolvedParameter(typeof(IHttpClientFactory))
* , new ResolvedParameter(typeof(ILogger))
* )
* );*/
container.RegisterSingleton <ISender, Sender>();
container.RegisterType(typeof(RemoteAppenderSink));
var sink = container.Resolve <RemoteAppenderSink>();
//sink.EventsReached += (s, a) => AddLog(a.LoggingEvents);
RemotingConfiguration.Configure("log4netListener.exe.config", false);
RemotingServices.Marshal(sink, "RemoteAppenderLoggingSink");
}
}
private static IUnityContainer InitialiseUnityContainer()
{
var container = new Unity.UnityContainer();
RegisterTelemetryClient(container);
RegisterAutoMapper(container);
container.RegisterType <IAppTokenDAL, AppTokenDAL>(new InjectionConstructor(new CDKAutolineContext(ConnectionString)));
container.RegisterType <IEncryptionService, RijndaelEncryptionService>(new InjectionConstructor(SecretKey));
container.RegisterType <IValidateRequest, ValidateRequest>();
container.RegisterType <IRestApiClient, RestApiClient>();
container.RegisterType <IPasswordService, PasswordService>(
new InjectionConstructor(Convert.ToInt32(PasswordLength), PasswordCharacters));
container.RegisterType <IEncryptedTokenCodeService, EncryptedTokenCodeService>(
new InjectionConstructor(UnregisteredGuid, container.Resolve <IEncryptionService>()));
container.RegisterType <ICdkCustomerDAL, CdkCustomerDAL>(
new InjectionConstructor(new CDKAutolineContext(ConnectionString)));
container.RegisterType <IDealerCDKConfigurationsDAL, DealerCDKConfigurationsDAL>(
new InjectionConstructor(new CDKAutolineContext(ConnectionString)));
container.RegisterType <ICdkCustomerService, CdkCustomerService>();
container.RegisterType <ICustomerService, CustomerService>(
new InjectionConstructor(container.Resolve <IRestApiClient>(), CdkAutolineUrl,
container.Resolve <IEncryptedTokenCodeService>()));
container.RegisterType <ITokenService, TokenService>(
new InjectionConstructor(container.Resolve <IRestApiClient>(),
container.Resolve <IEncryptedTokenCodeService>(), CdkAutolineUrl,
UnregisteredGuid, container.Resolve <IAppTokenDAL>(), container.Resolve <TelemetryClient>(),
container.Resolve <ICdkCustomerService>(), container.Resolve <ICustomerService>(),
container.Resolve <IDealerCDKConfigurationsDAL>()));
container.RegisterType <ICDKAutolineServices, CDKAutolineServices>();
container.RegisterType <ICDKVehicleMaintenanceService, CDKVehicleMaintenanceService>(
new InjectionConstructor(container.Resolve <IRestApiClient>(), CdkAutolineUrl,
container.Resolve <ITokenService>(), container.Resolve <TelemetryClient>()));
container.RegisterType <ICDKBookingService, CDKBookingService>(
new InjectionConstructor(container.Resolve <IRestApiClient>(),
container.Resolve <ITokenService>(), container.Resolve <ICdkCustomerDAL>(),
container.Resolve <TelemetryClient>(), CdkAutolineUrl));
container.RegisterType <ICDKServiceAdvisors, CDKServiceAdvisors>(
new InjectionConstructor(container.Resolve <IRestApiClient>(), container.Resolve <ITokenService>(),
container.Resolve <ICdkCustomerDAL>(), container.Resolve <TelemetryClient>(), CdkAutolineUrl));
container.RegisterType <ICDKAppointmentSlotsService, CDKAppointmentSlotsService>(
new InjectionConstructor(container.Resolve <IRestApiClient>(),
container.Resolve <ICdkCustomerDAL>(), container.Resolve <ITokenService>(),
container.Resolve <TelemetryClient>(), container.Resolve <IValidateRequest>(),
container.Resolve <IMapper>(), CdkAutolineUrl));
return(container);
}
private static void RegisterServiceClients(Unity.UnityContainer container)
{
var cdkClientConfiguration =
new ClientConfiguration {
ServiceUrl = CdkAutolineApiUrl, AccessKey = CdkAutolineApiKey
};
container.RegisterType <IRestfulClient, RestfulClient>(Constants.CDKAutolineAPI, new InjectionConstructor(cdkClientConfiguration));
var dealerClientConfiguration =
new ClientConfiguration {
ServiceUrl = DealerConfigurationApiUrl, AccessKey = DealerConfigurationApiKey
};
container.RegisterType <IRestfulClient, RestfulClient>(Constants.DealerConfigurationAPI, new InjectionConstructor(dealerClientConfiguration));
}
private static IUnityContainer InitialiseUnityContainer()
{
var container = new Unity.UnityContainer();
RegisterAutoMapper(container);
RegisterServiceClients(container);
container.RegisterType <ICustomerVehicleClient, CustomerVehicleClient>(
new InjectionConstructor(container.Resolve <IRestfulClient>(Constants.CustomerVehicleAPI),
container.Resolve <IMapper>()));
container.RegisterType <IDealerConfigurationClient, DealerConfigurationClient>(
new InjectionConstructor(container.Resolve <IRestfulClient>(Constants.DealerConfigurationAPI)));
container.RegisterType <IEmailProcessor, EmailProcessor>();
container.RegisterType <IExchangeServices, ExchangeServices>("ExchangeServices",
new ContainerControlledLifetimeManager(),
new InjectionConstructor(
ExchangeVersion,
ExchangeUserName,
ExchangePassword,
ExchangeUrl
));
container.RegisterType <IMailService, MailService>(
new InjectionConstructor(container.Resolve <IExchangeServices>("ExchangeServices")));
container.RegisterType <ICsvProcessor, CsvProcess>(new InjectionConstructor(GetCsvColumnNames()));
container.RegisterType <IAzureServices, AzureServices>(
new ContainerControlledLifetimeManager(),
new InjectionConstructor(
AzureFileConnectionString,
AzureFileShareName,
AzureFileProcessedFolderName,
AppendDateFormatInFileName
));
container.RegisterType <IAzureFileProcessor, AzureFileProcessor>(
new InjectionConstructor(container.Resolve <IAzureServices>()));
container.RegisterType <IFileContentService, FileContentService>(
new InjectionConstructor(container.Resolve <IEmailProcessor>(), container.Resolve <IAzureFileProcessor>()));
return(container);
}
static void Main()
{
Unity.UnityContainer container = new Unity.UnityContainer();
Unity.ServiceLocation.UnityServiceLocator unityServiceLocator = new Unity.ServiceLocation.UnityServiceLocator(container);
//Registrar tipos de operaciones con entidades
container.RegisterInstance <FUMIT.Entidades.FumitDbContext>(new Entidades.FumitDbContext());
container.RegisterType <AccesoDatos.IClientes, ClientesRepositorio>();
container.RegisterType <AccesoDatos.ISucursales, SucursalesRepositorio>();
container.RegisterType <IProgramacionServicios, ProgramacionServiciosRepositorio>();
container.RegisterType <IProgramacionServiciosCliente, ProgramacionServiciosClienteRepositorio>();
container.RegisterType <ICiclosFacturacion, CiclosFacturacionRepositorio>();
container.RegisterType <IServiciosProgramados, ServiciosProgramadosRepositorio>();
container.RegisterType <IServicio, ServiciosRepositorio>();
container.RegisterType <IContactos, ContactosRepositorio>();
container.RegisterType <IVSProgramacionServiciosCliente, VSProgramacionServiciosClienteRepositorio>();
container.RegisterType <ICicloFacturacionClientes, CiclosFactuacionClienteRepositorio>();
container.RegisterType <IEquipos, EquiposRepositorio>();
container.RegisterType <ITipoEquipos, TipoEquiposRepositorio>();
container.RegisterType <IAsignacionesEquipo, AsignacionesEquipoRepositorio>();
container.RegisterType <IMantenimientos, MantenimientosRepositorio>();
container.RegisterType <IMantenimientosEquipo, MantenimientosEquipoRepositorio>();
container.RegisterType <ICalendarioSemanalServicios, CalendarioSemanalServiciosRepositorio>();
container.RegisterType <IOperadores, OperadoresRepositorio>();
container.RegisterType <ITickets, TicketsRepositorio>();
container.RegisterType <IContenedoresTicket, ContenedoresTicketRepositorio>();
//Se registra ExceptionManager
Microsoft.Practices.EnterpriseLibrary.ExceptionHandling.ExceptionManager manager = Exceptions.ExceptionHandlingPolicies.InicializarPoliticas();
container.RegisterInstance(manager, new SingletonLifetimeManager());
//Se registra service locator
ServiceLocator.SetLocatorProvider(() => unityServiceLocator);
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
PantallaPrincipal pantallaPrincipal = new PantallaPrincipal();
//pantallaPrincipal.tsbEstado
var notificador = new NotificadorBarraEstado(pantallaPrincipal.statusStrip1);
notificador.ControlMostrarMensajes = pantallaPrincipal.tsbEstado;
container.RegisterInstance <INotificador>("BarraDeEstado", notificador, new SingletonLifetimeManager());
Application.Run(pantallaPrincipal);
}
protected override void OnStartup(StartupEventArgs e)
{
base.OnStartup(e);
// 设置线程帮助类
DispatcherHelper.Initialize();
// 设置当前关闭模式
this.ShutdownMode = ShutdownMode.OnExplicitShutdown;
// 注册异常事件
this.DispatcherUnhandledException += App_DispatcherUnhandledException;
AppDomain.CurrentDomain.UnhandledException += CurrentDomain_UnhandledException;
// 注册容器
Unity.UnityContainer container = new Unity.UnityContainer();
container.RegisterType<ICommonDataManager, CommonDataManager>(new ContainerControlledLifetimeManager());
container.RegisterType<IResultDataManager, ResultDataManager>(new ContainerControlledLifetimeManager());
container.RegisterType<IPatternDataManager, PatternDataManager>(new ContainerControlledLifetimeManager());
CacheManager.Instance.UnityContainer = container;
// 获取版本信息
if (System.IO.File.Exists(CommonPath.ClientUpdate))
{
// 1.获取本地版本信息
CacheManager.Instance.Version = CommonPath.ClientUpdate.LoadFromXml<ClientUpdate>();
}
#if !DEBUG
this.AutoUpdate();
#endif
// 检查本地用户是否登录
OSKernel.Presentation.Login.LoginWindow login = new OSKernel.Presentation.Login.LoginWindow();
login.Closed += (s, arg) =>
{
if (login.DialogResult.Value)
{
MainWindow main = new MainWindow();
main.Show();
}
};
login.ShowDialog();
}
static void Main(string[] args)
{
Dataflow dataflow = new Dataflow();
var notifyService = new StockQuoteService(dataflow);
//=======================================================================================================
// Call this before you initialize a new BackgroundJobServer()
var container = new Unity.UnityContainer();
GlobalConfiguration.Configuration.UseActivator(new UnityJobActivator(container));
container.RegisterInstance <IDataflow>(dataflow);
container.RegisterInstance <INotifyService>(notifyService);
//=======================================================================================================
JobStorage storage = new MemoryStorage(new MemoryStorageOptions());
LogProvider.SetCurrentLogProvider(new ColouredConsoleLogProvider());
var serverOptions = new BackgroundJobServerOptions()
{
ShutdownTimeout = TimeSpan.FromSeconds(5)
};
var server = new BackgroundJobServer(serverOptions, storage);
JobStorage.Current = storage;
Log("Hangfire Server started. Press any key to exit...", LogLevel.Fatal);
//=======================================================================================================
//ServiceHost host = new ServiceHost(typeof(StockQuoteService), new Uri("http://localhost:12345/StockQuoteService.svc"));
//host.Open();
var host = new ServiceHost(typeof(StockQuoteService), new Uri("http://localhost:12345/StockQuoteService.svc"));
//object instanceService = Activator.CreateInstance(typeof(StockQuoteService), dataflow);
//IServiceBehavior instanceBehavior = Activator.CreateInstance(typeof(StockQuoteServiceBehavior), instanceService) as IServiceBehavior;
object instanceService = Activator.CreateInstance(typeof(StockQuoteService), dataflow);
IServiceBehavior instanceBehavior = Activator.CreateInstance(typeof(StockQuoteServiceBehavior), notifyService) as IServiceBehavior;
host.Description.Behaviors.Add(instanceBehavior);
host.Open();
SesionSocketRunConsole.Start();
//=======================================================================================================
BackgroundJob.Enqueue <JobTest>(x => x.Execute("Hello, world!"));
//=======================================================================================================
Console.WriteLine("Enter to exit ...");
Console.ReadLine();
}
/// <summary>
/// Create a <see cref="UnityContainer"/> with the given parent container.
/// </summary>
/// <param name="parent">The parent <see cref="UnityContainer"/>. The current object
/// will apply its own settings first, and then check the parent for additional ones.</param>
private UnityContainer(UnityContainer parent)
{
this.parent = parent;
if (parent != null)
{
parent.lifetimeContainer.Add(this);
}
InitializeBuilderState();
// Put a noop at the beginning of each of our events so we don't have to worry
// about nulls
Registering += delegate { };
RegisteringInstance += delegate { };
ChildContainerCreated += delegate { };
// Every container gets the default behavior
this.AddExtension(new UnityDefaultBehaviorExtension());
#pragma warning disable 618
this.AddExtension(new InjectedMembers());
#pragma warning restore 618
}
public ExtensionContextImpl(UnityContainer container)
{
this.container = container;
}
public IUnityContainer CreateChildContainer()
{
var child = new UnityContainer(this);
// Ariel
if (this.AlternativeServiceProvider != null)
{
child.AlternativeServiceProvider = this.AlternativeServiceProvider;
}
var childContext = new ExtensionContextImpl(child);
ChildContainerCreated(this, new ChildContainerCreatedEventArgs(childContext));
return child;
}
protected override IServiceLocator CreateServiceLocator()
{
IUnityContainer container = new UnityContainer()
.RegisterType<ILogger, AdvancedLogger>()
.RegisterType<ILogger, SimpleLogger>(typeof(SimpleLogger).FullName)
.RegisterType<ILogger, AdvancedLogger>(typeof(AdvancedLogger).FullName);
return new UnityServiceLocator(container);
}
protected override IServiceProvider CreateServiceProvider(IServiceCollection serviceCollection)
{
var container = new UnityContainer();
Configuration.Register(serviceCollection, container);
return container.Resolve<IServiceProvider>();
}
