From a06bb58c34f10cbb7c3d0862a66a59107eaa7646 Mon Sep 17 00:00:00 2001
From: Dmitry Dmitriev <you@example.com>
Date: Sun, 19 Jun 2016 13:02:56 +0300
Subject: [PATCH 01/17] Benchmark package added

---
 .../BenchmarkMultithreadingConsole.csproj                   | 6 ++++++
 .../BenchmarkMultithreadingConsole/packages.config          | 4 ++++
 2 files changed, 10 insertions(+)
 create mode 100644 BenchmarkMultithreading/BenchmarkMultithreadingConsole/packages.config

diff --git a/BenchmarkMultithreading/BenchmarkMultithreadingConsole/BenchmarkMultithreadingConsole.csproj b/BenchmarkMultithreading/BenchmarkMultithreadingConsole/BenchmarkMultithreadingConsole.csproj
index d08bb06..7e81457 100644
--- a/BenchmarkMultithreading/BenchmarkMultithreadingConsole/BenchmarkMultithreadingConsole.csproj
+++ b/BenchmarkMultithreading/BenchmarkMultithreadingConsole/BenchmarkMultithreadingConsole.csproj
@@ -33,8 +33,13 @@
     <WarningLevel>4</WarningLevel>
   </PropertyGroup>
   <ItemGroup>
+    <Reference Include="BenchmarkDotNet, Version=0.9.7.0, Culture=neutral, PublicKeyToken=aa0ca2f9092cefc4, processorArchitecture=MSIL">
+      <HintPath>..\packages\BenchmarkDotNet.0.9.7\lib\net40\BenchmarkDotNet.dll</HintPath>
+      <Private>True</Private>
+    </Reference>
     <Reference Include="System" />
     <Reference Include="System.Core" />
+    <Reference Include="System.Management" />
     <Reference Include="System.Xml.Linq" />
     <Reference Include="System.Data.DataSetExtensions" />
     <Reference Include="Microsoft.CSharp" />
@@ -48,6 +53,7 @@
   </ItemGroup>
   <ItemGroup>
     <None Include="App.config" />
+    <None Include="packages.config" />
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
diff --git a/BenchmarkMultithreading/BenchmarkMultithreadingConsole/packages.config b/BenchmarkMultithreading/BenchmarkMultithreadingConsole/packages.config
new file mode 100644
index 0000000..b237384
--- /dev/null
+++ b/BenchmarkMultithreading/BenchmarkMultithreadingConsole/packages.config
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<packages>
+  <package id="BenchmarkDotNet" version="0.9.7" targetFramework="net452" />
+</packages>
\ No newline at end of file

From b36193f427cfbe59317f456374ad2155b6dd82ec Mon Sep 17 00:00:00 2001
From: Dmitry Dmitriev <you@example.com>
Date: Sun, 19 Jun 2016 13:21:53 +0300
Subject: [PATCH 02/17] Project structure jig-sawed.

---
 .../BenchmarkMultithreading.sln               |  6 ++
 .../BenchmarkMultithreading.csproj            | 64 +++++++++++++++++++
 .../BenchmarkMultithreading/Benchmarks.cs     | 32 ++++++++++
 .../Benchmarks/Lock.cs                        | 13 ++++
 .../Benchmarks/MonitorEnter.cs                | 12 ++++
 .../Properties/AssemblyInfo.cs                | 36 +++++++++++
 .../packages.config                           |  0
 .../BenchmarkMultithreadingConsole.csproj     |  5 --
 .../BenchmarkMultithreadingConsole/Program.cs | 17 +++++
 9 files changed, 180 insertions(+), 5 deletions(-)
 create mode 100644 BenchmarkMultithreading/BenchmarkMultithreading/BenchmarkMultithreading.csproj
 create mode 100644 BenchmarkMultithreading/BenchmarkMultithreading/Benchmarks.cs
 create mode 100644 BenchmarkMultithreading/BenchmarkMultithreading/Benchmarks/Lock.cs
 create mode 100644 BenchmarkMultithreading/BenchmarkMultithreading/Benchmarks/MonitorEnter.cs
 create mode 100644 BenchmarkMultithreading/BenchmarkMultithreading/Properties/AssemblyInfo.cs
 rename BenchmarkMultithreading/{BenchmarkMultithreadingConsole => BenchmarkMultithreading}/packages.config (100%)

diff --git a/BenchmarkMultithreading/BenchmarkMultithreading.sln b/BenchmarkMultithreading/BenchmarkMultithreading.sln
index c9c674f..2ba4e2f 100644
--- a/BenchmarkMultithreading/BenchmarkMultithreading.sln
+++ b/BenchmarkMultithreading/BenchmarkMultithreading.sln
@@ -5,6 +5,8 @@ VisualStudioVersion = 14.0.25123.0
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "BenchmarkMultithreadingConsole", "BenchmarkMultithreadingConsole\BenchmarkMultithreadingConsole.csproj", "{2706D524-D2D2-411B-86C3-07EBAAF97E93}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "BenchmarkMultithreading", "BenchmarkMultithreading\BenchmarkMultithreading.csproj", "{9F098A77-241D-4E01-9B3D-29FE857E1511}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -15,6 +17,10 @@ Global
 		{2706D524-D2D2-411B-86C3-07EBAAF97E93}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{2706D524-D2D2-411B-86C3-07EBAAF97E93}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{2706D524-D2D2-411B-86C3-07EBAAF97E93}.Release|Any CPU.Build.0 = Release|Any CPU
+		{9F098A77-241D-4E01-9B3D-29FE857E1511}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{9F098A77-241D-4E01-9B3D-29FE857E1511}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{9F098A77-241D-4E01-9B3D-29FE857E1511}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{9F098A77-241D-4E01-9B3D-29FE857E1511}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
diff --git a/BenchmarkMultithreading/BenchmarkMultithreading/BenchmarkMultithreading.csproj b/BenchmarkMultithreading/BenchmarkMultithreading/BenchmarkMultithreading.csproj
new file mode 100644
index 0000000..130b409
--- /dev/null
+++ b/BenchmarkMultithreading/BenchmarkMultithreading/BenchmarkMultithreading.csproj
@@ -0,0 +1,64 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProjectGuid>{9F098A77-241D-4E01-9B3D-29FE857E1511}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>BenchmarkMultithreading</RootNamespace>
+    <AssemblyName>BenchmarkMultithreading</AssemblyName>
+    <TargetFrameworkVersion>v4.5.2</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+  </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="BenchmarkDotNet, Version=0.9.7.0, Culture=neutral, PublicKeyToken=aa0ca2f9092cefc4, processorArchitecture=MSIL">
+      <HintPath>..\packages\BenchmarkDotNet.0.9.7\lib\net40\BenchmarkDotNet.dll</HintPath>
+      <Private>True</Private>
+    </Reference>
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Management" />
+    <Reference Include="System.Xml.Linq" />
+    <Reference Include="System.Data.DataSetExtensions" />
+    <Reference Include="Microsoft.CSharp" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Net.Http" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="Benchmarks.cs" />
+    <Compile Include="Benchmarks\Lock.cs" />
+    <Compile Include="Benchmarks\MonitorEnter.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="packages.config" />
+  </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>
\ No newline at end of file
diff --git a/BenchmarkMultithreading/BenchmarkMultithreading/Benchmarks.cs b/BenchmarkMultithreading/BenchmarkMultithreading/Benchmarks.cs
new file mode 100644
index 0000000..a62f015
--- /dev/null
+++ b/BenchmarkMultithreading/BenchmarkMultithreading/Benchmarks.cs
@@ -0,0 +1,32 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using BenchmarkDotNet.Attributes;
+
+namespace BenchmarkMultithreading
+{
+  public class Benchmarks
+  {
+    #region public methods
+    [Setup]
+    public void Setup()
+    {
+
+    }
+
+    [Benchmark]
+    public void Lock()
+    {
+
+    }
+
+    [Benchmark]
+    public void MonitorEnter()
+    {
+
+    }
+    #endregion
+  }
+}
diff --git a/BenchmarkMultithreading/BenchmarkMultithreading/Benchmarks/Lock.cs b/BenchmarkMultithreading/BenchmarkMultithreading/Benchmarks/Lock.cs
new file mode 100644
index 0000000..186ddd8
--- /dev/null
+++ b/BenchmarkMultithreading/BenchmarkMultithreading/Benchmarks/Lock.cs
@@ -0,0 +1,13 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace BenchmarkMultithreading.Benchmarks
+{
+  class Lock
+  {
+
+  }
+}
diff --git a/BenchmarkMultithreading/BenchmarkMultithreading/Benchmarks/MonitorEnter.cs b/BenchmarkMultithreading/BenchmarkMultithreading/Benchmarks/MonitorEnter.cs
new file mode 100644
index 0000000..60a28e7
--- /dev/null
+++ b/BenchmarkMultithreading/BenchmarkMultithreading/Benchmarks/MonitorEnter.cs
@@ -0,0 +1,12 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace BenchmarkMultithreading.Benchmarks
+{
+  class MonitorEnter
+  {
+  }
+}
diff --git a/BenchmarkMultithreading/BenchmarkMultithreading/Properties/AssemblyInfo.cs b/BenchmarkMultithreading/BenchmarkMultithreading/Properties/AssemblyInfo.cs
new file mode 100644
index 0000000..1378edf
--- /dev/null
+++ b/BenchmarkMultithreading/BenchmarkMultithreading/Properties/AssemblyInfo.cs
@@ -0,0 +1,36 @@
+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("BenchmarkMultithreading")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("BenchmarkMultithreading")]
+[assembly: AssemblyCopyright("Copyright ©  2016")]
+[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("9f098a77-241d-4e01-9b3d-29fe857e1511")]
+
+// 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.*")]
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]
diff --git a/BenchmarkMultithreading/BenchmarkMultithreadingConsole/packages.config b/BenchmarkMultithreading/BenchmarkMultithreading/packages.config
similarity index 100%
rename from BenchmarkMultithreading/BenchmarkMultithreadingConsole/packages.config
rename to BenchmarkMultithreading/BenchmarkMultithreading/packages.config
diff --git a/BenchmarkMultithreading/BenchmarkMultithreadingConsole/BenchmarkMultithreadingConsole.csproj b/BenchmarkMultithreading/BenchmarkMultithreadingConsole/BenchmarkMultithreadingConsole.csproj
index 7e81457..e92d2e9 100644
--- a/BenchmarkMultithreading/BenchmarkMultithreadingConsole/BenchmarkMultithreadingConsole.csproj
+++ b/BenchmarkMultithreading/BenchmarkMultithreadingConsole/BenchmarkMultithreadingConsole.csproj
@@ -33,10 +33,6 @@
     <WarningLevel>4</WarningLevel>
   </PropertyGroup>
   <ItemGroup>
