Menu
▾
▴
[Structuremap-commits] SF.net SVN: structuremap: [105] trunk/Source/StructureMap
|
From: <jer...@us...> - 2008-05-28 03:15:35
|
Revision: 105
http://structuremap.svn.sourceforge.net/structuremap/?rev=105&view=rev
Author: jeremydmiller
Date: 2008-05-27 20:15:34 -0700 (Tue, 27 May 2008)
Log Message:
-----------
Cleaning up Registry code
Modified Paths:
--------------
trunk/Source/StructureMap/Configuration/DSL/Expressions/CreatePluginFamilyExpression.cs
trunk/Source/StructureMap/Configuration/DSL/Registry.cs
trunk/Source/StructureMap/Configuration/FamilyParser.cs
trunk/Source/StructureMap/InstanceManager.cs
trunk/Source/StructureMap/StructureMapConfiguration.cs
trunk/Source/StructureMap.Testing/BuildSessionTester.cs
trunk/Source/StructureMap.Testing/Configuration/DSL/AddInstanceTester.cs
trunk/Source/StructureMap.Testing/Configuration/DSL/AddTypesTester.cs
trunk/Source/StructureMap.Testing/Configuration/DSL/ConstructorExpressionTester.cs
trunk/Source/StructureMap.Testing/Configuration/DSL/CreatePluginFamilyTester.cs
trunk/Source/StructureMap.Testing/Configuration/DSL/DeepInstanceTester.cs
trunk/Source/StructureMap.Testing/Configuration/DSL/InjectArrayTester.cs
trunk/Source/StructureMap.Testing/Configuration/DSL/InterceptAllInstancesOfPluginTypeTester.cs
trunk/Source/StructureMap.Testing/Configuration/DSL/InterceptorTesting.cs
trunk/Source/StructureMap.Testing/Configuration/DSL/ProfileExpressionTester.cs
trunk/Source/StructureMap.Testing/Container/ExplicitArgumentTester.cs
trunk/Source/StructureMap.Testing/Container/InstanceFactoryTester.cs
trunk/Source/StructureMap.Testing/Container/InstanceManagerTester.cs
trunk/Source/StructureMap.Testing/Container/Interceptors/TypeInterceptionTester.cs
trunk/Source/StructureMap.Testing/Container/TypeFindingTester.cs
trunk/Source/StructureMap.Testing/GenericsAcceptanceTester.cs
Modified: trunk/Source/StructureMap/Configuration/DSL/Expressions/CreatePluginFamilyExpression.cs
===================================================================
--- trunk/Source/StructureMap/Configuration/DSL/Expressions/CreatePluginFamilyExpression.cs 2008-05-27 23:46:15 UTC (rev 104)
+++ trunk/Source/StructureMap/Configuration/DSL/Expressions/CreatePluginFamilyExpression.cs 2008-05-28 03:15:34 UTC (rev 105)
@@ -32,7 +32,18 @@
});
}
+ public CreatePluginFamilyExpression<PLUGINTYPE> AddInstances(params Instance[] instances)
+ {
+ return alterAndContinue(delegate(PluginFamily family)
+ {
+ foreach (Instance instance in instances)
+ {
+ family.AddInstance(instance);
+ }
+ });
+ }
+
// TODO: 3.5, Try alterAndContinue(f => {});
private CreatePluginFamilyExpression<PLUGINTYPE> alterAndContinue(Action<PluginFamily> action)
{
Modified: trunk/Source/StructureMap/Configuration/DSL/Registry.cs
===================================================================
--- trunk/Source/StructureMap/Configuration/DSL/Registry.cs 2008-05-27 23:46:15 UTC (rev 104)
+++ trunk/Source/StructureMap/Configuration/DSL/Registry.cs 2008-05-28 03:15:34 UTC (rev 105)
@@ -7,7 +7,7 @@
namespace StructureMap.Configuration.DSL
{
- public class Registry : RegistryExpressions, IDisposable
+ public class Registry : RegistryExpressions
{
private readonly List<Action<PluginGraph>> _actions = new List<Action<PluginGraph>>();
private readonly PluginGraph _graph;
@@ -23,15 +23,6 @@
configure();
}
- #region IDisposable Members
-
- public void Dispose()
- {
- ConfigurePluginGraph(_graph);
- }
-
- #endregion
-
/// <summary>
/// Implement this method to
/// </summary>
@@ -86,12 +77,6 @@
return new CreatePluginFamilyExpression<PLUGINTYPE>(this);
}
- public IInstanceManager BuildInstanceManager()
- {
- ConfigurePluginGraph(_graph);
- return new InstanceManager(_graph);
- }
-
public PluginGraph Build()
{
ConfigurePluginGraph(_graph);
Modified: trunk/Source/StructureMap/Configuration/FamilyParser.cs
===================================================================
--- trunk/Source/StructureMap/Configuration/FamilyParser.cs 2008-05-27 23:46:15 UTC (rev 104)
+++ trunk/Source/StructureMap/Configuration/FamilyParser.cs 2008-05-28 03:15:34 UTC (rev 105)
@@ -62,12 +62,12 @@
});
}
- private InstanceScope findScope(XmlElement familyElement)
+ private static InstanceScope findScope(XmlElement familyElement)
{
InstanceScope returnValue = InstanceScope.PerRequest;
string scopeString = familyElement.GetAttribute(XmlConstants.SCOPE_ATTRIBUTE);
- if (scopeString != null && scopeString != string.Empty)
+ if (!string.IsNullOrEmpty(scopeString))
{
returnValue = (InstanceScope) Enum.Parse(typeof (InstanceScope), scopeString);
}
Modified: trunk/Source/StructureMap/InstanceManager.cs
===================================================================
--- trunk/Source/StructureMap/InstanceManager.cs 2008-05-27 23:46:15 UTC (rev 104)
+++ trunk/Source/StructureMap/InstanceManager.cs 2008-05-28 03:15:34 UTC (rev 105)
@@ -27,6 +27,10 @@
construct(registry.Build());
}
+ public InstanceManager(Registry registry) : this(registry.Build())
+ {
+ }
+
public InstanceManager() : this(new PluginGraph())
{
}
@@ -283,6 +287,5 @@
return _pipelineGraph.ForType(type);
}
-
}
}
\ No newline at end of file
Modified: trunk/Source/StructureMap/StructureMapConfiguration.cs
===================================================================
--- trunk/Source/StructureMap/StructureMapConfiguration.cs 2008-05-27 23:46:15 UTC (rev 104)
+++ trunk/Source/StructureMap/StructureMapConfiguration.cs 2008-05-28 03:15:34 UTC (rev 105)
@@ -166,7 +166,12 @@
return _registry.AddInstanceOf<T>();
}
+ public static void AddInstanceOf<T>(Instance instance)
+ {
+ _registry.ForRequestedType<T>().AddInstance(instance);
+ }
+
/// <summary>
/// Adds a preconfigured instance of Type T to StructureMap. When this instance is requested,
/// StructureMap will always return the original object.
Modified: trunk/Source/StructureMap.Testing/BuildSessionTester.cs
===================================================================
--- trunk/Source/StructureMap.Testing/BuildSessionTester.cs 2008-05-27 23:46:15 UTC (rev 104)
+++ trunk/Source/StructureMap.Testing/BuildSessionTester.cs 2008-05-28 03:15:34 UTC (rev 105)
@@ -138,13 +138,13 @@
[Test]
public void If_no_child_array_is_explicitly_defined_return_all_instances()
{
- Registry registry = new Registry();
- registry.AddInstanceOf<IWidget>(new ColorWidget("Red"));
- registry.AddInstanceOf<IWidget>(new ColorWidget("Blue"));
- registry.AddInstanceOf<IWidget>(new ColorWidget("Green"));
+ IInstanceManager manager = new InstanceManager(delegate(Registry registry)
+ {
+ registry.AddInstanceOf<IWidget>(new ColorWidget("Red"));
+ registry.AddInstanceOf<IWidget>(new ColorWidget("Blue"));
+ registry.AddInstanceOf<IWidget>(new ColorWidget("Green"));
+ });
- IInstanceManager manager = registry.BuildInstanceManager();
-
WidgetHolder holder = manager.CreateInstance<WidgetHolder>();
Assert.AreEqual(3, holder.Widgets.Length);
}
Modified: trunk/Source/StructureMap.Testing/Configuration/DSL/AddInstanceTester.cs
===================================================================
--- trunk/Source/StructureMap.Testing/Configuration/DSL/AddInstanceTester.cs 2008-05-27 23:46:15 UTC (rev 104)
+++ trunk/Source/StructureMap.Testing/Configuration/DSL/AddInstanceTester.cs 2008-05-28 03:15:34 UTC (rev 105)
@@ -15,38 +15,38 @@
[SetUp]
public void SetUp()
{
- pluginGraph = new PluginGraph();
- Registry registry = new Registry(pluginGraph);
- registry.ScanAssemblies().IncludeAssemblyContainingType<ColorWidget>();
+
+ manager = new InstanceManager(delegate(Registry registry)
+ {
+ registry.ScanAssemblies().IncludeAssemblyContainingType<ColorWidget>();
- // Add an instance with properties
- registry.AddInstanceOf<IWidget>()
- .UsingConcreteType<ColorWidget>()
- .WithName("DarkGreen")
- .WithProperty("Color").EqualTo("DarkGreen");
+ // Add an instance with properties
+ registry.AddInstanceOf<IWidget>()
+ .UsingConcreteType<ColorWidget>()
+ .WithName("DarkGreen")
+ .WithProperty("Color").EqualTo("DarkGreen");
- // Add an instance by specifying the ConcreteKey
- registry.AddInstanceOf<IWidget>()
- .UsingConcreteTypeNamed("Color")
- .WithName("Purple")
- .WithProperty("Color").EqualTo("Purple");
+ // Add an instance by specifying the ConcreteKey
+ registry.AddInstanceOf<IWidget>()
+ .UsingConcreteTypeNamed("Color")
+ .WithName("Purple")
+ .WithProperty("Color").EqualTo("Purple");
- // Pull a property from the App config
- registry.AddInstanceOf<IWidget>()
- .UsingConcreteType<ColorWidget>()
- .WithName("AppSetting")
- .WithProperty("Color").EqualToAppSetting("Color");
+ // Pull a property from the App config
+ registry.AddInstanceOf<IWidget>()
+ .UsingConcreteType<ColorWidget>()
+ .WithName("AppSetting")
+ .WithProperty("Color").EqualToAppSetting("Color");
- registry.AddInstanceOf<IWidget>().UsingConcreteType<AWidget>();
+ registry.AddInstanceOf<IWidget>().UsingConcreteType<AWidget>();
- manager = registry.BuildInstanceManager();
+ });
}
#endregion
private IInstanceManager manager;
- private PluginGraph pluginGraph;
[Test]
public void AddAnInstanceWithANameAndAPropertySpecifyingConcreteKey()
@@ -65,14 +65,13 @@
[Test]
public void AddInstanceAndOverrideTheConcreteTypeForADependency()
{
- Registry registry = new Registry();
+ IInstanceManager manager = new InstanceManager(delegate(Registry registry)
+ {
+ // Specify a new Instance that specifies the concrete type used for a dependency
+ registry.AddInstanceOf<Rule>().UsingConcreteType<WidgetRule>().WithName("AWidgetRule")
+ .Child<IWidget>().IsConcreteType<AWidget>();
+ });
- // Specify a new Instance that specifies the concrete type used for a dependency
- registry.AddInstanceOf<Rule>().UsingConcreteType<WidgetRule>().WithName("AWidgetRule")
- .Child<IWidget>().IsConcreteType<AWidget>();
-
- manager = registry.BuildInstanceManager();
-
WidgetRule rule = (WidgetRule) manager.CreateInstance<Rule>("AWidgetRule");
Assert.IsInstanceOfType(typeof (AWidget), rule.Widget);
}
@@ -88,13 +87,12 @@
[Test]
public void SimpleCaseWithNamedInstance()
{
- Registry registry = new Registry();
+ manager = new InstanceManager(delegate(Registry registry)
+ {
+ // Specify a new Instance and override the Name
+ registry.AddInstanceOf<IWidget>().UsingConcreteType<AWidget>().WithName("MyInstance");
+ });
- // Specify a new Instance and override the Name
- registry.AddInstanceOf<IWidget>().UsingConcreteType<AWidget>().WithName("MyInstance");
-
- manager = registry.BuildInstanceManager();
-
AWidget widget = (AWidget) manager.CreateInstance<IWidget>("MyInstance");
Assert.IsNotNull(widget);
}
@@ -102,25 +100,21 @@
[Test]
public void SpecifyANewInstanceOverrideADependencyWithANamedInstance()
{
- Registry registry = new Registry();
+ manager = new InstanceManager(delegate(Registry registry)
+ {
+ registry.AddInstanceOf<Rule>().UsingConcreteType<ARule>().WithName("Alias");
- //registry.ScanAssemblies().IncludeAssemblyContainingType<IWidget>();
+ // Add an instance by specifying the ConcreteKey
+ registry.AddInstanceOf<IWidget>()
+ .UsingConcreteType<ColorWidget>()
+ .WithName("Purple")
+ .WithProperty("Color").EqualTo("Purple");
+ // Specify a new Instance, override a dependency with a named instance
+ registry.AddInstanceOf<Rule>().UsingConcreteType<WidgetRule>().WithName("RuleThatUsesMyInstance")
+ .Child<IWidget>("widget").IsNamedInstance("Purple");
+ });
- registry.AddInstanceOf<Rule>().UsingConcreteType<ARule>().WithName("Alias");
-
- // Add an instance by specifying the ConcreteKey
- registry.AddInstanceOf<IWidget>()
- .UsingConcreteType<ColorWidget>()
- .WithName("Purple")
- .WithProperty("Color").EqualTo("Purple");
-
- // Specify a new Instance, override a dependency with a named instance
- registry.AddInstanceOf<Rule>().UsingConcreteType<WidgetRule>().WithName("RuleThatUsesMyInstance")
- .Child<IWidget>("widget").IsNamedInstance("Purple");
-
- manager = registry.BuildInstanceManager();
-
Assert.IsInstanceOfType(typeof (ARule), manager.CreateInstance<Rule>("Alias"));
WidgetRule rule = (WidgetRule) manager.CreateInstance<Rule>("RuleThatUsesMyInstance");
@@ -131,21 +125,21 @@
[Test]
public void SpecifyANewInstanceWithADependency()
{
- Registry registry = new Registry();
-
// Specify a new Instance, create an instance for a dependency on the fly
string instanceKey = "OrangeWidgetRule";
- registry.AddInstanceOf<Rule>().UsingConcreteType<WidgetRule>().WithName(instanceKey)
- .Child<IWidget>().Is(
- Registry.Instance<IWidget>().UsingConcreteType<ColorWidget>()
- .WithProperty("Color").EqualTo("Orange")
- .WithName("Orange")
- );
- IInstanceManager mgr = registry.BuildInstanceManager();
+ IInstanceManager manager = new InstanceManager(delegate(Registry registry)
+ {
+ registry.AddInstanceOf<Rule>().UsingConcreteType<WidgetRule>().WithName(instanceKey)
+ .Child<IWidget>().Is(
+ Registry.Instance<IWidget>().UsingConcreteType<ColorWidget>()
+ .WithProperty("Color").EqualTo("Orange")
+ .WithName("Orange")
+ );
+ });
- WidgetRule rule = (WidgetRule) mgr.CreateInstance<Rule>(instanceKey);
+ WidgetRule rule = (WidgetRule) manager.CreateInstance<Rule>(instanceKey);
ColorWidget widget = (ColorWidget) rule.Widget;
Assert.AreEqual("Orange", widget.Color);
}
@@ -153,13 +147,15 @@
[Test]
public void UseAPreBuiltObjectForAnInstanceAsAPrototype()
{
- Registry registry = new Registry();
// Build an instance for IWidget, then setup StructureMap to return cloned instances of the
// "Prototype" (GoF pattern) whenever someone asks for IWidget named "Jeremy"
CloneableWidget theWidget = new CloneableWidget("Jeremy");
- registry.AddPrototypeInstanceOf<IWidget>(theWidget).WithName("Jeremy");
+
- manager = registry.BuildInstanceManager();
+ manager = new InstanceManager(delegate(Registry registry)
+ {
+ registry.AddPrototypeInstanceOf<IWidget>(theWidget).WithName("Jeremy");
+ });
CloneableWidget widget1 = (CloneableWidget) manager.CreateInstance<IWidget>("Jeremy");
CloneableWidget widget2 = (CloneableWidget) manager.CreateInstance<IWidget>("Jeremy");
@@ -178,12 +174,13 @@
[Test]
public void UseAPreBuiltObjectWithAName()
{
- Registry registry = new Registry();
// Return the specific instance when an IWidget named "Julia" is requested
CloneableWidget julia = new CloneableWidget("Julia");
- registry.AddInstanceOf<IWidget>(julia).WithName("Julia");
- manager = registry.BuildInstanceManager();
+ manager = new InstanceManager(delegate(Registry registry)
+ {
+ registry.AddInstanceOf<IWidget>(julia).WithName("Julia");
+ });
CloneableWidget widget1 = (CloneableWidget) manager.CreateInstance<IWidget>("Julia");
CloneableWidget widget2 = (CloneableWidget) manager.CreateInstance<IWidget>("Julia");
Modified: trunk/Source/StructureMap.Testing/Configuration/DSL/AddTypesTester.cs
===================================================================
--- trunk/Source/StructureMap.Testing/Configuration/DSL/AddTypesTester.cs 2008-05-27 23:46:15 UTC (rev 104)
+++ trunk/Source/StructureMap.Testing/Configuration/DSL/AddTypesTester.cs 2008-05-28 03:15:34 UTC (rev 105)
@@ -30,14 +30,15 @@
[Test]
public void A_concrete_type_is_available_by_name_when_it_is_added_by_the_shorthand_mechanism()
{
- Registry registry = new Registry();
- registry.ForRequestedType<IAddTypes>()
- .AddConcreteType<RedAddTypes>("Red")
- .AddConcreteType<GreenAddTypes>("Green")
- .AddConcreteType<BlueAddTypes>("Blue")
- .AddConcreteType<PurpleAddTypes>();
+ IInstanceManager manager = new InstanceManager(delegate(Registry registry)
+ {
+ registry.ForRequestedType<IAddTypes>()
+ .AddConcreteType<RedAddTypes>("Red")
+ .AddConcreteType<GreenAddTypes>("Green")
+ .AddConcreteType<BlueAddTypes>("Blue")
+ .AddConcreteType<PurpleAddTypes>();
+ });
- IInstanceManager manager = registry.BuildInstanceManager();
Assert.IsInstanceOfType(typeof (RedAddTypes), manager.CreateInstance<IAddTypes>("Red"));
Assert.IsInstanceOfType(typeof (GreenAddTypes), manager.CreateInstance<IAddTypes>("Green"));
Assert.IsInstanceOfType(typeof (BlueAddTypes), manager.CreateInstance<IAddTypes>("Blue"));
@@ -46,28 +47,33 @@
[Test]
public void A_concrete_type_is_available_when_it_is_added_by_the_shorthand_mechanism()
{
- Registry registry = new Registry();
- registry.ForRequestedType<IAddTypes>()
- .AddConcreteType<RedAddTypes>()
- .AddConcreteType<GreenAddTypes>()
- .AddConcreteType<BlueAddTypes>()
- .AddConcreteType<PurpleAddTypes>();
+ IInstanceManager manager = new InstanceManager(delegate(Registry registry)
+ {
+ registry.ForRequestedType<IAddTypes>()
+ .AddConcreteType<RedAddTypes>()
+ .AddConcreteType<GreenAddTypes>()
+ .AddConcreteType<BlueAddTypes>()
+ .AddConcreteType<PurpleAddTypes>();
+ });
- IList<IAddTypes> instances = registry.BuildInstanceManager().GetAllInstances<IAddTypes>();
+
+ IList<IAddTypes> instances = manager.GetAllInstances<IAddTypes>();
Assert.AreEqual(4, instances.Count);
}
[Test]
public void Make_sure_that_we_dont_double_dip_instances_when_we_register_a_type_with_a_name()
{
- Registry registry = new Registry();
- registry.ForRequestedType<IAddTypes>()
- .AddConcreteType<RedAddTypes>("Red")
- .AddConcreteType<GreenAddTypes>()
- .AddConcreteType<BlueAddTypes>("Blue")
- .AddConcreteType<PurpleAddTypes>();
+ IInstanceManager manager = new InstanceManager(delegate(Registry registry)
+ {
+ registry.ForRequestedType<IAddTypes>()
+ .AddConcreteType<RedAddTypes>("Red")
+ .AddConcreteType<GreenAddTypes>()
+ .AddConcreteType<BlueAddTypes>("Blue")
+ .AddConcreteType<PurpleAddTypes>();
+ });
- IList<IAddTypes> instances = registry.BuildInstanceManager().GetAllInstances<IAddTypes>();
+ IList<IAddTypes> instances = manager.GetAllInstances<IAddTypes>();
Assert.AreEqual(4, instances.Count);
}
}
Modified: trunk/Source/StructureMap.Testing/Configuration/DSL/ConstructorExpressionTester.cs
===================================================================
--- trunk/Source/StructureMap.Testing/Configuration/DSL/ConstructorExpressionTester.cs 2008-05-27 23:46:15 UTC (rev 104)
+++ trunk/Source/StructureMap.Testing/Configuration/DSL/ConstructorExpressionTester.cs 2008-05-28 03:15:34 UTC (rev 105)
@@ -31,17 +31,15 @@
Concretion concretion1 = new Concretion();
Concretion concretion2 = new Concretion();
- Registry registry = new Registry();
- registry.ForRequestedType<Abstraction>()
- .AddInstance(
- ConstructedBy<Abstraction>(delegate { return concretion1; }).WithName("One")
- )
- .AddInstance(
- ConstructedBy<Abstraction>(delegate { return concretion2; }).WithName("Two")
- );
+ IInstanceManager manager = new InstanceManager(delegate(Registry registry)
+ {
+ registry.ForRequestedType<Abstraction>()
+ .AddInstances(
+ ConstructedBy<Abstraction>(delegate { return concretion1; }).WithName("One"),
+ ConstructedBy<Abstraction>(delegate { return concretion2; }).WithName("Two")
+ );
+ });
- IInstanceManager manager = registry.BuildInstanceManager();
-
Assert.AreSame(concretion1, manager.CreateInstance<Abstraction>("One"));
Assert.AreSame(concretion2, manager.CreateInstance<Abstraction>("Two"));
}
@@ -51,12 +49,13 @@
{
Concretion concretion = new Concretion();
- Registry registry = new Registry();
- registry.ForRequestedType<Abstraction>().TheDefaultIs(
- ConstructedBy<Abstraction>(delegate { return concretion; })
- );
+ IInstanceManager manager = new InstanceManager(delegate(Registry registry)
+ {
+ registry.ForRequestedType<Abstraction>().TheDefaultIs(
+ ConstructedBy<Abstraction>(delegate { return concretion; })
+ );
+ });
- IInstanceManager manager = registry.BuildInstanceManager();
Assert.AreSame(concretion, manager.CreateInstance<Abstraction>());
}
@@ -66,17 +65,17 @@
Concretion concretion1 = new Concretion();
Concretion concretion2 = new Concretion();
- Registry registry = new Registry();
- registry.ForRequestedType<Abstraction>().AddInstance(
- ConstructedBy<Abstraction>(delegate { return concretion1; }).WithName("One")
- );
+ IInstanceManager manager = new InstanceManager(delegate(Registry registry)
+ {
+ registry.ForRequestedType<Abstraction>().AddInstance(
+ ConstructedBy<Abstraction>(delegate { return concretion1; }).WithName("One")
+ );
- registry.ForRequestedType<Abstraction>().AddInstance(
- ConstructedBy<Abstraction>(delegate { return concretion2; }).WithName("Two")
- );
+ registry.ForRequestedType<Abstraction>().AddInstance(
+ ConstructedBy<Abstraction>(delegate { return concretion2; }).WithName("Two")
+ );
+ });
- IInstanceManager manager = registry.BuildInstanceManager();
-
Assert.AreSame(concretion1, manager.CreateInstance<Abstraction>("One"));
Assert.AreSame(concretion2, manager.CreateInstance<Abstraction>("Two"));
}
@@ -86,14 +85,13 @@
{
Concretion concretion = new Concretion();
- Registry registry = new Registry();
- registry.ForRequestedType<Abstraction>().AddInstance(
- ConstructedBy<Abstraction>(delegate { return concretion; })
- );
+ IInstanceManager manager = new InstanceManager(delegate(Registry registry)
+ {
+ registry.ForRequestedType<Abstraction>().AddInstance(
+ ConstructedBy<Abstraction>(delegate { return concretion; })
+ );
+ });
-
- IInstanceManager manager = registry.BuildInstanceManager();
-
Abstraction actual = manager.GetAllInstances<Abstraction>()[0];
Assert.AreSame(concretion, actual);
}
Modified: trunk/Source/StructureMap.Testing/Configuration/DSL/CreatePluginFamilyTester.cs
===================================================================
--- trunk/Source/StructureMap.Testing/Configuration/DSL/CreatePluginFamilyTester.cs 2008-05-27 23:46:15 UTC (rev 104)
+++ trunk/Source/StructureMap.Testing/Configuration/DSL/CreatePluginFamilyTester.cs 2008-05-28 03:15:34 UTC (rev 105)
@@ -5,7 +5,6 @@
using StructureMap.Configuration.DSL;
using StructureMap.Configuration.DSL.Expressions;
using StructureMap.Graph;
-using StructureMap.Interceptors;
using StructureMap.Pipeline;
using StructureMap.Testing.Widget;
using StructureMap.Testing.Widget3;
@@ -37,14 +36,36 @@
}
[Test]
- public void AddInstanceByNameOnlyAddsOneInstanceToStructureMap()
+ public void Add_an_instance_by_lambda()
{
- Registry registry = new Registry();
- registry.ForRequestedType<Something>().AddInstance(
- Registry.Instance<Something>().UsingConcreteType<RedSomething>().WithName("Red")
- );
+ InstanceManager manager =
+ new InstanceManager(
+ delegate(Registry registry) { registry.ForRequestedType<IWidget>().AddInstance(delegate { return new AWidget(); }); });
- IInstanceManager manager = registry.BuildInstanceManager();
+ Assert.IsInstanceOfType(typeof (AWidget), manager.GetAllInstances<IWidget>()[0]);
+ }
+
+ [Test]
+ public void Add_an_instance_by_literal()
+ {
+ AWidget aWidget = new AWidget();
+
+ InstanceManager manager =
+ new InstanceManager(
+ delegate(Registry registry) { registry.ForRequestedType<IWidget>().AddInstance(aWidget); });
+
+ Assert.IsInstanceOfType(typeof (AWidget), manager.GetAllInstances<IWidget>()[0]);
+ }
+
+ [Test]
+ public void AddInstanceByNameOnlyAddsOneInstanceToStructureMap()
+ {
+ IInstanceManager manager = new InstanceManager(delegate(Registry registry)
+ {
+ registry.ForRequestedType<Something>().AddInstance(
+ RegistryExpressions.Instance<Something>().UsingConcreteType<RedSomething>().WithName("Red")
+ );
+ });
IList<Something> instances = manager.GetAllInstances<Something>();
Assert.AreEqual(1, instances.Count);
}
@@ -52,12 +73,10 @@
[Test]
public void AddInstanceWithNameOnlyAddsOneInstanceToStructureMap()
{
- PluginGraph graph = new PluginGraph();
- Registry registry = new Registry(graph);
- registry.AddInstanceOf<Something>().UsingConcreteType<RedSomething>().WithName("Red");
-
-
- IInstanceManager manager = registry.BuildInstanceManager();
+ IInstanceManager manager = new InstanceManager(delegate(Registry registry)
+ {
+ registry.AddInstanceOf<Something>().UsingConcreteType<RedSomething>().WithName("Red");
+ });
IList<Something> instances = manager.GetAllInstances<Something>();
Assert.AreEqual(1, instances.Count);
}
@@ -65,72 +84,64 @@
[Test]
public void AsAnotherScope()
{
- PluginGraph pluginGraph = new PluginGraph();
- using (Registry registry = new Registry(pluginGraph))
- {
- CreatePluginFamilyExpression<IGateway> expression =
- registry.BuildInstancesOf<IGateway>().CacheBy(InstanceScope.ThreadLocal);
- Assert.IsNotNull(expression);
- }
+ Registry registry = new Registry();
+ CreatePluginFamilyExpression<IGateway> expression =
+ registry.BuildInstancesOf<IGateway>().CacheBy(InstanceScope.ThreadLocal);
+ Assert.IsNotNull(expression);
+ PluginGraph pluginGraph = registry.Build();
+
PluginFamily family = pluginGraph.FindFamily(typeof (IGateway));
- Assert.IsInstanceOfType(typeof(ThreadLocalStoragePolicy), family.Policy);
+ Assert.IsInstanceOfType(typeof (ThreadLocalStoragePolicy), family.Policy);
}
[Test]
public void BuildInstancesOfType()
{
- PluginGraph pluginGraph = new PluginGraph();
- using (Registry registry = new Registry(pluginGraph))
- {
- registry.BuildInstancesOf<IGateway>();
- }
+ Registry registry = new Registry();
+ registry.BuildInstancesOf<IGateway>();
+ PluginGraph pluginGraph = registry.Build();
- Assert.IsTrue(pluginGraph.ContainsFamily(typeof(IGateway)));
+ Assert.IsTrue(pluginGraph.ContainsFamily(typeof (IGateway)));
}
[Test]
public void BuildPluginFamilyAsPerRequest()
{
- PluginGraph pluginGraph = new PluginGraph();
- using (Registry registry = new Registry(pluginGraph))
- {
- CreatePluginFamilyExpression<IGateway> expression =
- registry.BuildInstancesOf<IGateway>();
- Assert.IsNotNull(expression);
- }
+ Registry registry = new Registry();
+ CreatePluginFamilyExpression<IGateway> expression =
+ registry.BuildInstancesOf<IGateway>();
+ Assert.IsNotNull(expression);
+ PluginGraph pluginGraph = registry.Build();
+
PluginFamily family = pluginGraph.FindFamily(typeof (IGateway));
- Assert.IsInstanceOfType(typeof(BuildPolicy), family.Policy);
+ Assert.IsInstanceOfType(typeof (BuildPolicy), family.Policy);
}
[Test]
public void BuildPluginFamilyAsSingleton()
{
- PluginGraph pluginGraph = new PluginGraph();
- using (Registry registry = new Registry(pluginGraph))
- {
- CreatePluginFamilyExpression<IGateway> expression =
- registry.BuildInstancesOf<IGateway>().AsSingletons();
- Assert.IsNotNull(expression);
- }
+ Registry registry = new Registry();
+ CreatePluginFamilyExpression<IGateway> expression =
+ registry.BuildInstancesOf<IGateway>().AsSingletons();
+ Assert.IsNotNull(expression);
+ PluginGraph pluginGraph = registry.Build();
PluginFamily family = pluginGraph.FindFamily(typeof (IGateway));
- Assert.IsInstanceOfType(typeof(SingletonPolicy), family.Policy);
+ Assert.IsInstanceOfType(typeof (SingletonPolicy), family.Policy);
}
[Test]
public void CanOverrideTheDefaultInstance1()
{
- PluginGraph pluginGraph = new PluginGraph();
- using (Registry registry = new Registry(pluginGraph))
- {
- // Specify the default implementation for an interface
- registry.BuildInstancesOf<IGateway>().TheDefaultIsConcreteType<StubbedGateway>();
- }
+ Registry registry = new Registry();
+ // Specify the default implementation for an interface
+ registry.BuildInstancesOf<IGateway>().TheDefaultIsConcreteType<StubbedGateway>();
- Assert.IsTrue(pluginGraph.ContainsFamily(typeof(IGateway)));
+ PluginGraph pluginGraph = registry.Build();
+ Assert.IsTrue(pluginGraph.ContainsFamily(typeof (IGateway)));
InstanceManager manager = new InstanceManager(pluginGraph);
IGateway gateway = (IGateway) manager.CreateInstance(typeof (IGateway));
@@ -141,13 +152,11 @@
[Test]
public void CanOverrideTheDefaultInstanceAndCreateAnAllNewPluginOnTheFly()
{
- PluginGraph pluginGraph = new PluginGraph();
- using (Registry registry = new Registry(pluginGraph))
- {
- registry.BuildInstancesOf<IGateway>().TheDefaultIsConcreteType<FakeGateway>();
- }
+ Registry registry = new Registry();
+ registry.BuildInstancesOf<IGateway>().TheDefaultIsConcreteType<FakeGateway>();
+ PluginGraph pluginGraph = registry.Build();
- Assert.IsTrue(pluginGraph.ContainsFamily(typeof(IGateway)));
+ Assert.IsTrue(pluginGraph.ContainsFamily(typeof (IGateway)));
InstanceManager manager = new InstanceManager(pluginGraph);
IGateway gateway = (IGateway) manager.CreateInstance(typeof (IGateway));
@@ -158,13 +167,14 @@
[Test]
public void CreatePluginFamilyWithADefault()
{
- Registry registry = new Registry();
- registry.BuildInstancesOf<IWidget>().TheDefaultIs(
- Registry.Instance<IWidget>().UsingConcreteType<ColorWidget>().WithProperty("Color").EqualTo("Red")
- );
+ IInstanceManager manager = new InstanceManager(delegate(Registry registry)
+ {
+ registry.BuildInstancesOf<IWidget>().TheDefaultIs(
+ RegistryExpressions.Instance<IWidget>().UsingConcreteType<ColorWidget>().WithProperty("Color").EqualTo(
+ "Red")
+ );
+ });
- IInstanceManager manager = registry.BuildInstanceManager();
-
ColorWidget widget = (ColorWidget) manager.CreateInstance<IWidget>();
Assert.AreEqual("Red", widget.Color);
}
@@ -174,44 +184,22 @@
{
StubbedInstanceFactoryInterceptor factoryInterceptor = new StubbedInstanceFactoryInterceptor();
- PluginGraph pluginGraph = new PluginGraph();
- using (Registry registry = new Registry(pluginGraph))
- {
- registry.BuildInstancesOf<IGateway>().InterceptConstructionWith(factoryInterceptor);
- }
-
- Assert.AreSame(pluginGraph.FindFamily(typeof(IGateway)).Policy, factoryInterceptor);
- }
-
- [Test]
- public void TheDefaultInstanceIsConcreteType()
- {
Registry registry = new Registry();
+ registry.BuildInstancesOf<IGateway>().InterceptConstructionWith(factoryInterceptor);
- // Needs to blow up if the concrete type can't be used
- registry.BuildInstancesOf<Rule>().TheDefaultIsConcreteType<ARule>();
+ PluginGraph pluginGraph = registry.Build();
- IInstanceManager manager = registry.BuildInstanceManager();
-
- Assert.IsInstanceOfType(typeof (ARule), manager.CreateInstance<Rule>());
+ Assert.AreSame(pluginGraph.FindFamily(typeof (IGateway)).Policy, factoryInterceptor);
}
[Test]
- public void TheDefaultInstanceIsPickedUpFromTheAttribute()
+ public void Set_the_default_by_a_lambda()
{
- PluginGraph pluginGraph = new PluginGraph();
- using (Registry registry = new Registry(pluginGraph))
- {
- registry.BuildInstancesOf<IGateway>();
- registry.ScanAssemblies().IncludeAssemblyContainingType<IGateway>();
- }
+ InstanceManager manager =
+ new InstanceManager(
+ delegate(Registry registry) { registry.ForRequestedType<IWidget>().TheDefaultIs(delegate { return new AWidget(); }); });
- Assert.IsTrue(pluginGraph.ContainsFamily(typeof(IGateway)));
-
- InstanceManager manager = new InstanceManager(pluginGraph);
- IGateway gateway = (IGateway) manager.CreateInstance(typeof (IGateway));
-
- Assert.IsInstanceOfType(typeof (DefaultGateway), gateway);
+ Assert.IsInstanceOfType(typeof (AWidget), manager.CreateInstance<IWidget>());
}
[Test]
@@ -219,56 +207,51 @@
{
AWidget aWidget = new AWidget();
- InstanceManager manager = new InstanceManager(delegate(Registry registry)
- {
- registry.ForRequestedType<IWidget>().TheDefaultIs(aWidget);
- });
+ InstanceManager manager =
+ new InstanceManager(
+ delegate(Registry registry) { registry.ForRequestedType<IWidget>().TheDefaultIs(aWidget); });
Assert.AreSame(aWidget, manager.CreateInstance<IWidget>());
}
[Test]
- public void Set_the_default_by_a_lambda()
+ public void TheDefaultInstanceIsConcreteType()
{
- InstanceManager manager = new InstanceManager(delegate(Registry registry)
+ IInstanceManager manager = new InstanceManager(delegate(Registry registry)
{
- registry.ForRequestedType<IWidget>().TheDefaultIs(delegate() { return new AWidget(); });
+ // Needs to blow up if the concrete type can't be used
+ registry.BuildInstancesOf<Rule>().TheDefaultIsConcreteType<ARule>();
});
- Assert.IsInstanceOfType(typeof(AWidget), manager.CreateInstance<IWidget>());
+ Assert.IsInstanceOfType(typeof (ARule), manager.CreateInstance<Rule>());
}
[Test]
- public void Add_an_instance_by_literal()
+ public void TheDefaultInstanceIsPickedUpFromTheAttribute()
{
- AWidget aWidget = new AWidget();
+ Registry registry = new Registry();
+ registry.BuildInstancesOf<IGateway>();
+ registry.ScanAssemblies().IncludeAssemblyContainingType<IGateway>();
- InstanceManager manager = new InstanceManager(delegate(Registry registry)
- {
- registry.ForRequestedType<IWidget>().AddInstance(aWidget);
- });
+ PluginGraph pluginGraph = registry.Build();
- Assert.IsInstanceOfType(typeof(AWidget), manager.GetAllInstances<IWidget>()[0]);
- }
+ Assert.IsTrue(pluginGraph.ContainsFamily(typeof (IGateway)));
- [Test]
- public void Add_an_instance_by_lambda()
- {
- InstanceManager manager = new InstanceManager(delegate(Registry registry)
- {
- registry.ForRequestedType<IWidget>().AddInstance(delegate() { return new AWidget(); });
- });
+ InstanceManager manager = new InstanceManager(pluginGraph);
+ IGateway gateway = (IGateway) manager.CreateInstance(typeof (IGateway));
- Assert.IsInstanceOfType(typeof(AWidget), manager.GetAllInstances<IWidget>()[0]);
+ Assert.IsInstanceOfType(typeof (DefaultGateway), gateway);
}
}
public class StubbedInstanceFactoryInterceptor : IBuildInterceptor
{
+ #region IBuildInterceptor Members
+
public IBuildPolicy InnerPolicy
{
get { throw new NotImplementedException(); }
- set { }
+ set { }
}
public object Build(IBuildSession buildSession, Type pluginType, Instance instance)
@@ -280,5 +263,7 @@
{
throw new NotImplementedException();
}
+
+ #endregion
}
}
\ No newline at end of file
Modified: trunk/Source/StructureMap.Testing/Configuration/DSL/DeepInstanceTester.cs
===================================================================
--- trunk/Source/StructureMap.Testing/Configuration/DSL/DeepInstanceTester.cs 2008-05-27 23:46:15 UTC (rev 104)
+++ trunk/Source/StructureMap.Testing/Configuration/DSL/DeepInstanceTester.cs 2008-05-28 03:15:34 UTC (rev 105)
@@ -1,19 +1,18 @@
using NUnit.Framework;
using StructureMap.Configuration.DSL;
-using StructureMap.Configuration.DSL.Expressions;
using StructureMap.Pipeline;
using StructureMap.Testing.Widget;
namespace StructureMap.Testing.Configuration.DSL
{
[TestFixture]
- public class DeepInstanceTester
+ public class DeepInstanceTester : RegistryExpressions
{
- private Thing _prototype = new Thing(4, "Jeremy", .333, new WidgetRule(new ColorWidget("yellow")));
+ private readonly Thing _prototype = new Thing(4, "Jeremy", .333, new WidgetRule(new ColorWidget("yellow")));
- private void assertThingMatches(Registry registry)
+ private void assertThingMatches(Action<Registry> action)
{
- IInstanceManager manager = registry.BuildInstanceManager();
+ IInstanceManager manager = new InstanceManager(action);
Thing actual = manager.CreateInstance<Thing>();
Assert.AreEqual(_prototype, actual);
}
@@ -21,129 +20,129 @@
[Test]
public void DeepInstance2()
{
- Registry registry = new Registry();
- registry.BuildInstancesOf<IWidget>().TheDefaultIs(
- Registry.Instance<IWidget>().UsingConcreteType<ColorWidget>()
- .WithProperty("Color").EqualTo("yellow")
- );
+ assertThingMatches(delegate(Registry registry)
+ {
+ registry.BuildInstancesOf<IWidget>().TheDefaultIs(
+ Instance<IWidget>().UsingConcreteType<ColorWidget>()
+ .WithProperty("Color").EqualTo("yellow")
+ );
- registry.BuildInstancesOf<Rule>().TheDefaultIsConcreteType<WidgetRule>();
+ registry.BuildInstancesOf<Rule>().TheDefaultIsConcreteType<WidgetRule>();
- registry.BuildInstancesOf<Thing>().TheDefaultIs(
- Registry.Instance<Thing>()
- .UsingConcreteType<Thing>()
- .WithProperty("average").EqualTo(.333)
- .WithProperty("name").EqualTo("Jeremy")
- .WithProperty("count").EqualTo(4)
- );
-
- assertThingMatches(registry);
+ registry.BuildInstancesOf<Thing>().TheDefaultIs(
+ Instance<Thing>()
+ .UsingConcreteType<Thing>()
+ .WithProperty("average").EqualTo(.333)
+ .WithProperty("name").EqualTo("Jeremy")
+ .WithProperty("count").EqualTo(4)
+ );
+ });
}
[Test]
public void DeepInstance3()
{
- Registry registry = new Registry();
- registry.BuildInstancesOf<IWidget>().TheDefaultIs(
- Registry.Object<IWidget>(new ColorWidget("yellow"))
- );
+ assertThingMatches(delegate(Registry registry)
+ {
+ registry.BuildInstancesOf<IWidget>().TheDefaultIs(
+ Object<IWidget>(new ColorWidget("yellow"))
+ );
- registry.BuildInstancesOf<Rule>().TheDefaultIsConcreteType<WidgetRule>();
+ registry.BuildInstancesOf<Rule>().TheDefaultIsConcreteType<WidgetRule>();
- registry.BuildInstancesOf<Thing>().TheDefaultIs(
- Registry.Instance<Thing>()
- .UsingConcreteType<Thing>()
- .WithProperty("average").EqualTo(.333)
- .WithProperty("name").EqualTo("Jeremy")
- .WithProperty("count").EqualTo(4)
- );
-
- assertThingMatches(registry);
+ registry.BuildInstancesOf<Thing>().TheDefaultIs(
+ Instance<Thing>()
+ .UsingConcreteType<Thing>()
+ .WithProperty("average").EqualTo(.333)
+ .WithProperty("name").EqualTo("Jeremy")
+ .WithProperty("count").EqualTo(4)
+ );
+ });
}
[Test]
public void DeepInstance4()
{
- Registry registry = new Registry();
- registry.BuildInstancesOf<IWidget>().TheDefaultIs(
- Registry.Prototype<IWidget>(new ColorWidget("yellow"))
- );
+ assertThingMatches(delegate(Registry registry)
+ {
+ registry.BuildInstancesOf<IWidget>().TheDefaultIs(
+ Prototype<IWidget>(new ColorWidget("yellow"))
+ );
- registry.BuildInstancesOf<Rule>().TheDefaultIsConcreteType<WidgetRule>();
+ registry.BuildInstancesOf<Rule>().TheDefaultIsConcreteType<WidgetRule>();
- registry.BuildInstancesOf<Thing>().TheDefaultIs(
- Registry.Instance<Thing>()
- .UsingConcreteType<Thing>()
- .WithProperty("average").EqualTo(.333)
- .WithProperty("name").EqualTo("Jeremy")
- .WithProperty("count").EqualTo(4)
- );
-
- assertThingMatches(registry);
+ registry.BuildInstancesOf<Thing>().TheDefaultIs(
+ Instance<Thing>()
+ .UsingConcreteType<Thing>()
+ .WithProperty("average").EqualTo(.333)
+ .WithProperty("name").EqualTo("Jeremy")
+ .WithProperty("count").EqualTo(4)
+ );
+ });
}
[Test]
public void DeepInstance5()
{
- Registry registry = new Registry();
+ assertThingMatches(delegate(Registry registry)
+ {
+ registry.AddInstanceOf<IWidget>()
+ .UsingConcreteType<ColorWidget>()
+ .WithName("Yellow")
+ .WithProperty("Color").EqualTo("yellow");
- registry.AddInstanceOf<IWidget>()
- .UsingConcreteType<ColorWidget>()
- .WithName("Yellow")
- .WithProperty("Color").EqualTo("yellow");
+ registry.AddInstanceOf<Rule>()
+ .UsingConcreteType<WidgetRule>()
+ .WithName("TheWidgetRule")
+ .Child<IWidget>().IsNamedInstance("Yellow");
- registry.AddInstanceOf<Rule>()
- .UsingConcreteType<WidgetRule>()
- .WithName("TheWidgetRule")
- .Child<IWidget>().IsNamedInstance("Yellow");
-
- registry.BuildInstancesOf<Thing>().TheDefaultIs(
- Registry.Instance<Thing>()
- .UsingConcreteType<Thing>()
- .WithProperty("average").EqualTo(.333)
- .WithProperty("name").EqualTo("Jeremy")
- .WithProperty("count").EqualTo(4)
- .Child<Rule>().IsNamedInstance("TheWidgetRule")
- );
-
- assertThingMatches(registry);
+ registry.BuildInstancesOf<Thing>().TheDefaultIs(
+ Instance<Thing>()
+ .UsingConcreteType<Thing>()
+ .WithProperty("average").EqualTo(.333)
+ .WithProperty("name").EqualTo("Jeremy")
+ .WithProperty("count").EqualTo(4)
+ .Child<Rule>().IsNamedInstance("TheWidgetRule")
+ );
+ });
}
[Test]
public void DeepInstanceTest1()
{
- Registry registry = new Registry();
- ConfiguredInstance widgetExpression = Registry.Instance<IWidget>()
+ ConfiguredInstance widgetExpression = Instance<IWidget>()
.UsingConcreteType<ColorWidget>()
.WithProperty("Color").EqualTo("yellow");
- ConfiguredInstance ruleExpression = Registry.Instance<Rule>()
+ ConfiguredInstance ruleExpression = Instance<Rule>()
.UsingConcreteType<WidgetRule>()
.Child<IWidget>().Is(widgetExpression);
- registry.BuildInstancesOf<Thing>().TheDefaultIs(
- Registry.Instance<Thing>()
- .UsingConcreteType<Thing>()
- .WithProperty("name").EqualTo("Jeremy")
- .WithProperty("count").EqualTo(4)
- .WithProperty("average").EqualTo(.333)
- .Child<Rule>().Is(
- ruleExpression
- )
- );
- assertThingMatches(registry);
+ assertThingMatches(delegate(Registry registry)
+ {
+ registry.BuildInstancesOf<Thing>().TheDefaultIs(
+ Instance<Thing>()
+ .UsingConcreteType<Thing>()
+ .WithProperty("name").EqualTo("Jeremy")
+ .WithProperty("count").EqualTo(4)
+ .WithProperty("average").EqualTo(.333)
+ .Child<Rule>().Is(
+ ruleExpression
+ )
+ );
+ });
}
}
public class Thing
{
- private double _average;
- private int _count;
- private string _name;
- private Rule _rule;
+ private readonly double _average;
+ private readonly int _count;
+ private readonly string _name;
+ private readonly Rule _rule;
public Thing(int count, string name, double average, Rule rule)
Modified: trunk/Source/StructureMap.Testing/Configuration/DSL/InjectArrayTester.cs
===================================================================
--- trunk/Source/StructureMap.Testing/Configuration/DSL/InjectArrayTester.cs 2008-05-27 23:46:15 UTC (rev 104)
+++ trunk/Source/StructureMap.Testing/Configuration/DSL/InjectArrayTester.cs 2008-05-28 03:15:34 UTC (rev 105)
@@ -4,7 +4,7 @@
namespace StructureMap.Testing.Configuration.DSL
{
[TestFixture]
- public class InjectArrayTester
+ public class InjectArrayTester : RegistryExpressions
{
#region Setup/Teardown
@@ -41,8 +41,8 @@
public class Processor2
{
- private IHandler[] _first;
- private IHandler[] _second;
+ private readonly IHandler[] _first;
+ private readonly IHandler[] _second;
public Processor2(IHandler[] first, IHandler[] second)
@@ -82,44 +82,44 @@
[Test]
public void CanStillAddOtherPropertiesAfterTheCallToChildArray()
{
- Registry registry = new Registry();
+ IInstanceManager manager = new InstanceManager(delegate(Registry registry)
+ {
+ registry.ForRequestedType<Processor>()
+ .TheDefaultIs(
+ Instance<Processor>().UsingConcreteType<Processor>()
+ .ChildArray<IHandler[]>().Contains(
+ Instance<IHandler>().UsingConcreteType<Handler1>(),
+ Instance<IHandler>().UsingConcreteType<Handler2>(),
+ Instance<IHandler>().UsingConcreteType<Handler3>()
+ )
+ .WithProperty("name").EqualTo("Jeremy")
+ );
+ });
- registry.ForRequestedType<Processor>()
- .TheDefaultIs(
- Registry.Instance<Processor>().UsingConcreteType<Processor>()
- .ChildArray<IHandler[]>().Contains(
- Registry.Instance<IHandler>().UsingConcreteType<Handler1>(),
- Registry.Instance<IHandler>().UsingConcreteType<Handler2>(),
- Registry.Instance<IHandler>().UsingConcreteType<Handler3>()
- )
- .WithProperty("name").EqualTo("Jeremy")
- );
-
- IInstanceManager manager = registry.BuildInstanceManager();
Processor processor = manager.CreateInstance<Processor>();
-
Assert.AreEqual("Jeremy", processor.Name);
}
[Test]
public void InjectPropertiesByName()
{
- Registry registry = new Registry();
+ IInstanceManager manager = new InstanceManager(delegate(Registry registry)
+ {
+ registry.ForRequestedType<Processor2>()
+ .TheDefaultIs(
+ Instance<Processor2>().UsingConcreteType<Processor2>()
+ .ChildArray<IHandler[]>("first").Contains(
+ Instance<IHandler>().UsingConcreteType<Handler1>(),
+ Instance<IHandler>().UsingConcreteType<Handler2>()
+ )
+ .ChildArray<IHandler[]>("second").Contains(
+ Instance<IHandler>().UsingConcreteType<Handler2>(),
+ Instance<IHandler>().UsingConcreteType<Handler3>()
+ )
+ );
+ });
- registry.ForRequestedType<Processor2>()
- .TheDefaultIs(
- Registry.Instance<Processor2>().UsingConcreteType<Processor2>()
- .ChildArray<IHandler[]>("first").Contains(
- Registry.Instance<IHandler>().UsingConcreteType<Handler1>(),
- Registry.Instance<IHandler>().UsingConcreteType<Handler2>()
- )
- .ChildArray<IHandler[]>("second").Contains(
- Registry.Instance<IHandler>().UsingConcreteType<Handler2>(),
- Registry.Instance<IHandler>().UsingConcreteType<Handler3>()
- )
- );
- IInstanceManager manager = registry.BuildInstanceManager();
Processor2 processor = manager.CreateInstance<Processor2>();
Assert.IsInstanceOfType(typeof (Handler1), processor.First[0]);
@@ -131,21 +131,21 @@
[Test,
ExpectedException(typeof (StructureMapException),
ExpectedMessage =
- "StructureMap Exception Code: 307\nIn the call to ChildArray<T>(), the type T must be an array")]
+ "StructureMap Exception Code: 307\nIn the call to ChildArray<T>(), the type T must be an array")]
public void InjectPropertiesByNameButUseTheElementType()
{
Registry registry = new Registry();
registry.ForRequestedType<Processor2>()
.TheDefaultIs(
- Registry.Instance<Processor2>().UsingConcreteType<Processor2>()
+ Instance<Processor2>().UsingConcreteType<Processor2>()
.ChildArray<IHandler>("first").Contains(
- Registry.Instance<IHandler>().UsingConcreteType<Handler1>(),
- Registry.Instance<IHandler>().UsingConcreteType<Handler2>()
+ Instance<IHandler>().UsingConcreteType<Handler1>(),
+ Instance<IHandler>().UsingConcreteType<Handler2>()
)
.ChildArray<IHandler[]>("second").Contains(
- Registry.Instance<IHandler>().UsingConcreteType<Handler2>(),
- Registry.Instance<IHandler>().UsingConcreteType<Handler3>()
+ Instance<IHandler>().UsingConcreteType<Handler2>(),
+ Instance<IHandler>().UsingConcreteType<Handler3>()
)
);
}
@@ -153,21 +153,22 @@
[Test]
public void PlaceMemberInArrayByReference()
{
- Registry registry = new Registry();
- registry.AddInstanceOf<IHandler>().UsingConcreteType<Handler1>().WithName("One");
- registry.AddInstanceOf<IHandler>().UsingConcreteType<Handler2>().WithName("Two");
+ IInstanceManager manager = new InstanceManager(delegate(Registry registry)
+ {
+ registry.AddInstanceOf<IHandler>().UsingConcreteType<Handler1>().WithName("One");
+ registry.AddInstanceOf<IHandler>().UsingConcreteType<Handler2>().WithName("Two");
- registry.ForRequestedType<Processor>()
- .TheDefaultIs(
- Registry.Instance<Processor>().UsingConcreteType<Processor>()
- .WithProperty("name").EqualTo("Jeremy")
- .ChildArray<IHandler[]>().Contains(
- Registry.Instance("Two"),
- Registry.Instance("One")
- )
- );
+ registry.ForRequestedType<Processor>()
+ .TheDefaultIs(
+ Instance<Processor>().UsingConcreteType<Processor>()
+ .WithProperty("name").EqualTo("Jeremy")
+ .ChildArray<IHandler[]>().Contains(
+ Instance("Two"),
+ Instance("One")
+ )
+ );
+ });
- IInstanceManager manager = registry.BuildInstanceManager();
Processor processor = manager.CreateInstance<Processor>();
Assert.IsInstanceOfType(typeof (Handler2), processor.Handlers[0]);
@@ -177,20 +178,20 @@
[Test]
public void ProgrammaticallyInjectArrayAllInline()
{
- Registry registry = new Registry();
+ IInstanceManager manager = new InstanceManager(delegate(Registry registry)
+ {
+ registry.ForRequestedType<Processor>()
+ .TheDefaultIs(
+ Instance<Processor>()
+ .ChildArray<IHandler[]>().Contains(
+ Instance<IHandler>().UsingConcreteType<Handler1>(),
+ Instance<IHandler>().UsingConcreteType<Handler2>(),
+ Instance<IHandler>().UsingConcreteType<Handler3>()
+ )
+ .WithProperty("name").EqualTo("Jeremy")
+ );
+ });
- registry.ForRequestedType<Processor>()
- .TheDefaultIs(
- Registry.Instance<Processor>().UsingConcreteType<Processor>()
- .ChildArray<IHandler[]>().Contains(
- Registry.Instance<IHandler>().UsingConcreteType<Handler1>(),
- Registry.Instance<IHandler>().UsingConcreteType<Handler2>(),
- Registry.Instance<IHandler>().UsingConcreteType<Handler3>()
- )
- .WithProperty("name").EqualTo("Jeremy")
- );
-
- IInstanceManager manager = registry.BuildInstanceManager();
Processor processor = manager.CreateInstance<Processor>();
Assert.IsInstanceOfType(typeof (Handler1), processor.Handlers[0]);
@@ -201,17 +202,17 @@
[Test,
ExpectedException(typeof (StructureMapException),
...
[truncated message content] |
