implab/ImplabNet Commit - r274:22629bf26121

Unity xml configuration, alpha2

cin -

r274:22629bf26121 v3

parent child

Context file:

r274:22629bf26121

Expand all files

Implab.ServiceHost/Unity/ContainerBuilder.cs created 644 +125 0

@@ -0,0 +1,125
	1	using System;
	2	using System.Collections.Generic;
	3	using System.Text.RegularExpressions;
	4	using Implab.Diagnostics;
	5
	6	namespace Implab.ServiceHost.Unity {
	7	using System.Linq;
	8	using System.Reflection;
	9	using System.Text;
	10	using global::Unity;
	11	using global::Unity.Registration;
	12	using Implab.Xml;
	13	using static Trace<ContainerBuilder>;
	14
	15	public class ContainerBuilder {
	16
	17	readonly TypeResolver m_resolver;
	18
	19	readonly UnityContainer m_container;
	20
	21	readonly ContainerConfigurationSchema m_schema;
	22
	23	public UnityContainer Container {
	24	get {
	25	return m_container;
	26	}
	27	}
	28
	29	public ContainerBuilder() : this(null, null) {
	30	}
	31
	32	public ContainerBuilder(UnityContainer container, ContainerConfigurationSchema schema) {
	33	m_container = container ?? new UnityContainer();
	34	m_resolver = new TypeResolver();
	35	m_schema = schema ?? ContainerConfigurationSchema.Default;
	36	}
	37
	38	public Type ResolveType(string typeReference) {
	39	return m_resolver.Resolve(typeReference);
	40	}
	41
	42	internal void Visit(RegisterElement registerElement) {
	43	var registrationType = ResolveType(registerElement.RegistrationType);
	44	var implementationType = string.IsNullOrEmpty(registerElement.MapToType) ? registrationType : ResolveType(registerElement.MapToType);
	45
	46	var registrationContext = new TypeRegistrationBuilder(
	47	m_resolver,
	48	registrationType,
	49	implementationType
	50	);
	51
	52	if (registerElement.Injectors != null) {
	53	foreach (var injector in registerElement.Injectors) {
	54	injector.Visit(registrationContext);
	55	}
	56	}
	57
	58	m_container.RegisterType(
	59	registrationContext.RegistrationType,
	60	registrationContext.ImplementationType,
	61	registerElement.Name,
	62	registerElement.Lifetime?.GetLifetimeManager(this),
	63	registrationContext.Injections
	64	);
	65	}
	66
	67	internal void Visit(SerializedElement serializedElement) {
	68	var registrationType = ResolveType(serializedElement.RegistrationType);
	69	var valueBuilder = new InjectionValueBuilder(m_resolver, null);
	70
	71	valueBuilder.Visit(serializedElement);
	72
	73	m_container.RegisterInstance(
	74	registrationType,
	75	serializedElement.Name,
	76	valueBuilder.Value,
	77	serializedElement.Lifetime?.GetLifetimeManager(this)
	78	);
	79	}
	80
	81	internal void Visit(ValueElement valueElement) {
	82	var registrationType = ResolveType(valueElement.RegistrationType);
	83	var valueBuilder = new InjectionValueBuilder(m_resolver, null);
	84
	85	valueBuilder.Visit(valueElement);
	86
	87	m_container.RegisterInstance(
	88	registrationType,
	89	valueElement.Name,
	90	valueBuilder.Value,
	91	valueElement.Lifetime?.GetLifetimeManager(this)
	92	);
	93	}
	94
	95	internal void Visit(NamespaceElement namespaceElement) {
	96	m_resolver.AddNamespace(namespaceElement.Name);
	97	}
	98
	99	internal void Visit(AssemblyElement assemblyElement) {
	100	Assembly.Load(assemblyElement.AssemblyName);
	101	}
	102
	103	internal void Visit(IncludeElement includeElement) {
	104	Include(includeElement.Href);
	105	}
	106
	107	public void Include(string file) {
	108	var includeContext = new ContainerBuilder(m_container, m_schema);
	109	includeContext.LoadConfig(file);
	110	}
	111
	112	public void LoadConfig(string file) {
	113	var config = m_schema.LoadFile(file);
	114	Visit(config);
	115	}
	116
	117	internal void Visit(ContainerElement containerElement) {
	118	foreach (var item in containerElement.Items)
	119	item.Visit(this);
	120	}
	121
	122
	123
	124	}
	125	} No newline at end of file

Implab.ServiceHost/Unity/FactoryInjectionElement.cs created 644 +7 0