-    <Reference Include="BenchmarkDotNet, Version=0.9.7.0, Culture=neutral, PublicKeyToken=aa0ca2f9092cefc4, processorArchitecture=MSIL">
-      <HintPath>..\packages\BenchmarkDotNet.0.9.7\lib\net40\BenchmarkDotNet.dll</HintPath>
-      <Private>True</Private>
-    </Reference>
     <Reference Include="System" />
     <Reference Include="System.Core" />
     <Reference Include="System.Management" />
@@ -53,7 +49,6 @@
   </ItemGroup>
   <ItemGroup>
     <None Include="App.config" />
-    <None Include="packages.config" />
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
diff --git a/BenchmarkMultithreading/BenchmarkMultithreadingConsole/Program.cs b/BenchmarkMultithreading/BenchmarkMultithreadingConsole/Program.cs
index e8e4c3e..f6173e3 100644
--- a/BenchmarkMultithreading/BenchmarkMultithreadingConsole/Program.cs
+++ b/BenchmarkMultithreading/BenchmarkMultithreadingConsole/Program.cs
@@ -10,6 +10,23 @@ class Program
   {
     static void Main(string[] args)
     {
+      foreach (var arg in args)
+      {
+        switch (arg)
+        {
+          case "run":
+          {
+
+            break;
+          }
+
+          case "pause":
+          {
+
+            break;
+          }
+        }
+      }
     }
   }
 }

From 7a085a2467e77fb41b8f04e6d8b0eaccf6b159f9 Mon Sep 17 00:00:00 2001
From: Dmitry Dmitriev <you@example.com>
Date: Sun, 19 Jun 2016 13:39:10 +0300
Subject: [PATCH 03/17] Benchmark runner provided.

---
 .../{Benchmarks.cs => BenchmarkContainer.cs}          |  2 +-
 .../BenchmarkMultithreading.csproj                    |  2 +-
 .../Benchmarks/MonitorEnter.cs                        |  1 +
 .../BenchmarkMultithreadingConsole.csproj             | 11 +++++++++++
 .../BenchmarkMultithreadingConsole/Program.cs         |  9 +++++++--
 .../BenchmarkMultithreadingConsole/packages.config    |  4 ++++
 6 files changed, 25 insertions(+), 4 deletions(-)
 rename BenchmarkMultithreading/BenchmarkMultithreading/{Benchmarks.cs => BenchmarkContainer.cs} (92%)
 create mode 100644 BenchmarkMultithreading/BenchmarkMultithreadingConsole/packages.config

