From d0d4885812c2bc77798e7f689a03dc9a59f54d12 Mon Sep 17 00:00:00 2001
From: Robert <robertcopilau@gmail.com>
Date: Wed, 10 Jan 2018 13:36:53 +0100
Subject: [PATCH] Created slim version of DisposableObject and fixed some code
 indentation

DisposableObjectSlim has no finalizer
---
 src/Umbraco.Core/DisposableObject.cs     | 90 ++++++++++++------------
 src/Umbraco.Core/DisposableObjectSlim.cs | 42 +++++++++++
 2 files changed, 87 insertions(+), 45 deletions(-)
 create mode 100644 src/Umbraco.Core/DisposableObjectSlim.cs

diff --git a/src/Umbraco.Core/DisposableObject.cs b/src/Umbraco.Core/DisposableObject.cs
index 516a9712e5..71477996ef 100644
--- a/src/Umbraco.Core/DisposableObject.cs
+++ b/src/Umbraco.Core/DisposableObject.cs
@@ -2,60 +2,60 @@ using System;
 using System.Threading;
 
 namespace Umbraco.Core
-{
-	/// <summary>
-	/// Abstract implementation of IDisposable.
-	/// </summary>
-	/// <remarks>
-	/// Can also be used as a pattern for when inheriting is not possible.
-	/// 
+{
+    /// <summary>
+    /// Abstract implementation of IDisposable.
+    /// </summary>
+    /// <remarks>
+    /// Can also be used as a pattern for when inheriting is not possible.
+    /// 
     /// See also: https://msdn.microsoft.com/en-us/library/b1yfkh5e%28v=vs.110%29.aspx
     /// See also: https://lostechies.com/chrispatterson/2012/11/29/idisposable-done-right/
     /// 
     /// Note: if an object's ctor throws, it will never be disposed, and so if that ctor
     /// has allocated disposable objects, it should take care of disposing them.
-	/// </remarks>
-	public abstract class DisposableObject : IDisposable
-	{
-		private bool _disposed;
-	    private readonly object _locko = new object();
-
-		// gets a value indicating whether this instance is disposed.
-        // for internal tests only (not thread safe)
-        //TODO make this internal + rename "Disposed" when we can break compatibility
-		public bool IsDisposed { get { return _disposed; } }
-
-		// implements IDisposable
-		public void Dispose()
-		{
-			Dispose(true);
-			GC.SuppressFinalize(this);
-		}
-
-        // finalizer
-		~DisposableObject()
-		{
-			Dispose(false);
-		}
+    /// </remarks>
+    public abstract class DisposableObject : IDisposable
+    {
+        private bool _disposed;
+        private readonly object _locko = new object();
+
+        // gets a value indicating whether this instance is disposed.
+        // for internal tests only (not thread safe)
+        //TODO make this internal + rename "Disposed" when we can break compatibility
+        public bool IsDisposed { get { return _disposed; } }
+
+        // implements IDisposable
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        // finalizer
+        ~DisposableObject()
+        {
+            Dispose(false);
+        }
 
         //TODO make this private, non-virtual when we can break compatibility
-        protected virtual void Dispose(bool disposing)
-		{
-		    lock (_locko)
-		    {
-		        if (_disposed) return;
-		        _disposed = true;
-		    }
+        protected virtual void Dispose(bool disposing)
+        {
+            lock (_locko)
+            {
+                if (_disposed) return;
+                _disposed = true;
+            }
 
             DisposeUnmanagedResources();
 
             if (disposing)
-                DisposeResources();
-		}
-
-		protected abstract void DisposeResources();
-
-		protected virtual void DisposeUnmanagedResources()
-		{ }
-	}
+                DisposeResources();
+        }
+
+        protected abstract void DisposeResources();
+
+        protected virtual void DisposeUnmanagedResources()
+        { }
+    }
 }
\ No newline at end of file
diff --git a/src/Umbraco.Core/DisposableObjectSlim.cs b/src/Umbraco.Core/DisposableObjectSlim.cs
new file mode 100644
index 0000000000..bcec6165db
--- /dev/null
+++ b/src/Umbraco.Core/DisposableObjectSlim.cs
@@ -0,0 +1,42 @@
+using System;
+
+namespace Umbraco.Core
+{
+    public abstract class DisposableObjectSlim : IDisposable
+    {
+        private bool _disposed;
+        private readonly object _locko = new object();
+
+        // gets a value indicating whether this instance is disposed.
+        // for internal tests only (not thread safe)
+        //TODO make this internal + rename "Disposed" when we can break compatibility
+        public bool IsDisposed { get { return _disposed; } }
+
+        // implements IDisposable
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        //TODO make this private, non-virtual when we can break compatibility
+        protected virtual void Dispose(bool disposing)
+        {
+            lock (_locko)
+            {
+                if (_disposed) return;
+                _disposed = true;
+            }
+
+            DisposeUnmanagedResources();
+
+            if (disposing)
+                DisposeResources();
+        }
+
+        protected abstract void DisposeResources();
+
+        protected virtual void DisposeUnmanagedResources()
+        { }
+    }
+}