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;
             using System.Collections.Generic;
             using System.Diagnostics;
             using System.Linq;
+            using Implab.Components;
             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 void AddRange(Foo[] items) {
                         Console.WriteLine($"AddRange: Foo[]");
                     }
                 }
+                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() {
                     }
                     public Container(T instance) {
                         Instance = instance;
                     }
                     public T Instance { get; set; }
                     public void SetInstance(T value) {
                         Instance = value;
                     }
                     public void AddRange(List<T> items) {
                         Console.WriteLine($"AddRange: {typeof(List<T>)}");
                     }
                     public void AddRange(T[] items) {
                         Console.WriteLine($"AddRange: T[] ofType {typeof(T[])}");
                     }
                 }
                 public class Program {
                     static void Main(string[] args) {
                         var listener = new SimpleTraceListener(Console.Out);
                         var source = Trace<TypeResolver>.TraceSource;
                         source.Switch.Level = SourceLevels.All;
                         source.Listeners.Add(listener);
-                        var stopwatch = new Stopwatch();
+                        var resolver = new TypeResolver();
-                        stopwatch.Start();
+                        resolver.AddNamespace("System");
+                        resolver.AddNamespace("System.Collections.Generic");
-                        var ctx = new ContainerBuilder();
+                        resolver.AddNamespace("Implab.Playground");
+                        resolver.AddMapping("string", typeof(string));
-                        Console.WriteLine($"Created: {stopwatch.ElapsedMilliseconds}");
+                        resolver.AddMapping("listOf`1", typeof(List<>));
-                        stopwatch.Restart();
-                        ctx.LoadConfig("data/sample.xml");
-                        Console.WriteLine($"Loaded: {stopwatch.ElapsedMilliseconds}");
-                        var container = ctx.Container;
+                        var spec = TypeReference.Parse("Container{listOf{string}}+Bar{List{string}}");
-                        stopwatch.Restart();
+                        var t = resolver.Resolve(spec, true);
-                        var instace1 = container.Resolve<IContainer<string>>();
-                        Console.WriteLine($"Resolved1: {stopwatch.ElapsedMilliseconds}");
-                        stopwatch.Restart();
+                        Console.WriteLine("{0}", t);
-                        var instace2 = container.Resolve<IContainer<Foo>>();
+                        Console.WriteLine("Spec: {0}", spec);
-                        Console.WriteLine($"Resolved2: {stopwatch.ElapsedMilliseconds}");
+                        Console.WriteLine("IsGenericType: {0}", t.IsGenericType);
+                        Console.WriteLine("IsGenericTypeDefinition: {0}", t.IsGenericTypeDefinition);
-                        DisplayContainerRegistrations(container);
+                        Console.WriteLine("ContainsGenericParameters: {0}", t.ContainsGenericParameters);
                     }
                     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 +9 -3

             <?xml version="1.0" encoding="UTF-8"?>
             <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 -->
                 <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">
                     <method name="AddRange">
                         <array itemsType="Foo">
                             <dependency name="foo2"/>
                         </array>
                     </method>
                 </register>
                 <register type="IContainer{}" mapTo="Container{}">
                     <constructor/>
                     <method name="SetInstance">
                         <dependency type="T"/>
                     </method>
                     <method name="AddRange">
                         <array itemsType="T">
-                            <dependency name="foo2"/>
+                            <dependency name="foo2-bar"/>
                         </array>
                     </method>
                 </register>
                 <register type="List{}">
                     <constructor />
                 </register>
                 <register type="IContainer{String}" mapTo="Container{String}">
                     <constructor/>
                     <method name="SetInstance">
                         <dependency type="String" name="name1"/>
                     </method>
                 </register>
                 <serialized type="Foo+Bar">
                     <Bar xmlns="" id="1">
                         <Name>Baaar</Name>
                     </Bar>
                 </serialized>
                 <value name="connection1" type="String"><![CDATA[Connect me <here>!]]></value>
                 <value name="name1" type="String" value="Hello!"/>
-                <factory name="foo3" type="FooFactory">
+                <factory name="foo3" type="IFactory{Foo}" mapTo="FooFactory">
-                    <parameter name="FooName"><![CDATA[Wired "" objecty <> name @#$%^&]]></parameter>
+                    <property name="Connection">
+                        <value><![CDATA[Wired "" objecty <> name @#$%^&]]></value>
+                    </property>
+                    <property name="UseSsl">
+                        <value>false</value>
+                    </property>
                 </factory>
             </container>

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

             using System.Xml.Serialization;
             namespace Implab.ServiceHost.Unity
             {
                 public class ArrayParameterElement : InjectionParameterElement {
                     [XmlAttribute("itemsType")]
                     public string ItemsType { get; set; }
                     [XmlElement("dependency", typeof(DependencyParameterElement))]
                     [XmlElement("value", typeof(ValueParameterElement))]
                     [XmlElement("serialized", typeof(SerializedParameterElement))]
                     [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

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

Implab.ServiceHost/Unity/ContainerBuilder.cs +78 -19

             using System;
-            using System.Collections.Generic;
+            using System.Reflection;
-            using System.Text.RegularExpressions;
+            using Unity;
-            using Implab.Diagnostics;
             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;
                     readonly UnityContainer m_container;
                     readonly ContainerConfigurationSchema m_schema;
                     public UnityContainer Container {
                         get {
                             return m_container;
                         }
                     }
                     public ContainerBuilder() : this(null, null) {
                     }
                     public ContainerBuilder(UnityContainer container, ContainerConfigurationSchema schema) {
                         m_container = container ?? new UnityContainer();
                         m_resolver = new TypeResolver();
                         m_schema = schema ?? ContainerConfigurationSchema.Default;
                     }
                     public Type ResolveType(string typeReference) {
-                        return m_resolver.Resolve(typeReference);
+                        return m_resolver.Resolve(typeReference, true);
                     }
                     internal void Visit(TypeAbstractRegistration typeRegistration) {
                         var registrationType = typeRegistration.GetRegistrationType(ResolveType);
                         var implementationType = typeRegistration.GetImplementationType(ResolveType) ?? registrationType;
                         var registrationContext = new TypeRegistrationBuilder(
                             m_resolver,
                             registrationType,
                             implementationType
                         );
                         typeRegistration.Visit(registrationContext);
                         m_container.RegisterType(
                             registrationContext.RegistrationType,
                             registrationContext.ImplementationType,
                             typeRegistration.Name,
                             registrationContext.Lifetime,
                             registrationContext.Injections
                         );
                     }
                     internal void Visit(InstanceAbstractRegistration instanceRegistration) {
                         var registrationType = instanceRegistration.GetRegistrationType(ResolveType);
                         var builder = new InstanceRegistrationBuilder(m_resolver, registrationType);
                         instanceRegistration.Visit(builder);
                         m_container.RegisterInstance(
                             builder.ValueBuilder.ValueType,
                             instanceRegistration.Name,
                             builder.ValueBuilder.Value,
                             builder.Lifetime
                         );
                     }
                     internal void Visit(FactoryAbstractRegistratrion factoryRgistration) {
                         var registrationType = factoryRgistration.GetRegistrationType(ResolveType);
                         var builder = new FactoryRegistrationBuilder(registrationType);
                         factoryRgistration.Visit(builder);
                         m_container.RegisterType(
                             builder.RegistrationType,
                             factoryRgistration.Name,
                             builder.Lifetime,
                             builder.Factory
                         );
                     }
-                    internal void Visit(NamespaceElement namespaceElement) {
+                    public void Visit(ITypeRegistration registration) {
-                        m_resolver.AddNamespace(namespaceElement.Name);
+                        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) {
+                    public void Visit(IInstanceRegistration registration) {
-                        Assembly.Load(assemblyElement.AssemblyName);
+                        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);
                         }
-                    internal void Visit(IncludeElement includeElement) {
+                        if (builder.RegistrationType == null && builder.ValueBuilder.ValueType == null)
-                        Include(includeElement.Href);
+                            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
+                        );
+                    }
+                    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) {
                         var includeContext = new ContainerBuilder(m_container, m_schema);
                         includeContext.LoadConfig(file);
                     }
                     public void LoadConfig(string file) {
                         var config = m_schema.LoadFile(file);
                         config.Visit(this);
                     }
                 }
             }

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

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

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

             namespace Implab.ServiceHost.Unity
             {
                 public class DefaultParameterElement : InjectionParameterElement {
                     public string Value {
                         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

             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; }
-                    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

             using System;
             using Implab.Components;
             using Unity;
             using Unity.Injection;
             using Unity.Registration;
             namespace Implab.ServiceHost.Unity
             {
                 public class FactoryRegistrationBuilder : RegistrationBuilder {
                     internal InjectionMember Factory { get; private set; }
                     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));
                         Factory = new InjectionFactory((c,t,name) => {
                             var backend = c.Resolve<T>(dependencyName);
                             return factory(backend);
                         });
                     }
+                    /// <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

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

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

             using System;
             using System.Xml.Serialization;
             namespace Implab.ServiceHost.Unity {
                 public abstract class InjectionParameterElement {
                     [XmlAttribute("type")]
                     public string TypeName { get; set; }
-                    public abstract void Visit(InjectionValueBuilder builder);
+                    public abstract void Visit(InjectionParameterBuilder builder);
                 }
             }

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

             using System;
             using System.Collections.Generic;
             using System.ComponentModel;
             using System.Linq;
             using System.Xml.Serialization;
             using Unity.Injection;
             namespace Implab.ServiceHost.Unity {
-                public class InjectionValueBuilder {
+                public class InjectionParameterBuilder {
                     readonly TypeResolver m_resolver;
                     public Type DefaultType { get; private set; }
                     public Type ValueType { get; private set; }
                     public object Value { get; set; }
                     internal InjectionParameterValue Injection {
                         get {
                             if (Value != null)
                                 return InjectionParameterValue.ToParameter(Value);
                             return new InjectionParameter(ValueType, null);
                         }
                     }
-                    internal InjectionValueBuilder(TypeResolver resolver, Type defaultType) {
+                    internal InjectionParameterBuilder(TypeResolver resolver, Type defaultType) {
                         m_resolver = resolver;
                         DefaultType = defaultType;
                     }
                     public Type ResolveInjectedValueType(string typeSpec) {
                         if (string.IsNullOrEmpty(typeSpec)) {
                             if (DefaultType == null)
                                 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) {
                         ValueType = type;
                         Value = value;
                     }
                     public void SetValue<T>(T value) {
                         SetValue(typeof(T), value);
                     }
                     public void SetDependencyReference(Type type, string name, bool optional) {
                         ValueType = type;
                         Value = optional ? (object)new OptionalParameter(type, name) : new ResolvedParameter(type, name);
                     }
                     internal void Visit(ArrayParameterElement arrayParameter) {
                         Type itemsType = null;
                         var arrayType = string.IsNullOrEmpty(arrayParameter.TypeName) ? null : ResolveType(arrayParameter.TypeName);
                         if (!string.IsNullOrEmpty(arrayParameter.ItemsType)) {
                             itemsType = ResolveType(arrayParameter.ItemsType);
                             if (arrayType == null)
                                 arrayType = itemsType.MakeArrayType();
                         } else {
                             itemsType = arrayType?.GetInterface(typeof(IEnumerable<>).FullName)?.GetGenericArguments()[0];
                         }
                         if (itemsType == null)
                             throw new Exception("Failed to determine array elements type");
                         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

             using System;
             namespace Implab.ServiceHost.Unity
             {
                 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);
                     }
                 }
             }

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

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

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

             using System;
             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; }
                     public XmlReader GetReader() {
                         if (!string.IsNullOrEmpty(Location))
                             return XmlReader.Create(Location);
                         if (Content != null && Content.Length > 0)
                             return Content[0].CreateNavigator().ReadSubtree();
                         throw new Exception("No content found, expected XML document");
                     }
-                    public override void Visit(InjectionValueBuilder builder) {
+                    public override void Visit(InjectionParameterBuilder builder) {
                         var type = builder.ResolveInjectedValueType(TypeName);
                         var serializer = new XmlSerializer(type);
                         using(var reader = GetReader())
                             builder.SetValue(type, serializer.Deserialize(reader));
                     }
                 }
             }

Implab.ServiceHost/Unity/TypeReference.cs +159 -35

@@ -1,58 +1,182
1	using System;	1	using System;
2	using System.Linq;	2	using System.Linq;
3	using System.Text;	3	using System.Text;
4		4
5	namespace Implab.ServiceHost.Unity {	5	namespace Implab.ServiceHost.Unity {
6	public class TypeReference {	6	/// <summary>
7	public string TypeName { get; set; }	7	/// Ссылка на тип, является абстрактной записью имени CLR типа.
8		8	/// </summary>
9	public string Namespace { get; set; }	9	/// <remarks>
10		10	/// Ссылка на тип содержит сокращенную информацию о типе и для ее интерпретации
11	public TypeReference[] GenericParameters { get; set; }	11	/// требуется некоторый контекст, который позволит превратить ее в полноценный
12		12	/// <see cref="Type"/>. Ссылки на тип позволяют записать:
13	public bool IsArray { get; set; }	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	get {	85	get {
17	return GenericParameters!=~~null~~ && GenericParameters.~~Contains~~(~~null~~);	86	return GenericParametersCount != 0 ? $"{Name}`{GenericParametersCount}" : Name;
18	}
19	}
20
21	public bool IsGeneric {
22	get {
23	return GenericParameters != null && GenericParameters.Length > 0;
24	}	87	}
25	}	88	}
26		89
27	public override string ToString() {	90	/// <summary>
28	var builder = new StringBuilder();	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");
29		98
30	if (!string.IsNullOrEmpty(Namespace)) {	99	if (genericParameters == null \|\| GenericParametersCount != genericParameters.Length)
31	builder.Append(Namespace);	100	throw new InvalidOperationException("Generic parameters count mismatch");
32	builder.Append('.');	101
		102	return new SpecializedTypeReference(this, genericParameters);
33	}	103	}
34		104
35	if (!string.IsNullOrEmpty(TypeName)) {	105	/// <summary>
36	builder.Append(TypeName);	106	/// Создает ссылку на тип массива указанной размерности, элементами которого являются экземпаляры даннго типа.
37	} else {	107	/// </summary>
38	builder.Append("__unnamed__");	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);
39	}	127	}
40		128
41	if (GenericParameters != null && GenericParameters.Length > 0) {	129	/// <summary>
42	builder.Append('{');	130	/// Возвращает строковое представление ссылки на тип.
43	for(var i = 0; i < GenericParameters.Length; i++) {	131	/// </summary>
44	if (i > 0)	132	/// <returns></returns>
45	builder.Append(',');	133	public override string ToString() {
46	builder.Append(GenericParameters[i]);	134	var builder = new StringBuilder();
		135	WriteTypeName(builder);
		136	WriteTypeParams(builder);
		137	return builder.ToString();
47	}	138	}
48	builder.Append('}');	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('}');
49	}	154	}
50		155
51	return builder.ToString();	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);
52	}	169	}
53	public static TypeReference Parse(string text) {	170
54	var parser = new TypeReferenceParser(text);	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	return parser.Parse();	178	return parser.Parse();
56	}	179	}
		180
57	}	181	}
58	} No newline at end of file	182	}

