C# Defaults.DefaultPicoContainer类代码示例

		public void NanoContainerCanBeBuiltFromCodeOnTheFly()
		{
			string code = @"
				using PicoContainer;
				using PicoContainer.Defaults;
				namespace Test 
				{
					public class NameTranslator 
					{
						private IPicoContainer parent;
						public IPicoContainer Parent {
							set { parent = value; } 
						}
				
						public IMutablePicoContainer Compose() {
							DefaultPicoContainer p = new DefaultPicoContainer(parent);
							p.RegisterComponentInstance(10, 1000);
							return p; 
						}
					}
				}";

			IMutablePicoContainer parent = new DefaultPicoContainer();
			ContainerBuilderFacade cbf = new CSharpContainerBuilderFacade(ScriptFixture.BuildStreamReader(code));
			IPicoContainer pico = cbf.Build(parent, new ArrayList());

			Assert.IsNotNull(pico);
			Assert.AreSame(parent, pico.Parent);
			Assert.AreEqual(1000, pico.GetComponentInstance(10));
		}

		public void ConstantParameterRespectsExpectedType()
		{
			IMutablePicoContainer picoContainer = new DefaultPicoContainer();
			IParameter parameter = new ConstantParameter(new SimpleTouchable());
			IComponentAdapter adapter = picoContainer.RegisterComponentImplementation(typeof (ITouchable), typeof (SimpleTouchable));
			Assert.IsFalse(parameter.IsResolvable(picoContainer, adapter, typeof (TestFixtureAttribute)));
		}

		public void NanoContainerCanBeBuiltFromCodeOnTheFly()
		{
			// Boo relies on indentation so start at column 1. MUST NOT BE REFORMATTED
			string code = @"
import PicoContainer from PicoContainer
import PicoContainer.Defaults from PicoContainer

class BooInjector:
	
	[Property(Parent)]
	_parent as IPicoContainer
	
	def Compose() as IMutablePicoContainer:
		p = DefaultPicoContainer(_parent)
		p.RegisterComponentInstance(10, 1000)
		return p

			";

			IMutablePicoContainer parent = new DefaultPicoContainer();
			ContainerBuilderFacade cbf = new BooContainerBuilderFacade(ScriptFixture.BuildStreamReader(code));
			IPicoContainer pico = cbf.Build(parent, new ArrayList());

			Assert.IsNotNull(pico);
			Assert.AreSame(parent, pico.Parent);
			Assert.AreEqual(1000, pico.GetComponentInstance(10));
		}

 public void ConstantParameter()
 {
     Object value = new Object();
     ConstantParameter parameter = new ConstantParameter(value);
     IMutablePicoContainer picoContainer = new DefaultPicoContainer();
     Assert.AreSame(value, parameter.ResolveInstance(picoContainer, null, typeof (object)));
 }

		public void DEF_verifyWithoutDependencyWorks()
		{
			IMutablePicoContainer picoContainer = new DefaultPicoContainer(CreateDefaultComponentAdapterFactory());
			IComponentAdapter componentAdapter = prepDEF_verifyWithoutDependencyWorks(picoContainer);
			Assert.AreSame(GetComponentAdapterType(), componentAdapter.GetType());
			componentAdapter.Verify(picoContainer);
		}

        protected virtual IPicoContainer WrapComponentInstances(Type decoratingComponentAdapterClass,
                                                                IPicoContainer picoContainer,
                                                                object[] wrapperDependencies)
        {
            Assert.IsTrue(typeof (DecoratingComponentAdapter).IsAssignableFrom(decoratingComponentAdapterClass));
            IMutablePicoContainer mutablePicoContainer = new DefaultPicoContainer();
            int size = (wrapperDependencies != null ? wrapperDependencies.Length : 0) + 1;
            ICollection allComponentAdapters = picoContainer.ComponentAdapters;

            foreach (object adapter in allComponentAdapters)
            {
                IParameter[] parameters = new IParameter[size];
                parameters[0] = new ConstantParameter(adapter);
                for (int i = 1; i < parameters.Length; i++)
                {
                    parameters[i] = new ConstantParameter(wrapperDependencies[i - 1]);
                }
                IMutablePicoContainer instantiatingPicoContainer =
                    new DefaultPicoContainer(new ConstructorInjectionComponentAdapterFactory());
                instantiatingPicoContainer.RegisterComponentImplementation("decorator", decoratingComponentAdapterClass,
                                                                           parameters);
                mutablePicoContainer.RegisterComponent(
                    (IComponentAdapter) instantiatingPicoContainer.GetComponentInstance("decorator"));
            }
            return mutablePicoContainer;
        }

		public IMutablePicoContainer Compose()
		{
			DefaultPicoContainer p = new DefaultPicoContainer(parent);

			p.RegisterComponentInstance("hello", "C#");
			return p;
		}

		private IMutablePicoContainer GetDefaultPicoContainer()
		{
			IMutablePicoContainer mpc = new DefaultPicoContainer();
			mpc.RegisterComponentImplementation(typeof (Bowl));
			mpc.RegisterComponentImplementation(typeof (Cod));
			mpc.RegisterComponentImplementation(typeof (Shark));
			return mpc;
		}

 public void ComponentParameterRespectsExpectedType()
 {
     IMutablePicoContainer picoContainer = new DefaultPicoContainer();
     IComponentAdapter adapter =
         picoContainer.RegisterComponentImplementation(typeof (ITouchable), typeof (SimpleTouchable));
     Assert.IsNull(
         ComponentParameter.DEFAULT.ResolveInstance(picoContainer, adapter, typeof (TestFixtureAttribute)));
 }

		public void ContainerCanBeBuiltWithParent()
		{
			IMutablePicoContainer parent = new DefaultPicoContainer();
			IPicoContainer pico = BuildContainer(new VBBuilder(GetStreamReader(@"NanoContainer.Tests.TestScripts.test.vb")), parent, new ArrayList());
			Assert.IsNotNull(pico);
			Assert.AreSame(parent, pico.Parent);
			Assert.AreEqual("VB", pico.GetComponentInstance("hello"));
		}

		public void DEF_verifyDoesNotInstantiate()
		{
			IMutablePicoContainer picoContainer = new DefaultPicoContainer(CreateDefaultComponentAdapterFactory());
			IComponentAdapter componentAdapter = prepDEF_verifyDoesNotInstantiate(picoContainer);
			Assert.AreSame(GetComponentAdapterType(), componentAdapter.GetType());
			IComponentAdapter notInstantiatablecomponentAdapter = new NotInstantiatableComponentAdapter(componentAdapter);
			IPicoContainer wrappedPicoContainer = WrapComponentInstances(typeof (NotInstantiatableComponentAdapter), picoContainer, null);
			notInstantiatablecomponentAdapter.Verify(wrappedPicoContainer);
		}

		public void ComponentParameterExcludesSelf()
		{
			DefaultPicoContainer pico = new DefaultPicoContainer();
			IComponentAdapter adapter = pico.RegisterComponentImplementation(typeof (ITouchable), typeof (SimpleTouchable));

			Assert.IsNotNull(pico.GetComponentInstance(typeof (ITouchable)));
			ITouchable touchable = (ITouchable) ComponentParameter.DEFAULT.ResolveInstance(pico, adapter, typeof (ITouchable));
			Assert.IsNull(touchable);
		}

		public void ContainerCanBeBuiltWithParent()
		{
			IMutablePicoContainer parent = new DefaultPicoContainer();
			ContainerBuilderFacade cbf = new JSharpContainerBuilderFacade(GetStreamReader(@"NanoContainer.Tests.TestScripts.test.java"));
			IPicoContainer pico = cbf.Build(parent, new ArrayList());
			Assert.IsNotNull(pico);
			Assert.AreSame(parent, pico.Parent);
			Assert.AreEqual("J#", pico.GetComponentInstance("hello"));
		}

		public DefaultNanoContainer(StreamReader composition, String builderClass)
		{
			DefaultReflectionContainerAdapter defaultReflectionContainerAdapter;
			DefaultPicoContainer dpc = new DefaultPicoContainer();
			dpc.RegisterComponentInstance(composition);

			defaultReflectionContainerAdapter = new DefaultReflectionContainerAdapter(dpc);
			IComponentAdapter componentAdapter = defaultReflectionContainerAdapter.RegisterComponentImplementation(builderClass);
			containerBuilder = (ScriptedContainerBuilder) componentAdapter.GetComponentInstance(dpc);
		}

		public void DefaultPicoContainerReturnsNewInstanceForEachCallWhenUsingTransientIComponentAdapter()
		{
			DefaultPicoContainer picoContainer = new DefaultPicoContainer();
			picoContainer.RegisterComponentImplementation(typeof (Service));
			picoContainer.RegisterComponent(new ConstructorInjectionComponentAdapter(typeof (TransientComponent), typeof (TransientComponent)));
			TransientComponent c1 = (TransientComponent) picoContainer.GetComponentInstance(typeof (TransientComponent));
			TransientComponent c2 = (TransientComponent) picoContainer.GetComponentInstance(typeof (TransientComponent));
			Assert.IsFalse(c1.Equals(c2));
			Assert.AreSame(c1.service, c2.service);
		}