.NET에서 직렬 포트의 상태를 지속적으로 확인하는 방법은 무엇입니까?

현재 SerialPort클래스를 사용하고 있지만 카드 판독기가 물리적으로 연결 해제되었는지 확인하기 위해 내 WPF 앱 내에서 포트 (존재 / 없음) 상태를 확인하고 싶습니다.

.NET에서 할 수있는 방법이 있습니까?

내가 사용하는 코드는 다음과 같습니다.

public class Proxi
    {
        public string proxicard = "";
        public DateTime readingtime = DateTime.MinValue;
        public bool Ready = false;
        public bool Correct = false;
        public bool COMreader = false;
        public bool COMAccess = false;
        public bool COMDataCorrect = false;
        public MemoryStream COMdata = new MemoryStream();
        public SerialPort port;

        // Public Event to allow other classes to subscribe to.
        public event EventHandler CardDetected = delegate { };

        public Proxi(string portname, bool isCOM)
        {
            try
            {
                port = new SerialPort(portname, 9600, Parity.None, 8, StopBits.One)
                {
                    DtrEnable = true,
                    RtsEnable = true
                };
                port.Open();
                port.DataReceived += new SerialDataReceivedEventHandler(Port_DataReceived);
                Ready = true;
                COMreader = isCOM;
            }
            catch
            {
                proxicard = "There is no port " + portname;
            }
        }

        private void Port_DataReceived(object sender, SerialDataReceivedEventArgs e)
        {
            SerialPort serialPort = (SerialPort)sender;
            byte[] buffer = new byte[serialPort.BytesToRead];
            serialPort.Read(buffer, 0, buffer.Length);
            proxicard = "";

            if ((int)buffer[0] == 58 && !COMreader)
            {
                for (int index = 1; index < buffer.Length; ++index)
                    proxicard = proxicard + ((char)buffer[index]).ToString();

                if (proxicard.Length >= 12)
                {
                    byte[] numArray = ConvertHexToByte(proxicard, 6);
                    byte num = 0;
                    for (int index = 0; index < numArray.Length - 1; ++index)
                        num += numArray[index];
                    Correct = (int)(byte)((uint)~num + 1U) == (int)numArray[numArray.Length - 1];
                    readingtime = DateTime.Now;
                }
                else
                    Correct = false;
            }
            if ((int)buffer[0] == 1 && COMreader)
            {
                COMdata = new MemoryStream();
                COMAccess = true;
                if (buffer.Length > 1)
                    COMdata.Write(buffer, 1, buffer.Length - 1);
            }

            if (!COMAccess || !COMreader || COMdata.Length < 7L)
            {

                // Raise Event, which triggers all method subscribed to it!
                CardDetected(this, new EventArgs());

                return;
            }

            MemoryStream memoryStream = new MemoryStream();
            memoryStream.Write(new byte[1] { (byte)1 }, 0, 1);
            for (int offset = (int)COMdata.Length - 2; offset >= 0; --offset)
                memoryStream.Write(COMdata.ToArray(), offset, 1);
            Correct = (int)CRC.CRC8(memoryStream.ToArray(), (int)memoryStream.Length) == (int)COMdata.ToArray()[COMdata.Length - 1L];
            proxicard = Proxi.GetRecordHEXBytes(COMdata.ToArray(), 1, 5);
            COMdata = new MemoryStream();
            COMAccess = false;

            // Raise Event, which triggers all method subscribed to it!
            CardDetected(this, new EventArgs());
        }

        public static string GetRecordHEXBytes(byte[] data, int position, int length)
        {
            if (position + length > data.Length)
                return "";
            string str = "";
            for (int index = 0; index < length; ++index)
            {
                byte num = data[position + index];
                str += num.ToString("X2");
            }
            return str;
        }

        public byte[] ConvertHexToByte(string HexValue, int length)
        {
            byte[] numArray = new byte[length];
            for (int index = 0; index < length; ++index)
                numArray[index] = (byte)Convert.ToChar(Convert.ToUInt32(HexValue.Substring(index * 2, 2), 16));
            return numArray;
        }

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