diff --git a/cairo/FontFace.cs b/cairo/FontFace.cs
index efa479b6d..b24e9dfb1 100644
--- a/cairo/FontFace.cs
+++ b/cairo/FontFace.cs
@@ -50,24 +50,27 @@ namespace Cairo
 
 		~FontFace ()
 		{
-			// Since Cairo is not thread safe, we can not unref the
-			// font_face here, the programmer must do this with Dispose
-
-			Console.Error.WriteLine ("Programmer forgot to call Dispose on the FontFace");
 			Dispose (false);
 		}
 
 		public void Dispose ()
 		{
 			Dispose (true);
+			GC.SuppressFinalize (this);
 		}
 
 		protected virtual void Dispose (bool disposing)
 		{
-			if (disposing)
-				NativeMethods.cairo_font_face_destroy (handle);
+			if (handle == IntPtr.Zero)
+				return;
+
+			if (!disposing) {
+				Console.Error.WriteLine ("Cairo.FontFace: called from finalization thread, programmer is missing a call to Dispose");
+				return;
+			}
+
+			NativeMethods.cairo_font_face_destroy (handle);
 			handle = IntPtr.Zero;
-			GC.SuppressFinalize (this);
 		}
 		
 		// TODO: make non-public when all entry points are complete in binding
diff --git a/cairo/FontOptions.cs b/cairo/FontOptions.cs
index 476910f1b..fa3e84f09 100644
--- a/cairo/FontOptions.cs
+++ b/cairo/FontOptions.cs
@@ -33,7 +33,6 @@ namespace Cairo
 	public class FontOptions : IDisposable
 	{
 		IntPtr handle;
-		bool disposed;
 
 		public FontOptions ()
 		{
@@ -55,9 +54,10 @@ namespace Cairo
 			return new FontOptions (NativeMethods.cairo_font_options_copy (handle));
 		}
 
+		[Obsolete ("Use Dispose()")]
 		public void Destroy ()
 		{
-			NativeMethods.cairo_font_options_destroy (handle);
+			Dispose ();
 		}
 
 		public void Dispose ()
@@ -66,13 +66,18 @@ namespace Cairo
 			GC.SuppressFinalize (this);
 		}
 
-		private void Dispose (bool disposing)
+		protected virtual void Dispose (bool disposing)
 		{
-			if (!disposed) {
-				Destroy ();
-				handle = IntPtr.Zero;
+			if (handle == IntPtr.Zero)
+				return;
+
+			if (!disposing) {
+				Console.Error.WriteLine ("Cairo.FontOptions: called from finalization thread, programmer is missing a call to Dispose");
+				return;
 			}
-			disposed = true;
+
+			NativeMethods.cairo_font_options_destroy (handle);
+			handle = IntPtr.Zero;
 		}
 
 		public static bool operator == (FontOptions options, FontOptions other)
diff --git a/cairo/Path.cs b/cairo/Path.cs
index 3146db5d0..301ba32cd 100644
--- a/cairo/Path.cs
+++ b/cairo/Path.cs
@@ -36,7 +36,7 @@ namespace Cairo {
 
         public class Path : IDisposable 
         {
-                internal IntPtr handle = IntPtr.Zero;
+		internal IntPtr handle = IntPtr.Zero;
 		
 		internal Path (IntPtr handle)
 		{
@@ -55,9 +55,9 @@ namespace Cairo {
 			GC.SuppressFinalize (this);
 		}
 		
-                protected virtual void Dispose (bool disposing)
-                {
-			if (!disposing){
+		protected virtual void Dispose (bool disposing)
+		{
+			if (!disposing) {
 				Console.Error.WriteLine ("Cairo.Path: called from finalization thread, programmer is missing a call to Dispose");
 				return;
 			}
@@ -65,8 +65,8 @@ namespace Cairo {
 			if (handle == IntPtr.Zero)
 				return;
 
-                        NativeMethods.cairo_path_destroy (handle);
+			NativeMethods.cairo_path_destroy (handle);
 			handle = IntPtr.Zero;
-                }
-        }
+		}
+	}
 }
diff --git a/cairo/Pattern.cs b/cairo/Pattern.cs
index e0af9edf3..8a770ed92 100644
--- a/cairo/Pattern.cs
+++ b/cairo/Pattern.cs
@@ -34,7 +34,7 @@ namespace Cairo {
    
         public class Pattern : IDisposable
         {
-                protected IntPtr pattern = IntPtr.Zero;
+		protected IntPtr pattern = IntPtr.Zero;
 
 		public static Pattern Lookup (IntPtr pattern)
 		{
@@ -76,6 +76,7 @@ namespace Cairo {
 
 		~Pattern ()
 		{
+			Dispose (false);
 		}
 		
                 [Obsolete ("Use the SurfacePattern constructor")]
@@ -92,24 +93,30 @@ namespace Cairo {
 		public void Dispose ()
 		{
 			Dispose (true);
+			GC.SuppressFinalize (this);
 		}
 
 		protected virtual void Dispose (bool disposing)
 		{
-			if (disposing)
-				Destroy ();
-			GC.SuppressFinalize (this);
-		}
-		
-                public void Destroy ()
-                {
-			if (pattern != IntPtr.Zero){
-				NativeMethods.cairo_pattern_destroy (pattern);
-				pattern = IntPtr.Zero;
+			if (!disposing) {
+				Console.Error.WriteLine ("Cairo.Pattern: called from finalization thread, programmer is missing a call to Dispose");
+				return;
 			}
+
+			if (pattern == IntPtr.Zero)
+				return;
+
+			NativeMethods.cairo_pattern_destroy (pattern);
+			pattern = IntPtr.Zero;
 			lock (patterns){
 				patterns.Remove (this);
 			}
+		}
+
+		[Obsolete ("Use Dispose()")]
+                public void Destroy ()
+                {
+			Dispose ();
                 }
 		
 		public Extend Extend {
diff --git a/cairo/ScaledFont.cs b/cairo/ScaledFont.cs
index 2b0f6cf0c..a15958dae 100644
--- a/cairo/ScaledFont.cs
+++ b/cairo/ScaledFont.cs
@@ -99,10 +99,16 @@ namespace Cairo {
 
 		protected virtual void Dispose (bool disposing)
 		{
-			if (disposing) {
-				NativeMethods.cairo_scaled_font_destroy (handle);
-				handle = IntPtr.Zero;
+			if (handle == IntPtr.Zero)
+				return;
+
+			if (!disposing) {
+				Console.Error.WriteLine ("Cairo.ScaledFont: called from finalization thread, programmer is missing a call to Dispose");
+				return;
 			}
+
+			NativeMethods.cairo_scaled_font_destroy (handle);
+			handle = IntPtr.Zero;
 		}
 		
                 protected void Reference ()
diff --git a/cairo/Surface.cs b/cairo/Surface.cs
index 52d0b4886..d9369a478 100644
--- a/cairo/Surface.cs
+++ b/cairo/Surface.cs
@@ -149,6 +149,10 @@ namespace Cairo {
 		{
 			if (surface == IntPtr.Zero)
 				return;
+			if (!disposing) {
+				Console.Error.WriteLine ("Cairo.Surface: called from finalization thread, programmer is missing a call to Dispose");
+				return;
+			}
 			
 			lock (surfaces.SyncRoot)
 				surfaces.Remove (surface);