Mercurial > pub > ImplabNet

changeset 0:279591fb4df3

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
initial commit promises async model
author user@factory.site.local
date Fri, 23 Aug 2013 04:38:46 +0400
parents
children 6fb3b01ee971
files .hgignore Implab.Test/AsyncTests.cs Implab.Test/Implab.Test.csproj Implab.Test/Properties/AssemblyInfo.cs Implab.sln Implab.suo Implab.vsmdi Implab/AsyncPool.cs Implab/Implab.csproj Implab/Promise.cs Implab/Properties/AssemblyInfo.cs Local.testsettings TraceAndTestImpact.testsettings
diffstat 13 files changed, 731 insertions(+), 0 deletions(-) [+]
line wrap: on
line diff
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/.hgignore	Fri Aug 23 04:38:46 2013 +0400
@@ -0,0 +1,8 @@
+syntax: glob
+Implab.Test/bin/
+*.user
+Implab.Test/obj/
+*.userprefs
+Implab/bin/
+Implab/obj/
+TestResults/
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Implab.Test/AsyncTests.cs	Fri Aug 23 04:38:46 2013 +0400
@@ -0,0 +1,101 @@
+using System;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Implab;
+using System.Reflection;
+using System.Threading;
+
+namespace Implab.Tests
+{
+	[TestClass]
+	public class AsyncTests
+	{
+		[TestMethod]
+		public void ResolveTest ()
+		{
+			int res = -1;
+			var p = new Promise<int> ();
+			p.Then (x => res = x);
+			p.Resolve (100);
+
+			Assert.AreEqual (res, 100);
+		}
+
+        [TestMethod]
+		public void RejectTest ()
+		{
+			int res = -1;
+			Exception err = null;
+
+			var p = new Promise<int> ();
+			p.Then (x => res = x, e => err = e);
+			p.Reject (new ApplicationException ("error"));
+
+			Assert.AreEqual (res, -1);
+			Assert.AreEqual (err.Message, "error");
+
+		}
+
+        [TestMethod]
+		public void JoinSuccessTest ()
+		{
+			var p = new Promise<int> ();
+			p.Resolve (100);
+			Assert.AreEqual (p.Join (), 100);
+		}
+
+        [TestMethod]
+		public void JoinFailTest ()
+		{
+			var p = new Promise<int> ();
+			p.Reject (new ApplicationException ("failed"));
+
+			try {
+				p.Join ();
+				throw new ApplicationException ("WRONG!");
+			} catch (TargetInvocationException err) {
+				Assert.AreEqual (err.InnerException.Message, "failed");
+			} catch {
+				Assert.Fail ("Got wrong excaption");
+			}
+		}
+
+        [TestMethod]
+		public void MapTest ()
+		{
+			var p = new Promise<int> ();
+
+			var p2 = p.Map (x => x.ToString ());
+			p.Resolve (100);
+
+			Assert.AreEqual (p2.Join (), "100");
+		}
+
+        [TestMethod]
+		public void ChainTest ()
+		{
+			var p1 = new Promise<int> ();
+
+			var p3 = p1.Chain (x => {
+				var p2 = new Promise<string> ();
+				p2.Resolve (x.ToString ());
+				return p2;
+			});
+
+			p1.Resolve (100);
+
+			Assert.AreEqual (p3.Join (), "100");
+		}
+
+        [TestMethod]
+		public void PoolTest ()
+		{
+			var pid = Thread.CurrentThread.ManagedThreadId;
+			var p = AsyncPool.Invoke (() => {
+				return Thread.CurrentThread.ManagedThreadId;
+			});
+
+			Assert.AreNotEqual (pid, p.Join ());
+		}
+	}
+}
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Implab.Test/Implab.Test.csproj	Fri Aug 23 04:38:46 2013 +0400
@@ -0,0 +1,65 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProductVersion>
+    </ProductVersion>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>{63F92C0C-61BF-48C0-A377-8D67C3C661D0}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>Implab.Test</RootNamespace>
+    <AssemblyName>Implab.Test</AssemblyName>
+    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+    <ProjectTypeGuids>{3AC096D0-A1C2-E12C-1390-A8335801FDAB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="Microsoft.VisualStudio.QualityTools.UnitTestFramework, Version=10.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL" />
+    <Reference Include="System" />
+    <Reference Include="System.Core">
+      <RequiredTargetFramework>3.5</RequiredTargetFramework>
+    </Reference>
+  </ItemGroup>
+  <ItemGroup>
+    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
+      <Visible>False</Visible>
+    </CodeAnalysisDependentAssemblyPaths>
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="AsyncTests.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\Implab\Implab.csproj">
+      <Project>{99B95D0D-9CF9-4F70-8ADF-F4D0AA5CB0D9}</Project>
+      <Name>Implab</Name>
+    </ProjectReference>
+  </ItemGroup>
+  <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>
\ No newline at end of file
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Implab.Test/Properties/AssemblyInfo.cs	Fri Aug 23 04:38:46 2013 +0400
@@ -0,0 +1,35 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("Implab.Test")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("Implab.Test")]
+[assembly: AssemblyCopyright("Copyright ©  2013")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("bfcae720-21eb-4411-b70a-6eeab99071de")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers 
+// by using the '*' as shown below:
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Implab.sln	Fri Aug 23 04:38:46 2013 +0400
@@ -0,0 +1,39 @@
+
+Microsoft Visual Studio Solution File, Format Version 11.00
+# Visual Studio 2010
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Implab", "Implab\Implab.csproj", "{99B95D0D-9CF9-4F70-8ADF-F4D0AA5CB0D9}"
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{CE8D8D18-437A-445C-B662-4C2CE79A76F6}"
+	ProjectSection(SolutionItems) = preProject
+		Implab.vsmdi = Implab.vsmdi
+		Local.testsettings = Local.testsettings
+		TraceAndTestImpact.testsettings = TraceAndTestImpact.testsettings
+	EndProjectSection
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Implab.Test", "Implab.Test\Implab.Test.csproj", "{63F92C0C-61BF-48C0-A377-8D67C3C661D0}"
+EndProject
+Global
+	GlobalSection(TestCaseManagementSettings) = postSolution
+		CategoryFile = Implab.vsmdi
+	EndGlobalSection
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{99B95D0D-9CF9-4F70-8ADF-F4D0AA5CB0D9}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{99B95D0D-9CF9-4F70-8ADF-F4D0AA5CB0D9}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{99B95D0D-9CF9-4F70-8ADF-F4D0AA5CB0D9}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{99B95D0D-9CF9-4F70-8ADF-F4D0AA5CB0D9}.Release|Any CPU.Build.0 = Release|Any CPU
+		{63F92C0C-61BF-48C0-A377-8D67C3C661D0}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{63F92C0C-61BF-48C0-A377-8D67C3C661D0}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{63F92C0C-61BF-48C0-A377-8D67C3C661D0}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{63F92C0C-61BF-48C0-A377-8D67C3C661D0}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(MonoDevelopProperties) = preSolution
+		StartupItem = Implab\Implab.csproj
+	EndGlobalSection
+EndGlobal
Binary file Implab.suo has changed
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Implab.vsmdi	Fri Aug 23 04:38:46 2013 +0400
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<TestLists xmlns="http://microsoft.com/schemas/VisualStudio/TeamTest/2010">
+  <TestList name="Lists of Tests" id="8c43106b-9dc1-4907-a29f-aa66a61bf5b6">
+    <RunConfiguration id="adaa4751-cfb4-4c5f-85cb-0f017ce09812" name="Local" storage="local.testsettings" type="Microsoft.VisualStudio.TestTools.Common.TestRunConfiguration, Microsoft.VisualStudio.QualityTools.Common, Version=10.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
+  </TestList>
+</TestLists>
\ No newline at end of file
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Implab/AsyncPool.cs	Fri Aug 23 04:38:46 2013 +0400
@@ -0,0 +1,28 @@
+using System;
+using System.Threading;
+
+namespace Implab {
+	/// <summary>
+	/// Класс для распаралеливания задач.
+	/// </summary>
+	/// <remarks>
+	/// Используя данный класс и лямда выражения можно распараллелить
+	/// вычисления, для этого используется концепция обещаний.
+	/// </remarks>
+	public static class AsyncPool {
+
+		public static Promise<T> Invoke<T>(Func<T> func) {
+			var p = new Promise<T>();
+
+			ThreadPool.QueueUserWorkItem(param => {
+				try {
+					p.Resolve(func());
+				} catch(Exception e) {
+					p.Reject(e);
+				}
+			});
+
+			return p;
+		}
+	}
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Implab/Implab.csproj	Fri Aug 23 04:38:46 2013 +0400
@@ -0,0 +1,43 @@
+<?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>{99B95D0D-9CF9-4F70-8ADF-F4D0AA5CB0D9}</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>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="Properties\AssemblyInfo.cs" />
+    <Compile Include="Promise.cs" />
+    <Compile Include="AsyncPool.cs" />
+  </ItemGroup>
+  <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
+  <ItemGroup>
+    <Folder Include="Parallels\" />
+  </ItemGroup>
+</Project>
\ No newline at end of file
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Implab/Promise.cs	Fri Aug 23 04:38:46 2013 +0400
@@ -0,0 +1,350 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Text;
+using System.Diagnostics;
+using System.Threading;
+
+namespace Implab {
+
+	public delegate void ErrorHandler(Exception e);
+
+	public delegate void ResultHandler<T>(T result);
+	public delegate TNew ResultMapper<TSrc,TNew>(TSrc result);
+	public delegate Promise<TNew> ChainedOperation<TSrc,TNew>(TSrc result);
+
+	/// <summary>
+	/// Класс для асинхронного получения результатов. Так называемое "обещание".
+	/// </summary>
+	/// <typeparam name="T">Тип получаемого результата</typeparam>
+	/// <remarks>
+	/// <para>Сервис при обращении к его методу дает обещаиние о выполнении операции,
+	/// клиент получив такое обещание может установить ряд обратных вызово для получения
+	/// событий выполнения обещания, тоесть завершения операции и предоставлении результатов.</para>
+	/// <para>
+	/// Обещение может быть как выполнено, так и выполнено с ошибкой. Для подписки на
+	/// данные события клиент должен использовать методы <c>Then</c>.
+	/// </para>
+	/// <para>
+	/// Сервис, в свою очередь, по окончанию выполнения операции (возможно с ошибкой),
+	/// использует методы <c>Resolve</c> либо <c>Reject</c> для оповещения клиетна о
+	/// выполнении обещания.
+	/// </para>
+	/// <para>
+	/// Если сервер успел выполнить обещание еще до того, как клиент на него подписался,
+	/// то в момент подписки клиента будут вызваны соответсвующие события в синхронном
+	/// режиме и клиент будет оповещен в любом случае. Иначе, обработчики добавляются в
+	/// список в порядке подписания и в этом же порядке они будут вызваны при выполнении
+	/// обещания.
+	/// </para>
+	/// <para>
+	/// Обрабатывая результаты обещания можно преобразовывать результаты либо инициировать
+	/// связанные асинхронные операции, которые также возвращают обещания. Для этого следует
+	/// использовать соответствующую форму методе <c>Then</c>.
+	/// </para>
+	/// <para>
+	/// Также хорошим правилом является то, что <c>Resolve</c> и <c>Reject</c> должен вызывать
+	/// только инициатор обещания иначе могут возникнуть противоречия.
+	/// </para>
+	/// </remarks>
+	public class Promise<T> {
+
+		struct ResultHandlerInfo {
+			public ResultHandler<T> resultHandler;
+			public ErrorHandler errorHandler;
+		}
+
+		enum State {
+			Unresolved,
+			Resolving,
+			Resolved,
+			Cancelled
+		}
+
+		LinkedList<ResultHandlerInfo> m_handlersChain = new LinkedList<ResultHandlerInfo>();
+		State m_state;
+		bool m_cancellable;
+		T m_result;
+		Exception m_error;
+
+		public Promise() {
+			m_cancellable = true;
+		}
+
+		/// <summary>
+		/// Событие, возникающее при отмене асинхронной операции.
+		/// </summary>
+		/// <description>
+		/// Как правило используется для оповещения объекта, выполняющего асинхронную операцию, о том, что ее следует отменить.
+		/// </description>
+		public event EventHandler Cancelled;
+
+		/// <summary>
+		/// Выполняет обещание, сообщая об успешном выполнении.
+		/// </summary>
+		/// <param name="result">Результат выполнения.</param>
+		/// <exception cref="InvalidOperationException">Данное обещание уже выполнено</exception>
+		public void Resolve(T result) {
+			lock (this) {
+				if (m_state == State.Cancelled)
+					return;
+				if (m_state != State.Unresolved)
+					throw new InvalidOperationException("The promise is already resolved");
+				m_result = result;
+				m_state = State.Resolving;
+			}
+
+			ResultHandlerInfo handler;
+			while (FetchNextHandler(out handler))
+				InvokeHandler(handler);
+		}
+
+		/// <summary>
+		/// Выполняет обещание, сообщая об ошибке
+		/// </summary>
+		/// <param name="error">Исключение возникшее при выполнении операции</param>
+		/// <exception cref="InvalidOperationException">Данное обещание уже выполнено</exception>
+		public void Reject(Exception error) {
+			lock (this) {
+				if (m_state == State.Cancelled)
+					return;
+				if (m_state != State.Unresolved)
+					throw new InvalidOperationException("The promise is already resolved");
+				m_error = error;
+				m_state = State.Resolving;
+			}
+
+			ResultHandlerInfo handler;
+			while (FetchNextHandler(out handler))
+				InvokeHandler(handler);
+		}
+
+		/// <summary>
+		/// Отменяет операцию, если это возможно.
+		/// </summary>
+		/// <returns><c>true</c> Операция была отменена, обработчики не будут вызваны.<c>false</c> отмена не возможна, поскольку обещание уже выполнено и обработчики отработали.</returns>
+		public bool Cancel() {
+			lock(this) {
+				if (m_state == State.Unresolved && m_cancellable) {
+					m_state = State.Cancelled;
+					return true;
+				} else
+					return false;
+			}
+		}
+
+		/// <summary>
+		/// Добавляет обработчики событий выполнения обещания.
+		/// </summary>
+		/// <param name="success">Обработчик успешного выполнения обещания.
+		/// Данному обработчику будет передан результат выполнения операции.</param>
+		/// <param name="error">Обработчик ошибки. Данный обработчик получит
+		/// исключение возникшее при выполнении операции.</param>
+		/// <returns>Само обещание</returns>
+		public Promise<T> Then(ResultHandler<T> success, ErrorHandler error) {
+			if (success == null && error == null)
+				return this;
+
+			AddHandler(new ResultHandlerInfo() {
+				resultHandler = success,
+				errorHandler = error
+			});
+
+			return this;
+		}
+
+		public Promise<T> Then(ResultHandler<T> success) {
+			return Then (success, null);
+		}
+
+		public Promise<T> Anyway(Action handler) {
+			if (handler == null)
+				return this;
+			AddHandler(new ResultHandlerInfo {
+				resultHandler = x => handler(),
+				errorHandler = x => handler()
+			});
+
+			return this;
+		}
+
+		/// <summary>
+		/// Позволяет преобразовать результат выполения операции к новому типу.
+		/// </summary>
+		/// <typeparam name="TNew">Новый тип результата.</typeparam>
+		/// <param name="mapper">Преобразование результата к новому типу.</param>
+		/// <param name="error">Обработчик ошибки. Данный обработчик получит
+		/// исключение возникшее при выполнении операции.</param>
+		/// <returns>Новое обещание, которое будет выполнено при выполнении исходного обещания.</returns>
+		public Promise<TNew> Map<TNew>(ResultMapper<T, TNew> mapper, ErrorHandler error) {
+			if (mapper == null)
+				throw new ArgumentNullException("mapper");
+
+			// создаем прицепленное обещание
+			Promise<TNew> chained = new Promise<TNew>();
+
+			AddHandler(new ResultHandlerInfo() {
+				resultHandler = delegate(T result) {
+					try {
+						// если преобразование выдаст исключение, то сработает reject сцепленного deferred
+						chained.Resolve(mapper(result));
+					} catch (Exception e) {
+						chained.Reject(e);
+					}
+				},
+				errorHandler = delegate(Exception e) {
+					if (error != null)
+					error(e);
+					// в случае ошибки нужно передать исключение дальше по цепочке
+					chained.Reject(e);
+				}
+			});
+
+			return chained;
+		}
+
+		public Promise<TNew> Map<TNew>(ResultMapper<T, TNew> mapper) {
+			return Map (mapper, null);
+		}
+
+		/// <summary>
+		/// Сцепляет несколько аснхронных операций. Указанная асинхронная операция будет вызвана после
+		/// выполнения текущей, а результат текущей операции может быть использован для инициализации
+		/// новой операции.
+		/// </summary>
+		/// <typeparam name="TNew">Тип результата указанной асинхронной операции.</typeparam>
+		/// <param name="chained">Асинхронная операция, которая должна будет начаться после выполнения текущей.</param>
+		/// <param name="error">Обработчик ошибки. Данный обработчик получит
+		/// исключение возникшее при выполнении текуещй операции.</param>
+		/// <returns>Новое обещание, которое будет выполнено по окончанию указанной аснхронной операции.</returns>
+		public Promise<TNew> Chain<TNew>(ChainedOperation<T, TNew> chained, ErrorHandler error) {
+
+			// проблема в том, что на момент связывания еще не начата асинхронная операция, поэтому нужно
+			// создать посредника, к которому будут подвызяваться следующие обработчики.
+			// когда будет выполнена реальная асинхронная операция, она обратиться к посреднику, чтобы
+			// передать через него результаты работы.
+			Promise<TNew> medium = new Promise<TNew>();
+
+			AddHandler(new ResultHandlerInfo() {
+				resultHandler = delegate(T result) {
+					try {
+						chained(result).Then(
+							x => medium.Resolve(x),
+							e => medium.Reject(e)
+							);
+					} catch(Exception e) {
+						// если сцепленное действие выдало исключение вместо обещания, то передаем ошибку по цепочке
+						medium.Reject(e);
+					}
+				},
+				errorHandler = delegate(Exception e) {
+					if (error != null)
+					error(e);
+					// в случае ошибки нужно передать исключение дальше по цепочке
+					medium.Reject(e);
+				}
+			});
+
+			return medium;
+		}
+
+		public Promise<TNew> Chain<TNew>(ChainedOperation<T, TNew> chained) {
+			return Chain (chained, null);
+		}
+
+		/// <summary>
+		/// Дожидается отложенного обещания и в случае успеха, возвращает
+		/// его, результат, в противном случае бросает исключение.
+		/// </summary>
+		/// <remarks>
+		/// <para>
+		/// Если ожидание обещания было прервано по таймауту, это не значит,
+		/// что обещание было отменено или что-то в этом роде, это только
+		/// означает, что мы его не дождались, однако все зарегистрированные
+		/// обработчики, как были так остались и они будут вызваны, когда
+		/// обещание будет выполнено.
+		/// </para>
+		/// <para>
+		/// Такое поведение вполне оправдано поскольку таймаут может истечь
+		/// в тот момент, когда началась обработка цепочки обработчиков, и
+		/// к тому же текущее обещание может стоять в цепочке обещаний и его
+		/// отклонение может привести к непрогнозируемому результату.
+		/// </para>
+		/// </remarks>
+		/// <param name="timeout">Время ожидания</param>
+		/// <returns>Результат выполнения обещания</returns>
+		public T Join(int timeout) {
+			ManualResetEvent evt = new ManualResetEvent(false);
+			Anyway(() => evt.Set());
+
+			if (!evt.WaitOne(timeout, true))
+				throw new TimeoutException();
+
+			if (m_error != null)
+				throw new TargetInvocationException( m_error );
+			else
+				return m_result;
+		}
+
+		public T Join() {
+			return Join(Timeout.Infinite);
+		}
+
+		/// <summary>
+		/// Данный метод последовательно извлекает обработчики обещания и когда
+		/// их больше не осталось - ставит состояние "разрешено".
+		/// </summary>
+		/// <param name="handler">Информация об обработчике</param>
+		/// <returns>Признак того, что еще остались обработчики в очереди</returns>
+		bool FetchNextHandler(out ResultHandlerInfo handler) {
+			handler = default(ResultHandlerInfo);
+
+			lock (this) {
+				Debug.Assert(m_state == State.Resolving);
+
+				if (m_handlersChain.Count > 0) {
+					handler = m_handlersChain.First.Value;
+					m_handlersChain.RemoveFirst();
+					return true;
+				} else {
+					m_state = State.Resolved;
+					return false;
+				}
+			}
+		}
+
+		void AddHandler(ResultHandlerInfo handler) {
+			bool invokeRequired = false;
+
+			lock (this) {
+				if (m_state != State.Resolved)
+					m_handlersChain.AddLast(handler);
+				else
+					invokeRequired = true;
+			}
+
+			// обработчики не должны блокировать сам объект
+			if (invokeRequired)
+				InvokeHandler(handler);
+		}
+
+		void InvokeHandler(ResultHandlerInfo handler) {
+			if (m_error == null) {
+				try {
+					if (handler.resultHandler != null)
+						handler.resultHandler(m_result);
+				} catch { }
+			}
+
+			if (m_error != null) {
+				try {
+					if (handler.errorHandler !=null)
+						handler.errorHandler(m_error);
+				} catch { }
+			}
+		}
+
+
+	}
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Implab/Properties/AssemblyInfo.cs	Fri Aug 23 04:38:46 2013 +0400
@@ -0,0 +1,25 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+
+// Information about this assembly is defined by the following attributes. 
+// Change them to the values specific to your project.
+
+[assembly: AssemblyTitle("Implab")]
+[assembly: AssemblyDescription("Tools")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("")]
+[assembly: AssemblyCopyright("Implab")]
+[assembly: AssemblyTrademark("")]
+// The assembly version has the format "{Major}.{Minor}.{Build}.{Revision}".
+// The form "{Major}.{Minor}.*" will automatically update the build and revision,
+// and "{Major}.{Minor}.{Build}.*" will update just the revision.
+
+[assembly: AssemblyVersion("1.0.*")]
+
+// The following attributes are used to specify the signing key for the assembly, 
+// if desired. See the Mono documentation for more information about signing.
+
+//[assembly: AssemblyDelaySign(false)]
+//[assembly: AssemblyKeyFile("")]
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Local.testsettings	Fri Aug 23 04:38:46 2013 +0400
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<TestSettings name="Local" id="adaa4751-cfb4-4c5f-85cb-0f017ce09812" xmlns="http://microsoft.com/schemas/VisualStudio/TeamTest/2010">
+  <Description>These are default test settings for a local test run.</Description>
+  <Deployment enabled="false" />
+  <Execution>
+    <TestTypeSpecific />
+    <AgentRule name="Execution Agents">
+    </AgentRule>
+  </Execution>
+</TestSettings>
\ No newline at end of file
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/TraceAndTestImpact.testsettings	Fri Aug 23 04:38:46 2013 +0400
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<TestSettings name="Trace and Test Impact" id="8057bc26-bca1-4225-a128-52e89dd1b7d3" xmlns="http://microsoft.com/schemas/VisualStudio/TeamTest/2010">
+  <Description>These are test settings for Trace and Test Impact.</Description>
+  <Execution>
+    <TestTypeSpecific />
+    <AgentRule name="Execution Agents">
+      <DataCollectors>
+        <DataCollector uri="datacollector://microsoft/SystemInfo/1.0" assemblyQualifiedName="Microsoft.VisualStudio.TestTools.DataCollection.SystemInfo.SystemInfoDataCollector, Microsoft.VisualStudio.TestTools.DataCollection.SystemInfo, Version=10.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" friendlyName="System Information">
+        </DataCollector>
+        <DataCollector uri="datacollector://microsoft/ActionLog/1.0" assemblyQualifiedName="Microsoft.VisualStudio.TestTools.ManualTest.ActionLog.ActionLogPlugin, Microsoft.VisualStudio.TestTools.ManualTest.ActionLog, Version=10.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" friendlyName="Actions">
+        </DataCollector>
+        <DataCollector uri="datacollector://microsoft/HttpProxy/1.0" assemblyQualifiedName="Microsoft.VisualStudio.TraceCollector.HttpProxyCollector, Microsoft.VisualStudio.TraceCollector, Version=10.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" friendlyName="ASP.NET Client Proxy for IntelliTrace and Test Impact">
+        </DataCollector>
+        <DataCollector uri="datacollector://microsoft/TestImpact/1.0" assemblyQualifiedName="Microsoft.VisualStudio.TraceCollector.TestImpactDataCollector, Microsoft.VisualStudio.TraceCollector, Version=10.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" friendlyName="Test Impact">
+        </DataCollector>
+        <DataCollector uri="datacollector://microsoft/TraceDebugger/1.0" assemblyQualifiedName="Microsoft.VisualStudio.TraceCollector.TraceDebuggerDataCollector, Microsoft.VisualStudio.TraceCollector, Version=10.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" friendlyName="IntelliTrace">
+        </DataCollector>
+      </DataCollectors>
+    </AgentRule>
+  </Execution>
+</TestSettings>
\ No newline at end of file