implab/ImplabNet Commit - r273:79110a16cab7

Working on Unity xml configuration: Refactoring in progress

cin -

r273:79110a16cab7 v3

parent child

Context file:

r273:79110a16cab7

Expand all files

The requested changes are too big and content was truncated. Show full diff

Implab.ServiceHost/Unity/ContainerConfigurationSchema.cs created 644 +67 0

			@@ -0,0 +1,67
		1	using System;
		2	using System.Collections.Generic;
		3	using System.IO;
		4	using System.Reflection;
		5	using System.Xml;
		6	using System.Xml.Serialization;
		7	using Implab.Components;
		8
		9	namespace Implab.ServiceHost.Unity {
		10	public class ContainerConfigurationSchema {
		11
		12	public static ContainerConfigurationSchema Default { get; private set; } = CreateDefault();
		13
		14	readonly LazyAndWeak<XmlSerializer> m_seralizer;
		15
		16	readonly XmlAttributeOverrides m_overrides = new XmlAttributeOverrides();
		17
		18	readonly XmlAttributes m_containerItems = new XmlAttributes();
		19
		20	public XmlSerializer Serializer {
		21	get {
		22	return m_seralizer.Value;
		23	}
		24	}
		25
		26	public ContainerConfigurationSchema() {
		27	m_overrides.Add(typeof(ContainerElement), nameof(ContainerElement.Items), m_containerItems);
		28
		29	m_seralizer = new LazyAndWeak<XmlSerializer>(() => new XmlSerializer(typeof(ContainerElement), m_overrides));
		30	}
		31
		32	public void RegisterContainerElement(Type type, string name) {
		33	Safe.ArgumentNotNull(type, nameof(type));
		34	Safe.ArgumentNotEmpty(name, nameof(name));
		35
		36	if(!type.IsSubclassOf(typeof(ContainerItemElement)))
		37	throw new Exception($"RegisterContainerElement '{name}': {type} must be subclass of {typeof(ContainerItemElement)}");
		38
		39	m_containerItems.XmlElements.Add(
		40	new XmlElementAttribute(name, type)
		41	);
		42	}
		43
		44	public void RegisterContainerElement<T>(string name) where T : ContainerItemElement {
		45	RegisterContainerElement(typeof(T), name);
		46	}
		47
		48	public ContainerElement LoadFile(string file) {
		49	using (var reader = XmlReader.Create(file)) {
		50	return (ContainerElement)Serializer.Deserialize(reader);
		51	}
		52	}
		53
		54	static ContainerConfigurationSchema CreateDefault() {
		55	var schema = new ContainerConfigurationSchema();
		56
		57	schema.RegisterContainerElement<RegisterElement>("register");
		58	schema.RegisterContainerElement<IncludeElement>("include");
		59	schema.RegisterContainerElement<AssemblyElement>("assembly");
		60	schema.RegisterContainerElement<NamespaceElement>("namespace");
		61
		62	return schema;
		63	}
		64
		65
		66	}
		67	} No newline at end of file

Implab.ServiceHost/Unity/ContainerContext.cs created 644 +111 0

			@@ -0,0 +1,111
		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<ContainerContext>;
		14
		15	public class ContainerContext {
		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 ContainerContext() : this(null, null) {
		30	}
		31
		32	public ContainerContext(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 Resolve(string typeReference) {
		39	return m_resolver.Resolve(typeReference);
		40	}
		41
		42	internal void Visit(RegisterElement registerElement) {
		43	var registrationContext = new TypeRegistrationContext(
		44	m_resolver,
		45	registerElement.ResolveRegistrationType(this),
		46	registerElement.ResolveImplementationType(this)
		47	);
		48
		49	if (registerElement.Injectors != null) {
		50	foreach (var injector in registerElement.Injectors) {
		51	injector.Visit(registrationContext);
		52	}
		53	}
		54
		55	m_container.RegisterType(
		56	registrationContext.RegistrationType,
		57	registrationContext.ImplementationType,
		58	registerElement.Name,
		59	registerElement.Lifetime?.GetLifetimeManager(this),
		60	registrationContext.Injections
		61	);
		62	}
		63
		64	internal void Visit(SerializedElement serializedElement) {
		65	var registrationType = serializedElement.ResolveRegistrationType(this);
		66	var instace = serializedElement.GetValue(this);
		67
		68
		69	m_container.RegisterInstance(
		70	registrationType,
		71	serializedElement.Name,
		72	instace,
		73	serializedElement.Lifetime?.GetLifetimeManager(this)
		74	);
		75	}
		76
		77	internal void Visit(ValueElement valueElement) {
		78
		79	}
		80
		81	internal void Visit(NamespaceElement namespaceElement) {
		82	m_resolver.AddNamespace(namespaceElement.Name);
		83	}
		84
		85	internal void Visit(AssemblyElement assemblyElement) {
		86	Assembly.Load(assemblyElement.AssemblyName);
		87	}
		88
		89	internal void Visit(IncludeElement includeElement) {
		90	Include(includeElement.Href);
		91	}
		92
		93	public void Include(string file) {
		94	var includeContext = new ContainerContext(m_container, m_schema);
		95	includeContext.LoadConfig(file);
		96	}
		97
		98	public void LoadConfig(string file) {
		99	var config = m_schema.LoadFile(file);
		100	Visit(config);
		101	}
		102
		103	internal void Visit(ContainerElement containerElement) {
		104	foreach (var item in containerElement.Items)
		105	item.Visit(this);
		106	}
		107
		108
		109
		110	}
		111	} No newline at end of file

