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());
}