Implab.ServiceHost/Unity/TypeReferenceParser.cs +83 -13

             using System;
             using System.Collections.Generic;
+            using System.Linq;
             using System.Text.RegularExpressions;
             namespace Implab.ServiceHost.Unity {
                 internal class TypeReferenceParser {
                     enum TokenType {
                         None,
                         Word,
                         Dot,
                         Comma,
                         OpenList,
                         CloseList,
                         OpenArray,
                         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;
                     string m_tokenValue;
                     int m_pos;
                     int m_tokenPos;
                     readonly string m_text;
                     TokenType Token { get { return m_token; } }
                     string TokenValue { get { return m_tokenValue; } }
                     int TokenPos { get { return m_tokenPos; } }
                     public TypeReferenceParser(string text) {
                         Safe.ArgumentNotEmpty(text, nameof(text));
                         m_text = text;
                     }
                     bool ReadToken() {
                         if (m_pos >= m_text.Length) {
                             m_token = TokenType.Eof;
                             m_tokenValue = null;
                             return false;
                         }
                         var m = _tokens.Match(m_text, m_pos);
                         if (m.Success) {
                             m_tokenPos = m_pos;
                             m_pos += m.Length;
                             if (m.Groups[1].Success) {
                                 m_token = TokenType.Word;
                                 m_tokenValue = m.Groups[1].Value;
                             } else if (m.Groups[2].Success) {
                                 m_tokenValue = null;
                                 switch (m.Groups[2].Value) {
                                     case "{":
                                         m_token = TokenType.OpenList;
                                         break;
                                     case "}":
                                         m_token = TokenType.CloseList;
                                         break;
                                     case ".":
                                         m_token = TokenType.Dot;
                                         break;
                                     case ",":
                                         m_token = TokenType.Comma;
                                         break;
                                     case "[":
                                         m_token = TokenType.OpenArray;
                                         break;
                                     case "]":
                                         m_token = TokenType.CloseArray;
                                         break;
+                                    case "+":
+                                        m_token = TokenType.Plus;
+                                        break;
                                 }
                             }
                             return true;
                         }
                         throw new FormatException($"Failed to parse '{m_text}' at pos {m_pos}");
                     }
                     public TypeReference Parse() {
                         var result = ReadTypeReference();
                         if (Token != TokenType.Eof)
                             ThrowUnexpectedToken();
                         return result;
                     }
-                    string[] ReadTypeName() {
+                    string[] ReadQTypeName() {
                         var parts = new List<string>();
                         string current = null;
                         bool stop = false;
                         while ((!stop) && ReadToken()) {
                             switch (Token) {
                                 case TokenType.Word:
                                     if (current != null)
                                         ThrowUnexpectedToken();
                                     current = TokenValue;
                                     break;
                                 case TokenType.Dot:
                                     if (current == null)
                                         ThrowUnexpectedToken();
                                     parts.Add(current);
                                     current = null;
                                     break;
                                 default:
                                     stop = true;
                                     break;
                             }
                         }
                         if (current != null)
                             parts.Add(current);
                         if (parts.Count == 0)
                             return 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 {
+                        var genericParameters = ReadGenericParams();
-                            Namespace = string.Join(".", parts, 0, parts.Length - 1),
-                            TypeName = parts[parts.Length - 1]
+                        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;
+                    }
-                        switch (Token) {
+                    TypeReference ReadNestedType(TypeReference declaringType) {
-                            case TokenType.OpenList:
+                        var name = ReadNQTypeName();
-                                typeReference.GenericParameters = ReadTypeReferenceList();
+                        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
+                        );
+                        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();
-                                break;
+                            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() {
+                    int CountRank() {
-                        return 0;
+                        int rank = 0;
+                        do {
+                            rank++;
+                        } while(ReadToken() && Token == TokenType.Comma);
+                        return rank;
                     }
                     TypeReference[] ReadTypeReferenceList() {
                         var list = new List<TypeReference>();
                         do {
                             var typeReference = ReadTypeReference();
                             list.Add(typeReference);
                         } while (Token == TokenType.Comma);
                         return list.ToArray();
                     }
                     void ThrowUnexpectedToken() {
                         throw new FormatException($"Unexpected '{Token}' at pos {TokenPos}: -->{m_text.Substring(TokenPos, Math.Min(m_text.Length - TokenPos, 10))}");
                     }
                 }
             }

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

             using System;
             using System.Collections.Generic;
             using System.Linq;
             using Unity.Injection;
             using Unity.Registration;
             namespace Implab.ServiceHost.Unity {
                 public class TypeRegistrationBuilder : RegistrationBuilder {
                     readonly TypeResolver m_resolver;
                     readonly List<InjectionMember> m_injections = new List<InjectionMember>();
                     internal InjectionMember[] Injections { get { return m_injections.ToArray(); } }
                     public Type ImplementationType {
                         get;
                         private set;
                     }
                     internal TypeRegistrationBuilder(TypeResolver resolver, Type registrationType, Type implementationType) : base(registrationType) {
                         ImplementationType = implementationType;
                         // when registering a generic mapping, register all generic parameter names as local types
                         if (ImplementationType.IsGenericTypeDefinition) {
                             m_resolver = new TypeResolver(resolver);
                             foreach (var p in ImplementationType.GetGenericArguments())
                                 m_resolver.AddMapping(p.Name, p);
                         } else {
                             m_resolver = resolver;
                         }
                     }
                     internal void Visit(ConstructorInjectionElement constructorInjection) {
                         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;
                             })
                             .ToArray();
                         var injection = parameters != null ? new InjectionConstructor(parameters) : new InjectionConstructor();
                         m_injections.Add(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;
                             })
                             .ToArray();
                         var injection = parameters != null ? new InjectionMethod(methodInjection.Name, parameters) : new InjectionMethod(methodInjection.Name);
                         m_injections.Add(injection);
                     }
                     internal void Visit(PropertyInjectionElement propertyInjection) {
                         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 propertyType = ImplementationType.GetProperty(propertyInjection.Name)?.PropertyType;
-                        var valueContext = new InjectionValueBuilder(m_resolver, propertyType);
+                        var valueContext = new InjectionParameterBuilder(m_resolver, propertyType);
                         propertyInjection.Value.Visit(valueContext);
                         var injection = new InjectionProperty(propertyInjection.Name, valueContext.Injection);
                         m_injections.Add(injection);
                     }
                 }
             }

Implab.ServiceHost/Unity/TypeResolver.cs +35 -62

             using System;
             using System.Collections.Generic;
             using System.Linq;
             using System.Text;
             using System.Text.RegularExpressions;
             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_parent = parent;
                         m_insertAt = new LinkedListNode<string>(string.Empty);
                         m_namespases.AddFirst(m_insertAt);
                     }
                     public void AddNamespace(string ns) {
                         Safe.ArgumentMatch(ns, nameof(ns), _nsRx);
                         if (m_insertAt != null)
                             m_namespases.AddAfter(m_insertAt, ns);
                         else
                             m_namespases.AddFirst(ns);
                     }
                     public void AddMapping(string typeName, Type type) {
                         Safe.ArgumentNotEmpty(typeName, nameof(typeName));
                         Safe.ArgumentNotNull(type, nameof(type));
                         m_cache[typeName] = type;
                     }
-                    public Type Resolve(TypeReference reference) {
+                    Type ProbeInNamespaces(string localName) {
-                        var args = reference.IsGeneric && !reference.IsOpenGeneric ? reference.GenericParameters?.Select(Resolve).ToArray() : null;
-                        var argc = reference.IsGeneric ? reference.GenericParameters.Length : 0;
                         Type resolved;
-                        if (!m_cache.TryGetValue(reference.ToString(), out resolved)) {
+                        if (!m_cache.TryGetValue(localName, out resolved)) {
-                            resolved = ResolveInternal(reference, args, argc);
+                            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)
-                                throw new Exception($"Failed to resolve {reference}");
+                                Log($"Probe '{localName}' failed");
-                            m_cache[reference.ToString()] = resolved;
+                            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();
                         foreach (var assembly in assemblies) {
                             var type = assembly.GetType(typeName);
                             if (type != null)
                                 return type;
                         }
                         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();
                 }
             }

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

             using System.ComponentModel;
             using System.Xml.Serialization;
             namespace Implab.ServiceHost.Unity {
                 public class ValueParameterElement : InjectionParameterElement {
                     [XmlAttribute("value")]
                     public string Value { get; set; }
                     [XmlText]
                     public string Text { get; set; }
                     string GetTextValue() {
                         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 +10 -13

             using System;
             using System.Collections.Generic;
             using System.IO;
             using System.Linq;
             using System.Reflection;
             using System.Text;
             using System.Threading.Tasks;
             using System.Xml;
             using System.Xml.Linq;
             using System.Xml.Serialization;
             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))
+                        XmlDefaultSerializer<T>.Instance.SerializeToFile(obj, file);
-                            SerializersPool<T>.Instance.Serialize(writer, obj);
                     }
                     public static void SerializeToElementChild<T>(XmlElement element, T obj) {
-                        using(var writer = element.CreateNavigator().AppendChild())
+                        XmlDefaultSerializer<T>.Instance.Serialize(obj, element);
-                            SerializersPool<T>.Instance.Serialize(writer, obj);
                     }
                     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 (T)XmlDefaultSerializer<T>.Instance.DeserializeFromFile(file);
-                            return Deserialize<T>(reader);
                     }
                     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) {
                         var options = new JsonXmlReaderOptions {
                             NamespaceUri = typeof(T).GetCustomAttribute<XmlRootAttribute>()?.Namespace,
                             RootName = typeof(T).Name,
                             FlattenArrays = true
                         };
                         using (var reader = JsonXmlReader.CreateJsonXmlReader(textReader, options))
                             return Deserialize<T>(reader);
                     }
                     public static T DeserializeJsonFromString<T>(string data) {
                         using (var reader = new StringReader(data)) {
                             return DeserializeJson<T>(reader);
                         }
                     }
                     public static void SerializeJson<T>(TextWriter writer, T obj) {
                         var doc = SerializeAsXmlDocument(obj);
                         XmlToJson.Default.Transform(doc, null, writer);
                     }
                     public static string SerializeJsonAsString<T>(T obj) {
                         using (var writer = new StringWriter()) {
                             SerializeJson(writer, obj);
                             return writer.ToString();
                         }
                     }
                 }
             }