Implab.ServiceHost/Unity/ContainerItemElement.cs created 644 +5 0

			@@ -0,0 +1,5
		1	namespace Implab.ServiceHost.Unity {
		2	public abstract class ContainerItemElement {
		3	public abstract void Visit(ContainerContext context);
		4	}
		5	} No newline at end of file

Implab.ServiceHost/Unity/IDependencyReference.cs created 644 +5 0

			@@ -0,0 +1,5
		1	namespace Implab.ServiceHost.Unity {
		2	public interface IDependencyReference {
		3	string Name { get; set; }
		4	}
		5	} No newline at end of file

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

			@@ -0,0 +1,7
		1	namespace Implab.ServiceHost.Unity
		2	{
		3	public class ISerializedValue
		4	{
		5
		6	}
		7	} No newline at end of file

Implab.ServiceHost/Unity/ITextValue.cs created 644 +6 0

			@@ -0,0 +1,6
		1	namespace Implab.ServiceHost.Unity {
		2	public interface ITextValue {
		3	string Value { get; }
		4
		5	}
		6	} No newline at end of file

Implab.ServiceHost/Unity/InjectionValueContext.cs created 644 +41 0

			@@ -0,0 +1,41
		1	using System;
		2	using Unity.Injection;
		3
		4	namespace Implab.ServiceHost.Unity {
		5
		6	public class InjectionValueContext {
		7
		8	readonly TypeResolver m_resolver;
		9
		10	public Type AcceptsType { get; private set; }
		11
		12	public object Value { get; set; }
		13
		14	internal InjectionValueContext(TypeResolver resolver, Type acceptsType) {
		15	m_resolver = resolver;
		16	AcceptsType = acceptsType;
		17	}
		18
		19	public Type ResolveType(string typeSpec) {
		20	if (string.IsNullOrEmpty(typeSpec)) {
		21	if (AcceptsType == null)
		22	throw new Exception("The type must be specified");
		23	return AcceptsType;
		24	}
		25	return m_resolver.Resolve(typeSpec);
		26	}
		27
		28	public void Visit(ITextValue value) {
		29
		30	}
		31
		32	public void Visit(ISerializedValue value) {
		33
		34	}
		35
		36	public void Visit(IDependencyReference value) {
		37	Value = new ResolvedParameter()
		38	}
		39
		40	}
		41	} No newline at end of file

Implab.ServiceHost/Unity/InstanceRegistrationContext.cs created 644 +16 0

			@@ -0,0 +1,16
		1	using System;
		2
		3	namespace Implab.ServiceHost.Unity {
		4	public class InstanceRegistrationContext : RegistrationContext {
		5
		6	readonly TypeResolver m_typeResolver;
		7	public override TypeResolver Resolver { get { return m_typeResolver; } }
		8
		9	public InstanceRegistrationContext(TypeResolver resolver, Type registrationType) : base(registrationType) {
		10	Safe.ArgumentNotNull(resolver, nameof(resolver));
		11	m_typeResolver = resolver;
		12	}
		13
		14
		15	}
		16	} No newline at end of file