@@ -0,0 +1,7
	1	namespace Implab.ServiceHost.Unity {
	2	public class FactoryInjectionElement : AbstractInjectionElement {
	3	internal override void Visit(TypeRegistrationBuilder context) {
	4
	5	}
	6	}
	7	} No newline at end of file

Implab.ServiceHost/Unity/InjectionValueBuilder.cs created 644 +64 0

@@ -0,0 +1,64
	1	using System;
	2	using System.ComponentModel;
	3	using System.Xml.Serialization;
	4	using Unity.Injection;
	5
	6	namespace Implab.ServiceHost.Unity {
	7
	8	public class InjectionValueBuilder {
	9
	10	readonly TypeResolver m_resolver;
	11
	12	public Type DefaultType { get; private set; }
	13
	14	public Type ValueType { get; set; }
	15
	16	public object Value { get; set; }
	17
	18	public InjectionParameterValue Injection {
	19	get {
	20	if (Value != null)
	21	return InjectionParameterValue.ToParameter(Value);
	22
	23	return new InjectionParameter(ValueType, null);
	24	}
	25	}
	26
	27	internal InjectionValueBuilder(TypeResolver resolver, Type acceptsType) {
	28	m_resolver = resolver;
	29	DefaultType = acceptsType;
	30	}
	31
	32	public Type ResolveType(string typeSpec) {
	33	if (string.IsNullOrEmpty(typeSpec)) {
	34	if (DefaultType == null)
	35	throw new Exception("The type must be specified");
	36	return DefaultType;
	37	}
	38	return m_resolver.Resolve(typeSpec);
	39	}
	40
	41	public void Visit(ITextValue value) {
	42	ValueType = ResolveType(value.TypeName);
	43
	44	Value = string.IsNullOrEmpty(value.Value) ?
	45	Safe.CreateDefaultValue(ValueType) :
	46	TypeDescriptor.GetConverter(ValueType).ConvertFromString(value.Value);
	47	}
	48
	49	public void Visit(ISerializedValue value) {
	50	ValueType = ResolveType(value.TypeName);
	51
	52	var serializer = new XmlSerializer(ValueType);
	53
	54	using (var reader = value.GetReader())
	55	Value = new InjectionParameter(ValueType, serializer.Deserialize(reader));
	56	}
	57
	58	public void Visit(IDependencyReference value) {
	59	ValueType = ResolveType(value.TypeName);
	60	Value = new ResolvedParameter(ValueType, value.DependencyName);
	61	}
	62
	63	}
	64	} No newline at end of file

Implab.ServiceHost/Unity/RegistrationBuilder.cs created 644 +21 0

@@ -0,0 +1,21
	1	using System;
	2	using System.Collections.Generic;
	3	using System.ComponentModel;
	4	using System.Linq;
	5	using System.Xml.Serialization;
	6	using Implab.Xml;
	7	using Unity.Injection;
	8	using Unity.Registration;
	9
	10	namespace Implab.ServiceHost.Unity {
	11	public abstract class RegistrationBuilder {
	12	public Type RegistrationType {
	13	get;
	14	private set;
	15	}
	16
	17	protected RegistrationBuilder(Type registrationType) {
	18	RegistrationType = registrationType;
	19	}
	20	}
	21	} No newline at end of file

Implab.ServiceHost/Unity/TypeRegistrationBuilder.cs created 644 +77 0

