implab/ImplabNet Commit - r278:6691aff01de1

Implab: added XmlDefaultSeializer (SerializersPool is now obsolete)...

cin -

r278:6691aff01de1 v3

parent child

Context file:

r278:6691aff01de1

Expand all files

Implab.ServiceHost/Unity/ArrayTypeReference.cs created 644 +57 0

			@@ -0,0 +1,57
		1	using System;
		2	using System.Text;
		3
		4	namespace Implab.ServiceHost.Unity {
		5	public class ArrayTypeReference : TypeReference {
		6	public int Rank { get; private set; }
		7
		8	public TypeReference ItemsType { get; private set; }
		9
		10	public override string Name {
		11	get {
		12	return ItemsType.Name;
		13	}
		14	}
		15
		16	public override string ClrName {
		17	get {
		18	return new StringBuilder()
		19	.Append(ItemsType.ClrName)
		20	.Append("[")
		21	.Append(',', Rank - 1)
		22	.Append("]")
		23	.ToString();
		24	}
		25	}
		26
		27	public override string Namespace {
		28	get {
		29	return ItemsType.Namespace;
		30	}
		31	}
		32
		33	public override int GenericParametersCount {
		34	get {
		35	return 0;
		36	}
		37	}
		38
		39	internal ArrayTypeReference(TypeReference itemsType, int rank) {
		40	ItemsType = itemsType;
		41	Rank = rank;
		42	}
		43
		44	internal override void Visit(TypeResolutionContext visitor) {
		45	visitor.Visit(this);
		46	}
		47
		48	override public string ToString() {
		49	return new StringBuilder()
		50	.Append(ItemsType.ToString())
		51	.Append('[')
		52	.Append(',', Rank - 1)
		53	.Append(']')
		54	.ToString();
		55	}
		56	}
		57	} No newline at end of file

Implab.ServiceHost/Unity/FactoryActivator.cs created 644 +29 0

			@@ -0,0 +1,29
		1	using System;
		2
		3	namespace Implab.ServiceHost.Unity {
		4	public class FactoryActivator : FactoryAbstractRegistratrion {
		5
		6	public Type FactoryType { get; set; }
		7
		8	public string FactoryName { get; set; }
		9
		10	public new Type RegistrationType { get; set; }
		11
		12	public override void Visit(FactoryRegistrationBuilder builder) {
		13	base.Visit(builder);
		14
		15	builder.GetType()
		16	.GetMethod(
		17	nameof(FactoryRegistrationBuilder.SetFactoryDependency)
		18	, new[] { typeof(string) }
		19	)
		20	.MakeGenericMethod(FactoryType, RegistrationType)
		21	.Invoke(builder, new[] { FactoryName });
		22	}
		23
		24	public override Type GetRegistrationType(Func<string, Type> resolver) {
		25	return RegistrationType;
		26	}
		27
		28	}
		29	} No newline at end of file

Implab.ServiceHost/Unity/FactoryElement.cs created 644 +72 0

			@@ -0,0 +1,72
		1	using System;
		2	using System.Xml.Serialization;
		3	using Implab.Components;
		4
		5	namespace Implab.ServiceHost.Unity {
		6	/// <summary>
		7	/// Расширяет стандартную регистрацию типа до фабрики, вместе с регистрацией
		8	/// самой фабрики создаются регистрации сервисов, которые она предоставляет.
		9	/// </summary>
		10	public class FactoryElement : RegisterElement {
		11
		12	/// <summary>
		13	/// Записи о сервисах, которые создаются данной фабрикой.
		14	/// </summary>
		15	/// <remarks>
		16	/// Сервисы, которые указаны в регистарциях они должны соответсвовать тому,
		17	/// что фабрика возвращает, но это остается на откуп контейнера
		18	/// </remarks>
		19	[XmlElement("provides")]
		20	public ProvidesElement[] Provides { get; set; }
		21
		22	/// <summary>
		23	/// Переопределяет стандарное поведение регистрации типа в контейнере,
		24	/// дополняя его регистрацией фабричных методов для получения типов.
		25	/// </summary>
		26	/// <param name="builder">Объект для конфигурирования контейнера.</param>
		27	public override void Visit(ContainerBuilder builder) {
		28	var factoryType = GetRegistrationType(builder.ResolveType);
		29
		30	base.Visit(builder);
		31
		32	if (Provides != null && Provides.Length > 0) {
		33	// если регистрации явно заданы, используеися информация из них
		34	foreach(var item in Provides) {
		35	var activator = new FactoryActivator {
		36	Name = item.RegistrationName,
		37	RegistrationType = builder.ResolveType(item.RegistrationType),
		38	FactoryName = Name,
		39	FactoryType = factoryType
		40	};
		41	activator.Visit(builder);
		42	}
		43	} else {
		44	// если регистрация явно не задана, в качестве сервиса для регистрации
		45	// используется тип создаваемый фабрикой, который будет добавлен в контейнер
		46	// с темже именем, что и сама фабрика (разные типы могут иметь одно имя для регистрации)
		47	var providedType = (
		48	factoryType.IsGenericType && factoryType.GetGenericTypeDefinition() == typeof(IFactory<>) ?
		49	factoryType :
		50	factoryType.GetInterface(typeof(IFactory<>).FullName)
		51	)?
		52	.GetGenericArguments()[0];
		53
		54	// не удалось определеить тип
		55	if (providedType == null)
		56	throw new ArgumentException("Failed to determine a type provided by the factory");
		57
		58	if (providedType.IsGenericParameter)
		59	throw new ArgumentException("Can't register a generic type paramter as a service");
		60
		61	var activator = new FactoryActivator {
		62	Name = Name,
		63	RegistrationType = providedType,
		64	FactoryName = Name,
		65	FactoryType = factoryType
		66	};
		67
		68	activator.Visit(builder);
		69	}
		70	}
		71	}
		72	} No newline at end of file

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

			@@ -0,0 +1,5
		1	namespace Implab.ServiceHost.Unity {
		2	public interface IFactoryMemberInjection {
		3	void Visit(FactoryRegistrationBuilder builder);
		4	}
		5	} No newline at end of file

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

			@@ -0,0 +1,7
		1	using System.Collections.Generic;
		2
		3	namespace Implab.ServiceHost.Unity {
		4	public interface IFactoryRegistration : IRegistration {
		5	IEnumerable<IFactoryMemberInjection> MemberInjections { get; }
		6	}
		7	} No newline at end of file

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

			@@ -0,0 +1,5
		1	namespace Implab.ServiceHost.Unity {
		2	public interface IInjectionParameter {
		3	void Visit(InjectionParameterBuilder builder);
		4	}
		5	} No newline at end of file

Implab.ServiceHost/Unity/IInstanceRegistration.cs created 644 +8 0

			@@ -0,0 +1,8
		1	using System.Collections.Generic;
		2
		3	namespace Implab.ServiceHost.Unity {
		4	public interface IInstanceRegistration : IRegistration {
		5
		6	IEnumerable<IInjectionParameter> MemberInjections { get; }
		7	}
		8	} No newline at end of file