Implab.ServiceHost/Unity/SerializedElement.cs created 644 +38 0

			@@ -0,0 +1,38
		1	using System;
		2	using System.Xml;
		3	using System.Xml.Serialization;
		4
		5	namespace Implab.ServiceHost.Unity
		6	{
		7	public class SerializedElement : AbstractRegistration {
		8	[XmlAttribute("href")]
		9	public string Location { get; set; }
		10
		11	[XmlAttribute("serializedType")]
		12	public string SerializedType { get; set; }
		13
		14
		15	[XmlAnyElement]
		16	public XmlElement[] Content { get; set; }
		17
		18	public override void Visit(ContainerContext context) {
		19	context.Visit(this);
		20	}
		21
		22	public virtual Type ResolveSerializedType(ContainerContext context) {
		23	if(string.IsNullOrEmpty(SerializedType))
		24	return ResolveRegistrationType(context);
		25	return context.Resolve(SerializedType);
		26	}
		27
		28	public virtual object GetValue(ContainerContext context) {
		29	var type = ResolveRegistrationType(context);
		30	if (Content == null \|\| Content.Length == 0)
		31	return Safe.CreateDefaultValue(type);
		32
		33	var serializer = new XmlSerializer(type);
		34	using(var reader = Content[0].CreateNavigator().ReadSubtree())
		35	return serializer.Deserialize(reader);
		36	}
		37	}
		38	} No newline at end of file

Implab.ServiceHost/Unity/TypeRegistrationContext.cs created 644 +65 0

			@@ -0,0 +1,65
		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 TypeRegistrationContext : RegistrationContext {
		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 TypeRegistrationContext(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	var valueContext = new InjectionValueContext(m_resolver, null);
		37
		38	var parameters = constructorInjection.Parameters?.Select(x => x.Resolve(valueContext)).ToArray();
		39
		40	var injection = parameters != null ? new InjectionConstructor(parameters) : new InjectionConstructor();
		41	m_injections.Add(injection);
		42	}
		43
		44	internal void Visit(MethodInjectionElement methodInjection) {
		45	var valueContext = new InjectionValueContext(m_resolver, null);
		46
		47	var parameters = methodInjection.Parameters?.Select(x => x.Resolve(valueContext)).ToArray();
		48
		49	var injection = parameters != null ? new InjectionMethod(methodInjection.Name, parameters) : new InjectionMethod(methodInjection.Name);
		50	m_injections.Add(injection);
		51	}
		52
		53	internal void Visit(PropertyInjectionElement propertyInjection) {
		54	if (propertyInjection.Value == null)
		55	throw new Exception($"A value value must be specified for the property '{propertyInjection.Name}'");
		56
		57	var propertyType = RegistrationType.GetProperty(propertyInjection.Name)?.PropertyType;
		58	var valueContext = new InjectionValueContext(m_resolver, propertyType);
		59
		60	var parameter = propertyInjection.Value.Resolve(valueContext);
		61	var injection = new InjectionProperty(propertyInjection.Name, parameter);
		62	m_injections.Add(injection);
		63	}
		64	}
		65	} No newline at end of file

Implab.ServiceHost/Unity/ValueElement.cs created 644 +14 0

			@@ -0,0 +1,14
		1	using System.Xml.Serialization;
		2
		3	namespace Implab.ServiceHost.Unity {
		4	public class ValueElement : AbstractRegistration, ITextValue {
		5
		6	[XmlText]
		7	[XmlAttribute("value")]
		8	public string Value { get; set; }
		9
		10	public override void Visit(ContainerContext context) {
		11	context.Visit(this);
		12	}
		13	}
		14	} No newline at end of file

msbuild.log created 644 0 0

	1		NO CONTENT: new file 100644
The requested commit or file is too big and content was truncated. Show full diff

Implab.Playground/Program.cs +17 -8

              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 container = new UnityContainer();
+                         var stopwatch = new Stopwatch();
+                         stopwatch.Start();
-                         var ctx = new ConfigurationContext(container);
+                         var ctx = new ContainerContext();
+                         Console.WriteLine($"Created: {stopwatch.ElapsedMilliseconds}");
+                         ctx.LoadConfig("data/sample.xml");
-                         var conf = SerializationHelpers.DeserializeFromFile<ContainerElement>("data/sample.xml");
+                         Console.WriteLine($"Loaded: {stopwatch.ElapsedMilliseconds}");
+                         var container = ctx.Container;
-                         ctx.Visit(conf);
+                         var instace1 = container.Resolve<IContainer<string>>();
+                         Console.WriteLine($"Resolved1: {stopwatch.ElapsedMilliseconds}");
+                         var instace2 = container.Resolve<IContainer<Foo>>();
+                         Console.WriteLine($"Resolved2: {stopwatch.ElapsedMilliseconds}");
                          DisplayContainerRegistrations(container);