Implab/Xml/SerializersPool.cs +1 0

             using Implab.Components;
             using System;
             using System.Collections.Generic;
             using System.IO;
             using System.Linq;
             using System.Text;
             using System.Threading.Tasks;
             using System.Xml;
             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>();
                     public static SerializersPool<T> Instance {
                         get { return _instance; }
                     }
                     #region implemented abstract members of ObjectPool
                     protected override XmlSerializer CreateInstance() {
                         return new XmlSerializer(typeof(T));
                     }
                     #endregion
                     public T DeserializeFromString(string data) {
                         using (var reader = new StringReader(data)) {
                             return Deserialize(reader);
                         }
                     }
                     public T Deserialize(TextReader reader) {
                         var sr = Allocate();
                         try {
                             return (T)sr.Deserialize(reader);
                         } finally {
                             Release(sr);
                         }
                     }
                     public T Deserialize(XmlReader reader) {
                         var sr = Allocate();
                         try {
                             return (T)sr.Deserialize(reader);
                         } finally {
                             Release(sr);
                         }
                     }
                     public string SerializeAsString(T data) {
                         using (var writer = new StringWriter()) {
                             Serialize(writer, data);
                             return writer.ToString();
                         }
                     }
                     public void Serialize(TextWriter writer, T data) {
                         var sr = Allocate();
                         try {
                             sr.Serialize(writer, data);
                         } finally {
                             Release(sr);
                         }
                     }
                     public void Serialize(XmlWriter writer, T data) {
                         var sr = Allocate();
                         try {
                             sr.Serialize(writer, data);
                         } finally {
                             Release(sr);
                         }
                     }
                 }
             }

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