implab/ImplabNet Commit - r210:5dc21f6a3222

Code review for RunnableComponent...

cin -

r210:5dc21f6a3222 v2

parent child

Context file:

r210:5dc21f6a3222

Collapse all files

Implab.Fx.Test/StaApartmentTests.cs created 644 +52 0

@@ -0,0 +1,52
	1	using System;
	2	using System.Reflection;
	3	using System.Threading;
	4	using Implab.Parallels;
	5	using Implab.Components;
	6
	7	#if MONO
	8
	9	using NUnit.Framework;
	10	using TestClassAttribute = NUnit.Framework.TestFixtureAttribute;
	11	using TestMethodAttribute = NUnit.Framework.TestAttribute;
	12	using AssertFailedException = NUnit.Framework.AssertionException;
	13	#else
	14
	15	using Microsoft.VisualStudio.TestTools.UnitTesting;
	16
	17	#endif
	18	namespace Implab.Fx.Test {
	19	[TestClass]
	20	public class StaApartmentTests {
	21	[TestMethod]
	22	public void CreateDestroyApartment() {
	23	var apartment = new StaApartment();
	24	try {
	25	Assert.IsNotNull(apartment.SyncContext);
	26	Assert.Fail();
	27	} catch (InvalidOperationException) {
	28	// OK
	29	}
	30
	31	apartment.Start().Join();
	32	Assert.AreEqual(apartment.State, ExecutionState.Running);
	33
	34	Assert.IsNotNull(apartment.SyncContext);
	35	apartment.Stop().Join();
	36
	37	Assert.IsTrue(apartment.State == ExecutionState.Disposed);
	38	}
	39
	40	[TestMethod]
	41	public void InvokeInApartment() {
	42	var apartment = new StaApartment();
	43
	44	apartment.Start().Join();
	45
	46	var apType = apartment.Invoke(() => { return Thread.CurrentThread.GetApartmentState(); }).Join();
	47	Assert.AreEqual(apType, ApartmentState.STA);
	48
	49	apartment.Stop().Join();
	50	}
	51	}
	52	}

Implab.Fx/StaApartment.cs created 644 +188 0