Implab.ServiceHost/Unity/IRegistration.cs created 644 +12 0

			@@ -0,0 +1,12
		1	using System;
		2	using Unity.Lifetime;
		3
		4	namespace Implab.ServiceHost.Unity {
		5	public interface IRegistration {
		6	string Name { get; }
		7
		8	Type GetRegistrationType(ContainerBuilder builder);
		9
		10	LifetimeManager GetLifetime(ContainerBuilder builder);
		11	}
		12	} No newline at end of file

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

			@@ -0,0 +1,6
		1	namespace Implab.ServiceHost.Unity
		2	{
		3	public interface ITypeMemberInjection {
		4	void Visit(TypeRegistrationBuilder builder);
		5	}
		6	} No newline at end of file

Implab.ServiceHost/Unity/ITypeRegistration.cs created 644 +10 0

			@@ -0,0 +1,10
		1	using System;
		2	using System.Collections.Generic;
		3
		4	namespace Implab.ServiceHost.Unity {
		5	public interface ITypeRegistration : IRegistration {
		6	Type GetImplementationType(ContainerBuilder builder);
		7
		8	IEnumerable<ITypeMemberInjection> MemberInjections { get; }
		9	}
		10	} No newline at end of file

Implab.ServiceHost/Unity/NestedTypeReference.cs created 644 +48 0

			@@ -0,0 +1,48
		1	using System;
		2	using System.Text;
		3
		4	namespace Implab.ServiceHost.Unity {
		5	public class NestedTypeReference : TypeReference {
		6
		7	readonly string m_name;
		8
		9	readonly int m_genericParametersCount;
		10
		11	public TypeReference DeclaringType { get; private set; }
		12
		13	public override string Name {
		14	get {
		15	return m_name;
		16	}
		17	}
		18
		19	public override string Namespace {
		20	get {
		21	return DeclaringType.Namespace;
		22	}
		23	}
		24
		25	public override int GenericParametersCount {
		26	get {
		27	return m_genericParametersCount;
		28	}
		29	}
		30
		31	internal NestedTypeReference(TypeReference declaringType, string name, int parametersCount) {
		32	DeclaringType = declaringType;
		33	m_name = name;
		34	m_genericParametersCount = parametersCount;
		35	}
		36
		37	internal override void Visit(TypeResolutionContext visitor) {
		38	visitor.Visit(this);
		39	}
		40
		41	internal override void WriteTypeName(StringBuilder builder) {
		42	builder
		43	.Append(DeclaringType)
		44	.Append('+')
		45	.Append(Name);
		46	}
		47	}
		48	} No newline at end of file

Implab.ServiceHost/Unity/ProvidesElement.cs created 644 +11 0

			@@ -0,0 +1,11
		1	using System.Xml.Serialization;
		2
		3	namespace Implab.ServiceHost.Unity {
		4	public class ProvidesElement {
		5	[XmlAttribute("type")]
		6	public string RegistrationType { get; set; }
		7
		8	[XmlAttribute("name")]
		9	public string RegistrationName { get; set; }
		10	}
		11	} No newline at end of file

Implab.ServiceHost/Unity/RootTypeReference.cs created 644 +36 0

			@@ -0,0 +1,36
		1	using System;
		2
		3	namespace Implab.ServiceHost.Unity
		4	{
		5	public class RootTypeReference : TypeReference {
		6	readonly string m_name;
		7
		8	readonly string m_namespace;
		9
		10	readonly int m_genericParametersCount;
		11
		12	public override string Name {
		13	get { return m_name; }
		14	}
		15
		16	public override string Namespace {
		17	get { return m_namespace; }
		18	}
		19
		20	public override int GenericParametersCount {
		21	get { return m_genericParametersCount; }
		22	}
		23
		24	internal RootTypeReference(string ns, string name, int genericParameters) {
		25	m_name = name;
		26	m_genericParametersCount = genericParameters;
		27	m_namespace = ns;
		28	}
		29
		30	internal override void Visit(TypeResolutionContext visitor) {
		31	visitor.Visit(this);
		32	}
		33
		34
		35	}
		36	} No newline at end of file

Implab.ServiceHost/Unity/SpecializedTypeReference.cs created 644 +52 0

			@@ -0,0 +1,52
		1	using System;
		2	using System.Linq;
		3	using System.Text;
		4
		5	namespace Implab.ServiceHost.Unity {
		6	public class SpecializedTypeReference : TypeReference {
		7	public override string Name {
		8	get {
		9	return GenericType.Name;
		10	}
		11	}
		12
		13	public override string Namespace {
		14	get {
		15	return GenericType.Namespace;
		16	}
		17	}
		18
		19	public override int GenericParametersCount {
		20	get {
		21	return GenericParameters.Length;
		22	}
		23	}
		24
		25	public TypeReference GenericType { get; private set; }
		26
		27	public TypeReference[] GenericParameters { get; private set; }
		28
		29	internal SpecializedTypeReference(TypeReference genericType, TypeReference[] genericParameters) {
		30	GenericType = genericType;
		31	GenericParameters = genericParameters;
		32	}
		33
		34	internal override void Visit(TypeResolutionContext visitor) {
		35	visitor.Visit(this);
		36	}
		37
		38	internal override void WriteTypeName(StringBuilder builder) {
		39	GenericType.WriteTypeName(builder);
		40	}
		41
		42	internal override void WriteTypeParams(StringBuilder builder) {
		43	builder.Append('{');
		44	for (var i = 0; i < GenericParameters.Length; i++) {
		45	if (i > 0)
		46	builder.Append(',');
		47	builder.Append(GenericParameters[i]);
		48	}
		49	builder.Append('}');
		50	}
		51	}
		52	} No newline at end of file

Implab.ServiceHost/Unity/TypeResolutionContext.cs created 644 +75 0

			@@ -0,0 +1,75
		1	using System;
		2	using System.Collections.Generic;
		3	using Implab.Diagnostics;
		4
		5	namespace Implab.ServiceHost.Unity {
		6	using static Trace<TypeResolver>;
		7
		8	/// <summary>
		9	/// Позволяет обойти вложенные типы и собрать цеочку из типов и параметров генериков, которые они предлагают
		10	/// </summary>
		11	internal class TypeResolutionContext {
		12	readonly TypeResolver m_resolver;
		13
		14
		15	readonly List<Type> m_genericParameters = new List<Type>();
		16
		17	public IEnumerable<Type> GenericParameters { get { return m_genericParameters; } }
		18
		19	public Type ResolvedType { get; private set; }
		20
		21
		22	public int ArrayRank { get; private set; }
		23
		24
		25	public bool ThrowOnFail { get; private set; }
		26
		27	public TypeResolutionContext(TypeResolver resolver, bool throwOnFail) {
		28	m_resolver = resolver;
		29	ThrowOnFail = throwOnFail;
		30	}
		31
		32	public Type MakeType() {
		33	return m_genericParameters.Count > 0 ?
		34	ResolvedType?.MakeGenericType(m_genericParameters.ToArray()) :
		35	ResolvedType;
		36	}
		37
		38	public void Visit(SpecializedTypeReference typeReference) {
		39	typeReference.GenericType.Visit(this);
		40
		41	if (ResolvedType != null) {
		42	foreach (var genericParamRef in typeReference.GenericParameters) {
		43	var context = new TypeResolutionContext(m_resolver, ThrowOnFail);
		44	genericParamRef.Visit(context);
		45	m_genericParameters.Add(context.MakeType());
		46	}
		47	}
		48	}
		49
		50	public void Visit(NestedTypeReference typeReference) {
		51	typeReference.DeclaringType.Visit(this);
		52	if (ResolvedType != null)
		53	ResolvedType = ResolvedType?.GetNestedType(typeReference.ClrName) ?? Failed(typeReference);
		54	}
		55
		56	public void Visit(RootTypeReference typeReference) {
		57	ResolvedType = m_resolver.Resolve(typeReference.Namespace, typeReference.ClrName) ?? Failed(typeReference);
		58	}
		59
		60	public void Visit(ArrayTypeReference typeReference) {
		61	var context = new TypeResolutionContext(m_resolver, ThrowOnFail);
		62	typeReference.ItemsType.Visit(context);
		63	ResolvedType = typeReference.Rank == 1 ?
		64	context.MakeType()?.MakeArrayType() :
		65	context.MakeType()?.MakeArrayType(typeReference.Rank);
		66	}
		67
		68	Type Failed(TypeReference reference) {
		69	Log($"Falied to resolve {reference}");
		70	if (ThrowOnFail)
		71	throw new Exception($"Failed to resolve {reference}");
		72	return null;
		73	}
		74	}
		75	} No newline at end of file

