public static void Register(HttpConfiguration config) { // Web API configuration and services // Configure Web API to use only bearer token authentication. config.SuppressDefaultHostAuthentication(); config.Filters.Add(new HostAuthenticationFilter(OAuthDefaults.AuthenticationType)); //Unity var container = new UnityContainer(); container.RegisterType<IUnitOfWork, UnitOfWork>(new HierarchicalLifetimeManager()); container.RegisterType<IGenericRepository<Farmacia>, GenericRepository<Farmacia>>(new HierarchicalLifetimeManager()); config.DependencyResolver = new UnityResolver(container); //Formatters config.Formatters.JsonFormatter.SupportedMediaTypes.Add(new MediaTypeHeaderValue("text/html")); //GlobalConfiguration.Configuration.Formatters.XmlFormatter.SupportedMediaTypes.Clear(); //config.Formatters.Insert(0, new System.Net.Http.Formatting.JsonMediaTypeFormatter()); // Web API routes config.MapHttpAttributeRoutes(); //config.EnableCors(); var cors = new EnableCorsAttribute("http://localhost:28285", "*", "*"); config.EnableCors(cors); config.Routes.MapHttpRoute( name: "DefaultApi", routeTemplate: "api/{controller}/{id}", defaults: new { id = RouteParameter.Optional } ); }
protected void Page_Load(object sender, EventArgs e) { IUnityContainer container = new UnityContainer(); UnityConfigurationSection section = (UnityConfigurationSection)ConfigurationManager.GetSection("unity"); section.Configure(container); if (Request["installation"] != null) { int installationid = Int32.Parse(Request["installation"]); userid = Int32.Parse(Request["userid"]); user = Request["user"]; sservice = container.Resolve<IStatisticService>(); IInstallationBL iinstall = container.Resolve<IInstallationBL>(); imodel = iinstall.getInstallation(installationid); Dictionary<InstallationModel, List<InstallationState>> statelist = sservice.getInstallationState(imodel.customerid); StringBuilder str = new StringBuilder(); str.Append("<table border = '1'><tr><th>Description</th><th>Messwert</th><th>Einheit</th></tr>"); foreach (var values in statelist) { if(values.Key.installationid.Equals(installationid)) { foreach (var item in values.Value) { str.Append("<tr><td>" + item.description + "</td><td>" + item.lastValue + "</td><td>" + item.unit + "</td></tr>"); } break; } } str.Append("</table>"); anlagenzustand.InnerHtml = str.ToString(); } }
public static void Register(HttpConfiguration config) { // Dependency resolver for dependency injection UnityContainer container = new UnityContainer(); container.RegisterType<IResearchRepository, ResearchRepository>(new HierarchicalLifetimeManager()); container.RegisterType<IProjectsRepository, ProjectsRepository>(new HierarchicalLifetimeManager()); container.RegisterType<IReferencesRepository, ReferencesRepository>(new HierarchicalLifetimeManager()); config.DependencyResolver = new UnityResolver(container); config.MapHttpAttributeRoutes(); // API routes config.Routes.MapHttpRoute( name: "DefaultApi", routeTemplate: "api/{controller}/{id}", defaults: new { id = RouteParameter.Optional }); //OData Models ODataModelBuilder odataBuilder = new ODataConventionModelBuilder(); odataBuilder.Namespace = "SpResearchTracker.Models"; odataBuilder.EntitySet<Project>("Projects"); odataBuilder.EntitySet<Reference>("References"); // OData routes config.Routes.MapODataRoute( routeName: "odata", routePrefix: "odata", model: odataBuilder.GetEdmModel(), batchHandler: new BreezeODataBatchHandler(GlobalConfiguration.DefaultServer)); }
private static IUnityContainer BuildUnityContainer() { var container = new UnityContainer(); container.LoadConfiguration(); return container; }
private static void RegisterConventions(Microsoft.Practices.Unity.UnityContainer container, IEnumerable <Assembly> assemblies = null) { foreach (var type in GetClassesFromAssemblies(assemblies)) { IEnumerable <Type> interfacesToBeRegsitered = GetInterfacesToBeRegistered(type); AddToInternalTypeMapping(type, interfacesToBeRegsitered); } foreach (KeyValuePair <Type, HashSet <Type> > typeMapping in InternalTypeMapping) { if (typeMapping.Value.Count == 1) { var type = typeMapping.Value.First(); container.RegisterType(typeMapping.Key, type); } else { foreach (var type in typeMapping.Value) { container.RegisterType(typeMapping.Key, type, GetNameForRegistration(type)); } } } }
public static void Resolve(UnityContainer container) { container.RegisterType<DataBaseContext, DataBaseContext>(new HierarchicalLifetimeManager()); container.RegisterType<IUsuarioService, UsuarioService>(new HierarchicalLifetimeManager()); container.RegisterType<IUsuarioRepository, UsuarioRepository>(new HierarchicalLifetimeManager()); container.RegisterType<IPermissaoRepository, PermissaoRepository>(new HierarchicalLifetimeManager()); container.RegisterType<IGrupoPermissaoRepository, GrupoPermissaoRepository>(new HierarchicalLifetimeManager()); container.RegisterType<IAutenticacao, AutenticacaoService>(new HierarchicalLifetimeManager()); container.RegisterType<IPessoaService, PessoaService>(new HierarchicalLifetimeManager()); container.RegisterType<IPessoaRepository, PessoaRepository>(new HierarchicalLifetimeManager()); container.RegisterType<IPapelRepository, PapelRepository>(new HierarchicalLifetimeManager()); container.RegisterType<IPessoaFisicaRepository, PessoaFisicaRepository>(new HierarchicalLifetimeManager()); container.RegisterType<IPessoaJuridicaRepository, PessoaJuridicaRepository>(new HierarchicalLifetimeManager()); container.RegisterType<IMeioComunicacaoRepository, MeioComunicacaoRepository>(new HierarchicalLifetimeManager()); container.RegisterType<IEnderecoRepository, EnderecoRepository>(new HierarchicalLifetimeManager()); container.RegisterType<IEstadoCivilRepository, EstadoCivilRepository>(new HierarchicalLifetimeManager()); container.RegisterType<IEstadoRepository, EstadoRepository>(new HierarchicalLifetimeManager()); container.RegisterType<IProdutoService, ProdutoService>(new HierarchicalLifetimeManager()); container.RegisterType<IProdutoRepository, ProdutoRepository>(new HierarchicalLifetimeManager()); container.RegisterType<IUnidadeRepository, UnidadeRepository>(new HierarchicalLifetimeManager()); container.RegisterType<ICondicaoPagamentoService, CondicaoPagamentoService>(new HierarchicalLifetimeManager()); container.RegisterType<IFormaPagamentoService, FormaPagamentoService>(new HierarchicalLifetimeManager()); container.RegisterType<ICondicaoPagamentoRepository, CondicaoPagamentoRepository>(new HierarchicalLifetimeManager()); container.RegisterType<IFormaPagamentoRepository, FormaPagamentoRepository>(new HierarchicalLifetimeManager()); //container.RegisterType<User, User>(new HierarchicalLifetimeManager()); }
static void Main() { Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); using (IUnityContainer container = new UnityContainer()) { container .RegisterType<IStocksTickerView, StocksTickerForm>() .RegisterType<IStockQuoteService, RandomStockQuoteService>( new InjectionProperty("Logger")) .RegisterType<ILogger, ConsoleLogger>() .RegisterType<ILogger, TraceSourceLogger>( "UI", new ContainerControlledLifetimeManager(), new InjectionConstructor("UI")) .RegisterType<StocksTickerPresenter>( new InjectionProperty( "Logger", new ResolvedParameter<ILogger>("UI"))); StocksTickerPresenter presenter = container.Resolve<StocksTickerPresenter>(); Application.Run((Form)presenter.View); } }
public static void RegisterComponents() { var container = new UnityContainer(); // register all your components with the container here // it is NOT necessary to register your controllers // e.g. container.RegisterType<ITestService, TestService>(); GlobalConfiguration.Configuration.DependencyResolver = new UnityDependencyResolver(container); // repositories injection container.RegisterType<IRepository<Item, int>, ItemRepository>(); container.RegisterType<IRepository<Category, int>, CategoryRepository>(); container.RegisterType<IRepository<Reservation, int>, ReservationRepository>(); container.RegisterType<IRepository<Image, int>, ImageRepository>(); // authentication injection container.RegisterType<DbContext, ReservationContext>(new HierarchicalLifetimeManager()); container.RegisterType<UserManager<User>, ApplicationUserManager>(); container.RegisterType<ReservationContext>(new HierarchicalLifetimeManager()); container.RegisterType<ApplicationUserManager>(); container.RegisterType<ISecureDataFormat<AuthenticationTicket>, SecureDataFormat<AuthenticationTicket>>(); container.RegisterType<ITextEncoder, Base64TextEncoder>(); container.RegisterType<IDataSerializer<AuthenticationTicket>, TicketSerializer>(); container.RegisterType<IDataProtector>(new InjectionFactory(o => new DpapiDataProtectionProvider().Create("ASP.NET Identity"))); container.RegisterType<IUserStore<User>, UserStore<User>>(new InjectionConstructor(typeof(ReservationContext))); container.RegisterType<IAuthenticationManager>(new InjectionFactory(o => HttpContext.Current.GetOwinContext().Authentication)); container.RegisterType<IOwinContext>(new InjectionFactory(o => HttpContext.Current.GetOwinContext())); }
private static IUnityContainer BuildUnityContainer() { var container = new UnityContainer(); container.RegisterType<IHomeService, HomeService>(); MvcUnityContainer.Container = container; return container; }
static void Main(string[] args) { IUnityContainer container = new UnityContainer(); UnityApplicationFrameworkDependencyResolver resolver = new UnityApplicationFrameworkDependencyResolver(container); resolver.UseCore(defaultTraceLoggerMinimumLogLevel: LogLevelEnum.Verbose); IAsynchronousBackoffPolicy policy = resolver.Resolve<IAsynchronousBackoffPolicy>(); CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(); Task.Run(async () => { try { await policy.ExecuteAsync(BackoffTask, cancellationTokenSource.Token); } catch (Exception ex) { Console.WriteLine(ex.Message); } }); Console.WriteLine("Press a key to finish..."); Console.ReadKey(); cancellationTokenSource.Cancel(); }
public void TryResolveShouldReturnNullIfElementNotExist() { var container = new UnityContainer(); object dependantA = container.TryResolve<IDependantA>(); Assert.IsNull(dependantA); }
private IUnityContainer CreateUnityContainer() { var container = new UnityContainer(); UnityConfigurationSection section = (UnityConfigurationSection)System.Configuration.ConfigurationManager.GetSection("unity"); section.Configure(container); return container; }
private static IUnityContainer BuildUnityContainer() { var container = new UnityContainer(); // Register repository. container.RegisterType<IMyBigBroRepository, MyBigBroRepository>( new InjectionConstructor(new MyBigBroContext(GetConnectionString()))); // Register services. container.RegisterType<ILocation, Location>(); container.RegisterType<IStorageServiceAgent, AzureStorageServiceAgent>(); container.RegisterType<ILocation, Location>(); container.RegisterType<IWebCamControl, WebCamControl>(); container.RegisterType<IGeoMarkerService, GeoMarkerService>(); container.RegisterType<IAccountService, AccountService>(); container.RegisterType<IFormsAuthenticationService, FormsAuthenticationService>(); // Register Web API controllers. //container.RegisterType<LoginController>(); container.RegisterType<GeoMarkersController>(); container.RegisterType<CapturedImagesGeoMarkerController>(); container.RegisterType<WebCamsController>(); // Return the populated container. return container; }
public void TryResolveWorksWithValueTypes() { var container = new UnityContainer(); int valueType = container.TryResolve<int>(); Assert.AreEqual(default(int), valueType); }
internal static IUnityContainer GetContainer() { var container = new UnityContainer(); container.RegisterType<IHttpClient, HttpClient>(); container.RegisterType<IPreferences, Preferences>(); container.RegisterType<IRepository, SQLiteRepository>(Constants.Injection.SQLITE_STORE); container.RegisterType<IRepository, InMemoryQueue>(Constants.Injection.VOLATILE_STORE); container.RegisterType<INetworkStateService, NetworkStateService>(); container.RegisterType<INamedWaitHandle, NamedWaitHandle>(); container.RegisterType<IAutoResetEventAdapter, AutoResetEventAdapter>(); container.RegisterType<IStoreService, StoreService>(); container.RegisterType<IForwardService, ForwardService>(); container.RegisterType<IEncryptionChecker, EncryptionChecker>(); container.RegisterType<INetwork, Network>(); container.RegisterType<IConnectionManager, ConnectionManager>(); container.RegisterType<IPowerManager, PowerManager>(); container.RegisterType<IConnectionInfo, ConnectionInfo>(); container.RegisterType<IBlackoutTime, BlackoutTime>(); container.RegisterType<IWebRequest, ReynaWebRequest>(); container.RegisterType<INetworkInterfaceWrapper, NetworkInterfaceWrapper>(); container.RegisterType<INetworkInterfaceWrapperFactory, NetworkInterfaceWrapperFactory>(); container.RegisterType<IMbnInterfaceManagerWrapper, MbnInterfaceManagerWrapper>(); container.RegisterType<IPowerStatusWrapper, PowerStatusWrapper>(); container.RegisterType<IRegistry, Registry>(); container.RegisterType<IBatchConfiguration, BatchConfiguration>(); container.RegisterType<IPeriodicBackoutCheck, RegistryPeriodicBackoutCheck>(); container.RegisterType<IMessageProvider, BatchProvider>(Constants.Injection.BATCH_PROVIDER); container.RegisterType<IMessageProvider, MessageProvider>(Constants.Injection.MESSAGE_PROVIDER); container.RegisterType<ITime, Time>(); container.RegisterInstance<IReynaLogger>(new ReynaLogger()); return container; }
private static void SetupUnity() { IUnityContainer container = new UnityContainer(); GetReal(container); //call GetReal for release. //container.RegisterType<IUnitOfWork, UnitOfWork>() ControllerBuilder.Current.SetControllerFactory(new UnityControllerFactory(container)); }
public static string LoginUser(string username, string password, string response) { string result = string.Empty; try { if (!IsRobot(response)) { IUnityContainer container = new UnityContainer(); container.RegisterType<AccountMgr>(); container.RegisterType<IAccountDacMgr, AccountDacMgr>(); AccountMgr accountMgr = container.Resolve<AccountMgr>(); accountMgr.UserName = username; accountMgr.Password = password; if (accountMgr.Login()) { FormsAuthentication.SetAuthCookie(accountMgr.UserName, false); result = "OK"; } } } catch { throw; } return result; }
public void Test() { using (var container = new UnityContainer()) { container.RegisterType<ITestClass, TestClass>(); container.AddNewExtension<LazyExtension>(); var testClass1 = container.Resolve<Lazy<ITestClass>>(); Assert.AreEqual(false, testClass1.IsValueCreated); Assert.AreEqual(0, TestClass.InstanceCount); Assert.AreEqual(5, testClass1.Value.HighFive()); Assert.AreEqual(true, testClass1.IsValueCreated); Assert.AreEqual(1, TestClass.InstanceCount); var testClass2 = container.Resolve<Lazy<ITestClass>>(); Assert.AreEqual(false, testClass2.IsValueCreated); Assert.AreEqual(1, TestClass.InstanceCount); Assert.AreEqual(5, testClass2.Value.HighFive()); Assert.AreEqual(true, testClass2.IsValueCreated); Assert.AreEqual(2, TestClass.InstanceCount); } }
private UnityContainer RegisterUnityContainer() { var container = new UnityContainer(); container.LoadConfiguration(); return container; }
public static void Register(HttpConfiguration config) { // Web API configuration and services registration var container = new UnityContainer(); var dataAccessRegistration = new DataAccessRegistration(); var repositoryRegistation = new RepositoryRegistration(); var serviceRegistration = new ServiceRegistration(); dataAccessRegistration.Register(container); repositoryRegistation.Register(container); serviceRegistration.Register(container); config.DependencyResolver = new UnityResolver(container); config.Formatters.JsonFormatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver(); config.Formatters.JsonFormatter.UseDataContractJsonSerializer = false; // Web API routes config.MapHttpAttributeRoutes(); config.Routes.MapHttpRoute( name: "DefaultApi", routeTemplate: "api/{controller}/{id}", defaults: new { id = RouteParameter.Optional } ); }
private static IUnityContainer BuildUnityContainer() { var container = new UnityContainer(); ConnectionStringSettings connectionStringSettings = ConfigurationManager.ConnectionStrings["WhaConnection"]; string providerName = connectionStringSettings.ProviderName; string connectionString = connectionStringSettings.ConnectionString; DbProviderFactory databaseProviderFactory = DbProviderFactories.GetFactory(providerName); container.RegisterInstance(databaseProviderFactory); // e.g. container.RegisterType<ITestService, TestService>(); //container.Register(c => new KiggDbFactory(c.Resolve<DbProviderFactory>(), connectionString)).As<IKiggDbFactory>().InstancePerLifetimeScope(); //container.Register(c => new QueryFactory(c.Resolve<IKiggDbFactory>(), true)).As<IQueryFactory>().SingleInstance(); container.RegisterInstance<IWhaDbFactory>(new WhaDbFactory(databaseProviderFactory, connectionString));//.As<IWhaDbFactory>().InstancePerLifetimeScope(); //container.RegisterType<IWhaDbFactory, WhaDbFactory>(); container.RegisterType<IQueryFactory, QueryFactory>(); container.RegisterType<ITourRepository, TourRepository>(); container.RegisterType<ILocationRepository, LocationRepository>(); return container; }
private static void Main(string[] args) { #if DEBUG args = new[] {@"C:\GitHUB-Applications\GlobalX-Test\NameSort\NameSort\InputFile\names.txt"}; #endif string inputFileUrl = args[0]; string outputFileUrl = string.Format("{0}\\{1}", Path.GetDirectoryName(inputFileUrl), "names-sorted.txt"); try { IUnityContainer unitycontainer = new UnityContainer(); unitycontainer.RegisterType<ISortData, SortData>(); unitycontainer.RegisterType<ITextFile, TextFile>(); var nameSort = unitycontainer.Resolve<TextFileNameSort>(); IEnumerable<Name> data = nameSort.Read(inputFileUrl); IEnumerable<Name> sortedData = nameSort.Sort(data); IList<Name> sortedDataCollection = sortedData as IList<Name> ?? sortedData.ToList(); nameSort.Save(sortedDataCollection, outputFileUrl); sortedDataCollection.ForEach(n => Console.WriteLine(n.ToString())); Console.Write("Finished: created {0}", outputFileUrl); } catch (Exception ex) { Console.WriteLine(ex.Message); } Console.ReadKey(); }
public App() { try { IUnityContainer unityContainer = new UnityContainer(); var connectionString = System.Configuration.ConfigurationSettings.AppSettings.Get("webService"); IWebservice webService = new Webservice(connectionString); EventAggregator eventAggregator = new EventAggregator(); unityContainer.RegisterInstance<IEventAggregator>(eventAggregator); unityContainer.RegisterInstance<IWebservice>(webService); IMessaging emailMessenger = new EmailMessaging(); unityContainer.RegisterInstance<IMessaging>(emailMessenger); var regionManager = new RegionManager(); regionManager.Regions.Add(new Region() { Name = "MainContentRegion" }); unityContainer.RegisterInstance<IRegionManager>(regionManager); ServiceLocator.SetLocatorProvider(() => new UnityServiceLocator(unityContainer)); } catch (Exception ex) { logger.Error("Error in app constructor", ex); } }
static void Main(string[] args) { using (UnityContainer container = new UnityContainer()) { ContainerBootstrapper.RegisterTypes(container); Application consoleApp = new Application(); consoleApp.Title = "WELCOME! This program will help you test the Files REST service."; foreach (string commandType in new string[] { "UploadCommand", "GetAllMetadataCommand", "GetMetadataCommand", "DownloadAllCommand", "DownloadCommand", "DeleteCommand", "SettingsCommand" }) { Commands.BaseCommand command = container.Resolve<Commands.BaseCommand>(commandType); consoleApp.AddCommand(command); } Starter.Start(consoleApp); } }
private void App_OnStartup(object sender, StartupEventArgs e) { using (UnityContainer container = new UnityContainer()) { // Load settings int discoveryPort = WiDroid.Properties.Settings.Default.DiscoveryPort; // Create Unity container and load all types container.RegisterType<MainViewModel>(); container.RegisterType<SettingsViewModel>(new InjectionProperty("DiscoveryPort", discoveryPort), new InjectionProperty("SettingsCurrentState", SettingsViewModel.SettingsState.Default)); container.RegisterType<FileTransferViewModel>(); // Start client discovery server ClientDiscoveryServer.ClientDiscoveryServer discoveryServer = new ClientDiscoveryServer.ClientDiscoveryServer(discoveryPort); discoveryServer.Start(); // Show main window MainWindow mainWindow = new MainWindow(); MainViewModel mainViewModel = container.Resolve<MainViewModel>(); mainWindow.DataContext = mainViewModel; mainWindow.ViewModel = mainViewModel; FlowManager.Instance.AppWindow = mainWindow; FlowManager.Instance.ViewModelContainer = container; mainWindow.Show(); } }
static async Task AsyncMain() { #region ContainerConfiguration BusConfiguration busConfiguration = new BusConfiguration(); busConfiguration.EndpointName("Samples.Unity"); UnityContainer container = new UnityContainer(); container.RegisterInstance(new MyService()); busConfiguration.UseContainer<UnityBuilder>(c => c.UseExistingContainer(container)); #endregion busConfiguration.UseSerialization<JsonSerializer>(); busConfiguration.UsePersistence<InMemoryPersistence>(); busConfiguration.EnableInstallers(); busConfiguration.SendFailedMessagesTo("error"); IEndpointInstance endpoint = await Endpoint.Start(busConfiguration); try { IBusSession busSession = endpoint.CreateBusSession(); await busSession.SendLocal(new MyMessage()); Console.WriteLine("Press any key to exit"); Console.ReadKey(); } finally { await endpoint.Stop(); } }
public void InjectClassWithTwoConstructors() { int myInt = 37; string myStr = "Test"; IUnityContainer container = new UnityContainer(); //constructor without params container.Configure<InjectedMembers>().ConfigureInjectionFor<TestClass>(new InjectionConstructor()); TestClass withOutCon = container.Resolve<TestClass>(); Assert.IsFalse(withOutCon.StringConstructorCalled); Assert.IsFalse(withOutCon.IntConstructorCalled); //constructor with one param container.Configure<InjectedMembers>() .ConfigureInjectionFor<TestClass>("First", new InjectionConstructor(myInt)); TestClass myTestClass = container.Resolve<TestClass>("First"); Assert.IsFalse(myTestClass.StringConstructorCalled); Assert.IsTrue(myTestClass.IntConstructorCalled); //constructor with one param container.Configure<InjectedMembers>() .ConfigureInjectionFor<TestClass>("Second", new InjectionConstructor(myStr)); TestClass myTestClass1 = container.Resolve<TestClass>("Second"); Assert.IsFalse(myTestClass1.IntConstructorCalled); Assert.IsTrue(myTestClass1.StringConstructorCalled); }
public static void Register(HttpConfiguration config) { // Web API configuration and services // var container = new UnityContainer(); //Service registration container.RegisterType<ITestService, TestService>(new HierarchicalLifetimeManager()); //Data repository registration container.RegisterType<ITestRepo, TestRepo>(new HierarchicalLifetimeManager()); config.DependencyResolver = new UnityDiResolver(container); // Web API routes - attribute routing // config.MapHttpAttributeRoutes(); // Web API routes - conventional routing config.Routes.MapHttpRoute( name: "DefaultApi", routeTemplate: "api/{controller}/{id}", defaults: new { id = RouteParameter.Optional } ); }
private void RegisterUnityContainer() { var container = new UnityContainer(); container.RegisterType<IPkgOrderService, PkgOrderService>(new PerThreadLifetimeManager()) .RegisterType<IDALContext, PkgOrderDALContext>(); DependencyResolver.SetResolver(new UnityDependencyResolver(container)); }
public void Register(UnityContainer container) { container .ConfigureAutoRegistration() .Include(x => x.Assembly == Assembly.GetExecutingAssembly(), Then.Register().AsAllInterfacesOfType().UsingPerCallMode()) .ApplyAutoRegistration(); }
/// <summary> /// Application Entry Point /// </summary> protected void Application_Start() { AreaRegistration.RegisterAllAreas(); WebApiConfig.Register(GlobalConfiguration.Configuration); FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters); RouteConfig.RegisterRoutes(RouteTable.Routes); BundleConfig.RegisterBundles(BundleTable.Bundles); //************************************************************* AppDomain.CurrentDomain.UnhandledException += delegate(object sender, UnhandledExceptionEventArgs e) { Logging.LogManagerProvider.Instance.WriteError(e.ExceptionObject as Exception); }; //logging initialization Logging.LogManagerProvider.Initialize("LoggingSection"); //Repository and controller initialization UnityContainer container = new UnityContainer(); RepositoryProvider.Register(container, "RepositoryProvider"); GlobalConfiguration.Configuration.DependencyResolver = new Unity.WebApi.UnityDependencyResolver(container); //************************************************************* }
private static void CriarContainer() { _unityContainer = new Microsoft.Practices.Unity.UnityContainer(); _unityContainer .RegisterType <IGaleryCreator, GaleryCreator> (new HttpContextLifetimeManager <IGaleryCreator>()) .RegisterType <IImagesRepository, ImagesRepository> (new HttpContextLifetimeManager <IImagesRepository>()); }
static void Main(string[] args) { string cpf = "05039162693"; CultureInfo ci = new CultureInfo("pt-BR"); Thread.CurrentThread.CurrentCulture = ci; Thread.CurrentThread.CurrentUICulture = ci; var container = new Microsoft.Practices.Unity.UnityContainer(); DependencyResolver.Resolve(container); var service = container.Resolve <IClientAppService>(); #region Salvar try { //List<Phone> listPhones = new List<Phone> //{ // new Phone {ClientId = 3, Number = "1111"}, // new Phone {ClientId = 3, Number = "2222"}, // new Phone {ClientId = 3, Number = "3333"} //}; //Client client = new Client(cpf, "Rua Nogueira de Paiva, 30 Casa 09", "Jean Tadeu Ferreira", "*****@*****.**", MaritalStatus.Single, null); //service.Register(client); } catch (Exception ex) { Console.WriteLine(ex.Message); } #endregion try { var clients = service.GetAll(); foreach (var c in clients) { Console.WriteLine(c.Name + "\t" + c.Address); } } catch (Exception ex) { Console.WriteLine(ex.Message); } Console.ReadKey(); }
public static IUnityContainer BuildUnityContainer() { Microsoft.Practices.Unity.UnityContainer container = new Microsoft.Practices.Unity.UnityContainer(); container.RegisterType <ITestService, TestService>(); container.RegisterType <IUserService, UserService>(); container.RegisterType <IRoleService, RoleService>(); container.RegisterType <ITestResultService, TestResultService>(); container.RegisterType <IAnswerService, AnswerService>(); container.RegisterType <IQuestionService, QuestionService>(); UnityBllConfig.BuildUnityBllContainer(container); return(container); }
public static void Initialize() { var container = new Microsoft.Practices.Unity.UnityContainer(); GlobalConfiguration.Configuration.DependencyResolver = new QMailer.UnityDependencyResolver(container); GlobalConfiguration.Configuration.FullUrl = "http://localhost"; GlobalConfiguration.Configuration.SenderEmail = "*****@*****.**"; GlobalConfiguration.Configuration.SenderName = "TestEmail"; var existingBus = container.Resolve <Ariane.IServiceBus>(); container.RegisterType <Ariane.IServiceBus, Ariane.SyncBusManager>(new ContainerControlledLifetimeManager(), new InjectionConstructor(existingBus)); var bus = container.Resolve <Ariane.IServiceBus>(); bus.Register.AddQueue(new QueueSetting() { AutoStartReading = true, Name = GlobalConfiguration.Configuration.EmailBodyRequestedQueueName, TypeMedium = typeof(Ariane.InMemoryMedium), TypeReader = typeof(QMailer.Web.EmailBodyRequestedMessageReader) }); bus.Register.AddQueue(new QueueSetting() { AutoStartReading = true, Name = GlobalConfiguration.Configuration.SendEmailQueueName, TypeMedium = typeof(Ariane.InMemoryMedium), TypeReader = typeof(QMailer.SendEmailMessageReader) }); QMailerService.ReplaceBusService(bus); QMailer.Web.QMailerConfig.Configure(container); var viewEngines = new Moq.Mock <ViewEngineCollection>(); var fakeView = new FakeView(); viewEngines.Setup(i => i.FindView(Moq.It.IsAny <ControllerContext>(), "test", null)) .Returns(new ViewEngineResult(fakeView, Moq.Mock.Of <IViewEngine>())); var fakeRenderer = new QMailer.Web.EmailViewRenderer(viewEngines.Object, "http://localhost", "~/emailviews"); container.RegisterInstance <QMailer.Web.IEmailViewRenderer>(fakeRenderer, new ContainerControlledLifetimeManager()); container.RegisterType <QMailer.ILogger, QMailer.DiagnosticsLogger>(new ContainerControlledLifetimeManager()); }
public void DataBaseCreateTest() { this.unityContainer = new UnityContainer(); ServiceLocator.Initialize( (x, y) => this.unityContainer.RegisterType(x, y), (x, y) => this.unityContainer.RegisterInstance(x, y), (x) => { return(this.unityContainer.Resolve(x)); }, (x) => { return(this.unityContainer.ResolveAll(x)); }); // Context Factory connString = this.ConnectionString(); RootAggregateFrameworkUnitOfWorkFactory <Atento.Suite.Shared.Infrastructure.BootstrapUnitOfWork> ctxFactory = new RootAggregateFrameworkUnitOfWorkFactory <BootstrapUnitOfWork>(connString); if (!ctxFactory.DatabaseExists()) { ctxFactory.CreateDatabase(); } Assert.AreEqual(true, ctxFactory.DatabaseExists()); }// end data base create
public void TestInit() { // IoCcontainer anlegen IoCContainer = new Microsoft.Practices.Unity.UnityContainer(); // Typen im IOC Container registrieren // Achtung: Mock.User hat zwei Konstruktoren. Mittels Attribut InjectionController // wird einer für die DI- ausgewählt IoCContainer.RegisterType <IUser, Mocks.User>(new InjectionConstructor("unbekannt")); IoCContainer.RegisterType <ICanvasScript, Mocks.CanvasScript>(); // Achtung: die Repositorys sollen als Singletons ausgewählt werden. Dazu ist ein spezieller // Lifetime- Manager zu setzen // https://msdn.microsoft.com/de-de/library/dn178463(v=pandp.30).aspx#_Lifetime_Management IoCContainer.RegisterType <UserRepository, Mocks.UsersRepository>(new Microsoft.Practices.Unity.ContainerControlledLifetimeManager()); IoCContainer.RegisterType <CanvasScriptRepository, Mocks.CanvasScriptsRepository>(new Microsoft.Practices.Unity.ContainerControlledLifetimeManager()); IoCContainer.RegisterType <ICanvasScriptServerUnitOfWork, Mocks.CanvasScriptServerUnitOfWork>(); }
/// <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 void Register(ref Microsoft.Practices.Unity.UnityContainer container) { container.RegisterType <Context, Context>(new HierarchicalLifetimeManager()); }
private static void Main(string[] args) { DoStuff(); Console.WriteLine(); DoAnotherStuff(); Console.WriteLine(); DoMoreStuff(); Console.WriteLine(); DoBetterStuff(); Console.WriteLine(); InterceptedViaInjection(); Console.WriteLine(); #region Autofac adapter demo // autofac container var afContainerBuilder = new ContainerBuilder(); afContainerBuilder .RegisterType <InterceptorForContainer>() .As <ITypedInterceptor>(); var afContainer = afContainerBuilder.Build(); // cop adapter var afCopAdapter = new CodeCop.Setup.Autofac.AutofacContainerAdapter(afContainer); #endregion #region Castle.Windsor adapter demo var cwContainer = new WindsorContainer(); cwContainer.Register( Component .For <ITypedInterceptor>() .ImplementedBy <InterceptorForContainer>() ); var cwCopAdapter = new CodeCop.Setup.Castle.Windsor.CastleWindsorContainerAdapter(cwContainer); #endregion #region Ninject adapter demo var nContainer = new StandardKernel(); nContainer .Bind <ITypedInterceptor>() .To <InterceptorForContainer>(); var nCopAdapter = new CodeCop.Setup.Ninject.NinjectContainerAdapter(nContainer); #endregion #region StructureMap adapter demo var smContainer = new global::StructureMap.Container(); smContainer .Configure(c => { c.For <ITypedInterceptor>() .Use <InterceptorForContainer>(); }); var smCopAdapter = new CodeCop.Setup.StructureMap.StructureMapContainerAdapter(smContainer); #endregion #region Unity adapter demo var uContainer = new Microsoft.Practices.Unity.UnityContainer(); uContainer.RegisterType <ITypedInterceptor, InterceptorForContainer>(); var uCopAdapter = new CodeCop.Setup.Unity.UnityContainerAdapter(uContainer); #endregion Setup .Build(afCopAdapter) // pass the adapter .InterceptMethodIn <Program>(nameof(DoStuff), Intercept.Before, ctx => { Console.WriteLine("InterceptOn.Before > DoStuff !"); return(null); }) .InterceptMethodIn <Program>(nameof(DoAnotherStuff), new MyInterceptor()) .UseInterceptor(new ProgramTypedInterceptor()) .Create() .Activate(); DoStuff(); Console.WriteLine(); DoAnotherStuff(); Console.WriteLine(); DoMoreStuff(); Console.WriteLine(); DoBetterStuff(); Console.WriteLine(); InterceptedViaInjection(); Console.WriteLine(); }
public ExtensionContextImpl(UnityContainer container) { this.container = container; }
public void Register(ref Microsoft.Practices.Unity.UnityContainer container) { }
private static void SetupContainerInstance() { _containerInstance = new uc.UnityContainer(); }
public ValidateUser() { UnityContainer resolver = new Microsoft.Practices.Unity.UnityContainer(); _userServices = resolver.Resolve <UserServices>(); }
static ContainerConfiguration() { Container = new Microsoft.Practices.Unity.UnityContainer(); }
public void Register(Microsoft.Practices.Unity.UnityContainer container) { container.RegisterType <A.Core.Interfaces.IProductService, ProductService>(new HierarchicalLifetimeManager()); container.RegisterType <A.Core.Interfaces.IAddressService, AddressService>(new HierarchicalLifetimeManager()); container.RegisterType <A.Core.Interfaces.ICurrencyService, CurrencyService>(new HierarchicalLifetimeManager()); }
public void Register(ref Microsoft.Practices.Unity.UnityContainer container) { container.RegisterType <A.Core.PermissionModule.Interfaces.IPermissionChecker, PermissionChecker>(new HierarchicalLifetimeManager()); container.RegisterType <A.Core.PermissionModule.Interfaces.IPermissionService, PermissionService>(new HierarchicalLifetimeManager()); container.RegisterType <A.Core.PermissionModule.Interfaces.IRoleService, RoleService>(new HierarchicalLifetimeManager()); }