diff --git a/BenchmarkMultithreading/BenchmarkMultithreading/Benchmarks.cs b/BenchmarkMultithreading/BenchmarkMultithreading/BenchmarkContainer.cs
similarity index 92%
rename from BenchmarkMultithreading/BenchmarkMultithreading/Benchmarks.cs
rename to BenchmarkMultithreading/BenchmarkMultithreading/BenchmarkContainer.cs
index a62f015..9b9de1b 100644
--- a/BenchmarkMultithreading/BenchmarkMultithreading/Benchmarks.cs
+++ b/BenchmarkMultithreading/BenchmarkMultithreading/BenchmarkContainer.cs
@@ -7,7 +7,7 @@
 
 namespace BenchmarkMultithreading
 {
-  public class Benchmarks
+  public class BenchmarkContainer
   {
     #region public methods
     [Setup]
diff --git a/BenchmarkMultithreading/BenchmarkMultithreading/BenchmarkMultithreading.csproj b/BenchmarkMultithreading/BenchmarkMultithreading/BenchmarkMultithreading.csproj
index 130b409..10f6c83 100644
--- a/BenchmarkMultithreading/BenchmarkMultithreading/BenchmarkMultithreading.csproj
+++ b/BenchmarkMultithreading/BenchmarkMultithreading/BenchmarkMultithreading.csproj
@@ -45,7 +45,7 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="Benchmarks.cs" />
+    <Compile Include="BenchmarkContainer.cs" />
     <Compile Include="Benchmarks\Lock.cs" />
     <Compile Include="Benchmarks\MonitorEnter.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
diff --git a/BenchmarkMultithreading/BenchmarkMultithreading/Benchmarks/MonitorEnter.cs b/BenchmarkMultithreading/BenchmarkMultithreading/Benchmarks/MonitorEnter.cs
index 60a28e7..51cb966 100644
--- a/BenchmarkMultithreading/BenchmarkMultithreading/Benchmarks/MonitorEnter.cs
+++ b/BenchmarkMultithreading/BenchmarkMultithreading/Benchmarks/MonitorEnter.cs
@@ -8,5 +8,6 @@ namespace BenchmarkMultithreading.Benchmarks
 {
   class MonitorEnter
   {
+
   }
 }
diff --git a/BenchmarkMultithreading/BenchmarkMultithreadingConsole/BenchmarkMultithreadingConsole.csproj b/BenchmarkMultithreading/BenchmarkMultithreadingConsole/BenchmarkMultithreadingConsole.csproj
index e92d2e9..31e19aa 100644
--- a/BenchmarkMultithreading/BenchmarkMultithreadingConsole/BenchmarkMultithreadingConsole.csproj
+++ b/BenchmarkMultithreading/BenchmarkMultithreadingConsole/BenchmarkMultithreadingConsole.csproj
@@ -33,6 +33,10 @@
     <WarningLevel>4</WarningLevel>
   </PropertyGroup>
   <ItemGroup>
+    <Reference Include="BenchmarkDotNet, Version=0.9.7.0, Culture=neutral, PublicKeyToken=aa0ca2f9092cefc4, processorArchitecture=MSIL">
+      <HintPath>..\packages\BenchmarkDotNet.0.9.7\lib\net40\BenchmarkDotNet.dll</HintPath>
+      <Private>True</Private>
+    </Reference>
     <Reference Include="System" />
     <Reference Include="System.Core" />
     <Reference Include="System.Management" />
@@ -49,6 +53,13 @@
   </ItemGroup>
   <ItemGroup>
     <None Include="App.config" />
+    <None Include="packages.config" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\BenchmarkMultithreading\BenchmarkMultithreading.csproj">
+      <Project>{9f098a77-241d-4e01-9b3d-29fe857e1511}</Project>
+      <Name>BenchmarkMultithreading</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. 
diff --git a/BenchmarkMultithreading/BenchmarkMultithreadingConsole/Program.cs b/BenchmarkMultithreading/BenchmarkMultithreadingConsole/Program.cs
index f6173e3..0a596f3 100644
--- a/BenchmarkMultithreading/BenchmarkMultithreadingConsole/Program.cs
+++ b/BenchmarkMultithreading/BenchmarkMultithreadingConsole/Program.cs
@@ -3,6 +3,10 @@
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
+using BenchmarkDotNet.Running;
+
+using BenchmarkMultithreading;
+
 
 namespace BenchmarkMultithreadingConsole
 {
@@ -16,13 +20,14 @@ static void Main(string[] args)
         {
           case "run":
           {
-
+            BenchmarkRunner.Run<BenchmarkContainer>();
             break;
           }
 
           case "pause":
           {
-
+            Console.WriteLine("Press ENTER to release console.");
+            Console.ReadKey();
             break;
           }
         }
diff --git a/BenchmarkMultithreading/BenchmarkMultithreadingConsole/packages.config b/BenchmarkMultithreading/BenchmarkMultithreadingConsole/packages.config
new file mode 100644
index 0000000..b237384
--- /dev/null
+++ b/BenchmarkMultithreading/BenchmarkMultithreadingConsole/packages.config
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<packages>
+  <package id="BenchmarkDotNet" version="0.9.7" targetFramework="net452" />
+</packages>
\ No newline at end of file

From c176c86c9627148538dd3f8de8f7efb33fcbc951 Mon Sep 17 00:00:00 2001
From: Dmitry Dmitriev <you@example.com>
Date: Sun, 19 Jun 2016 14:04:17 +0300
Subject: [PATCH 04/17] Domain objects for testing provided.

---
 .../BenchmarkMultithreading.csproj            |  3 +++
 .../Benchmarks/Lock.cs                        | 12 ++++++++++-
 .../Benchmarks/MonitorEnter.cs                | 20 +++++++++++++++++--
 .../BenchmarkMultithreading/IBenchmarkable.cs |  8 ++++++++
 .../TestDomainObjects/Client.cs               | 13 ++++++++++++
 .../TestDomainObjects/Credit.cs               | 15 ++++++++++++++
 6 files changed, 68 insertions(+), 3 deletions(-)
 create mode 100644 BenchmarkMultithreading/BenchmarkMultithreading/IBenchmarkable.cs
 create mode 100644 BenchmarkMultithreading/BenchmarkMultithreading/TestDomainObjects/Client.cs
 create mode 100644 BenchmarkMultithreading/BenchmarkMultithreading/TestDomainObjects/Credit.cs

diff --git a/BenchmarkMultithreading/BenchmarkMultithreading/BenchmarkMultithreading.csproj b/BenchmarkMultithreading/BenchmarkMultithreading/BenchmarkMultithreading.csproj
index 10f6c83..a5e3d31 100644
--- a/BenchmarkMultithreading/BenchmarkMultithreading/BenchmarkMultithreading.csproj
+++ b/BenchmarkMultithreading/BenchmarkMultithreading/BenchmarkMultithreading.csproj
@@ -46,9 +46,12 @@
   </ItemGroup>
   <ItemGroup>
     <Compile Include="BenchmarkContainer.cs" />
+    <Compile Include="IBenchmarkable.cs" />
     <Compile Include="Benchmarks\Lock.cs" />
     <Compile Include="Benchmarks\MonitorEnter.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="TestDomainObjects\Client.cs" />
+    <Compile Include="TestDomainObjects\Credit.cs" />
   </ItemGroup>
   <ItemGroup>
     <None Include="packages.config" />
diff --git a/BenchmarkMultithreading/BenchmarkMultithreading/Benchmarks/Lock.cs b/BenchmarkMultithreading/BenchmarkMultithreading/Benchmarks/Lock.cs
index 186ddd8..0634659 100644
--- a/BenchmarkMultithreading/BenchmarkMultithreading/Benchmarks/Lock.cs
+++ b/BenchmarkMultithreading/BenchmarkMultithreading/Benchmarks/Lock.cs
@@ -6,8 +6,18 @@
 
 namespace BenchmarkMultithreading.Benchmarks
 {
-  class Lock
+  class Lock : IBenchmarkable
   {
+    #region IBenchmarkable
+    public void Run()
+    {
+      throw new NotImplementedException();
+    }
 
+    public void Setup()
+    {
+      throw new NotImplementedException();
+    }
+    #endregion
   }
 }
diff --git a/BenchmarkMultithreading/BenchmarkMultithreading/Benchmarks/MonitorEnter.cs b/BenchmarkMultithreading/BenchmarkMultithreading/Benchmarks/MonitorEnter.cs
index 51cb966..0c6fb26 100644
--- a/BenchmarkMultithreading/BenchmarkMultithreading/Benchmarks/MonitorEnter.cs
+++ b/BenchmarkMultithreading/BenchmarkMultithreading/Benchmarks/MonitorEnter.cs
@@ -1,4 +1,5 @@
-using System;
+using BenchmarkMultithreading.TestDomainObjects;
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
@@ -6,8 +7,23 @@
 
 namespace BenchmarkMultithreading.Benchmarks
 {
-  class MonitorEnter
+  class MonitorEnter : IBenchmarkable
   {
+    #region private fields
+    private Client data;
+    #endregion
+
+    #region IBenchmarkable
+    public void Run()
+    {
+      throw new NotImplementedException();
+    }
+
+    public void Setup()
+    {
+      throw new NotImplementedException();
+    }
+    #endregion
 
   }
 }
diff --git a/BenchmarkMultithreading/BenchmarkMultithreading/IBenchmarkable.cs b/BenchmarkMultithreading/BenchmarkMultithreading/IBenchmarkable.cs
new file mode 100644
index 0000000..efdfa01
--- /dev/null
+++ b/BenchmarkMultithreading/BenchmarkMultithreading/IBenchmarkable.cs
@@ -0,0 +1,8 @@
+namespace BenchmarkMultithreading
+{
+  internal interface IBenchmarkable
+  {
+    void Run();
+    void Setup();
+  }
+}
\ No newline at end of file
diff --git a/BenchmarkMultithreading/BenchmarkMultithreading/TestDomainObjects/Client.cs b/BenchmarkMultithreading/BenchmarkMultithreading/TestDomainObjects/Client.cs
new file mode 100644
index 0000000..be3ea62
--- /dev/null
+++ b/BenchmarkMultithreading/BenchmarkMultithreading/TestDomainObjects/Client.cs
@@ -0,0 +1,13 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace BenchmarkMultithreading.TestDomainObjects
+{
+  internal class Client
+  {
+    public string Name { get; set; }
+  }
+}
diff --git a/BenchmarkMultithreading/BenchmarkMultithreading/TestDomainObjects/Credit.cs b/BenchmarkMultithreading/BenchmarkMultithreading/TestDomainObjects/Credit.cs
new file mode 100644
index 0000000..98c43f5
--- /dev/null
+++ b/BenchmarkMultithreading/BenchmarkMultithreading/TestDomainObjects/Credit.cs
@@ -0,0 +1,15 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace BenchmarkMultithreading.TestDomainObjects
+{
+  internal class Credit
+  {
+    public int Amount { get; set; }
+    public byte Security { get; set; }
+    public List<Client> clients { get; set; } = new List<Client>();
+  }
+}

From 4ac477f3ddd89ab8a3c051ba43cb8fadc6eb4a4f Mon Sep 17 00:00:00 2001
From: Dmitry Dmitriev <you@example.com>
Date: Sun, 19 Jun 2016 14:31:15 +0300
Subject: [PATCH 05/17] MonitorEnter benchmark provided.

---
 .../Benchmarks/MonitorEnter.cs                | 40 +++++++++++++++++--
 .../TestDomainObjects/Credit.cs               |  2 +-
 2 files changed, 38 insertions(+), 4 deletions(-)

diff --git a/BenchmarkMultithreading/BenchmarkMultithreading/Benchmarks/MonitorEnter.cs b/BenchmarkMultithreading/BenchmarkMultithreading/Benchmarks/MonitorEnter.cs
index 0c6fb26..b9fb0dd 100644
--- a/BenchmarkMultithreading/BenchmarkMultithreading/Benchmarks/MonitorEnter.cs
+++ b/BenchmarkMultithreading/BenchmarkMultithreading/Benchmarks/MonitorEnter.cs
@@ -3,6 +3,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
+using System.Threading;
 using System.Threading.Tasks;
 
 namespace BenchmarkMultithreading.Benchmarks
@@ -10,18 +11,51 @@ namespace BenchmarkMultithreading.Benchmarks
   class MonitorEnter : IBenchmarkable
   {
     #region private fields
-    private Client data;
+    private Credit credits;
+
+    public int ThreadCount { get { return 4; } }
+
+    public int WritesCount { get { return 10; } }
     #endregion
 
     #region IBenchmarkable
     public void Run()
     {
-      throw new NotImplementedException();
+      for (int i = 0; i < ThreadCount; i++)
+      {
+        Thread thread = new Thread(
+          new ThreadStart(() =>
+          {
+            for (int j = 0; j < WritesCount; j++)
+            {
+
+            }
+            Monitor.Enter(credits);
+            try
+            {
+              Client client =
+                new Client()
+                {
+                  Name = "Kozlov Ivan Petrovich"
+                };
+              credits.clients.Add(client);
+            }
+            finally
+            {
+              Monitor.Exit(credits);
+            }
+          }));
+        thread.Start();
+      }
     }
 
     public void Setup()
     {
-      throw new NotImplementedException();
+      credits = new Credit()
+      {
+        Security = 810,
+        Amount = 1000000
+      };
     }
     #endregion
 
diff --git a/BenchmarkMultithreading/BenchmarkMultithreading/TestDomainObjects/Credit.cs b/BenchmarkMultithreading/BenchmarkMultithreading/TestDomainObjects/Credit.cs
index 98c43f5..78d045a 100644
--- a/BenchmarkMultithreading/BenchmarkMultithreading/TestDomainObjects/Credit.cs
+++ b/BenchmarkMultithreading/BenchmarkMultithreading/TestDomainObjects/Credit.cs
@@ -9,7 +9,7 @@ namespace BenchmarkMultithreading.TestDomainObjects
   internal class Credit
   {
     public int Amount { get; set; }
-    public byte Security { get; set; }
+    public short Security { get; set; }
     public List<Client> clients { get; set; } = new List<Client>();
   }
 }

From f5b6b31e23708fd1b86f9220e22b0786b82f7cdc Mon Sep 17 00:00:00 2001
From: Max Davydov <maks4171@gmail.com>
Date: Sun, 19 Jun 2016 16:00:20 +0300
Subject: [PATCH 06/17] List (with lock) and ConcurrentBag comparsion

---
 .../BenchmarkMultithreadingConsole/Program.cs | 77 +++++++++++++++++++
 1 file changed, 77 insertions(+)

diff --git a/BenchmarkMultithreading/BenchmarkMultithreadingConsole/Program.cs b/BenchmarkMultithreading/BenchmarkMultithreadingConsole/Program.cs
index e8e4c3e..c4faa37 100644
--- a/BenchmarkMultithreading/BenchmarkMultithreadingConsole/Program.cs
+++ b/BenchmarkMultithreading/BenchmarkMultithreadingConsole/Program.cs
@@ -1,15 +1,92 @@
 using System;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
+using System.Threading;
 using System.Threading.Tasks;
 
 namespace BenchmarkMultithreadingConsole
 {
   class Program
   {
+    #region [.consts]
+    const int NEW_ROWS_NUMBER = 5000;
+    const int THREADS_NUMBER = 10;
+    const int INIT_ROWS_NUMBER = 10000;
+    #endregion
+
+    #region [.init]
+    private static List<string> unsafeSource = new List<string>();
+    private static ConcurrentBag<string> safeSource = new ConcurrentBag<string>();
+    private static object SyncRoot = new object();
+    private static ulong changesSum = 0;
+    private static ulong changesSumConcurrent = 0;
+
+    static Thread[] threadsLock = new Thread[THREADS_NUMBER];
+    static Thread[] threadsConcurrent = new Thread[THREADS_NUMBER]; 
+    #endregion
+
     static void Main(string[] args)
     {
+        fillSources();
+        Console.WriteLine("Number of elements at collection: {0}", unsafeSource.Count);
+
+        threadsInit();
+
+        //start threads
+        for (int i = 0; i < THREADS_NUMBER; i++)
+        {
+            threadsLock[i].Start();
+            threadsConcurrent[i].Start();
+        }
+
+        Console.ReadKey();       
+    }
+
+    public static void changeSourceWithLock()
+    {
+        for (int i = 0; i < NEW_ROWS_NUMBER; i++)
+        {
+            lock (SyncRoot)
+            {
+                unsafeSource.Add("with lock");
+                changesSum++;
+            } 
+        }
+    }
+
+    public static void changeSource()
+    {
+        for (int i = 0; i < NEW_ROWS_NUMBER; i++)
+        {
+            safeSource.Add("with concurrent");
+            changesSumConcurrent++; 
+        }
+    }
+
+    public static void threadsInit()
+    {
+        for (int i = 0; i < THREADS_NUMBER; i++)
+        {
+            ThreadStart t1s = new ThreadStart(changeSourceWithLock);
+            Thread t1 = new Thread(t1s);
+            threadsLock[i] = t1;
+
+            ThreadStart t2s = new ThreadStart(changeSource);
+            Thread t2 = new Thread(t2s);
+            threadsConcurrent[i] = t2;
+        }
+    }
+
+    public static void fillSources()
+    {
+        for (int i = 0; i < INIT_ROWS_NUMBER; i++)
+        {
+            var str = "default" + i;
+            unsafeSource.Add(str);
+            safeSource.Add(str);
+        }
     }
   }
 }

From 12a80dfe92ac4ef0817886dd94bd51b8b9ee6833 Mon Sep 17 00:00:00 2001
From: Max Davydov <maks4171@gmail.com>
Date: Sun, 19 Jun 2016 16:16:59 +0300
Subject: [PATCH 07/17] Add internal dependecies

---
 BenchmarkMultithreading/BenchmarkMultithreading.sln            | 3 +++
 .../BenchmarkMultithreadingConsole.csproj                      | 1 +
 2 files changed, 4 insertions(+)

diff --git a/BenchmarkMultithreading/BenchmarkMultithreading.sln b/BenchmarkMultithreading/BenchmarkMultithreading.sln
index 2ba4e2f..2d0e79e 100644
--- a/BenchmarkMultithreading/BenchmarkMultithreading.sln
+++ b/BenchmarkMultithreading/BenchmarkMultithreading.sln
@@ -4,6 +4,9 @@ Microsoft Visual Studio Solution File, Format Version 12.00
 VisualStudioVersion = 14.0.25123.0
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "BenchmarkMultithreadingConsole", "BenchmarkMultithreadingConsole\BenchmarkMultithreadingConsole.csproj", "{2706D524-D2D2-411B-86C3-07EBAAF97E93}"
+	ProjectSection(ProjectDependencies) = postProject
+		{9F098A77-241D-4E01-9B3D-29FE857E1511} = {9F098A77-241D-4E01-9B3D-29FE857E1511}
+	EndProjectSection
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "BenchmarkMultithreading", "BenchmarkMultithreading\BenchmarkMultithreading.csproj", "{9F098A77-241D-4E01-9B3D-29FE857E1511}"
 EndProject
diff --git a/BenchmarkMultithreading/BenchmarkMultithreadingConsole/BenchmarkMultithreadingConsole.csproj b/BenchmarkMultithreading/BenchmarkMultithreadingConsole/BenchmarkMultithreadingConsole.csproj
index 31e19aa..e803b3c 100644
--- a/BenchmarkMultithreading/BenchmarkMultithreadingConsole/BenchmarkMultithreadingConsole.csproj
+++ b/BenchmarkMultithreading/BenchmarkMultithreadingConsole/BenchmarkMultithreadingConsole.csproj
@@ -36,6 +36,7 @@
     <Reference Include="BenchmarkDotNet, Version=0.9.7.0, Culture=neutral, PublicKeyToken=aa0ca2f9092cefc4, processorArchitecture=MSIL">
       <HintPath>..\packages\BenchmarkDotNet.0.9.7\lib\net40\BenchmarkDotNet.dll</HintPath>
       <Private>True</Private>
+      <EmbedInteropTypes>False</EmbedInteropTypes>
     </Reference>
     <Reference Include="System" />
     <Reference Include="System.Core" />

From 7999911e1783bda5bcb6b39a4c8401325abb42a8 Mon Sep 17 00:00:00 2001
From: Max Davydov <maks4171@gmail.com>
Date: Sun, 19 Jun 2016 16:00:20 +0300
Subject: [PATCH 08/17] List (with lock) and ConcurrentBag comparsion

---
 .../BenchmarkMultithreadingConsole/Program.cs | 91 +++++++++++++++----
 1 file changed, 75 insertions(+), 16 deletions(-)

diff --git a/BenchmarkMultithreading/BenchmarkMultithreadingConsole/Program.cs b/BenchmarkMultithreading/BenchmarkMultithreadingConsole/Program.cs
index 0a596f3..70bd2fc 100644
--- a/BenchmarkMultithreading/BenchmarkMultithreadingConsole/Program.cs
+++ b/BenchmarkMultithreading/BenchmarkMultithreadingConsole/Program.cs
@@ -1,7 +1,9 @@
 using System;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
+using System.Threading;
 using System.Threading.Tasks;
 using BenchmarkDotNet.Running;
 
@@ -12,26 +14,83 @@ namespace BenchmarkMultithreadingConsole
 {
   class Program
   {
+    #region [.consts]
+    const int NEW_ROWS_NUMBER = 5000;
+    const int THREADS_NUMBER = 10;
+    const int INIT_ROWS_NUMBER = 10000;
+    #endregion
+
+    #region [.init]
+    private static List<string> unsafeSource = new List<string>();
+    private static ConcurrentBag<string> safeSource = new ConcurrentBag<string>();
+    private static object SyncRoot = new object();
+    private static ulong changesSum = 0;
+    private static ulong changesSumConcurrent = 0;
+
+    static Thread[] threadsLock = new Thread[THREADS_NUMBER];
+    static Thread[] threadsConcurrent = new Thread[THREADS_NUMBER]; 
+    #endregion
+
     static void Main(string[] args)
     {
-      foreach (var arg in args)
-      {
-        switch (arg)
+        fillSources();
+        Console.WriteLine("Number of elements at collection: {0}", unsafeSource.Count);
+
+        threadsInit();
+
+        //start threads
+        for (int i = 0; i < THREADS_NUMBER; i++)
+        {
+            threadsLock[i].Start();
+            threadsConcurrent[i].Start();
+        }
+
+        Console.ReadKey();       
+    }
+
+    public static void changeSourceWithLock()
+    {
+        for (int i = 0; i < NEW_ROWS_NUMBER; i++)
+        {
+            lock (SyncRoot)
+            {
+                unsafeSource.Add("with lock");
+                changesSum++;
+            } 
+        }
+    }
+
+    public static void changeSource()
+    {
+        for (int i = 0; i < NEW_ROWS_NUMBER; i++)
+        {
+            safeSource.Add("with concurrent");
+            changesSumConcurrent++; 
+        }
+    }
+
+    public static void threadsInit()
+    {
+        for (int i = 0; i < THREADS_NUMBER; i++)
+        {
+            ThreadStart t1s = new ThreadStart(changeSourceWithLock);
+            Thread t1 = new Thread(t1s);
+            threadsLock[i] = t1;
+
+            ThreadStart t2s = new ThreadStart(changeSource);
+            Thread t2 = new Thread(t2s);
+            threadsConcurrent[i] = t2;
+        }
+    }
+
+    public static void fillSources()
+    {
+        for (int i = 0; i < INIT_ROWS_NUMBER; i++)
         {
-          case "run":
-          {
-            BenchmarkRunner.Run<BenchmarkContainer>();
-            break;
-          }
-
-          case "pause":
-          {
-            Console.WriteLine("Press ENTER to release console.");
-            Console.ReadKey();
-            break;
-          }
+            var str = "default" + i;
+            unsafeSource.Add(str);
+            safeSource.Add(str);
         }
-      }
     }
   }
 }

From 19bab9ab31674c846bb7fe2d65c283eca71973fd Mon Sep 17 00:00:00 2001
From: Max Davydov <maks4171@gmail.com>
Date: Sun, 19 Jun 2016 16:26:06 +0300
Subject: [PATCH 09/17] Light refactor

---
 .../BenchmarkMultithreadingConsole/Program.cs              | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/BenchmarkMultithreading/BenchmarkMultithreadingConsole/Program.cs b/BenchmarkMultithreading/BenchmarkMultithreadingConsole/Program.cs
index 70bd2fc..13c2c94 100644
--- a/BenchmarkMultithreading/BenchmarkMultithreadingConsole/Program.cs
+++ b/BenchmarkMultithreading/BenchmarkMultithreadingConsole/Program.cs
@@ -32,6 +32,11 @@ class Program
     #endregion
 
     static void Main(string[] args)
+    {
+    
+    }
+
+    public static void start()
     {
         fillSources();
         Console.WriteLine("Number of elements at collection: {0}", unsafeSource.Count);
@@ -45,7 +50,7 @@ static void Main(string[] args)
             threadsConcurrent[i].Start();
         }
 
-        Console.ReadKey();       
+        //Console.ReadKey();
     }
 
     public static void changeSourceWithLock()

From 16017686bb56d83293c8e2c99b9f2c814d559a81 Mon Sep 17 00:00:00 2001
From: Max Davydov <maks4171@gmail.com>
Date: Sun, 19 Jun 2016 16:29:16 +0300
Subject: [PATCH 10/17] After merge master-develop

---
 .../BenchmarkMultithreadingConsole/Program.cs | 29 ++++++++++++++-----
 1 file changed, 21 insertions(+), 8 deletions(-)

diff --git a/BenchmarkMultithreading/BenchmarkMultithreadingConsole/Program.cs b/BenchmarkMultithreading/BenchmarkMultithreadingConsole/Program.cs
index 13c2c94..8aca050 100644
--- a/BenchmarkMultithreading/BenchmarkMultithreadingConsole/Program.cs
+++ b/BenchmarkMultithreading/BenchmarkMultithreadingConsole/Program.cs
@@ -1,18 +1,13 @@
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
-using System.Linq;
-using System.Text;
 using System.Threading;
-using System.Threading.Tasks;
 using BenchmarkDotNet.Running;
-
 using BenchmarkMultithreading;
 
-
 namespace BenchmarkMultithreadingConsole
 {
-  class Program
+    class Program
   {
     #region [.consts]
     const int NEW_ROWS_NUMBER = 5000;
@@ -33,8 +28,26 @@ class Program
 
     static void Main(string[] args)
     {
-    
-    }
+        foreach (var arg in args)
+        {
+            switch (arg)
+            {
+                case "run":
+                    {
+                        BenchmarkRunner.Run<BenchmarkContainer>();
+                        start();
+                        break;
+                    }
+
+                case "pause":
+                    {
+                        Console.WriteLine("Press ENTER to release console.");
+                        Console.ReadKey();
+                        break;
+                    }
+            }
+        }
+        }
 
     public static void start()
     {

From cb21c2c7f393a4bfb20167dac8087415ec795d31 Mon Sep 17 00:00:00 2001
From: Max Davydov <maks4171@gmail.com>
Date: Sun, 19 Jun 2016 18:35:23 +0300
Subject: [PATCH 11/17] Refactor comparsion collections

---
 .../BenchmarkContainer.cs                     |  14 +--
 .../BenchmarkMultithreading.csproj            |   1 +
 .../Benchmarks/ComparsionCollection.cs        |  98 +++++++++++++++
 .../Benchmarks/MonitorEnter.cs                |   7 +-
 .../BenchmarkMultithreadingConsole/Program.cs | 116 +++---------------
 5 files changed, 124 insertions(+), 112 deletions(-)
 create mode 100644 BenchmarkMultithreading/BenchmarkMultithreading/Benchmarks/ComparsionCollection.cs

diff --git a/BenchmarkMultithreading/BenchmarkMultithreading/BenchmarkContainer.cs b/BenchmarkMultithreading/BenchmarkMultithreading/BenchmarkContainer.cs
index 9b9de1b..4b1b437 100644
--- a/BenchmarkMultithreading/BenchmarkMultithreading/BenchmarkContainer.cs
+++ b/BenchmarkMultithreading/BenchmarkMultithreading/BenchmarkContainer.cs
@@ -1,13 +1,8 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using BenchmarkDotNet.Attributes;
+using BenchmarkDotNet.Attributes;
 
 namespace BenchmarkMultithreading
 {
-  public class BenchmarkContainer
+    public class BenchmarkContainer
   {
     #region public methods
     [Setup]
@@ -26,6 +21,11 @@ public void Lock()
     public void MonitorEnter()
     {
 
+    }
+    [Benchmark]
+    public void ComparsionCollection()
+    {
+
     }
     #endregion
   }
diff --git a/BenchmarkMultithreading/BenchmarkMultithreading/BenchmarkMultithreading.csproj b/BenchmarkMultithreading/BenchmarkMultithreading/BenchmarkMultithreading.csproj
index a5e3d31..fc7bf85 100644
--- a/BenchmarkMultithreading/BenchmarkMultithreading/BenchmarkMultithreading.csproj
+++ b/BenchmarkMultithreading/BenchmarkMultithreading/BenchmarkMultithreading.csproj
@@ -46,6 +46,7 @@
   </ItemGroup>
   <ItemGroup>
     <Compile Include="BenchmarkContainer.cs" />
+    <Compile Include="Benchmarks\ComparsionCollection.cs" />
     <Compile Include="IBenchmarkable.cs" />
     <Compile Include="Benchmarks\Lock.cs" />
     <Compile Include="Benchmarks\MonitorEnter.cs" />
diff --git a/BenchmarkMultithreading/BenchmarkMultithreading/Benchmarks/ComparsionCollection.cs b/BenchmarkMultithreading/BenchmarkMultithreading/Benchmarks/ComparsionCollection.cs
new file mode 100644
index 0000000..88be3a9
--- /dev/null
+++ b/BenchmarkMultithreading/BenchmarkMultithreading/Benchmarks/ComparsionCollection.cs
@@ -0,0 +1,98 @@
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Threading;
+
+namespace BenchmarkMultithreading.Benchmarks
+{
+    class ComparsionCollection : IBenchmarkable
+    {
+
+        #region [.inits]
+        const int NEW_ROWS_NUMBER = 5000;
+        const int THREADS_NUMBER = 10;
+        const int INIT_ROWS_NUMBER = 10000;
+
+        private List<string> unsafeSource;
+        private ConcurrentBag<string> safeSource;
+        private object SyncRoot;
+        private ulong changesSum;
+        private ulong changesSumConcurrent;
+
+        Thread[] threadsLock;
+        Thread[] threadsConcurrent;
+        #endregion
+
+        private void changeSourceWithLock()
+        {
+            for (int i = 0; i < NEW_ROWS_NUMBER; i++)
+            {
+                lock (SyncRoot)
+                {
+                    unsafeSource.Add("with lock");
+                    changesSum++;
+                }
+            }
+        }
+
+        private void changeSource()
+        {
+            for (int i = 0; i < NEW_ROWS_NUMBER; i++)
+            {
+                safeSource.Add("with concurrent");
+                changesSumConcurrent++;
+            }
+        }
+
+        private void threadsInit()
+        {
+            for (int i = 0; i < THREADS_NUMBER; i++)
+            {
+                ThreadStart t1s = new ThreadStart(changeSourceWithLock);
+                Thread t1 = new Thread(t1s);
+                threadsLock[i] = t1;
+
+                ThreadStart t2s = new ThreadStart(changeSource);
+                Thread t2 = new Thread(t2s);
+                threadsConcurrent[i] = t2;
+            }
+        }
+
+        private void fillSources()
+        {
+            for (int i = 0; i < INIT_ROWS_NUMBER; i++)
+            {
+                var str = "default" + i;
+                unsafeSource.Add(str);
+                safeSource.Add(str);
+            }
+        }
+
+        public void Run()
+        {
+            fillSources();
+            Console.WriteLine("Number of elements at collection: {0}", unsafeSource.Count);
+
+            //start threads
+            for (int i = 0; i < THREADS_NUMBER; i++)
+            {
+                threadsLock[i].Start();
+                threadsConcurrent[i].Start();
+            }
+        }
+
+        public void Setup()
+        {
+            unsafeSource = new List<string>();
+            safeSource = new ConcurrentBag<string>();
+            SyncRoot = new object();
+            changesSum = 0;
+            changesSumConcurrent = 0;
+
+            threadsLock = new Thread[THREADS_NUMBER];
+            threadsConcurrent = new Thread[THREADS_NUMBER];
+
+            threadsInit();
+        }
+    }
+}
diff --git a/BenchmarkMultithreading/BenchmarkMultithreading/Benchmarks/MonitorEnter.cs b/BenchmarkMultithreading/BenchmarkMultithreading/Benchmarks/MonitorEnter.cs
index b9fb0dd..9792313 100644
--- a/BenchmarkMultithreading/BenchmarkMultithreading/Benchmarks/MonitorEnter.cs
+++ b/BenchmarkMultithreading/BenchmarkMultithreading/Benchmarks/MonitorEnter.cs
@@ -1,14 +1,9 @@
 using BenchmarkMultithreading.TestDomainObjects;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
 using System.Threading;
-using System.Threading.Tasks;
 
 namespace BenchmarkMultithreading.Benchmarks
 {
-  class MonitorEnter : IBenchmarkable
+    class MonitorEnter : IBenchmarkable
   {
     #region private fields
     private Credit credits;
diff --git a/BenchmarkMultithreading/BenchmarkMultithreadingConsole/Program.cs b/BenchmarkMultithreading/BenchmarkMultithreadingConsole/Program.cs
index 8aca050..4dc8fc6 100644
--- a/BenchmarkMultithreading/BenchmarkMultithreadingConsole/Program.cs
+++ b/BenchmarkMultithreading/BenchmarkMultithreadingConsole/Program.cs
@@ -1,7 +1,4 @@
 using System;
-using System.Collections.Concurrent;
-using System.Collections.Generic;
-using System.Threading;
 using BenchmarkDotNet.Running;
 using BenchmarkMultithreading;
 
@@ -9,106 +6,27 @@ namespace BenchmarkMultithreadingConsole
 {
     class Program
   {
-    #region [.consts]
-    const int NEW_ROWS_NUMBER = 5000;
-    const int THREADS_NUMBER = 10;
-    const int INIT_ROWS_NUMBER = 10000;
-    #endregion
-
-    #region [.init]
-    private static List<string> unsafeSource = new List<string>();
-    private static ConcurrentBag<string> safeSource = new ConcurrentBag<string>();
-    private static object SyncRoot = new object();
-    private static ulong changesSum = 0;
-    private static ulong changesSumConcurrent = 0;
-
-    static Thread[] threadsLock = new Thread[THREADS_NUMBER];
-    static Thread[] threadsConcurrent = new Thread[THREADS_NUMBER]; 
-    #endregion
-
-    static void Main(string[] args)
-    {
-        foreach (var arg in args)
+        static void Main(string[] args)
         {
-            switch (arg)
+            foreach (var arg in args)
             {
-                case "run":
-                    {
-                        BenchmarkRunner.Run<BenchmarkContainer>();
-                        start();
-                        break;
-                    }
-
-                case "pause":
-                    {
-                        Console.WriteLine("Press ENTER to release console.");
-                        Console.ReadKey();
-                        break;
-                    }
+                switch (arg)
+                {
+                    case "run":
+                        {
+                            BenchmarkRunner.Run<BenchmarkContainer>();
+                            break;
+                        }
+
+                    case "pause":
+                        {
+                            Console.WriteLine("Press ENTER to release console.");
+                            Console.ReadKey();
+                            break;
+                        }
+                }
             }
         }
-        }
-
-    public static void start()
-    {
-        fillSources();
-        Console.WriteLine("Number of elements at collection: {0}", unsafeSource.Count);
-
-        threadsInit();
-
-        //start threads
-        for (int i = 0; i < THREADS_NUMBER; i++)
-        {
-            threadsLock[i].Start();
-            threadsConcurrent[i].Start();
-        }
-
-        //Console.ReadKey();
-    }
-
-    public static void changeSourceWithLock()
-    {
-        for (int i = 0; i < NEW_ROWS_NUMBER; i++)
-        {
-            lock (SyncRoot)
-            {
-                unsafeSource.Add("with lock");
-                changesSum++;
-            } 
-        }
-    }
-
-    public static void changeSource()
-    {
-        for (int i = 0; i < NEW_ROWS_NUMBER; i++)
-        {
-            safeSource.Add("with concurrent");
-            changesSumConcurrent++; 
-        }
-    }
 
-    public static void threadsInit()
-    {
-        for (int i = 0; i < THREADS_NUMBER; i++)
-        {
-            ThreadStart t1s = new ThreadStart(changeSourceWithLock);
-            Thread t1 = new Thread(t1s);
-            threadsLock[i] = t1;
-
-            ThreadStart t2s = new ThreadStart(changeSource);
-            Thread t2 = new Thread(t2s);
-            threadsConcurrent[i] = t2;
-        }
-    }
-
-    public static void fillSources()
-    {
-        for (int i = 0; i < INIT_ROWS_NUMBER; i++)
-        {
-            var str = "default" + i;
-            unsafeSource.Add(str);
-            safeSource.Add(str);
-        }
-    }
   }
 }

From 96526a74c8cad935c5671658ea2565bd57c30408 Mon Sep 17 00:00:00 2001
From: Max Davydov <maks4171@gmail.com>
Date: Mon, 20 Jun 2016 23:29:06 +0300
Subject: [PATCH 12/17] Init test classes and refactor

---
 .../BenchmarkContainer.cs                     | 16 +++--
 .../ComparsionCollectionConcurrent.cs         | 71 +++++++++++++++++++
 ...lection.cs => ComparsionCollectionList.cs} | 27 +------
 3 files changed, 86 insertions(+), 28 deletions(-)
 create mode 100644 BenchmarkMultithreading/BenchmarkMultithreading/Benchmarks/ComparsionCollectionConcurrent.cs
 rename BenchmarkMultithreading/BenchmarkMultithreading/Benchmarks/{ComparsionCollection.cs => ComparsionCollectionList.cs} (66%)

diff --git a/BenchmarkMultithreading/BenchmarkMultithreading/BenchmarkContainer.cs b/BenchmarkMultithreading/BenchmarkMultithreading/BenchmarkContainer.cs
index 4b1b437..8c123bb 100644
--- a/BenchmarkMultithreading/BenchmarkMultithreading/BenchmarkContainer.cs
+++ b/BenchmarkMultithreading/BenchmarkMultithreading/BenchmarkContainer.cs
@@ -1,4 +1,5 @@
 using BenchmarkDotNet.Attributes;
+using BenchmarkMultithreading.Benchmarks;
 
 namespace BenchmarkMultithreading
 {
@@ -23,10 +24,17 @@ public void MonitorEnter()
 
     }
     [Benchmark]
-    public void ComparsionCollection()
+    public void ComparsionCollectionList()
     {
-
+        var testObj = new ComparsionCollectionList();
+        testObj.Run();
+    }
+    [Benchmark]
+    public void ComparsionCollectionConcurrent()
+    {
+        var testObj = new ComparsionCollectionConcurrent();
+        testObj.Run();
+    }
+        #endregion
     }
-    #endregion
-  }
 }
diff --git a/BenchmarkMultithreading/BenchmarkMultithreading/Benchmarks/ComparsionCollectionConcurrent.cs b/BenchmarkMultithreading/BenchmarkMultithreading/Benchmarks/ComparsionCollectionConcurrent.cs
new file mode 100644
index 0000000..10b503d
--- /dev/null
+++ b/BenchmarkMultithreading/BenchmarkMultithreading/Benchmarks/ComparsionCollectionConcurrent.cs
@@ -0,0 +1,71 @@
+using System;
+using System.Collections.Concurrent;
+using System.Threading;
+
+namespace BenchmarkMultithreading.Benchmarks
+{
+    class ComparsionCollectionConcurrent : IBenchmarkable
+    {
+        #region [.inits]
+        const int NEW_ROWS_NUMBER = 5000;
+        const int THREADS_NUMBER = 10;
+        const int INIT_ROWS_NUMBER = 10000;
+
+        private ConcurrentBag<string> safeSource;
+        private ulong changesSumConcurrent;
+
+        Thread[] threadsConcurrent;
+        #endregion
+
+        private void changeSource()
+        {
+            for (int i = 0; i < NEW_ROWS_NUMBER; i++)
+            {
+                safeSource.Add("new value");
+                changesSumConcurrent++;
+            }
+        }
+
+        private void threadsInit()
+        {
+            for (int i = 0; i < THREADS_NUMBER; i++)
+            {
+                ThreadStart t2s = new ThreadStart(changeSource);
+                Thread t2 = new Thread(t2s);
+                threadsConcurrent[i] = t2;
+            }
+        }
+
+        private void fillSources()
+        {
+            for (int i = 0; i < INIT_ROWS_NUMBER; i++)
+            {
+                var str = "default" + i;
+                safeSource.Add(str);
+            }
+        }
+
+        public void Run()
+        {
+            Setup();
+            fillSources();
+            Console.WriteLine("Number of elements at collection: {0}", safeSource.Count);
+
+            //start threads
+            for (int i = 0; i < THREADS_NUMBER; i++)
+            {
+                threadsConcurrent[i].Start();
+            }
+        }
+
+        public void Setup()
+        {
+            safeSource = new ConcurrentBag<string>();
+            changesSumConcurrent = 0;
+
+            threadsConcurrent = new Thread[THREADS_NUMBER];
+
+            threadsInit();
+        }
+    }
+}
\ No newline at end of file
diff --git a/BenchmarkMultithreading/BenchmarkMultithreading/Benchmarks/ComparsionCollection.cs b/BenchmarkMultithreading/BenchmarkMultithreading/Benchmarks/ComparsionCollectionList.cs
similarity index 66%
rename from BenchmarkMultithreading/BenchmarkMultithreading/Benchmarks/ComparsionCollection.cs
rename to BenchmarkMultithreading/BenchmarkMultithreading/Benchmarks/ComparsionCollectionList.cs
index 88be3a9..7b8ed15 100644
--- a/BenchmarkMultithreading/BenchmarkMultithreading/Benchmarks/ComparsionCollection.cs
+++ b/BenchmarkMultithreading/BenchmarkMultithreading/Benchmarks/ComparsionCollectionList.cs
@@ -1,11 +1,10 @@
 using System;
-using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Threading;
 
 namespace BenchmarkMultithreading.Benchmarks
 {
-    class ComparsionCollection : IBenchmarkable
+    class ComparsionCollectionList : IBenchmarkable
     {
 
         #region [.inits]
@@ -14,13 +13,10 @@ class ComparsionCollection : IBenchmarkable
         const int INIT_ROWS_NUMBER = 10000;
 
         private List<string> unsafeSource;
-        private ConcurrentBag<string> safeSource;
         private object SyncRoot;
         private ulong changesSum;
-        private ulong changesSumConcurrent;
 
         Thread[] threadsLock;
-        Thread[] threadsConcurrent;
         #endregion
 
         private void changeSourceWithLock()
@@ -29,21 +25,12 @@ private void changeSourceWithLock()
             {
                 lock (SyncRoot)
                 {
-                    unsafeSource.Add("with lock");
+                    unsafeSource.Add("new value");
                     changesSum++;
                 }
             }
         }
 
-        private void changeSource()
-        {
-            for (int i = 0; i < NEW_ROWS_NUMBER; i++)
-            {
-                safeSource.Add("with concurrent");
-                changesSumConcurrent++;
-            }
-        }
-
         private void threadsInit()
         {
             for (int i = 0; i < THREADS_NUMBER; i++)
@@ -51,10 +38,6 @@ private void threadsInit()
                 ThreadStart t1s = new ThreadStart(changeSourceWithLock);
                 Thread t1 = new Thread(t1s);
                 threadsLock[i] = t1;
-
-                ThreadStart t2s = new ThreadStart(changeSource);
-                Thread t2 = new Thread(t2s);
-                threadsConcurrent[i] = t2;
             }
         }
 
@@ -64,12 +47,12 @@ private void fillSources()
             {
                 var str = "default" + i;
                 unsafeSource.Add(str);
-                safeSource.Add(str);
             }
         }
 
         public void Run()
         {
+            Setup();
             fillSources();
             Console.WriteLine("Number of elements at collection: {0}", unsafeSource.Count);
 
@@ -77,20 +60,16 @@ public void Run()
             for (int i = 0; i < THREADS_NUMBER; i++)
             {
                 threadsLock[i].Start();
-                threadsConcurrent[i].Start();
             }
         }
 
         public void Setup()
         {
             unsafeSource = new List<string>();
-            safeSource = new ConcurrentBag<string>();
             SyncRoot = new object();
             changesSum = 0;
-            changesSumConcurrent = 0;
 
             threadsLock = new Thread[THREADS_NUMBER];
-            threadsConcurrent = new Thread[THREADS_NUMBER];
 
             threadsInit();
         }

From f3a1ef61c0c64fe276aac266608723d6e01df104 Mon Sep 17 00:00:00 2001
From: Max Davydov <maks4171@gmail.com>
Date: Tue, 21 Jun 2016 09:44:33 +0300
Subject: [PATCH 13/17] Revert "Init test classes and refactor"

This reverts commit 96526a74c8cad935c5671658ea2565bd57c30408.
---
 .../BenchmarkContainer.cs                     | 16 ++---
 ...lectionList.cs => ComparsionCollection.cs} | 27 ++++++-
 .../ComparsionCollectionConcurrent.cs         | 71 -------------------
 3 files changed, 28 insertions(+), 86 deletions(-)
 rename BenchmarkMultithreading/BenchmarkMultithreading/Benchmarks/{ComparsionCollectionList.cs => ComparsionCollection.cs} (66%)
 delete mode 100644 BenchmarkMultithreading/BenchmarkMultithreading/Benchmarks/ComparsionCollectionConcurrent.cs

diff --git a/BenchmarkMultithreading/BenchmarkMultithreading/BenchmarkContainer.cs b/BenchmarkMultithreading/BenchmarkMultithreading/BenchmarkContainer.cs
index 8c123bb..4b1b437 100644
--- a/BenchmarkMultithreading/BenchmarkMultithreading/BenchmarkContainer.cs
+++ b/BenchmarkMultithreading/BenchmarkMultithreading/BenchmarkContainer.cs
@@ -1,5 +1,4 @@
 using BenchmarkDotNet.Attributes;
-using BenchmarkMultithreading.Benchmarks;
 
 namespace BenchmarkMultithreading
 {
@@ -24,17 +23,10 @@ public void MonitorEnter()
 
     }
     [Benchmark]
-    public void ComparsionCollectionList()
+    public void ComparsionCollection()
     {
-        var testObj = new ComparsionCollectionList();
-        testObj.Run();
-    }
-    [Benchmark]
-    public void ComparsionCollectionConcurrent()
-    {
-        var testObj = new ComparsionCollectionConcurrent();
-        testObj.Run();
-    }
-        #endregion
+
     }