Implab/Xml/XmlDefaultSerializer.cs created 644 +14 0

			@@ -0,0 +1,14
		1	using System.Xml.Serialization;
		2	using Implab.Components;
		3
		4	namespace Implab.Xml {
		5	/// <summary>
		6	/// This class used to get default serializer for the specified type <typeparamref name="T"/>.
		7	/// </summary>
		8	/// <typeparam name="T">The type used to create <see cref="XmlSerializer"/></typeparam>
		9	public static class XmlDefaultSerializer<T> {
		10	static readonly LazyAndWeak<XmlSerializer> m_instance = new LazyAndWeak<XmlSerializer>(() => new XmlSerializer(typeof(T)));
		11
		12	public static XmlSerializer Instance { get { return m_instance.Value; } }
		13	}
		14	} No newline at end of file

Implab/Xml/XmlSerializerExtensions.cs created 644 +89 0

			@@ -0,0 +1,89
		1	using System.IO;
		2	using System.Text;
		3	using System.Xml;
		4	using System.Xml.Linq;
		5	using System.Xml.Serialization;
		6
		7	namespace Implab.Xml {
		8	public static class XmlSerializerExtensions {
		9
		10	public static void Serialize(this XmlSerializer that, object obj, XmlElement element) {
		11	Safe.ArgumentNotNull(that, nameof(that));
		12	using (var writer = element.CreateNavigator().AppendChild())
		13	that.Serialize(writer, obj);
		14	}
		15
		16	public static void Serialize(this XmlSerializer that, object obj, XElement element) {
		17	Safe.ArgumentNotNull(that, nameof(that));
		18	using (var writer = element.CreateWriter())
		19	that.Serialize(writer, obj);
		20	}
		21
		22	public static XDocument SerializeAsXDocumnet(this XmlSerializer that, object obj) {
		23	Safe.ArgumentNotNull(that, nameof(that));
		24	var doc = new XDocument();
		25	using (var writer = doc.CreateWriter()) {
		26	that.Serialize(writer, obj);
		27	}
		28	return doc;
		29	}
		30
		31	public static XmlDocument SerializeAsXmlDocument(this XmlSerializer that, object obj) {
		32	Safe.ArgumentNotNull(that, nameof(that));
		33	var doc = new XmlDocument();
		34	using (var writer = doc.CreateNavigator().AppendChild()) {
		35	that.Serialize(writer, obj);
		36	}
		37	return doc;
		38	}
		39	public static string SerializeAsString(this XmlSerializer that, object obj) {
		40	Safe.ArgumentNotNull(that, nameof(that));
		41	using (var writer = new StringWriter()) {
		42	that.Serialize(writer, obj);
		43	return writer.ToString();
		44	}
		45	}
		46
		47	public static void SerializeToFile(this XmlSerializer that, object obj, string file, Encoding encoding) {
		48	Safe.ArgumentNotNull(that, nameof(that));
		49	using (var writer = new StreamWriter(File.Create(file),encoding))
		50	that.Serialize(writer, obj);
		51	}
		52
		53	public static void SerializeToFile(this XmlSerializer that, object obj, string file) {
		54	SerializeToFile(that, obj, file, Encoding.UTF8);
		55	}
		56
		57	public static object Deserialize(this XmlSerializer that, XmlElement element) {
		58	Safe.ArgumentNotNull(that, nameof(that));
		59	Safe.ArgumentNotNull(element, nameof(element));
		60
		61	using (var reader = element.CreateNavigator().ReadSubtree())
		62	return that.Deserialize(reader);
		63	}
		64
		65	public static object Deserialize(this XmlSerializer that, XElement element) {
		66	Safe.ArgumentNotNull(that, nameof(that));
		67	Safe.ArgumentNotNull(element, nameof(element));
		68
		69	using (var reader = element.CreateReader())
		70	return that.Deserialize(reader);
		71	}
		72
		73	public static object DeserializeFromString(this XmlSerializer that, string text) {
		74	Safe.ArgumentNotNull(that, nameof(that));
		75
		76	using(var reader = new StringReader(text))
		77	return that.Deserialize(reader);
		78	}
		79
		80	public static object DeserializeFromFile(this XmlSerializer that, string file) {
		81	Safe.ArgumentNotNull(that, nameof(that));
		82
		83	using(var reader = File.OpenRead(file))
		84	return that.Deserialize(reader);
		85	}
		86
		87
		88	}
		89	} No newline at end of file

Implab.Playground/Program.cs +42 -20

              using System.Collections.Generic;
              using System.Diagnostics;
              using System.Linq;
+             using Implab.Components;
              using Implab.Diagnostics;
              using Implab.ServiceHost.Unity;
              using Implab.Xml;
                  }
