implab/ImplabNet Commit - r40:fe33f4e02ad5

improved tracing...

cin -

r40:fe33f4e02ad5 default

parent child

Context file:

r40:fe33f4e02ad5

Collapse all files

Implab/Component.cs created 644 +37 0

@@ -0,0 +1,37
	1	using System;
	2	using System.Collections.Generic;
	3	using System.Linq;
	4	using System.Web;
	5
	6	namespace Implab {
	7	/// <summary>
	8	/// Компоненты являются состовными объектами, имеют детерминированный период жизни, автоматически освобождают ресурсы входящие в них.
	9	/// </summary>
	10	/// <remarks>Компонента управляет временем жизни включенных в нее компонент</remarks>
	11	public class Component: Disposable {
	12	LinkedList<IDisposable> m_components = new LinkedList<IDisposable>();
	13
	14	/// <summary>
	15	/// Коллекция компонент, из которых состоит текущая компонента.
	16	/// </summary>
	17	public ICollection<IDisposable> Components {
	18	get {
	19	AssertNotDisposed();
	20	return m_components;
	21	}
	22	}
	23
	24	/// <summary>
	25	/// Освобождает компоненты, входящие в состав текущей компоненты.
	26	/// </summary>
	27	/// <param name="disposing">Признак того, что происходит освобождение ресурсов.</param>
	28	protected override void Dispose(bool disposing) {
	29	if (disposing) {
	30	foreach (var item in m_components)
	31	item.Dispose();
	32	m_components.Clear();
	33	}
	34	base.Dispose(disposing);
	35	}
	36	}
	37	} No newline at end of file

Implab/Diagnostics/EventText.cs created 644 +12 0

@@ -0,0 +1,12
	1	using System;
	2	using System.Collections.Generic;
	3	using System.Linq;
	4	using System.Text;
	5
	6	namespace Implab.Diagnostics {
	7	public struct EventText {
	8	public int indent;
	9
	10	public string content;
	11	}
	12	}

Implab/Diagnostics/IEventTextFormatter.cs created 644 +10 0

@@ -0,0 +1,10
	1	using System;
	2	using System.Collections.Generic;
	3	using System.Linq;
	4	using System.Text;
	5
	6	namespace Implab.Diagnostics {
	7	public interface IEventTextFormatter<in TEvent> {
	8	EventText Format(TraceContext context, TEvent data);
	9	}
	10	}

Implab/Diagnostics/TextFileListener.cs created 644 +44 0

@@ -0,0 +1,44
	1	using System;
	2	using System.Collections.Generic;
	3	using System.IO;
	4	using System.Linq;
	5	using System.Text;
	6
	7	namespace Implab.Diagnostics {
	8	public class TextFileListener: TextListenerBase {
	9	readonly TextWriter m_textWriter;
	10
	11	public TextFileListener(string fileName) {
	12	m_textWriter = File.CreateText(fileName);
	13
	14	m_textWriter.WriteLine("LOG {0}", DateTime.Now);
	15	Register(this);
	16	}
	17
	18	protected override void WriteEntry(TraceContext context, EventText text) {
	19	var msg = new StringBuilder();
	20	for (int i = 0; i < text.indent; i++)
	21	msg.Append(" ");
	22	msg.AppendFormat("[{0}]: {1}", context.ThreadId, text.content);
	23
	24	lock (m_textWriter) {
	25	if (!IsDisposed) {
	26	m_textWriter.WriteLine(msg.ToString());
	27	m_textWriter.Flush();
	28	}
	29	}
	30	}
	31
	32
	33	protected override void Dispose(bool disposing) {
	34	base.Dispose(disposing);
	35	if (disposing) {
	36	lock (m_textWriter) {
	37	Safe.Dispose(m_textWriter);
	38	}
	39	}
	40	}
	41
	42
	43	}
	44	}

Implab/Diagnostics/TextListenerBase.cs created 644 +99 0