+    #endregion
+  }
 }
diff --git a/BenchmarkMultithreading/BenchmarkMultithreading/Benchmarks/ComparsionCollectionList.cs b/BenchmarkMultithreading/BenchmarkMultithreading/Benchmarks/ComparsionCollection.cs
similarity index 66%
rename from BenchmarkMultithreading/BenchmarkMultithreading/Benchmarks/ComparsionCollectionList.cs
rename to BenchmarkMultithreading/BenchmarkMultithreading/Benchmarks/ComparsionCollection.cs
index 7b8ed15..88be3a9 100644
--- a/BenchmarkMultithreading/BenchmarkMultithreading/Benchmarks/ComparsionCollectionList.cs
+++ b/BenchmarkMultithreading/BenchmarkMultithreading/Benchmarks/ComparsionCollection.cs
@@ -1,10 +1,11 @@
 using System;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Threading;
 
 namespace BenchmarkMultithreading.Benchmarks
 {
-    class ComparsionCollectionList : IBenchmarkable
+    class ComparsionCollection : IBenchmarkable
     {
 
         #region [.inits]
@@ -13,10 +14,13 @@ class ComparsionCollectionList : IBenchmarkable
         const int INIT_ROWS_NUMBER = 10000;
 
         private List<string> unsafeSource;
+        private ConcurrentBag<string> safeSource;
         private object SyncRoot;
         private ulong changesSum;
+        private ulong changesSumConcurrent;
 
         Thread[] threadsLock;
+        Thread[] threadsConcurrent;
         #endregion
 
         private void changeSourceWithLock()
@@ -25,12 +29,21 @@ private void changeSourceWithLock()
             {
                 lock (SyncRoot)
                 {
-                    unsafeSource.Add("new value");
+                    unsafeSource.Add("with lock");
                     changesSum++;
                 }
             }
         }
 
+        private void changeSource()
+        {
+            for (int i = 0; i < NEW_ROWS_NUMBER; i++)
+            {
+                safeSource.Add("with concurrent");
+                changesSumConcurrent++;
+            }
+        }
+
         private void threadsInit()
         {
             for (int i = 0; i < THREADS_NUMBER; i++)
@@ -38,6 +51,10 @@ private void threadsInit()
                 ThreadStart t1s = new ThreadStart(changeSourceWithLock);
                 Thread t1 = new Thread(t1s);
                 threadsLock[i] = t1;
+
+                ThreadStart t2s = new ThreadStart(changeSource);
+                Thread t2 = new Thread(t2s);
+                threadsConcurrent[i] = t2;
             }
         }
 