@@ -0,0 +1,77
	1	using System;
	2	using System.Collections.Generic;
	3	using System.Linq;
	4	using Unity.Injection;
	5	using Unity.Registration;
	6
	7	namespace Implab.ServiceHost.Unity {
	8	public class TypeRegistrationBuilder : RegistrationBuilder {
	9
	10	readonly TypeResolver m_resolver;
	11
	12	readonly List<InjectionMember> m_injections = new List<InjectionMember>();
	13
	14	public InjectionMember[] Injections { get { return m_injections.ToArray(); } }
	15
	16	public Type ImplementationType {
	17	get;
	18	private set;
	19	}
	20
	21	internal TypeRegistrationBuilder(TypeResolver resolver, Type registrationType, Type implementationType) : base(registrationType) {
	22	ImplementationType = implementationType;
	23
	24	// when registering a generic mapping, register all generic parameter names as local types
	25	if (ImplementationType.IsGenericTypeDefinition) {
	26	m_resolver = new TypeResolver(resolver);
	27
	28	foreach (var p in ImplementationType.GetGenericArguments())
	29	m_resolver.AddMapping(p.Name, p);
	30	} else {
	31	m_resolver = resolver;
	32	}
	33	}
	34
	35	internal void Visit(ConstructorInjectionElement constructorInjection) {
	36
	37
	38	var parameters = constructorInjection.Parameters?
	39	.Select(x => {
	40	var valueBuilder = new InjectionValueBuilder(m_resolver, null);
	41	x.Visit(valueBuilder);
	42	return valueBuilder.Injection;
	43	})
	44	.ToArray();
	45
	46	var injection = parameters != null ? new InjectionConstructor(parameters) : new InjectionConstructor();
	47	m_injections.Add(injection);
	48	}
	49
	50	internal void Visit(MethodInjectionElement methodInjection) {
	51	var valueContext = new InjectionValueBuilder(m_resolver, null);
	52
	53	var parameters = methodInjection.Parameters?
	54	.Select(x => {
	55	var valueBuilder = new InjectionValueBuilder(m_resolver, null);
	56	x.Visit(valueBuilder);
	57	return valueBuilder.Injection;
	58	})
	59	.ToArray();
	60
	61	var injection = parameters != null ? new InjectionMethod(methodInjection.Name, parameters) : new InjectionMethod(methodInjection.Name);
	62	m_injections.Add(injection);
	63	}
	64
	65	internal void Visit(PropertyInjectionElement propertyInjection) {
	66	if (propertyInjection.Value == null)
	67	throw new Exception($"A value value must be specified for the property '{propertyInjection.Name}'");
	68
	69	var propertyType = RegistrationType.GetProperty(propertyInjection.Name)?.PropertyType;
	70	var valueContext = new InjectionValueBuilder(m_resolver, propertyType);
	71
	72	propertyInjection.Value.Visit(valueContext);
	73	var injection = new InjectionProperty(propertyInjection.Name, valueContext.Injection);
	74	m_injections.Add(injection);
	75	}
	76	}
	77	} No newline at end of file

Implab.Playground/Program.cs +1 -1

             using System;
             using System.Diagnostics;
             using System.Linq;
             using Implab.Diagnostics;
             using Implab.ServiceHost.Unity;
             using Implab.Xml;
             using Unity;
             using Unity.Injection;
             using Unity.Registration;
             namespace Implab.Playground {
                 public class Foo {
                     public class Bar {
                     }
                     public string Name { get; set; }
                     public int IntValue { get; set; }
                     public string StringValue { get; set; }
                 }
                 public interface IContainer<T> {
                     T Instance { get; set; }
                 }
                 public class Container<T> : IContainer<T> {
                     public Container() {
                     }
                     public Container(T instance) {
                         Instance = instance;
                     }
                     public T Instance { get; set; }
                     public void SetInstance(T value) {
                         Instance = value;
                     }
                 }
                 public class Program {
                     static void Main(string[] args) {
                         var stopwatch = new Stopwatch();
                         stopwatch.Start();
-                        var ctx = new ContainerContext();
+                        var ctx = new ContainerBuilder();
                         Console.WriteLine($"Created: {stopwatch.ElapsedMilliseconds}");
                         ctx.LoadConfig("data/sample.xml");
                         Console.WriteLine($"Loaded: {stopwatch.ElapsedMilliseconds}");
                         var container = ctx.Container;
                         var instace1 = container.Resolve<IContainer<string>>();
                         Console.WriteLine($"Resolved1: {stopwatch.ElapsedMilliseconds}");
                         var instace2 = container.Resolve<IContainer<Foo>>();
                         Console.WriteLine($"Resolved2: {stopwatch.ElapsedMilliseconds}");
                         DisplayContainerRegistrations(container);
                     }
                     static void DisplayContainerRegistrations(IUnityContainer theContainer) {
                         string regName, regType, mapTo, lifetime;
                         Console.WriteLine("Container has {0} Registrations:",
                                 theContainer.Registrations.Count());
                         foreach (ContainerRegistration item in theContainer.Registrations) {
                             regType = item.RegisteredType.FullName;
                             mapTo = item.MappedToType.FullName;
                             regName = item.Name ?? "[default]";
                             lifetime = item.LifetimeManager.LifetimeType.Name;
                             if (mapTo != regType) {
                                 mapTo = " -> " + mapTo;
                             } else {
                                 mapTo = string.Empty;
                             }
                             lifetime = lifetime.Substring(0, lifetime.Length - "LifetimeManager".Length);
                             Console.WriteLine("+ {0}{1}  '{2}'  {3}", regType, mapTo, regName, lifetime);
                         }
                     }
                 }
             }