@@ -0,0 +1,99
	1	using System;
	2	using System.Collections.Generic;
	3	using System.Linq;
	4	using System.Text;
	5
	6	namespace Implab.Diagnostics {
	7	public abstract class TextListenerBase : ServiceLocator, IEventTextFormatter<object>, IEventTextFormatter<TraceEvent> {
	8
	9	readonly Dictionary<object, Action> m_subscriptions = new Dictionary<object, Action>();
	10
	11	protected TextListenerBase() {
	12	Register(this);
	13	}
	14
	15	public void Subscribe(Type eventType) {
	16	if (eventType == null)
	17	throw new ArgumentNullException("eventType");
	18	GetType().GetMethod("Subscribe", new Type[0]).MakeGenericMethod(eventType).Invoke(this, null);
	19	}
	20
	21	public void Subscribe<TEvent>() {
	22	Subscribe<TEvent>(LogChannel<TEvent>.Default);
	23	}
	24
	25	public void Subscribe<TEvent>(LogChannel<TEvent> channel) {
	26	if (channel == null)
	27	throw new ArgumentNullException("channel");
	28
	29	lock (m_subscriptions) {
	30	AssertNotDisposed();
	31
	32	var formatter = GetService<IEventTextFormatter<TEvent>>();
	33
	34	EventHandler<ValueEventArgs<TEvent>> handler = (sender, args) => {
	35	WriteEntry((TraceContext)sender, formatter.Format((TraceContext)sender, args.Value));
	36	};
	37
	38	if (m_subscriptions.ContainsKey(channel))
	39	return;
	40
	41	channel.Events += handler;
	42
	43	Action unsubscribe = () => {
	44	channel.Events -= handler;
	45	};
	46
	47	m_subscriptions.Add(channel, unsubscribe);
	48	}
	49	}
	50
	51	public void Unsubscribe<TEvent>(LogChannel<TEvent> channel) {
	52	if (channel == null)
	53	throw new ArgumentNullException("channel");
	54
	55	lock (m_subscriptions) {
	56	Action subscription;
	57	if (m_subscriptions.TryGetValue(channel, out subscription)) {
	58	subscription();
	59	m_subscriptions.Remove(channel);
	60	}
	61	}
	62	}
	63
	64	public void UnsubscribeAll() {
	65	lock (m_subscriptions) {
	66	foreach (var subscription in m_subscriptions.Values)
	67	subscription();
	68	m_subscriptions.Clear();
	69	}
	70	}
	71
	72	protected abstract void WriteEntry(TraceContext context, EventText text);
	73
	74	public EventText Format(TraceContext context, object data) {
	75	return new EventText {
	76	indent = context.CurrentOperation.Level,
	77	content = data.ToString()
	78	};
	79	}
	80
	81	public EventText Format(TraceContext context, TraceEvent data) {
	82	var level = context.CurrentOperation.Level;
	83	if (data.EventType == TraceEventType.OperationCompleted \|\| data.EventType == TraceEventType.OperationStarted)
	84	level--;
	85
	86	return new EventText {
	87	indent = level,
	88	content = data.ToString()
	89	};
	90	}
	91
	92	protected override void Dispose(bool disposing) {
	93	if (disposing) {
	94	UnsubscribeAll();
	95	}
	96	base.Dispose(disposing);
	97	}
	98	}
	99	}

Implab/Disposable.cs created 644 +46 0

@@ -0,0 +1,46
	1	using System;
	2	using System.Collections.Generic;
	3	using System.Diagnostics;
	4	using System.Linq;
	5	using System.Web;
	6
	7	namespace Implab {
	8	public class Disposable : IDisposable {
	9
	10	bool m_disposed;
	11
	12	public event EventHandler Disposed;
	13
	14	public bool IsDisposed {
	15	get { return m_disposed; }
	16	}
	17
	18	protected void AssertNotDisposed() {
	19	if (m_disposed)
	20	throw new ObjectDisposedException(this.ToString());
	21	}
	22
	23	protected virtual void Dispose(bool disposing) {
	24	if (disposing && !m_disposed) {
	25	m_disposed = true;
	26
	27	EventHandler temp = Disposed;
	28	if (temp != null)
	29	temp(this,EventArgs.Empty);
	30	}
	31	}
	32	public void Dispose() {
	33	Dispose(true);
	34	GC.SuppressFinalize(this);
	35	}
	36
	37	protected virtual void ReportObjectLeaks() {
	38	Trace.TraceWarning("The object is marked as disposable but isn't disposed properly: {0}", this);
	39	}
	40
	41	~Disposable() {
	42	Dispose(false);
	43	ReportObjectLeaks();
	44	}
	45	}
	46	} No newline at end of file

Implab/IServiceLocator.cs created 644 +12 0

@@ -0,0 +1,12
	1	using System;
	2	using System.Collections.Generic;
	3	using System.Linq;
	4	using System.Text;
	5	using System.Threading.Tasks;
	6
	7	namespace Implab {
	8	public interface IServiceLocator: IServiceProvider {
	9	T GetService<T>();
	10	bool TryGetService<T>(out T service);
	11	}
	12	}

Implab/ServiceLocator.cs created 644 +209 0

@@ -0,0 +1,209
	1	using System;
	2	using System.Collections.Generic;
	3	using System.Linq;
	4	using System.Web;
	5
	6	namespace Implab {
	7	/// <summary>
	8	/// Коллекция сервисов, позволяет регистрировать и получать сервисы.
	9	/// </summary>
	10	public class ServiceLocator: Component, IServiceLocator, IServiceProvider {
	11	// запись об сервисе
	12	struct ServiceEntry {
	13	public object service; // сервис
	14	public bool shared; // признак того, что сервис НЕ нужно освобождать
	15	public Func<object> activator; // активатор сервиса при первом обращении
	16	public List<Type> associated; // ссылки на текущую запись
	17	public Type origin; // ссылка на оригинальную запись о сервисе
	18	}
	19
	20	// словарь существующих сервисов
	21	Dictionary<Type, ServiceEntry> m_services = new Dictionary<Type,ServiceEntry>();
	22
	23	/// <summary>
	24	/// Получает объект предоставляющий сервис <typeparamref name="T"/>.
	25	/// </summary>
	26	/// <typeparam name="T">Тип запрашиваемого сервиса</typeparam>
	27	/// <returns>Объект, реализующий сервис</returns>
	28	/// <exception cref="KeyNotFoundException">Сервис не зарегистрирован</exception>
	29	public T GetService<T>() {
	30	return (T)GetService(typeof(T));
	31	}
	32
	33
	34	/// <summary>
	35	/// Пытается получить указанный сервис, в случае, если компонента не предоставляет требуемый сервис
	36	/// не возникает исключений.
	37	/// </summary>
	38	/// <typeparam name="T">Тип требуемого сервиса.</typeparam>
	39	/// <param name="service">Объект реализующий сервис, или <c>default(T)</c> если такового нет.</param>
	40	/// <returns><c>true</c> - сервис найден, <c>false</c> - сервис не зарегистрирован.</returns>
	41	public bool TryGetService<T>(out T service) {
	42	AssertNotDisposed();
	43
	44	try {
	45	service = GetService<T>();
	46	return true;
	47	} catch(KeyNotFoundException) {
	48	service = default(T);
	49	return false;
	50	}
	51	}
	52
	53	/// <summary>
	54	/// Получает объект предоставляющий сервис <paramref name="serviceType"/>
	55	/// </summary>
	56	/// <param name="serviceType">Тип запрашиваемого сервиса</param>
	57	/// <returns>Объект, реализующий сервис</returns>
	58	/// <exception cref="KeyNotFoundException">Сервис не зарегистрирован</exception>
	59	public object GetService(Type serviceType) {
	60	if (serviceType == null)
	61	throw new ArgumentNullException("serviceType");
	62	AssertNotDisposed();
	63
	64	ServiceEntry se;
	65	if (!m_services.TryGetValue(serviceType, out se)) {
	66	// ищем ближайщий объект, реализующий нужный сервис
	67	Type pt = null;
	68	foreach (var t in m_services.Keys)
	69	if (serviceType.IsAssignableFrom(t) && (pt == null \|\| t.IsAssignableFrom(pt)))
	70	pt = t;
	71	if (pt == null)
	72	throw new ApplicationException(String.Format("{0} doesn't provide {1} service",this,serviceType));
	73
	74	var pe = m_services[pt];
	75
	76	// найденная запись может ссылаться на оригинальную запись с сервисом
	77	if(pe.origin != null) {
	78	pt = pe.origin;
	79	pe = m_services[pt];
	80	}
	81
	82	// добавляем список с обратными ссылками
	83	if (pe.associated == null)
	84	pe.associated = new List<Type>();
	85
	86	pe.associated.Add(serviceType);
	87
	88	// обновляем родительскую запись
	89	m_services[pt] = pe;
	90
	91	// создаем запись со ссылкой
	92	se = new ServiceEntry {
	93	service = pe.service,
	94	origin = pt,
	95	shared = true // предотвращаем множественные попытки освобождения
	96	};
	97
	98	m_services[serviceType] = se;
	99	}
	100
	101	// запись содержит в себе информацию о сервисе
	102	if (se.service != null)
	103	return se.service;
	104
	105	// текущая запись является ссылкой
	106	if (se.origin != null) {
	107	se.service = GetService(se.origin);
	108	m_services[serviceType] = se;
	109	return se.service;
	110	}
	111
	112	// текущая запись не является ссылкой и не имеет информации о сервисе
	113	// она должна сожержать информацию об активации
	114	if (se.activator != null) {
	115	se.service = se.activator();
	116
	117	m_services[serviceType] = se;
	118
	119	return se.service;
	120	}
	121
	122	throw new Exception("Unable to create a service instance");
	123	}
	124
	125	/// <summary>
	126	/// Регистрирует фабрику для активации сервиса по первому требованию.
	127	/// </summary>
	128	/// <typeparam name="T">Тип регистрируемого сервиса.</typeparam>
	129	/// <param name="activator">Фабрика для создания/получения объекта, предоставляющего сервис.</param>
	130	/// <exception cref="InvalidOperationException">Указанный сервис уже зарегистрирован.</exception>
	131	/// <remarks>При освобождении сервис-локатора, сервисы полученные в результате активации также будут освобождены.</remarks>
	132	public void Register<T>(Func<T> activator) {
	133	if (activator == null)
	134	throw new ArgumentNullException("activator");
	135
	136	AssertNotDisposed();
	137
	138	Unregister(typeof(T));
	139
	140	m_services[typeof(T)] = new ServiceEntry {
	141	activator = () => activator() as object
	142	};
	143	}
	144
	145	/// <summary>
	146	/// Регистрирует объект, предоставляющий сервис.
	147	/// </summary>
	148	/// <typeparam name="T">Тип регистрируемого сервиса.</typeparam>
	149	/// <param name="service">Объект, предоставляющий сервис.</param>
	150	/// <exception cref="InvalidOperationException">Указанный сервис уже зарегистрирован.</exception>
	151	/// <remarks>Сервис-локатором не управляет временем жизни объекта для зарегистрированного сервиса.</remarks>
	152	public void Register<T>(T service) {
	153	Register(service, true);
	154	}
	155
	156	/// <summary>
	157	/// Регистрирует объект, предоставляющий сервис.
	158	/// </summary>
	159	/// <typeparam name="T">Тип регистрируемого сервиса.</typeparam>
	160	/// <param name="service">Объект, предоставляющий сервис.</param>
	161	/// <param name="shared">Признак того, что объект является разделяемым и сервис-локатор не должен его освобождать.</param>
	162	/// <exception cref="InvalidOperationException">Указанный сервис уже зарегистрирован.</exception>
	163	public void Register<T>(T service, bool shared) {
	164	if (service == null)
	165	throw new ArgumentNullException("service");
	166
	167	AssertNotDisposed();
	168
	169	Unregister(typeof(T));
	170
	171	m_services[typeof(T)] = new ServiceEntry { service = service, shared = shared };
	172	}
	173
	174	public void Unregister(Type serviceType) {
	175	if (serviceType == null)
	176	throw new ArgumentNullException("serviceType");
	177
	178	AssertNotDisposed();
	179
	180	ServiceEntry se;
	181	if (m_services.TryGetValue(serviceType, out se)) {
	182	// освобождаем ресурсы
	183	if (se.service != null && !se.shared)
	184	((IDisposable)se.service).Dispose();
	185	m_services.Remove(serviceType);
	186
	187	// убираем связанные записи
	188	if (se.associated != null)
	189	foreach (var item in se.associated)
	190	m_services.Remove(item);
	191	}
	192	}
	193
	194	/// <summary>
	195	/// Освобождает зарегистрированные сервисы (которые требуется освобоить).
	196	/// </summary>
	197	/// <param name="disposing">Призанак того, что нужно освободить ресурсы.</param>
	198	protected override void Dispose(bool disposing) {
	199	if (disposing) {
	200
	201	foreach (var entry in m_services.Values)
	202	if (!entry.shared && entry.service is IDisposable)
	203	((IDisposable)entry.service).Dispose();
	204
	205	}
	206	base.Dispose(disposing);
	207	}
	208	}
	209	} No newline at end of file

