C＃哪个更快：SerialPort.Write（byte []，int，int）或SerialPort.BaseStream.WriteByte（）？

Question

I am working some code that controls a device via serial port (over usb). This application will need to be able to run in the background, yet push a fair amount of data continuously over the port, so I need the data writing code to be reasonably fast. My code pushes its data in large batches ("frames") multiple times per second. Currently, I have a Queue that is used to generate the commands that need to be sent for the current frame. Would it be faster to just iterate through the Queue and push my commands one at a time using SerialPort.BaseStream.WriteByte(byte), or use the Queue to build up a byte array and send it all at once using SerialPort.Write(byte[], int, int)?

Some example code, if my description is confusing: Which is faster, this:

   public void PushData(List<KeyValuePair<Address, byte>> data) {
        Queue<DataPushAction> actions = BuildActionQueue(data);
        foreach(var item in actions) {
            port.BaseStream.WriteByte(item.Value);
        }
    }

or this:

    public void PushData(List<KeyValuePair<Address, byte>> data) {
        Queue<DataPushAction> actions = BuildActionQueue(data);
        byte[] buffer = actions.Select(x => x.Value).ToArray();
        port.Write(buffer, 0, buffer.Length);
    }

Update

Upon closer inspection of the source code, it seems that both methods are the same (WriteByte just uses a temporary array with one element and is otherwise the same as Write). However, this doesn't actually answer the question, just rephrases it: Is it faster to write many small arrays of bytes or one large one?

Answer 1

By modifying the code in Rion's answer below, I was able to test this and got some surprising results. I used the following code (modified from Rion, thanks):

    class Program {
    static void Main(string[] args) {
        // Create a stopwatch for performance testing
        var stopwatch = new Stopwatch();
        // Test content
        var data = GetTestingBytes();

        var ports = SerialPort.GetPortNames();
        using (SerialPort port = new SerialPort(ports[0], 115200, Parity.None, 8, StopBits.One)) {
            port.Open();

            // Looping Test
            stopwatch.Start();
            foreach (var item in data) {
                port.BaseStream.WriteByte(item);
            }
            stopwatch.Stop();
            Console.WriteLine($"Loop Test: {stopwatch.Elapsed}");

            stopwatch.Start();
            port.Write(data, 0, data.Length);
            stopwatch.Stop();
            Console.WriteLine($"All At Once Test: {stopwatch.Elapsed}");
        }

        Console.Read();
    }

    static byte[] GetTestingBytes() {
        var str = String.Join(",", Enumerable.Range(0, 1000).Select(x => Guid.NewGuid()).ToArray());
        byte[] bytes = new byte[str.Length * sizeof(char)];
        System.Buffer.BlockCopy(str.ToCharArray(), 0, bytes, 0, bytes.Length);
        return bytes;
    }
}

The results were extremely surprising; using the method that takes an array of bytes took almost exactly twice as long at 12.5818728 seconds compared to 6.2935748 seconds when just calling WriteByte repeatedly. This was the opposite result than I was expecting. Either way, I wasn't expecting one method to be twice as fast as the other!

If anyone can figure out why this is the case, I would love to know!

Answer 2

Based on a quick glance at the source , it looks like the SerialPort.Write() method actually just points to the Write() method of the underlying stream anyways :

public void Write(byte[] buffer, int offset, int count)
{
            if (!IsOpen)
                throw new InvalidOperationException(SR.GetString(SR.Port_not_open));
            if (buffer==null)
                throw new ArgumentNullException("buffer", SR.GetString(SR.ArgumentNull_Buffer));
            if (offset < 0)
                throw new ArgumentOutOfRangeException("offset", SR.GetString(SR.ArgumentOutOfRange_NeedNonNegNumRequired));
            if (count < 0)
                throw new ArgumentOutOfRangeException("count", SR.GetString(SR.ArgumentOutOfRange_NeedNonNegNumRequired));
            if (buffer.Length - offset < count)
                throw new ArgumentException(SR.GetString(SR.Argument_InvalidOffLen));
            if (buffer.Length == 0) return;

            internalSerialStream.Write(buffer, offset, count, writeTimeout);
}

If I had to wager a guess, I would assume that the difference between the two performance wise might be negligible. I suppose if you had some test data, you could create a StopWatch to actually time the differences between both approaches.

Update with Performance Tests

I didn't test this using SerialPort objects, but instead opted for basic MemoryStream ones as the real heart of the question seemed to be if writing bytes in a loop is more performant than writing them using a byte[] .

For test data, I simply generated 1000 random Guid objects and concatenated them into a string :

static byte[] GetTestingBytes()
{
        var str = String.Join(",", Enumerable.Range(0, 1000).Select(x => Guid.NewGuid()).ToArray());
        byte[] bytes = new byte[str.Length * sizeof(char)];
        System.Buffer.BlockCopy(str.ToCharArray(), 0, bytes, 0, bytes.Length);
        return bytes;
}

As far as the tests themselves go :

// Create a stopwatch for performance testing
var stopwatch = new Stopwatch();
 // Test content
var data = GetTestingBytes();

// Looping Test
using (var loop = new MemoryStream())
{
      stopwatch.Start();
      foreach (var item in data)
      {
            loop.WriteByte(item);
      }
      stopwatch.Stop();
      Console.WriteLine($"Loop Test: {stopwatch.Elapsed}");
}
// Buffered Test
using (var buffer = new MemoryStream())
{
      stopwatch.Start();
      buffer.Write(data, 0, data.Length);
      stopwatch.Stop();
      Console.WriteLine($"Buffer Test: {stopwatch.Elapsed}");
}

After running the tests a few times, the averages after 1000 tests broke down as follows :

  LOOP: 00:00:00.0976584
BUFFER: 00:00:00.0976629

So the looping approach, at least in the context of using MemoryStream objects, appears to be the winner.

You can see the entire testing code here if you want to run it yourself.