C#

public static class OldHaspCommunication
 {
    private static SerialPort m_port;
    private static string m_portName;
    private static bool m_isOpen = false;

    private static int m_baudRate;
    private static Parity m_parity;
    private static int m_dataBits;
    private static StopBits m_stopBits;
    private static bool m_xonxoff;
    private static bool m_dtr;
    private static bool m_rts;

    // ................................

    // Open port.
    public static void OpenPort(string portName,
                                int baudRate,
                                Parity parity,
                                int dataBits,
                                StopBits stopBits,
                                bool dtr,
                                bool rts,
                                bool xonxoff = false)
    {

        // Create new Serial Port object
        m_port = new SerialPort(portName, baudRate, parity, dataBits, stopBits);

        // .........................................
        // Set class member variables.

        m_portName = portName;
        m_baudRate = baudRate;
        m_parity = parity;
        m_dataBits = dataBits;
        m_stopBits = stopBits;
        m_xonxoff = xonxoff;
        m_dtr = dtr;
        m_rts = rts;

        // ............................................
        // Initialize some port object properties

        // XOnXOff - parameter
        if (xonxoff)
            m_port.Handshake = Handshake.XOnXOff;

        // Set DTR/RTS
        m_port.DtrEnable = dtr;
        m_port.RtsEnable = rts;

        // Set
        m_port.ReadTimeout = 500;
        m_port.WriteTimeout = 500;

        // ..............................................
        // Some final steps.

        // Open the port for communications
        m_port.Open();

        // If we get this far, mark port as opened.
        m_isOpen = true;
    }

    /// <summary>
    /// Just makes sure to read the specified number of bytes from the serial port.
    /// Typical reads may return fewer bytes then told to read. This method is used
    /// to avoid this problem.
    /// Based on a similar function from Jon Skeet: http://jonskeet.uk/csharp/readbinary.html
    /// </summary>
    /// <param name="data"> [OUT] Data read should be stored here</param>
    /// <param name="length"> [IN] How much data to read exactly </param>
    /// <param name="count"> [IN] Some kind of retry count parameter.</param>
    private static void ReadAll(byte[] data, uint length, int retryCount)
    {

        // Check data length parameter.
        if (length > data.Length)
        {
            throw new Exception("Wrong data length in ReadAll");
        }

        int offset = 0;
        int i = 0;
        int remaining = checked((int)length); // NOTE: Will throw OverflowException if length > Int32.MaxValue due to checked keyword.

        // Start reading.
        while (remaining > 0)
        {
            // Just a retry count check
            if (i >= retryCount)
            {
                throw new Exception("Exceeded retry count parameter during reading in ReadAll");
            }

            // Read Certain amount of bytes
            int read = m_port.Read(data, offset, remaining);

            // Was there error?
            if (read <= 0)
            {
                throw new EndOfStreamException(String.Format("ReadAll(OldHaspCommunication) - End of data reached with {0} bytes left to read", remaining));
            }

            // Advance offset, and decrease remaining count.
            remaining -= read;
            offset += read;

            i++;

        }


    }

    /// <summary>
    /// Write specified number of bytes to the serial port
    /// </summary>
    /// <param name="data"> [IN] Buffer from which to write data</param>
    /// <param name="length"> [IN] How many bytes to write</param>
    private static void WriteAll(byte[] data, uint length)
    {
        // TODO: Maybe we should add a retry count as in C++

        int len = checked((int)length); // NOTE: Will throw OverflowException if length > Int32.MaxValue due to checked keyword.

        // We can't write more data to serial port than available in the array.
        if (len > data.Length)
        {
            throw new Exception("Wrong data length in WriteAll");
        }

        // Do the write.
        m_port.Write(data, 0, len);
    }





    /// <summary>
    /// Close the serial port.
    /// NOTE: Don't forget to call this one.
    /// </summary>
    public static void ClosePort()
    {
        if (m_isOpen)
        {
            Reset(); // Calls our custom Reset function.
            m_port.Close(); // Close port
            m_isOpen = false; // Mark this object as closed.
        }
    }

    // ...
    private static void Reset()
    {
        m_port.DiscardInBuffer();
        m_port.DiscardOutBuffer();
    }


}

public class SomeClass
{
    public int? SomeInt1 { private set; get; }
    public int? SomeInt2 { private set; get; }
    public string SomeString { private set; get; }

    public SomeClass(int? someint1 = null, int? someint2 = null, string somestring = null)
    {
        SomeInt1 = someint1;
        SomeInt2 = someint2;
        SomeString = somestring;
    }
}

SomeClass sc1 = new SomeClass();
SomeClass sc2 = new SomeClass(someint1: 100);
SomeClass sc3 = new SomeClass(somestring: "hello");
SomeClass sc4 = new SomeClass(someint1: 999, someint2: 345, somestring: "goodbye");
SomeClass sc5 = new SomeClass(somestring: "hello", someint2: 555);