@@ -0,0 +1,188
	1	using Implab.Components;
	2	using Implab.Diagnostics;
	3	using Implab.Parallels;
	4	using System;
	5	using System.Collections.Generic;
	6	using System.Linq;
	7	using System.Text;
	8	using System.Threading;
	9	using System.Threading.Tasks;
	10	using System.Windows.Forms;
	11
	12	namespace Implab.Fx {
	13	public class StaApartment : RunnableComponent {
	14	readonly Thread m_worker;
	15	SynchronizationContext m_syncContext;
	16	readonly Promise m_threadStarted;
	17	readonly Promise m_threadTerminated;
	18
	19	public StaApartment() : base(true) {
	20	m_threadStarted = new Promise();
	21	m_threadTerminated = new Promise();
	22
	23	m_worker = new Thread(WorkerEntry);
	24	m_worker.SetApartmentState(ApartmentState.STA);
	25	m_worker.IsBackground = true;
	26	m_worker.Name = "STA managed aparment";
	27	}
	28
	29	public SynchronizationContext SyncContext {
	30	get {
	31	if (m_syncContext == null)
	32	throw new InvalidOperationException();
	33	return m_syncContext;
	34	}
	35	}
	36
	37	public IPromise Invoke(Action<ICancellationToken> action) {
	38	Safe.ArgumentNotNull(action, "action");
	39
	40	if (m_syncContext == null)
	41	throw new InvalidOperationException();
	42	var p = new Promise();
	43	var lop = TraceContext.Instance.CurrentOperation;
	44
	45	m_syncContext.Post(x => {
	46	TraceContext.Instance.EnterLogicalOperation(lop, false);
	47	try {
	48	if (p.CancelOperationIfRequested())
	49	return;
	50
	51	action(p);
	52	p.Resolve();
	53	} catch (Exception e) {
	54	p.Reject(e);
	55	} finally {
	56	TraceContext.Instance.Leave();
	57	}
	58	}, null);
	59
	60	return p;
	61	}
	62
	63	public IPromise<T> Invoke<T>(Func<ICancellationToken, T> action) {
	64	Safe.ArgumentNotNull(action, "action");
	65
	66	if (m_syncContext == null)
	67	throw new InvalidOperationException();
	68	var p = new Promise<T>();
	69	var lop = TraceContext.Instance.CurrentOperation;
	70
	71	m_syncContext.Post(x => {
	72	TraceContext.Instance.EnterLogicalOperation(lop, false);
	73	try {
	74	if (p.CancelOperationIfRequested())
	75	return;
	76	p.Resolve(action(p));
	77	} catch (Exception e) {
	78	p.Reject(e);
	79	} finally {
	80	TraceContext.Instance.Leave();
	81	}
	82	}, null);
	83
	84	return p;
	85	}
	86
	87	public IPromise Invoke(Action action) {
	88	Safe.ArgumentNotNull(action, "action");
	89
	90	if (m_syncContext == null)
	91	throw new InvalidOperationException();
	92	var p = new Promise();
	93	var lop = TraceContext.Instance.CurrentOperation;
	94
	95	m_syncContext.Post(x => {
	96	TraceContext.Instance.EnterLogicalOperation(lop, false);
	97	try {
	98	if (p.CancelOperationIfRequested())
	99	return;
	100	action();
	101	p.Resolve();
	102	} catch (Exception e) {
	103	p.Reject(e);
	104	} finally {
	105	TraceContext.Instance.Leave();
	106	}
	107	}, null);
	108
	109	return p;
	110	}
	111
	112	public IPromise<T> Invoke<T>(Func<T> action) {
	113	Safe.ArgumentNotNull(action, "action");
	114
	115	if (m_syncContext == null)
	116	throw new InvalidOperationException();
	117	var p = new Promise<T>();
	118	var lop = TraceContext.Instance.CurrentOperation;
	119
	120	m_syncContext.Post(x => {
	121	TraceContext.Instance.EnterLogicalOperation(lop, false);
	122	try {
	123	if (p.CancelOperationIfRequested())
	124	return;
	125	p.Resolve(action());
	126	} catch (Exception e) {
	127	p.Reject(e);
	128	} finally {
	129	TraceContext.Instance.Leave();
	130	}
	131	}, null);
	132
	133	return p;
	134	}
	135
	136
	137	/// <summary>
	138	/// Starts the apartment thread
	139	/// </summary>
	140	/// <returns>Promise which will be fullfiled when the syncronization
	141	/// context will be ready to accept tasks.</returns>
	142	protected override IPromise OnStart() {
	143	m_worker.Start();
	144	return m_threadStarted;
	145	}
	146
	147	/// <summary>
	148	/// Posts quit message to the message loop of the apartment
	149	/// </summary>
	150	/// <returns>Promise</returns>
	151	protected override IPromise OnStop() {
	152	m_syncContext.Post(x => Application.ExitThread(), null);
	153	return m_threadTerminated;
	154	}
	155
	156	void WorkerEntry() {
	157	m_syncContext = new WindowsFormsSynchronizationContext();
	158	SynchronizationContext.SetSynchronizationContext(m_syncContext);
	159
	160	m_threadStarted.Resolve();
	161
	162	Application.OleRequired();
	163	Application.Run();
	164
	165	try {
	166	OnShutdown();
	167	m_threadTerminated.Resolve();
	168	} catch(Exception err) {
	169	m_threadTerminated.Reject(err);
	170	}
	171	}
	172
	173	/// <summary>
	174	/// Called from the STA apartment after the message loop is terminated, override this
	175	/// method to handle apartment cleanup.
	176	/// </summary>
	177	protected virtual void OnShutdown() {
	178	}
	179
	180	protected override void Dispose(bool disposing) {
	181	if (disposing) {
	182	if (!m_threadTerminated.IsResolved)
	183	m_syncContext.Post(x => Application.ExitThread(), null);
	184	}
	185	base.Dispose(disposing);
	186	}
	187	}
	188	}

