implab/ImplabNet Commit - r94:a43745f81f10

minor fixes

cin -

r94:a43745f81f10 v2

parent child

Context file:

r94:a43745f81f10

Collapse all files

Implab/Diagnostics/Extensions.cs +11 0

             namespace Implab.Diagnostics {
                 public static class Extensions {
                     public static IPromise<T> EndLogicalOperation<T>(this IPromise<T> promise) {
                         Safe.ArgumentNotNull(promise, "promise");
                         var op = TraceContext.Instance.DetachLogicalOperation();
                         return promise.Anyway(() => {
                             TraceContext.Instance.EnterLogicalOperation(op,true);
                             TraceLog.EndLogicalOperation();
                             TraceContext.Instance.Leave();
                         });
                     }
+                    public static IPromise EndLogicalOperation(this IPromise promise) {
+                        Safe.ArgumentNotNull(promise, "promise");
+                        var op = TraceContext.Instance.DetachLogicalOperation();
+                        return promise.Anyway(() => {
+                            TraceContext.Instance.EnterLogicalOperation(op,true);
+                            TraceLog.EndLogicalOperation();
+                            TraceContext.Instance.Leave();
+                        });
+                    }
                 }
             }

Implab/Diagnostics/TraceContext.cs +7 -4

             using System;
             using System.Collections.Generic;
             using System.Threading;
             namespace Implab.Diagnostics {
                 /// <summary>
                 /// Trace context is bound to the specific thread, each thread has it's own ThreadContext.
                 /// </summary>
                 /// <remarks>
                 /// ThreadContext manages relations between logical operations and threads.
                 /// </remarks>
                 public class TraceContext {
                     [ThreadStatic]
                     static TraceContext _instance;
                     OperationContext m_current = OperationContext.EMPTY;
                     readonly Stack<OperationContext> m_stack = new Stack<OperationContext>();
                     readonly int m_threadId;
                     public static TraceContext Instance {
                         get {
                             if (_instance == null)
                                 _instance = new TraceContext();
                             return _instance;
                         }
                     }
                     public TraceContext() {
                         m_threadId = Thread.CurrentThread.ManagedThreadId;
                     }
                     public int ThreadId {
                         get { return m_threadId; }
                     }
                     public LogicalOperation CurrentOperation {
                         get {
                             return m_current.CurrentOperation;
                         }
                     }
                     public void EnterLogicalOperation(LogicalOperation operation, bool takeOwnership) {
-                        LogChannel<TraceEvent>.Default.LogEvent(new TraceEvent(TraceEventType.Attach, String.Format("{0} -> [{1}]", operation.Name, m_threadId)));
+                        var prev = CurrentOperation;
                         m_stack.Push(m_current);
                         m_current = new OperationContext(operation, takeOwnership);
+                        LogChannel<TraceEvent>.Default.LogEvent(new TraceEvent(takeOwnership ? TraceEventType.Attach : TraceEventType.Enter, String.Format("{0} -> {1}",prev.Name, operation.Name)));
                     }
                     public void StartLogicalOperation(string name) {
                         m_current.BeginLogicalOperation(name);
                         LogChannel<TraceEvent>.Default.LogEvent(new TraceEvent(TraceEventType.OperationStarted, String.Format("+{0}",CurrentOperation.Name)));
                     }
                     public void StartLogicalOperation() {
                         StartLogicalOperation(String.Empty);
                     }
                     public void EndLogicalOperation() {
                         LogChannel<TraceEvent>.Default.LogEvent(new TraceEvent(TraceEventType.OperationCompleted, String.Format("-{0} : {1}ms",CurrentOperation.Name, CurrentOperation.Duration)));
                         m_current.EndLogicalOperation();
                     }
                     public LogicalOperation DetachLogicalOperation() {
-                        var op = m_current.DetachLogicalOperation();
+                        var prev = m_current.DetachLogicalOperation();
-                        LogChannel<TraceEvent>.Default.LogEvent(new TraceEvent(TraceEventType.Detach, String.Format("[{0}] -> {1}", m_threadId, op.Name)));
+                        LogChannel<TraceEvent>.Default.LogEvent(new TraceEvent(TraceEventType.Detach, String.Format("{0} -> {1}",prev.Name, CurrentOperation.Name)));
-                        return op;
+                        return prev;
                     }
                     public void Leave() {
                         if (m_stack.Count > 0) {
                             m_current.Leave();
+                            var prev = CurrentOperation;
                             m_current = m_stack.Pop();
+                            LogChannel<TraceEvent>.Default.LogEvent(new TraceEvent(TraceEventType.Leave, String.Format("{0} -> {1}", prev.Name, CurrentOperation.Name)));
                         } else {
                             TraceLog.TraceWarning("Attemtp to leave the last operation context");
                             m_current = OperationContext.EMPTY;
                         }
                     }
                 }
             }

Implab/Diagnostics/TraceEventType.cs +2 0

             using System;
             using System.Collections.Generic;
             using System.Linq;
             using System.Text;
             using System.Threading.Tasks;
             namespace Implab.Diagnostics {
                 public enum TraceEventType {
                     Information = 1,
                     Warning,
                     Error,
                     OperationStarted,
                     OperationCompleted,
                     Attach,
                     Detach,
+                    Enter,
+                    Leave
                 }
             }

