private static IMediator GetMediator()
{
var configuration = new ConfigurationBuilder()
.AddUserSecrets <FilmEntry>()
.Build();
var container = new StructureMap.Container(cfg =>
{
cfg.Scan(scanner =>
{
scanner.AssemblyContainingType <CreateFilmCommand>(); // Our assembly with requests & handlers
scanner.ConnectImplementationsToTypesClosing(typeof(IRequestHandler <>)); // Handlers with no response
scanner.ConnectImplementationsToTypesClosing(typeof(IRequestHandler <,>)); // Handlers with a response
scanner.ConnectImplementationsToTypesClosing(typeof(INotificationHandler <>));
scanner.ConnectImplementationsToTypesClosing(typeof(IRequestPreProcessor <>));
});
cfg.For(typeof(IPipelineBehavior <,>)).Add(typeof(RequestPreProcessorBehavior <,>));
cfg.For <SingleInstanceFactory>().Use <SingleInstanceFactory>(ctx => t => ctx.GetInstance(t));
cfg.For <MultiInstanceFactory>().Use <MultiInstanceFactory>(ctx => t => ctx.GetAllInstances(t));
cfg.For <IMediator>().Use <Mediator>();
cfg.For <LiteDbProvider>().Use(x => new LiteDbProvider("c:\\temp\\dvdcollection.db")).Singleton();
cfg.For <IConfigurationRoot>().Use(x => configuration);
});
var mediator = container.GetInstance <IMediator>();
return(mediator);
}
protected override void PerformSetUp()
{
this.UnitOfWork.Session.Save(new Fish
{
Description = "A fish called wanda"
});
this.UnitOfWork.Session.Save(new Fish
{
Description = "Once up a time in a land called nod."
});
this.UnitOfWork.Session.Save(new Fish
{
Description = "There was a giant timelord."
});
this.UnitOfWork.Session.Save(new Fish
{
Description = "There was big and good travel thru time."
});
this.UnitOfWork.Commit(true);
var container = new StructureMap.Container();
container.Configure(x => x.Scan(cfg =>
{
cfg.TheCallingAssembly();
cfg.AssemblyContainingType<Fish>();
cfg.WithDefaultConventions();
}));
this.fishRepository = new FutureFishNHibernateRepository(this.UnitOfWork);
}
static void Main(string[] args)
{
var storageDictionary = new Dictionary <string, User>();
StructureMap.Container contanier = new StructureMap.Container(_ =>
{
_.For <IDateTimeProvider>().Use <DateTimeProvider>();
_.For <IMessageTranslator>().Use <MessageTranslator>();
_.For <IMessageAppCommandParser>().Use <MessageAppCommandParser>();
_.For <IMessageAppService>().Use <MessageAppService>();
_.For <IMessageAppRepository>().Use <MessageAppRepository>().Ctor <Dictionary <string, User> >().Is(storageDictionary);
_.For <MessageAppController>().Use <MessageAppController>();
});
var messageAppController = contanier.GetInstance <MessageAppController>();
while (true)
{
var userInput = Console.ReadLine();
if (userInput == "exit")
{
break;
}
messageAppController.ExecuteCommand(userInput);
}
}
static void Main()
{
_log = LogManager.GetCurrentClassLogger();
_log.Warn("Service is about to start");
#if DEBUG
LogManager.GlobalThreshold = LogLevel.Trace;
#endif
AppDomain.CurrentDomain.UnhandledException += CurrentDomainUnhandledException;
try
{
var container = new Container(new SensuClientRegistry());
var sensuClient = container.GetInstance<ISensuClient>() as ServiceBase;
ServiceBase[] servicesToRun;
servicesToRun = new ServiceBase[]
{
sensuClient
};
if (Environment.UserInteractive)
{
RunInteractive(servicesToRun);
}
else
{
ServiceBase.Run(servicesToRun);
}
}
catch (Exception exception)
{
_log.Error(exception, "Error in startup sensu-client.");
}
}
public void StructureMap()
{
var container = new StructureMap.Container();
foreach (var type in _types)
{
container.Configure(c => c.For(type).Use(type));
}
int length = 0;
if (Scenario == ResolveScenario.ResolveOne)
{
length = 1;
}
else if (Scenario == ResolveScenario.ResolveHalf)
{
length = _types.Length / 2;
}
else if (Scenario == ResolveScenario.ResolveAll)
{
length = _types.Length;
}
for (var i = 0; i < length; i++)
{
container.GetInstance(_types[i]);
}
container.Dispose();
}
static void Main()
{
_log = LogManager.GetCurrentClassLogger();
_log.Warn("Service is about to start");
#if DEBUG
LogManager.GlobalThreshold = LogLevel.Trace;
#endif
AppDomain.CurrentDomain.UnhandledException += CurrentDomainUnhandledException;
try
{
var container = new Container(new SensuClientRegistry());
var sensuClient = container.GetInstance <ISensuClient>() as ServiceBase;
ServiceBase[] servicesToRun;
servicesToRun = new ServiceBase[]
{
sensuClient
};
if (Environment.UserInteractive)
{
RunInteractive(servicesToRun);
}
else
{
ServiceBase.Run(servicesToRun);
}
}
catch (Exception exception)
{
_log.Error(exception, "Error in startup sensu-client.");
}
}
public void Sample()
{
var container = new StructureMap.Container();
container.Configure(c => c.For <ILogger>().Use <ConsoleLogger>());
ILogger logger = container.GetInstance <ILogger>();
}
static ApplicationServiceLocator()
{
Container = new StructureMap.Container(configuration =>
{
configuration.For <IMovieService>().Use <MovieService>().Transient();
});
}
public static AdaptedContainerBuilderOptions <TTenant> WithStructureMap <TTenant>(
this ContainerBuilderOptions <TTenant> options,
Action <TTenant, IServiceCollection> configureTenant)
where TTenant : class
{
var adaptorFactory = new Func <ITenantContainerAdaptor>(() =>
{
// host level container.
var container = new StructureMap.Container();
container.Populate(options.Builder.Services);
var adaptedContainer = container.GetInstance <ITenantContainerAdaptor>();
var containerEventsPublisher = container.TryGetInstance <ITenantContainerEventsPublisher <TTenant> >();
// add ITenantContainerBuilder<TTenant> service to the host container
// This service can be used to build a child container (adaptor) for a particular tenant, when required.
var defaultServices = options.DefaultServices;
container.Configure(_ =>
_.For <ITenantContainerBuilder <TTenant> >()
.Use(new TenantContainerBuilder <TTenant>(defaultServices, adaptedContainer, configureTenant, containerEventsPublisher))
);
// NOTE: Im not sure why I was resolving ITenantContainerAdaptor twice, changed to just return previous instance.
//var adaptor = container.GetInstance<ITenantContainerAdaptor>();
//return adaptor;
return(adaptedContainer);
});
var adapted = new AdaptedContainerBuilderOptions <TTenant>(options, adaptorFactory);
return(adapted);
}
public ViewBase ViewInTab <T>(Action <T> initializer = null) where T : ViewBase
{
var typeRegistery = new TypeRegistery();
var container = new StructureMap.Container(typeRegistery);
var viewInstance = container.GetInstance <T>();
if (initializer != null)
{
initializer(viewInstance);
}
viewInstance.ViewEngin = this;
if (openTabs.ContainsKey(viewInstance.ViewIdentifier))
{
var currentTab = openTabs[viewInstance.ViewIdentifier];
tabControl.SelectedTab = currentTab;
return(currentTab.Controls.OfType <T>().First());
}
TabPage tabPage = new TabPage();
tabPage.Text = viewInstance.ViewTitle;
tabPage.Controls.Add(viewInstance);
viewInstance.Dock = DockStyle.Fill;
tabControl.TabPages.Add(tabPage);
tabControl.SelectedTab = tabPage;
openTabs.Add(viewInstance.ViewIdentifier, tabPage);
return((T)viewInstance);
}
protected TestContainer()
{
var registry = new Registry();
registry.IncludeRegistry <SeleniumRegistry>();
_container = new Container(registry);
}
private static Engine StructureMapMain()
{
var container = new StructureMap.Container();
container.SetupEngine <MyEnvironment>(Build);
return(container.GetInstance <Engine>());
}
public IContainer CreateContainer()
{
var structureMap = new StructureMap.Container();
var container = new Container(structureMap);
return(container);
}
public static void ConfigureStructureMapContainer()
{
HttpConfiguration config = GlobalConfiguration.Configuration;
StructureMap.IContainer container = new StructureMap.Container(c => c.AddRegistry<DefaultRegistry>());
config.Services.Replace(
typeof(IHttpControllerActivator),
new StructureMapWebApiControllerActivator(container));
}
public Form1()
{
var container = new Container(c => c.For<ICalculator>().Use<Calculator>());
var viewModel = container.GetInstance<ViewModel>();
InitializeComponent();
button1.Click += viewModel.Add;
viewModelBindingSource.DataSource = new [] {viewModel};
}
public static Initialize()
{
StructureMap.Configuration.DSL.Registry registry = new StructureMap.Configuration.DSL.Registry();
registry.For <IUser>().Use <User>();
registry.For <IDatabase>().Use <Database>();
registry.ForConcreteType <UserManagement>().Singleton();
_container = new Container(registry);
}
protected override IContainer InitializeContainer()
{
var container = new StructureMap.Container();
container.Configure(x => x.ForConcreteType <RequestA>().Configure.Named("KeyForRequestA"));
container.Configure(x => x.ForConcreteType <RequestB>().Configure.Named("KeyForRequestB"));
return(new Agatha.StructureMap.Container(container));
}
private void ConfigureIoC(BusConfiguration busConfiguration)
{
var container = new StructureMap.Container(expression =>
{
expression.AddRegistry<DefaultRegistry>();
});
busConfiguration.UseContainer<StructureMapBuilder>(customizations => customizations.ExistingContainer(container));
}
public void ShouldPickUpAutoNotifyAttributedClass()
{
var container = new Container(config => config.Scan(scan =>
{
scan.With(new AutoNotifyAttrConvention());
scan.TheCallingAssembly();
}));
Assert.That(container.GetInstance<TestClassWithAttr>(), Is.InstanceOf<INotifyPropertyChanged>());
}
public static IEnumerable <object[]> GetContainerAdapters()
{
yield return(new object[] { (ResolverFactory)(c =>
{
var container = new DefaultServiceContainer();
c(container);
return container.Resolve <IServiceResolver>();
}) });
yield return(new object[] { (ResolverFactory)(c =>
{
var container = new LightInjectContainer();
c(new LightInjectAdapter(container));
return container.GetInstance <IServiceResolver>();
}) });
yield return(new object[] { (ResolverFactory)(c =>
{
var container = new SimpleInjectorContainer {
Options = { AllowOverridingRegistrations = true }
};
c(new SimpleInjectorAdapter(container));
return container.GetInstance <IServiceResolver>();
}) });
yield return(new object[] { (ResolverFactory)(c =>
{
var container = new StructureMapContainer(r => c(new StructureMapAdapter(r)));
return container.GetInstance <IServiceResolver>();
}) });
yield return(new object[] { (ResolverFactory)(c =>
{
var containerBuilder = new ContainerBuilder();
c(new AutofacAdapter(containerBuilder));
var container = containerBuilder.Build();
return container.Resolve <IServiceResolver>();
}) });
#if NETFX
yield return(new object[] { (ResolverFactory)(c =>
{
var container = new WindsorContainer();
c(new WindsorAdapter(container));
return container.Resolve <IServiceResolver>();
}) });
yield return(new object[] { (ResolverFactory)(c =>
{
var container = new NinjectContainer();
c(new NinjectAdapter(container));
return container.Get <IServiceResolver>();
}) });
#endif
}
public void SampleForAutoScan()
{
var container = new StructureMap.Container(c =>
{
c.Scan(x =>
{
x.TheCallingAssembly();
x.WithDefaultConventions();
});
});
}
public void LoadLocalDummyConfigurationWithFrameworkConfiguration_VerifySingleton()
{
var container = new StructureMap.Container();
ConfigurationLoader.LoadConfigurations(container, ".\\Configuration\\", "{0}Configuration");
var config = container.GetInstance <DummyConfiguration>();
var config2 = container.GetInstance <DummyConfiguration>();
Assert.AreEqual(config, config2);
}
public void LoadLocalDummyConfiguration_VerifyRegistration()
{
var container = new StructureMap.Container();
ConfigurationLoader.LoadConfigurations(container, ".\\Configuration\\", "{0}Configuration");
var config = container.GetInstance <DummyConfiguration>();
Assert.IsNotNull(config);
Assert.AreEqual(1234, config.Port);
Assert.AreEqual("DataCollectorQueue", config.MsmqQueueName);
}
public void TestInitialize()
{
var smContainer = new StructureMap.Container();
this.container = new SMContainer(smContainer);
container.Configuration.Configure(smre =>
{
CompositionRoot.RegisterNetXPStandard(smre, container);
smre.RegisterInstance <IContainer>(container, DILifeTime.Trasient);
});
}
public void UsingAutoNotifyAttributeConvention()
{
var container = new Container(config => config.Scan(scanConfig =>
{
scanConfig.With(new AutoNotifyAttrConvention());
scanConfig.TheCallingAssembly();
scanConfig.WithDefaultConventions();
}));
var gem = container.GetInstance<IGem>();
Assert.That(gem, Is.InstanceOf<INotifyPropertyChanged>());
}
public void try_out_the_test_package_1()
{
var container = new Container(x =>
{
x.Scan(o =>
{
o.AssemblyContainingType <TestPackage1Registry>();
o.AddAllTypesOf <IFubuRegistryExtension>();
});
});
Debug.WriteLine(container.WhatDoIHave());
}
internal static void Register(HttpConfiguration config)
{
var container = new StructureMap.Container(x =>
{
x.Scan(s =>
{
s.TheCallingAssembly();
s.WithDefaultConventions();
});
});
DependencyResolver.SetResolver(new StructureMapDependencyResolver(container));
}
protected override void OnStartup(StartupEventArgs e)
{
base.OnStartup(e);
var container = new StructureMap.Container(x => {
x.Scan(y => {
y.TheCallingAssembly();
y.WithDefaultConventions();
});
});
ServiceLocator.Container = container;
PageControllerConfiguration.PageDependencyResolver = new StructureMapDependencyResolver(container);
var eventBus = new UiEventBus();
container.Configure(x => {
x.For <LoggingService>().Use <LoggingService>().Singleton();
x.For <IEventBus>().Use(eventBus);
x.For <ICrossAppEventBus>().Use(eventBus);
x.For <IBroadcastService>().Use <BroadcastService>().Singleton();
x.For <IRequestHandler>().Use <TcpRequestHandler>();
x.For <AppData>().Use <AppData>().Singleton();
x.For <Configuration>().Use <Configuration>().Singleton();
x.For <Game>().Use <Game>().Singleton();
x.For <IControllerFactory>().Use(new ControllerFactory(container));
});
_loggingService = container.GetInstance <LoggingService>();
var cardLoadService = container.GetInstance <CardLoadService>();
cardLoadService.RegisterEvents();
var configurationService = container.GetInstance <ConfigurationService>();
configurationService.Load();
var gameFileService = container.GetInstance <GameFileService>();
gameFileService.Load();
var receiveSocketService = container.GetInstance <ReceiveSocketService>();
receiveSocketService.StartListening(TcpInfo.EmoPort);
var controller = container.GetInstance <MainController>();
controller.View.Show();
}
public T ViewInForm <T>(Action <T> initialazer = null, bool displayAsDialog = false
, FormWindowState windowState = FormWindowState.Normal, bool topButtonBar = false) where T : ViewBase
{
var typeRegistery = new TypeRegistery();
var container = new StructureMap.Container(typeRegistery);
var viewInstance = container.GetInstance <T>();
viewInstance.ViewEngin = this;
if (initialazer != null)
{
initialazer(viewInstance);
}
if (openForms.ContainsKey(viewInstance.ViewIdentifier))
{
var currentForm = openForms[viewInstance.ViewIdentifier];
currentForm.Activate();
return((T)currentForm.Controls.OfType <ViewBase>().First());
}
viewInstance.VisibleTopBar = topButtonBar;
var form = new Form();
form.Height = 600;
form.Width = 800;
form.StartPosition = FormStartPosition.CenterScreen;
form.RightToLeft = RightToLeft.Yes;
form.Font = new Font("Tahoma", 8);
form.Text = viewInstance.ViewTitle;
viewInstance.Dock = DockStyle.Fill;
form.Controls.Add(viewInstance);
form.FormClosed += (obj, e) =>
{
openForms.Remove(viewInstance.ViewIdentifier);
};
form.WindowState = windowState;
openForms.Add(viewInstance.ViewIdentifier, form);
if (displayAsDialog)
{
form.ShowDialog();
}
else
{
form.Show();
}
return((T)viewInstance);
}
public void ButtonClicked()
{
var container = new StructureMap.Container(x =>
{
x.For <IService1>().Use <Service1>().Transient();
x.For <IService2>().Use <Service2>().Singleton();
x.For <Client>().Use <Client>();
});
var client = container.GetInstance <Client>();
client.InitiateServiceMethods();
container.Release(client);
}
public RequestGraph(ActionMethod actionMethod)
{
Configuration = new Configuration();
ActionMethod = actionMethod;
ResponseType = !actionMethod.Method.HasResult ?
null : actionMethod.Method.ReturnType;
CancellationToken = new CancellationToken();
HttpConfiguration = new HttpConfiguration();
ActionArguments = new object[actionMethod.Method.Parameters.Length];
HttpMethod = "GET";
Url = "http://fark.com";
_urlTemplate = "";
UnderlyingContainer = new StructureMap.Container();
Container = new Container(UnderlyingContainer);
TypeCache = new TypeCache();
}
public void _Inline_Setter_Should_Populate_Multiple_Implementations()
{
//Arrange
var registry = new StructureMap.Registry();
registry.IncludeRegistry <ContainerRegistry>();
// build a container
var container = new StructureMap.Container(registry);
//Act
var application = container.GetInstance <IMeasurementContractsApplication>();
//Assert
application.Should().NotBeNull();
application.Foo.Should().BeOfType <Foo>();
application.Bar.Should().BeOfType <Bar>();
}
public void _Inline_Setter_Should_Populate_Multiple_Implementations()
{
//Arrange
var registry = new StructureMap.Registry();
registry.IncludeRegistry <ContainerRegistry>();
// build a container
var container = new StructureMap.Container(registry);
//Act
var target = container.GetInstance <IMeasurementContractsApplication>();
//Assert
target.Should().NotBeNull();
target.DistributionListProvider.Should().BeOfType <DistributionListProvider>();
target.FirstDeliveryNoticeDocumentRecallProvider.Should().BeOfType <FirstDeliveryNoticeDocumentAdminUpdateProvider>();
}
/// <summary>
/// Initializes the service locator.
/// </summary>
static void InitializeServiceLocator()
{
var container = new StructureMap.Container();
var locator = new StructureMapServiceLocator(container);
var context = new ServiceConfigurationContext(HostType.Installer, new StructureMapConfiguration(container));
context.Services.AddSingleton <IRequiredMetaFieldCollection, NoRequiredMetaFields>();
context.Services.AddSingleton <IWarehouseRepository, WarehouseRepositoryDatabase>();
context.Services.AddSingleton <ISynchronizedObjectInstanceCache, LocalCacheWrapper>();
context.Services.AddSingleton <ICatalogSystem>(locate => CatalogContext.Current);
context.Services.AddSingleton <IChangeNotificationManager, NullChangeNotificationManager>();
context.Services.AddSingleton <IPriceService, PriceServiceDatabase>();
context.Services.AddTransient <SecurityContext>(locate => SecurityContext.Current);
context.Services.AddTransient <CustomerContext>(locate => CustomerContext.Current);
context.Services.AddTransient <FrameworkContext>(locate => FrameworkContext.Current);
ServiceLocator.SetLocator(locator);
}
public void UsingFireOptionAlways()
{
var container = new Container(config => config.Scan(scanConfig =>
{
scanConfig.With(new AutoNotifyAttrConvention());
scanConfig.TheCallingAssembly();
scanConfig.WithDefaultConventions();
}));
var bar = container.GetInstance<Bar>();
var tracker = new EventTracker<PropertyChangedEventHandler>();
bar.Value = "test";
(bar as INotifyPropertyChanged).PropertyChanged += tracker;
bar.Value = "test";
Assert.That(tracker.WasCalled);
}
public void UsingFireOptionOnlyOnChange()
{
var container = new Container(config => config.Scan(scanConfig =>
{
scanConfig.With(new AutoNotifyAttrConvention());
scanConfig.TheCallingAssembly();
scanConfig.WithDefaultConventions();
}));
var foo = container.GetInstance<Foo>();
var tracker = new EventTracker<PropertyChangedEventHandler>();
foo.Value = "test";
(foo as INotifyPropertyChanged).PropertyChanged += tracker;
foo.Value = "test";
Assert.That(tracker.WasNotCalled);
}
public static void Main(string[] args)
{
#if DEBUG
// optional, but recommended
System.Diagnostics.Debugger.Launch();
#endif
var container = new StructureMap.Container(x => {
x.Scan(y => {
y.TheCallingAssembly();
y.WithDefaultConventions();
});
});
var eventBus = new EventBus();
container.Configure(x => {
x.For <IEventBus>().Use(eventBus);
x.For <ICrossAppEventBus>().Use(eventBus);
x.For <ICardGroupStore>().Use <CardGroupStore>().Singleton();
x.For <IDynamicActionManager>().Use <DynamicActionManager>().Singleton();
x.For <IDynamicActionInfoStore>().Use <DynamicActionInfoStore>().Singleton();
x.For <ISendEventHandler>().Use <SendEventHandler>().Singleton();
x.For <IImageService>().Use <ImageService>().Singleton();
x.For <ITcpRequestHandler>().Use <TcpRequestHandler>().Singleton();
x.For <IRequestHandler>().Use(c => c.GetInstance <ITcpRequestHandler>());
x.For <IReceiveSocketService>().Use <ReceiveSocketService>();
x.For <IEstablishConnectionToUiService>().Use <EstablishConnectionToUiService>();
});
ServiceLocator.Container = container;
//keep references or garbage collection will clean this up and we'll stop receiving events
var sendEventHandler = container.GetInstance <ISendEventHandler>();
var receiveSocketService = container.GetInstance <IReceiveSocketService>();
receiveSocketService.StartListening(StreamDeckTcpInfo.Port);
var establishConnectionToUiService = container.GetInstance <IEstablishConnectionToUiService>();
establishConnectionToUiService.AttemptToEstablishConnection();
// register actions and connect to the Stream Deck
SharpDeck.StreamDeckPlugin.Run();
}
public static void Execute()
{
var container = new StructureMap.Container();
container.Configure(c =>
{
c.Scan(x =>
{
x.AssembliesFromApplicationBaseDirectory();
x.WithDefaultConventions();
x.LookForRegistries();
});
c.SetAllProperties(x =>
x.TypeMatches(
type => container.Model.HasImplementationsFor(type)));
});
DependencyResolver.SetResolver(new StructureMapDependencyResolver(container));
FilterProviders.Providers.Add(new StructureMapFilterAttributeFilterProvider(container));
}
public BusinessTestFixture()
{
// Build configuration settings
var builder = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true);
Configuration = builder.Build();
var appSettings = Configuration.Get<AppSettings>("Application");
// Start up DI container
this.container = new StructureMap.Container();
container.Configure(c => c.ForSingletonOf<AppSettings>().Use(appSettings));
container.Configure(c => c.For<IApplicationContext>().Use<BusinessTestContext>());
DependencyResolver.RegisterResolver(new StructureMapIOCContainer(container)).RegisterImplmentation();
// Load mapping
LoadAutoMapper();
}
static IContainer BootstrapContainer()
{
var container = new Container(x => { x.AddType(typeof(OrderForm)); });
container.Configure(cfg =>
{
cfg.For<IServiceBus>().Use(context => ServiceBusFactory.New(sbc =>
{
sbc.ReceiveFrom("msmq://localhost/starbucks_customer");
sbc.UseMsmq();
sbc.UseMulticastSubscriptionClient();
sbc.UseControlBus();
sbc.Subscribe(subs => { subs.LoadFrom(container); });
}));
});
return container;
}
public void UsingDependentPropertiesUpdatesRelatedWhenUsingDependsOnAttribute()
{
var container = new Container(config => config.Scan(scanConfig =>
{
scanConfig.With(new AutoNotifyAttrConvention());
scanConfig.TheCallingAssembly();
scanConfig.WithDefaultConventions();
}));
var account = container.GetInstance<Account>();
var propsChanged = new List<string>();
(account as INotifyPropertyChanged).PropertyChanged += (o, e) => propsChanged.Add(e.PropertyName);
account.AccountName = "big customer";
account.ClientId = "1234";
Assert.That(propsChanged.Count, Is.EqualTo(4));
Assert.That(propsChanged.Count(x => x == "AccountName"), Is.EqualTo(1));
Assert.That(propsChanged.Count(x => x == "ClientId"), Is.EqualTo(1));
Assert.That(propsChanged.Count(x => x == "AccountId"), Is.EqualTo(2));
}
public void CreateForClass()
{
var container = new Container(config =>
{
config
.For<Bar>()
.Use(context => Notifiable.MakeForClassGeneric<Bar>(FireOptions.Always, new ProxyGenerator(), new DependencyMap()));
});
var bar = container.GetInstance<Bar>();
// make sure it's wrapped
Assert.That(bar, Is.InstanceOf<INotifyPropertyChanged>());
// make sure it fires properly
var tracker = new EventTracker<PropertyChangedEventHandler>();
(bar as INotifyPropertyChanged).PropertyChanged += tracker;
bar.Value = "yo";
Assert.That(tracker.WasCalled);
}
public static void Register(Action<StructureMap.ConfigurationExpression> configuration)
{
_container = new StructureMap.Container(configuration);
}
static void Main(string[] args)
{
var container = new StructureMap.Container();
Func<Type, object> serviceLocator = new Func<Type, object>(
(type) =>
{
return container.GetInstance(type);
}
);
ApplicationBus.Bus.Instance.UseServiceLocator(serviceLocator);
var configuration = ServiceBusFactory.New(x =>
{
//x.LogTo<String>();
//x.UseDataprovider<Type>();
//x.what else
x.AddEndPoint(e =>
{
e.UseQueueClient<TimeEcoQueueClient>("End Point 1");
e.DeSerializeTo<TimeMessage>();
e.UseSerializer<EndPoint.XmlDeserializer>();
// e.UseObjectRouter<String>();
});
x.AddEndPoint(e =>
{
e.UseQueueClient<TimeEcoQueueClient>("End Point 2");
e.DeSerializeTo<TimeMessage>();
e.UseSerializer<EndPoint.XmlDeserializer>();
// e.UseObjectRouter<String>();
});
x.AddEndPoint(e =>
{
e.UseQueueClient<TimeEcoQueueClient>("End Point 3");
e.DeSerializeTo<TimeMessage>();
e.UseSerializer<EndPoint.XmlDeserializer>();
// e.UseObjectRouter<String>();
});
x.AddEndPoint(e =>
{
e.UseQueueClient<TimeEcoQueueClient>("End Point 4");
e.DeSerializeTo<TimeMessage>();
e.UseSerializer<EndPoint.XmlDeserializer>();
// e.UseObjectRouter<String>();
});
x.AddEndPoint(e =>
{
e.UseQueueClient<TimeEcoQueueClient>("End Point 5");
e.DeSerializeTo<TimeMessage>();
e.UseSerializer<EndPoint.XmlDeserializer>();
// e.UseObjectRouter<String>();
});
x.AddEndPoint(e =>
{
e.UseQueueClient<TimeEcoQueueClient>("End Point 6");
e.DeSerializeTo<TimeMessage>();
e.UseSerializer<EndPoint.XmlDeserializer>();
// e.UseObjectRouter<String>();
});
});
// ApplicationBus.Bus.RegisterHandlerForCommand<TimeMessage, TimeHandler>();
var host = HostFactory.New(x =>
{
x.Service<ServiceBusHost>(s =>
{
s.SetServiceName("Service Bus Host");
s.ConstructUsing(name => ServiceBusFactory.CreateHost(configuration));
s.WhenStarted(svc => svc.Start());
s.WhenStopped(svc => svc.Stop());
});
x.RunAsLocalSystem();
x.SetDescription("Service Bus Host");
x.SetDisplayName("Service Bus Host");
x.SetServiceName("Service Bus Host");
});
host.Run();
}
public static void Start()
{
var container = new StructureMap.Container();
GlobalConfiguration.Configuration.DependencyResolver = new StructureMapWebApiDependencyResolver(container);
}
static void Main(string[] args)
{
var container = new StructureMap.Container();
var serviceLocator = new Func<Type, object>(container.GetInstance);
ApplicationBus.Bus.Instance.UseServiceLocator(serviceLocator);
var configuration = ServiceBusFactory.New(x =>
{
x.AddEndPoint(Message.OfType<TimeMessage>()
.SerializedBy<EndPoint.XmlDeserializer>()
.UsingClient<TimeEcoQueueClient>()
.WithConnectionString("End Point 1"));
x.AddEndPoint(Message.OfType<TimeMessage>()
.SerializedBy<EndPoint.XmlDeserializer>()
.UsingClient<TimeEcoQueueClient>()
.WithConnectionString("End Point 2"));
x.AddEndPoint(Message.OfType<TimeMessage>()
.SerializedBy<EndPoint.XmlDeserializer>()
.UsingClient<TimeEcoQueueClient>()
.WithConnectionString("End Point 3"));
x.AddEndPoint(Message.OfType<TimeMessage>()
.SerializedBy<EndPoint.XmlDeserializer>()
.UsingClient<TimeEcoQueueClient>()
.WithConnectionString("End Point 4"));
x.AddEndPoint(Message.OfType<TimeMessage>()
.SerializedBy<EndPoint.XmlDeserializer>()
.UsingClient<TimeEcoQueueClient>()
.WithConnectionString("End Point 5"));
x.AddEndPoint(Message.OfType<TimeMessage>()
.SerializedBy<EndPoint.XmlDeserializer>()
.UsingClient<TimeEcoQueueClient>()
.WithConnectionString("End Point 6"));
});
// ApplicationBus.Bus.RegisterHandlerForCommand<TimeMessage, TimeHandler>();
var host = HostFactory.New(x =>
{
x.Service<ServiceBusHost>(s =>
{
s.SetServiceName("Service Bus Host");
s.ConstructUsing(name => ServiceBusFactory.CreateHost(configuration));
s.WhenStarted(svc => svc.Start());
s.WhenStopped(svc => svc.Stop());
});
x.RunAsLocalSystem();
x.SetDescription("Service Bus Host");
x.SetDisplayName("Service Bus Host");
x.SetServiceName("Service Bus Host");
});
host.Run();
}
public void try_out_the_test_package_1()
{
var container = new Container(x =>
{
x.Scan(o =>
{
o.AssemblyContainingType<TestPackage1Registry>();
o.AddAllTypesOf<IFubuRegistryExtension>();
});
});
Debug.WriteLine(container.WhatDoIHave());
}
static StructureMapRegistration()
{
s_container = new StructureMap.Container();
}
public override bool Execute()
{
if (TargetSitemapsFiles == null && TargetProjectFiles == null && TargetUrls == null)
{
Log.LogError("You must specify at least 1 url in order to run the task. " +
"The urls can be provided through TargetUrls, TargetProjectFiles, or TargetSitemapFiles.");
return false;
}
// Setup configuration of DI container
Log.LogMessage(MessageImportance.Low, "Composing Application");
var container = new StructureMap.Container();
container.Configure(r => r.AddRegistry<HtmlValidatorRegistry>());
// Add the current parameters to context
Log.LogMessage(MessageImportance.Low, "Creating Context");
var context = new HtmlValidatorRunnerContext(new ConsoleAnnouncer())
{
TargetSitemapsFiles = this.TargetSitemapsFiles.ToStringArray(),
TargetUrls = this.TargetUrls.ToStringArray(),
TargetProjectFiles = this.TargetProjectFiles.ToStringArray(),
UrlReplacementArgs = this.UrlReplacementArgs.ToStringArray(),
OutputPath = this.OutputPath,
OutputFormat = this.OutputFormat,
ValidatorUrl = this.ValidatorUrl,
DirectInputMode = this.DirectInputMode,
CharSet = this.CharSet,
DocType = this.DocType,
Verbose = this.Verbose,
Debug = this.Debug,
ShowSource = this.ShowSource,
Outline = this.Outline,
GroupErrors = this.GroupErrors,
UseHtmlTidy = this.UseHtmlTidy
};
// Setup the container to use the context as a singleton so it is available everywhere.
container.Configure(r => r.For<IHtmlValidatorRunnerContext>().Singleton().Use(x => context));
container.Configure(r => r.For<IValidatorRunnerContext>().Singleton().Use(x => context));
container.Configure(r => r.For<IRunnerContext>().Singleton().Use(x => context));
var runner = container.GetInstance<IValidatorRunner>();
Log.LogMessage(MessageImportance.Low, "Starting Runner");
try
{
// get output information (errors, warnings)
var report = runner.Execute();
this.TotalErrors = report.TotalErrors;
this.TotalWarnings = report.TotalWarnings;
}
catch (Exception ex)
{
Log.LogError("While executing validation the following error was encountered: {0}, {1}", ex.Message, ex.StackTrace);
return false;
}
return true;
}