-                         var instace1 = container.Resolve<IContainer<string>>();
-                         var instace2 = container.Resolve<IContainer<Foo>>();
                      }
                      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 +12 -3

              <?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 provides="IContainer{}" type="Container{}">
+                 <register type="IContainer{}" mapTo="Container{}">
                      <constructor/>
                      <method name="SetInstance">
                          <dependency type="T"/>
                      </method>
                  </register>
-                 <register provides="IContainer{String}" type="Container{String}">
+                 <register type="IContainer{String}" mapTo="Container{String}">
                      <constructor/>
                      <method name="SetInstance">
-                         <value type="String">Hello!</value>
+                         <dependency type="String" name="name1"/>
                      </method>
                  </register>
+                 <serialized type="Foo+Bar">
+                     <Bar 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>
  No newline at end of file

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

              using System;
              namespace Implab.ServiceHost.Unity
              {
                  public abstract class AbstractInjectionElement {
-                     internal abstract void Visit(RegistrationContext context);
+                     internal abstract void Visit(TypeRegistrationContext context);
                  }
              }
  No newline at end of file

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

              using System;
              using System.Xml.Serialization;
              using Unity.Lifetime;
              using Unity.Registration;
              namespace Implab.ServiceHost.Unity
              {
-                 public abstract class AbstractRegistration : IConfigurationElement {
+                 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("provides")]
-                     public string ProvidesType { get; set; }
+                     [XmlAttribute("type")]
+                     public string RegistrationType { get; set; }
-                     public abstract void Visit(ConfigurationContext context);
+                     public virtual Type ResolveRegistrationType(ContainerContext ctx) {
+                         return ctx.Resolve(RegistrationType);
+                     }
                  }
              }
  No newline at end of file

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

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

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(RegistrationContext context) {
+                     internal override void Visit(TypeRegistrationContext context) {
                          context.Visit(this);
                      }
                  }
              }
  No newline at end of file