@@ -47,12 +64,12 @@ private void fillSources()
             {
                 var str = "default" + i;
                 unsafeSource.Add(str);
+                safeSource.Add(str);
             }
         }
 
         public void Run()
         {
-            Setup();
             fillSources();
             Console.WriteLine("Number of elements at collection: {0}", unsafeSource.Count);
 
@@ -60,16 +77,20 @@ public void Run()
             for (int i = 0; i < THREADS_NUMBER; i++)
             {
                 threadsLock[i].Start();
+                threadsConcurrent[i].Start();
             }
         }
 
         public void Setup()
         {
             unsafeSource = new List<string>();
+            safeSource = new ConcurrentBag<string>();
             SyncRoot = new object();
             changesSum = 0;
+            changesSumConcurrent = 0;
 
             threadsLock = new Thread[THREADS_NUMBER];
+            threadsConcurrent = new Thread[THREADS_NUMBER];
 
             threadsInit();
         }
diff --git a/BenchmarkMultithreading/BenchmarkMultithreading/Benchmarks/ComparsionCollectionConcurrent.cs b/BenchmarkMultithreading/BenchmarkMultithreading/Benchmarks/ComparsionCollectionConcurrent.cs
deleted file mode 100644
index 10b503d..0000000
--- a/BenchmarkMultithreading/BenchmarkMultithreading/Benchmarks/ComparsionCollectionConcurrent.cs
+++ /dev/null
@@ -1,71 +0,0 @@
-using System;
-using System.Collections.Concurrent;
-using System.Threading;
-
-namespace BenchmarkMultithreading.Benchmarks
-{
-    class ComparsionCollectionConcurrent : IBenchmarkable
-    {
-        #region [.inits]
-        const int NEW_ROWS_NUMBER = 5000;
-        const int THREADS_NUMBER = 10;
-        const int INIT_ROWS_NUMBER = 10000;
-
-        private ConcurrentBag<string> safeSource;
-        private ulong changesSumConcurrent;
-
-        Thread[] threadsConcurrent;
-        #endregion
-
-        private void changeSource()
-        {
-            for (int i = 0; i < NEW_ROWS_NUMBER; i++)
-            {
-                safeSource.Add("new value");
-                changesSumConcurrent++;
-            }
-        }
-
-        private void threadsInit()
-        {
-            for (int i = 0; i < THREADS_NUMBER; i++)
-            {
-                ThreadStart t2s = new ThreadStart(changeSource);
-                Thread t2 = new Thread(t2s);
-                threadsConcurrent[i] = t2;
-            }
-        }
-
-        private void fillSources()
-        {
-            for (int i = 0; i < INIT_ROWS_NUMBER; i++)
-            {
-                var str = "default" + i;
-                safeSource.Add(str);
-            }
-        }
-
-        public void Run()
-        {
-            Setup();
-            fillSources();
-            Console.WriteLine("Number of elements at collection: {0}", safeSource.Count);
-
-            //start threads
-            for (int i = 0; i < THREADS_NUMBER; i++)
-            {
-                threadsConcurrent[i].Start();
-            }
-        }
-
-        public void Setup()
-        {
-            safeSource = new ConcurrentBag<string>();
-            changesSumConcurrent = 0;
-
-            threadsConcurrent = new Thread[THREADS_NUMBER];
-
-            threadsInit();
-        }
-    }
-}
\ No newline at end of file

