Web Development

using System;
using System.Data;
using System.Data.SqlClient;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Configuration;
namespace mrosite
{
    public class Product
    {
        public int PCode { get; set; }
        public string PartNumber { get; set; }
        public string Description { get; set; }
        public int Available { get; set; }
        public decimal Price { get; set; }
    

        public Product(int pcode)
        {
        this.PCode = pcode;
            /* Begin Searh the product code into the database */
            string SqlStr = "SELECT [PCode], [PartNumber], [Description], [PStock], [Price] FROM Products WHERE PCode=@PCode";
            DataSet SqlDs = new DataSet();
            SqlCommand SqlCmd = new SqlCommand(SqlStr);
            String connStr = ConfigurationManager.ConnectionStrings["TOOLCRIB"].ConnectionString;
            SqlConnection SqlConn = new SqlConnection(connStr);
            SqlDataAdapter SqlAdap = new SqlDataAdapter();
            SqlCmd.CommandType = CommandType.Text;
            SqlCmd.Parameters.AddWithValue("@PCode", PCode);
            SqlCmd.Connection = SqlConn;
            SqlAdap.SelectCommand = SqlCmd;
            SqlAdap.Fill(SqlDs, "Prod");
            SqlConn.Close();

            this.PCode= Convert.ToInt32(SqlDs.Tables["Prod"].Rows[0][0]);
            this.PartNumber = SqlDs.Tables["Prod"].Rows[0][1].ToString();
            this.Description = SqlDs.Tables["Prod"].Rows[0][2].ToString();
            this.Available = Convert.ToInt32(SqlDs.Tables["Prod"].Rows[0][3]);
            this.Price = Convert.ToDecimal(SqlDs.Tables["Prod"].Rows[0][4]);

        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;

namespace mrosite
{
    /// <summary>
    /// Summary description for ShoppingCart
    /// </summary>
    public class ShoppingCart
    {
        #region Properties

        public List<CartItem> Items { get; private set; }

        #endregion

        #region Singleton Implementation

        // Readonly properties can only be set in initialization or in a constructor
        public static readonly ShoppingCart Instance;

        // The static constructor is called as soon as the class is loaded into memory
        static ShoppingCart()
        {
            // If the cart is not in the session, create one and put it there
            // Otherwise, get it from the session
            if (HttpContext.Current.Session["ASPNETShoppingCart"] == null)
            {
                Instance = new ShoppingCart();
                Instance.Items = new List<CartItem>();
                HttpContext.Current.Session["ASPNETShoppingCart"] = Instance;
            }
            else
            {
                Instance = (ShoppingCart)HttpContext.Current.Session["ASPNETShoppingCart"];
            }
        }

        // A protected constructor ensures that an object can't be created from outside
        protected ShoppingCart() { }

        #endregion

        #region Item Modification Methods
        /**
         * AddItem() - Adds an item to the shopping 
         */
        public void AddItem(int pCode)
        {
            // Create a new item to add to the cart
            CartItem newItem = new CartItem(pCode);

            // If this item already exists in our list of items, increase the quantity
            // Otherwise, add the new item to the list
            if (Items.Contains(newItem))
            {
                foreach (CartItem item in Items)
                {
                    if (item.Equals(newItem))
                    {
                        item.Quantity++;
                        return;
                    }
                }
            }
            else
            {
                newItem.Quantity = 1;
                Items.Add(newItem);
            }
        }

        /**
         * SetItemQuantity() - Changes the quantity of an item in the cart
         */
        public void SetItemQuantity(int pCode, int quantity)
        {
            // If we are setting the quantity to 0, remove the item entirely
            if (quantity == 0)
            {
                RemoveItem(pCode);
                return;
            }

            // Find the item and update the quantity
            CartItem updatedItem = new CartItem(pCode);

            foreach (CartItem item in Items)
            {
                if (item.Equals(updatedItem))
                {
                    item.Quantity = quantity;
                    return;
                }
            }
        }

        /**
         * RemoveItem() - Removes an item from the shopping cart
         */
        public void RemoveItem(int pCode)
        {
            CartItem removedItem = new CartItem(pCode);
            Items.Remove(removedItem);
        }
        #endregion

        #region Reporting Methods
        /**
         * GetSubTotal() - returns the total price of all of the items
         *                 before tax, shipping, etc.
         */
        public decimal GetSubTotal()
        {
            decimal subTotal = 0;
            foreach (CartItem item in Items)
                subTotal += item.TotalPrice;

            return subTotal;
        }
        #endregion
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
/**
 * The CartItem Class
 * 
 * Basically a structure for holding item data
 */
namespace mrosite
{
    public class CartItem : IEquatable<CartItem> 
    {
        #region Properties

        // A place to store the quantity in the cart
        // This property has an implicit getter and setter.
        public int Quantity { get; set; }

        private int _productId;
        public int ProductId
        {
            get { return _productId; }
            set {
                // To ensure that the Prod object will be re-created
                _product = null;
                _productId = value;
            }
        }

        private Product _product = null;
        public Product Prod
        {
            get {
                // Lazy initialization - the object won't be created until it is needed
                if (_product == null) {
                    _product = new Product(ProductId);
                }
                return _product;
            }
        }
        public string PartNumber
        {
            get { return Prod.PartNumber; }
        }

        public string Description {
            get { return Prod.Description; }
        }

        public int Available
        {
            get { return Prod.Available; }
        }

        public decimal UnitPrice {
            get { return Prod.Price; }
        }

        public decimal TotalPrice {
            get { return UnitPrice * Quantity; }
        }

        #endregion

        // CartItem constructor just needs a productId
        public CartItem(int productId) {
            this.ProductId = productId;
        }

        /**
        * Equals() - Needed to implement the IEquatable interface
        *    Tests whether or not this item is equal to the parameter
        *    This method is called by the Contains() method in the List class
        *    We used this Contains() method in the ShoppingCart AddItem() method
        */
        public bool Equals(CartItem item) {
            return item.ProductId == this.ProductId;
        }
    }
}

protected void GrdBrowse_RowCommand1(object sender, GridViewCommandEventArgs e)
        {
                if (e.CommandName == "SendCart")
            {
                //Determine the RowIndex of the Row whose Button was clicked.
                int index = Convert.ToInt32(e.CommandArgument);

                //Reference the GridView Row.
                GridViewRow row = GrdBrowse.Rows[index];

                //Fetch value of Product Code
                int myId = Convert.ToInt32(row.Cells[1].Text);

                //Set value for add to shopping cart
                Product Prod = new Product(Convert.ToInt32(row.Cells[1].Text));

                               ShoppingCart.Instance.AddItem(Prod.PCode);
                //----------------------------------------------------------------------                
                Response.Redirect("ViewCart.aspx");

<%@ Page Title="" Language="C#" MasterPageFile="~/Site.Master" AutoEventWireup="true" CodeBehind="BrowseProducts.aspx.cs" Inherits="mrosite.BrowseProducts" %>
<asp:Content ID="Content1" ContentPlaceHolderID="MainContent" runat="server">
        <div class="jumbotron">
        <h1>Product Finder</h1>
        <p class="lead">Search your product according with your keyword</p>
        <p>
            <asp:TextBox ID="txtScr" runat="server" Width="310px"></asp:TextBox>
             
            <a><asp:Button ID="btnSearch" CssClass="btn btn-primary btn-lg" runat="server" Text="Search" Height="42px" Width="123px" OnClick="btnSearch_Click" /></a>
        </p>
    </div>
    <div class="container">
        
            <h3>Results...</h3>
            <p>
                <asp:Label ID="lblResults" runat="server" Text="0 Results for: none" ForeColor="Red"></asp:Label></p>
            <p><asp:Label ID="lblShowing" runat="server" Text="0 Showing results: none" ForeColor="GrayText"></asp:Label>
            </p>
            <p>
                <asp:GridView ID="GrdBrowse" runat="server" AutoGenerateColumns="False" AllowPaging="True" PageSize="10" EmptyDataText="There is nothing in the product list." GridLines="None" Width="100%" CellPadding="5" ShowFooter="true" 
                    DataKeyNames="PCode" OnPageIndexChanging="GrdBrowse_PageIndexChanging" OnRowCommand="GrdBrowse_RowCommand1" >
                    <HeaderStyle HorizontalAlign="Left" BackColor="#3D7169" ForeColor="#FFFFFF" />
                    <FooterStyle HorizontalAlign="Right" BackColor="#6C6B66" ForeColor="#FFFFFF" />
                    <AlternatingRowStyle BackColor="#F8F8F8" />
                    <Columns>
                        <asp:TemplateField ShowHeader="False">
                            <ItemTemplate>
                            <asp:Image runat="server" DataImageUrlField="Picture" HeaderText="Picture" ControlStyle-Width="75px" ControlStyle-Height ="75px">
                            </asp:Image>
                            </ItemTemplate>
                        </asp:TemplateField>
                        <asp:BoundField DataField="PCode" HeaderText="Product Code" />
                        <asp:BoundField DataField="PN" HeaderText="Part Number" />
                        <asp:BoundField DataField="Description" HeaderText="Description" />
                        <asp:BoundField DataField="Available" HeaderText="Available" />
                        <asp:TemplateField ShowHeader="False">
                            <ItemTemplate>
                                <asp:TextBox ID="txtQty" runat="server" Columns="5" Text="0"></asp:TextBox>  
                            </ItemTemplate>
                        </asp:TemplateField>
                        <asp:TemplateField ShowHeader="False">
                            <ItemTemplate>
                                <asp:Button Text="Add to Cart" runat="server" CommandName="SendCart" CommandArgument="<%# Container.DataItemIndex %>" />
                            </ItemTemplate>
                        </asp:TemplateField>
                    </Columns>
                </asp:GridView>
            </p>
        </div>
    
</asp:Content>

<div>
    
        Title
    
</div>

<div>Title</div>

.surround-brackets::before {
    content: "(";
}

.surround-brackets::after {
    content: ")";
}

[HttpGet]
public List<string> GetOperatorsNotOnServer(List<string> instrumentOperators)
{
    var bl = GetBusinessLayer();
    var results = bl.GetOperatorsNotOnServer(instrumentOperators);
    return results;
}

[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"