+                 public class FooFactory : IFactory<Foo>, IFactory<Foo.Bar> {
+                     public bool UseSsl { get; set; }
+                     public string Connection { get; set; }
+                     public Foo Create() {
+                         return new Foo() {
+                             Name = "AutoFac"
+                         };
+                     }
+                     Foo.Bar IFactory<Foo.Bar>.Create() {
+                         return new Foo.Bar();
+                     }
+                 }
                  public interface IContainer<T> {
                      T Instance { get; set; }
                  }
                  public class Container<T> : IContainer<T> {
+                     public class Bar {
+                     }
+                     public class Bar<T2> {
+                         public class Baz {
+                         }
+                     }
                      public Container() {
                      }
                          source.Switch.Level = SourceLevels.All;
                          source.Listeners.Add(listener);
-                         var stopwatch = new Stopwatch();
-                         stopwatch.Start();
-                         var ctx = new ContainerBuilder();
-                         Console.WriteLine($"Created: {stopwatch.ElapsedMilliseconds}");
-                         stopwatch.Restart();
-                         ctx.LoadConfig("data/sample.xml");
-                         Console.WriteLine($"Loaded: {stopwatch.ElapsedMilliseconds}");
+                         var resolver = new TypeResolver();
+                         resolver.AddNamespace("System");
+                         resolver.AddNamespace("System.Collections.Generic");
+                         resolver.AddNamespace("Implab.Playground");
+                         resolver.AddMapping("string", typeof(string));
+                         resolver.AddMapping("listOf`1", typeof(List<>));
-                         var container = ctx.Container;
+                         var spec = TypeReference.Parse("Container{listOf{string}}+Bar{List{string}}");
-                         stopwatch.Restart();
-                         var instace1 = container.Resolve<IContainer<string>>();
-                         Console.WriteLine($"Resolved1: {stopwatch.ElapsedMilliseconds}");
+                         var t = resolver.Resolve(spec, true);
-                         stopwatch.Restart();
-                         var instace2 = container.Resolve<IContainer<Foo>>();
-                         Console.WriteLine($"Resolved2: {stopwatch.ElapsedMilliseconds}");
-                         DisplayContainerRegistrations(container);
+                         Console.WriteLine("{0}", t);
+                         Console.WriteLine("Spec: {0}", spec);
+                         Console.WriteLine("IsGenericType: {0}", t.IsGenericType);
+                         Console.WriteLine("IsGenericTypeDefinition: {0}", t.IsGenericTypeDefinition);
+                         Console.WriteLine("ContainsGenericParameters: {0}", t.ContainsGenericParameters);
                      }
                      static void DisplayContainerRegistrations(IUnityContainer theContainer) {

Implab.Playground/data/sample.xml +9 -3

              <container xmlns="http://implab.org/schemas/servicehost/unity.v1.xsd">
                  <namespace name="System"/>
                  <namespace name="System.Collections.Generic"/>
+                 <namespace name="Implab.Components"/>
                  <namespace name="Implab.Playground"/>
                  <!-- foo1 -->
                      </method>
                      <method name="AddRange">
                          <array itemsType="T">
-                             <dependency name="foo2"/>
+                             <dependency name="foo2-bar"/>
                          </array>
                      </method>
                  </register>
                  <value name="connection1" type="String"><![CDATA[Connect me <here>!]]></value>
                  <value name="name1" type="String" value="Hello!"/>
-                 <factory name="foo3" type="FooFactory">
-                     <parameter name="FooName"><![CDATA[Wired "" objecty <> name @#$%^&]]></parameter>
+                 <factory name="foo3" type="IFactory{Foo}" mapTo="FooFactory">
+                     <property name="Connection">
+                         <value><![CDATA[Wired "" objecty <> name @#$%^&]]></value>
+                     </property>
+                     <property name="UseSsl">
+                         <value>false</value>
+                     </property>
                  </factory>
              </container>
  No newline at end of file

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

                      [XmlElement("default", typeof(DefaultParameterElement))]
                      public InjectionParameterElement[] Items { get; set; }
-                     public override void Visit(InjectionValueBuilder builder) {
+                     public override void Visit(InjectionParameterBuilder builder) {
                          builder.Visit(this);
                      }
                  }

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

                      public string AssemblyName { get; set; }
                      public override void Visit(ContainerBuilder builder) {
-                         builder.Visit(this);
+                         builder.AddAssembly(AssemblyName);
                      }
                  }
              }
  No newline at end of file

Implab.ServiceHost/Unity/ContainerBuilder.cs +79 -20

              using System;
-             using System.Collections.Generic;
-             using System.Text.RegularExpressions;
-             using Implab.Diagnostics;
+             using System.Reflection;
+             using Unity;
              namespace Implab.ServiceHost.Unity {
-                 using System.Linq;
-                 using System.Reflection;
-                 using System.Text;
-                 using global::Unity;
-                 using global::Unity.Registration;
-                 using Implab.Xml;
-                 using static Trace<ContainerBuilder>;
                  public class ContainerBuilder {
                      readonly TypeResolver m_resolver;
                      }
                      public Type ResolveType(string typeReference) {
-                         return m_resolver.Resolve(typeReference);
+                         return m_resolver.Resolve(typeReference, true);
                      }
                          );
                      }
-                     internal void Visit(NamespaceElement namespaceElement) {
-                         m_resolver.AddNamespace(namespaceElement.Name);
+                     public void Visit(ITypeRegistration registration) {
+                         Safe.ArgumentNotNull(registration, nameof(registration));
+                         var registrationType = registration.GetRegistrationType(this);
+                         var implementationType = registration.GetImplementationType(this) ?? registrationType;
+                         if (registrationType == null)
+                             throw new Exception($"A type must be specified for the registration {registration.Name}");
+                         var builder = new TypeRegistrationBuilder(
+                             m_resolver,
+                             registrationType,
+                             implementationType
+                         );
+                         builder.Lifetime = registration.GetLifetime(this);
+                         if (registration.MemberInjections != null) {
+                             foreach(var member in registration.MemberInjections)
+                                 member.Visit(builder);
+                         }
+                         m_container.RegisterType(
+                             builder.RegistrationType,
+                             builder.ImplementationType,
+                             registration.Name,
+                             builder.Lifetime,
+                             builder.Injections
+                         );
                      }
-                     internal void Visit(AssemblyElement assemblyElement) {
-                         Assembly.Load(assemblyElement.AssemblyName);
+                     public void Visit(IInstanceRegistration registration) {
+                         Safe.ArgumentNotNull(registration, nameof(registration));
+                         var registrationType = registration.GetRegistrationType(this);
+                         var builder = new InstanceRegistrationBuilder (
+                             m_resolver,
+                             registrationType
+                         );
+                         builder.Lifetime = registration.GetLifetime(this);
+                         if (registration.MemberInjections != null) {
+                             foreach(var member in registration.MemberInjections)
+                                 member.Visit(builder.ValueBuilder);
+                         }
+                         if (builder.RegistrationType == null && builder.ValueBuilder.ValueType == null)
+                             throw new Exception($"A type must be specified for the registration {registration.Name}");
+                         m_container.RegisterInstance(
+                             builder.RegistrationType ?? builder.ValueBuilder.ValueType,
+                             registration.Name,
+                             builder.ValueBuilder.Injection,
+                             builder.Lifetime
+                         );
                      }
-                     internal void Visit(IncludeElement includeElement) {
-                         Include(includeElement.Href);
+                     public void Visit(IFactoryRegistration registration) {
+                         Safe.ArgumentNotNull(registration, nameof(registration));
+                         var registrationType = registration.GetRegistrationType(this);
+                         var builder = new FactoryRegistrationBuilder(registrationType);
+                         if (registration.MemberInjections != null) {
+                             foreach(var member in registration.MemberInjections)
+                                 member?.Visit(builder);
+                         }
+                     }
+                     public void AddNamespace(string ns) {
+                         m_resolver.AddNamespace(ns);
+                     }
+                     public void AddAssembly(string assembly) {
                      }
                      public void Include(string file) {
                      public void LoadConfig(string file) {
                          var config = m_schema.LoadFile(file);
                          config.Visit(this);
                      }
                  }
              }
  No newline at end of file

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

                          var schema = new ContainerConfigurationSchema();
                          schema.RegisterContainerElement<RegisterElement>("register");
+                         schema.RegisterContainerElement<FactoryElement>("factory");
                          schema.RegisterContainerElement<SerializedElement>("serialized");
                          schema.RegisterContainerElement<ValueElement>("value");
                          schema.RegisterContainerElement<IncludeElement>("include");

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

                          get { return null; }
                      }
-                     public override void Visit(InjectionValueBuilder builder) {
+                     public override void Visit(InjectionParameterBuilder builder) {
                          var type = builder.ResolveInjectedValueType(TypeName);
                          builder.SetValue(type, Safe.CreateDefaultValue(type));
                      }

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

                      [XmlAttribute("optional")]
                      public bool Optional { get; set; }
-                     public override  void Visit(InjectionValueBuilder builder) {
+                     public override  void Visit(InjectionParameterBuilder builder) {
                          var type = builder.ResolveInjectedValueType(TypeName);
                          builder.SetDependencyReference(type, DependencyName, Optional);
                      }

Implab.ServiceHost/Unity/FactoryRegistrationBuilder.cs +18 0

                      internal FactoryRegistrationBuilder(Type registrationType) : base(registrationType) {
                      }
+                     /// <summary>
+                     /// Задает делегат, который будет использоваться в качестве фабрики
+                     /// для создания экземпляров, параметры делагата будет заполнены
+                     /// соответствующими зависимостями.
+                     /// </summary>
+                     /// <param name="factory">Фабрика для создания экземпляров.</param>
                      public void SetFactoryDelegate(Delegate factory) {
                          Safe.ArgumentNotNull(factory, nameof(factory));
                          Factory = new DelegateInjectionFactory(factory);
                      }
+                     /// <summary>
+                     /// Указывает зависимость типа <typeparamref name="T"/> с именем
+                     /// <paramref name="dependencyName"/>, которая будет передана в качетве
+                     /// параметра делегату <paramref name="factory"/>
+                     /// </summary>
+                     /// <param name="dependencyName">Имя зависимости</param>
+                     /// <param name="factory">Фабрика для создания экземпляра</param>
                      public void SetFactoryDependency<T>(string dependencyName, Func<T, object> factory) {
                          Safe.ArgumentNotNull(factory, nameof(factory));
                          });
                      }
+                     /// <summary>
+                     /// Указывает зависимость, реализующую интерфейс <see cref="IFactory{TObj}"/>,
+                     /// которая будет использоваться в качестве фабрики для создания объектов
+                     /// </summary>
+                     /// <param name="dependencyName"></param>
                      public void SetFactoryDependency<TFac, TObj>(string dependencyName) where TFac : IFactory<TObj> {
                          Factory = new InjectionFactory(c => c.Resolve<TFac>(dependencyName).Create());

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

                      [XmlAttribute("href")]
                      public string Href { get; set; }
-                     public override void Visit(ContainerBuilder context) {
-                         context.Visit(this);
+                     public override void Visit(ContainerBuilder builder) {
+                         builder.Include(Href);
                      }
                  }
              }
  No newline at end of file

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

                      [XmlAttribute("type")]
                      public string TypeName { get; set; }
-                     public abstract void Visit(InjectionValueBuilder builder);
+                     public abstract void Visit(InjectionParameterBuilder builder);
                  }
              }
  No newline at end of file

Implab.ServiceHost/Unity/InjectionValueBuilder.cs +9 -6

              namespace Implab.ServiceHost.Unity {
-                 public class InjectionValueBuilder {
+                 public class InjectionParameterBuilder {
                      readonly TypeResolver m_resolver;
                          }
                      }
-                     internal InjectionValueBuilder(TypeResolver resolver, Type defaultType) {
+                     internal InjectionParameterBuilder(TypeResolver resolver, Type defaultType) {
                          m_resolver = resolver;
                          DefaultType = defaultType;
                      }
                                  throw new Exception("The type must be specified");
                              return DefaultType;
                          }
-                         return m_resolver.Resolve(typeSpec);
+                         return m_resolver.Resolve(typeSpec, true);
                      }
                      public Type ResolveType(string typeSpec) {
-                         return m_resolver.Resolve(typeSpec);
+                         return m_resolver.Resolve(typeSpec, true);
                      }
                      public void SetValue(Type type, object value) {
                          InjectionParameterValue[] injections = (arrayParameter.Items ?? new InjectionParameterElement[0])
                              .Select(x => {
-                                 var builder = new InjectionValueBuilder(m_resolver, itemsType);
+                                 var builder = new InjectionParameterBuilder(m_resolver, itemsType);
                                  x.Visit(builder);
                                  return builder.Injection;
                              })
                              .ToArray();
-                         var array = itemsType.IsGenericParameter ? (object)new GenericResolvedArrayParameter(itemsType.Name, injections) : new ResolvedArrayParameter(itemsType, injections);
+                         var array = itemsType.IsGenericParameter ?
+                             (object)new GenericResolvedArrayParameter(itemsType.Name, injections) :
+                             new ResolvedArrayParameter(itemsType, injections);
                          ValueType = arrayType;
                          Value = array;
                      }

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

              {
                  public class InstanceRegistrationBuilder : RegistrationBuilder {
-                     public InjectionValueBuilder ValueBuilder { get; private set; }
+                     public InjectionParameterBuilder ValueBuilder { get; private set; }
                      internal InstanceRegistrationBuilder(TypeResolver typeResolver, Type registrationType) : base(registrationType) {
-                         ValueBuilder = new InjectionValueBuilder(typeResolver, registrationType);
+                         ValueBuilder = new InjectionParameterBuilder(typeResolver, registrationType);
                      }
                  }
              }
  No newline at end of file

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

                      [XmlAttribute("name")]
                      public string Name { get; set; }
-                     public override void Visit(ContainerBuilder context) {
-                         context.Visit(this);
+                     public override void Visit(ContainerBuilder builder) {
+                         builder.AddNamespace(Name);
                      }
                  }
              }
  No newline at end of file

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

                          throw new Exception("No content found, expected XML document");
                      }