Implab/IPromiseT.cs 0 -3

             using System;
-            using System.Collections.Generic;
-            using System.Linq;
-            using System.Text;
             namespace Implab {
                 public interface IPromise<T> : IPromise {
                     new T Join();
                     new T Join(int timeout);
                     void Last(ResultHandler<T> success, ErrorHandler error, Action cancel);
                     void Last(ResultHandler<T> success, ErrorHandler error);
                     void Last(ResultHandler<T> success);
                     IPromise<T> Then(ResultHandler<T> success, ErrorHandler<T> error, Action cancel);
                     IPromise<T> Then(ResultHandler<T> success, ErrorHandler<T> error);
                     IPromise<T> Then(ResultHandler<T> success);
                     IPromise<T2> Then<T2>(ResultMapper<T, T2> mapper, ErrorHandler<T2> error, Action cancel);
                     IPromise<T2> Then<T2>(ResultMapper<T, T2> mapper, ErrorHandler<T2> error);
                     IPromise<T2> Then<T2>(ResultMapper<T, T2> mapper);
                     IPromise<T2> Chain<T2>(ResultMapper<T, IPromise<T2>> chained, ErrorHandler<IPromise<T2>> error, Action cancel);
                     IPromise<T2> Chain<T2>(ResultMapper<T, IPromise<T2>> chained, ErrorHandler<IPromise<T2>> error);
                     IPromise<T2> Chain<T2>(ResultMapper<T, IPromise<T2>> chained);
                     IPromise<T> Error(ErrorHandler<T> error);
                     new IPromise<T> Cancelled(Action handler);
                     new IPromise<T> Anyway(Action handler);
                 }
             }

Implab/Safe.cs +3 -3

             using System;
             using System.Collections.Generic;
             using System.Linq;
             using System.Text;
             using System.Text.RegularExpressions;
             using System.Diagnostics;
             namespace Implab
             {
                 public static class Safe
                 {
                     public static void ArgumentMatch(string param, string name, Regex rx) {
                         if (rx == null)
                             throw new ArgumentNullException("rx");
                         if (!rx.IsMatch(param))
                             throw new ArgumentException(String.Format("The prameter value must match {0}", rx), name);
                     }
                     public static void ArgumentNotEmpty(string param, string name) {
                         if (String.IsNullOrEmpty(param))
                             throw new ArgumentException("The parameter can't be empty", name);
                     }
                     public static void ArgumentNotEmpty<T>(T[] param, string name) {
                         if (param == null || param.Length == 0)
                             throw new ArgumentException("The array must be not emty");
                     }
                     public static void ArgumentNotNull(object param, string name) {
                         if (param == null)
                             throw new ArgumentNullException(name);
                     }
                     public static void ArgumentInRange(int arg, int min, int max, string name) {
                         if (arg < min || arg > max)
                             throw new ArgumentOutOfRangeException(name);
                     }
                     public static void Dispose<T>(T obj) where T : class
                     {
                         var disp = obj as IDisposable;
                         if (disp != null)
                             disp.Dispose();
                     }
                     [DebuggerStepThrough]
-                    public static IPromise<T> GuargPromise<T>(Func<T> action) {
+                    public static IPromise<T> InvokePromise<T>(Func<T> action) {
                         ArgumentNotNull(action, "action");
                         var p = new Promise<T>();
                         try {
                             p.Resolve(action());
                         } catch (Exception err) {
                             p.Reject(err);
                         }
                         return p;
                     }
                     [DebuggerStepThrough]
-                    public static IPromise<T> GuardPromise<T>(Func<IPromise<T>> action) {
+                    public static IPromise<T> InvokePromise<T>(Func<IPromise<T>> action) {
                         ArgumentNotNull(action, "action");
                         try {
-                            return action();
+                            return action() ?? Promise<T>.ExceptionToPromise(new Exception("The action returned null"));
                         } catch (Exception err) {
                             return Promise<T>.ExceptionToPromise(err);
                         }
                     }
                 }
             }

MonoPlay/Program.cs +4 -3

             using System;
             using Implab.Diagnostics;
             using Implab.Parallels;
             using Implab;
             namespace MonoPlay {
                 class MainClass {
                     public static void Main(string[] args) {
+                        if (args == null)
+                            throw new ArgumentNullException("args");
                         var listener = new ConsoleTraceListener(true);
                         listener.Subscribe<TraceEvent>();
                         MTComponentContainer.AppContainer.Add(listener);
                         TraceLog.StartLogicalOperation("program");
-                        Console.WriteLine("Hello World!");
                         TraceLog.StartLogicalOperation("async");
                         AsyncPool.Invoke(() => {
                             TraceLog.TraceInformation("Hello async");
-                            TraceLog.StartLogicalOperation();
+                            TraceLog.StartLogicalOperation("foo");
                             return 0;
                         })
                             .EndLogicalOperation()
                             .Join();
                         TraceLog.EndLogicalOperation();
                     }
                 }
             }

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