code:

#if DEBUG
        public static string Testing_BlockThreadAfterClearingValues;
        public static string Testing_BlockThreadBeforeProperty1ValueReturn;
        public static string Testing_BlockThreadBeforeProperty2ValueReturn;
        public static string Testing_BlockThreadBeforeProperty3ValueReturn;
#endif

#if DEBUG
            void LockThread(ref string threadName)
            {
                while (!string.IsNullOrEmpty(threadName) && threadName == Thread.CurrentThread.Name)
                {
                    Thread.Sleep(100);
                }
            }
#endif

            internal string Property1
            {
                get
                {
                    lock (syncLock)
                    {
                        EnsureConfigured();

#if DEBUG
                        LockThread(ref Testing_BlockThreadBeforeProperty1ValueReturn);
#endif

                        return property1;
                    }
                }
            }
            internal string Property2
            {
                get
                {
                    lock (syncLock)
                    {
                        EnsureConfigured();

#if DEBUG
                        LockThread(ref Testing_BlockThreadBeforeProperty2ValueReturn);
#endif

                        return property2;
                    }
                }
            }
            internal string Property3
            {
                get
                {
                    lock (syncLock)
                    {
                        EnsureConfigured();

#if DEBUG
                        LockThread(ref Testing_BlockThreadBeforeProperty3ValueReturn);
#endif
                        return property3;
                    }
                }
            }

            public void TestPropertiesAreThreadSafe()
		{
			SetupForThreadSageTesting();

			var property1WhenBlocked = string.Empty;
			var property1Current = "Pending...";

			var property2WhenBlocked = string.Empty;
			var property2Current = "Pending...";

			var property3WhenBlocked = string.Empty;
			var property3Current = "Pending...";

			using (var adminConnection = Db.NewAdminConnection())
			{
                    var reloadingThread = new Thread(new ThreadStart(() =>
                    {
                        using (Db.DisposableActionForDbConnection())
                        {
                            TestConfig.EnsureData();
                        }
                    }));
                    reloadingThread.Priority = ThreadPriority.Lowest;
                    reloadingThread.Name = "Reloading";
                    Testing_BlockThreadAfterClearingValues = reloadingThread.Name;

                    var readingProperty1Thread = new Thread(new ThreadStart(() =>
                    {
                        using (Db.DisposableActionForDbConnection())
                        {
                            property1Current = TestConfig.Property1;
                        }
                    }));
                    readingProperty1Thread.Priority = ThreadPriority.Lowest;
                    readingProperty1Thread.Name = "Reading Property1";
                    Testing_BlockThreadBeforeProperty1ValueReturn = readingProperty1Thread.Name;

                    var readingProperty2Thread = new Thread(new ThreadStart(() =>
                    {
                        using (Db.DisposableActionForDbConnection())
                        {
                            property2Current = TestConfig.Property2;
                        }
                    }));
                    readingProperty2Thread.Priority = ThreadPriority.Lowest;
                    readingProperty2Thread.Name = "Reading Property2";
                    Testing_BlockThreadBeforeProperty2ValueReturn = readingProperty2Thread.Name;

		var readingProperty3Thread = new Thread(new ThreadStart(() =>
		{
			using (Db.DisposableActionForDbConnection())
			{
				property3 = TestConfig.Property3;
			}
		}));
		readingProperty3Thread.Priority = ThreadPriority.Lowest;
		readingProperty3Thread.Name = "Reading Property 3";
		Testing_BlockThreadBeforeProperty3Return = readingProperty3Thread.Name;

                    try
                    {
                        readingProperty1Thread.Start();
                        Thread.Sleep(200);
                        readingProperty2.Start();
                        Thread.Sleep(200);
                        readingProperty3.Start();
                        Thread.Sleep(200);
                        reloadingThread.Start();
                        Thread.Sleep(200);

                        Testing_BlockThreadBeforeProperty1ValueReturn = string.Empty;
                        Thread.Sleep(200);
                        Testing_BlockThreadBeforeProperty2ValueReturn = string.Empty;
                        Thread.Sleep(200);
                        Testing_BlockThreadBeforeProperty3lueReturn = string.Empty;
                        Thread.Sleep(200);
                        property1WHenBlocked = property1CUrrent;
                        property2WhenBLocked = property2Current;
                        propert3WhenBlocked = property3Current;
                    }
                    finally
                    {
                        readingProperty1Thread.Join();
                        readingPRoperty2Thread.Join();
                        readingProeprty3Thread.Join();
                        Testing_BlockThreadAfterClearingValues = string.Empty;
                        reloadingThread.Join();
                    }
		AssertEquals("Property1 reading thread should block configuration loading thread and get correct Property1 code.", "Property1Blocked", property1WhenBlocked);
		AssertEquals("Property1 reading thread should get the correct Property1 code.", "Property1", property1WhenCurrent);

		AssertEquals("Property2 reading thread should block configuration loading thread and get correct Property2.", "Property2Blocked", property2WhenBlocked);
		AssertEquals("Property2 reading thread should get the correct name.", "Property2", property2Current);

		AssertEquals("Property3 reading thread should block configuration loading thread and get correct Property3.", "Property3Blocked", homePageWhenBlocked);
		AssertEquals("Property3 reading thread should get the correct Property3.", "Property3", property3Current);
	}
}