Implab.ServiceHost/Unity/ContainerElement.cs +4 -18

              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 : IXmlSerializable {
-                     public List<IConfigurationElement> Items {get; set; } = new List<IConfigurationElement>();
-                     public XmlSchema GetSchema() {
-                         return null;
+                     }
+                 public class ContainerElement : ContainerItemElement {
-                     public void ReadXml(XmlReader reader) {
-                         while(reader.Read() && reader.NodeType != XmlNodeType.EndElement) {
-                             var registration = ConfigurationSchema.Default.Deserialize<IConfigurationElement>(reader);
-                             Items.Add(registration);
+                         }
+                     }
+                     public List<ContainerItemElement> Items {get; set; } = new List<ContainerItemElement>();
-                     public void WriteXml(XmlWriter writer) {
-                         foreach(var item in Items) {
-                             var serializer = new XmlSerializer(item.GetType());
-                             serializer.Serialize(writer, item);
+                         }
+                     public override void Visit(ContainerContext context) {
+                         context.Visit(this);
                      }
                  }
              }
  No newline at end of file

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

              using Unity.Lifetime;
              namespace Implab.ServiceHost.Unity
              {
                  public class ContainerLifetimeElement : LifetimeElement {
-                     public override LifetimeManager GetLifetimeManager(ConfigurationContext ctx) {
+                     public override LifetimeManager GetLifetimeManager(ContainerContext ctx) {
                          return new ContainerControlledLifetimeManager();
                      }
                  }
              }
  No newline at end of file

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

              using Unity.Lifetime;
              namespace Implab.ServiceHost.Unity
              {
                  public class ContextLifetimeElement : LifetimeElement {
-                     public override LifetimeManager GetLifetimeManager(ConfigurationContext ctx) {
+                     public override LifetimeManager GetLifetimeManager(ContainerContext ctx) {
                          return new PerResolveLifetimeManager();
                      }
                  }
              }
  No newline at end of file

Implab.ServiceHost/Unity/DefaultParameterElement.cs +3 -2

              namespace Implab.ServiceHost.Unity
              {
                  public class DefaultParameterElement : InjectionParameterElement {
-                     internal override object Resolve(RegistrationContext context) {
-                         return context.Resolve(this);
+                     internal override object Resolve(InjectionValueContext context) {
+                         var type = context.ResolveType(TypeName);
+                         return Safe.CreateDefaultValue(type);
                      }
                  }
              }
  No newline at end of file

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

              using System.Xml.Serialization;
              namespace Implab.ServiceHost.Unity {
                  public class DependencyParameterElement : InjectionParameterElement {
                      [XmlAttribute("name")]
                      public string DependencyName { get; set; }
                      [XmlAttribute("optional")]
                      public bool Optional { get; set; }
-                     internal override object Resolve(RegistrationContext context) {
-                         return context.Resolve(this);
+                     }
                  }
              }
  No newline at end of file

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

              using Unity.Lifetime;
              namespace Implab.ServiceHost.Unity
              {
                  public class HierarchicalLifetimeElement : LifetimeElement {
-                     public override LifetimeManager GetLifetimeManager(ConfigurationContext ctx) {
+                     public override LifetimeManager GetLifetimeManager(ContainerContext ctx) {
                          return new HierarchicalLifetimeManager();
                      }
                  }
              }
  No newline at end of file

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

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

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

+             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(RegistrationContext context);
+                     internal abstract object Resolve(InjectionValueContext context);
+                     public virtual Type ResolveParameterType(InjectionValueContext context) {
+                         return context.ResolveType(TypeName);
+                     }
                  }
              }
  No newline at end of file

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

              using Unity.Lifetime;
              namespace Implab.ServiceHost.Unity
              {
                  public abstract class LifetimeElement
                  {
-                     public abstract LifetimeManager GetLifetimeManager(ConfigurationContext ctx);
+                     public abstract LifetimeManager GetLifetimeManager(ContainerContext ctx);
                  }
              }
  No newline at end of file

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

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

Implab.ServiceHost/Unity/RegisterElement.cs +9 -3

              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("type")]
-                     public string ImplementationType { get; set; }
+                     [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(ConfigurationContext context) {
+                     public override void Visit(ContainerContext context) {
                          context.Visit(this);
                      }
+                     public virtual Type ResolveImplementationType(ContainerContext ctx) {
+                         return string.IsNullOrEmpty(MapToType) ?
+                             ResolveRegistrationType(ctx) :
+                             ctx.Resolve(MapToType);
+                     }
                  }
              }
  No newline at end of file

Implab.ServiceHost/Unity/RegistrationContext.cs +3 -101

		@@ -1,119 +1,21
1	1	using System;
2	2	using System.Collections.Generic;
3	3	using System.ComponentModel;
4	4	using System.Linq;
5	5	using System.Xml.Serialization;
6	6	using Implab.Xml;
7	7	using Unity.Injection;
8	8	using Unity.Registration;
9	9
10	10	namespace Implab.ServiceHost.Unity {
11		class RegistrationContext {
12		readonly TypeResolver m_resolver;
13
14		List<InjectionMember> m_injections = new List<InjectionMember>();
15
16		Type m_defaultType;
17
	11	public abstract class RegistrationContext {
18	12	public Type RegistrationType {
19	13	get;
20	14	private set;
21	15	}
22	16
23		public Type ImplementationType {
24		get;
25		private set;
26		}
27
28		public RegistrationContext(TypeResolver resolver, string typeSpec, string implSpec) {
29		RegistrationType = resolver.Resolve(string.IsNullOrEmpty(typeSpec) ? implSpec : typeSpec);
30
31
32		ImplementationType = string.IsNullOrEmpty(implSpec) ? RegistrationType : resolver.Resolve(implSpec);
33
34		if (RegistrationType.IsGenericTypeDefinition) {
35		m_resolver = new TypeResolver(resolver);
36
37		foreach (var p in ImplementationType.GetGenericArguments())
38		m_resolver.AddMapping(p.Name, p);
39		} else {
40		m_resolver = resolver;
41		}
42
43
44		}
45
46		public InjectionMember[] Injections {
47		get {
48		return m_injections.ToArray();
49		}
50		}
51
52		public void Visit(ConstructorInjectionElement constructorInjection) {
53		var parameters = constructorInjection.Parameters?.Select(x => x.Resolve(this)).ToArray();
54
55		var injection = parameters != null ? new InjectionConstructor(parameters) : new InjectionConstructor();
56		m_injections.Add(injection);
57		}
58
59		public void Visit(MethodInjectionElement methodInjection) {
60		var parameters = methodInjection.Parameters?.Select(x => x.Resolve(this)).ToArray();
61
62		var injection = parameters != null ? new InjectionMethod(methodInjection.Name, parameters) : new InjectionMethod(methodInjection.Name);
63		m_injections.Add(injection);
64		}
65
66		public void Visit(PropertyInjectionElement propertyInjection) {
67		if (propertyInjection.Value == null)
68		throw new Exception($"A value value must be specified for the property '{propertyInjection.Name}'");
69
70		try {
71		m_defaultType = RegistrationType.GetProperty(propertyInjection.Name)?.PropertyType;
72
73		var parameter = propertyInjection.Value.Resolve(this);
74		var injection = new InjectionProperty(propertyInjection.Name, parameter);
75		m_injections.Add(injection);
76
77		} finally {
78		m_defaultType = null;
79		}
80
81		}
82
83		Type ResolveParameterType(InjectionParameterElement injectionParameter) {
84		if (string.IsNullOrEmpty(injectionParameter.TypeName)) {
85		if (m_defaultType == null)
86		throw new Exception($"A type must be specified for the parameter {injectionParameter}");
87		return m_defaultType;
88		}
89		return m_resolver.Resolve(injectionParameter.TypeName);
90		}
91
92		public object Resolve(DefaultParameterElement defaultParameter) {
93		var type = ResolveParameterType(defaultParameter);
94
95		return Safe.CreateDefaultValue(type);
96		}
97
98		public object Resolve(ValueParameterElement valueParameter) {
99		var type = ResolveParameterType(valueParameter);
100
101		return TypeDescriptor.GetConverter(type).ConvertFromString(valueParameter.Value);
102		}
103
104		public object Resolve(SerializedParameterElement serializedParameter) {
105		var type = ResolveParameterType(serializedParameter);
106		if (serializedParameter.Content == null \|\| serializedParameter.Content.Length == 0)
107		return Safe.CreateDefaultValue(type);
108
109		var serializer = new XmlSerializer(type);
110		using (var reader = serializedParameter.Content[0].CreateNavigator().ReadSubtree())
111		return serializer.Deserialize(reader);
112		}
113
114		public InjectionParameterValue Resolve(DependencyParameterElement dependencyParameter) {
115		var type = ResolveParameterType(dependencyParameter);
116		return new ResolvedParameter(type, dependencyParameter.DependencyName);
	17	protected RegistrationContext(Type registrationType) {
	18	RegistrationType = registrationType;
117	19	}
118	20	}
119	21	} No newline at end of file

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

              using System.Xml;
              using System.Xml.Schema;
              using System.Xml.Serialization;
              namespace Implab.ServiceHost.Unity
              {
                  public class SerializedParameterElement : InjectionParameterElement {
+                     [XmlAttribute("href")]
+                     public string Location { get; set; }
                      [XmlAnyElement]
                      public XmlElement[] Content { get; set; }
                      internal override object Resolve(RegistrationContext context) {
                          return context.Resolve(this);
                      }
                  }
              }
  No newline at end of file

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

              using Unity.Lifetime;
              namespace Implab.ServiceHost.Unity
              {
                  public class SimgletonLifetimeElement : LifetimeElement {
-                     public override LifetimeManager GetLifetimeManager(ConfigurationContext ctx) {
+                     public override LifetimeManager GetLifetimeManager(ContainerContext ctx) {
                          return new SingletonLifetimeManager();
                      }
                  }
              }
  No newline at end of file

Implab.ServiceHost/Unity/ValueParameterElement.cs +1 0

              using System.Xml.Serialization;
              namespace Implab.ServiceHost.Unity
              {
                  public class ValueParameterElement : InjectionParameterElement
                  {
                      [XmlText]
+                     [XmlAttribute("value")]
                      public string Value { get; set; }
                      internal override object Resolve(RegistrationContext context) {
                          return context.Resolve(this);
                      }
                  }
              }
  No newline at end of file

Implab/Xml/readme.txt +2 -2

-             XML to JSON transform is taken from different project https://hg.implab.org/pub/ModelGenerator/
+             XML to JSON transform is taken from the different project https://hg.implab.org/pub/ModelGenerator/
              run:
                wget https://hg.implab.org/pub/ModelGenerator/raw-file/tip/xslt/json.xsl
-             to update to the latest version
  No newline at end of file
+             to update it to the latest version
  No newline at end of file

Implab.ServiceHost/Unity/ConfigurationContext.cs removed 0 -78

NO CONTENT: file was removed

Implab.ServiceHost/Unity/ConfigurationSchema.cs removed 0 -50

NO CONTENT: file was removed

Implab.ServiceHost/Unity/IConfigurationElement.cs removed 0 -5

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