C#

static void Main(string[] args)
{
    //Create an instance of the repository class
    OrderRepository oRepository = new OrderRepository();

    //Get the kist of orders
    List<Order> lOrders = oRepository.GetYesterdaysOrders().ToList();

    //Create a new collection to insert the line into
    List<OrderLine> oLines = new List<OrderLine>();

    //loop through the orders and get the lines
    foreach (Order Item in lOrders)
    {
        //add the lines from each order into the main collection
        oLines.AddRange(Item.orderLines);
    }
    Console.WriteLine(string.Format("Order Lines {0}", oLines.Count));

    //print each orderline in the amin collection
    foreach (OrderLine oLine in oLines.OrderByDescending(x => x.quantity))
    {
        Console.WriteLine(string.Format("Item {0} Qty {1}", oLine.itemName,oLine.quantity));
    }
    Console.ReadLine();

    //You now need to aggregate the main collection by the item no to get the sum of the quantity for each item then prin it.
}

var data = new Dictionary<string, List<string>>(StringComparer.OrdinalIgnoreCase)
{
    ["Acids"] = new List<string> { "A1", "A2", "A3" },
    ["Sulphur"] = new List<string> { "S1", "S2" },
    ["Carbon"] = new List<string> { "C1", "C2" },
};

// Add an item:
if (!data.TryGetValue("Acids", out var acids)) acids = data["Acids"] = new List<string>();
acids.Add("A4");

// Remove an item:
if (data.TryGetValue("Sulphur", out var sulphur)) sulphur.Remove("S1");

// Iterate over the items:
foreach (KeyValuePair<string, List<string>> pair in data)
{
    Console.WriteLine(pair.Key);
    foreach (string value in pair.Value)
    {
        Console.WriteLine(value);
    }
    Console.WriteLine();
}

RDP.OnLogonError += new AxMSTSCLib.IMsTscAxEvents_OnLogonErrorEventHandler(this.OnLogonError);
RDP.OnConnected += new EventHandler(axMsRdpClient2_OnConnected);

Quote:

Conversion of TIME or DATETIME values to numeric form (for example, by adding +0) results in a double-precision value with a microseconds part of .000000

• The fractional part, if nonzero, is the number of microseconds in the time.
• The integral part is always present, is a Unix time.

public static DateTime UnixTimeStampToDateTime( double unixTimeStamp )
{
    // Unix timestamp is seconds past epoch
    System.DateTime dtDateTime = new DateTime(1970,1,1,0,0,0,0,System.DateTimeKind.Utc);
    dtDateTime = dtDateTime.AddSeconds( unixTimeStamp ).ToLocalTime();
    return dtDateTime;
}

The following statement in the article that you cited tells me enough to give a reasonable hint.

<blockquote class="quote"><div class="op">Quote:</div>Conversion of TIME or DATETIME values to numeric form (for example, by adding +0) results in a double-precision value with a microseconds part of .000000</blockquote>

The TIMESTAMP is a double-precision floating point number, which is interpreted as follows.

<ul>
<li>The fractional part, if nonzero, is the number of microseconds in the time.</li>
<li>The integral part is always present, is a Unix time.</li>
</ul>
With these two bits of information, you can use the following function, which you can implement as a static method, to convert the Unix timestamp.

<pre>public static DateTime UnixTimeStampToDateTime( double unixTimeStamp )
{
    // Unix timestamp is seconds past epoch
    System.DateTime dtDateTime = new DateTime(1970,1,1,0,0,0,0,System.DateTimeKind.Utc);
    dtDateTime = dtDateTime.AddSeconds( unixTimeStamp ).ToLocalTime();
    return dtDateTime;
}