Implab.Playground/data/sample.xml +1 -1

             <?xml version="1.0" encoding="UTF-8"?>
             <container xmlns="http://implab.org/schemas/servicehost/unity.v1.xsd">
                 <namespace name="System"/>
                 <namespace name="Implab.Playground"/>
                 <!-- foo1 -->
                 <register name="foo1" type="Foo">
                     <property name="Name">
                         <value>FOO!</value>
                     </property>
                 </register>
                 <!-- foo2 -->
                 <register name="foo2" type="Foo">
                     <property name="Name">
                         <value>GOOD</value>
                     </property>
                     <property name="IntValue">
                         <value>2</value>
                     </property>
                 </register>
                 <register type="Foo">
                 </register>
                 <register type="IContainer{}" mapTo="Container{}">
                     <constructor/>
                     <method name="SetInstance">
                         <dependency type="T"/>
                     </method>
                 </register>
                 <register type="IContainer{String}" mapTo="Container{String}">
                     <constructor/>
                     <method name="SetInstance">
                         <dependency type="String" name="name1"/>
                     </method>
                 </register>
                 <serialized type="Foo+Bar">
-                    <Bar id="1">
+                    <Bar xmlns="" id="1">
                         <Name>Baaar</Name>
                     </Bar>
                 </serialized>
                 <value name="connection1" type="String"><![CDATA[Connect me <here>!]]></value>
                 <value name="name1" type="String" value="Hello!"/>
             </container>

Implab.ServiceHost/Unity/AbstractInjectionElement.cs +5 -3

             using System;
-            namespace Implab.ServiceHost.Unity
+            namespace Implab.ServiceHost.Unity {
+                /// <summary>
+                /// Base class for injections, each injection is applied to the type registration context.
+                /// </summary>
                 public abstract class AbstractInjectionElement {
-                    internal abstract void Visit(TypeRegistrationContext context);
+                    internal abstract void Visit(TypeRegistrationBuilder context);
                 }
             }

