Calling .Dispose() on a class that has a Finalizer
<p>According to <a href="https://rads.stackoverflow.com/amzn/click/com/0134141040" rel="nofollow noreferrer" rel="nofollow noreferrer">Essential C# 6.0</a> you should:</p>

<blockquote>
  <p>AVOID calling Dispose() on owned objects that have a finalizer.
  Instead, rely on the finalization queue to clean up the instance.</p>
</blockquote>

<ol>
<li>Could someone please elaborate on this as I'm not clear on what the point of Dispose is if we're not to call it from owned objects?</li>
<li>Apart from Reflection, how would you figure out if the object has a <code>Finalizer</code>?</li>
<li>How do you figure out when to call <code>Close()</code> / <code>Close()</code> + <code>Dispose()</code> other than searching the API documentation (if you have access to it and it exists) or Reflection?  I see a lot of questions around the net for very specific types ( <code>MemoryStream</code> / <code>Form</code> / <code>SqlConnection</code> / etc ) but I'm looking more at "how to figure it out yourself".</li>
</ol>

<p>According to the <a href="https://msdn.microsoft.com/en-us/library/b1yfkh5e%28v=vs.110%29.aspx?f=255&amp;MSPPError=-2147217396" rel="nofollow noreferrer">Dispose Pattern</a> you should:</p>

<blockquote>
  <p>CONSIDER providing method Close(), in addition to the Dispose(), if close is standard terminology in the area.  When doing so, it is important that you make the Close implementation identical to Dispose and consider implementing the IDisposable.Dispose method explicitly. </p>
</blockquote>

<p>but there are times when you should call both like with <code>Form</code>, etc.  Questions like "<a href="https://stackoverflow.com/questions/61092/close-and-dispose-which-to-call/61131#comment57568051_61131">Close and Dispose - which to call?</a>" get close but there's no defined approach apart from </p>

<blockquote>
  <p>As usual the answer is: it depends. Different classes implement IDisposable in different ways, and it's up to you to do the necessary research.</p>
</blockquote>

<p>Edit: Here is the full guideline, I haven't asked for permission to reproduce but since it's a guideline (thereby assuming it's supposed to be freely shared public knowledge) and not some part of the actual training material, I'm hoping I'm not breaking any rules.</p>

<blockquote>
  <p><strong>Guidelines</strong><br>
  DO implement a finalizer method only on objects with resources that are scarce or expensive, even though finalization delays garbage collection.<br>
  DO implement IDisposable to support deterministic finalization on classes with finalizers.<br>
  DO implement a finalizer method on classes that implement IDisposable in case Dispose() is not invoked explicitly.<br>
  DO refactor a finalization method to call the same code as IDisposable, perhaps simply calling the Dispose() method.<br>
  DO NOT throw exceptions from finalizer methods.<br>
  DO call System.GC.SuppressFinalize() from Dispose() to avoid repeating resource cleanup and delaying garbage collection on an object.<br>
  DO ensure that Dispose() is idempotent (it should be possible to call Dispose() multiple times).<br>
  DO keep Dispose() simple, focusing on resource cleanup required by finalization.<br>
  AVOID calling Dispose () on owned objects that have a finalizer.  Instead, rely on the finalization queue to clean up the instance.<br>
  AVOID referencing other objects that are not being finalized during finalization.<br>
  DO invoke a base class’s Dispose() method when overriding Dispose().<br>
  CONSIDER ensuring that an object becomes unusable after Dispose() is called. After an object has been disposed, methods other than Dispose() (which could potentially be called multiple times) should throw an ObjectDisposedException.<br>
  DO implement IDisposable on types that own disposable fields (or properties) and dispose of said instances.</p>
</blockquote>