Implab/Diagnostics/ConsoleTraceListener.cs +5 -18

             using System;
             using System.Collections.Generic;
             using System.Linq;
             using System.Text;
             namespace Implab.Diagnostics {
-                public class ConsoleTraceListener {
+                public class ConsoleTraceListener: TextListenerBase {
                     static readonly object _consoleLock = new object();
-                    public void Subscribe() {
+                    protected override void WriteEntry(TraceContext context, EventText text) {
-                        LogChannel<TraceEvent>.Default.Events += Default_Events;
+                        var msg = new StringBuilder();
-                    public void Unsubscribe() {
-                        LogChannel<TraceEvent>.Default.Events -= Default_Events;
-                    void Default_Events(object sender, ValueEventArgs<TraceEvent> e) {
+                        for (int i = 0; i < text.indent; i++)
-                        LogEvent((TraceContext)sender, e.Value);
-                    void LogEvent(TraceContext context, TraceEvent evt) {
-                        var msg = new StringBuilder();
-                        for (int i = 0; i < context.CurrentOperation.Level; i++)
                             msg.Append("  ");
-                        msg.Append(evt.EventType);
+                        msg.AppendFormat("[{0}]: {1}", context.ThreadId, text.content);
-                        msg.AppendFormat("[{0}]: ",context.ThreadId);
-                        msg.Append(evt.Message);
                         lock (_consoleLock) {
                             Console.ForegroundColor = (ConsoleColor)(context.ThreadId % 15 + 1);
                             Console.WriteLine(msg.ToString());
                         }
                     }
                 }
             }

Implab/Diagnostics/TraceContext.cs +86 -20

             using System;
             using System.Collections.Generic;
             using System.Linq;
             using System.Text;
             using System.Threading;
             using System.Threading.Tasks;
             namespace Implab.Diagnostics {
+                /// <summary>
+                /// Контекст трассировки, привязывается к потоку и содержит в себе информацию о стеке логических операций.
+                /// </summary>
+                /// <remarks>
+                /// Контекст трассировки передается слушателям событий для определения места, где возникло событие.
+                /// </remarks>
                 public class TraceContext {
                     LogicalOperation m_currentOperation;
-                    readonly LogicalOperation m_traceBound;
+                    readonly LogicalOperation m_bound;
                     readonly int m_threadId;
-                    readonly TraceContext m_parent;
-                    readonly static object _consoleLock = new object();
                     [ThreadStatic]
                     static TraceContext _current;
+                    /// <summary>
+                    /// Текущий контекст трассировки для потока, создается астоматически при первом обращении.
+                    /// </summary>
                     public static TraceContext Current {
                         get {
                             if (_current == null)
                                 _current = new TraceContext();
                             return _current;
                         }
                     }
                     TraceContext(TraceContext context) {
                         if (context == null)
                             throw new ArgumentNullException("context");
-                        m_parent = context;
                         m_currentOperation = context.CurrentOperation;
-                        m_traceBound = context.CurrentOperation;
+                        m_bound = context.CurrentOperation;
                         m_threadId = Thread.CurrentThread.ManagedThreadId;
-                        LogEvent(TraceEventType.Transfer, "FORK {0}", context.ThreadId);
                     }
                     TraceContext() {
                         m_currentOperation = new LogicalOperation();
-                        m_traceBound = m_currentOperation;
+                        m_bound = m_currentOperation;
                         m_threadId = Thread.CurrentThread.ManagedThreadId;
                     }
+                    /// <summary>
+                    /// При необходимости копирует состояние контекста трассивровки в текущий поток.
+                    /// </summary>
+                    /// <param name="from">Исходный контекст трассировки, который передается.</param>
+                    /// <remarks>
+                    /// <para>
+                    /// Копирование происходит за счет создания нового контекста трассировки и заполнением его
+                    /// состояния из переданного контекста. При этом копируется стек операций, однако в новом
+                    /// контексте ранее начатые логические операции не могут быть завершены.
+                    /// </para>
+                    /// <para>
+                    /// Если передача состояния состоялась, то вызывается событие трассировки <see cref="TraceEventType.Transfer"/>.
+                    /// </para>
+                    /// </remarks>
                     public static void Transfer(TraceContext from) {
-                        _current = from == null ? new TraceContext() : new TraceContext(from);
+                        if (_current == from)
+                            return;
+                        if (from != null) {
-                    public TraceContext ParentContext {
+                            var context = new TraceContext(from);
-                        get {
+                            context.LogEvent(TraceEventType.Transfer, "[{0}]-->[{1}]",from.ThreadId, context.ThreadId);
-                            return m_parent;
+                            _current = context;
+                        } else {
+                            _current = new TraceContext();
                         }
                     }
+                    /// <summary>
+                    /// Создает постоянную копию текущего контекста, данную копию можно хранить и использовать для передачи через <see cref="Transfer(TraceContext)"/>
+                    /// </summary>
+                    /// <returns>Копия текущего контекста трассировки или <c>null</c> если таковой не был создан.</returns>
+                    public static TraceContext Snapshot() {
+                        return _current == null ? null : new TraceContext(_current);
+                    }
+                    /// <summary>
+                    /// Выполняет переданное действие в указанном контексте трассировки, по окончании восстанавливает предыдущий контекст трассировки потока.
+                    /// </summary>
+                    /// <param name="action"></param>
+                    public void Invoke(Action action) {
+                        if (action == null)
+                            throw new ArgumentNullException("action");
+                        var old = _current;
+                        Transfer(this);
+                        try {
+                            action();
+                        } finally {
+                            _current = old;
+                        }
+                    }
+                    /// <summary>
+                    /// Текущая логическая операция.
+                    /// </summary>
                     public LogicalOperation CurrentOperation {
                         get {
                             return m_currentOperation;
                         }
                     }
-                    public LogicalOperation TraceBound {
+                    /// <summary>
+                    /// Операция ниже которой нельзя опускаться в стеке логических операций, т.е. она не может быть завершена в текущем контексте.
+                    /// </summary>
+                    public LogicalOperation BoundOperation {
                         get {
-                            return m_traceBound;
+                            return m_bound;
                         }
                     }
+                    /// <summary>
+                    /// Поток, в котором создан контекст трассировки.
+                    /// </summary>
                     public int ThreadId {
                         get {
                             return m_threadId;
                         }
                     }
+                    /// <summary>
+                    /// Начинает безымянную логическую операцию.
+                    /// </summary>
                     public void StartLogicalOperation() {
                         StartLogicalOperation(null);
                     }
+                    /// <summary>
+                    /// Начинает логическую операцию с указанным именем. Созданная операция будет добвалена в стек логических операций контекста, затем будет создано соответсвующее событие.
+                    /// </summary>
+                    /// <param name="name">Имя начинаемой операции.</param>
                     public void StartLogicalOperation(string name) {
-                        LogEvent(TraceEventType.OperationStarted, "{0}", name);
                         m_currentOperation = new LogicalOperation(name, m_currentOperation);
+                        LogEvent(TraceEventType.OperationStarted, name);
                     }
+                    /// <summary>
+                    /// Заканчивает логическую операцию начатую в текущем контексте. Операции, начатые в других контекстах не могут быть закончены в текущем контексте.
+                    /// </summary>
+                    /// <remarks>
+                    /// При вызове данного метода создается событие журнала трассировки, либо о завершении операции, либо об ошибки, поскольку данная операция
+                    /// начата в другом контексте.
+                    /// </remarks>
                     public void EndLogicalOperation() {
-                        if (m_traceBound == m_currentOperation) {
+                        if (m_bound == m_currentOperation) {
                             LogEvent(TraceEventType.Error, "Trying to end the operation which isn't belongs to current trace");
                         } else {
                             var op = m_currentOperation;
+                            LogEvent(TraceEventType.OperationCompleted, "{0} {1} ms", op.Name, op.Duration);
                             m_currentOperation = m_currentOperation.Parent;
-                            LogEvent(TraceEventType.OperationCompleted, "{0} {1} ms", op.Name, op.Duration);
                         }
                     }
                     void LogEvent(TraceEventType type, string format, params object[] args) {
                         LogChannel<TraceEvent>.Default.LogEvent(this, TraceEvent.Create(type, format, args));
                     }
                 }
             }

Implab/Diagnostics/TraceEvent.cs +4 0

             using System;
             using System.Collections.Generic;
             using System.Linq;
             using System.Text;
             namespace Implab.Diagnostics {
                 public class TraceEvent {
                     public string Message {
                         get;
                         private set;
                     }
                     public TraceEventType EventType {
                         get;
                         private set;
                     }
                     public TraceEvent(TraceEventType type, string message) {
                         EventType = type;
                         Message = message;
                     }
+                    public override string ToString() {
+                        return String.Format("{0}: {1}", EventType, Message);
+                    }
                     public static TraceEvent Create(TraceEventType type, string format, params object[] args) {
                         return new TraceEvent(type, String.Format(format, args));
                     }
                 }
             }

Implab/Diagnostics/TraceLog.cs +3 -6

             using System;
             using System.Collections.Generic;
             using System.Diagnostics;
             using System.Linq;
             using System.Text;
             using System.Threading.Tasks;
             namespace Implab.Diagnostics {
                 /// <summary>
-                /// Класс для публикации событий выполнения программы, события публикуются через <see cref="LogChannel{TraceEvent}"/>
+                /// Класс для публикации событий выполнения программы, события публикуются через <see cref="LogChannel{TraceEvent}"/>.
+                /// Журнал трассировки отражает логический ход выполнения программы и существует всегда, поскольку тесно связан с
+                /// контекстом трассировки.
                 /// </summary>
                 public static class TraceLog {
                     [Conditional("TRACE")]
-                    public static void Transfer(TraceContext from) {
-                        TraceContext.Transfer(from);
-                    [Conditional("TRACE")]
                     public static void StartLogicalOperation() {
                         TraceContext.Current.StartLogicalOperation();
                     }
                     [Conditional("TRACE")]
                     public static void StartLogicalOperation(string name) {
                         TraceContext.Current.StartLogicalOperation(name);
                     }
                     [Conditional("TRACE")]
                     public static void EndLogicalOperation() {
                         TraceContext.Current.EndLogicalOperation();
                     }
                     [Conditional("TRACE")]
                     public static void TraceInformation(string format, params object[] arguments) {
                         LogChannel<TraceEvent>.Default.LogEvent(TraceEvent.Create(TraceEventType.Information, format, arguments));
                     }
                     [Conditional("TRACE")]
                     public static void TraceWarning(string format, params object[] arguments) {
                         LogChannel<TraceEvent>.Default.LogEvent(TraceEvent.Create(TraceEventType.Warning, format, arguments));
                     }
                     [Conditional("TRACE")]
                     public static void TraceError(string format, params object[] arguments) {
                         LogChannel<TraceEvent>.Default.LogEvent(TraceEvent.Create(TraceEventType.Error, format, arguments));
                     }
                     [Conditional("TRACE")]
                     public static void TraceError(Exception err) {
                         TraceError("{0}", err);
                     }
                 }
             }

Implab/Implab.csproj +8 0

             <?xml version="1.0" encoding="utf-8"?>
             <Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
               <PropertyGroup>
                 <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
                 <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
                 <ProductVersion>10.0.0</ProductVersion>
                 <SchemaVersion>2.0</SchemaVersion>
                 <ProjectGuid>{F550F1F8-8746-4AD0-9614-855F4C4B7F05}</ProjectGuid>
                 <OutputType>Library</OutputType>
                 <RootNamespace>Implab</RootNamespace>
                 <AssemblyName>Implab</AssemblyName>
               </PropertyGroup>
               <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
                 <DebugSymbols>true</DebugSymbols>
                 <DebugType>full</DebugType>
                 <Optimize>false</Optimize>
                 <OutputPath>bin\Debug</OutputPath>
                 <DefineConstants>TRACE;DEBUG;</DefineConstants>
                 <ErrorReport>prompt</ErrorReport>
                 <WarningLevel>4</WarningLevel>
                 <ConsolePause>false</ConsolePause>
               </PropertyGroup>
               <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
                 <DebugType>full</DebugType>
                 <Optimize>true</Optimize>
                 <OutputPath>bin\Release</OutputPath>
                 <ErrorReport>prompt</ErrorReport>
                 <WarningLevel>4</WarningLevel>
                 <ConsolePause>false</ConsolePause>
               </PropertyGroup>
               <ItemGroup>
                 <Reference Include="System" />
               </ItemGroup>
               <ItemGroup>
+                <Compile Include="Component.cs" />
                 <Compile Include="Diagnostics\ConsoleTraceListener.cs" />
+                <Compile Include="Diagnostics\EventText.cs" />
+                <Compile Include="Diagnostics\IEventTextFormatter.cs" />
                 <Compile Include="Diagnostics\LogChannel.cs" />
                 <Compile Include="Diagnostics\LogicalOperation.cs" />
+                <Compile Include="Diagnostics\TextFileListener.cs" />
+                <Compile Include="Diagnostics\TextListenerBase.cs" />
                 <Compile Include="Diagnostics\TraceLog.cs" />
                 <Compile Include="Diagnostics\TraceContext.cs" />
                 <Compile Include="Diagnostics\TraceEvent.cs" />
                 <Compile Include="Diagnostics\TraceEventType.cs" />
+                <Compile Include="Disposable.cs" />
                 <Compile Include="ICancellable.cs" />
                 <Compile Include="IProgressHandler.cs" />
                 <Compile Include="IProgressNotifier.cs" />
                 <Compile Include="IPromise.cs" />
                 <Compile Include="IPromiseBase.cs" />
+                <Compile Include="IServiceLocator.cs" />
                 <Compile Include="ITaskController.cs" />
                 <Compile Include="ManagedPromise.cs" />
                 <Compile Include="Parallels\DispatchPool.cs" />
                 <Compile Include="Parallels\ArrayTraits.cs" />
                 <Compile Include="Parallels\MTQueue.cs" />
                 <Compile Include="Parallels\WorkerPool.cs" />
+                <Compile Include="ServiceLocator.cs" />
                 <Compile Include="TaskController.cs" />
                 <Compile Include="ProgressInitEventArgs.cs" />
                 <Compile Include="Properties\AssemblyInfo.cs" />
                 <Compile Include="Promise.cs" />
                 <Compile Include="Parallels\AsyncPool.cs" />
                 <Compile Include="Safe.cs" />
                 <Compile Include="ValueEventArgs.cs" />
               </ItemGroup>
               <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
               <ItemGroup />
             </Project>

Implab/Parallels/AsyncPool.cs +4 -4

             using Implab.Diagnostics;
             using System;
             using System.Threading;
             namespace Implab.Parallels {
             	/// <summary>
             	/// Класс для распаралеливания задач.
             	/// </summary>
             	/// <remarks>
             	/// Используя данный класс и лямда выражения можно распараллелить
             	/// вычисления, для этого используется концепция обещаний.
             	/// </remarks>
             	public static class AsyncPool {
             		public static Promise<T> Invoke<T>(Func<T> func) {
             			var p = new Promise<T>();
-                        var caller = TraceContext.Current;
+                        var caller = TraceContext.Snapshot();
             			ThreadPool.QueueUserWorkItem(param => {
-                            TraceLog.Transfer(caller);
+                            TraceContext.Transfer(caller);
             				try {
             					p.Resolve(func());
             				} catch(Exception e) {
             					p.Reject(e);
             				}
             			});
             			return p;
             		}
                     public static Promise<T> InvokeNewThread<T>(Func<T> func) {
                         var p = new Promise<T>();
-                        var caller = TraceContext.Current;
+                        var caller = TraceContext.Snapshot();
                         var worker = new Thread(() => {
-                            TraceLog.Transfer(caller);
+                            TraceContext.Transfer(caller);
                             try {
                                 p.Resolve(func());
                             } catch (Exception e) {
                                 p.Reject(e);
                             }
                         });
                         worker.IsBackground = true;
                         worker.Start();
                         return p;
                     }
             	}
             }

Implab/Parallels/WorkerPool.cs +8 -7

             using System;
             using System.Collections.Generic;
             using System.Linq;
             using System.Text;
             using System.Threading;
             using System.Diagnostics;
             using Implab.Diagnostics;
             namespace Implab.Parallels {
                 public class WorkerPool : DispatchPool<Action> {
                     MTQueue<Action> m_queue = new MTQueue<Action>();
                     int m_queueLength = 0;
                     readonly int m_threshold = 1;
                     public WorkerPool(int minThreads, int maxThreads, int threshold)
                         : base(minThreads, maxThreads) {
                         m_threshold = threshold;
                         InitPool();
                     }
                     public WorkerPool(int minThreads, int maxThreads) :
                         base(minThreads, maxThreads) {
                         InitPool();
                     }
                     public WorkerPool(int threads)
                         : base(threads) {
                         InitPool();
                     }
                     public WorkerPool()
                         : base() {
                         InitPool();
                     }
                     public Promise<T> Invoke<T>(Func<T> task) {
                         if (task == null)
                             throw new ArgumentNullException("task");
                         if (IsDisposed)
                             throw new ObjectDisposedException(ToString());
                         var promise = new Promise<T>();
-                        var caller = TraceContext.Current;
+                        var caller = TraceContext.Snapshot();
                         EnqueueTask(delegate() {
-                            TraceLog.Transfer(caller);
+                            caller.Invoke(delegate() {
-                            try {
+                                try {
-                                promise.Resolve(task());
+                                    promise.Resolve(task());
-                            } catch (Exception e) {
+                                } catch (Exception e) {
-                                promise.Reject(e);
+                                    promise.Reject(e);
+                                }
+                            });
                         });
                         return promise;
                     }
                     protected void EnqueueTask(Action unit) {
                         Debug.Assert(unit != null);
                         var len = Interlocked.Increment(ref m_queueLength);
                         m_queue.Enqueue(unit);
                         if (len > m_threshold*ActiveThreads)
                             GrowPool();
                     }
                     protected override bool TryDequeue(out Action unit) {
                         if (m_queue.TryDequeue(out unit)) {
                             Interlocked.Decrement(ref m_queueLength);
                             return true;
                         }
                         return false;
                     }
                     protected override bool Suspend() {
                         // This override solves race condition
                         // WORKER                   CLIENT
                         // ---------------------------------------
                         // TryDeque == false
                         //                          Enqueue(unit), queueLen++
                         //                          GrowPool? == NO
                         // ActiveThreads--
                         // Suspend
                         //    queueLength > 0
                         // continue
                         if (m_queueLength > 0)
                             return true;
                         return base.Suspend();
                     }
                     protected override void InvokeUnit(Action unit) {
                         unit();
                     }
                 }
             }

General Comments 0

Write
Preview

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

No TODOs yet

	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