Implab.ServiceHost/Unity/AbstractRegistration.cs 0 -4

             using System;
             using System.Xml.Serialization;
             using Unity.Lifetime;
             using Unity.Registration;
             namespace Implab.ServiceHost.Unity
             {
                 public abstract class AbstractRegistration : ContainerItemElement {
                     /// <summary>
                     /// An optional name for a registration in the container
                     /// </summary>
                     [XmlAttribute("name")]
                     public string Name {
                         get; set;
                     }
                     [XmlElement("signleton", typeof(SimgletonLifetimeElement))]
                     [XmlElement("context", typeof(ContextLifetimeElement))]
                     [XmlElement("container", typeof(ContainerLifetimeElement))]
                     [XmlElement("hierarchy", typeof(HierarchicalLifetimeElement))]
                     public LifetimeElement Lifetime {get; set;}
                     /// <summary>
                     /// A type specification for the service registration,
                     /// </summary>
                     [XmlAttribute("type")]
                     public string RegistrationType { get; set; }
-                    public virtual Type ResolveRegistrationType(ContainerContext ctx) {
-                        return ctx.Resolve(RegistrationType);
                 }
             }

Implab.ServiceHost/Unity/AssemblyElement.cs +1 -1

             using System.Xml.Serialization;
             namespace Implab.ServiceHost.Unity
             {
                 [XmlRoot("assembly", Namespace = Schema.ContainerConfigurationNamespace)]
                 public class AssemblyElement : ContainerItemElement {
                     [XmlAttribute("name")]
                     public string AssemblyName { get; set; }
-                    public override void Visit(ContainerContext context) {
+                    public override void Visit(ContainerBuilder context) {
                         context.Visit(this);
                     }
                 }
             }

Implab.ServiceHost/Unity/ConstructorInjectionElement.cs +1 -1

             using System.Xml.Serialization;
             namespace Implab.ServiceHost.Unity {
                 public class ConstructorInjectionElement : AbstractInjectionElement {
                     [XmlElement("dependency", typeof(DependencyParameterElement))]
                     [XmlElement("value", typeof(ValueParameterElement))]
                     [XmlElement("serialized", typeof(SerializedParameterElement))]
                     [XmlElement("default", typeof(DefaultParameterElement))]
                     public InjectionParameterElement[] Parameters { get; set; }
-                    internal override void Visit(TypeRegistrationContext context) {
+                    internal override void Visit(TypeRegistrationBuilder context) {
                         context.Visit(this);
                     }
                 }
             }

Implab.ServiceHost/Unity/ContainerConfigurationSchema.cs +2 0

             using System;
             using System.Collections.Generic;
             using System.IO;
             using System.Reflection;
             using System.Xml;
             using System.Xml.Serialization;
             using Implab.Components;
             namespace Implab.ServiceHost.Unity {
                 public class ContainerConfigurationSchema {
                     public static ContainerConfigurationSchema Default { get; private set; } = CreateDefault();
                     readonly LazyAndWeak<XmlSerializer> m_seralizer;
                     readonly XmlAttributeOverrides m_overrides = new XmlAttributeOverrides();
                     readonly XmlAttributes m_containerItems = new XmlAttributes();
                     public XmlSerializer Serializer {
                         get {
                             return m_seralizer.Value;
                         }
                     }
                     public ContainerConfigurationSchema() {
                         m_overrides.Add(typeof(ContainerElement), nameof(ContainerElement.Items), m_containerItems);
                         m_seralizer = new LazyAndWeak<XmlSerializer>(() => new XmlSerializer(typeof(ContainerElement), m_overrides));
                     }
                     public void RegisterContainerElement(Type type, string name) {
                         Safe.ArgumentNotNull(type, nameof(type));
                         Safe.ArgumentNotEmpty(name, nameof(name));
                         if(!type.IsSubclassOf(typeof(ContainerItemElement)))
                             throw new Exception($"RegisterContainerElement '{name}': {type} must be subclass of {typeof(ContainerItemElement)}");
                         m_containerItems.XmlElements.Add(
                             new XmlElementAttribute(name, type)
                         );
                     }
                     public void RegisterContainerElement<T>(string name) where T : ContainerItemElement {
                         RegisterContainerElement(typeof(T), name);
                     }
                     public ContainerElement LoadFile(string file) {
                         using (var reader = XmlReader.Create(file)) {
                             return (ContainerElement)Serializer.Deserialize(reader);
                         }
                     }
                     static ContainerConfigurationSchema CreateDefault() {
                         var schema = new ContainerConfigurationSchema();
                         schema.RegisterContainerElement<RegisterElement>("register");
+                        schema.RegisterContainerElement<SerializedElement>("serialized");
+                        schema.RegisterContainerElement<ValueElement>("value");
                         schema.RegisterContainerElement<IncludeElement>("include");
                         schema.RegisterContainerElement<AssemblyElement>("assembly");
                         schema.RegisterContainerElement<NamespaceElement>("namespace");
                         return schema;
                     }
                 }
             }

Implab.ServiceHost/Unity/ContainerElement.cs +1 -1

             using Implab.Xml;
             using System.Collections.Generic;
             using System.Xml;
             using System.Xml.Schema;
             using System.Xml.Serialization;
             namespace Implab.ServiceHost.Unity {
                 [XmlRoot("container", Namespace = Schema.ContainerConfigurationNamespace)]
                 public class ContainerElement : ContainerItemElement {
                     public List<ContainerItemElement> Items { get; set; } = new List<ContainerItemElement>();
-                    public override void Visit(ContainerContext context) {
+                    public override void Visit(ContainerBuilder context) {
                         context.Visit(this);
                     }
                 }
             }

Implab.ServiceHost/Unity/ContainerItemElement.cs +1 -1

             namespace Implab.ServiceHost.Unity {
                 public abstract class ContainerItemElement {
-                    public abstract void Visit(ContainerContext context);
+                    public abstract void Visit(ContainerBuilder context);
                 }
             }

Implab.ServiceHost/Unity/ContainerLifetimeElement.cs +1 -1

             using Unity.Lifetime;
             namespace Implab.ServiceHost.Unity
             {
                 public class ContainerLifetimeElement : LifetimeElement {
-                    public override LifetimeManager GetLifetimeManager(ContainerContext ctx) {
+                    public override LifetimeManager GetLifetimeManager(ContainerBuilder ctx) {
                         return new ContainerControlledLifetimeManager();
                     }
                 }
             }

Implab.ServiceHost/Unity/ContextLifetimeElement.cs +1 -1

             using Unity.Lifetime;
             namespace Implab.ServiceHost.Unity
             {
                 public class ContextLifetimeElement : LifetimeElement {
-                    public override LifetimeManager GetLifetimeManager(ContainerContext ctx) {
+                    public override LifetimeManager GetLifetimeManager(ContainerBuilder ctx) {
                         return new PerResolveLifetimeManager();
                     }
                 }
             }

Implab.ServiceHost/Unity/DefaultParameterElement.cs +7 -4

@@ -1,9 +1,12
1	namespace Implab.ServiceHost.Unity	1	namespace Implab.ServiceHost.Unity
2	{	2	{
3	public class DefaultParameterElement : InjectionParameterElement {	3	public class DefaultParameterElement : InjectionParameterElement, ITextValue {
4	internal override object Resolve(InjectionValueContext context) {	4	public string Value {
5	var type = context.ResolveType(TypeName);	5	get { return null; }
6	return Safe.CreateDefaultValue(type);	6	}
		7
		8	internal override void Visit(InjectionValueBuilder builder) {
		9	builder.Visit(this);
7	}	10	}
8	}	11	}
9	} No newline at end of file	12	}

Implab.ServiceHost/Unity/DependencyParameterElement.cs +5 -1

             using System.Xml.Serialization;
             namespace Implab.ServiceHost.Unity {
-                public class DependencyParameterElement : InjectionParameterElement {
+                public class DependencyParameterElement : InjectionParameterElement, IDependencyReference {
                     [XmlAttribute("name")]
                     public string DependencyName { get; set; }
                     [XmlAttribute("optional")]
                     public bool Optional { get; set; }
+                    internal override void Visit(InjectionValueBuilder builder) {
+                        builder.Visit(this);
+                    }
                 }
             }

Implab.ServiceHost/Unity/HierarchicalLifetimeElement.cs +1 -1

             using Unity.Lifetime;
             namespace Implab.ServiceHost.Unity
             {
                 public class HierarchicalLifetimeElement : LifetimeElement {
-                    public override LifetimeManager GetLifetimeManager(ContainerContext ctx) {
+                    public override LifetimeManager GetLifetimeManager(ContainerBuilder ctx) {
                         return new HierarchicalLifetimeManager();
                     }
                 }
             }

Implab.ServiceHost/Unity/IDependencyReference.cs +4 -1

             namespace Implab.ServiceHost.Unity {
                 public interface IDependencyReference {
-                    string Name { get; set; }
+                    string TypeName { get; set; }
+                    string DependencyName { get; set; }
                 }
             }

Implab.ServiceHost/Unity/ISerializedValue.cs +8 -4

@@ -1,7 +1,11
1	namespace Implab.ServiceHost.Unity	1	using System.Xml;
2	{	2
3	public class ISerializedValue	3	namespace Implab.ServiceHost.Unity {
4	{	4	public interface ISerializedValue {
		5
		6	string TypeName { get; }
		7
		8	XmlReader GetReader();
5		9
6	}	10	}
7	} No newline at end of file	11	}

Implab.ServiceHost/Unity/ITextValue.cs +2 0

             namespace Implab.ServiceHost.Unity {
                 public interface ITextValue {
+                    string TypeName { get; }
                     string Value { get; }
                 }
             }

Implab.ServiceHost/Unity/IncludeElement.cs +1 -1

             using System.Xml.Serialization;
             namespace Implab.ServiceHost.Unity {
                 [XmlRoot("include", Namespace = Schema.ContainerConfigurationNamespace)]
                 public class IncludeElement : ContainerItemElement {
                     [XmlAttribute("href")]
                     public string Href { get; set; }
-                    public override void Visit(ContainerContext context) {
+                    public override void Visit(ContainerBuilder context) {
                         context.Visit(this);
                     }
                 }
             }

Implab.ServiceHost/Unity/InjectionParameterElement.cs +1 -5

             using System;
             using System.Xml.Serialization;
             namespace Implab.ServiceHost.Unity {
                 public abstract class InjectionParameterElement {
                     [XmlAttribute("type")]
                     public string TypeName { get; set; }
-                    internal abstract object Resolve(InjectionValueContext context);
+                    internal abstract void Visit(InjectionValueBuilder builder);
-                    public virtual Type ResolveParameterType(InjectionValueContext context) {
-                        return context.ResolveType(TypeName);
                 }
             }

Implab.ServiceHost/Unity/LifetimeElement.cs +1 -1

             using Unity.Lifetime;
             namespace Implab.ServiceHost.Unity
             {
                 public abstract class LifetimeElement
                 {
-                    public abstract LifetimeManager GetLifetimeManager(ContainerContext ctx);
+                    public abstract LifetimeManager GetLifetimeManager(ContainerBuilder ctx);
                 }
             }

Implab.ServiceHost/Unity/MethodInjectionElement.cs +1 -1

             using System.Xml.Serialization;
             namespace Implab.ServiceHost.Unity {
                 public class MethodInjectionElement : AbstractInjectionElement {
                     [XmlAttribute("name")]
                     public string Name { get; set; }
                     [XmlElement("dependency", typeof(DependencyParameterElement))]
                     [XmlElement("value", typeof(ValueParameterElement))]
                     [XmlElement("serialized", typeof(SerializedParameterElement))]
                     [XmlElement("default", typeof(DefaultParameterElement))]
                     public InjectionParameterElement[] Parameters { get; set; }
-                    internal override void Visit(RegistrationContext context) {
+                    internal override void Visit(TypeRegistrationBuilder context) {
                         context.Visit(this);
                     }
                 }
             }

Implab.ServiceHost/Unity/NamespaceElement.cs +1 -1

             using System.Xml.Serialization;
             namespace Implab.ServiceHost.Unity
             {
                 [XmlRoot("namespace", Namespace = Schema.ContainerConfigurationNamespace)]
                 public class NamespaceElement : ContainerItemElement {
                     [XmlAttribute("name")]
                     public string Name { get; set; }
-                    public override void Visit(ContainerContext context) {
+                    public override void Visit(ContainerBuilder context) {
                         context.Visit(this);
                     }
                 }
             }

Implab.ServiceHost/Unity/PropertyInjectionElement.cs +1 -1

             using System.Xml.Serialization;
             namespace Implab.ServiceHost.Unity {
                 public class PropertyInjectionElement : AbstractInjectionElement {
                     [XmlAttribute("name")]
                     public string Name { get; set; }
                     [XmlElement("dependency", typeof(DependencyParameterElement))]
                     [XmlElement("value", typeof(ValueParameterElement))]
                     [XmlElement("serialized", typeof(SerializedParameterElement))]
                     [XmlElement("default", typeof(DefaultParameterElement))]
                     public InjectionParameterElement Value { get; set; }
-                    internal override void Visit(RegistrationContext context) {
+                    internal override void Visit(TypeRegistrationBuilder context) {
                         context.Visit(this);
                     }
                 }
             }

Implab.ServiceHost/Unity/RegisterElement.cs +1 -7

             using System;
             using System.Xml.Serialization;
             using Unity.Lifetime;
             using Unity.Registration;
             namespace Implab.ServiceHost.Unity {
                 [XmlRoot("register", Namespace = Schema.ContainerConfigurationNamespace)]
                 public class RegisterElement : AbstractRegistration  {
                     /// <summary>
                     /// An optional type which is registered as a service in the container, must be assignable to <see cref="ProvidesType">.
                     /// </summary>
                     [XmlAttribute("mapTo")]
                     public string MapToType { get; set; }
                     [XmlElement("constructor", typeof(ConstructorInjectionElement))]
                     [XmlElement("property", typeof(PropertyInjectionElement))]
                     [XmlElement("method", typeof(MethodInjectionElement))]
                     public AbstractInjectionElement[] Injectors { get; set; }
-                    public override void Visit(ContainerContext context) {
+                    public override void Visit(ContainerBuilder context) {
                         context.Visit(this);
                     }
-                    public virtual Type ResolveImplementationType(ContainerContext ctx) {
-                        return string.IsNullOrEmpty(MapToType) ?
-                            ResolveRegistrationType(ctx) :
-                            ctx.Resolve(MapToType);
                 }
             }

Implab.ServiceHost/Unity/SerializedElement.cs +14 -15

             using System;
             using System.Xml;
             using System.Xml.Serialization;
             namespace Implab.ServiceHost.Unity
             {
-                public class SerializedElement : AbstractRegistration {
+                public class SerializedElement : AbstractRegistration, ISerializedValue {
                     [XmlAttribute("href")]
                     public string Location { get; set; }
                     [XmlAttribute("serializedType")]
                     public string SerializedType { get; set; }
                     [XmlAnyElement]
                     public XmlElement[] Content { get; set; }
-                    public override void Visit(ContainerContext context) {
+                    string ISerializedValue.TypeName {
+                        get {
+                            return string.IsNullOrEmpty(SerializedType) ? RegistrationType : SerializedType;
+                        }
+                    }
+                    public override void Visit(ContainerBuilder context) {
                         context.Visit(this);
                     }
-                    public virtual Type ResolveSerializedType(ContainerContext context) {
+                    public XmlReader GetReader() {
-                        if(string.IsNullOrEmpty(SerializedType))
+                        if (!string.IsNullOrEmpty(Location))
-                            return ResolveRegistrationType(context);
+                            return XmlReader.Create(Location);
-                        return context.Resolve(SerializedType);
+                        if (Content != null && Content.Length > 0)
+                            return Content[0].CreateNavigator().ReadSubtree();
-                    public virtual object GetValue(ContainerContext context) {
+                        throw new Exception("No content found, expected XML document");
-                        var type = ResolveRegistrationType(context);
-                        if (Content == null || Content.Length == 0)
-                            return Safe.CreateDefaultValue(type);
-                        var serializer = new XmlSerializer(type);
-                        using(var reader = Content[0].CreateNavigator().ReadSubtree())
-                            return serializer.Deserialize(reader);
                     }
                 }
             }

Implab.ServiceHost/Unity/SerializedParameterElement.cs +13 -3

+            using System;
             using System.Xml;
             using System.Xml.Schema;
             using System.Xml.Serialization;
             namespace Implab.ServiceHost.Unity
             {
-                public class SerializedParameterElement : InjectionParameterElement {
+                public class SerializedParameterElement : InjectionParameterElement, ISerializedValue {
                     [XmlAttribute("href")]
                     public string Location { get; set; }
                     [XmlAnyElement]
                     public XmlElement[] Content { get; set; }
-                    internal override object Resolve(RegistrationContext context) {
+                    public XmlReader GetReader() {
-                        return context.Resolve(this);
+                        if (!string.IsNullOrEmpty(Location))
+                            return XmlReader.Create(Location);
+                        if (Content != null && Content.Length > 0)
+                            return Content[0].CreateNavigator().ReadSubtree();
+                        throw new Exception("No content found, expected XML document");
+                    }
+                    internal override void Visit(InjectionValueBuilder builder) {
+                        builder.Visit(this);
                     }
                 }
             }

Implab.ServiceHost/Unity/SimgletonLifetimeElement.cs +1 -1

             using Unity.Lifetime;
             namespace Implab.ServiceHost.Unity
             {
                 public class SimgletonLifetimeElement : LifetimeElement {
-                    public override LifetimeManager GetLifetimeManager(ContainerContext ctx) {
+                    public override LifetimeManager GetLifetimeManager(ContainerBuilder ctx) {
                         return new SingletonLifetimeManager();
                     }
                 }
             }

Implab.ServiceHost/Unity/ValueElement.cs +16 -2

             using System.Xml.Serialization;
             namespace Implab.ServiceHost.Unity {
                 public class ValueElement : AbstractRegistration, ITextValue {
-                    [XmlText]
                     [XmlAttribute("value")]
                     public string Value { get; set; }
-                    public override void Visit(ContainerContext context) {
+                    [XmlText]
+                    public string Text { get; set; }
+                    string ITextValue.Value {
+                        get {
+                            return string.IsNullOrEmpty(Value) ? Text : Value;
+                        }
+                    }
+                    public string TypeName {
+                        get {
+                            return RegistrationType;
+                        }
+                    }
+                    public override void Visit(ContainerBuilder context) {
                         context.Visit(this);
                     }
                 }
             }

Implab.ServiceHost/Unity/ValueParameterElement.cs +4 -6

             using System.Xml.Serialization;
-            namespace Implab.ServiceHost.Unity
+            namespace Implab.ServiceHost.Unity {
+                public class ValueParameterElement : InjectionParameterElement, ITextValue {
-                public class ValueParameterElement : InjectionParameterElement
                     [XmlText]
                     [XmlAttribute("value")]
                     public string Value { get; set; }
-                    internal override object Resolve(RegistrationContext context) {
+                    internal override void Visit(InjectionValueBuilder builder) {
-                        return context.Resolve(this);
+                        builder.Visit(this);
                     }
                 }
             }

Implab.ServiceHost/Unity/ContainerContext.cs removed 0 -111

NO CONTENT: file was removed

Implab.ServiceHost/Unity/InjectionValueContext.cs removed 0 -41

NO CONTENT: file was removed

Implab.ServiceHost/Unity/InstanceRegistrationContext.cs removed 0 -16

NO CONTENT: file was removed

Implab.ServiceHost/Unity/RegistrationContext.cs removed 0 -21

NO CONTENT: file was removed

Implab.ServiceHost/Unity/TypeRegistrationContext.cs removed 0 -65

NO CONTENT: file was removed

General Comments 3

sergey

|

Auto status change to "Under Review"

sergey

|

ok, latest stable version should be in default

Write
Preview

You need to be logged in to leave comments. Login now

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages