implab/ImplabNet Commit - r213:9ee78a345738

Minor code changes

cin -

r213:9ee78a345738 v2

parent child

Context file:

r213:9ee78a345738

Collapse all files

Implab/Components/Disposable.cs +4 -6

             using Implab.Diagnostics;
             using System;
             using System.Diagnostics.CodeAnalysis;
             using System.Threading;
             namespace Implab.Components {
                 /// <summary>
                 /// Base class the objects which support disposing.
                 /// </summary>
                 public class Disposable : IDisposable {
                     int m_disposed;
                     public event EventHandler Disposed;
                     public bool IsDisposed {
                         get {
                             Thread.MemoryBarrier();
                             return m_disposed != 0;
                         }
                     }
                     /// <summary>
                     /// Asserts the object is not disposed.
                     /// </summary>
                     /// <exception cref="ObjectDisposedException">The object is disposed</exception>
                     /// <remarks>
                     /// Успешная проверка того, что объект не освобожден еще не гарантирует, что он не
                     /// будет освобожден сразу после нее, поэтому методы использующие проверку должны
                     /// учитывать, что объект может быть освобожден из параллельного потока.
                     /// Данны метод служит для упрощения отладки ошибок при использовании объекта после его
                     /// освобождения.
                     /// </remarks>
                     /// <example>
                     /// // пример синхронизированного освобождения ресурсов
                     /// class FileStore : Disposable {
                     ///     readonly TextWriter m_file;
                     ///     readonly obejct m_sync = new object();
                     ///
                     ///     public FileStore(string file) {
                     ///         m_file = new TextWriter(File.OpenWrite(file));
                     ///     }
                     ///
                     ///     public void Write(string text) {
                     ///         lock(m_sync) {
                     ///             AssertNotDisposed();
                     ///             m_file.Write(text);
                     ///         }
                     ///     }
                     ///
                     ///     protected override void Dispose(bool disposing) {
                     ///         if (disposing)
                     ///             lock(m_sync) {
                     ///                 m_file.Dipose();
                     ///                 base.Dispose(true);
                     ///             }
                     ///         else
                     ///             base.Dispose(false);
                     ///     }
                     /// }
                     /// <example>
                     protected void AssertNotDisposed() {
                         Thread.MemoryBarrier();
                         if (m_disposed != 0)
                             throw new ObjectDisposedException(ToString());
                     }
                     /// <summary>
                     /// Вызывает событие <see cref="Disposed"/>
                     /// </summary>
                     /// <param name="disposing">Признак того, что нужно освободить ресурсы, иначе данный метод
                     /// вызван сборщиком мусора и нужно освобождать ТОЛЬКО неуправляемые ресурсы ТОЛЬКО этого
                     /// объекта.</param>
                     /// <remarks>
                     /// Данный метод вызывается гарантированно один раз даже при одновременном вызове <see cref="Dispose()"/>
                     /// из нескольких потоков.
                     /// </remarks>
                     protected virtual void Dispose(bool disposing) {
-                        if (disposing) {
+                        if (disposing)
-                            EventHandler temp = Disposed;
+                            Disposed.DispatchEvent(this, EventArgs.Empty);
-                            if (temp != null)
-                                temp(this, EventArgs.Empty);
                     }
                     [SuppressMessage("Microsoft.Design", "CA1063:ImplementIDisposableCorrectly", Justification = "Dipose(bool) and GC.SuppessFinalize are called")]
                     public void Dispose() {
                         if (Interlocked.Increment(ref m_disposed) == 1) {
                             Dispose(true);
                             GC.SuppressFinalize(this);
                         }
                     }
                     /// <summary>
                     /// Записывает сообщение об утечке объекта.
                     /// </summary>
                     protected virtual void ReportObjectLeaks() {
                         TraceLog.TraceWarning("The object is marked as disposable but isn't disposed properly: {0}", this);
                     }
                     ~Disposable() {
                         Dispose(false);
                         ReportObjectLeaks();
                     }
                 }
             }

Implab/Safe.cs +12 0

             using System;
             using System.Collections.Generic;
             using System.Linq;
             using System.Text;
             using System.Text.RegularExpressions;
             using System.Diagnostics;
             using System.Collections;
+            #if NET_4_5
+            using System.Threading.Tasks;
+            #endif
             namespace Implab
             {
                 public static class Safe
                 {
                     public static void ArgumentAssert(bool condition, string paramName) {
                         if (!condition)
                             throw new ArgumentException("The parameter is invalid", paramName);
                     }
                     public static void ArgumentMatch(string value, string paramName, Regex rx) {
                         if (rx == null)
                             throw new ArgumentNullException("rx");
                         if (!rx.IsMatch(value))
                             throw new ArgumentException(String.Format("The prameter value must match {0}", rx), paramName);
                     }
                     public static void ArgumentNotEmpty(string value, string paramName) {
                         if (String.IsNullOrEmpty(value))
                             throw new ArgumentException("The parameter can't be empty", paramName);
                     }
                     public static void ArgumentNotEmpty<T>(T[] value, string paramName) {
                         if (value == null || value.Length == 0)
                             throw new ArgumentException("The array must be not emty", paramName);
                     }
                     public static void ArgumentNotNull(object value, string paramName) {
                         if (value == null)
                             throw new ArgumentNullException(paramName);
                     }
                     public static void ArgumentInRange(int value, int min, int max, string paramName) {
                         if (value < min || value > max)
                             throw new ArgumentOutOfRangeException(paramName);
                     }
                     public static void ArgumentOfType(object value, Type type, string paramName) {
                         if (!type.IsInstanceOfType(value))
                             throw new ArgumentException(String.Format("The parameter must be of type {0}", type), paramName);
                     }
                     public static void Dispose(params IDisposable[] objects) {
                         foreach (var d in objects)
                             if (d != null)
                                 d.Dispose();
                     }
                     public static void Dispose(params object[] objects) {
                         foreach (var obj in objects) {
                             var d = obj as IDisposable;
                             if (d != null)
                                 d.Dispose();
                         }
                     }
                     public static void Dispose(IEnumerable<IDisposable> objects) {
                         foreach (var d in objects)
                             if (d != null)
                                 d.Dispose();
                     }
                     public static void Dispose(object obj) {
                         var d = obj as IDisposable;
                         if (d != null)
                             d.Dispose();
                     }
                     public static void DispatchEvent<T>(this EventHandler<T> handler, object sender, T args) {
                         if (handler != null)
                             handler(sender, args);
                     }
                     public static void DispatchEvent(this EventHandler handler, object sender, EventArgs args) {
                         if (handler != null)
                             handler(sender, args);
                     }
                     [DebuggerStepThrough]
                     public static IPromise<T> Run<T>(Func<T> action) {
                         ArgumentNotNull(action, "action");
                         try {
                             return Promise<T>.FromResult(action());
                         } catch (Exception err) {
                             return Promise<T>.FromException(err);
                         }
                     }
                     [DebuggerStepThrough]
                     public static IPromise Run(Action action) {
                         ArgumentNotNull(action, "action");
                         try {
                             action();
                             return Promise.Success;
                         } catch (Exception err) {
                             return new FailedPromise(err);
                         }
                     }
                     [DebuggerStepThrough]
                     public static IPromise Run(Func<IPromise> action) {
                         ArgumentNotNull(action, "action");
                         try {
                             return action() ?? new FailedPromise(new Exception("The action returned null"));
                         } catch (Exception err) {
                             return new FailedPromise(err);
                         }
                     }
+                    public static void NoWait(IPromise promise) {
+                    }
                     [DebuggerStepThrough]
                     public static IPromise<T> Run<T>(Func<IPromise<T>> action) {
                         ArgumentNotNull(action, "action");
                         try {
                             return action() ?? Promise<T>.FromException(new Exception("The action returned null"));
                         } catch (Exception err) {
                             return Promise<T>.FromException(err);
                         }
                     }
+            #if NET_4_5
+                    public static void NoWait(Task t) {
+                    }
+            #endif
                 }
             }

General Comments 3

sergey

|

Auto status change to "Under Review"

sergey

|

ok, latest stable version should be in default

Write
Preview

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

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

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