-                     public override void Visit(InjectionValueBuilder builder) {
+                     public override void Visit(InjectionParameterBuilder builder) {
                          var type = builder.ResolveInjectedValueType(TypeName);
                          var serializer = new XmlSerializer(type);

Implab.ServiceHost/Unity/TypeReference.cs +164 -40

		@@ -3,56 +3,180 using System.Linq;
3	3	using System.Text;
4	4
5	5	namespace Implab.ServiceHost.Unity {
6		public class TypeReference {
7		public string TypeName { get; set; }
8
9		public string Namespace { get; set; }
10
11		public TypeReference[] GenericParameters { get; set; }
12
13		public bool IsArray { get; set; }
	6	/// <summary>
	7	/// Ссылка на тип, является абстрактной записью имени CLR типа.
	8	/// </summary>
	9	/// <remarks>
	10	/// Ссылка на тип содержит сокращенную информацию о типе и для ее интерпретации
	11	/// требуется некоторый контекст, который позволит превратить ее в полноценный
	12	/// <see cref="Type"/>. Ссылки на тип позволяют записать:
	13	/// <list>
	14	/// <item><description>общие типы, их специализации</description></item>
	15	/// <item><description>вложенные типы</description></item>
	16	/// <item><description>массивы</description></item>
	17	/// </list>
	18	/// <para>
	19	/// Для получения из ссылки на тип конкретного CLR типа используется <see cref="TypeResolver.Resolve(TypeReference, bool)"/>.
	20	/// </para>
	21	/// <para>
	22	/// Ссылку на тип можно создать либо програмно при помощи методов <see cref="Create(string, string, int)"/>,
	23	/// <see cref="Create(string, int)"/>, <see cref="MakeArrayType(int)"/>, <see cref="MakeGenericType(TypeReference[])"/>,
	24	/// либо разобрав строку со спецификацией при помощи метода <see cref="Parse(string)"/>.
	25	/// </para>
	26	/// <para>
	27	/// Спецификация ссыдки на тип имеет следующий вид <c>Name.Space.MyType+Nested{String}[][]</c>, где:
	28	/// <list type="table">
	29	/// <item>
	30	/// <term><c>.</c></term>
	31	/// <description>Разделяет элементы пространства имен</description>
	32	/// <item>
	33	/// <item>
	34	/// <term><c>+</c></term>
	35	/// <description>Разделяет вложенные типы</description>
	36	/// <item>
	37	/// <item>
	38	/// <term><c>[]</c>, <c>[,,,]</c></term>
	39	/// <description>Указывает на то, что тип является массивом, также указывается его размерность</description>
	40	/// <item>
	41	/// <item>
	42	/// <term><c>{}</c>, <c>{,,}</c>, <c>{Int32,String}</c></term>
	43	/// <description>Указывает на то, что тип является общим, также
	44	/// указывается количество параметров, либо конкретные типы для
	45	/// специализации</description>
	46	/// <item>
	47	/// </list>
	48	/// </para>
	49	/// </remarks>
	50	public abstract class TypeReference {
14	51
15		public bool IsOpenGeneric {
	52	/// <summary>
	53	/// Имя типа без дополнительных элементов, указывающих на то, что он общий или массив.
	54	/// </summary>
	55	/// <remarks>
	56	/// Для массивов это имя его элементов.
	57	/// </remarks>
	58	public abstract string Name { get; }
	59
	60	/// <summary>
	61	/// Пространство имен в котором нахожится тип.
	62	/// </summary>
	63	/// <remarks>
	64	/// Для вложенных типов это пространтство имен типа самого верхнего уровня,
	65	/// для массивов - пространство имен его элементов.
	66	/// </remarks>
	67	public abstract string Namespace { get; }
	68
	69	/// <summary>
	70	/// Количество параметров общего типа.
	71	/// </summary>
	72	/// <remarks>
	73	/// <para>
	74	/// Вложенные типы неявно получают параметры от типов в которых они объявлены,
	75	/// данное свойство это не учитывает, возвращается только количество собственных
	76	/// параметров.
	77	/// </para>
	78	/// <para>
	79	/// Данное свойство используется для получения CRL имени типа.
	80	/// </para>
	81	/// </remarks>
	82	public abstract int GenericParametersCount { get; }
	83
	84	public virtual string ClrName {
16	85	get {
17		return GenericParameters!=~~null~~ && GenericParameters.~~Contains~~(~~null~~);
18		}
19		}
20
21		public bool IsGeneric {
22		get {
23		return GenericParameters != null && GenericParameters.Length > 0;
	86	return GenericParametersCount != 0 ? $"{Name}`{GenericParametersCount}" : Name;
24	87	}
25	88	}
26	89
	90	/// <summary>
	91	/// Создает ссылку на специализацию текущего типа.
	92	/// </summary>
	93	/// <param name="genericParameters">Ссылки на типы, которые будут использоваться для специализации текущего типа.</param>
	94	/// <returns>Специализация данного типа.</returns>
	95	public virtual SpecializedTypeReference MakeGenericType(TypeReference[] genericParameters) {
	96	if (GenericParametersCount == 0)
	97	throw new InvalidOperationException("Can't specialize a non-geneic type");
	98
	99	if (genericParameters == null \|\| GenericParametersCount != genericParameters.Length)
	100	throw new InvalidOperationException("Generic parameters count mismatch");
	101
	102	return new SpecializedTypeReference(this, genericParameters);
	103	}
	104
	105	/// <summary>
	106	/// Создает ссылку на тип массива указанной размерности, элементами которого являются экземпаляры даннго типа.
	107	/// </summary>
	108	/// <param name="rank">Размерность, если размерность <c>1</c> создается вектор (<see cref="Type.MakeArrayType()"/>).</param>
	109	/// <returns>Ссылка на тип массива</returns>
	110	public ArrayTypeReference MakeArrayType(int rank) {
	111	Safe.ArgumentInRange(rank > 0, nameof(rank));
	112
	113	return new ArrayTypeReference(this, rank);
	114	}
	115
	116	/// <summary>
	117	/// Создает ссылку на вложенный тип.
	118	/// </summary>
	119	/// <param name="name">Имя типа</param>
	120	/// <param name="genericParameters">Количество параметров, если это общий тип, иначе 0.</param>
	121	/// <returns>Ссылка на вложенный тип.</returns>
	122	public TypeReference Create(string name, int genericParameters) {
	123	Safe.ArgumentNotEmpty(name, nameof(name));
	124	Safe.ArgumentInRange(genericParameters >= 0, nameof(genericParameters));
	125
	126	return new NestedTypeReference(this, name, genericParameters);
	127	}
	128
	129	/// <summary>
	130	/// Возвращает строковое представление ссылки на тип.
	131	/// </summary>
	132	/// <returns></returns>
27	133	public override string ToString() {
28	134	var builder = new StringBuilder();
29
30		if (!string.IsNullOrEmpty(Namespace)) {
31		builder.Append(Namespace);
32		builder.Append('.');
33		}
34
35		if (!string.IsNullOrEmpty(TypeName)) {
36		builder.Append(TypeName);
37		} else {
38		builder.Append("__unnamed__");
39		}
40
41		if (GenericParameters != null && GenericParameters.Length > 0) {
42		builder.Append('{');
43		for(var i = 0; i < GenericParameters.Length; i++) {
44		if (i > 0)
45		builder.Append(',');
46		builder.Append(GenericParameters[i]);
47		}
48		builder.Append('}');
49		}
50
	135	WriteTypeName(builder);
	136	WriteTypeParams(builder);
51	137	return builder.ToString();
52	138	}
53		public static TypeReference Parse(string text) {
54		var parser = new TypeReferenceParser(text);
	139
	140	internal virtual void WriteTypeName(StringBuilder builder) {
	141	if (!string.IsNullOrEmpty(Namespace))
	142	builder
	143	.Append(Namespace)
	144	.Append('.');
	145	builder.Append(Name);
	146	}
	147
	148	internal virtual void WriteTypeParams(StringBuilder builder) {
	149	if (GenericParametersCount > 0)
	150	builder
	151	.Append('{')
	152	.Append(',', GenericParametersCount-1)
	153	.Append('}');
	154	}
	155
	156	internal abstract void Visit(TypeResolutionContext visitor);
	157
	158	/// <summary>
	159	/// Создает ссылку на тип.
	160	/// </summary>
	161	/// <param name="ns">Пространство имен, либо его фрагмент.</param>
	162	/// <param name="name">Имя типа без указания на количество параметров, либо на то, что это массив.</param>
	163	/// <param name="genericParameters">Количество параметров типа, если это общий тип, иначе 0.</param>
	164	/// <returns>Ссылка на тип.</returns>
	165	public static TypeReference Create(string ns, string name, int genericParameters) {
	166	Safe.ArgumentNotEmpty(name, nameof(name));
	167	Safe.ArgumentInRange(genericParameters >= 0, nameof(genericParameters));
	168	return new RootTypeReference(ns, name, genericParameters);
	169	}
	170
	171	/// <summary>
	172	/// Разирает строковую запись ссылки на тип.
	173	/// </summary>
	174	/// <param name="typeSpec">Строковая запись ссылки на тип, например <c>Dictionary{String,String}</c></param>
	175	/// <returns>Ссылка на тип.</returns>
	176	public static TypeReference Parse(string typeSpec) {
	177	var parser = new TypeReferenceParser(typeSpec);
55	178	return parser.Parse();
56	179	}
	180
57	181	}
58	182	} No newline at end of file

Implab.ServiceHost/Unity/TypeReferenceParser.cs +86 -16

              using System;
              using System.Collections.Generic;
+             using System.Linq;
              using System.Text.RegularExpressions;
              namespace Implab.ServiceHost.Unity {
                          CloseArray,
+                         Plus,
                          Eof
                      }
-                     readonly Regex _tokens = new Regex(@"([\w\+]+)|\s*([\.{},\[\]])\s*");
+                     readonly Regex _tokens = new Regex(@"\G(?:([\w]+)|\s*([\+\.{},\[\]])\s*)", RegexOptions.Compiled);
                      TokenType m_token;
                                      case "]":
                                          m_token = TokenType.CloseArray;
                                          break;
+                                     case "+":
+                                         m_token = TokenType.Plus;
+                                         break;
                                  }
                              }
                              return true;
                          return result;
                      }
-                     string[] ReadTypeName() {
+                     string[] ReadQTypeName() {
                          var parts = new List<string>();
                          string current = null;
                          return parts.ToArray();
                      }
+                     string ReadNQTypeName() {
+                         ReadToken();
+                         if (Token != TokenType.Word)
+                             ThrowUnexpectedToken();
+                         return TokenValue;
+                     }
                      TypeReference ReadTypeReference() {
-                         var parts = ReadTypeName();
+                         var parts = ReadQTypeName();
                          if (parts == null)
                              return null;
-                         var typeReference = new TypeReference {
-                             Namespace = string.Join(".", parts, 0, parts.Length - 1),
-                             TypeName = parts[parts.Length - 1]
-                         };
+                         var genericParameters = ReadGenericParams();
+                         var typeReference = TypeReference.Create(
+                             string.Join(".", parts, 0, parts.Length - 1),
+                             parts[parts.Length - 1],
+                             genericParameters.Length
+                         );
+                         if (genericParameters.Length > 0 && genericParameters.All(x => x != null))
+                             typeReference = typeReference.MakeGenericType(genericParameters);
+                         typeReference = ReadArraySpec(typeReference);
+                         if(Token == TokenType.Plus)
+                             return ReadNestedType(typeReference);
+                         return typeReference;
+                     }
+                     TypeReference ReadNestedType(TypeReference declaringType) {
+                         var name = ReadNQTypeName();
+                         if(string.IsNullOrEmpty(name))
+                             throw new FormatException("Nested type name can't be empty");
+                         ReadToken();
+                         var genericParameters = ReadGenericParams();
+                         var typeReference = declaringType.Create(
+                             name,
+                             genericParameters.Length
+                         );
-                         switch (Token) {
-                             case TokenType.OpenList:
-                                 typeReference.GenericParameters = ReadTypeReferenceList();
-                                 if (Token != TokenType.CloseList)
-                                     ThrowUnexpectedToken();
-                                 ReadToken();
-                                 break;
+                         if (genericParameters.Length > 0 && genericParameters.All(x => x != null))
+                             typeReference = typeReference.MakeGenericType(genericParameters);
+                         typeReference = ReadArraySpec(typeReference);
+                         if(Token == TokenType.Plus)
+                             return ReadNestedType(typeReference);
+                         return typeReference;
+                     }
+                     TypeReference[] ReadGenericParams() {
+                         if (Token == TokenType.OpenList) {
+                             var genericParameters = ReadTypeReferenceList();
+                             if (Token != TokenType.CloseList)
+                                 ThrowUnexpectedToken();
+                             ReadToken();
+                             return genericParameters;
+                         }
+                         return Array.Empty<TypeReference>();
+                     }
+                     TypeReference ReadArraySpec(TypeReference typeReference) {
+                         while (Token == TokenType.OpenArray) {
+                             var rank = CountRank();
+                             if (Token != TokenType.CloseArray)
+                                 ThrowUnexpectedToken();
+                             typeReference = typeReference.MakeArrayType(rank);
+                             ReadToken();
                          }
                          return typeReference;
                      }
-                     int CountDimentions() {
-                         return 0;
+                     int CountRank() {
+                         int rank = 0;
+                         do {
+                             rank++;
+                         } while(ReadToken() && Token == TokenType.Comma);
+                         return rank;
                      }
                      TypeReference[] ReadTypeReferenceList() {

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

                          var parameters = constructorInjection.Parameters?
                              .Select(x => {
-                                 var valueBuilder = new InjectionValueBuilder(m_resolver, null);
+                                 var valueBuilder = new InjectionParameterBuilder(m_resolver, null);
                                  x.Visit(valueBuilder);
                                  return valueBuilder.Injection;
                              })
                      }
                      internal void Visit(MethodInjectionElement methodInjection) {
-                         var valueContext = new InjectionValueBuilder(m_resolver, null);
                          var parameters = methodInjection.Parameters?
                              .Select(x => {
-                                 var valueBuilder = new InjectionValueBuilder(m_resolver, null);
+                                 var valueBuilder = new InjectionParameterBuilder(m_resolver, null);
                                  x.Visit(valueBuilder);
                                  return valueBuilder.Injection;
                              })
                          if (propertyInjection.Value == null)
                              throw new Exception($"A value value must be specified for the property '{propertyInjection.Name}'");
-                         var propertyType = RegistrationType.GetProperty(propertyInjection.Name)?.PropertyType;
-                         var valueContext = new InjectionValueBuilder(m_resolver, propertyType);
+                         var propertyType = ImplementationType.GetProperty(propertyInjection.Name)?.PropertyType;
+                         var valueContext = new InjectionParameterBuilder(m_resolver, propertyType);
                          propertyInjection.Value.Visit(valueContext);
                          var injection = new InjectionProperty(propertyInjection.Name, valueContext.Injection);

Implab.ServiceHost/Unity/TypeResolver.cs +36 -63

              using Implab.Diagnostics;
              namespace Implab.ServiceHost.Unity {
+                 using System.Diagnostics;
                  using static Trace<TypeResolver>;
                  public class TypeResolver {
                      readonly Dictionary<string, Type> m_cache = new Dictionary<string, Type>();
                      Regex _nsRx = new Regex(@"^\w+(\.\w+)*$", RegexOptions.Compiled);
                      readonly LinkedList<string> m_namespases = new LinkedList<string>();
+                     internal Type Resolve(string ns, string typeName) {
+                         var fullName = string.IsNullOrEmpty(ns) ? typeName : $"{ns}.{typeName}";
+                         return ProbeInNamespaces(fullName);
+                     }
+                     public Type Resolve(TypeReference typeReference, bool throwOnFail) {
+                         var context = new TypeResolutionContext(this, throwOnFail);
+                         typeReference.Visit(context);
+                         return context.MakeType();
+                     }
+                     public Type Resolve(string typeSpec, bool throwOnFail) {
+                         var typeReference = TypeReference.Parse(typeSpec);
+                         return Resolve(typeReference, throwOnFail);
+                     }
                      LinkedListNode<string> m_insertAt;
                      readonly TypeResolver m_parent;
                      public TypeResolver() : this(null) {
                      }
                      public TypeResolver(TypeResolver parent) {
                          m_cache[typeName] = type;
                      }
-                     public Type Resolve(TypeReference reference) {
-                         var args = reference.IsGeneric && !reference.IsOpenGeneric ? reference.GenericParameters?.Select(Resolve).ToArray() : null;
-                         var argc = reference.IsGeneric ? reference.GenericParameters.Length : 0;
+                     Type ProbeInNamespaces(string localName) {
                          Type resolved;
-                         if (!m_cache.TryGetValue(reference.ToString(), out resolved)) {
-                             resolved = ResolveInternal(reference, args, argc);
-                             if (resolved == null)
-                                 throw new Exception($"Failed to resolve {reference}");
-                             m_cache[reference.ToString()] = resolved;
+                         if (!m_cache.TryGetValue(localName, out resolved)) {
+                             foreach (var ns in m_namespases) {
+                                 var typeName = string.IsNullOrEmpty(ns) ? localName : $"{ns}.{localName}";
+                                 resolved = Probe(typeName);
+                                 if (resolved != null) {
+                                     Log($"Probe '{localName}' -> '{resolved.FullName}'");
+                                     break;
+                                 }
+                             }
+                             if (resolved == null && m_parent != null)
+                                 resolved = m_parent.ProbeInNamespaces(localName);
+                             if(resolved == null)
+                                 Log($"Probe '{localName}' failed");
+                             m_cache[localName] = resolved;
                          }
                          return resolved;
                      }
-                     public Type Resolve(string typeSpec) {
-                         return Resolve(TypeReference.Parse(typeSpec));
+                     }
-                     Type ResolveInternal(TypeReference reference, Type[] args, int argc) {
-                         var resolved = ProbeInNamespaces(
-                             String.Join(".", new[] { reference.Namespace, reference.TypeName }.Where(x => !string.IsNullOrEmpty(x))),
-                             args,
-                             argc,
-                             reference.IsArray,
-                             reference.ToString()
-                         );
-                         if (resolved == null && m_parent != null)
-                             resolved = m_parent.ResolveInternal(reference, args, argc);
-                         return resolved;
+                     }
-                     public Type ProbeInNamespaces(string localName, Type[] args, int argc, bool isArray, string referenceName) {
-                         foreach (var ns in m_namespases) {
-                             var typeName = FormatName(new[] { ns, localName }, argc);
-                             var resolved = Probe(typeName);
-                             if (resolved != null) {
-                                 if (args != null && args.Length > 0) {
-                                     resolved = resolved.MakeGenericType(args);
+                                 }
-                                 if (isArray)
-                                     resolved = resolved.MakeArrayType();
-                                 Log("Probe succeed {0} in '{1}': {2} -> {3}", referenceName, ns, typeName, resolved.AssemblyQualifiedName);
-                                 return resolved;
-                             } else {
-                                 Log("Probe failed {0} in '{1}': {2}", referenceName, ns, typeName);
+                             }
+                         }
-                         return null;
+                     }
                      Type Probe(string typeName) {
                          var assemblies = AppDomain.CurrentDomain.GetAssemblies();
                          }
                          return null;
                      }
-                     string FormatName(string[] parts, int argc) {
-                         var builder = new StringBuilder();
-                         builder.Append(String.Join(".", parts.Where(x => !string.IsNullOrEmpty(x))));
-                         if (argc > 0) {
-                             builder.Append('`');
-                             builder.Append(argc);
+                         }
-                         return builder.ToString();
+                     }
                  }
              }
  No newline at end of file

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

                          return string.IsNullOrEmpty(Value) ? Text : Value;
                      }
-                     public override void Visit(InjectionValueBuilder builder) {
+                     public override void Visit(InjectionParameterBuilder builder) {
                          var type = builder.ResolveInjectedValueType(TypeName);
                          builder.SetValue(type, TypeDescriptor.GetConverter(type).ConvertFromString(GetTextValue()));
                      }

Implab/Xml/SerializationHelpers.cs +13 -16

              namespace Implab.Xml {
                  public static class SerializationHelpers {
                      public static string SerializeAsString<T>(T obj) {
-                         return SerializersPool<T>.Instance.SerializeAsString(obj);
+                         return XmlDefaultSerializer<T>.Instance.SerializeAsString(obj);
                      }
                      public static void Serialize<T>(XmlWriter writer, T obj) {
-                         SerializersPool<T>.Instance.Serialize(writer, obj);
+                         XmlDefaultSerializer<T>.Instance.Serialize(writer, obj);
                      }
                      public static XmlDocument SerializeAsXmlDocument<T>(T obj) {
                          var doc = new XmlDocument();
                          using (var writer = doc.CreateNavigator().AppendChild()) {
-                             SerializersPool<T>.Instance.Serialize(writer, obj);
+                             XmlDefaultSerializer<T>.Instance.Serialize(writer, obj);
                          }
                          return doc;
                      }
                      public static XDocument SerializeAsXDocument<T>(T obj) {
                          var doc = new XDocument();
                          using (var writer = doc.CreateWriter()) {
-                             SerializersPool<T>.Instance.Serialize(writer, obj);
+                             XmlDefaultSerializer<T>.Instance.Serialize(writer, obj);
                          }
                          return doc;
                      }
                      public static void SerializeToFile<T>(string file, T obj) {
-                         using (var writer = File.CreateText(file))
-                             SerializersPool<T>.Instance.Serialize(writer, obj);
+                         XmlDefaultSerializer<T>.Instance.SerializeToFile(obj, file);
                      }
                      public static void SerializeToElementChild<T>(XmlElement element, T obj) {
-                         using(var writer = element.CreateNavigator().AppendChild())
-                             SerializersPool<T>.Instance.Serialize(writer, obj);
+                         XmlDefaultSerializer<T>.Instance.Serialize(obj, element);
                      }
                      public static T Deserialize<T>(XmlReader reader) {
-                         return SerializersPool<T>.Instance.Deserialize(reader);
+                         return (T)XmlDefaultSerializer<T>.Instance.Deserialize(reader);
                      }
                      public static T DeserializeFromFile<T>(string file) {
-                         using(var reader = XmlReader.Create(File.OpenText(file)))
-                             return Deserialize<T>(reader);
+                         return (T)XmlDefaultSerializer<T>.Instance.DeserializeFromFile(file);
                      }
                      public static T DeserializeFromString<T>(string data) {
-                         return SerializersPool<T>.Instance.DeserializeFromString(data);
+                         return (T)XmlDefaultSerializer<T>.Instance.DeserializeFromString(data);
                      }
                      public static T DeserializeFromXmlNode<T>(XmlNode node) {
                          Safe.ArgumentNotNull(node, nameof(node));
                          using (var reader = node.CreateNavigator().ReadSubtree())
-                             return SerializersPool<T>.Instance.Deserialize(reader);
+                             return (T)XmlDefaultSerializer<T>.Instance.Deserialize(reader);
                      }
                      public static T DeserializeJson<T>(TextReader textReader) {
                              FlattenArrays = true
                          };
-                         using(var reader = JsonXmlReader.CreateJsonXmlReader(textReader, options))
+                         using (var reader = JsonXmlReader.CreateJsonXmlReader(textReader, options))
                              return Deserialize<T>(reader);
                      }
                      public static T DeserializeJsonFromString<T>(string data) {
-                         using(var reader = new StringReader(data)) {
+                         using (var reader = new StringReader(data)) {
                              return DeserializeJson<T>(reader);
                          }
                      }
                      }
                      public static string SerializeJsonAsString<T>(T obj) {
-                         using(var writer = new StringWriter()) {
+                         using (var writer = new StringWriter()) {
                              SerializeJson(writer, obj);
                              return writer.ToString();
                          }

Implab/Xml/SerializersPool.cs +1 0

              using System.Xml.Serialization;
              namespace Implab.Xml {
+                 [Obsolete("this class will be removed, use XmlDefaultSerializer")]
                  public class SerializersPool<T> : ObjectPool<XmlSerializer> {
                      static readonly SerializersPool<T> _instance = new SerializersPool<T>();

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