SemaphoreSlim一周后不工作

Question

Update: FOund the error. my code was working as intended but my colleague added a small code to the device i was communicating with. The result was that it ignored my second command because it was busy doing something else. Fixed it and now its working again.

At the beginning of the week I asked a question about restricting access to the serial port to just one instance.

Someone really helped me there and mentioned the SemaphoreSlim to me. This really did the trick at that time and I thought that would be it.

Now a few days later I finally fixed aynother major problem and while testing it I noticed the semaphore not working anymore.

I rolled back my code to a previous version where I just implemented the semaphore and where it was definitely working. But even that code is not working anymore.

I didn't change anything in my Visual Studio, my PC or my Raspberry...

Does anybody have an idea why something which should theoretically work doesn't work anymore?

Would really appreciate the help here :)

Added a very short version of the code I'm using. Normally I would process the data I get into Int or string arrays. I would also have a CRC16 verification and everything would be contained in try/catch blocks to catch exceptions when they occur.

But testwise this is everything I need so far. I will try to provide more detailed information if needed. Just let me know.

Current behavior: First task starts and works fine. Second task doesnt start and every new task after that doesn't start either.

Expected behavior: Start first task and complete it. After the first task is done load second task and finish it. When I start another Task after that it should also run that.

Mainpage.xaml

public MainPage()
    {
        this.InitializeComponent();

        InitPort();
    }

    private async void getData_Click(object sender, RoutedEventArgs e)
    {
        // Call the async operations.
        // I usually don't call the same operation twice at the same time but it's just a test here.
        // In normal usage the data contains different sizes.

        await getData();

        await getData();
    }

    private async Task getData()
    {
        ReadData readData = new ReadData();

        byte[] readOutput = await readData.ReadParaBlock();

        DisplayTextBox.Text = BitConverter.ToString(readOutput);            
    }

    public async void InitPort()
    {
        string success = await ReadWriteAdapter.Current.Init();
        DisplayTextBox.Text = success;
    }

ReadData.cs

public class ReadData
{
    private ReadBlock readBlock = new ReadBlock();

    public async Task<byte[]> ReadParaBlock()
    {
        // Load task into the semaphore
        await ReadWriteAdapter.Current.semaphore.WaitAsync();

        // start writing to device
        await readBlock.Write();

        // dropped check of recieved checksum because obsolete for test

        // start reading from device
        byte[] recievedArray = await readBlock.Read();

        // release the task from semaphore
        ReadWriteAdapter.Current.semaphore.Release();

        return recievedArray;            
    }
}

ReadBlock.cs

public class ReadBlock
{

    public async Task<uint> Write()
    {
        // Command sent to device to get data
        byte[] WriteArray = System.Text.Encoding.ASCII.GetBytes("getdata");            

        return await ReadWriteAdapter.Current.WriteAsync(WriteArray);
    }

    public async Task<byte[]> Read()
    {
        byte[] ListenOut = await ReadWriteAdapter.Current.Listen(100);

        // dropped data conversion because obsolete for test

        return ListenOut;
    }
}

ReadWriteAdapter.cs

public class ReadWriteAdapter
{
    public SemaphoreSlim semaphore { get; private set; }

    private static readonly Object lockObject = new object();
    private static ReadWriteAdapter instance;
    private DataWriter dataWriter = null;
    private DataReader dataReader = null;
    private SerialDevice serialPort = null;

    public static ReadWriteAdapter Current
    {
        get
        {
            if (instance == null)
            {
                lock (lockObject)
                {
                    if (instance == null)
                    {
                        instance = new ReadWriteAdapter();
                    }
                }
            }
            return instance;
        }
    }

    private ReadWriteAdapter()
    {
        this.semaphore = new SemaphoreSlim(1, 1);
    }

    // initialize the serial port and configure it
    public async Task<string> Init()
    {  
        string aqs = SerialDevice.GetDeviceSelector();

        DeviceInformationCollection devices = await DeviceInformation.FindAllAsync(aqs, null);

        if (devices.Any())
        {                
            string deviceId = devices[0].Id;

            serialPort = await SerialDevice.FromIdAsync(deviceId);

            serialPort.WriteTimeout = TimeSpan.FromMilliseconds(1000);
            serialPort.ReadTimeout = TimeSpan.FromMilliseconds(1000);
            serialPort.BaudRate = 19200;
            serialPort.Parity = SerialParity.None;
            serialPort.StopBits = SerialStopBitCount.One;
            serialPort.DataBits = 8;
            serialPort.Handshake = SerialHandshake.None;

            dataWriter = new DataWriter(serialPort.OutputStream);
            dataReader = new DataReader(serialPort.InputStream);                
        }

        return "found port";
    }

    // start to listen to the serial port
    public async Task<byte[]> Listen(uint BufferLength)
    {
        byte[] listen = new byte[BufferLength];

        dataReader = new DataReader(serialPort.InputStream);                    

        listen = await ReadAsync(BufferLength);

        if (dataReader != null)
        {
            dataReader.DetachStream();
            dataReader.Dispose();
            dataReader = null;
        }

        return listen;
    }

    // function to read and interpret the data from serial port
    private async Task<byte[]> ReadAsync(uint ReadBufferLength)
    {
        Task<uint> loadAsyncTask;
        byte[] returnArray = new byte[ReadBufferLength];

        dataReader.InputStreamOptions = InputStreamOptions.Partial;

        loadAsyncTask = dataReader.LoadAsync(ReadBufferLength).AsTask();

        uint bytesRead = await loadAsyncTask;

        if (bytesRead > 0)
        {
            dataReader.ReadBytes(returnArray);
        }            

        return returnArray;
    }

