如何为串行连接包装器实现IDisposable模式

Question

I am designing a C# library that uses FTDI library to manage FTDI devices and their connections. I model it in three levels of operations: 1. Enumerate plugged devices; 2. Open/Close a connection to a specific device; 3. Write to the device, and receive bytes from it.

Currently I have the following classes:

public static class FtdiEnumerator
{
    public static IEnumerable<FtdiDevice> Enumerate()
    {
        FTDI ftdi = new FTDI();
        FTDI.FT_STATUS status;
        uint bufferLenght = 0;
        status = ftdi.GetNumberOfDevices(ref bufferLenght);
        FTDI.FT_DEVICE_INFO_NODE[] result = new FTDI.FT_DEVICE_INFO_NODE[bufferLenght];

        if (status != FTDI.FT_STATUS.FT_OK)
            return Enumerable.Empty<FtdiDevice>();

        status = ftdi.GetDeviceList(result);
        if (status != FTDI.FT_STATUS.FT_OK)
            return Enumerable.Empty<DispositivoFtdi>();

        return result.Where(node => node != null)
                     .Select(node => new DispositivoFtdi(node))
                     .ToArray(); ;
    }
}


public class FtdiDevice
{
    protected FT_DEVICE_INFO_NODE _node;
    protected FTDI _ftdi = new FTDI();

    public string Description => _node.Description;
    public string SerialNumber => _node.SerialNumber;

    public FtdiDevice(FT_DEVICE_INFO_NODE node)
    {
        _node = node;
    }

    public void Open(uint baudRate = 115200)
    {
        FT_STATUS status = _ftdi.OpenBySerialNumber(_node.SerialNumber);

        if (status != FT_STATUS.FT_OK)
            throw new Exception();

        status = _ftdi.SetBaudRate(baudRate);

        if (status != FT_STATUS.FT_OK)
            throw new Exception()
    }

    public void Close()
    {
        _ftdi.Close();
    }


    public void Write(byte[] bytes)
    {
        uint bytesReceived = 0;
        _ftdi.Write(bytes, bytes.Length, ref bytesReceived);
    }
}

I know about the IDisposable pattern, and I see a clear use case for it here, regarding FtdiDevice.Open() and FtdiDevice.Close() methods, but I see that usually the pattern is implemented with another , additional class. I imagine something like a FtdiConnection class, to be used like this, I think:

var device = new FtdiDevice(node);
using (FtdiConnection connection = device.Open())
{
    connection.Write(bytes);
}

That would imply moving the Write(byte[] bytes) method to this FtdiConnection class.

I am not sure if I am in the right track, or how much sense my idea makes, and would appreciate any clarification.

Answer 1

I think what you want to do this:

public class FtdiConnection : IDisposable
{
   private FtdiDevice device;
   public FtdiConnection(FtdiDevice device)
   {
       this.device = device;
   }
   public void Dispose()
   {
       device.Close();
   }
}

into your open method:

public FtdiConnection Open(uint baudRate = 115200)
{
    ... Open ...
    return new FtdiConnection(this);
}

and use like

var device = new FtdiDevice(node);
using (FtdiConnection connection = device.Open())
{
    connection.Write(bytes);
}

Answer 2

I found out, inspired on the discussion and previous answer, the following design answers my needs. I will add it here as an alternative to Gustavo's answer, and would be glad to know other alternatives.

The solution principle here is to have Device.Open() to return this as the disposable, thus avoiding the need for an additional Connection class:

using System;

namespace DisposableConnection
{
    class Program
    {
        static void Main(string[] args)
        {
            var device = new Device();

            using (device.Open())
            {
                device.Write();
            }

            Console.ReadKey();
        }
    }

    public class Device : IDisposable
    {
        public Device()
        {
        }

        public IDisposable Open()
        {
            Console.WriteLine("Open!!");
            return this;
        }

        public void Close()
        {
            Console.WriteLine("Close!!");
        }

        internal void Write()
        {
            Console.WriteLine("Write!!");
            //throw new Exception();   // optional, also works
        }

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