From cbff5d4b868411f49fe6a33d01f50bfc2b02ec74 Mon Sep 17 00:00:00 2001
From: Max Davydov <maks4171@gmail.com>
Date: Tue, 21 Jun 2016 09:45:17 +0300
Subject: [PATCH 14/17] Revert "Revert "Init test classes and refactor""

This reverts commit f3a1ef61c0c64fe276aac266608723d6e01df104.
---
 .../BenchmarkContainer.cs                     | 16 +++--
 .../ComparsionCollectionConcurrent.cs         | 71 +++++++++++++++++++
 ...lection.cs => ComparsionCollectionList.cs} | 27 +------
 3 files changed, 86 insertions(+), 28 deletions(-)
 create mode 100644 BenchmarkMultithreading/BenchmarkMultithreading/Benchmarks/ComparsionCollectionConcurrent.cs
 rename BenchmarkMultithreading/BenchmarkMultithreading/Benchmarks/{ComparsionCollection.cs => ComparsionCollectionList.cs} (66%)

diff --git a/BenchmarkMultithreading/BenchmarkMultithreading/BenchmarkContainer.cs b/BenchmarkMultithreading/BenchmarkMultithreading/BenchmarkContainer.cs
index 4b1b437..8c123bb 100644
--- a/BenchmarkMultithreading/BenchmarkMultithreading/BenchmarkContainer.cs
+++ b/BenchmarkMultithreading/BenchmarkMultithreading/BenchmarkContainer.cs
@@ -1,4 +1,5 @@
 using BenchmarkDotNet.Attributes;