Implab.Fx.Test/Implab.Fx.Test.csproj +1 0

             <?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>8.0.30703</ProductVersion>
                 <SchemaVersion>2.0</SchemaVersion>
                 <ProjectGuid>{2F31E405-E267-4195-A05D-574093C21209}</ProjectGuid>
                 <OutputType>Library</OutputType>
                 <AppDesignerFolder>Properties</AppDesignerFolder>
                 <RootNamespace>Implab.Fx.Test</RootNamespace>
                 <AssemblyName>Implab.Fx.Test</AssemblyName>
                 <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
                 <FileAlignment>512</FileAlignment>
                 <ProjectTypeGuids>{3AC096D0-A1C2-E12C-1390-A8335801FDAB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
                 <TargetFrameworkProfile />
               </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>
                 <Prefer32Bit>false</Prefer32Bit>
               </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>
                 <Prefer32Bit>false</Prefer32Bit>
               </PropertyGroup>
               <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug 4.5|AnyCPU' ">
                 <DebugSymbols>true</DebugSymbols>
                 <DebugType>full</DebugType>
                 <Optimize>false</Optimize>
                 <OutputPath>bin\Debug\</OutputPath>
                 <DefineConstants>DEBUG;TRACE</DefineConstants>
                 <ErrorReport>prompt</ErrorReport>
                 <WarningLevel>4</WarningLevel>
                 <Prefer32Bit>false</Prefer32Bit>
               </PropertyGroup>
               <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release 4.5|AnyCPU' ">
                 <DebugType>pdbonly</DebugType>
                 <Optimize>true</Optimize>
                 <OutputPath>bin\Release\</OutputPath>
                 <DefineConstants>TRACE</DefineConstants>
                 <ErrorReport>prompt</ErrorReport>
                 <WarningLevel>4</WarningLevel>
                 <Prefer32Bit>false</Prefer32Bit>
               </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>
                 <Reference Include="System.Data" />
                 <Reference Include="System.Drawing" />
                 <Reference Include="System.Windows.Forms" />
                 <Reference Include="System.Xml" />
                 <Reference Include="WindowsBase" />
               </ItemGroup>
               <ItemGroup>
                 <Compile Include="Properties\AssemblyInfo.cs" />
                 <Compile Include="OverlayTest.cs" />
                 <Compile Include="Sample\MainForm.cs">
                   <SubType>Form</SubType>
                 </Compile>
                 <Compile Include="Sample\MainForm.Designer.cs">
                   <DependentUpon>MainForm.cs</DependentUpon>
                 </Compile>
                 <Compile Include="Sample\OverlayForm.cs">
                   <SubType>Form</SubType>
                 </Compile>
                 <Compile Include="Sample\OverlayForm.Designer.cs">
                   <DependentUpon>OverlayForm.cs</DependentUpon>
                 </Compile>
+                <Compile Include="StaApartmentTests.cs" />
               </ItemGroup>
               <ItemGroup>
                 <EmbeddedResource Include="Sample\MainForm.resx">
                   <DependentUpon>MainForm.cs</DependentUpon>
                   <LogicalName>
                   </LogicalName>
                 </EmbeddedResource>
                 <EmbeddedResource Include="Sample\OverlayForm.resx">
                   <DependentUpon>OverlayForm.cs</DependentUpon>
                   <LogicalName>
                   </LogicalName>
                 </EmbeddedResource>
               </ItemGroup>
               <ItemGroup>
                 <ProjectReference Include="..\Implab.Fx\Implab.Fx.csproj">
                   <Project>{06E706F8-6881-43EB-927E-FFC503AF6ABC}</Project>
                   <Name>Implab.Fx</Name>
                 </ProjectReference>
                 <ProjectReference Include="..\Implab\Implab.csproj">
                   <Project>{F550F1F8-8746-4AD0-9614-855F4C4B7F05}</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>

Implab.Fx/Implab.Fx.csproj +1 0

             <?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>8.0.30703</ProductVersion>
                 <SchemaVersion>2.0</SchemaVersion>
                 <ProjectGuid>{06E706F8-6881-43EB-927E-FFC503AF6ABC}</ProjectGuid>
                 <OutputType>Library</OutputType>
                 <AppDesignerFolder>Properties</AppDesignerFolder>
                 <RootNamespace>Implab.Fx</RootNamespace>
                 <AssemblyName>Implab.Fx</AssemblyName>
                 <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
                 <FileAlignment>512</FileAlignment>
                 <ReleaseVersion>0.2</ReleaseVersion>
                 <TargetFrameworkProfile />
               </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>
                 <Prefer32Bit>false</Prefer32Bit>
               </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>
                 <Prefer32Bit>false</Prefer32Bit>
               </PropertyGroup>
               <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug 4.5|AnyCPU' ">
                 <DebugSymbols>true</DebugSymbols>
                 <DebugType>full</DebugType>
                 <Optimize>false</Optimize>
                 <OutputPath>bin\Debug\</OutputPath>
                 <DefineConstants>DEBUG;TRACE</DefineConstants>
                 <ErrorReport>prompt</ErrorReport>
                 <WarningLevel>4</WarningLevel>
                 <Prefer32Bit>false</Prefer32Bit>
               </PropertyGroup>
               <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release 4.5|AnyCPU' ">
                 <DebugType>pdbonly</DebugType>
                 <Optimize>true</Optimize>
                 <OutputPath>bin\Release\</OutputPath>
                 <DefineConstants>TRACE</DefineConstants>
                 <ErrorReport>prompt</ErrorReport>
                 <WarningLevel>4</WarningLevel>
                 <Prefer32Bit>false</Prefer32Bit>
               </PropertyGroup>
               <ItemGroup>
                 <Reference Include="System" />
                 <Reference Include="System.Core" />
                 <Reference Include="System.Drawing" />
                 <Reference Include="System.Windows.Forms" />
                 <Reference Include="System.Xml.Linq" />
                 <Reference Include="System.Data.DataSetExtensions" />
                 <Reference Include="Microsoft.CSharp" />
                 <Reference Include="System.Data" />
                 <Reference Include="System.Xml" />
               </ItemGroup>
               <ItemGroup>
                 <Compile Include="Animation.cs" />
                 <Compile Include="AnimationHelpers.cs" />
                 <Compile Include="PromiseHelpers.cs" />
                 <Compile Include="Properties\AssemblyInfo.cs" />
                 <Compile Include="ControlBoundPromise.cs" />
+                <Compile Include="StaApartment.cs" />
               </ItemGroup>
               <ItemGroup>
                 <ProjectReference Include="..\Implab\Implab.csproj">
                   <Project>{F550F1F8-8746-4AD0-9614-855F4C4B7F05}</Project>
                   <Name>Implab</Name>
                 </ProjectReference>
               </ItemGroup>
               <Import Project="$(MSBuildToolsPath)\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>

Implab.Test/Implab.Test.csproj +6 0

             <?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>8.0.30703</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.5</TargetFrameworkVersion>
                 <FileAlignment>512</FileAlignment>
                 <ProjectTypeGuids>{3AC096D0-A1C2-E12C-1390-A8335801FDAB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
                 <TargetFrameworkProfile />
               </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>
                 <Prefer32Bit>false</Prefer32Bit>
               </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>
                 <Prefer32Bit>false</Prefer32Bit>
               </PropertyGroup>
               <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug 4.5|AnyCPU' ">
                 <DebugSymbols>true</DebugSymbols>
                 <DebugType>full</DebugType>
                 <Optimize>false</Optimize>
                 <OutputPath>bin\Debug\</OutputPath>
                 <DefineConstants>DEBUG;TRACE</DefineConstants>
                 <ErrorReport>prompt</ErrorReport>
                 <WarningLevel>4</WarningLevel>
                 <Prefer32Bit>false</Prefer32Bit>
               </PropertyGroup>
               <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release 4.5|AnyCPU' ">
                 <DebugType>pdbonly</DebugType>
                 <Optimize>true</Optimize>
                 <OutputPath>bin\Release\</OutputPath>
                 <DefineConstants>TRACE</DefineConstants>
                 <ErrorReport>prompt</ErrorReport>
                 <WarningLevel>4</WarningLevel>
                 <Prefer32Bit>false</Prefer32Bit>
               </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>
                 <Compile Include="AsyncTests.cs" />
                 <Compile Include="CancelationTests.cs" />
+                <Compile Include="Mock\MockPollingComponent.cs" />
+                <Compile Include="Mock\MockRunnableComponent.cs" />
+                <Compile Include="PollingComponentTests.cs" />
                 <Compile Include="PromiseHelper.cs" />
                 <Compile Include="Properties\AssemblyInfo.cs" />
                 <Compile Include="RunnableComponentTests.cs" />
               </ItemGroup>
               <ItemGroup>
                 <ProjectReference Include="..\Implab\Implab.csproj">
                   <Project>{99B95D0D-9CF9-4F70-8ADF-F4D0AA5CB0D9}</Project>
                   <Name>Implab</Name>
                 </ProjectReference>
               </ItemGroup>
+              <ItemGroup>
+                <Folder Include="Implab.Format.Test\" />
+              </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>

Implab/Components/RunnableComponent.cs +94 -51

             using System;
             using System.Diagnostics.CodeAnalysis;
             namespace Implab.Components {
                 public abstract class RunnableComponent : IDisposable, IRunnable, IInitializable {
                     enum Commands {
                         Ok = 0,
                         Fail,
                         Init,
                         Start,
                         Stop,
                         Dispose,
                         Reset,
                         Last = Reset
                     }
                     class StateMachine {
-                        static readonly ExecutionState[,] _transitions;
+                        public static readonly ExecutionState[,] ReusableTransitions;
+                        public static readonly ExecutionState[,] NonreusableTransitions;
+                        class StateBuilder {
+                            readonly ExecutionState[,] m_states;
+                            public ExecutionState[,] States {
+                                get { return m_states; }
+                            }
+                            public StateBuilder(ExecutionState[,] states) {
+                                m_states = states;
+                            }
+                            public StateBuilder() {
+                                m_states = new ExecutionState[(int)ExecutionState.Last + 1, (int)Commands.Last + 1];
+                            }
+                            public StateBuilder Edge(ExecutionState s1, ExecutionState s2, Commands cmd) {
+                                m_states[(int)s1, (int)cmd] = s2;
+                                return this;
+                            }
+                            public StateBuilder Clone() {
+                                return new StateBuilder((ExecutionState[,])m_states.Clone());
+                            }
+                        }
                         static StateMachine() {
-                            _transitions = new ExecutionState[(int)ExecutionState.Last + 1, (int)Commands.Last + 1];
+                            ReusableTransitions = new ExecutionState[(int)ExecutionState.Last + 1, (int)Commands.Last + 1];
-                            Edge(ExecutionState.Created, ExecutionState.Initializing, Commands.Init);
+                            var common = new StateBuilder()
-                            Edge(ExecutionState.Created, ExecutionState.Disposed, Commands.Dispose);
+                                .Edge(ExecutionState.Created, ExecutionState.Initializing, Commands.Init)
+                                .Edge(ExecutionState.Created, ExecutionState.Disposed, Commands.Dispose)
-                            Edge(ExecutionState.Initializing, ExecutionState.Ready, Commands.Ok);
+                                .Edge(ExecutionState.Initializing, ExecutionState.Ready, Commands.Ok)
-                            Edge(ExecutionState.Initializing, ExecutionState.Failed, Commands.Fail);
+                                .Edge(ExecutionState.Initializing, ExecutionState.Failed, Commands.Fail)
-                            Edge(ExecutionState.Ready, ExecutionState.Starting, Commands.Start);
+                                .Edge(ExecutionState.Ready, ExecutionState.Starting, Commands.Start)
-                            Edge(ExecutionState.Ready, ExecutionState.Disposed, Commands.Dispose);
+                                .Edge(ExecutionState.Ready, ExecutionState.Disposed, Commands.Dispose)
+                                .Edge(ExecutionState.Starting, ExecutionState.Running, Commands.Ok)
+                                .Edge(ExecutionState.Starting, ExecutionState.Failed, Commands.Fail)
+                                .Edge(ExecutionState.Starting, ExecutionState.Stopping, Commands.Stop)
+                                .Edge(ExecutionState.Starting, ExecutionState.Disposed, Commands.Dispose)
-                            Edge(ExecutionState.Starting, ExecutionState.Running, Commands.Ok);
+                                .Edge(ExecutionState.Running, ExecutionState.Failed, Commands.Fail)
-                            Edge(ExecutionState.Starting, ExecutionState.Failed, Commands.Fail);
+                                .Edge(ExecutionState.Running, ExecutionState.Stopping, Commands.Stop)
-                            Edge(ExecutionState.Starting, ExecutionState.Stopping, Commands.Stop);
+                                .Edge(ExecutionState.Running, ExecutionState.Disposed, Commands.Dispose)
-                            Edge(ExecutionState.Starting, ExecutionState.Disposed, Commands.Dispose);
+                                .Edge(ExecutionState.Failed, ExecutionState.Disposed, Commands.Dispose)
+                                .Edge(ExecutionState.Failed, ExecutionState.Initializing, Commands.Reset)
+                                .Edge(ExecutionState.Stopping, ExecutionState.Failed, Commands.Fail)
+                                .Edge(ExecutionState.Stopping, ExecutionState.Disposed, Commands.Dispose)
+                                .Edge(ExecutionState.Disposed, ExecutionState.Disposed, Commands.Dispose);
-                            Edge(ExecutionState.Running, ExecutionState.Failed, Commands.Fail);
+                            var reusable = common
-                            Edge(ExecutionState.Running, ExecutionState.Stopping, Commands.Stop);
+                                .Clone()
-                            Edge(ExecutionState.Running, ExecutionState.Disposed, Commands.Dispose);
+                                .Edge(ExecutionState.Stopping, ExecutionState.Ready, Commands.Ok);
-                            Edge(ExecutionState.Stopping, ExecutionState.Failed, Commands.Fail);
+                            var nonreusable = common
-                            Edge(ExecutionState.Stopping, ExecutionState.Ready, Commands.Ok);
+                                .Clone()
-                            Edge(ExecutionState.Stopping, ExecutionState.Disposed, Commands.Dispose);
+                                .Edge(ExecutionState.Stopping, ExecutionState.Disposed, Commands.Ok);
-                            Edge(ExecutionState.Failed, ExecutionState.Disposed, Commands.Dispose);
+                            NonreusableTransitions = nonreusable.States;
-                            Edge(ExecutionState.Failed, ExecutionState.Initializing, Commands.Reset);
+                            ReusableTransitions = reusable.States;
                         }
-                        static void Edge(ExecutionState s1, ExecutionState s2, Commands cmd) {
+                        readonly ExecutionState[,] m_states;
-                            _transitions[(int)s1, (int)cmd] = s2;
                         public ExecutionState State {
                             get;
                             private set;
                         }
-                        public StateMachine(ExecutionState initial) {
+                        public StateMachine(ExecutionState[,] states, ExecutionState initial) {
                             State = initial;
+                            m_states = states;
                         }
                         public bool Move(Commands cmd) {
-                            var next = _transitions[(int)State, (int)cmd];
+                            var next = m_states[(int)State, (int)cmd];
                             if (next == ExecutionState.Undefined)
                                 return false;
                             State = next;
                             return true;
                         }
                     }
                     IPromise m_pending;
                     Exception m_lastError;
                     readonly StateMachine m_stateMachine;
                     readonly bool m_reusable;
                     public event EventHandler<StateChangeEventArgs> StateChanged;
                     /// <summary>
                     /// Initializes component state.
                     /// </summary>
                     /// <param name="initialized">If set, the component initial state is <see cref="ExecutionState.Ready"/> and the component is ready to start, otherwise initialization is required.</param>
                     /// <param name="reusable">If set, the component may start after it has been stopped, otherwise the component is disposed after being stopped.</param>
                     protected RunnableComponent(bool initialized, bool reusable) {
-                        m_stateMachine = new StateMachine(initialized ? ExecutionState.Ready : ExecutionState.Created);
+                        m_stateMachine = new StateMachine(
+                            reusable ? StateMachine.ReusableTransitions : StateMachine.NonreusableTransitions,
+                            initialized ? ExecutionState.Ready : ExecutionState.Created
+                        );
                         m_reusable = reusable;
-                        DisposeTimeout = 10000;
                     }
                     /// <summary>
                     /// Initializes component state. The component created with this constructor is not reusable, i.e. it will be disposed after stop.
                     /// </summary>
                     /// <param name="initialized">If set, the component initial state is <see cref="ExecutionState.Ready"/> and the component is ready to start, otherwise initialization is required.</param>
                     protected RunnableComponent(bool initialized) : this(initialized, false) {
                     }
-                    /// <summary>
-                    /// Gets or sets the timeout to wait for the pending operation to complete. If the pending operation doesn't finish than the component will be disposed anyway.
-                    /// </summary>
-                    protected int DisposeTimeout {
-                        get;
-                        set;
                     void ThrowInvalidCommand(Commands cmd) {
                         if (m_stateMachine.State == ExecutionState.Disposed)
                             throw new ObjectDisposedException(ToString());
                         throw new InvalidOperationException(String.Format("Command {0} is not allowed in the state {1}", cmd, m_stateMachine.State));
                     }
                     bool MoveIfInState(Commands cmd, IPromise pending, Exception error, ExecutionState state) {
                         ExecutionState prev, current;
                         lock (m_stateMachine) {
                             if (m_stateMachine.State != state)
                                 return false;
                             prev = m_stateMachine.State;
                             if (!m_stateMachine.Move(cmd))
                                 ThrowInvalidCommand(cmd);
                             current = m_stateMachine.State;
                             m_pending = pending;
                             m_lastError = error;
                         }
                         if (prev != current)
                             OnStateChanged(prev, current, error);
                         return true;
                     }
                     bool MoveIfPending(Commands cmd, IPromise pending, Exception error, IPromise expected) {
                         ExecutionState prev, current;
                         lock (m_stateMachine) {
                             if (m_pending != expected)
                                 return false;
                             prev = m_stateMachine.State;
                             if (!m_stateMachine.Move(cmd))
                                 ThrowInvalidCommand(cmd);
                             current = m_stateMachine.State;
                             m_pending = pending;
                             m_lastError = error;
                         }
                         if (prev != current)
                             OnStateChanged(prev, current, error);
                         return true;
                     }
                     IPromise Move(Commands cmd, IPromise pending, Exception error) {
                         ExecutionState prev, current;
                         IPromise ret;
                         lock (m_stateMachine) {
                             prev = m_stateMachine.State;
                             if (!m_stateMachine.Move(cmd))
                                 ThrowInvalidCommand(cmd);
                             current = m_stateMachine.State;
                             ret = m_pending;
                             m_pending = pending;
                             m_lastError = error;
                         }
                         if (prev != current)
                             OnStateChanged(prev, current, error);
                         return ret;
                     }
+                    /// <summary>
+                    /// Handles the state of the component change event, raises the <see cref="StateChanged"/>  event, handles
+                    /// the transition to the <see cref="ExecutionState.Disposed"/> state (calls <see cref="Dispose(bool)"/> method).
+                    /// </summary>
+                    /// <param name="previous">The previous state</param>
+                    /// <param name="current">The current state</param>
+                    /// <param name="error">The last error if any.</param>
+                    /// <remarks>
+                    /// <para>
+                    /// If the previous state and the current state are same this method isn't called, such situiation is treated
+                    /// as the component hasn't changed it's state.
+                    /// </para>
+                    /// <para>
+                    /// When overriding this method ensure the call is made to the base implementation, otherwise it will lead to
+                    /// the wrong behavior of the component.
+                    /// </para>
+                    /// </remarks>
                     protected virtual void OnStateChanged(ExecutionState previous, ExecutionState current, Exception error) {
-                        var h = StateChanged;
+                        StateChanged.DispatchEvent(
-                        if (h != null)
+                            this,
-                            h(this, new StateChangeEventArgs {
+                            new StateChangeEventArgs {
                                 State = current,
                                 LastError = error
-                            });
+                        );
+                        if (current == ExecutionState.Disposed) {
+                            GC.SuppressFinalize(this);
+                            Dispose(true);
+                        }
                     }
                     /// <summary>
                     /// Moves the component from running to failed state.
                     /// </summary>
                     /// <param name="error">The exception which is describing the error.</param>
                     protected bool Fail(Exception error) {
                         return MoveIfInState(Commands.Fail, null, error, ExecutionState.Running);
                     }
                     /// <summary>
                     /// Tries to reset <see cref="ExecutionState.Failed"/> state to <see cref="ExecutionState.Ready"/>.
                     /// </summary>
                     /// <returns>True if component is reset to <see cref="ExecutionState.Ready"/>, false if the componet wasn't
                     /// in <see cref="ExecutionState.Failed"/> state.</returns>
                     /// <remarks>
                     /// This method checks the current state of the component and if it's in <see cref="ExecutionState.Failed"/>
                     /// moves component to <see cref="ExecutionState.Initializing"/>.
                     /// The <see cref="OnResetState()"/> is called and if this method completes succesfully the component moved
                     /// to <see cref="ExecutionState.Ready"/> state, otherwise the component is moved to <see cref="ExecutionState.Failed"/>
                     /// state. If <see cref="OnResetState()"/> throws an exception it will be propagated by this method to the caller.
                     /// </remarks>
                     protected bool ResetState() {
                         if (!MoveIfInState(Commands.Reset, null, null, ExecutionState.Failed))
                             return false;
                         try {
                             OnResetState();
                             Move(Commands.Ok, null, null);
                             return true;
                         } catch (Exception err) {
                             Move(Commands.Fail, null, err);
                             throw;
                         }
                     }
                     /// <summary>
                     /// This method is called by <see cref="ResetState"/> to reinitialize component in the failed state.
                     /// </summary>
                     /// <remarks>
                     /// Default implementation throws <see cref="NotImplementedException"/> which will cause the component
                     /// fail to reset it's state and it left in <see cref="ExecutionState.Failed"/> state.
                     /// If this method doesn't throw exceptions the component is moved to <see cref="ExecutionState.Ready"/> state.
                     /// </remarks>
                     protected virtual void OnResetState() {
                         throw new NotImplementedException();
                     }
                     IPromise InvokeAsync(Commands cmd, Func<IPromise> action, Action<IPromise, IDeferred> chain) {
                         IPromise promise = null;
                         IPromise prev;
                         var task = new ActionChainTask(action, null, null, true);
                         Action<Exception> errorOrCancel = e => {
                             if (e == null)
                                 e = new OperationCanceledException();
                             MoveIfPending(Commands.Fail, null, e, promise);
                             throw new PromiseTransientException(e);
                         };
                         promise = task.Then(
                             () => MoveIfPending(Commands.Ok, null, null, promise),
                             errorOrCancel,
                             errorOrCancel
                         );
                         prev = Move(cmd, promise, null);
                         if (prev == null)
                             task.Resolve();
                         else
                             chain(prev, task);
                         return promise;
                     }
                     #region IInitializable implementation
                     public void Initialize() {
                         Move(Commands.Init, null, null);
                         try {
                             OnInitialize();
                             Move(Commands.Ok, null, null);
                         } catch (Exception err) {
                             Move(Commands.Fail, null, err);
                             throw;
                         }
                     }
                     protected virtual void OnInitialize() {
                     }
                     #endregion
                     #region IRunnable implementation
                     public IPromise Start() {
                         return InvokeAsync(Commands.Start, OnStart, null);
                     }
                     protected virtual IPromise OnStart() {
                         return Promise.Success;
                     }
                     public IPromise Stop() {
-                        var pending = InvokeAsync(Commands.Stop, OnStop, StopPending);
+                        return InvokeAsync(Commands.Stop, OnStop, StopPending);
-                        return m_reusable ? pending : pending.Then(Dispose);
                     }
                     protected virtual IPromise OnStop() {
                         return Promise.Success;
                     }
                     /// <summary>
                     /// Stops the current operation if one exists.
                     /// </summary>
                     /// <param name="current">Current.</param>
                     /// <param name="stop">Stop.</param>
                     protected virtual void StopPending(IPromise current, IDeferred stop) {
                         if (current == null) {
                             stop.Resolve();
                         } else {
                             // связваем текущую операцию с операцией остановки
                             current.On(
                                 stop.Resolve, // если текущая операция заверщилась, то можно начинать остановку
                                 stop.Reject, // если текущая операция дала ошибку - то все плохо, нельзя продолжать
                                 e => stop.Resolve() // если текущая отменилась, то можно начинать остановку
                             );
                             // посылаем текущей операции сигнал остановки
                             current.Cancel();
                         }
                     }
                     public ExecutionState State {
                         get {
                             return m_stateMachine.State;
                         }
                     }
                     public Exception LastError {
                         get {
                             return m_lastError;
                         }
                     }
                     #endregion
                     #region IDisposable implementation
                     /// <summary>
                     /// Releases all resource used by the <see cref="Implab.Components.RunnableComponent"/> object.
                     /// </summary>
                     /// <remarks>
                     /// <para>Will not try to stop the component, it will just release all resources.
                     /// To cleanup the component gracefully use <see cref="Stop()"/> method.</para>
                     /// <para>
                     /// In normal cases the <see cref="Dispose()"/> method shouldn't be called, the call to the <see cref="Stop()"/>
                     /// method is sufficient to cleanup the component. Call <see cref="Dispose()"/> only to cleanup after errors,
                     /// especially if <see cref="Stop"/> method is failed. Using this method insted of <see cref="Stop()"/> may
                     /// lead to the data loss by the component.
                     /// </para></remarks>
                     [SuppressMessage("Microsoft.Design", "CA1063:ImplementIDisposableCorrectly", Justification = "Dipose(bool) and GC.SuppessFinalize are called")]
                     public void Dispose() {
-                        IPromise pending;
-                        lock (m_stateMachine) {
-                            if (m_stateMachine.State == ExecutionState.Disposed)
-                                return;
                         Move(Commands.Dispose, null, null);
                     }
-                        GC.SuppressFinalize(this);
-                        Dispose(true);
                     ~RunnableComponent() {
                         Dispose(false);
                     }
                     #endregion
                     /// <summary>
                     /// Releases all resources used by the component, called automatically, override this method to implement your cleanup.
                     /// </summary>
                     /// <param name="disposing">true if this method is called during normal dispose process.</param>
                     /// <param name="pending">The operation which is currenty pending</param>
                     protected virtual void Dispose(bool disposing) {
                     }
                 }
             }

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