/// <summary>
///
/// </summary>
/// <param name="diContainer"></param>
/// <param name="assembly"></param>
private static void RegisterMvc(IDependencyInjectionContainer diContainer, Assembly assembly)
{
// Register Common MVC Types
diContainer.Configure(c =>
{
c.Export<MemoryCache>()
.WithCtorParam((scope, context) => "CastleWindsorRegistration_Default")
.WithCtorParam((scope, context) => new NameValueCollection());
c.Export<RequestContext>()
.WithCtorParam((scope, context) => new HttpContextWrapper(HttpContext.Current))
.WithCtorParam((scope, context) => RouteTable.Routes.GetRouteData(new HttpContextWrapper(HttpContext.Current))).Lifestyle.SingletonPerRequest();
c.Export<UrlHelper>()
.WithCtorParam((scope, context) => context.Locate<RequestContext>())
.WithCtorParam((scope, context) => RouteTable.Routes).Lifestyle.SingletonPerRequest();
});
// Register MVC Filters
// Register MVC Controllers
diContainer.Configure(c =>
{
c.ExportAssembly(assembly).ByInterface<IController>();
});
}
public static void RegisterRoutes(RouteCollection routes, IDependencyInjectionContainer container)
{
routes.IgnoreRoute("{resource}.axd/{*pathInfo}");
// TODO: Make custom FavIcons per tenant
routes.IgnoreRoute("{*favicon}", new { favicon = @"(.*/)?favicon.ico(/.*)?" });
routes.MapRoute(
name: "Error - 404",
url: "not-found",
defaults: new { controller = "System", action = "Status404" }
);
routes.MapRoute(
name: "Error - 500",
url: "server-error",
defaults: new { controller = "System", action = "Status500" }
);
routes.Add(container.Resolve<LowercaseRedirectRoute>());
routes.Add(container.Resolve<TrailingSlashRedirectRoute>());
routes.Add(container.Resolve<DefaultLocaleRedirectRoute>());
routes.Add("Page", container.Resolve<PageRoute>());
routes.Add("Product", container.Resolve<ProductRoute>());
routes.MapRoute(
name: "Default",
url: "{controller}/{action}/{id}",
defaults: new { controller = "Home", action = "Index", id = UrlParameter.Optional }
);
}
public override void Dispose()
{
// Shutdown the container
this.container.Shutdown();
// Release container from memory
this.container = null;
}
public static void Register(IDependencyInjectionContainer container)
{
// Configure AutoMapper - all work done in constructor
container.Resolve<IDataInitializer>();
// TODO: Remove the initializer before deploying to production
Database.SetInitializer(new ComplexCommerceSeeder());
}
public override void Start()
{
Logger.Info("Starting Service '" + ServiceName + "' v" + Assembly.GetExecutingAssembly().GetName().Version.ToString());
MessageHandlersContainer = CreateMessageHandlersContainer();
ReceivingEndpoint.SetMessageHandlersContainer(MessageHandlersContainer);
ReceivingEndpoint.Start();
Logger.Info("Service Started");
}
public InjectableDependencyResolver(IDependencyInjectionContainer container, IDependencyResolver currentDependencyResolver)
{
if (container == null)
throw new ArgumentNullException("container");
if (currentDependencyResolver == null)
throw new ArgumentNullException("currentDependencyResolver");
this.container = container;
this.dependencyResolver = currentDependencyResolver;
}
/// <summary>
/// Initializes a new instance of the <see cref="Module"/> class.
/// </summary>
public Module(
IDependencyInjectionContainer container,
IApplicationPhases applicationPhases,
PortalExtensibilityHelper extensibilityHelper)
{
mContainer = container;
mApplicationPhases = applicationPhases;
mExtensibilityHelper = extensibilityHelper;
}
public PersistenceContextFactory(
Type contextType,
IDependencyInjectionContainer container
)
{
if (contextType == null)
throw new ArgumentNullException("contextType");
if (container == null)
throw new ArgumentNullException("container");
this.contextType = contextType;
this.container = container;
}
public void RegisterWithContainer(IDependencyInjectionContainer container)
{
container.RegisterInstance <IOperatingSystemServices>(this);
container.RegisterInstance(this.ComInteropServices);
container.RegisterInstance(this.FileSystem);
container.RegisterInstance(this.InternetInformationServicesInterop);
container.RegisterInstance(this.MachineInformationProvider);
container.RegisterInstance(this.NetshInterop);
container.RegisterInstance(this.ThreadingServices);
container.RegisterInstance(this.TimeServices);
container.RegisterInstance(this.WindowsServicesManager);
}
public static void Register(IDependencyInjectionContainer container)
{
// Setup global sitemap loader
MvcSiteMapProvider.SiteMaps.Loader = container.GetInstance<ISiteMapLoader>();
// Check all configured .sitemap files to ensure they follow the XSD for MvcSiteMapProvider
var validator = container.GetInstance<ISiteMapXmlValidator>();
validator.ValidateXml(HostingEnvironment.MapPath("~/Mvc.sitemap"));
// Register the Sitemaps routes for search engines
XmlSiteMapController.RegisterRoutes(RouteTable.Routes);
}
/// <summary>
/// Bootstraps this instance.
/// </summary>
public void Bootstrap()
{
this.DependencyInjectionContainer = new UnityDependencyInjectionContainer();
this.DependencyInjectionContainer.ConfigureScriptingTool();
this.DependencyInjectionContainer.ConfigureConsoleOutputs();
this.DependencyInjectionContainer.Register <IScriptingController, ScriptingController>();
this.DependencyInjectionContainer.Register <ScriptingToolViewModel>();
this.DependencyInjectionContainer.Register <MainView>();
}
public InjectableDependencyResolver(IDependencyInjectionContainer container, IDependencyResolver currentDependencyResolver)
{
if (container == null)
{
throw new ArgumentNullException("container");
}
if (currentDependencyResolver == null)
{
throw new ArgumentNullException("currentDependencyResolver");
}
this.container = container;
this.dependencyResolver = currentDependencyResolver;
}
public override void Dispose()
{
// Allow the container and everything it references to be garbage collected.
if (this.container == null)
{
return;
}
this.container.Shutdown();
// Release container from memory
this.container = null;
}
public static void Register(IDependencyInjectionContainer container)
{
// Setup global sitemap loader
MvcSiteMapProvider.SiteMaps.Loader = container.GetInstance <ISiteMapLoader>();
// Check all configured .sitemap files to ensure they follow the XSD for MvcSiteMapProvider
var validator = container.GetInstance <ISiteMapXmlValidator>();
validator.ValidateXml(HostingEnvironment.MapPath("~/Mvc.sitemap"));
// Register the Sitemaps routes for search engines
XmlSiteMapController.RegisterRoutes(RouteTable.Routes);
}
/// <summary>
///
/// </summary>
/// <param name="diContainer"></param>
internal static void RegisterServices(IDependencyInjectionContainer diContainer)
{
diContainer.Configure(c =>
{
c.Export<CacheService>().As<ICacheService>();
c.Export<FeedService>().As<IFeedService>();
c.Export<LoggingService>().As<ILoggingService>().Lifestyle.Singleton();
c.Export<OpenSearchService>().As<IOpenSearchService>();
c.Export<RobotsService>().As<IRobotsService>();
c.Export<SitemapService>().As<ISitemapService>();
c.Export<SitemapPingerService>().As<ISitemapPingerService>();
});
}
public override void Dispose()
{
// Allow the container and everything it references to be garbage collected.
if (this.container == null)
{
return;
}
this.container.Shutdown();
// Release container from memory
this.container = null;
}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
container = DIConfig.Register();
MvcSiteMapProviderConfig.Register(container);
ModelConfig.Register(container);
WebApiConfig.Register(GlobalConfiguration.Configuration);
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes, container);
BundleConfig.RegisterBundles(BundleTable.Bundles);
AuthConfig.RegisterAuth();
DbConfig.Register(container);
}
public override void PrepareBasic()
{
this.container = new DependencyInjectionContainer();
// Register all needed types out of StyleMVVM.DotNet
this.container.RegisterAssembly(typeof(DependencyInjectionContainer).Assembly);
// Remove extra XAML based exports that aren't needed (MVVM classes and what not)
this.container.RemoveXAMLExports();
this.RegisterBasic();
this.container.Start();
}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
container = DIConfig.Register();
MvcSiteMapProviderConfig.Register(container);
ModelConfig.Register(container);
WebApiConfig.Register(GlobalConfiguration.Configuration);
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes, container);
BundleConfig.RegisterBundles(BundleTable.Bundles);
AuthConfig.RegisterAuth();
DbConfig.Register(container);
}
public PersistenceContextFactory(
Type contextType,
IDependencyInjectionContainer container
)
{
if (contextType == null)
{
throw new ArgumentNullException("contextType");
}
if (container == null)
{
throw new ArgumentNullException("container");
}
this.contextType = contextType;
this.container = container;
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public static IDependencyInjectionContainer Initiate()
{
DependencyInjectionContainer = new DependencyInjectionContainer { ThrowExceptions = true };
Assembly assembly = Assembly.GetExecutingAssembly();
GraceDependencyCatalog.RegisterServices(DependencyInjectionContainer);
RegisterMvc(DependencyInjectionContainer, assembly);
var registrations = DependencyInjectionContainer.WhatDoIHave();
SetMvcDependencyResolver(DependencyInjectionContainer);
return DependencyInjectionContainer;
}
protected void Application_Start(object sender, EventArgs e)
{
GlobalConfiguration.Configure(config =>
{
config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
});
container = new WebAPIDependencyInjectionContainer();
container.RegisterDependencies();
}
public override void Prepare()
{
container = new DependencyInjectionContainer();
// Register all needed types out of StyleMVVM.DotNet
container.RegisterAssembly(typeof(DependencyInjectionContainer).Assembly);
// Remove extra XAML based exports that aren't need (MVVM classes and what not)
container.RemoveXAMLExports();
// Register local exports
container.Register<Singleton>().As<ISingleton>().AndSharedPermenantly();
container.Register<Transient>().As<ITransient>();
container.Register<Combined>().As<ICombined>().ImportConstructor(() => new Combined(null, null));
container.Start();
}
/// <summary>
/// Initializes a new instance of the <see cref="Module"/> class.
/// </summary>
public Module(
IDependencyInjectionContainer container,
IApplicationPhases applicationPhases,
IExtensibilityHelper extensibilityHelper,
IExpandableHeaderViewModel expandableHeaderViewModel,
IExpandableRegionViewModel expandableRegionViewModel,
IAsyncActionsFactory asyncActionsFactory,
INotificationService notificationService)
{
mContainer = container;
mApplicationPhases = applicationPhases;
mExtensibilityHelper = extensibilityHelper;
mExpandableHeaderViewModel = expandableHeaderViewModel;
mExpandableRegionViewModel = expandableRegionViewModel;
mAsyncActionsFactory = asyncActionsFactory;
mNotificationService = notificationService;
}
public static void Register(IDependencyInjectionContainer container)
{
// CSLA 4 Configuration
// NOTE: For some reason this doesn't work even though the correct type is configured in the DI container
//var modelBinder = container.Resolve<IModelBinder>();
var modelBinder = new CslaModelBinder();
ModelBinders.Binders.DefaultBinder = modelBinder;
// Localization
var modelMetadataProvider = container.Resolve<LocalizedModelMetadataProvider>();
ModelMetadataProviders.Current = modelMetadataProvider;
var modelValidatorProvider = container.Resolve<LocalizedModelValidatorProvider>();
ModelValidatorProviders.Providers.Clear();
ModelValidatorProviders.Providers.Add(modelValidatorProvider);
}
/// <summary>
/// Initializes a new instance of the <see cref="Module"/> class.
/// </summary>
public Module(
IDependencyInjectionContainer container,
IApplicationPhases applicationPhases,
IExtensibilityHelper extensibilityHelper,
IExpandableHeaderViewModel expandableHeaderViewModel,
IExpandableRegionViewModel expandableRegionViewModel,
IAsyncActionsFactory asyncActionsFactory,
INotificationService notificationService)
{
mContainer = container;
mApplicationPhases = applicationPhases;
mExtensibilityHelper = extensibilityHelper;
mExpandableHeaderViewModel = expandableHeaderViewModel;
mExpandableRegionViewModel = expandableRegionViewModel;
mAsyncActionsFactory = asyncActionsFactory;
mNotificationService = notificationService;
}
/// <summary>
/// Creates a new instance of the RemotingServer class.
/// </summary>
/// <param name="config">Configuration settings to be used (Default configuration is used, if left null)</param>
public RemotingServer(ServerConfig config = null)
{
_config = config ?? new ServerConfig();
_uniqueServerInstanceName =
string.IsNullOrWhiteSpace(_config.UniqueServerInstanceName)
? Guid.NewGuid().ToString()
: _config.UniqueServerInstanceName;
_serverInstances.AddOrUpdate(
key: _config.UniqueServerInstanceName,
addValueFactory: uniqueInstanceName => this,
updateValueFactory: (uniqueInstanceName, oldServer) =>
{
oldServer?.Dispose();
return(this);
});
SessionRepository =
_config.SessionRepository ??
new SessionRepository(
keySize: _config.KeySize,
inactiveSessionSweepInterval: _config.InactiveSessionSweepInterval,
maximumSessionInactivityTime: _config.MaximumSessionInactivityTime);
_container = _config.DependencyInjectionContainer ?? new CastleWindsorDependencyInjectionContainer();
Serializer = _config.Serializer ?? new BsonSerializerAdapter();
MethodCallMessageBuilder = new MethodCallMessageBuilder();
MessageEncryptionManager = new MessageEncryptionManager();
_container.RegisterService <IDelegateProxyFactory, DelegateProxyFactory>(
lifetime: ServiceLifetime.Singleton);
_config.RegisterServicesAction?.Invoke(_container);
Channel = _config.Channel ?? new WebsocketServerChannel();
Channel.Init(this);
if (_config.IsDefault)
{
RemotingServer.DefaultRemotingServer ??= this;
}
}
public override void Prepare()
{
this.container = new DependencyInjectionContainer();
// Register all needed types out of StyleMVVM.DotNet
this.container.RegisterAssembly(typeof(DependencyInjectionContainer).Assembly);
// Remove extra XAML based exports that aren't needed (MVVM classes and what not)
this.container.RemoveXAMLExports();
this.RegisterBasic();
this.RegisterPropertyInjection();
this.RegisterOpenGeneric();
this.RegisterConditional();
this.RegisterMultiple();
this.container.Start();
}
public override void Prepare()
{
this.container = new DependencyInjectionContainer();
// Register all needed types out of StyleMVVM.DotNet
this.container.RegisterAssembly(typeof(DependencyInjectionContainer).Assembly);
// Remove extra XAML based exports that aren't needed (MVVM classes and what not)
this.container.RemoveXAMLExports();
this.RegisterDummies();
this.RegisterStandard();
this.RegisterComplex();
this.RegisterOpenGeneric();
this.RegisterConditional();
this.RegisterMultiple();
this.container.Start();
}
public static void Register(IDependencyInjectionContainer container)
{
// CSLA 4 Configuration
// NOTE: For some reason this doesn't work even though the correct type is configured in the DI container
//var modelBinder = container.Resolve<IModelBinder>();
var modelBinder = new CslaModelBinder();
ModelBinders.Binders.DefaultBinder = modelBinder;
// Localization
var modelMetadataProvider = container.Resolve <LocalizedModelMetadataProvider>();
ModelMetadataProviders.Current = modelMetadataProvider;
var modelValidatorProvider = container.Resolve <LocalizedModelValidatorProvider>();
ModelValidatorProviders.Providers.Clear();
ModelValidatorProviders.Providers.Add(modelValidatorProvider);
}
/// <summary>
/// Initializes a new instance of the <see cref="AcxiomTabViewModel"/> class.
/// </summary>
public AcxiomTabViewModel(IAcxiomTabView view,
IIntentManager intentManager,
IDispatcherTimer dispatcherTimer,
IDependencyInjectionContainer container,
IAcxiomConstants acxiomConstants)
: base(isCloseable: true)
{
mIntentManager = intentManager;
mContainer = container;
mDispatcherTimer = dispatcherTimer;
mAcxiomConstants = acxiomConstants;
Header = AcxiomStringResources.TabHeader; //Tab Header text
HeaderTooltip = AcxiomStringResources.TabHeaderTooltip; //Tab header tooltip
mBaseURL = mAcxiomConstants.ExternalSubsetGenerationUri.ToString();
PageLocation = mBaseURL;
mJavaScriptHandler = new JavaScriptHandler(this);
SetAsViewModelForView(view);
//All is ok, start to render html UI
mDispatcherTimer.Interval = TimeSpan.FromMilliseconds(100);
mDispatcherTimer.Tick += CheckForHtmlReady;
mDispatcherTimer.Start();
}
public InjectableControllerFactory(IDependencyInjectionContainer container)
{
this.container = container;
}
public static T Resolve <T>(this IDependencyInjectionContainer container)
{
return((T)container.Resolve(typeof(T)));
}
public static void Register(IDependencyInjectionContainer container)
{
// Setup global sitemap loader
MvcSiteMapProvider.SiteMaps.Loader = container.Resolve<ISiteMapLoader>();
}
/// <summary>
/// Configures the scripting tool.
/// </summary>
/// <param name="dependencyInjectionContainer">The dependency injection container.</param>
public static void ConfigureScriptingTool(this IDependencyInjectionContainer dependencyInjectionContainer)
{
dependencyInjectionContainer.Register <IFileDiscoveryService, FileDiscoveryService>((dic) => new FileDiscoveryService("*.csx", dic.ResolveAll <IFileDiscoveryStatusObserver>().ToArray()));
dependencyInjectionContainer.Register <IScriptLoaderService, ScriptLoaderService>();
dependencyInjectionContainer.Register <IScriptingService, ScriptingService>();
}
public static T GetInstance <T>(this IDependencyInjectionContainer container)
{
return((T)container.GetInstance(typeof(T)));
}
public InjectableControllerFactory(IDependencyInjectionContainer container)
{
if (container == null)
throw new ArgumentNullException("container");
this.container = container;
}
public ServicoController(IDependencyInjectionContainer _container)
{
container = _container;
}
public DummyDependencyInjectionServiceLocator(IDependencyInjectionContainer container) : base(container)
{
}
public DependencyInjectionContainerImportService(IDependencyInjectionContainer container)
{
Container = container;
}
public CreditoCRUDService(IDependencyInjectionContainer _container)
{
container = _container;
}
public PedidoTecnicoController(IDependencyInjectionContainer _container)
{
container = _container;
}
public CustomGraceBasedTypeFactory(IDependencyInjectionContainer container)
{
this.container = container;
}
/// <summary>
/// Initialize the bootstrapper
/// </summary>
/// <param name="exportEnvironment">export environment</param>
private void Initialize(ExportEnvironment exportEnvironment)
{
Container = new DependencyInjectionContainer(exportEnvironment);
Container.Configure(new StyleMVVMCompositionRoot());
Instance = this;
}
public PessoaFisica2CRUDService(IDependencyInjectionContainer _container)
{
container = _container;
}
public PessoaFisicaController(IDependencyInjectionContainer _container)
{
container = _container;
}
/// <summary>
/// Sets the ASP.NET MVC dependency resolver.
/// </summary>
/// <param name="diContainer">The container.</param>
private static void SetMvcDependencyResolver(IDependencyInjectionContainer diContainer)
{
DependencyResolver.SetResolver(new GraceDependencyResolver(diContainer));
}
/// <summary>
/// Default constructor takes a DI container
/// </summary>
/// <param name="container">container to diagnose</param>
public DependencyInjectionContainerDiagnostic(IDependencyInjectionContainer container)
{
this.container = container;
}
/// <summary>
/// Shutdown bootstrapper
/// </summary>
public void Shutdown()
{
Container.Dispose();
Container = null;
}
/// <summary>
/// Initializes a new instance of the <see cref="Module"/> class.
/// </summary>
public Module(IDependencyInjectionContainer container)
{
mContainer = container;
}
/// <summary>
/// Initializes a new instance of the <see cref="PortalExtensibilityHelper"/> class.
/// </summary>
public PortalExtensibilityHelper(
IDependencyInjectionContainer container)
{
mContainer = container;
}
public ConfiguracaoRepository(IUnitOfWork unitOfWork, IDependencyInjectionContainer container) : base(unitOfWork, container)
{
}
public static ILoggerFactory GetLoggerFactory(this IDependencyInjectionContainer container)
{
return(GetLoggerFactoryInternal(container));
}
public CPFBloqueadoRepository(IUnitOfWork unitOfWork, IDependencyInjectionContainer container) : base(unitOfWork, container)
{
}
public PagSeguroController(IDependencyInjectionContainer _container)
{
container = _container;
}
public static void RegisterExport(IDependencyInjectionContainer container)
{
container.Register <DebugLogAppender>().As <ILogAppender>();
}
public EmailRepository(IUnitOfWork unitOfWork, IDependencyInjectionContainer container) : base(unitOfWork, container)
{
}
public InjectableControllerFactory(IDependencyInjectionContainer container)
{
this.container = container;
}
