Создание класса для работы с последовательным портом

Question

Моя цель: У меня есть HASP, с которым мне нужно общаться с помощью последовательного порта. Возможно, многие функции из разных потоков могут связываться с этим HASP - и мне нужна некоторая синхронизация.

Что я сделал: Я создал класс оболочки HASPClass. Выглядит так:

class HASPCLass 
{ 
    SerialPort m_port; 
    HASPClass(..) 
    { 
    //.. Init some other properties 
    m_port.Open(); 
    //.. 
    } 
    void CustomWriteToHASP() 
    { 
    //.. Do something 
    m_port.Write(...); 
    } 
    void CustomReadHASP() 
    { 
    //.. Do something 
    m_port.Read(...); 
    } 
    void Close() 
    { 
    //Some code to close m_port 
    }; 
} 

Использование этого класса будет:

FUNCTION1 из некоторой нити:

HASPClass o = new HASPClass(..); 
o.CustomWriteToHASP(..) 

Function2 из другого потока:

HASPClass o1 = new HASPClass(..); 
o1.CustomReadHASP(..) 

задачи1: Теперь, если o не закрыл m_port - конструктор o1 будет бросать, так как порт открыт. Я хочу избежать этого и сделать o1 ждать o, чтобы закончить работу.

То, что я думал,: Может быть, я должен сделать m_port статический - статический и поставить замок везде, где он используется в HASPClass, будет ли он решить вышеуказанную проблему? Также конструктор будет заменен только открытым статическим m_port, если он закрыт. Будет ли этот подход решать большинство проблем, о которых я говорил ранее?

---

Update: Моя другая проблема заключается в том, что различные объекты могут задавать различные параметры (скорость передачи данных и т.д.) в конструкторе - так я сталкиваюсь с проблемой :(так как я один статический m_port :(Что.. делать в таком случае ?? (? я мог бы ослабить это требование и сказать, что все объекты будут ставить одни и те же параметры в конструкторе, но это поможет)

Answer 1

простой синглтон шаблон может выглядеть следующим образом:

class HASPClass 
{ 
    private static HASPClass _instance; 

    private HASPClass(..) 
    { 
    //.. Init some other properties 

    } 

    public static GetInstance(...) 
    { 
     // Note, if called with different parameters then this will be 
     // quite a bit more complicated 
     if (_instance == null) 
     { 
      _instance = new HASPClass(...) 
     } 
     return _instance; 
    } 
} 

Теперь, когда вы называете это, вы могли бы сделать что-то вроде:

HASPClass o = HASPClass.GetInstance(..); 
o.CustomWriteToHASP(..) 

... Но так как вы многопоточности, эта модель не будет в безопасности. Вам нужно будет выполнить некоторую блокировку вокруг критического раздела GetInstance, чтобы убедиться, что вы не создаете несколько объектов. Таким образом, вы могли бы сделать что-то вроде:

private static object lockObj = new object(); 
    public static GetInstance(...) 
    { 
     // Note, if called with different parameters then this will be 
     // quite a bit more complicated 
     if (_instance == null) 
     { 
      lock (lockObj) 
      { 
       if (_instance == null) 
       { 
        _instance = new HASPClass(...) 
       } 
      } 
     } 
     return _instance; 
    } 

Лучше, чем вручную блокировка будет использовать Lazy, но это может быть сложным, если вам нужно передать параметры. Если (как я полагаю) эти параметры только когда-либо передаются один раз, вы можете захотеть иметь отдельную функцию инициализации, которая будет хранить эти параметры, поэтому вам не нужно передавать их при получении вашего экземпляра.

Если параметры одинаковы каждый раз, вы могли бы, возможно, попробовать что-то вроде этого:

class HASPClass 
{ 
    private static ParameterObject _parameters; 

    private static Lazy<HASPClass> _instance = new Lazy<HASPClass>(() => 
    { 
     if (_parameters == null) 
     { 
      throw new InvalidOperationException("Can get instance before initializing"); 
     } 
     return new HASPClass(_parameters); 
    }); 

    public static HASPClass Instance 
    { 
     get { return _instance.Value; } 
    } 

    private HASPClass(ParametersObject parameters) 
    { 
     // create and populate your object using values from parameters 
    } 

    public static void Initialize(ParameterObject parameters) 
    { 
     if (_parameters != null) 
     { 
      // you might throw an exception here if this is not allowed 
      // Or you might drop and recreate your object if it is allowed 
     } 
     _parameters = parameters; 
    } 
} 

Вы можете или не должны иметь блокировку вокруг Initialize, но идея будет то, что вы, вероятно, сначала вызовите Initialize из родительского потока, чтобы он никогда не нуждался в вызове из любого другого потока.

Answer 2

class HASPCLass 
{ 
    static SerialPort m_port; 

    HASPClass(..) 
    { 
    lock(m_port) 
    { 
     if (!Initialized()) 
     { 
     Initialize(); 
     } 
    } 
    } 
    void Close() 
    { 
    lock(m_port) 
    { 
     if (Initialized()) 
     { 
     Uninitialize(); 
     } 
    } 
    } 
} 

Answer 3

Вот еще один вариант кода для вас. Он должен работать в любом случае. Он вновь открывает порт в случае запроса другой скорости передачи.

class HASPCLass 
{ 
    private static SerialPort m_port; 
    private static bool m_initialized; 
    private static int m_baudRate; 

    public HASPClass(int baudRate) 
    { 
    lock(m_port) 
    { 
     if (!m_initialized) 
     { 
     Initialize(baudRate); 
     } 
    } 
    } 

    private Initialize() 
    { 
    m_port.open(baudRate); 
    m_baudRate = baudRate; 
    m_initialized = true; 
    } 

    private Uninitialize() 
    { 
    m_port.close(); 
    m_initialized = false; 
    } 

    private ReinitializeIfNeeded(int baudRate) 
    { 
    if (baudRate != m_baudRate) 
    { 
     Uninitialize(); 
     Initialize(baudRate); 
    } 
    } 

    public void Read(int baudRate, out buff) 
    { 
    lock(m_port) 
    { 
     ReinitializeIfNeeded(baudRate); 
     m_port.Read(out buff); 
    } 
    } 

    public void Write(int baudRate, in buff) 
    { 
    lock(m_port) 
    { 
     ReinitializeIfNeeded(baudRate); 
     m_port.Write(buff); 
    } 
    } 

    public void Close() 
    { 
    lock(m_port) 
    { 
     if (m_initialized) 
     { 
     Uninitialize(); 
     } 
    } 
    } 
}