Web Development

[HttpGet]
public IEnumerable<OperatorEntity> GetAllOperators()
{
    var bl = GetBusinessLayer();
    var results = bl.GetAll(); //<=== This shows 18 rows with data
    return results;
}

public async Task<T> ExecuteAsync<T>() where T : new()
{
    URL = client.BaseUrl + request.Resource;

<pre>
IRestResponse<T> restResponse = await client.ExecuteTaskAsync<T>(request, new CancellationToken());

var result = (T)restResponse.Data; // <===== NO DATA HERE

if (!string.IsNullOrEmpty(restResponse.ErrorMessage))

public async Task<List<OperatorEntity>> GetAllOperatorsAsync()
{
    var webAPIExecutor = new WebAPIExecutor(ServerUrl, "/Operator/GetAllOperators/", Method.GET);
    return await webAPIExecutor.ExecuteAsync<List<OperatorEntity>>();
}

<pre>    [DataContract]
    [Serializable]
    public class OperatorEntity : _EntityBase
    {
        private bool _BuiltIn;
        [DataMember]
        public bool BuiltIn
        {
            get
            {
                return _BuiltIn;
            }
            set
            {
                if (_BuiltIn != value)
                {
                    _BuiltIn = value;
                    RaisePropertyChanged("BuiltIn");
                }
            }
        }

        private bool _Active;
        [DataMember]
        public bool Active
        {
            get
            {
                return _Active;
            }
            set
            {
                if (_Active != value)
                {
                    _Active = value;
                    RaisePropertyChanged("Active");
                }
            }
        }

        private string _FirstName;
        [DataMember]
        public string FirstName
        {
            get
            {
                return _FirstName;
            }
            set
            {
                if (_FirstName != value)
                {
                    _FirstName = value;
                    RaisePropertyChanged("FirstName");
                }
            }
        }

        private string _LastName;
        [DataMember]
        public string LastName
        {
            get
            {
                return _LastName;
            }
            set
            {
                if (_LastName != value)
                {
                    _LastName = value;
                    RaisePropertyChanged("LastName");
                }
            }
        }

        private string _Username;
        [DataMember]
        public string Username
        {
            get
            {
                return _Username;
            }
            set
            {
                if (_Username != value)
                {
                    _Username = value;
                    RaisePropertyChanged("Username");
                }
            }
        }

        private string _Password;
        [DataMember]
        public string Password
        {
            get
            {
                return _Password;
            }
            set
            {
                if (_Password != value)
                {
                    _Password = value;
                    RaisePropertyChanged("Password");
                }
            }
        }

        private DateTimeOffset? _PasswordChangedDate;
        [DataMember]
        public DateTimeOffset? PasswordChangedDate
        {
            get
            {
                return _PasswordChangedDate;
            }
            set
            {
                if (_PasswordChangedDate != value)
                {
                    _PasswordChangedDate = value;
                    RaisePropertyChanged("PasswordChangedDate");
                }
            }
        }

        private DateTimeOffset? _LastLoginDate;
        [DataMember]
        public DateTimeOffset? LastLoginDate
        {
            get
            {
                return _LastLoginDate;
            }
            set
            {
                if (_LastLoginDate != value)
                {
                    _LastLoginDate = value;
                    RaisePropertyChanged("LastLoginDate");
                }
            }
        }

        private byte[] _rowversion;
        [DataMember]
        public byte[] rowversion
        {
            get
            {
                return _rowversion;
            }
            set
            {
                if (_rowversion != value)
                {
                    _rowversion = value;
                    RaisePropertyChanged("rowversion");
                }
            }
        }

        private short _RoleType;
        [DataMember]
        public short RoleType
        {
            get
            {
                return _RoleType;
            }
            set
            {
                if (_RoleType != value)
                {
                    _RoleType = value;
                    RaisePropertyChanged("RoleType");
                }
            }
        }

        private byte[] _ESignature;
        [DataMember]
        public byte[] ESignature
        {
            get
            {
                return _ESignature;
            }
            set
            {
                if (_ESignature != value)
                {
                    _ESignature = value;
                    RaisePropertyChanged("ESignature");
                }
            }
        }

        private string _Email1;
        [DataMember]
        public string Email1
        {
            get
            {
                return _Email1;
            }
            set
            {
                if (_Email1 != value)
                {
                    _Email1 = value;
                    RaisePropertyChanged("Email1");
                }
            }
        }

        private string _Email2;
        [DataMember]
        public string Email2
        {
            get
            {
                return _Email2;
            }
            set
            {
                if (_Email2 != value)
                {
                    _Email2 = value;
                    RaisePropertyChanged("Email2");
                }
            }
        }

        private bool _SendAlerts;
        [DataMember]
        public bool SendAlerts
        {
            get
            {
                return _SendAlerts;
            }
            set
            {
                if (_SendAlerts != value)
                {
                    _SendAlerts = value;
                    RaisePropertyChanged("SendAlerts");
                }
            }
        }

        private short? _SendAlertsTime;
        [DataMember]
        public short? SendAlertsTime
        {
            get
            {
                return _SendAlertsTime;
            }
            set
            {
                if (_SendAlertsTime != value)
                {
                    _SendAlertsTime = value;
                    RaisePropertyChanged("SendAlertsTime");
                }
            }
        }

        private bool _SendResults;
        [DataMember]
        public bool SendResults
        {
            get
            {
                return _SendResults;
            }
            set
            {
                if (_SendResults != value)
                {
                    _SendResults = value;
                    RaisePropertyChanged("SendResults");
                }
            }
        }

        private short? _SendResultsTime;
        [DataMember]
        public short? SendResultsTime
        {
            get
            {
                return _SendResultsTime;
            }
            set
            {
                if (_SendResultsTime != value)
                {
                    _SendResultsTime = value;
                    RaisePropertyChanged("SendResultsTime");
                }
            }
        }

        private bool _MonitoringSystemUser;
        [DataMember]
        public bool MonitoringSystemUser
        {
            get
            {
                return _MonitoringSystemUser;
            }
            set
            {
                if (_MonitoringSystemUser != value)
                {
                    _MonitoringSystemUser = value;
                    RaisePropertyChanged("MonitoringSystemUser");
                }
            }
        }

        private bool _Email1AllowHtml;
        [DataMember]
        public bool Email1AllowHtml
        {
            get
            {
                return _Email1AllowHtml;
            }
            set
            {
                if (_Email1AllowHtml != value)
                {
                    _Email1AllowHtml = value;
                    RaisePropertyChanged("Email1AllowHtml");
                }
            }
        }

        private bool _Email2AllowHtml;
        [DataMember]
        public bool Email2AllowHtml
        {
            get
            {
                return _Email2AllowHtml;
            }
            set
            {
                if (_Email2AllowHtml != value)
                {
                    _Email2AllowHtml = value;
                    RaisePropertyChanged("Email2AllowHtml");
                }
            }
        }

        private bool _MonitoringSelf;
        [DataMember]
        public bool MonitoringSelf
        {
            get
            {
                return _MonitoringSelf;
            }
            set
            {
                if (_MonitoringSelf != value)
                {
                    _MonitoringSelf = value;
                    RaisePropertyChanged("MonitoringSelf");
                }
            }
        }

        private bool? _IsLockedOut;
        [DataMember]
        public bool? IsLockedOut
        {
            get
            {
                return _IsLockedOut;
            }
            set
            {
                if (_IsLockedOut != value)
                {
                    _IsLockedOut = value;
                    RaisePropertyChanged("IsLockedOut");
                }
            }
        }

        private bool? _IsActiveDirectory;
        [DataMember]
        public bool? IsActiveDirectory
        {
            get
            {
                return _IsActiveDirectory;
            }
            set
            {
                if (_IsActiveDirectory != value)
                {
                    _IsActiveDirectory = value;
                    RaisePropertyChanged("IsActiveDirectory");
                }
            }
        }
    }

Hello all.

While trying to implement a web-socket handshake, I encountered a weird behavior. It looks like the HttpListenerResponse class doesn't send the 'Connection' header.

Here is an example for explaining what I mean:

public void TestWebSocketHttpHandshake()
{
    int port = 9444;
    ManualResetEvent serverStartedEvent = new ManualResetEvent(false);
    ManualResetEvent clientClosedEvent = new ManualResetEvent(false);

    // HTTP server that gets a web-socket handshake request and,
    // send back a web-socket handshake response.
    async Task RunHttpServer()
    {
        HttpListener hl = new HttpListener();
        hl.Prefixes.Add($"http://+:{port}/");
        hl.Start();
        serverStartedEvent.Set();
        HttpListenerContext hlc = await hl.GetContextAsync();

        string secWebSocketKeyHeader = hlc.Request.Headers["Sec-WebSocket-Key"]?.Trim();
        string secWebSocketAcceptHeader = Convert.ToBase64String(
            System.Security.Cryptography.SHA1.Create().ComputeHash(
                Encoding.UTF8.GetBytes(secWebSocketKeyHeader + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11")
            )
        );

        hlc.Response.StatusCode = (int)HttpStatusCode.SwitchingProtocols; // 101
        hlc.Response.StatusDescription = "Switching Protocols";
        hlc.Response.ProtocolVersion = new Version("1.1");
        hlc.Response.AddHeader("Upgrade", "websocket");
        hlc.Response.AddHeader("Connection", "Upgrade");
        hlc.Response.AddHeader("Sec-WebSocket-Accept", secWebSocketAcceptHeader);

        hlc.Response.Close();

        // Wait for the client to close.
        clientClosedEvent.WaitOne();
        hl.Stop();
    }

    // Tcp Client that sends a web-socket handshake request and,
    // writes the received web-socket handshake response.
    async Task RunTcpClient()
    {
        const string eol = "\r\n"; // HTTP/1.1 defines the sequence CR LF as the end-of-line marker

        // Wait for the server to start.
        serverStartedEvent.WaitOne();

        using (TcpClient tc = new TcpClient())
        {
            tc.Connect("localhost", port);

            using (NetworkStream ns = tc.GetStream())
            {
                string wsRequest =
                    $"GET /chat HTTP/1.1{eol}Host: localhost:{port}{eol}"+ 
                    $"Upgrade: websocket{eol}Connection: Upgrade{eol}" +
                    $"Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ=={eol}"+ 
                    $"Sec-WebSocket-Version: 13{eol}{eol}";

                byte[] wsRequestBytes = Encoding.ASCII.GetBytes(wsRequest);
                await ns.WriteAsync(wsRequestBytes, 0, wsRequestBytes.Length);
                Console.WriteLine("Sent request:");
                Console.WriteLine(wsRequest);

                byte[] responseBuf = new byte[256];
                int resBytesCount = await ns.ReadAsync(responseBuf, 0, responseBuf.Length);
                string wsResponse = Encoding.ASCII.GetString(responseBuf, 0, resBytesCount);
                Console.WriteLine("Received response:");
                Console.WriteLine(wsResponse);
            }
        }

        clientClosedEvent.Set();
    }

    Task.WaitAll(RunHttpServer(), RunTcpClient());
}

The result is:

Sent request:
GET /chat HTTP/1.1
Host: localhost:9444
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==
Sec-WebSocket-Version: 13


Received response:
HTTP/1.1 101 Switching Protocols
Upgrade: websocket
Content-Length: 0
Server: Microsoft-HTTPAPI/2.0
Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=
Date: Mon, 11 Feb 2019 16:16:37 GMT

So, what we can see here is that we have a HttpListener server that sets the 'Connection' header in the response but, when the client gets the server's response, the 'Connection' header is missing.

I know that we can use the HttpListenerContext.AcceptWebSocketAsync method for handling the web-socket connection but, this method uses the operating system web-socket support that is supported only from Windows 8/ Windows Server 2012 and, we want this to work also on a Windows Server 2008 system.

I know that there are some solutions on the web for running a web-socket server. But, all the solutions I found are for running a server that listens to web-socket requests on a given port. Since in my case I want to accept web-socket requests on the same port of an existing server (Owin server that does other things), I have to handle it using the given request's HttpListenerContext.

Can anyone explain this behavior (the missing 'Connection' header) or, suggest a solution?

[HttpPost]
public void AddOperator(OperatorEntity entity)
{
    var bl = GetBusinessLayer();
    bl.Add(entity);
}

GET http://localhost:53175/api/Operator/AddOperator/ HTTP/1.1
Accept: application/json, text/json, text/x-json, text/javascript, application/xml, text/xml, text/plain
User-Agent: RestSharp/106.6.7.0
Host: localhost:53175
Accept-Encoding: gzip, deflate
Connection: Keep-Alive

System.Exception: 'An error occured calling the WebAPI. 
 The status code is 'MethodNotAllowed'. 
 The error message is {"Message":"The requested resource does not support http method 'DELETE'."}'

public async Task DeleteOperatorAsync(Guid id)
{
    await Task.Factory.StartNew(() =>
    {
        var webAPIExecutor = new WebAPIExecutor(ServerUrl, "/Operator/Delete/", Method.DELETE);
        webAPIExecutor.AddParameter(id, "id");
        webAPIExecutor.Execute();
    });
}

[HttpDelete]
public void Delete(Guid id)
{
    IBusinessLayer bl = new BusLayer();
    bl.DeleteOperator(id);
}

DELETE <a href="http://localhost:53175/api/Operator/Delete/">http://localhost:53175/api/Operator/Delete/</a> HTTP/1.1
Accept: application/json, text/json, text/x-json, text/javascript, application/xml, text/xml, text/plain
User-Agent: RestSharp/106.6.7.0
Content-Type: application/json
Host: localhost:53175
Content-Length: 38
Accept-Encoding: gzip, deflate

"77932bef-1b12-4204-9bd7-9a50f854a72a"