+using BenchmarkMultithreading.Benchmarks;
 
 namespace BenchmarkMultithreading
 {
@@ -23,10 +24,17 @@ public void MonitorEnter()
 
     }
     [Benchmark]
-    public void ComparsionCollection()
+    public void ComparsionCollectionList()
     {
-
+        var testObj = new ComparsionCollectionList();
+        testObj.Run();
+    }
+    [Benchmark]
+    public void ComparsionCollectionConcurrent()
+    {
+        var testObj = new ComparsionCollectionConcurrent();
+        testObj.Run();
+    }
+        #endregion
     }
-    #endregion
-  }
 }
diff --git a/BenchmarkMultithreading/BenchmarkMultithreading/Benchmarks/ComparsionCollectionConcurrent.cs b/BenchmarkMultithreading/BenchmarkMultithreading/Benchmarks/ComparsionCollectionConcurrent.cs
new file mode 100644
index 0000000..10b503d
--- /dev/null
+++ b/BenchmarkMultithreading/BenchmarkMultithreading/Benchmarks/ComparsionCollectionConcurrent.cs
@@ -0,0 +1,71 @@
+using System;
+using System.Collections.Concurrent;
+using System.Threading;
+
+namespace BenchmarkMultithreading.Benchmarks
+{
+    class ComparsionCollectionConcurrent : IBenchmarkable
+    {
+        #region [.inits]
+        const int NEW_ROWS_NUMBER = 5000;
+        const int THREADS_NUMBER = 10;
+        const int INIT_ROWS_NUMBER = 10000;
+
+        private ConcurrentBag<string> safeSource;
+        private ulong changesSumConcurrent;
+
+        Thread[] threadsConcurrent;
+        #endregion
+
+        private void changeSource()
+        {
+            for (int i = 0; i < NEW_ROWS_NUMBER; i++)
+            {
+                safeSource.Add("new value");
+                changesSumConcurrent++;
+            }
+        }
+
+        private void threadsInit()
+        {
+            for (int i = 0; i < THREADS_NUMBER; i++)
+            {
+                ThreadStart t2s = new ThreadStart(changeSource);
+                Thread t2 = new Thread(t2s);
+                threadsConcurrent[i] = t2;
+            }
+        }
+
+        private void fillSources()
+        {
+            for (int i = 0; i < INIT_ROWS_NUMBER; i++)
+            {
+                var str = "default" + i;
+                safeSource.Add(str);
+            }
+        }
+
+        public void Run()
+        {
+            Setup();
+            fillSources();
+            Console.WriteLine("Number of elements at collection: {0}", safeSource.Count);
+
+            //start threads
+            for (int i = 0; i < THREADS_NUMBER; i++)
+            {
+                threadsConcurrent[i].Start();
+            }
+        }
+
+        public void Setup()
+        {
+            safeSource = new ConcurrentBag<string>();
+            changesSumConcurrent = 0;
+
+            threadsConcurrent = new Thread[THREADS_NUMBER];
+
+            threadsInit();
+        }
+    }
+}
\ No newline at end of file
diff --git a/BenchmarkMultithreading/BenchmarkMultithreading/Benchmarks/ComparsionCollection.cs b/BenchmarkMultithreading/BenchmarkMultithreading/Benchmarks/ComparsionCollectionList.cs
similarity index 66%
rename from BenchmarkMultithreading/BenchmarkMultithreading/Benchmarks/ComparsionCollection.cs
rename to BenchmarkMultithreading/BenchmarkMultithreading/Benchmarks/ComparsionCollectionList.cs
index 88be3a9..7b8ed15 100644
--- a/BenchmarkMultithreading/BenchmarkMultithreading/Benchmarks/ComparsionCollection.cs
+++ b/BenchmarkMultithreading/BenchmarkMultithreading/Benchmarks/ComparsionCollectionList.cs
@@ -1,11 +1,10 @@
 using System;
-using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Threading;
 
 namespace BenchmarkMultithreading.Benchmarks
 {
-    class ComparsionCollection : IBenchmarkable
+    class ComparsionCollectionList : IBenchmarkable
     {
 
         #region [.inits]
@@ -14,13 +13,10 @@ class ComparsionCollection : IBenchmarkable
         const int INIT_ROWS_NUMBER = 10000;
 
         private List<string> unsafeSource;
-        private ConcurrentBag<string> safeSource;
         private object SyncRoot;
         private ulong changesSum;
-        private ulong changesSumConcurrent;
 
         Thread[] threadsLock;
-        Thread[] threadsConcurrent;
         #endregion
 
         private void changeSourceWithLock()
@@ -29,21 +25,12 @@ private void changeSourceWithLock()
             {
                 lock (SyncRoot)
                 {
-                    unsafeSource.Add("with lock");
+                    unsafeSource.Add("new value");
                     changesSum++;
                 }
             }
         }
 
-        private void changeSource()
-        {
-            for (int i = 0; i < NEW_ROWS_NUMBER; i++)
-            {
-                safeSource.Add("with concurrent");
-                changesSumConcurrent++;
-            }
-        }
-
         private void threadsInit()
         {
             for (int i = 0; i < THREADS_NUMBER; i++)
@@ -51,10 +38,6 @@ private void threadsInit()
                 ThreadStart t1s = new ThreadStart(changeSourceWithLock);
                 Thread t1 = new Thread(t1s);
                 threadsLock[i] = t1;
-
-                ThreadStart t2s = new ThreadStart(changeSource);
-                Thread t2 = new Thread(t2s);
-                threadsConcurrent[i] = t2;
             }
         }
 
@@ -64,12 +47,12 @@ private void fillSources()
             {
                 var str = "default" + i;
                 unsafeSource.Add(str);
-                safeSource.Add(str);
             }
         }
 
         public void Run()
         {
+            Setup();
             fillSources();
             Console.WriteLine("Number of elements at collection: {0}", unsafeSource.Count);
 
@@ -77,20 +60,16 @@ public void Run()
             for (int i = 0; i < THREADS_NUMBER; i++)
             {
                 threadsLock[i].Start();
-                threadsConcurrent[i].Start();
             }
         }
 
         public void Setup()
         {
             unsafeSource = new List<string>();
-            safeSource = new ConcurrentBag<string>();
             SyncRoot = new object();
             changesSum = 0;
-            changesSumConcurrent = 0;
 
             threadsLock = new Thread[THREADS_NUMBER];
-            threadsConcurrent = new Thread[THREADS_NUMBER];
 
             threadsInit();
         }

From f350a4598daa3ad3d90a91ebd34c325e94593273 Mon Sep 17 00:00:00 2001
From: Max Davydov <maks4171@gmail.com>
Date: Tue, 21 Jun 2016 09:49:20 +0300
Subject: [PATCH 15/17] Update csproj-file

---
 .../BenchmarkMultithreading/BenchmarkMultithreading.csproj     | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/BenchmarkMultithreading/BenchmarkMultithreading/BenchmarkMultithreading.csproj b/BenchmarkMultithreading/BenchmarkMultithreading/BenchmarkMultithreading.csproj
index fc7bf85..8ff3d2c 100644
--- a/BenchmarkMultithreading/BenchmarkMultithreading/BenchmarkMultithreading.csproj
+++ b/BenchmarkMultithreading/BenchmarkMultithreading/BenchmarkMultithreading.csproj
@@ -46,7 +46,8 @@
   </ItemGroup>
   <ItemGroup>
     <Compile Include="BenchmarkContainer.cs" />
-    <Compile Include="Benchmarks\ComparsionCollection.cs" />
+    <Compile Include="Benchmarks\ComparsionCollectionList.cs" />
+    <Compile Include="Benchmarks\ComparsionCollectionConcurrent.cs" />
     <Compile Include="IBenchmarkable.cs" />
     <Compile Include="Benchmarks\Lock.cs" />
     <Compile Include="Benchmarks\MonitorEnter.cs" />

From c069ce6236708f5ecff4320421c1c65db3470938 Mon Sep 17 00:00:00 2001
From: Max Davydov <maks4171@gmail.com>
Date: Tue, 21 Jun 2016 10:14:54 +0300
Subject: [PATCH 16/17] Added interface for comparsion collections with filling
 through same threads. TODO: change threads to tasks for optimize

---
 .../BenchmarkContainer.cs                        | 16 ++++++++++------
 .../BenchmarkMultithreading.csproj               |  1 +
 .../Benchmarks/ComparsionCollectionConcurrent.cs | 12 ++++++------
 .../Benchmarks/ComparsionCollectionList.cs       | 14 +++++++-------
 .../BenchmarkMultithreading/IComparsion.cs       | 11 +++++++++++
 5 files changed, 35 insertions(+), 19 deletions(-)
 create mode 100644 BenchmarkMultithreading/BenchmarkMultithreading/IComparsion.cs