    // write the data using the serial port
    public async Task<uint> WriteAsync(byte[] data)
    {   
        dataWriter.WriteBytes(data);

        Task<uint> storeAsyncTask = dataWriter.StoreAsync().AsTask();

        return await storeAsyncTask;            
    }
}

Answer 1

This looks like it should work, and indeed, a version modified to use a MemoryStream instead of a serial port works just fine. I don't have access to the I/O APIs you're using, so I don't know anything about how they're supposed to be used. The semaphore, however, seems to be doing its job just fine. Below you'll find a simplified version of your example, with buttons to run GetData() in serial or in parallel.

If there is a problem with the semaphore, it could only be that you are not calling Release() from inside a finally . Otherwise, your use of the semaphore looks fine.

To see that the semaphore is working, you need only change the initializer to new SemaphoreSlim(8, 8) and see the threads clobber each other.

ReadBlock.cs:

public class ReadBlock {
    private static int nextString;

    private static readonly string[] strings = {
        "ONE  ", "TWO  ", "THREE", "FOUR ",
        "FIVE ", "SIX  ", "SEVEN", "EIGHT"
    };

    public static async Task<byte[]> ReadParaBlock() {
        var id = Interlocked.Increment(ref nextString) - 1;
        var name = strings[id % strings.Length];

        try
        {
            await ReadWriteAdapter.Current.Semaphore.WaitAsync();
            Trace.WriteLine($"[{name.Trim()}] Entered Semaphore");
            await Write(Encoding.ASCII.GetBytes("TEST_" + name));
            return await Read();
        }
        finally {
            Trace.WriteLine($"[{name.Trim()}] Exiting Semaphore");
            ReadWriteAdapter.Current.Semaphore.Release();
        }
    }

    public static async Task<uint> Write(byte[] bytes) =>
        await ReadWriteAdapter.Current.WriteAsync(bytes);

    public static async Task<byte[]> Read() => await ReadWriteAdapter.Current.Listen(10);
}

ReadWriteAdapter.cs:

public class ReadWriteAdapter {
    private static ReadWriteAdapter instance;

    public static ReadWriteAdapter Current
        => LazyInitializer.EnsureInitialized(
            ref instance,
            () => new ReadWriteAdapter());

    private readonly MemoryStream stream = new MemoryStream();

    public SemaphoreSlim Semaphore { get; } = new SemaphoreSlim(1, 1);

    public async Task<string> Init()
        => await Task.FromResult("found port");

    public async Task<byte[]> Listen(uint bufferLength) 
        => await ReadAsync(bufferLength);

    private async Task<byte[]> ReadAsync(uint readBufferLength) {
        await Task.CompletedTask;
        var returnArray = new byte[readBufferLength];
        await stream.ReadAsync(returnArray, 0, returnArray.Length);
        return returnArray;
    }

    public async Task<uint> WriteAsync(byte[] data) {
        stream.SetLength(stream.Capacity);
        stream.Position = 0;
        await Task.Delay(1);
        await stream.WriteAsync(data, 0, data.Length);
        stream.SetLength(data.Length);
        stream.Position = 0;
        return (uint)data.Length;
    }
}

MainWindow.xaml.cs:

public partial class MainWindow {
    private class TextBoxTraceListener : TraceListener {
        private readonly TextBoxBase _textBox;

        public TextBoxTraceListener(TextBoxBase textBox) 
            => _textBox = textBox;

        public override void WriteLine(string message) 
            => Write(message + Environment.NewLine);

        public override void Write(string message) {
            _textBox.Dispatcher.BeginInvoke(
                DispatcherPriority.Normal,
                new Action(() => _textBox.AppendText(message)));
        }
    }

    public MainWindow() {
        TaskScheduler.UnobservedTaskException +=
            (s, e) => Trace.TraceError(e.ToString());
        InitializeComponent();
        Trace.Listeners.Add(new TextBoxTraceListener(textBox));
        InitPort();
    }

    private async void InitPort() {
        textBox.AppendText(await ReadWriteAdapter.Current.Init());
    }

    private async void OnGetDataInSerialClick(object sender, RoutedEventArgs e) {
        textBox.Clear();
        for (var i = 0; i < 8; i++) await GetData();
    }

    private async void OnGetDataInParallelClick(object sender, RoutedEventArgs e) {
        textBox.Clear();
        await Task.WhenAll(Enumerable.Range(0, 8).Select(i => GetData()));
    }

    private async Task GetData() {
        await Task.Delay(50).ConfigureAwait(false); // Get off the UI thread.
        Trace.WriteLine(Encoding.ASCII.GetString(await ReadBlock.ReadParaBlock()));
    }
}

MainWindow.xaml:

<Window x:Class="WpfTest2.MainWindow"
            xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
            xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
  <DockPanel LastChildFill="True">
    <Button DockPanel.Dock="Bottom" Click="OnGetDataInSerialClick"
                Content="Load Data in Serial" />
    <Button DockPanel.Dock="Bottom" Click="OnGetDataInParallelClick"
                Content="Load Data in Parallel" />
    <TextBox x:Name="textBox" TextWrapping="Wrap" />
  </DockPanel>
</Window>