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() {
-                         LogChannel<TraceEvent>.Default.Events += Default_Events;
+                     }
-                     public void Unsubscribe() {
-                         LogChannel<TraceEvent>.Default.Events -= Default_Events;
+                     }
+                     protected override void WriteEntry(TraceContext context, EventText text) {
+                         var msg = new StringBuilder();
-                     void Default_Events(object sender, ValueEventArgs<TraceEvent> e) {
-                         LogEvent((TraceContext)sender, e.Value);
+                     }
-                     void LogEvent(TraceContext context, TraceEvent evt) {
-                         var msg = new StringBuilder();
-                         for (int i = 0; i < context.CurrentOperation.Level; i++)
+                         for (int i = 0; i < text.indent; i++)
                              msg.Append("  ");
-                         msg.Append(evt.EventType);
-                         msg.AppendFormat("[{0}]: ",context.ThreadId);
-                         msg.Append(evt.Message);
+                         msg.AppendFormat("[{0}]: {1}", context.ThreadId, text.content);
                          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);
+                     }
-                     public TraceContext ParentContext {
-                         get {
-                             return m_parent;
+                         if (_current == from)
+                             return;
+                         if (from != null) {
+                             var context = new TraceContext(from);
+                             context.LogEvent(TraceEventType.Transfer, "[{0}]-->[{1}]",from.ThreadId, context.ThreadId);
+                             _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>
  No newline at end of file

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);
-                             try {
-                                 promise.Resolve(task());
-                             } catch (Exception e) {
-                                 promise.Reject(e);
+                             }
+                             caller.Invoke(delegate() {
+                                 try {
+                                     promise.Resolve(task());
+                                 } catch (Exception 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