implab/ImplabNet Commit - r281:e0916ddc9950

code cleanup and refactoring

cin -

r281:e0916ddc9950 v3

parent child

Context file:

r281:e0916ddc9950

Collapse all files

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

@@ -0,0 +1,12
	1	using System;
	2	using System.Xml.Serialization;
	3
	4	namespace Implab.ServiceHost.Unity {
	5	public abstract class AbstractInjectionParameter : IInjectionParameter {
	6
	7	[XmlAttribute("type")]
	8	public string TypeName { get; set; }
	9
	10	public abstract void Visit(InjectionParameterBuilder builder);
	11	}
	12	} No newline at end of file

Implab/Diagnostics/ChannelAdvertisementEventArgs.cs created 644 +17 0

@@ -0,0 +1,17
	1	using System;
	2	using System.Diagnostics;
	3
	4	namespace Implab.Diagnostics
	5	{
	6	public class ChannelAdvertisementEventArgs : EventArgs {
	7	internal ChannelAdvertisementEventArgs(object channelId, TraceSource source) {
	8	ChannelId = channelId;
	9	Source = source;
	10	}
	11
	12	public object ChannelId { get; private set; }
	13
	14	public TraceSource Source { get; private set; }
	15
	16	}
	17	} No newline at end of file

Implab.ServiceHost/Implab.ServiceHost.csproj +11 0

             <Project Sdk="Microsoft.NET.Sdk">
               <PropertyGroup>
                 <TargetFrameworks>netstandard2.0;net46</TargetFrameworks>
                 <FrameworkPathOverride Condition="'$(TargetFramework)'=='net46'">/usr/lib/mono/4.6-api/</FrameworkPathOverride>
