GC.KeepAlive to maintain context

Question

I have a class that is a simple wrapper for WNetUseConnection

Here is the implementation (for reference only):

internal class RemoteFileSystemContext : IDisposable
{
    private readonly string _remoteUnc;
    private bool _isConnected;
    public RemoteFileSystemContext(string remoteUnc, string username, string password, bool promptUser)
    {
        if (WindowsNetworking.TryConnectToRemote(remoteUnc, username, password, promptUser))
        {
            _isConnected = true;
            _remoteUnc = remoteUnc;
        }
        else
        {
            GC.SuppressFinalize(this);
        }
    }

    public void Dispose()
    {
        Dispose(true);
    }

    ~RemoteFileSystemContext()
    {
        Dispose(false);
    }

    private void Dispose(bool isDisposing)
    {
        if (!_isConnected)
            return;
        _isConnected = false;
        if (isDisposing)
        {
            GC.SuppressFinalize(this);
        }
        WindowsNetworking.DisconnectRemote(_remoteUnc);
    }
}

and here is used:

using (var context = WindowsNetworking.CreateRemoteContext(storagePath, login, pass))
{
    // do something with storagePath
    GC.KeepAlive(context);
}

The question is whether to write GC.KeepAlive(context)or not? I mean that I did not write such code until I read the article (about AsyncLock, but now I can not find the link), and now I'm not sure that the GC can call the finalizer before this method completes. Theoretically, it should use Disposein the section finally using, but this article is written by a smart guy, so I'm not sure right now.

---

Just in case, I provide the code for the reference class:

public static class WindowsNetworking
{
    public static bool TryConnectToRemote(string remoteUnc, string username, string password, bool promptUser = false)
    {
        bool isUnc = remoteUnc != null && remoteUnc.Length >= 2 && remoteUnc[0] == '\\' && remoteUnc[1] == '\\';
        if (!isUnc)
        {
            return false;
        }
        ConnectToRemote(remoteUnc, username, password, promptUser);
        return true;
    }

    public static IDisposable CreateRemoteContext(string remoteUnc, string username, string password, bool promptUser = false)
    {
        return new RemoteFileSystemContext(remoteUnc, username, password, promptUser);
    }

    public static void DisconnectRemote(string remoteUNC)
    {
        var ret = (NetworkError) WNetCancelConnection2(remoteUNC, CONNECT_UPDATE_PROFILE, false);
        if (ret != NetworkError.NO_ERROR)
        {
            throw new Win32Exception((int) ret, ret.ToString());
        }
    }

    [DllImport("Mpr.dll")]
    private static extern int WNetUseConnection(
        IntPtr hwndOwner,
        NETRESOURCE lpNetResource,
        string lpPassword,
        string lpUserID,
        int dwFlags,
        string lpAccessName,
        string lpBufferSize,
        string lpResult
        );

    [DllImport("Mpr.dll")]
    private static extern int WNetCancelConnection2(
        string lpName,
        int dwFlags,
        bool fForce
        );

    [StructLayout(LayoutKind.Sequential)]
    private class NETRESOURCE
    {
        public int dwScope = 0;
        public int dwType = 0;
        public int dwDisplayType = 0;
        public int dwUsage = 0;
        public string lpLocalName = "";
        public string lpRemoteName = "";
        public string lpComment = "";
        public string lpProvider = "";
    }

    private static void ConnectToRemote(string remoteUNC, string username, string password, bool promptUser)
    {
        NETRESOURCE nr = new NETRESOURCE
        {
            dwType = RESOURCETYPE_DISK,
            lpRemoteName = remoteUNC
        };

        NetworkError ret;
        if (promptUser)
            ret = (NetworkError) WNetUseConnection(IntPtr.Zero, nr, "", "", CONNECT_INTERACTIVE | CONNECT_PROMPT, null, null, null);
        else
            ret = (NetworkError) WNetUseConnection(IntPtr.Zero, nr, password, username, 0, null, null, null);

        if (ret != NetworkError.NO_ERROR)
        {
            throw new Win32Exception((int) ret, ret.ToString());
        }
    }
}

Answer 1

GC.KeepAlive . , , , , , , .

, , KeepAlive, - finally, Dispose. , GC.KeepAlive .

Answer 2

, , , .

using System;

namespace SandboxConsole
{ 
    class Program
    {
        static void Main(string[] args)
        {
            using (var context = new TestClass())
            {

                GC.Collect();
                GC.WaitForPendingFinalizers();
                GC.Collect();

                Console.WriteLine("After collection");
            }
            Console.WriteLine("After dispose, before 2nd collection");

            GC.Collect();
            GC.WaitForPendingFinalizers();
            GC.Collect();

            Console.WriteLine("After 2nd collection");
            Console.ReadLine();
        }
    }

    internal class TestClass : IDisposable
    {
        public void Dispose()
        {
            Dispose(true);
        }

        ~TestClass()
        {
            Console.WriteLine("In finalizer");
            Dispose(false);
        }

        private void Dispose(bool isDisposing)
        {
            Console.WriteLine("In Dispose: {0}", isDisposing);
            if (isDisposing)
            {
                //uncomment this line out to have the finalizer never run
                //GC.SuppressFinalize(this);
            }
        }
    }
}

After collection
In Dispose: True
After dispose, before 2nd collection
In finalizer
In Dispose: False
After 2nd collection

---

, IL

.method private hidebysig static void  Main(string[] args) cil managed
{
  .entrypoint
  // Code size       85 (0x55)
  .maxstack  1
  .locals init ([0] class SandboxConsole.TestClass context)
  IL_0000:  newobj     instance void SandboxConsole.TestClass::.ctor()
  IL_0005:  stloc.0
  .try
  {
    IL_0006:  call       void [mscorlib]System.GC::Collect()
    IL_000b:  call       void [mscorlib]System.GC::WaitForPendingFinalizers()
    IL_0010:  call       void [mscorlib]System.GC::Collect()
    IL_0015:  ldstr      "After collection"
    IL_001a:  call       void [mscorlib]System.Console::WriteLine(string)
    IL_001f:  leave.s    IL_002b
  }  // end .try
  finally
  {
    IL_0021:  ldloc.0
    IL_0022:  brfalse.s  IL_002a
    IL_0024:  ldloc.0
    IL_0025:  callvirt   instance void [mscorlib]System.IDisposable::Dispose()
    IL_002a:  endfinally
  }  // end handler
  IL_002b:  ldstr      "After dispose, before 2nd collection"
  IL_0030:  call       void [mscorlib]System.Console::WriteLine(string)
  IL_0035:  call       void [mscorlib]System.GC::Collect()
  IL_003a:  call       void [mscorlib]System.GC::WaitForPendingFinalizers()
  IL_003f:  call       void [mscorlib]System.GC::Collect()
  IL_0044:  ldstr      "After 2nd collection"
  IL_0049:  call       void [mscorlib]System.Console::WriteLine(string)
  IL_004e:  call       string [mscorlib]System.Console::ReadLine()
  IL_0053:  pop
  IL_0054:  ret
} // end of method Program::Main

, finally, , , Dispose . .

: . Damien , - , , this . , ( ) GC.SuppressFinalize(this); .