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)
{
Console.WriteLine("Registering dependencies ...");
var container = UnityResolver.RegisterServices(new UnityContainer());
int syncInterval = Convert.ToInt16(ConfigurationManager.AppSettings["SyncInterval"]);
HostFactory.Run(x =>
{
x.UseUnityContainer(container);
x.UsingQuartzJobFactory(() => new UnityJobFactory(container));
x.Service <SyncingJobService>(s =>
{
s.ConstructUsingUnityContainer();
s.WhenStarted(service => service.OnStart());
s.WhenStopped(service => service.OnStop());
s.ScheduleQuartzJob(q =>
q.WithJob(() =>
JobBuilder.Create <SyncingJob>().Build())
.AddTrigger(() =>
TriggerBuilder.Create()
.WithSimpleSchedule(b => b.WithIntervalInMinutes(syncInterval).RepeatForever()).Build())
);
});
x.RunAsLocalSystem()
.DependsOnEventLog()
.StartAutomatically()
.EnableServiceRecovery(rc => rc.RestartService(0));
x.SetServiceName(SyncingJobService.ServiceName);
x.SetDisplayName(SyncingJobService.DisplayName);
x.SetDescription(SyncingJobService.Description);
});
}
public void Create()
{
UnityResolver.Register();
IBranchManager BranchManager = UnityResolver.Resolve <IBranchManager>();
Branch branch = new Branch
{
BranchName = "TestBranch",
Address = "Panadura",
TelNo = 12,
Institute = new Common.Models.Institute {
InstituteName = "Test Institute"
}
};
bool ans = BranchManager.Create(branch);
BranchManager.Save();
Branch branch1 = BranchManager.Find(B => B.Address == "Panadura");
string expected = "Panadura";
string actual = branch1.Address;
Assert.AreEqual(expected, actual);
}
public static void Register(HttpConfiguration config)
{
//Web API configuration and services
//ReferenceLoopHandling.Ignore will solve the Self referencing loop detected error
//config.Formatters.JsonFormatter.SerializerSettings.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;
//config.EnableCors();
//Will serve json as default instead of XML
//config.Formatters.JsonFormatter.SupportedMediaTypes.Add(new MediaTypeHeaderValue("text/html"));
// Web API routes
config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute(
name: "DefaultRoute",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
config.Filters.Add(new AuthorizeAttribute());
//WebApiConfig.Register(config);
var container = new UnityContainer();
var unitySection = (UnityConfigurationSection)ConfigurationManager.GetSection("unity");
unitySection.Configure(container);
var resolver = new UnityResolver(container);
config.DependencyResolver = resolver;
}
public void ResolveTest()
{
FilePathResolver filePathResolver = new FilePathResolver("hiahia", "biabia");
TraceLogger logger = new TraceLogger(new MockUpTraceEventProvider());
using (UnityContainer container = new UnityContainer())
{
container.RegisterInstance <IFilePathResolver>(filePathResolver, new ContainerControlledLifetimeManager());
container.RegisterInstance <TraceLogger>(logger, new ContainerControlledLifetimeManager());
using (UnityResolver resolver = new UnityResolver(container))
{
for (int i = 0; i < 3; i++)
{
using (IDependencyScope dependencyScope = resolver.BeginScope())
{
object resolvedFilePathResolver = dependencyScope.GetService(typeof(IFilePathResolver));
Assert.AreSame(filePathResolver, resolvedFilePathResolver);
object resolvedLogger = dependencyScope.GetService(typeof(TraceLogger));
Assert.AreSame(logger, resolvedLogger);
}
}
}
}
}
public ActionResult Index()
{
IBranchResourceAllocationManager BranchManager = UnityResolver.Resolve <IBranchResourceAllocationManager>();
// IBranchResourceAllocationManager BranchManager = new BranchResourceAllocationManager();
return(View());
}
public static void Register(HttpConfiguration config)
{
config.SuppressDefaultHostAuthentication();
config.Filters.Add(new HostAuthenticationFilter(OAuthDefaults.AuthenticationType));
config.Filters.Add(new ApiAuthenticationFilter());
config.Filters.Add(new IdentityBasicAuthenticationAttribute());
config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
var container = new UnityContainer();
container.RegisterType <IUserServices, UserServices>();
container.RegisterType <DbContext, ApplicationDbContext>(
new HierarchicalLifetimeManager());
container.RegisterType <UserManager <ApplicationUser> >(
new HierarchicalLifetimeManager());
container.RegisterType <IUserStore <ApplicationUser>, UserStore <ApplicationUser> >(
new HierarchicalLifetimeManager());
UnityResolver unityResolver = new UnityResolver(container);
config.DependencyResolver = unityResolver;
DependencyResolver.SetResolver(unityResolver);
}
/// <summary>
/// Creates an ApplicationUserManager with default settings
/// </summary>
/// <param name="options"></param>
/// <param name="context"></param>
/// <returns></returns>
public static ApplicationUserManager Create(IdentityFactoryOptions <ApplicationUserManager> options, IOwinContext context)
{
var manager = new ApplicationUserManager(UnityResolver.Resolve <IUserStore <User, int> >());
// Configure validation logic for usernames
manager.UserValidator = new UserValidator <User, int>(manager)
{
AllowOnlyAlphanumericUserNames = false,
RequireUniqueEmail = false
};
// Configure validation logic for passwords
manager.PasswordValidator = new PasswordValidator
{
RequiredLength = 8,
RequireNonLetterOrDigit = false,
RequireDigit = false,
RequireLowercase = false,
RequireUppercase = false,
};
var dataProtectionProvider = options.DataProtectionProvider;
if (dataProtectionProvider != null)
{
manager.UserTokenProvider = new DataProtectorTokenProvider <User, int>(dataProtectionProvider.Create("ASP.NET Identity"));
}
// manager.UserTokenProvider = new UserTokenProvider<User>();
return(manager);
}
public static void Register(HttpConfiguration config)
{
// Set unity container.
var container = UnityContainerBuilder.getContainer();
var resolver = new UnityResolver(container);
config.DependencyResolver = resolver;
// Attribute routing.
config.MapHttpAttributeRoutes();
// Convention-based routing.
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
// Set message handlers.
object authenticationHandler = container.Resolve(typeof(AuthenticationHandler), null);
config.MessageHandlers.Add(authenticationHandler as AuthenticationHandler);
// Set Filters.
object exceptionFilter = container.Resolve(typeof(ExceptionFilter), null);
config.Filters.Add(exceptionFilter as ExceptionFilter);
}
public static void Register(HttpConfiguration config)
{
var container = new UnityContainer();
var resolver = new UnityResolver(container);
resolver.RegisterTypes();
config.DependencyResolver = resolver;
GlobalHost.DependencyResolver = new SignalRUnityDependencyResolver(container);
// Web API configuration and services
// Configure Web API to use only bearer token authentication.
config.SuppressDefaultHostAuthentication();
config.Filters.Add(new HostAuthenticationFilter(OAuthDefaults.AuthenticationType));
// Web API routes
config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
config.Formatters.JsonFormatter.SerializerSettings.ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Ignore;
}
public void Create()
{
UnityResolver.Register();
IBatchManager BatchManager = UnityResolver.Resolve <IBatchManager>();
Batch batch = new Batch
{
BatchName = "37Batch" + DateTime.Now.ToString(),
Branch = new Branch
{
BranchName = "TestBranch",
Institute = new Common.Models.Institute {
InstituteName = "Test Institute"
}
}
};
bool ans = BatchManager.Create(batch);
BatchManager.Save();
Batch batch1 = BatchManager.Find(B => B.BatchName == "37Batch");
string expected = "37Batch";
string actual = batch1.BatchName;
Assert.AreEqual(expected, actual);
}
public override async Task GrantResourceOwnerCredentials(OAuthGrantResourceOwnerCredentialsContext context)
{
// Allow CORS for middleware.
//context.OwinContext.Response.Headers.Add("Access-Control-Allow-Origin", new[] { "*" });
var container = new UnityResolver();
var userManager = (IUserManager)container.GetService(typeof(IUserManager));
try
{
var user = userManager.Login(new Login()
{
Email = context.UserName,
Password = context.Password,
});
var identity = new ClaimsIdentity(context.Options.AuthenticationType);
identity.AddClaim(new Claim("sub", user.Email));
identity.AddClaim(new Claim("userId", user.UserGUID));
identity.AddClaim(new Claim("role", "user"));
// Generate a token
context.Validated(identity);
}
catch (HivemindException)
{
context.SetError("invalid_grant", "The username or password is incorrect.");
return;
}
}
protected override void RegisterTypes(IContainerRegistry containerRegistry)
{
var container = containerRegistry.GetContainer();
// Register services
container.AddServices();
// Register view models
container.RegisterType <INewConnectionViewModel, NewConnectionViewModel>();
container.RegisterType <IKeyHashViewModel, KeyHashViewModel>();
container.RegisterType <IKeyListViewModel, KeyListViewModel>();
container.RegisterType <IKeySetViewModel, KeySetViewModel>();
container.RegisterType <IKeyStreamViewModel, KeyStreamViewModel>();
container.RegisterType <IKeyStringViewModel, KeyStringViewModel>();
container.RegisterType <IKeyZsetViewModel, KeyZsetViewModel>();
container.RegisterType <IKeyViewerViewModel, KeyViewerViewModel>();
container.RegisterType <IDialogWindow, NewConnectionView>(nameof(NewConnectionView));
container.RegisterType <IShellViewModel, ShellViewModel>();
// Register view for dialog services
containerRegistry.RegisterForNavigation <KeyHashView>(nameof(KeyHashView));
containerRegistry.RegisterForNavigation <KeyListView>(nameof(KeyListView));
containerRegistry.RegisterForNavigation <KeySetView>(nameof(KeySetView));
containerRegistry.RegisterForNavigation <KeyStreamView>(nameof(KeyStreamView));
containerRegistry.RegisterForNavigation <KeyStringView>(nameof(KeyStringView));
containerRegistry.RegisterForNavigation <KeyZsetView>(nameof(KeyZsetView));
containerRegistry.RegisterForNavigation <KeyViewerView>(nameof(KeyViewerView));
UnityResolver.SetContainer(container);
}
public void UnityResolver_Resolves_Registered_LogService_Test()
{
var container = new UnityContainer();
container.RegisterInstance<ILogService>(new LogService("ConnectionString", new EmailService()));
var resolver = new UnityResolver(container);
var instance = resolver.GetService(typeof(ILogService));
Assert.IsNotNull(instance);
}
public static ApplicationRoleManager Create(IdentityFactoryOptions <ApplicationRoleManager> options, IOwinContext context)
{
var manager = new ApplicationRoleManager(UnityResolver.Resolve <IRoleStore <Role, int> >());
manager.RoleValidator = new RoleValidator <Role, int>(manager);
return(manager);
}
public static UnityResolver CreateResolver()
{
var container = UnityContainerFactory.CreateContainer();
var dependancyResolver = new UnityResolver(container);
return(dependancyResolver);
}
public void UnityResolver_Resolves_Registered_PersistenceService_Test()
{
var container = new UnityContainer();
container.RegisterInstance<IPersistenceService>(new PersistenceService(_context));
var resolver = new UnityResolver(container);
var instance = resolver.GetService(typeof(IPersistenceService));
Assert.IsNotNull(instance);
}
public void UnityResolver_Resolves_Registered_Utilities_Test()
{
var container = new UnityContainer();
container.RegisterInstance<IUtilities>(new Utilities(new PersistenceService(_context),new LogService("ConnectionString", new EmailService())));
var resolver = new UnityResolver(container);
var instance = resolver.GetService(typeof(IUtilities));
Assert.IsNotNull(instance);
}
public void UnityResolver_Resolves_Registered_DBContect_Test()
{
var container = new UnityContainer();
container.RegisterInstance<IDataContext>(_context);
var resolver = new UnityResolver(container);
var instance = resolver.GetService(typeof(IDataContext));
Assert.IsNotNull(instance);
}
public void UnityResolver_DoesNot_Resolve_NonRegistered_ContactRepository_Test()
{
var container = new UnityContainer();
var resolver = new UnityResolver(container);
var instance = resolver.GetService(typeof(IContactRepository));
Assert.IsNull(instance);
}
public ReceiveContainer()
{
UnityResolver = new UnityResolver();
QueueConfig = UnityResolver.Resolve <IQueueConfig>();
ConsumerConfig = UnityResolver.Resolve <IRabbitMQConsumerConfig>();
MessageChannel = UnityResolver.Resolve <IMessageChannel>();
Display = UnityResolver.Resolve <IDisplay>();
}
public static void RegisterComponents()
{
var container = new UnityContainer();
UnityResolver.RegisterServices(container);
DependencyResolver.SetResolver(new Unity.AspNet.Mvc.UnityDependencyResolver(container));
GlobalConfiguration.Configuration.DependencyResolver = new Unity.WebApi.UnityDependencyResolver(container);
}
public void Add()
{
IItemManager ItemManager = UnityResolver.Resolve <IItemManager>();
Item i = new Item {
Id = 1, ResourceType = "vodka", ResourceDescription = "alchohol", AdditionalInfo = "Russia"
};
ItemManager.AddItem(i);
}
public void UnityResolver_DoesNot_Resolve_NonRegistered_InterfaceNotUsed_Test()
{
var container = new UnityContainer();
var resolver = new UnityResolver(container);
var instance = resolver.GetService(typeof(InterfaceNotUsed));
Assert.IsNull(instance);
}
public void UnityResolver_DoesNot_Resolve_NonRegistered_ContactRepository_Test()
{
var container = new UnityContainer();
var resolver = new UnityResolver(container);
var instance = resolver.GetService(typeof(IContactRepository));
Assert.IsNull(instance);
}
// [Authorize]
public ActionResult Create()
{
IInvoiceManger invoiceManger2 = UnityResolver.Resolve <IInvoiceManger>();
// IInvoiceManger invoiceManger = new InvoiceManger(repository, log);
// ViewBag.CustomerID = new SelectList(db.Customer, "ID", "Name");
return(View());
}
public SendContainer()
{
UnityResolver = new UnityResolver();
QueueConfig = UnityResolver.Resolve <IQueueConfig>();
PublisherConfig = UnityResolver.Resolve <IRabbitMQPublisherConfig>();
MessageChannel = UnityResolver.Resolve <IMessageChannel>();
Display = UnityResolver.Resolve <IDisplay>();
}
public async static Task ExecuteAsync()
{
var unityContainer = UnityResolver.CreateContainer();
var topicProcessor = unityContainer.Resolve <ITopicProcessor>();
var chatProcessor = unityContainer.Resolve <IChatIngestionProcessor>();
await topicProcessor.ProcessAsync();
await chatProcessor.ProcessAsync();
}
public static void ResolveDependencias()
{
// HttpConfiguration config = new HttpConfiguration();
var container = new UnityContainer();
container.RegisterType <IManipulador <DominioNotificacoes>, DominioNotificacoesManipulador>(new HierarchicalLifetimeManager());
var DependencyResolver = new UnityResolver(container);
DominioEvento.Container = new DominioEventosContainer(DependencyResolver);
}
public void UnityResolver_Resolves_Registered_ContactRepository_Test()
{
var container = new UnityContainer();
container.RegisterInstance<IContactRepository>(new InMemoryContactRepository());
var resolver = new UnityResolver(container);
var instance = resolver.GetService(typeof(IContactRepository));
Assert.IsNotNull(instance);
}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
GlobalConfiguration.Configure(WebApiConfig.Register);
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
UnityResolver.Register();
}
public void UnityResolver_Resolves_Registered_ContactRepository_Test()
{
var container = new UnityContainer();
container.RegisterInstance <IContactRepository>(new InMemoryContactRepository());
var resolver = new UnityResolver(container);
var instance = resolver.GetService(typeof(IContactRepository));
Assert.IsNotNull(instance);
}
public void UnityResolver_Resolves_Registered_PremiumPaymentGateway_Test()
{
var container = new UnityContainer();
container.RegisterInstance <IPremiumPaymentGateway>(new PremiumPaymentGateway.PremiumPaymentGateway());
var resolver = new UnityResolver(container);
var instance = resolver.GetService(typeof(IPremiumPaymentGateway));
Assert.IsNotNull(instance);
}
public void GetAll()
{
UnityResolver.Register();
IInstituteManager InstituteManager = UnityResolver.Resolve <IInstituteManager>();
List <Common.Models.Institute> list = InstituteManager.GetAll();
foreach (Common.Models.Institute institute in list)
{
Console.WriteLine("Test : " + institute.InstituteName);
}
}
public void GetAll()
{
UnityResolver.Register();
IBranchManager BranchManager = UnityResolver.Resolve <IBranchManager>();
List <Branch> list = BranchManager.GetAll();
foreach (Branch branch in list)
{
Console.WriteLine("Ashan Tharuka : " + branch.Address);
}
}
public async static Task ExecuteAsync()
{
var unityContainer = UnityResolver.CreateContainer();
var twitterServiceProvider = unityContainer.Resolve <ITwitterServiceProvider>();
var twitterAnalyzer = unityContainer.Resolve <ITwitterAnalyzer>();
await twitterServiceProvider.LoadIntoDatabaseAsync();
await twitterAnalyzer.CheckPendingTweets();
//await twitterAnalyzer.AnaylzeTopicAsync();
}
private static void Main()
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
// Add handler for UI thread exceptions
Application.ThreadException += UiThreadException;
// Force all WinForms errors to go through handler
Application.SetUnhandledExceptionMode(UnhandledExceptionMode.CatchException);
// This handler is for catching non-UI thread exceptions
AppDomain.CurrentDomain.UnhandledException += CurrentDomain_UnhandledException;
var resolver = new UnityResolver();
var presenter = resolver.Container.Resolve<IParentPresenter>();
presenter.LoadPlugins();
presenter.ClosedHandler = (sender, args) => Application.Exit();
presenter.ClosingHandler = Closing.ClosingHandler;
presenter.Show();
Application.Run();
}
public void Init()
{
this.Unity = new UnityResolver();
}