+                <Authors>Sergey Smirnov</Authors>
+                <Title>Implab.SrviceHost library</Title>
+                <Description>Provides simple and flexible XML configuration for the Unity IoC</Description>
+                <Copyright>2018 Sergey Smirnov</Copyright>
+                <Version>1.0.0</Version>
+                <PackageLicenseUrl>https://hg.implab.org/pub/ImplabNet/file/tip/Implab/license.txt</PackageLicenseUrl>
+                <PackageProjectUrl>https://implab.org</PackageProjectUrl>
+                <RepositoryUrl>https://hg.implab.org/pub/ImplabNet/</RepositoryUrl>
+                <RepositoryType>mercurial</RepositoryType>
+                <PackageTags>IoC; Unity; Dependency Injection</PackageTags>
+                <TargetFrameworks>netstandard2.0;net46</TargetFrameworks>
               </PropertyGroup>
               <ItemGroup>
                 <PackageReference Include="Unity" Version="5.8.5" />
               </ItemGroup>
               <ItemGroup>
                 <ProjectReference Include="..\Implab\Implab.csproj" />
               </ItemGroup>
             </Project>

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

             using System.Xml.Serialization;
             namespace Implab.ServiceHost.Unity
             {
-                public class ArrayParameterElement : InjectionParameterElement {
+                public class ArrayParameterElement : AbstractInjectionParameter {
                     [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 AbstractInjectionParameter[] Items { get; set; }
                     public override void Visit(InjectionParameterBuilder builder) {
                         builder.Visit(this);
                     }
                 }
             }

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

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

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

             namespace Implab.ServiceHost.Unity
             {
-                public class DefaultParameterElement : InjectionParameterElement {
+                public class DefaultParameterElement : AbstractInjectionParameter {
                     public string Value {
                         get { return null; }
                     }
                     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 {
+                public class DependencyParameterElement : AbstractInjectionParameter {
                     [XmlAttribute("name")]
                     public string DependencyName { get; set; }
                     [XmlAttribute("optional")]
                     public bool Optional { get; set; }
                     public override  void Visit(InjectionParameterBuilder builder) {
                         var type = builder.ResolveInjectedValueType(TypeName);
                         builder.SetDependency(type, DependencyName, Optional);
                     }
                 }
             }

Implab.ServiceHost/Unity/FactoryElement.cs +2 -1

             using System;
             using System.Xml.Serialization;
             using Implab.Components;
             namespace Implab.ServiceHost.Unity {
                 /// <summary>
                 /// Расширяет стандартную регистрацию типа до фабрики, вместе с регистрацией
                 /// самой фабрики создаются регистрации сервисов, которые она предоставляет.
                 /// </summary>
                 public class FactoryElement : RegisterElement, ITypeRegistration {
                     /// <summary>
                     /// Записи о сервисах, которые создаются данной фабрикой.
                     /// </summary>
                     /// <remarks>
                     /// Сервисы, которые указаны в регистарциях они должны соответсвовать тому,
                     /// что фабрика возвращает, но это остается на откуп контейнера
                     /// </remarks>
                     [XmlElement("provides")]
                     public ProvidesElement[] Provides { get; set; }
                     /// <summary>
                     /// Переопределяет стандарное поведение регистрации типа в контейнере,
                     /// дополняя его регистрацией фабричных методов для получения типов.
                     /// </summary>
                     /// <param name="builder">Объект для конфигурирования контейнера.</param>
                     public override void Visit(ContainerBuilder builder) {
                         var factoryType = GetRegistrationType(builder.ResolveType);
                         base.Visit(builder);
                         if (Provides != null && Provides.Length > 0) {
                             // если регистрации явно заданы, используеися информация из них
                             foreach(var item in Provides) {
                                 var activator = new FactoryActivator {
                                     Name = item.RegistrationName,
                                     RegistrationType = builder.ResolveType(item.RegistrationType),
                                     FactoryName = Name,
-                                    FactoryType = factoryType
+                                    FactoryType = factoryType,
+                                    Lifetime = item.Lifetime.GetLifetime(builder)
                                 };
                                 builder.Visit(activator);
                             }
                         } else {
                             // если регистрация явно не задана, в качестве сервиса для регистрации
                             // используется тип создаваемый фабрикой, который будет добавлен в контейнер
                             // с темже именем, что и сама фабрика (разные типы могут иметь одно имя для регистрации)
                             var providedType = (
                                     factoryType.IsGenericType && factoryType.GetGenericTypeDefinition() == typeof(IFactory<>) ?
                                     factoryType :
                                     factoryType.GetInterface(typeof(IFactory<>).FullName)
                                 )?
                                 .GetGenericArguments()[0];
                             // не удалось определеить тип
                             if (providedType == null)
                                 throw new ArgumentException("Failed to determine a type provided by the factory");
                             if (providedType.IsGenericParameter)
                                 throw new ArgumentException("Can't register a generic type paramter as a service");
                             var activator = new FactoryActivator {
                                 Name = Name,
                                 RegistrationType = providedType,
                                 FactoryName = Name,
                                 FactoryType = factoryType
                             };
                             builder.Visit(activator);
                         }
                     }
                 }
             }

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

             using System;
             using System.Collections;
             using System.Collections.Generic;
             using System.ComponentModel;
             using System.Linq;
             using System.Xml.Serialization;
             using Unity.Injection;
             namespace Implab.ServiceHost.Unity {
                 public class InjectionParameterBuilder {
                     readonly TypeResolver m_resolver;
                     public Type DefaultType { get; private set; }
                     public Type ValueType { get; private set; }
                     object m_value;
                     public object Value {
                         get {
                             if (!ValueSpecified)
                                 throw new InvalidOperationException("The regular value must be set (dependency or array are not situable in this context)");
                             return m_value;
                         }
                     }
                     public bool ValueSpecified { get; private set; }
                     InjectionParameterValue m_injection;
                     public InjectionParameterValue Injection {
                         get {
                             if (m_injection == null)
                                 throw new InvalidOperationException("The injection parameter is not specified");
                             return m_injection;
                         }
                     }
                     public bool InjectionSpecified {
                         get { return m_injection != null; }
                     }
                     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, true);
                     }
                     public Type ResolveType(string typeSpec) {
                         return string.IsNullOrEmpty(typeSpec) ? null : m_resolver.Resolve(typeSpec, true);
                     }
                     public void SetValue(Type type, object value) {
                         Safe.ArgumentNotNull(type, nameof(type));
                         ValueType = type;
                         m_value = value;
                         ValueSpecified = true;
                         m_injection = new InjectionParameter(type, value);
                     }
                     public void SetDependency(Type type, string name, bool optional) {
                         Safe.ArgumentNotNull(type, nameof(type));
                         ValueType = type;
                         ValueSpecified = false;
                         m_value = null;
                         m_injection = optional ? (InjectionParameterValue)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 (arrayType == null)
                             arrayType = DefaultType;
                         if (!string.IsNullOrEmpty(arrayParameter.ItemsType)) {
                             itemsType = ResolveType(arrayParameter.ItemsType);
                             arrayType = itemsType.MakeArrayType();
                         } else {
                             itemsType = GetItemsType(arrayType);
                         }
                         if (itemsType == null)
                             throw new Exception("Failed to determine array elements type");
-                        InjectionParameterValue[] injections = (arrayParameter.Items ?? new InjectionParameterElement[0])
+                        InjectionParameterValue[] injections = (arrayParameter.Items ?? new AbstractInjectionParameter[0])
                             .Select(x => {
                                 var builder = new InjectionParameterBuilder(m_resolver, itemsType);
                                 x.Visit(builder);
                                 return builder.Injection;
                             })
                             .ToArray();
                         var array = itemsType.IsGenericParameter ?
                             (InjectionParameterValue)new GenericResolvedArrayParameter(itemsType.Name, injections) :
                             new ResolvedArrayParameter(itemsType, injections);
                         ValueType = arrayType;
                         m_value = null;
                         ValueSpecified = false;
                         m_injection = array;
                     }
                     Type GetItemsType(Type collectionType) {
                         if (collectionType == null)
                             return null;
                         Type itemsType = null;
                         if (collectionType.GetGenericTypeDefinition() == typeof(IEnumerable<>)) {
                             itemsType = collectionType.GetGenericArguments()[0];
                         } else if (collectionType == typeof(IEnumerable)) {
                             itemsType = typeof(object);
                         } else {
                             itemsType = collectionType.GetInterface(typeof(IEnumerable<>).FullName)?.GetGenericArguments()[0];
                         }
                         return itemsType;
                     }
                 }
             }

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

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

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

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

Implab.ServiceHost/Unity/ProvidesElement.cs +6 0

             using System.Xml.Serialization;
             namespace Implab.ServiceHost.Unity {
                 public class ProvidesElement {
                     [XmlAttribute("type")]
                     public string RegistrationType { get; set; }
                     [XmlAttribute("name")]
                     public string RegistrationName { get; set; }
+                    [XmlElement("signleton", typeof(SingletonLifetimeElement))]
+                    [XmlElement("context", typeof(ContextLifetimeElement))]
+                    [XmlElement("container", typeof(ContainerLifetimeElement))]
+                    [XmlElement("hierarchy", typeof(HierarchicalLifetimeElement))]
+                    public LifetimeElement Lifetime {get; set;}
                 }
             }

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 {
+                public class SerializedParameterElement : AbstractInjectionParameter {
                     [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(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/ValueParameterElement.cs +1 -1

             using System.ComponentModel;
             using System.Xml.Serialization;
             namespace Implab.ServiceHost.Unity {
-                public class ValueParameterElement : InjectionParameterElement {
+                public class ValueParameterElement : AbstractInjectionParameter {
                     [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(InjectionParameterBuilder builder) {
                         var type = builder.ResolveInjectedValueType(TypeName);
                         builder.SetValue(type, TypeDescriptor.GetConverter(type).ConvertFromString(GetTextValue()));
                     }
                 }
             }

Implab.ServiceHost/docs/XmlConfiguration.md +27 -14

             # XML Конфигурация IoC контейнера
-            Данная библиоетка создавалась для загрузки и применения конфигурации к IoC контейнеру, она не предназначена для конфигурирования
+            Библиоетка создавалась для загрузки и применения конфигурации к IoC контейнеру, она не предназначена для конфигурирования
             контейнера во время выполнения, большинство контейнеров уже обладают данным функционалом.
             На данный момент поддерживается единственный вид контейнера - [Unity Container](https://unitycontainer.github.io/)
-            Unity уже обладает средствами загрузки конфигурации из XML, данная библиотека позволяет решать следующие задачи
+            Unity уже обладает средствами загрузки конфигурации из XML, данная библиотека реализует аналогичный функционал, кроме того, позволяет решать следующие задачи:
             - Конфигурация является простым Xml документом, который можно получить из любого источика и не ограничивается `.config` файлами приложения
             - Включение существующе конфигурации `<include href='config.xml'/>` в текущую
             - Поддержка сериализованных объектов в качестве регистраций сервисов и параметров
-            - Описание зависимостей может быть расширено собсвтенными элементами с произвольной структурой
+            - Поддержка специфиакции генериков любой вложенности, например `Dictionary{Foo,Bar{Int32}}`
-            - Поддержка специфиакции генериков любой вложенности `Dictionary{Foo,Bar{Int32}}`
+            - Поддержка фабрик в XML конфигурации
+            - Расширение схемы XML конфигурации собственными элементами
             ## Общая архитектура
-            `Implab.ServiceHost.Unity` содержит в себе классы для загрузки и применения XML конфигурации к IoC контейнеру, в частности к Unity.
+            Пространство имен `Implab.ServiceHost.Unity` содержит в себе классы для загрузки и применения XML конфигурации к IoC контейнеру.
+            Применение конфигурации к контейнеру состоит из следующих основных шагов:
-. Настраивается схема `ContainerConfigurationSchema`
+. Настраивается схема `ContainerConfigurationSchema` XML конфигурации контейнера
 . Загружается документ и десереализуется в виде `ContainerElement`
-. Создается `ContainerBuilder` при помощи которого применяются настройки из `ContainerElement`
+. Создается `ContainerBuilder` при помощи которого применяются настройки из `ContainerElement` к контейнеру
-            `ContainerConfigurationSchema` - определяет элементы которые могут быть использованы в конфигурации контейнера, предоставляет настроенный `XmlSerializer`.
+            Схема `ContainerConfigurationSchema` определяет элементы документа, которые могут быть использованы в конфигурации контейнера, позволяет создать `XmlSerializer`, который используется для загрузки конфигурации.
-            `ContainerBuilder` - основной класс, который используется для применения конфигурации к контейнеру, добавляет записи регистрации сервисов.
+            `ContainerBuilder` - основной класс, который используется для применения конфигурации к контейнеру, он добавляет записи регистрации сервисов из конфигурации в контейнер.
-            `ContainerElement` - Корневой элемент конфигурации, который загружается из документа.
+            `ContainerElement` - Конфигурация контейнера, которая загружается из документа, состоит из директив для `ContainerBuilder`, а также из записей регистрации сервисов.
-            Классы заканчивающиеся словом `Builder` используются для применения конфигурации к контейнеру,
+            В библиотеки приняты следующие правила именования классов:
-            классы заканчивающиеся на `Element` содержат информацию о конфигурации и десериализуются из исходного документа.
+            - `***Builder` используются для применения конфигурации к контейнеру,
+            - `***Element` содержат информацию о конфигурации и десериализуются из исходного документа.
             ## Структура конфигурации контейнера
-            Элемент верхнего уровня всегда `ContainerElemnt`, он используется для хранения набора элеметов, которые распознаются и выполняются `ContainerBuilder`.
+            Элемент верхнего уровня всегда `container`, он используется для хранения набора элеметов, которые распознаются и выполняются `ContainerBuilder`.
             Все элементы, входящие в контейнер наследуются от абстрактного класса `ContainerItemElement`,
             который позволяет получить текущий `ContainerBuilder` и выполнить над ним какие-либо действия.
-            Примерами элементов контейнера могут быть
+            Основные элементы конфигурации контенейра
             - `<include href='config.xml'/>` - включение конфигурации из указанного места
             - `<namespace name='My.App'/>` - добавление пространства имен для поиска типов
             - `<register type='MyGenericType{}'/>` - добавление в контейнер регистрации типа ``My.App.MyGenericType`1``
+            - `<factory type='IFactory{Foo}' mapTo ='MyFactory'/>` - фабрика, регистрирует свой тип, а также тип `Foo`
+            - `<serialized />` - сериализованный экземпляр объекта, использует `XmlSerializer` для десериализации
+            - `<value />` - значение объекта в виде строки, используется для простых типов
             Полный набор элементов, доступных для использования в контейнере определяет схема `ContainerConfigurationSchema`,
             разработчик может расширить контейнер совими собственными элементами зарегистрировав их в схеме.
+            ### register
+            О
             Например, мы используем компоненту `MyHttpClient` для загрузки данных
             ```xml
                 <register type="IClient" mapTo="MyHttpClient">
                     <property name="proxy">
                         <value>socks5://proxy1.my.company</value>
                     </property>
                 </register>
             ```
             При частом использовании можно сделать описание конфигурации несколько проще,
             описав новый эелемент конфигурации
             ```csharp
             public class MyHttpClientElement : ContainerItemElement {
                 public string Proxy { get; set; }
                 public override void Visit(ContainerBuilder builder) {
                     // создаем описание элемента
                     var registration = new RegistrationElement {
                         RegistrationType = "IClient",
                         ImplementationType = "My.App.MyHttpClient",
                         Injectors = new [] {
                             new PropertyInjectionElement {
                                 Name = "Proxy",
                                 Value = ValueParameterElement {
                                     Value = Proxy
                                 }
                             }
                         }
                     };
                     // применяем созданное описание к контейнеру
                     builder.Visit(registration)
                 }
             }
             ```
             Регистрируем новый элемент в схеме
             ```csharp
             schema.RegisterContainerElement<MyHttpClientElement>("http");
             ```
             Используем новый элемент в конфигурации
             ```xml
                 <http>
                     <proxy>socks5://proxy1.my.company</propxy>
                 </http>
             ```

Implab/Diagnostics/Trace.cs +19 -2

-            using System;
+            // enable System.Diagnostics trace methods
+            #define TRACE
+            using System;
             using System.Collections.Generic;
             using System.Diagnostics;
             using System.Linq;
             using System.Text;
             using System.Threading;
             using System.Threading.Tasks;
             namespace Implab.Diagnostics {
                 public static class Trace<T> {
-                    public static TraceSource TraceSource { get; } = new TraceSource(typeof(T).Name);
+                    static Lazy<TraceSource> _traceSource = new Lazy<TraceSource>(CreateChannel, LazyThreadSafetyMode.ExecutionAndPublication);
+                    static int _nextId;
+                    static TraceSource CreateChannel() {
+                        var id = Interlocked.Increment(ref _nextId);
+                        return new TraceSource(typeof(T).Name);
+                    }
+                    public static TraceSource TraceSource { get { return _traceSource.Value; } }
+                    public static IDisposable Subscribe() {
+                        throw new NotImplementedException();
+                    }
             #if NETFX_TRACE_BUG
                     readonly static AsyncLocal<object> m_currentOperation = new AsyncLocal<object>();
             #endif
                     /// <summary>
                     /// Starts the logical operation nested to the current operation nested to the current one.
                     /// </summary>
                     public static void StartLogicalOperation() {
                         Trace.CorrelationManager.StartLogicalOperation();
                     }
                     /// <summary>
                     /// Starts the logical operation with the specified name, this name is usefull in logs.
                     /// </summary>
                     /// <param name="name">Name.</param>
             #if NETFX_TRACE_BUG
                     public static void StartLogicalOperation(object name) {
                         m_currentOperation.Value = name;
                         Trace.CorrelationManager.StartLogicalOperation(name);
                     }
             #else
                     public static void StartLogicalOperation(object name) {
                         Trace.CorrelationManager.StartLogicalOperation(name);
                     }
             #endif
                     /// <summary>
                     /// Ends the logical operation and restores the previous one.
                     /// </summary>
                     public static void StopLogicalOperation() {
                         Trace.CorrelationManager.StopLogicalOperation();
                     }
                     /// <summary>
                     /// Writes a debug message.
                     /// </summary>
                     /// <param name="format">Format.</param>
                     /// <param name="arguments">Arguments.</param>
                     [Conditional("DEBUG")]
                     public static void Debug(string format, params object[] arguments) {
                     }
                     /// <summary>
                     /// Writes an informational message.
                     /// </summary>
                     /// <param name="format">Format.</param>
                     /// <param name="arguments">Arguments.</param>
                     [Conditional("TRACE")]
                     public static void Log(string format, params object[] arguments) {
                         TraceSource.TraceEvent(TraceEventType.Information, 0, format, arguments);
                     }
                     /// <summary>
                     /// Writes a warning message.
                     /// </summary>
                     /// <param name="format">Format.</param>
                     /// <param name="arguments">Arguments.</param>
                     public static void Warn(string format, params object[] arguments) {
                         TraceSource.TraceEvent(TraceEventType.Warning, 0, format, arguments);
                     }
                     /// <summary>
                     /// Writes a error message.
                     /// </summary>
                     /// <param name="format">Format.</param>
                     /// <param name="arguments">Arguments.</param>
                     public static void Error(string format, params object[] arguments) {
                         TraceSource.TraceEvent(TraceEventType.Error, 0, format, arguments);
                     }
                     public static void Error(Exception err) {
                         TraceSource.TraceData(TraceEventType.Error, 0, err);
                     }
                     /// <summary>
                     /// This method save the current activity, and transfers to the specified activity,
                     /// emits <see cref="TraceEventType.Start"/> and returns a scope of the new
                     /// activity.
                     /// </summary>
                     /// <param name="activityName">The name of the new activity/</param>
                     /// <param name="activityId">The identifier of the activity to which
                     /// the control will be transferred</param>
                     /// <returns>A scope of the new activity, dispose it to transfer
                     /// the control back to the original activity.</returns>
                     public static ActivityScope TransferActivity(string activityName, Guid activityId) {
                         var prev = Trace.CorrelationManager.ActivityId;
                         TraceSource.TraceTransfer(0, "Transfer", activityId);
                         Trace.CorrelationManager.ActivityId = activityId;
                         TraceSource.TraceEvent(TraceEventType.Start, 0, activityName);
                         return new ActivityScope(TraceSource, prev, 0, activityName);
                     }
                     /// <summary>
                     /// Emits <see cref="TraceEventType.Start"/> and returns a scope of the
                     /// activity.
                     /// </summary>
                     /// <param name="activityName">The name of the activity to start</param>
                     /// <returns>A scope of the new activity, dispose it to emit
                     /// <see cref="TraceEventType.Stop"/> for the current activity.</returns>
                     public static ActivityScope StartActivity(string activityName) {
                         if (Trace.CorrelationManager.ActivityId == Guid.Empty)
                             Trace.CorrelationManager.ActivityId = Guid.NewGuid();
                         var prev = Trace.CorrelationManager.ActivityId;
                         TraceSource.TraceEvent(TraceEventType.Start, 0, activityName);
                         return new ActivityScope(TraceSource, prev, 0, activityName);
                     }
                     /// <summary>
                     /// Creates new <see cref="LogicalOperation(string)"/> and calls
                     /// to <see cref="CorrelationManager.StartLogicalOperation(object)"/>
                     /// passing the created operation as identity. Calls
                     /// <see cref="TraceSource.TraceData(TraceEventType, int, object)"/>
                     /// to notify listeners on operation start.
                     /// </summary>
                     /// <param name="name">The name of the logical operation.</param>
                     /// <returns>Logical operation scope, disposing it will stop
                     /// logical operation and notify trace listeners.</returns>
                     public static LogicalOperationScope LogicalOperation(string name) {
                         var operation = new LogicalOperation(name);
                         TraceSource.TraceData(TraceEventType.Information, TraceEventCodes.StartLogicalOperation, operation);
                         StartLogicalOperation(operation);
                         return new LogicalOperationScope(TraceSource, operation);
                     }
                 }
             }

Implab/Implab.csproj +1 -1

             <Project Sdk="Microsoft.NET.Sdk">
               <PropertyGroup>
                 <Authors>Sergey Smirnov</Authors>
                 <Title>Implab library</Title>
                 <Description>Provides some helper clesses like XML serialization helpers, JSON XML reader,
                 JSON pull-parser, ECMA-style promises, lightweight synchonization routines Signal
                 and SharedLock, Trace helpers on top of System.Diagnostics, ObjectPool etc.
                 </Description>
                 <Copyright>2012-2018 Sergey Smirnov</Copyright>
-                <Version>3.0.10</Version>
+                <Version>3.0.12</Version>
                 <PackageLicenseUrl>https://hg.implab.org/pub/ImplabNet/file/tip/Implab/license.txt</PackageLicenseUrl>
                 <PackageProjectUrl>https://implab.org</PackageProjectUrl>
                 <RepositoryUrl>https://hg.implab.org/pub/ImplabNet/</RepositoryUrl>
                 <RepositoryType>mercurial</RepositoryType>
                 <PackageTags>IMPLAB;Json pull-parser;Json Xml;async;diagnostics;serialization;</PackageTags>
                 <TargetFrameworks>netstandard2.0;net46</TargetFrameworks>
                 <FrameworkPathOverride Condition="'$(TargetFramework)'=='net46' and '$(OSTYPE)'=='linux'">/usr/lib/mono/4.5/</FrameworkPathOverride>
                 <DefineConstants Condition="'$(TargetFramework)'=='net46'">NETFX_TRACE_BUG;$(DefineConstants)</DefineConstants>
               </PropertyGroup>
               <ItemGroup>
                 <EmbeddedResource Include="Xml\json.xsl"/>
               </ItemGroup>
             </Project>

Implab.ServiceHost/Unity/InjectionParameterElement.cs removed 0 -12

NO CONTENT: file was removed

Implab/Messaging/ISession.cs removed 0 -14

NO CONTENT: file was removed

General Comments 3

sergey

|

Auto status change to "Under Review"

sergey

|

ok, latest stable version should be in default

Write
Preview

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

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

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