namespace Test {

	class TestDict {
		private readonly Dictionary<string, Guid> dict = new Dictionary<string, Guid>();

		public Guid GetValue1(string key)
		{
			if (dict.ContainsKey(key))
				return dict[key];
			var newValue = Guid.NewGuid();
			dict.Add(key, newValue);
			return newValue;
		}

		public Guid GetValue2(string key)
		{
			Guid value;
			if (dict.TryGetValue(key, out value))
				return value;
			var newValue = Guid.NewGuid();
			dict.Add(key, newValue);
			return newValue;
		}
	}

	static class Test {

		static string[] test_value;

		static void Init(int size) {
			Console.WriteLine($"Init {size} values");
			test_value = new string[size];
			for(int i = 0; i < test_value.Length; i++) test_value[i] = Guid.NewGuid().ToString();
		}

		static void Test1() {
			var td = new TestDict();
			Console.WriteLine("Test GetValue1() ...");
			var sw = Stopwatch.StartNew();
			for(int i = 0; i < test_value.Length; i++) {
				for(int j = i; j < test_value.Length; j += 100) {
					var guid = td.GetValue1(test_value[j]);
				}
			}
			Console.WriteLine($"Elapsed {sw.ElapsedMilliseconds} ms");
		}

		static void Test2() {
			var td = new TestDict();
			Console.WriteLine("Test GetValue2() ...");
			var sw = Stopwatch.StartNew();
			for(int i = 0; i < test_value.Length; i++) {
				for(int j = i; j < test_value.Length; j += 100) {
					var guid = td.GetValue2(test_value[j]);
				}
			}
			Console.WriteLine($"Elapsed {sw.ElapsedMilliseconds} ms");
		}

		static void Main(string[] args) {
			Init(100000);
			Test1();
			Test2();
			return;
		}
	}
}

class Program
{
    private static readonly TestClass TestClass1 = new TestClass();
    private static readonly TestClass TestClass2 = new TestClass();
    private static void Main()
    {
        const int count = 10000000;
        for (var i = 0; i < count; i++)
        {
            StartTest1(i);
            StartTest2(i);
        }

        Console.WriteLine("Press Enter");
        Console.ReadLine();
    }

    private static void StartTest1(int key)
    {
        var sw = Stopwatch.StartNew();
        TestClass1.GetValueI(key);
        var ms = sw.ElapsedMilliseconds;

        if (ms > 100)
        {
            Console.WriteLine($"Key: {key}");
            Console.WriteLine($"GetValueI: {ms} ms.");
            Console.WriteLine();
        }
    }

    private static void StartTest2(int key)
    {
        var sw = Stopwatch.StartNew();
        TestClass2.GetValueI(key);
        var ms = sw.ElapsedMilliseconds;

        if (ms > 100)
        {
            Console.WriteLine($"Key: {key}");
            Console.WriteLine($"GetValueII: {ms} ms.");
            Console.WriteLine();
        }
    }
}

class TestDict
{
    private readonly Dictionary<string, Guid> dict = new Dictionary<string, Guid>();

    public Guid GetValue1(string key)
    {
        if (dict.ContainsKey(key))
            return dict[key];
        var newValue = Guid.NewGuid();
        dict.Add(key, newValue);
        return newValue;
    }

    public Guid GetValue2(string key)
    {
        Guid value;
        if (dict.TryGetValue(key, out value))
            return value;
        var newValue = Guid.NewGuid();
        dict.Add(key, newValue);
        return newValue;
    }
}

namespace Test {

	class TestDict {
		private Dictionary<string, Guid> dict;

		ReaderWriterLockSlim rwsl = new ReaderWriterLockSlim();

		public void Init() {
			dict = new Dictionary<string, Guid>();
		}

		public Guid GetValue_lock(string key)
		{
			lock(dict) {
				Guid value;
				if (dict.TryGetValue(key, out value))
					return value;
				var newValue = Guid.NewGuid();
				dict.Add(key, newValue);
				return newValue;
			}
		}

		public Guid GetValue_RWSL(string key)
		{
			rwsl.EnterUpgradeableReadLock();
			try {
				Guid value;
				if (dict.TryGetValue(key, out value)) {
					return value;
				}
				rwsl.EnterWriteLock();
				try {
					var newValue = Guid.NewGuid();
					dict.Add(key, newValue);
					return newValue;
				} finally {
					rwsl.ExitWriteLock();
				}
			} finally {
				rwsl.ExitUpgradeableReadLock();
			}
		}
	}

	class TestDictConcurrent {
		private ConcurrentDictionary<string, Guid> dict = new ConcurrentDictionary<string, Guid>();

		public Guid GetValue(string key)
		{
			return dict.GetOrAdd(key, (k) => Guid.NewGuid());
		}
	}

	static class Test {

		static string[] test_value;

		static void Init(int size) {
			Console.WriteLine($"Init {size} values");
			test_value = new string[size];
			for(int i = 0; i < test_value.Length; i++) test_value[i] = Guid.NewGuid().ToString();
		}

		static TestDict td = new TestDict();

		static void Task1() {
			for(int i = 0; i < test_value.Length; i++) {
				for(int j = i; j < test_value.Length; j += 100) {
					var guid = td.GetValue_lock(test_value[j]);
				}
			}
		}

		static void Test1() {
			td.Init();
			Console.WriteLine("Test lock() ...");
			var sw = Stopwatch.StartNew();
			var tasks = new Task[3];
			for(int i = 0; i < tasks.Length; i++) {
				tasks[i] = Task.Run(() => Task1());
			}
			Task.WaitAll(tasks);
			Console.WriteLine($"Elapsed {sw.ElapsedMilliseconds} ms");
		}

		static void Task2() {
			for(int i = 0; i < test_value.Length; i++) {
				for(int j = i; j < test_value.Length; j += 100) {
					var guid = td.GetValue_RWSL(test_value[j]);
				}
			}
		}

		static void Test2() {
			td.Init();
			Console.WriteLine("Test ReaderWriterLockSlim() ...");
			var sw = Stopwatch.StartNew();
			var tasks = new Task[3];
			for(int i = 0; i < tasks.Length; i++) {
				tasks[i] = Task.Run(() => Task2());
			}
			Task.WaitAll(tasks);
			Console.WriteLine($"Elapsed {sw.ElapsedMilliseconds} ms");
		}

		static TestDictConcurrent tdc = new TestDictConcurrent();

		static void Task3() {
			for(int i = 0; i < test_value.Length; i++) {
				for(int j = i; j < test_value.Length; j += 100) {
					var guid = tdc.GetValue(test_value[j]);
				}
			}
		}

		static void Test3() {
			td.Init();
			Console.WriteLine("Test ConcurrentDictionary() ...");
			var sw = Stopwatch.StartNew();
			var tasks = new Task[3];
			for(int i = 0; i < tasks.Length; i++) {
				tasks[i] = Task.Run(() => Task3());
			}
			Task.WaitAll(tasks);
			Console.WriteLine($"Elapsed {sw.ElapsedMilliseconds} ms");
		}

		static void Main(string[] args) {
			Init(100000);
			Test1();
			Test2();
			Test3();
			return;
		}
	}
}