C#

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.IO.Ports;

namespace New_Interfacing
{
    public partial class Form1 : Form
    {

        private SerialPort _serialPort;         
        private const int BaudRate = 9600;      


        public Form1()
        {
            InitializeComponent();
        }


        private void Form1_Load(object sender, EventArgs e)
        {
            string[] portNames = SerialPort.GetPortNames();     
            foreach (var portName in portNames)
            {
                comboBox1.Items.Add(portName);                  
            }
            comboBox1.SelectedIndex = 0;                       

        }
        private void button1_Click(object sender, EventArgs e)
        {
           
       
         
          
            _serialPort = new SerialPort(comboBox1.Text, BaudRate, Parity.None, 8, StopBits.One);      
            _serialPort.DataReceived += SerialPortOnDataReceived;
            _serialPort.Open();
            textBox1.Text = "Listening on " + comboBox1.Text + "...";
        }

        private delegate void Closure();
        private void SerialPortOnDataReceived(object sender, SerialDataReceivedEventArgs serialDataReceivedEventArgs)
        {
            if (InvokeRequired)    
                BeginInvoke(new Closure(() => { SerialPortOnDataReceived(sender, serialDataReceivedEventArgs); }));     
            else
            {
                while (_serialPort.BytesToRead > 0) //<-- repeats until the In-Buffer is empty
                {
                    textBox1.Text += string.Format("{0:X2} ", _serialPort.ReadByte());
                
                }
            }
        }


    }
}

public async Task TryAuthorizeAsync()
{
    // Generates state and PKCE values.
    string state = RandomDataBase64url(32);
    string codeVerifier = RandomDataBase64url(32);
    string codeChallenge = Base64urlencodeNoPadding(SHA256(codeVerifier));

    // Creates an HttpListener to listen for requests
    string localHost = $"https://{IPAddress.Loopback}";
    string listenerURI = $"{localHost}:{GetRandomUnusedPort()}/"; // Includes a random port #
    var listener = new HttpListener();
    RaiseStatusChanged($"listening on {listenerURI}");
    listener.Prefixes.Add(listenerURI);

    listener.Start();

    // Create the authorization request passing <a href="https://127.0.0.1">https://127.0.0.1</a> as the redirect.
    var authorizationRequest = $"{AuthorizationEndpoint}?response_type=code&" +
                                $"scope=openid%20profile&" +
                                $"redirect_uri={Uri.EscapeDataString(localHost)}&" +
                                $"client_id={ClientID}&" +
                                $"state={state}&" +
                                $"code_challenge={codeChallenge}&" +
                                $"code_challenge_method={CODE_CHALLENEGE_METHOD}";

    // Opens request in the default browser
    Process.Start(authorizationRequest);

    bool success = false;

    // Wait for the auth authorization response.
    await Task.Run(() =>
    {
        // Begin waiting for context. Call the ListenerCallback when context is recieved
        IAsyncResult context2 = listener.BeginGetContext(new AsyncCallback(result => ListenerCallback(result, state, codeVerifier, listenerURI)), listener);

        if (HANDLE_TIMEOUT)
        {
            success = context2.AsyncWaitHandle.WaitOne(RESPONSE_TIMEOUT, true);
        }
    });

    // If here and both handling the timeout and the auth was not successfull, then the user
    // didn't do anything in the browser, so the auth process timed out. If the user did
    // anything in the browser, the ListenerCallback method handles it.
    if (HANDLE_TIMEOUT && !success)
    {
        RaiseAuthorizationTimedOut();
    }
}

This site can't be reached
127.0.0.1 refused to connect

private ProjectInformationBase? GetProjectBaseByDevelopmentProject(Guid idProject)
        {
            const string getProject = "SELECT * FROM Projects WHERE idProject = @idProject";

            var getProjectCommand = new SqlCommand(getProject, DbConnection);
            getProjectCommand.Parameters.Add("@idProject", SqlDbType.UniqueIdentifier).Value = idProject;

            var projectData = getProjectCommand.ReadDataByCommand();

            if (projectData.Rows.Count == 1)
            {
                return new ProjectInformationBase
                {
                    IdProjectInformationBase = (Guid)projectData.Rows[0]["idProject"], //this one crashed
                };
            }

            return null;
        }

        private ProjectInformationBase? GetProjectBaseByEcrProject(Guid idProject)
        {
            const string getEcrProject = "SELECT * FROM EcrProject WHERE ecrIdProject = @idProject";

            var getEcrProjectCommand = new SqlCommand(getEcrProject, DbConnection);
            getEcrProjectCommand.Parameters.Add("@ecrIdProject", SqlDbType.UniqueIdentifier).Value = idProject;

            var projectData = getEcrProjectCommand.ReadDataByCommand();

            if (projectData.Rows.Count == 1)
            {
                try
                {
                    return new ProjectInformationBase
                    {
                        IdProjectInformationBase = (Guid)projectData.Rows[0]["ecrIdProject"],
                    };
                }
                catch (Exception e)
                {
                    throw;
                }
            }

            return null;
        }

MessageBox.Show(!string.IsNullOrWhiteSpace(_signature) 
    ? $"This is my signature:{Environment.NewLine}{_signature}": "404-Signature not found");