/// <summary>
/// IoC 컨테이너가 제공하는 객체 처리를 수행합니다.
/// </summary>
/// <param name="element"> 컨테이너 요소입니다. </param>
/// <param name="lifetime"> The lifetime. </param>
/// <param name="constructor">역직렬화된 생성자 요소입니다.</param>
/// <param name="properties">역직렬화된 속성(Property) 요소입니다.</param>
/// <param name="methods">역직렬화된 메서드 요소입니다.</param>
protected override void ResolveRegisterProcessor(RegisterElement element, LifetimeFlag lifetime, IEnumerable <object> constructor, IEnumerable <object> properties, IEnumerable <object> methods)
{
var component = Component.For(Type.GetType(element.contract))
.ImplementedBy(Type.GetType(element.dependencyTo))
.Named(element.key);
if (constructor != null)
{
var constructorParams = ((List <object>)constructor.First());
constructorParams.Where(o => o is Parameter).Cast <Parameter>().ToList().ForEach(o => component.Parameters(o));
constructorParams.Where(o => o is DynamicParametersDelegate).Cast <DynamicParametersDelegate>().ToList().ForEach(@delegate =>
component.DynamicParameters((kernel, d) => @delegate(kernel, d)));
}
if (properties != null)
{
properties.Where(o => o is Property).Cast <Property>().ToList().ForEach(o => component.DependsOn(o));
properties.Where(o => o is DynamicParametersDelegate).Cast <DynamicParametersDelegate>().ToList().ForEach(@delegate =>
component.DynamicParameters((kernel, d) => @delegate(kernel, d)));
}
if (methods != null)
{
throw new NotSupportedException("FrameworkContainerForCastle 은 현재 Method Injection 을 지원하지 않습니다.");
}
container.ContainerObject.Register(component);
}
public void Then_SectionWithExtendedValueElementsIsSerialized()
{
var loadedSection = SerializeAndLoadSection("SerializingExtensionElements.config", s =>
{
var registration = new RegisterElement
{
TypeName = "SomeType"
};
var prop = new PropertyElement()
{
Name = "MyProp",
Value = new SeventeenValueElement()
};
registration.InjectionMembers.Add(prop);
var container = new ContainerElement();
container.Registrations.Add(registration);
s.Containers.Add(container);
s.SectionExtensions.Add(new SectionExtensionElement
{
TypeName = typeof(TestSectionExtension).AssemblyQualifiedName,
Prefix = "pre1"
});
});
loadedSection.Containers.Default.Registrations[0].InjectionMembers
.OfType <PropertyElement>()
.Select(p => p.Value.GetType())
.AssertContainsExactly(typeof(SeventeenValueElement));
}
public void Then_BehaviorElementsGetSerialized()
{
var loadedSection = SerializeAndLoadConfig("SerializingInjectionMembers.config", c =>
{
var reg = new RegisterElement
{
TypeName = "SomeType"
};
reg.InjectionMembers.Add(new InterceptionBehaviorElement()
{
TypeName = "SomeBehavior"
});
reg.InjectionMembers.Add(new InterceptionBehaviorElement()
{
Name = "NamedBehavior",
TypeName = "SomeOtherBehavior"
});
c.Registrations.Add(reg);
});
var injectionMembers =
loadedSection.Containers.Default.Registrations[0].InjectionMembers
.Cast <InterceptionBehaviorElement>();
injectionMembers.Select(m => m.TypeName)
.AssertContainsExactly("SomeBehavior", "SomeOtherBehavior");
injectionMembers.Select(m => m.Name)
.AssertContainsExactly(String.Empty, "NamedBehavior");
}
/// <summary>
/// IoC 컨테이너가 제공하는 객체 처리를 수행합니다.
/// </summary>
/// <param name="element"> 컨테이너 요소입니다. </param>
/// <param name="lifetime"> The lifetime. </param>
/// <param name="constructor">역직렬화된 생성자 요소입니다.</param>
/// <param name="properties">역직렬화된 속성(Property) 요소입니다.</param>
/// <param name="methods">역직렬화된 메서드 요소입니다.</param>
protected override void ResolveRegisterProcessor(RegisterElement element, LifetimeFlag lifetime, IEnumerable <object> constructor, IEnumerable <object> properties, IEnumerable <object> methods)
{
var concat = Enumerable.Empty <InjectionMember>();
if (constructor != null)
{
concat = concat.Concat(constructor.Cast <InjectionMember>());
}
if (properties != null)
{
concat = concat.Concat(properties.Cast <InjectionMember>());
}
if (methods != null)
{
concat = concat.Concat(methods.Cast <InjectionMember>());
}
var contractType = Type.GetType(element.contract);
var dependencyType = Type.GetType(element.dependencyTo);
try
{
container.ContainerObject.RegisterType(
contractType,
dependencyType,
element.key,
container.LifetimeMapping.GetLifetimeObject(lifetime),
concat.ToArray());
}
catch (NotSupportedException) { }
catch (Exception e)
{
// logger.Error(e);
}
}
public void Then_SimplePropertyWithDependencyIsSerialized()
{
var loadedSection = SerializeAndLoadSection("SerializingProperties.config", s =>
{
var prop = new PropertyElement()
{
Name = "MyProp"
};
var reg = new RegisterElement()
{
TypeName = "MyType"
};
reg.InjectionMembers.Add(prop);
var container = new ContainerElement();
container.Registrations.Add(reg);
s.Containers.Add(container);
});
loadedSection.Containers[0].Registrations[0].InjectionMembers
.Cast <PropertyElement>()
.Select(p => p.Name)
.AssertContainsExactly("MyProp");
loadedSection.Containers[0].Registrations[0].InjectionMembers
.Cast <PropertyElement>()
.Select(p => p.Value.GetType())
.AssertContainsExactly(typeof(DependencyElement));
}
protected override void Arrange()
{
base.Arrange();
container = Section.Containers.Default;
firstRegistration = container.Registrations[0];
secondRegistration = container.Registrations[1];
thirdRegistration = container.Registrations[2];
}
protected override void Arrange()
{
base.Arrange();
this.container = this.section.Containers.Default;
this.firstRegistration = this.container.Registrations[0];
this.secondRegistration = this.container.Registrations[1];
this.thirdRegistration = this.container.Registrations[2];
}
public void Then_RegistrationWithLifetimeIsSerialized()
{
var loadedSection = SerializeAndLoadSection("SerializeContainers.config", s =>
{
var containerElement = new ContainerElement();
var reg1 = new RegisterElement
{
TypeName = "MyType"
};
var reg2 = new RegisterElement
{
TypeName = "MyOtherType",
Lifetime = new LifetimeElement
{
TypeName = "SomeCustomLifetime",
Value = "input value",
TypeConverterTypeName = "CustomLifetimeConverter"
}
};
var reg3 = new RegisterElement
{
TypeName = "StillAnotherType",
Lifetime = new LifetimeElement
{
TypeName = "singleton"
}
};
containerElement.Registrations.Add(reg1);
containerElement.Registrations.Add(reg2);
containerElement.Registrations.Add(reg3);
s.Containers.Add(containerElement);
});
var loadedReg0 = loadedSection.Containers.Default.Registrations[0];
var loadedReg1 = loadedSection.Containers.Default.Registrations[1];
var loadedReg2 = loadedSection.Containers.Default.Registrations[2];
Assert.IsNotNull(loadedReg0.Lifetime);
Assert.AreEqual(String.Empty, loadedReg0.Lifetime.TypeName);
Assert.IsNotNull(loadedReg1.Lifetime);
Assert.AreEqual("SomeCustomLifetime", loadedReg1.Lifetime.TypeName);
Assert.AreEqual("input value", loadedReg1.Lifetime.Value);
Assert.AreEqual("CustomLifetimeConverter", loadedReg1.Lifetime.TypeConverterTypeName);
Assert.IsNotNull(loadedReg2.Lifetime);
Assert.AreEqual("singleton", loadedReg2.Lifetime.TypeName);
Assert.AreEqual(String.Empty, loadedReg2.Lifetime.TypeConverterTypeName);
}
public void Then_MultiplePropertiesWithVaryingValuesAreSerialized()
{
var loadedSection = SerializeAndLoadSection("SerializingProperties.config", s =>
{
var prop = new PropertyElement()
{
Name = "SimpleProp"
};
var prop2 = new PropertyElement
{
Name = "NamedDependencyProp",
Value = new DependencyElement
{
Name = "MyDep"
}
};
var prop3 = new PropertyElement
{
Name = "OptionalProp",
Value = new OptionalElement
{
Name = "OptionalDep",
TypeName = "MyType"
}
};
var reg = new RegisterElement()
{
TypeName = "MyType"
};
reg.InjectionMembers.Add(prop);
reg.InjectionMembers.Add(prop2);
reg.InjectionMembers.Add(prop3);
var container = new ContainerElement();
container.Registrations.Add(reg);
s.Containers.Add(container);
});
var propertyElements = loadedSection.Containers[0].Registrations[0].InjectionMembers.Cast <PropertyElement>();
propertyElements.Select(p => p.Name)
.AssertContainsExactly("SimpleProp", "NamedDependencyProp", "OptionalProp");
propertyElements.Select(p => p.Value.GetType())
.AssertContainsExactly(typeof(DependencyElement), typeof(DependencyElement), typeof(OptionalElement));
Assert.AreEqual("MyDep",
((DependencyElement)propertyElements.Where(p => p.Name == "NamedDependencyProp").First().Value).Name);
}
public void Then_MethodsGetSerialized()
{
var loadedSection = SerializeAndLoadSection("SerializingMethods.config", s =>
{
var method0 = new MethodElement
{
Name = "NoArgsMethod"
};
var method1 = new MethodElement
{
Name = "OneArgMethod"
};
method1.Parameters.Add(new ParameterElement
{
Name = "BasicDependency"
});
method1.Parameters.Add(new ParameterElement
{
Name = "ArrayDependency",
Value = new ArrayElement
{
TypeName = "SomeType"
}
});
var reg = new RegisterElement
{
TypeName = "MyType"
};
reg.InjectionMembers.Add(method0);
reg.InjectionMembers.Add(method1);
var container = new ContainerElement();
container.Registrations.Add(reg);
s.Containers.Add(container);
});
var methods = loadedSection.Containers.Default.Registrations[0].InjectionMembers.Cast <MethodElement>();
methods.Select(m => m.Name)
.AssertContainsExactly("NoArgsMethod", "OneArgMethod");
var oneArgMethod = methods.Where(m => m.Name == "OneArgMethod").First();
Assert.AreEqual(2, oneArgMethod.Parameters.Count);
}
protected override void Arrange()
{
base.Arrange();
var ctor = new ConstructorElement();
ctor.Parameters.Add(
new ParameterElement
{
Name = "dependencyParameter",
Value = new DependencyElement {
Name = "dep1"
}
});
ctor.Parameters.Add(
new ParameterElement
{
Name = "valueParameter",
Value = new ValueElement
{
Value = "123",
TypeConverterTypeName = "IntConverter"
}
});
ctor.Parameters.Add(
new ParameterElement
{
Name = "optionalParameter",
Value = new OptionalElement()
});
var registration = new RegisterElement
{
TypeName = "MyType"
};
registration.InjectionMembers.Add(ctor);
var container = new ContainerElement();
container.Registrations.Add(registration);
Section = new UnityConfigurationSection();
Section.Containers.Add(container);
}
public void Then_InterceptorGetsSerialized()
{
var loadedSection = SerializeAndLoadConfig("SerializingInjectionMembers.config", c =>
{
var reg = new RegisterElement()
{
TypeName = "SomeType"
};
reg.InjectionMembers.Add(new InterceptorElement()
{
Name = "interceptor",
TypeName = "NoSuchInterceptor"
});
var reg2 = new RegisterElement()
{
TypeName = "SomeType",
Name = "Default"
};
reg2.InjectionMembers.Add(new InterceptorElement()
{
IsDefaultForType = true,
Name = "otherInterceptor",
TypeName = "AnotherInterceptor"
});
c.Registrations.Add(reg);
c.Registrations.Add(reg2);
});
var firstInterceptor =
(InterceptorElement)loadedSection.Containers.Default.Registrations[0].InjectionMembers[0];
Assert.IsFalse(firstInterceptor.IsDefaultForType);
Assert.AreEqual("interceptor", firstInterceptor.Name);
Assert.AreEqual("NoSuchInterceptor", firstInterceptor.TypeName);
var secondInterceptor =
(InterceptorElement)loadedSection.Containers.Default.Registrations[1].InjectionMembers[0];
Assert.IsTrue(secondInterceptor.IsDefaultForType);
Assert.AreEqual("otherInterceptor", secondInterceptor.Name);
Assert.AreEqual("AnotherInterceptor", secondInterceptor.TypeName);
}
/// <summary>
/// 생성자에 대한 역직렬화를 수행합니다.
/// </summary>
/// <param name="element"> 컨테이너 요소입니다. </param>
/// <returns>IoC 컨테이너가 제공하는 생성자에 대한 객체 입니다.</returns>
protected override object ResolveConstructor(RegisterElement element)
{
List <object> paramList = new List <object>();
foreach (var p in element.constructor)
{
var obj = this.ResolveParam(p.name, p.Item);
if (obj is DynamicParametersDelegate)
{
paramList.Add(obj);
}
else
{
paramList.Add(Parameter.ForKey(p.name).Eq(obj.ToString()));
}
}
return(paramList);
}
protected override void Arrange()
{
base.Arrange();
var ctor = new ConstructorElement();
ctor.Parameters.Add(
new ParameterElement
{
Name = "dependencyParameter",
Value = new DependencyElement {Name = "dep1"}
});
ctor.Parameters.Add(
new ParameterElement
{
Name = "valueParameter",
Value = new ValueElement
{
Value = "123",
TypeConverterTypeName = "IntConverter"
}
});
ctor.Parameters.Add(
new ParameterElement
{
Name = "optionalParameter",
Value = new OptionalElement()
});
var registration = new RegisterElement
{
TypeName = "MyType"
};
registration.InjectionMembers.Add(ctor);
var container = new ContainerElement();
container.Registrations.Add(registration);
Section = new UnityConfigurationSection();
Section.Containers.Add(container);
}
public void Then_AdditionalInterfacesGetSerialized()
{
var loadedSection = SerializeAndLoadConfig("SerializingInjectionMembers.config", c =>
{
var reg = new RegisterElement
{
TypeName = "SomeType"
};
reg.InjectionMembers.Add(new AddInterfaceElement()
{
TypeName = "InterfaceOne"
});
c.Registrations.Add(reg);
});
var additionalInterface = (AddInterfaceElement)
loadedSection.Containers.Default.Registrations[0].InjectionMembers[0];
Assert.AreEqual("InterfaceOne", additionalInterface.TypeName);
}
private static void FillSectionWithConstructors(UnityConfigurationSection s)
{
var zeroArgCtor = new ConstructorElement();
var intCtor = new ConstructorElement();
intCtor.Parameters.Add(new ParameterElement
{
Name = "intParam",
Value = new ValueElement
{
Value = "23"
}
});
var zeroArgRegistration = new RegisterElement
{
TypeName = "SomeType",
Name = "zeroArg"
};
zeroArgRegistration.InjectionMembers.Add(zeroArgCtor);
var oneArgRegistration = new RegisterElement
{
TypeName = "SomeType",
Name = "oneArg"
};
oneArgRegistration.InjectionMembers.Add(intCtor);
var container = new ContainerElement();
container.Registrations.Add(zeroArgRegistration);
container.Registrations.Add(oneArgRegistration);
s.Containers.Add(container);
}
public void Then_SectionWithExtendedInjectionmemberElementsIsSerialized()
{
var loadedSection = SerializeAndLoadSection("SerializingExtensionElements.config", s =>
{
var registration = new RegisterElement
{
TypeName = "string"
};
registration.InjectionMembers.Add(new TestInjectionMemberElement());
var container = new ContainerElement();
container.Registrations.Add(registration);
s.Containers.Add(container);
s.SectionExtensions.Add(new SectionExtensionElement
{
TypeName = typeof(TestSectionExtension).AssemblyQualifiedName,
Prefix = "pre1"
});
});
loadedSection.Containers.Default.Registrations[0].InjectionMembers
.Select(i => i.GetType())
.AssertContainsExactly(typeof(TestInjectionMemberElement));
}
public bool SearchByName(string name, out RegisterElement res)
{
res = Array.Find(Registers, (e) => e.IsMatchByName(name));
return(res.Name != null);
}
/// <summary>
/// 생성자에 대한 역직렬화를 수행합니다.
/// </summary>
/// <param name="element"> 컨테이너 요소입니다. </param>
/// <returns>IoC 컨테이너가 제공하는 생성자에 대한 객체 입니다.</returns>
protected override object ResolveConstructor(RegisterElement element)
{
return(new InjectionConstructor(this.ResolveParams(element.constructor).ToArray()));
}
private static bool IsInterceptableType(RegisterElement element)
{
return(element.TypeName == "Interceptable");
}
private void BuildConfigWithValues(UnityConfigurationSection s)
{
var ctorElement = new ConstructorElement();
ctorElement.Parameters.Add(new ParameterElement
{
Name = "defaultDependency"
});
ctorElement.Parameters.Add(new ParameterElement
{
Name = "namedDependency",
Value = new DependencyElement
{
Name = "someName"
}
});
ctorElement.Parameters.Add(new ParameterElement()
{
Name = "typedDependency",
Value = new DependencyElement()
{
TypeName = "SomeOtherType"
}
});
ctorElement.Parameters.Add(new ParameterElement()
{
Name = "valueDependency",
Value = new ValueElement
{
Value = "someValue"
}
});
ctorElement.Parameters.Add(new ParameterElement()
{
Name = "valueWithTypeConverter",
Value = new ValueElement
{
Value = "someValue",
TypeConverterTypeName = "MyConverter"
}
});
ctorElement.Parameters.Add(new ParameterElement()
{
Name = "optionalValue",
Value = new OptionalElement()
{
Name = "dependencyKey",
TypeName = "DependencyType"
}
});
ctorElement.Parameters.Add(new ParameterElement()
{
Name = "emptyArrayValue",
Value = new ArrayElement()
});
ctorElement.Parameters.Add(new ParameterElement()
{
Name = "typedEmptyArrayValue",
Value = new ArrayElement
{
TypeName = "MyElementType"
}
});
var arrayWithValues = new ArrayElement();
arrayWithValues.Values.Add(new DependencyElement());
arrayWithValues.Values.Add(new ValueElement()
{
Value = "something"
});
arrayWithValues.Values.Add(new DependencyElement()
{
Name = "dependencyName"
});
ctorElement.Parameters.Add(new ParameterElement()
{
Name = "arrayWithValues",
Value = arrayWithValues
});
var registration = new RegisterElement
{
TypeName = "someType"
};
registration.InjectionMembers.Add(ctorElement);
var container = new ContainerElement();
container.Registrations.Add(registration);
s.Containers.Add(container);
}
/// <summary> /// 생성자에 대한 역직렬화를 수행합니다. /// </summary> /// <param name="element"> 컨테이너 요소입니다. </param> /// <returns>IoC 컨테이너가 제공하는 생성자에 대한 객체 입니다.</returns> protected abstract object ResolveConstructor(RegisterElement element);
public bool SearchByOperand(int num, int index, out RegisterElement res)
{
res = Array.Find(Registers, (e) => e.IsMatchByOperand(num, index));
return(res.Name != null);
}
/// <summary> /// IoC 컨테이너가 제공하는 객체 처리를 수행합니다. /// </summary> /// <param name="element"> 컨테이너 요소입니다. </param> /// <param name="lifetime"> The lifetime. </param> /// <param name="constructor"> 역직렬화된 생성자 요소입니다.</param> /// <param name="properties"> 역직렬화된 속성(Property) 요소입니다.</param> /// <param name="methods"> 역직렬화된 메서드 요소입니다.</param> protected abstract void ResolveRegisterProcessor(RegisterElement element, LifetimeFlag lifetime, IEnumerable <object> constructor, IEnumerable <object> properties, IEnumerable <object> methods);