diff --git a/BenchmarkMultithreading/BenchmarkMultithreading/BenchmarkContainer.cs b/BenchmarkMultithreading/BenchmarkMultithreading/BenchmarkContainer.cs
index 8c123bb..c816da3 100644
--- a/BenchmarkMultithreading/BenchmarkMultithreading/BenchmarkContainer.cs
+++ b/BenchmarkMultithreading/BenchmarkMultithreading/BenchmarkContainer.cs
@@ -5,11 +5,17 @@ namespace BenchmarkMultithreading
 {
     public class BenchmarkContainer
   {
+    #region [.private fields]
+    private ComparsionCollectionList testList;
+    private ComparsionCollectionConcurrent testConcurrent;
+    #endregion
+
     #region public methods
     [Setup]
     public void Setup()
     {
-
+        testList = new ComparsionCollectionList();
+        testConcurrent = new ComparsionCollectionConcurrent();
     }
 
     [Benchmark]
@@ -26,15 +32,13 @@ public void MonitorEnter()
     [Benchmark]
     public void ComparsionCollectionList()
     {
-        var testObj = new ComparsionCollectionList();
-        testObj.Run();
+        testList.Run();
     }
     [Benchmark]
     public void ComparsionCollectionConcurrent()
     {
-        var testObj = new ComparsionCollectionConcurrent();
-        testObj.Run();
+        testConcurrent.Run();
     }
-        #endregion
+    #endregion
     }
 }
diff --git a/BenchmarkMultithreading/BenchmarkMultithreading/BenchmarkMultithreading.csproj b/BenchmarkMultithreading/BenchmarkMultithreading/BenchmarkMultithreading.csproj
index 8ff3d2c..9231a4d 100644
--- a/BenchmarkMultithreading/BenchmarkMultithreading/BenchmarkMultithreading.csproj
+++ b/BenchmarkMultithreading/BenchmarkMultithreading/BenchmarkMultithreading.csproj
@@ -51,6 +51,7 @@
     <Compile Include="IBenchmarkable.cs" />
     <Compile Include="Benchmarks\Lock.cs" />
     <Compile Include="Benchmarks\MonitorEnter.cs" />
+    <Compile Include="IComparsion.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="TestDomainObjects\Client.cs" />
     <Compile Include="TestDomainObjects\Credit.cs" />
diff --git a/BenchmarkMultithreading/BenchmarkMultithreading/Benchmarks/ComparsionCollectionConcurrent.cs b/BenchmarkMultithreading/BenchmarkMultithreading/Benchmarks/ComparsionCollectionConcurrent.cs
index 10b503d..d659511 100644
--- a/BenchmarkMultithreading/BenchmarkMultithreading/Benchmarks/ComparsionCollectionConcurrent.cs
+++ b/BenchmarkMultithreading/BenchmarkMultithreading/Benchmarks/ComparsionCollectionConcurrent.cs
@@ -4,7 +4,7 @@
 
 namespace BenchmarkMultithreading.Benchmarks
 {
-    class ComparsionCollectionConcurrent : IBenchmarkable
+    class ComparsionCollectionConcurrent : IBenchmarkable, IComparsion
     {
         #region [.inits]
         const int NEW_ROWS_NUMBER = 5000;
@@ -17,7 +17,7 @@ class ComparsionCollectionConcurrent : IBenchmarkable
         Thread[] threadsConcurrent;
         #endregion
 
-        private void changeSource()
+        public void changeSource()
         {
             for (int i = 0; i < NEW_ROWS_NUMBER; i++)
             {
@@ -26,7 +26,7 @@ private void changeSource()
             }
         }
 
-        private void threadsInit()
+        public void threadsInit()
         {
             for (int i = 0; i < THREADS_NUMBER; i++)
             {
@@ -36,7 +36,7 @@ private void threadsInit()
             }
         }
 
-        private void fillSources()
+        public void fillSource()
         {
             for (int i = 0; i < INIT_ROWS_NUMBER; i++)
             {
@@ -48,8 +48,8 @@ private void fillSources()
         public void Run()
         {
             Setup();
-            fillSources();
-            Console.WriteLine("Number of elements at collection: {0}", safeSource.Count);
+            fillSource();
+            //Console.WriteLine("Number of elements at collection: {0}", safeSource.Count);
 
             //start threads
             for (int i = 0; i < THREADS_NUMBER; i++)
diff --git a/BenchmarkMultithreading/BenchmarkMultithreading/Benchmarks/ComparsionCollectionList.cs b/BenchmarkMultithreading/BenchmarkMultithreading/Benchmarks/ComparsionCollectionList.cs
index 7b8ed15..e866e2e 100644
--- a/BenchmarkMultithreading/BenchmarkMultithreading/Benchmarks/ComparsionCollectionList.cs
+++ b/BenchmarkMultithreading/BenchmarkMultithreading/Benchmarks/ComparsionCollectionList.cs
@@ -4,7 +4,7 @@
 
 namespace BenchmarkMultithreading.Benchmarks
 {
-    class ComparsionCollectionList : IBenchmarkable
+    class ComparsionCollectionList : IBenchmarkable, IComparsion
     {
 
         #region [.inits]
@@ -19,7 +19,7 @@ class ComparsionCollectionList : IBenchmarkable
         Thread[] threadsLock;
         #endregion
 
-        private void changeSourceWithLock()
+        public void changeSource()
         {
             for (int i = 0; i < NEW_ROWS_NUMBER; i++)
             {
@@ -31,17 +31,17 @@ private void changeSourceWithLock()
             }
         }
 
-        private void threadsInit()
+        public void threadsInit()
         {
             for (int i = 0; i < THREADS_NUMBER; i++)
             {
-                ThreadStart t1s = new ThreadStart(changeSourceWithLock);
+                ThreadStart t1s = new ThreadStart(changeSource);
                 Thread t1 = new Thread(t1s);
                 threadsLock[i] = t1;
             }
         }
 
-        private void fillSources()
+        public void fillSource()
         {
             for (int i = 0; i < INIT_ROWS_NUMBER; i++)
             {
@@ -53,8 +53,8 @@ private void fillSources()
         public void Run()
         {
             Setup();
-            fillSources();
-            Console.WriteLine("Number of elements at collection: {0}", unsafeSource.Count);
+            fillSource();
+            //Console.WriteLine("Number of elements at collection: {0}", unsafeSource.Count);
 
             //start threads
             for (int i = 0; i < THREADS_NUMBER; i++)
diff --git a/BenchmarkMultithreading/BenchmarkMultithreading/IComparsion.cs b/BenchmarkMultithreading/BenchmarkMultithreading/IComparsion.cs
new file mode 100644
index 0000000..4a1e146
--- /dev/null
+++ b/BenchmarkMultithreading/BenchmarkMultithreading/IComparsion.cs
@@ -0,0 +1,11 @@
+using System;
+
+namespace BenchmarkMultithreading
+{
+    internal interface IComparsion
+    {
+        void fillSource();
+        void changeSource();
+        void threadsInit();
+    }
+}

From eb6ba7855533117da814f310a3c5b6ff2d157420 Mon Sep 17 00:00:00 2001
From: Max Davydov <maks4171@gmail.com>
Date: Tue, 21 Jun 2016 10:30:46 +0300
Subject: [PATCH 17/17] Changed init for private fields for optimization

---
 .../ComparsionCollectionConcurrent.cs           | 14 ++++----------
 .../Benchmarks/ComparsionCollectionList.cs      | 17 +++++------------
 2 files changed, 9 insertions(+), 22 deletions(-)

diff --git a/BenchmarkMultithreading/BenchmarkMultithreading/Benchmarks/ComparsionCollectionConcurrent.cs b/BenchmarkMultithreading/BenchmarkMultithreading/Benchmarks/ComparsionCollectionConcurrent.cs
index d659511..4211b4c 100644
--- a/BenchmarkMultithreading/BenchmarkMultithreading/Benchmarks/ComparsionCollectionConcurrent.cs
+++ b/BenchmarkMultithreading/BenchmarkMultithreading/Benchmarks/ComparsionCollectionConcurrent.cs
@@ -11,10 +11,10 @@ class ComparsionCollectionConcurrent : IBenchmarkable, IComparsion
         const int THREADS_NUMBER = 10;
         const int INIT_ROWS_NUMBER = 10000;
 
-        private ConcurrentBag<string> safeSource;
-        private ulong changesSumConcurrent;
+        private ConcurrentBag<string> safeSource = new ConcurrentBag<string>();
+        private ulong changesSumConcurrent = 0;
 
-        Thread[] threadsConcurrent;
+        Thread[] threadsConcurrent = new Thread[THREADS_NUMBER];
         #endregion
 
         public void changeSource()
@@ -47,7 +47,7 @@ public void fillSource()
 
         public void Run()
         {
-            Setup();
+            threadsInit();
             fillSource();
             //Console.WriteLine("Number of elements at collection: {0}", safeSource.Count);
 
@@ -60,12 +60,6 @@ public void Run()
 
         public void Setup()
         {
-            safeSource = new ConcurrentBag<string>();
-            changesSumConcurrent = 0;
-
-            threadsConcurrent = new Thread[THREADS_NUMBER];
-
-            threadsInit();
         }
     }
 }
\ No newline at end of file
diff --git a/BenchmarkMultithreading/BenchmarkMultithreading/Benchmarks/ComparsionCollectionList.cs b/BenchmarkMultithreading/BenchmarkMultithreading/Benchmarks/ComparsionCollectionList.cs
index e866e2e..f395fd1 100644
--- a/BenchmarkMultithreading/BenchmarkMultithreading/Benchmarks/ComparsionCollectionList.cs
+++ b/BenchmarkMultithreading/BenchmarkMultithreading/Benchmarks/ComparsionCollectionList.cs
@@ -12,11 +12,11 @@ class ComparsionCollectionList : IBenchmarkable, IComparsion
         const int THREADS_NUMBER = 10;
         const int INIT_ROWS_NUMBER = 10000;
 
-        private List<string> unsafeSource;
-        private object SyncRoot;
-        private ulong changesSum;
+        private List<string> unsafeSource = new List<string>();
+        private object SyncRoot = new object();
+        private ulong changesSum = 0;
 
-        Thread[] threadsLock;
+        Thread[] threadsLock = new Thread[THREADS_NUMBER];
         #endregion
 
         public void changeSource()
@@ -52,7 +52,7 @@ public void fillSource()
 
         public void Run()
         {
-            Setup();
+            threadsInit();
             fillSource();
             //Console.WriteLine("Number of elements at collection: {0}", unsafeSource.Count);
 
@@ -65,13 +65,6 @@ public void Run()
 
         public void Setup()
         {
-            unsafeSource = new List<string>();
-            SyncRoot = new object();
-            changesSum = 0;
-
-            threadsLock = new Thread[THREADS_NUMBER];
-
-            threadsInit();
         }
     }
 }