Portfolio2

MAINLY CONSOLE APPS AND MVC ENTITY FRAMEWORK ASP
February 1, 2016
Authored by: Chris
Chris Worledge Portfolio 2
A SELECTION OF EXAMPLES OF MORE RECENT WORK

1
ChrisWorledgePortfolio2|2/1/2016
Chris Worledge Portfolio 2
A selection of examples of more recent work
 Page 2 Measuring the Performance of Algorithms (C#)
 Page 36 Exploration of MongoDB using NodeJS
 Page 40 Temporal Data Store (Efficient use of C# Data Structures;
Lists, Dictionaries etc.)
 Page 53 Entity Framework with WebForms
 Page 57 Entity Framework with MVC
 Page 84 Web API with Angular JS
 Page 97 Bank Cash Machine Programme and Database

2
MEASURING THE PERFORMANCE OF ALGORITHMS
For comparison of different approaches to the same problem I have measured
the performance of two methods of measuring/calculating the digits within all
the numbers from one to any selected number. The problem was described to
me in terms of providing the numbers for doors where door numbers could
exceed 10^12! A less than likely scenario, but it indicated the leading zeros
would not be required.
The CountDigits method actually counts the digits within each number in turn
until the target number is reached. This is the brute force approach which is
ideal within small ranges, but does not scale up well.
The CalculateNumbers method actually adds the numbers of each digit as a
result of each digit in the target number.
A comparative unit test was employed to check they both produce the same
results:
using Microsoft.VisualStudio.TestTools.UnitTesting;
namespace CountDigitsUnitTests
{
[TestClass]
public class UnitTest1
{
[TestMethod]
public void TestMethod1()
{
ulong index = 1, next = 1;
for (ulong value = 1; value < 10000000; value = next)
{
ulong[] linear = new CountDigits.DigitCount().CountDigits(value);
ulong[] log = new CountDigits.CountDigits().CalculateNumbers(value);
CollectionAssert.AreEqual(linear, log);
index++;
next = next + index;
}
}
}
}
This test couldn’t cover the complete range of the methods as the time required
to run such a check was prohibitive.

3
Using 10^8 as a limit took 6 minutes over a whole day!
In Big O notation the first approach has O(n), a linear relationship which can
be ideal with very small number ranges, but has terrible performance with
large numbers, whilst the second has O(log(n)), which is much more scalable to
requirements in modern business environments.
We need System and System.Diagnostics (for the stopwatch class to measure
the execution times).
using System;
using System.Diagnostics;
namespace HotelApplication
{
class Program
{
public static void Main(string[] args)
{

4
ulong max = 10000000000 ;
//the upper number n in the range 1 to n
var timeTest = Stopwatch.StartNew();//set a stopwatch going
ulong[] digValues = new CountDigits().CalculateNumbers(max);
timeTest.Stop();//call the method, and stop the stopwatch
var elapsedValue = timeTest.Elapsed;
string longStringTime = String.Format("{0:00}:{1:00}:{2:00}.{3:00}", elapsedValue.Hours,
elapsedValue.Minutes, elapsedValue.Seconds, elapsedValue.Milliseconds);//display the time
and the values
Console.WriteLine("Input: " + max.ToString());
Console.WriteLine("");
Console.WriteLine("Time in milliseconds = " + elapsedValue.TotalMilliseconds.ToString() +
" milliseconds");
Console.WriteLine("Time = " + longStringTime);
Console.WriteLine("0: " + digValues[0].ToString());
//Do the same things again for the other method
var clock = Stopwatch.StartNew();
ulong[] digCount = new DigitCount().CountDigits(max);
clock.Stop();
var elapsedMillis = clock.ElapsedMilliseconds;
var timeelapsed = clock.Elapsed;
string elapsedTime = String.Format("{0:00}:{1:00}:{2:00}.{3:00}", timeelapsed.Hours,
timeelapsed.Minutes, timeelapsed.Seconds, timeelapsed.Milliseconds);
Console.WriteLine("Time in milliseconds = " + timeelapsed.TotalMilliseconds.ToString() +
" milliseconds");
Console.WriteLine("Time = " + elapsedTime);
Console.WriteLine("0: " + digCount[0].ToString());

5
Console.WriteLine("Press enter to close...");
Console.ReadLine();
}
}
}
The anticipated outcome would be a linear time to logarithmic input for the
CalculateNumbers method; whilst the CountDigits method would remain linear
against input and become inpractical for large numbers.
The console display for 10^9:

6
The console display for 10^10:

7
The console display of 10^11:
An averaging technique was employed to reduce the impact of overhead, and
display the true trend of the underlying algorithm. This was only practical for
the Olog(n) algorithm due to the much increased run times of the O(n)
algorithm. This will have introduced error, but it’s impact would be small.

8
A table of results shows the performance of each algorithm in ms.
Input Input(scientific) Olog(n) O(n)
1 1.E+00 0.0005 0.3589
10 1.E+01 0.00052 0.0049
100 1.E+02 0.000748 0.0158
1000 1.E+03 0.00984 0.1433
10000 1.E+04 0.001136 1.272
100000 1.E+05 0.001343 18.056
1000000 1.E+06 0.001694 176.6585
10000000 1.E+07 0.001851 1820.4105
100000000 1.E+08 0.002001 19687.2353
1000000000 1.E+09 0.0022248 218771.4353
10000000000 1.E+10 0.002532 2427029.663
100000000000 1.E+11 0.002837 25599515.25
1000000000000 1E+12 0.003152
10000000000000 1E+13 0.003309
100000000000000 1E+14 0.003699
1000000000000000 1E+15 0.004099
10000000000000000 1E+16 0.004624
100000000000000000 1E+17 0.005271
1000000000000000000 1E+18 0.006046
10000000000000000000 1E+19 0.007024
18446744073709551615 1.84467E+19 0.0383061
The O(n) results stop at 10^11 as that took seven and a half hours, so it would
be reasonable to expect 10^12 to take around three days.
A linear comparison of both algorithms, demonstrates the limits of practical
use of the brute force approach.

9
If the mid point input value of 5 million were related to population, the linear
algorithm would demonstrate poor performance with most town and city
populations, but not cope at all with larger cities or counties, let alone
countries.
Independent charting against a logarithmic input shows the performance
comparison more fully.
0
5000000
10000000
15000000
20000000
25000000
30000000
O(n)

10
It should be noted that the y axis representing time in milliseconds is very
different on the two plots.
0
0.05
0.1
0.15
0.2
Olog(n)

11
A complete demo was devised which allowed any number ranges outputs to be
recorded in a text file, and a display of the results of successive powers of ten
finishing with 2^64 – 1.
using System;
using System.Diagnostics;
using System.IO;
namespace CleanDigitCounter
{
class Program
{
static void Main(string[] args)
{
consDemo();//runs a demo using the range of values from 10^0 to 10^19 and
2^64-1
}
private static void consDemo()
{
double[] times = new double[22] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0 };
int index = 0;
ulong max = 1;
while (index <= 19)
{
double totalMiliseconds = 0;
for (int i = 1; i <= 10; i++)
{
var avTest = Stopwatch.StartNew();
ulong[] alues = new CountDigits().CalculateNumbers(max);
avTest.Stop();
totalMiliseconds += avTest.Elapsed.TotalMilliseconds;
}
var avElapsedValue = totalMiliseconds / 10;
times[index] += avElapsedValue;
string avElapsed = avElapsedValue.ToString();
Console.WriteLine("Average Milliseconds for Value " + avElapsed);
if (max == 1)
{
double totalMilis = 0;
for (int i = 1; i <= 10; i++)
{
ulong[] alues = new CountDigits().CalculateNumbers(max);
avTest.Stop();
totalMilis += avTest.Elapsed.TotalMilliseconds;
}

12
var avValue = totalMilis / 10;
times[index] += avValue;
string av = avValue.ToString();
Console.WriteLine("Average Milliseconds for Value " + av);
}
var timeTest = Stopwatch.StartNew();
timeTest.Stop();
string longStringTime = String.Format("{0:00}:{1:00}:{2:00}.{3:00}",
elapsedValue.Hours, elapsedValue.Minutes, elapsedValue.Seconds,
elapsedValue.Milliseconds);
Console.WriteLine("Time in milliseconds = " +
elapsedValue.TotalMilliseconds.ToString() + " milliseconds");
if (index < 9)//just so the demo doesn't take weeks to run
{
clock.Stop();
string elapsedTime = String.Format("{0:00}:{1:00}:{2:00}.{3:00}",
timeelapsed.Hours, timeelapsed.Minutes, timeelapsed.Seconds, timeelapsed.Milliseconds);
timeelapsed.TotalMilliseconds.ToString() + " milliseconds");

13
}
max *= 10;
index++;
}
double miliseconds = 0;
ulong maxNumber = 18446744073709551615;
for (int k = 0; k < 10; k++)
{
for (int i = 1; i <= 10; i++)
{
ulong[] alues = new CountDigits().CalculateNumbers(maxNumber);
avTest.Stop();
miliseconds += avTest.Elapsed.TotalMilliseconds;
}
Console.WriteLine("Input: " + maxNumber.ToString());
var average = miliseconds / 10;
times[20] += average;
}
double zero = times[0] / 20;
double one = times[1] / 10;
double two = times[2] / 10;
double three = times[3] / 10;
double four = times[4] / 10;
double five = times[5] / 10;
double six = times[6] / 10;
double seven = times[7] / 10;
double eight = times[8] / 10;
double nine = times[9] / 10;
double ten = times[10] / 10;
double eleven = times[11] / 10;
double twelve = times[12] / 10;
double thirteen = times[13] / 10;
double fourteen = times[14] / 10;
double fifteen = times[15] / 10;
double sixteen = times[16] / 10;
double seventeen = times[17] / 10;
double eighteen = times[18] / 10;
double nineteen = times[19] / 10;
double twenty = times[20] / 100;

14
Console.WriteLine("Average Milliseconds for Value 1 : " + zero.ToString());
Console.WriteLine("Average Milliseconds for Value 10 : " + one.ToString());
Console.WriteLine("Average Milliseconds for Value 100 : " +
two.ToString());
Console.WriteLine("Average Milliseconds for Value 1,000 : " +
three.ToString());
four.ToString());
five.ToString());
Console.WriteLine("Average Milliseconds for Value 1,000,000 : " +
six.ToString());
seven.ToString());
eight.ToString());
nine.ToString());
Console.WriteLine("Average Milliseconds for Value 10,000,000,000 : " +
ten.ToString());
Console.WriteLine("Average Milliseconds for Value 100,000,000,000 : " +
eleven.ToString());
Console.WriteLine("Average Milliseconds for Value 1,000,000,000,000 : " +
twelve.ToString());
thirteen.ToString());
fourteen.ToString());
Console.WriteLine("Average Milliseconds for Value 1,000,000,000,000,000 : "
+ fifteen.ToString());
Console.WriteLine("Average Milliseconds for Value 10,000,000,000,000,000 :
" + sixteen.ToString());
Console.WriteLine("Average Milliseconds for Value 100,000,000,000,000,000 :
" + seventeen.ToString());
Console.WriteLine("Average Milliseconds for Value 1,000,000,000,000,000,000
: " + eighteen.ToString());

15
Console.WriteLine("Average Milliseconds for Value 10,000,000,000,000,000,000
: " + nineteen.ToString());
Console.WriteLine("Average Milliseconds for Value 18446744073709551615 : "
+ twenty.ToString());
Console.ReadLine();
}
private static void textFile(ulong start, ulong finish)
{
FileStream outstrm;
StreamWriter writer;
TextWriter oldOut = Console.Out;
try
{
outstrm = new FileStream("C:/Test/ConsoleOutput.txt",
FileMode.OpenOrCreate, FileAccess.Write);
writer = new StreamWriter(outstrm);
}
catch (Exception e)
{
Console.WriteLine("Cannot open ConsoleOutput.txt for writing");
Console.WriteLine(e.Message);
return;
}
Console.SetOut(writer);
ulong max;
for (max = start; max < finish; max++)
{
var timeTest = Stopwatch.StartNew();
timeTest.Stop();
string timeVal = elapsedValue.ToString();
string timeS = timeVal.Substring(5, 3);
string timeM = timeVal.Substring(9, 3);
string timeD = timeVal.Substring(12);
string longStringTime = String.Format("{0:00}:{1:00}:{2:00}.{3:00}",
elapsedValue.Hours, elapsedValue.Minutes, elapsedValue.Seconds,
elapsedValue.Milliseconds);
elapsedValue.TotalMilliseconds.ToString() + " milliseconds");

16
clock.Stop();
string timelapsed = timeelapsed.ToString();
string hrs = timelapsed.Substring(0, 2);
string mins = timelapsed.Substring(3, 2);
string secs = timelapsed.Substring(6, 2);
double milliseconds = 0;
int hours = 0;
int minutes = 0;
int seconds = 0;
int wholeMilis = 0;
int intdecMilis = 0;
double decMilis = 0.0;
int.TryParse(hrs, out hours);
int.TryParse(mins, out minutes);
int.TryParse(secs, out seconds);
string millis = timelapsed.Substring(9, 3);
int.TryParse(millis, out wholeMilis);
string afterDec = timelapsed.Substring(12);
int.TryParse(afterDec, out intdecMilis);
decMilis = (double)intdecMilis / 10000;
milliseconds = (hours * 60 * 60 * 1000) + (minutes * 60 * 1000) +
(seconds * 1000) + wholeMilis + decMilis;
string elapsedTime = String.Format("{0:00}:{1:00}:{2:00}.{3:00}",
timeelapsed.Hours, timeelapsed.Minutes, timeelapsed.Seconds, timeelapsed.Milliseconds);
timeelapsed.TotalMilliseconds.ToString() + " milliseconds");

17
}
writer.Close();
outstrm.Close();
Console.SetOut(oldOut);
Console.WriteLine("Done");
Console.ReadLine();
}
}
}
The results:
Input: 1
Average Milliseconds for Value 0.07499
Input: 1
Input: 1
Time in milliseconds = 0.0005 milliseconds
Time = 00:00:00.00
0: 0
1: 1
2: 0
3: 0
4: 0
5: 0
6: 0
7: 0

18
8: 0
9: 0
Input: 1
Time = 00:00:00.00
0: 0
1: 1
2: 0
3: 0
4: 0
5: 0
6: 0
7: 0
8: 0
9: 0
Input: 10
Input: 10
Time = 00:00:00.00
0: 1
1: 2
2: 1
3: 1
4: 1
5: 1

19
6: 1
7: 1
8: 1
9: 1
Input: 10
Time = 00:00:00.00
0: 1
1: 2
2: 1
3: 1
4: 1
5: 1
6: 1
7: 1
8: 1
9: 1
Input: 100
Input: 100
Time = 00:00:00.00
0: 11
1: 21
2: 20

20
3: 20
4: 20
5: 20
6: 20
7: 20
8: 20
9: 20
Input: 100
Time = 00:00:00.00
0: 11
1: 21
2: 20
3: 20
4: 20
5: 20
6: 20
7: 20
8: 20
9: 20
Input: 1000
Input: 1000

21
Time = 00:00:00.00
0: 192
1: 301
2: 300
3: 300
4: 300
5: 300
6: 300
7: 300
8: 300
9: 300
Input: 1000
Time = 00:00:00.00
0: 192
1: 301
2: 300
3: 300
4: 300
5: 300
6: 300
7: 300
8: 300
9: 300
Input: 10000

22
Input: 10000
Time = 00:00:00.00
0: 2893
1: 4001
2: 4000
3: 4000
4: 4000
5: 4000
6: 4000
7: 4000
8: 4000
9: 4000
Input: 10000
Time = 00:00:00.01
0: 2893
1: 4001
2: 4000
3: 4000
4: 4000
5: 4000
6: 4000
7: 4000
8: 4000

23
9: 4000
Input: 100000
Input: 100000
Time = 00:00:00.00
0: 38894
1: 50001
2: 50000
3: 50000
4: 50000
5: 50000
6: 50000
7: 50000
8: 50000
9: 50000
Input: 100000
Time = 00:00:00.15
0: 38894
1: 50001
2: 50000
3: 50000
4: 50000
5: 50000

24
6: 50000
7: 50000
8: 50000
9: 50000
Input: 1000000
Input: 1000000
Time = 00:00:00.00
0: 488895
1: 600001
2: 600000
3: 600000
4: 600000
5: 600000
6: 600000
7: 600000
8: 600000
9: 600000
Input: 1000000
Time = 00:00:00.171
0: 488895
1: 600001
2: 600000

25
3: 600000
4: 600000
5: 600000
6: 600000
7: 600000
8: 600000
9: 600000
Input: 10000000
Input: 10000000
Time = 00:00:00.00
0: 5888896
1: 7000001
2: 7000000
3: 7000000
4: 7000000
5: 7000000
6: 7000000
7: 7000000
8: 7000000
9: 7000000
Input: 10000000
Time = 00:00:01.903

26
0: 5888896
1: 7000001
2: 7000000
3: 7000000
4: 7000000
5: 7000000
6: 7000000
7: 7000000
8: 7000000
9: 7000000
Input: 100000000
Input: 100000000
Time = 00:00:00.00
0: 68888897
1: 80000001
2: 80000000
3: 80000000
4: 80000000
5: 80000000
6: 80000000
7: 80000000
8: 80000000
9: 80000000

27
Input: 1000000000
Input: 1000000000
Time = 00:00:00.00
0: 788888898
1: 900000001
2: 900000000
3: 900000000
4: 900000000
5: 900000000
6: 900000000
7: 900000000
8: 900000000
9: 900000000
Input: 10000000000
Input: 10000000000
Time = 00:00:00.00
0: 8888888899
1: 10000000001
2: 10000000000
3: 10000000000
4: 10000000000
5: 10000000000

28
6: 10000000000
7: 10000000000
8: 10000000000
9: 10000000000
Input: 100000000000
Input: 100000000000
Time = 00:00:00.00
0: 98888888900
1: 110000000001
2: 110000000000
3: 110000000000
4: 110000000000
5: 110000000000
6: 110000000000
7: 110000000000
8: 110000000000
9: 110000000000
Input: 1000000000000
Input: 1000000000000
Time = 00:00:00.00
0: 1088888888901
1: 1200000000001

29
2: 1200000000000
3: 1200000000000
4: 1200000000000
5: 1200000000000
6: 1200000000000
7: 1200000000000
8: 1200000000000
9: 1200000000000
Input: 10000000000000
Input: 10000000000000
Time = 00:00:00.00
0: 11888888888902
1: 13000000000001
2: 13000000000000
3: 13000000000000
4: 13000000000000
5: 13000000000000
6: 13000000000000
7: 13000000000000
8: 13000000000000
9: 13000000000000
Input: 100000000000000

30
Input: 100000000000000
Time = 00:00:00.00
0: 128888888888903
1: 140000000000001
2: 140000000000000
3: 140000000000000
4: 140000000000000
5: 140000000000000
6: 140000000000000
7: 140000000000000
8: 140000000000000
9: 140000000000000
Input: 1000000000000000
Input: 1000000000000000
Time = 00:00:00.00
0: 1388888888888904
1: 1500000000000001
2: 1500000000000000
3: 1500000000000000
4: 1500000000000000
5: 1500000000000000
6: 1500000000000000
7: 1500000000000000

31
8: 1500000000000000
9: 1500000000000000
Input: 10000000000000000
Input: 10000000000000000
Time = 00:00:00.00
0: 14888888888888905
1: 16000000000000001
2: 16000000000000000
3: 16000000000000000
4: 16000000000000000
5: 16000000000000000
6: 16000000000000000
7: 16000000000000000
8: 16000000000000000
9: 16000000000000000
Input: 100000000000000000
Input: 100000000000000000
Time = 00:00:00.00
0: 158888888888888906
1: 170000000000000001
2: 170000000000000000

32
3: 170000000000000000
4: 170000000000000000
5: 170000000000000000
6: 170000000000000000
7: 170000000000000000
8: 170000000000000000
9: 170000000000000000
Input: 1000000000000000000
Input: 1000000000000000000
Time = 00:00:00.00
0: 1688888888888888907
1: 1800000000000000001
2: 1800000000000000000
3: 1800000000000000000
4: 1800000000000000000
5: 1800000000000000000
6: 1800000000000000000
7: 1800000000000000000
8: 1800000000000000000
9: 1800000000000000000
Input: 10000000000000000000
Input: 10000000000000000000

33
Time = 00:00:00.00
0: 17888888888888888908
1: 553255926290448385
2: 553255926290448384
3: 553255926290448384
4: 553255926290448384
5: 553255926290448384
6: 553255926290448384
7: 553255926290448384
8: 553255926290448384
9: 553255926290448384
Input: 18446744073709551615
Input: 18446744073709551615
Input: 18446744073709551615
Input: 18446744073709551615
Input: 18446744073709551615
Input: 18446744073709551615
Input: 18446744073709551615
Input: 18446744073709551615
Input: 18446744073709551615
Input: 18446744073709551615
Average Milliseconds for Value 1 : 0.0044365
Average Milliseconds for Value 10 : 8.3E-05

34
Average Milliseconds for Value 1,000 : 0.000142
Average Milliseconds for Value 1,000,000 : 0.000286
Average Milliseconds for Value 10,000,000,000 : 0.000253
Average Milliseconds for Value 100,000,000,000 : 0.000269
Average Milliseconds for Value 1,000,000,000,000 : 0.000296
Average Milliseconds for Value 1,000,000,000,000,000 : 0.000469

35
Average Milliseconds for Value 1,000,000,000,000,000,000 : 0.00049
Average Milliseconds for Value 10,000,000,000,000,000,000 : 0.00055
Press enter to close...

36
EXPLORATION OF MONGODB USING NODEJS
This was achieved following a Microsoft Tutorial
Links the app to the database instance, we can then pass the database
instance to the MongoDB Client and populate and interrogate it as follows:

37

38
We perform CRUD operations out of sequence. Create; Update; Retrieve; and
Delete.

39

40
C# TEMPORAL DATA STORE
You will be implementing a read-biased in-memory temporal data store.
A temporal store allows point-in-time queries about data. An example would be
the price of an exchange traded security. We might capture the price of the
security once an hour throughout the trading day, and store the price in a
temporal store. We can then query the temporal store to determine at any given
time, what the most recent captured price was.
This example illustrates the following key terms, which will be used throughout
this document:
1. Identifier - a key (e.g. the security id), for which we want to store a
history of observations
2. History - the list of observations for a given identifier
3. Observation - a piece of data which is associated with a particular
identifier at a particular timestamp
4. Timestamp - a given point in time
The latest observation for an identifier at a timestamp is found by searching in
the identifier's history for the first observation whose timestamp is less than, or
equal to, the sought timestamp.
For the purposes of this scenario, you should assume the following:
1. Identifiers are integers in the inclusive range [0..2^31 - 1]
2. Timestamps are integers in the inclusive range [0..2^63 - 1]
3. Data is represented as a contiguous string of non-whitespace
characters. For example, "jiggawatt" is a valid piece of data. The string "great
scot" is not, owing to its whitespace.
4. Users may interact with the temporal store, as well as processes. you
should be strict in what data you accept, but should provide suitable error
messages where the user has erred.
5. Capacity; there is no requirement to restrict your store to a given size,
but you may assume that you will be provided with no more than 10,000
identifiers, each with no more than 1,000 history entries, and no data item will
be no more than 16 characters.

41
Your temporal data store will communicate with other processes via standard
input and output. A series of commands are read and applied to the data store
from standard input. The results of evaluating the commands should be
written to standard output. A command will only ever be one line; the result of
executing a command will be a single output line, except for the QUIT
command.
When there are no more lines to consume, your temporal data store should
exit. There is no need to persist data in the store between executions (this is an
in-memory temporal store).
class Program
{
{
/*Holds the references to all the history stores, so we can find the required
history if it exists*/
List<DataDict> contain = new List<DataDict>();
//We make a few histories (from 0 - 4) and populate them with dummy data
for (int i = 0; i < 5; i++)
{
string j = "100";
string k = "1.1";
string dummy = "FirstCreate " + i + " " + j + " " + k;
new CommandHandler(dummy, contain);
}
for (int i = 0; i < 5; i++)
{
var p = 110;
var q = 1.2;
for (int l = 0; l < 10; l++)
{
string dummy = "FirstUpdate " + i.ToString() + " " + p.ToString() + "
" + q.ToString();
new CommandHandler(dummy, contain);
p = p + 10;
q = q + 0.1;
}
}
//Cue the console up, ready to receive user input
string line;
line = Console.ReadLine();
if (line != null)
{
new CommandHandler(line, contain);
}
}
}

42
The commands which can be executed against your data store are described
below. Note that:
- Items in <angle brackets> represent required arguments, but the angle
brackets themselves do not form part of the command
- Items in [square brackets] are optional arguments
- Successfully processed commands should always start their response with
"OK ", followed by the result of executing the command
- Commands which could not be executed should always start their response
with "ERR ", followed by a reasonable error message.
- Commands are not sensitive to whitespace; arguments must be separated by
at least one character of whitespace, but may be separated by more.
CREATE <id> <timestamp> <data>
- Creates a new history for the given identifier, if there is no existing
history. Adds an observation to the newly created history for the given
timestamp and data. CREATE should not be executed if the provided identifier
already has a history. Returns the data which was inserted, to confirm
insertion.
UPDATE <id> <timestamp> <data>
- Inserts an observation for the given identifier, timestamp and data.
Returns the data from the prior observation for that timestamp.
DELETE <id> [timestamp]
- If timestamp is provided, deletes all observations for the given identifier
from that timestamp forward. Returns the current observation at the given
timestamp, or an error if there is no available observation.
- If timestamp is not provided, deletes the history for the given identifier,
and returns the observation with the greatest timestamp from the history
which has been deleted.

43
GET <id> <timestamp>
- Returns the data from the observation for the given identifier at the given
timestamp, or an error if there is no available observation.
LATEST <id>
- Locates the observation with the greatest timestamp from the history for
the given identifier, and responds with its timestamp and data.
QUIT - Terminates the process immediately. No response should be written.
We use a List to store references to a series of Dictionaries, one for
each security.
class CommandHandler
{
string id = string.Empty;
string timeStamp = string.Empty;
string data = string.Empty;
string Command = string.Empty;
int ID;
long dateTime;
string line;
public CommandHandler(string command, List<DataDict> contain)
{
//separate out the different elements of the user input
char[] seperator = new char[] { ' ' };
string[] commands = command.Split(seperator,
StringSplitOptions.RemoveEmptyEntries);
Command = commands[0].Trim().ToLower();
if (commands.Count() > 1)
{
id = commands[1].Trim();
}
{
timeStamp = commands[2].Trim();
}
{
data = commands[3].Trim();
}
switch (Command)
{
case "create":
Create(contain);

44
break;
case "update":
Update(contain);
break;
case "delete":
Delete(contain);
break;
case "get":
Get(contain);
break;
case "latest":
Latest(contain);
break;
//These two are just to provide some intial values, so little comms with
user
case "firstcreate":
FirstCreate(contain);
break;
case "firstupdate":
FirstUpdate(contain);
break;
case "quit":
Environment.Exit(0);
break;
default:
Console.WriteLine("I am sorry, I do not understand that command.");
if (line != null)
{
}
break;
}
}
protected void Create(List<DataDict> contain)
{
if (int.TryParse(id, out ID))
{
int index = contain.FindIndex(e => e.Name == ID);
if (index >= 0)
{
Console.WriteLine("Error: The history already exists for ID '" + ID +
"'");

45
}
else
{
DataDict n = new DataDict(ID);
contain.Add(n);//adds the reference to the history store in the
container list
if (long.TryParse(timeStamp, out dateTime))
{
n.Add(dateTime, data);
Console.WriteLine("OK " + data.ToString());
}
else
{
Console.WriteLine("Error: The DateTime value provided is invalid.
Please ensure you provide a valid DateTime value.");
}
}
}
if (line != null)
{
}
}
protected void Update(List<DataDict> contain)
{
{
int index = -1;
index = contain.FindIndex(e => e.Name == ID);
if (index >= 0)
{
var n = (from DataList in contain
where DataList.Name == ID
select DataList).FirstOrDefault();
{
int exists = -1;
exists = n.DoesExist(dateTime);
string previous = string.Empty;
if (exists > 0)
{
previous = n.Update(dateTime, data);
}
else
{
previous = n.Add(dateTime, data);
}
Console.WriteLine("OK " + previous);
}
else
{
}

46
}
else
{
Console.WriteLine("Error: No history exists for identifier '" +
ID.ToString() + "' ");
}
}
else
{
Console.WriteLine("Error: The ID provided is invalid. Please ensure it is
a number.");
}
if (line != null)
{
}
}
protected void Delete(List<DataDict> contain)
{
{
if (index >= 0)
{
{
KeyValuePair<long, string> got = n.Specific(dateTime);
n.deleteAfter(dateTime);
Console.WriteLine("OK " + got.Value.ToString());
}
//if there is no timestamp, remove the whole list
else
{
string newestValue = n.Latest().Value;
contain.Remove(n);
Console.WriteLine("OK " + newestValue);
}
}
else
{
Console.WriteLine("Error: The ID provided [" + ID.ToString() + "] has
no history. Please ensure you provide a valid ID.");
}
}
else
{
Console.WriteLine("Error: The ID provided is Invalid. Please ensure it is
a number.");
}
if (line != null)

47
{
}
}
protected void Get(List<DataDict> contain)
{
{
if (index >= 0)
{
{
if (n.ExistsOrLess(dateTime) > 0)
{
KeyValuePair<long, string> got = n.Specific(dateTime);
Console.WriteLine("OK " + got.Value.ToString());
}
else
{
Console.WriteLine("Error: The ID provided [" + ID.ToString()
+ "] has no history prior to the supplied DateTime value.");
}
}
else
{
}
}
else
{
Console.WriteLine("Error: The ID provided [" + ID.ToString() + "] has
no history. Please ensure you provide a valid ID.");
}
}
else
{
a number.");
}
if (line != null)
{
}
}
protected void Latest(List<DataDict> contain)
{
{

48
if (index >= 0)
{
KeyValuePair<long, string> latest = n.Latest();
Console.WriteLine("OK " + latest.Key.ToString() + " " +
latest.Value.ToString());
}
else
{
Console.WriteLine("Error: No history exists for identifier '" +
ID.ToString() + "' ") ;
}
}
else
{
a number.");
}
if (line != null)
{
}
}
protected void FirstCreate(List<DataDict> contain)
{
{
if (index >= 0)
{
Console.WriteLine("Error: The id value " + ID.ToString() + " already
exists");
}
else
{
DataDict n = new DataDict(ID);
contain.Add(n);//adds the reference to the history store in the
container list
{
DataItem d = new DataItem(data, dateTime);
n.Add(dateTime, data);//the first record in the history
}
}
}
}
protected void FirstUpdate(List<DataDict> contain)
{

49
{
{
n.Add(dateTime, data);//additional records in the history
}
}
}
}
class DataDict
{
int name;
/*the Property only has an accessor to prevent accidental edit.
It allows multiple records to be stored and retrieved against the same ID
This structure allows you to access just the information relating to the ID
(Security) submitted
The alternative of putting all records in one list would mean selecting the
required ID from
the dictionary into a working dictionary each time, or working within the clutter
of many irrelevant records */
public int Name { get { return name; } }
public SortedDictionary<long, string> dataDict { get; set; }
public DataDict(int n)
{
name = n;
dataDict = new SortedDictionary<long, string>();
}
public string Add(long timePassed, string data)
{
string prev = string.Empty;
long prevKey = -1;
if (dataDict.Keys.Count > 0)
{
prevKey = dataDict.Keys.Max();
}
if (prevKey >= 0)
{
var previous = dataDict.Where(x => x.Key == prevKey).First();
prev = previous.Value;
}
else { prev = "not available"; }
dataDict.Add(timePassed, data);
return prev;
}
public int DoesExist(long dateTime)

50
{
if (dataDict.ContainsKey(dateTime))
{
return 1;
}
else
{
return 0;
}
}
public string Update(long timePassed, string data)
{
string prev = string.Empty;
var previous = dataDict.FirstOrDefault(e => e.Key == timePassed);
prev = previous.Value;
dataDict.Remove(timePassed);
dataDict.Add(timePassed, data);
return prev;
}
public string getBiggestData()
{
return dataDict.Values.Max().ToString();
}
public int ExistsOrLess(long dateTime)
{
var allUnder = dataDict.Where(e => e.Key <= dateTime);
if (allUnder.Count() > 0)
{
return 1;
}
else
{
return 0;
}
}
public KeyValuePair<long, string> Specific(long dateTime)
{
if (dataDict.ContainsKey(dateTime))
{
return dataDict.FirstOrDefault(e => e.Key == dateTime);
}
else
{
var allUnder = dataDict.Where(e => e.Key < dateTime);
return allUnder.Last();
}
}

51
public void deleteBefore(long dateTime)
{
SortedDictionary<long, string> tempDict = new SortedDictionary<long,
string>(dataDict.Where(e => e.Key >= dateTime).ToDictionary(e => e.Key, e => e.Value));
dataDict = tempDict;
}
public void deleteAfter(long dateTime)
{
SortedDictionary<long, string> tempDict = new SortedDictionary<long,
string>(dataDict.Where(e => e.Key <= dateTime).ToDictionary(e => e.Key, e => e.Value));
dataDict = tempDict;
}
public KeyValuePair<long, string> Latest()
{
long highest = dataDict.Keys.Max();
return dataDict.Where(x => x.Key == highest).First();
}
}

52
ChrisWorledgePortfolio2|2/1/2016Zero to four were used in the automated demo, so five and six have been used
in place of 0 & 1 in the manual demo.

53
ENTITY FRAMEWORK WITH WEBFORMS
An example of displaying the relationships between different staff from a
database using entity framework and web forms:
Data
ID ForeName SurName Manager
0 Lucy Atwell NULL
1 Carla Barns 0
2 Tara Crane 0
3 Freda Dunbarr 0
4 Patricia Edwards 1
5 Vicky Fox 1
6 Margaret Grant 2
7 Cindy Hall 2
8 Kirsty Irwin 3
10 Jane James 3
ID EmpID JobID
1 0 1
2 1 2
3 2 4
4 3 6
5 4 3
6 5 5
7 6 7
8 7 3
9 8 5
10 9 7
11 10 7

54
ID Job
1 Pharmacist
2 Physiotherapist
3 Cardiac Technician
4 Radiographer
5 Phlebotomist
6 Biomedical Scientist
7 Pharmacy Technician
Data Access Classes
public partial class Ldemo : DataContext
{
public Table<Emp> Emp;
public Table<EmpJob> EmpJob;
public Table<Job> Job;
public Ldemo(string connection) : base(connection) { }
}
public class Relationship
{
public String Forename { get; set; }
public String Surname { get; set; }
public String Job { get; set; }
public String Manager { get; set; }
public Relationship(String f, String s, String j, String m) {
Forename = f;
Surname = s;
Job = j;
Manager = m;
}
}
Form Code Behind
public partial class Page1 : System.Web.UI.Page
{
public List<Relationship> relations = new List<Relationship>();
protected void Page_Load(object sender, EventArgs e)
{
var conString =
System.Configuration.ConfigurationManager.ConnectionStrings["LinqDemoConnectionString"].T
oString();
Ldemo db = new Ldemo(conString);
relations = (from a in db.Emp
join b in db.Emp on new { Manager =
a.Manager.GetValueOrDefault(-1) } equals new { Manager = b.ID } into b_join

55
from b in b_join.DefaultIfEmpty()
join EmpJobs in db.EmpJob on new { ID = a.ID } equals new { ID =
EmpJobs.EmpID }
join Jobs in db.Job on new { JobID = EmpJobs.JobID } equals new
{ JobID = Jobs.ID }
select new Relationship(
a.ForeName,
a.SurName,
Jobs.Job1,
b.ForeName + " " + b.SurName
)).ToList();
}
}
The code creates a list called relations which holds all of the staff names with
their job and their manager. Since Lucy Atwell’s manager field contains null,
her manager field should be blank. All the other staff have a number
representing another member of staff is their manager.
Form aspx
<%@ Page Language="C#" AutoEventWireup="true" CodeBehind="Page1.aspx.cs"
Inherits="LinqDemo.Page1" %>
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
<title></title>
</head>
<body>
<form id="form1" runat="server">
<div>
<table>
<tr>
<td><b>Forename</b></td>
<td><b>Surname</b></td>
<td><b>Job</b></td>
<td><b>Manager</b></td>
</tr>
<% foreach (var relation in relations) { %>
<tr><td><%= relation.Forename %></td>
<td><%= relation.Surname %></td>
<td><%= relation.Job %></td>
<td><%= relation.Manager %></td></tr>
<% } %>
</table>
</div>
</form>
</body>
</html>

56
The outcome:

57
ENTITY FRAMEWORK WITH MVC
This application demonstrates the use of entity framework 6 with an MVC5
asp.net (C#) 4.5 combination:
The purpose of the application is to store, retrieve, and display information
about shares.
It has different markets; shares; and share prices, so displays tables of these
allowing Create; Read; Update; and Delete functionality. It also allows display of
tables sorted by different parameters, and a view of just the most recent prices
for each share. The prices and shares table’s pages have a chart facility which
provides a line chart of the selected share price over time.
This is the Home page from the navigation bar along the top.
The subsequent shots follow along the navigation bar (List of stocks; List of
markets; List of prices; Sorted list of prices; Latest prices).

58

59

60

61
From the Prices list the chart button click for Jones gives:

62
From the Stocks page the charts link click for Browns gives:
Adding a new price:
The current date and time is inserted for you, and you select the stock from the
drop-down.

63
Models:
namespace MVC5ef6.Models
{
using System;
using System.Collections.Generic;
public partial class Stock
{
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage",
"CA2214:DoNotCallOverridableMethodsInConstructors")]
public Stock()
{
this.Prices = new HashSet<Price>();
}
public int stockID { get; set; }
public string stockName { get; set; }
public Nullable<int> marketID { get; set; }
public virtual Market Market { get; set; }
"CA2227:CollectionPropertiesShouldBeReadOnly")]
public virtual ICollection<Price> Prices { get; set; }
}
public partial class Market
{
"CA2214:DoNotCallOverridableMethodsInConstructors")]
public Market()
{
this.Stocks = new HashSet<Stock>();
}
public int marketID { get; set; }
public string marketName { get; set; }
"CA2227:CollectionPropertiesShouldBeReadOnly")]
public virtual ICollection<Stock> Stocks { get; set; }
}
public partial class Price
{
public int ID { get; set; }
public Nullable<int> stockID { get; set; }
public Nullable<System.DateTime> Stamp { get; set; }
public Nullable<decimal> Pence { get; set; }
public virtual Stock Stock { get; set; }
}
public partial class LatestPrice
{

64
public long ID { get; set; }
public string marketName { get; set; }
}
public partial class PriceListItem
{
public Nullable<int> stockID { get; set; }
}
public class StockPriceModel
{
public string ChartTitle { get; set; }
public string StampTitle { get; set; }
public string PenceTitle { get; set; }
public int stockID { get; set; }
public StockPrice PriceData { get; set; }
}
public class StockPrice
{
public string Stamp { get; set; }
public decimal Pence { get; set; }
}
}
Views:
Shared: _Layout;
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8" />
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>@ViewBag.Title - My ASP.NET Application</title>
@Styles.Render("~/Content/css")
@Scripts.Render("~/bundles/modernizr")
@Scripts.Render("~/bundles/jquery")
<script type="text/javascript"
src="https://www.gstatic.com/charts/loader.js"></script>
</head>
<body>
<div class="navbar navbar-inverse navbar-fixed-top">
<div class="container">

65
<div class="navbar-header">
<button type="button" class="navbar-toggle" data-toggle="collapse" data-
target=".navbar-collapse">
<span class="icon-bar"></span>
</button>
@Html.ActionLink("Share Prices", "Index", "Home", new { area = "" }, new
{ @class = "navbar-brand" })
</div>
<div class="navbar-collapse collapse">
<ul class="nav navbar-nav">
<li>@Html.ActionLink("Home", "Index", "Home")</li>
<li>@Html.ActionLink("List of stocks", "Index", "Stocks")</li>
<li>@Html.ActionLink("List of markets", "Index", "Markets")</li>
<li>@Html.ActionLink("List of prices", "Index", "Prices")</li>
<li>@Html.ActionLink("Sorted List of prices", "Index",
"PriceListItems")</li>
<li>@Html.ActionLink("Latest Prices", "Index", "LatestPrices")</li>
</ul>
</div>
</div>
</div>
<div class="container body-content">
<h1></h1>
@RenderBody()

<footer>
<p>© @DateTime.Now.Year - MVC5 with entity framework 6 application</p>
</footer>
</div>
@Scripts.Render("~/bundles/jquery")
@Scripts.Render("~/bundles/bootstrap")
@RenderSection("scripts", required: false)
</body>
</html>
Home: Index;
@{
ViewBag.Title = "Home Page";
}
<div class="jumbotron">
<h1>A short - cut to the latest prices</h1>
<h2>
Each stock's latest price, ordered by market.
<a>
@Html.ActionLink("Latest Prices", "Index", "LatestPrices", null, new { @class
= "btn btn-primary btn-lg actionLink" })
</a>
</h2>
</div>
<div>

66
<div class="spacer"></div>
</div>
<div class="row">
<div class="col-md-4">
<h2>See the Stocks</h2>
<a>@Html.ActionLink("List of stocks", "Index", "Stocks", null, new {@class= "btn
btn-primary btn-lg actionLink" }) </a>
</div>
<h2>See the Markets</h2>
<a>@Html.ActionLink("List of markets", "Index", "Markets", null, new { @class =
"btn btn-primary btn-lg actionLink" })</a>
</div>
<h2>See the Prices</h2>
<a>@Html.ActionLink("List of prices", "Index", "PriceListItems", null, new {
@class = "btn btn-primary btn-lg actionLink" }) </a>
</div>
</div>
Stocks: Index;
@model IEnumerable<MVC5ef6.Models.Stock>
@{
ViewBag.Title = "Index";
}
<h2>Table of Stocks</h2>
<p>
@Html.ActionLink("Create New", "Create")
</p>
<table class="table">
<tr>
<th>
@Html.DisplayNameFor(model => model.stockName)
</th>
<th>
@Html.DisplayNameFor(model => model.Market.marketName)
</th>
<th></th>
</tr>
@foreach (var item in Model) {
<tr>
<td>
@Html.DisplayFor(modelItem => item.stockName)

67
</td>
<td>
@Html.DisplayFor(modelItem => item.Market.marketName)
</td>
<td>
@Html.ActionLink("Chart", "Chart", new { id = item.stockID }, new { @class =
"actionLink" }) |
@Html.ActionLink("Edit", "Edit", new { id=item.stockID }, new { @class =
"actionLink" }) |
@Html.ActionLink("Details", "Details", new { id=item.stockID }, new { @class
= "actionLink" }) |
@Html.ActionLink("Delete", "Delete", new { id=item.stockID }, new { @class =
"actionLink" })
</td>
</tr>
}
</table>
Markets: Index;
@model IEnumerable<MVC5ef6.Models.Market>
@{
}
<h2>Table of Markets</h2>
<p>
@Html.ActionLink("Create New", "Create")
</p>
<tr>
<th>
@Html.DisplayNameFor(model => model.marketName)
</th>
<th></th>
</tr>
<tr>
<td>
@Html.DisplayFor(modelItem => item.marketName)
</td>
<td>
@Html.ActionLink("Edit", "Edit", new { id=item.marketID }, new { @class =
"actionLink" }) |
@Html.ActionLink("Details", "Details", new { id=item.marketID }, new { @class
= "actionLink" }) |
@Html.ActionLink("Delete", "Delete", new { id=item.marketID }, new { @class =
"actionLink" })
</td>
</tr>
}

68
</table>
Prices: Index;
@model IEnumerable<MVC5ef6.Models.Price>
@{
ViewBag.Title = "Prices";
}
<div class="spacer" ></div>
<h2>Table of Prices</h2>
<p>
@Html.ActionLink("Create New", "Create", null, new { @class = "actionLink" })
</p>
<tr>
<th>
@Html.DisplayNameFor(model => model.Stamp)
</th>
<th>
@Html.DisplayNameFor(model => model.Pence)
</th>
<th>
@Html.DisplayNameFor(model => model.Stock.stockName)
</th>
<th></th>
</tr>
@foreach (var item in Model)
{
<tr>
<td>
@Html.DisplayFor(modelItem => item.Stamp)
</td>
<td>
@Html.DisplayFor(modelItem => item.Pence)
</td>
<td>
@Html.DisplayFor(modelItem => item.Stock.stockName)
</td>
<td>
@Html.ActionLink("Chart", "Chart", new { id = item.stockID }, new {
@class = "actionLink" }) |
@Html.ActionLink("Edit", "Edit", new { id = item.ID }, new { @class =
"actionLink" }) |
@Html.ActionLink("Details", "Details", new { id = item.ID }, new {
@class = "actionLink" }) |
@Html.ActionLink("Delete", "Delete", new { id = item.ID }, new {
@class = "actionLink" })
</td>
</tr>
}
</table>

69
PriceListItems (sorted list): Index;
@model IEnumerable<MVC5ef6.Models.PriceListItem>
@{
ViewBag.Title = "Sorted Prices";
}
<h2>Index</h2>
<p>
</p>
<tr>
<th>
</th>
<th>
</th>
<th>
</th>
<th></th>
</tr>
<tr>
<td>
</td>
<td>
</td>
<td>
</td>
</tr>
}
</table>
Latest Prices: Index;
<META HTTP-EQUIV="REFRESH" CONTENT="60">
@model IEnumerable<MVC5ef6.Models.LatestPrice>
@{
}

70
<h2>Table of Latest Prices</h2>
<tr>
<th>
@Html.DisplayNameFor(model => model.marketName)
</th>
<th>
</th>
<th>
</th>
<th>
</th>
<th></th>
</tr>
<tr>
<td>
@Html.DisplayFor(modelItem => item.marketName)
</td>
<td>
</td>
<td>
</td>
<td>
</td>
</tr>
}
</table>
Controllers:
namespace MVC5ef6.Controllers
{
public class HomeController : Controller
{
public ActionResult Index()
{
return View();
}
public ActionResult About()
{
ViewBag.Message = "Your application description page.";

71
return View();
}
public ActionResult Contact()
{
ViewBag.Message = "Your contact page.";
return View();
}
}
public class LatestPricesController : Controller
{
private MVC5demoEntities db = new MVC5demoEntities();
// GET: LatestPrices
{
return View(db.LatestPrices.OrderBy(l => l.marketName).ToList());
}
// GET: LatestPrices/Details/5
public ActionResult Details(long? id)
{
if (id == null)
{
return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
}
LatestPrice latestPrice = db.LatestPrices.Find(id);
if (latestPrice == null)
{
return HttpNotFound();
}
return View(latestPrice);
}
// GET: LatestPrices/Create
public ActionResult Create()
{
return View();
}
// POST: LatestPrices/Create
[HttpPost]
[ValidateAntiForgeryToken]
public ActionResult Create([Bind(Include =
"ID,stockName,marketName,Pence,Stamp")] LatestPrice latestPrice)
{
if (ModelState.IsValid)
{
db.LatestPrices.Add(latestPrice);
db.SaveChanges();
return RedirectToAction("Index");
}

72
}
// GET: LatestPrices/Edit/5
public ActionResult Edit(long? id)
{
if (id == null)
{
}
{
}
}
// POST: LatestPrices/Edit/5
[HttpPost]
public ActionResult Edit([Bind(Include = "ID,stockName,marketName,Pence,Stamp")]
LatestPrice latestPrice)
{
{
db.Entry(latestPrice).State = EntityState.Modified;
db.SaveChanges();
}
}
// GET: LatestPrices/Delete/5
public ActionResult Delete(long? id)
{
if (id == null)
{
}
{
}
}
// POST: LatestPrices/Delete/5
[HttpPost, ActionName("Delete")]
public ActionResult DeleteConfirmed(long id)
{
db.LatestPrices.Remove(latestPrice);
db.SaveChanges();
}

73
protected override void Dispose(bool disposing)
{
if (disposing)
{
db.Dispose();
}
base.Dispose(disposing);
}
}
public class MarketsController : Controller
{
// GET: Markets
{
return View(db.Markets.ToList());
}
// GET: Markets/Details/5
public ActionResult Details(int? id)
{
if (id == null)
{
}
Market market = db.Markets.Find(id);
if (market == null)
{
}
return View(market);
}
// GET: Markets/Create
{
return View();
}
// POST: Markets/Create
[HttpPost]
public ActionResult Create([Bind(Include = "marketID,marketName")] Market market)
{
{
db.Markets.Add(market);
db.SaveChanges();
}
}

74
// GET: Markets/Edit/5
public ActionResult Edit(int? id)
{
if (id == null)
{
}
if (market == null)
{
}
}
// POST: Markets/Edit/5
[HttpPost]
public ActionResult Edit([Bind(Include = "marketID,marketName")] Market market)
{
{
db.Entry(market).State = EntityState.Modified;
db.SaveChanges();
}
}
// GET: Markets/Delete/5
public ActionResult Delete(int? id)
{
if (id == null)
{
}
if (market == null)
{
}
}
// POST: Markets/Delete/5
public ActionResult DeleteConfirmed(int id)
{
db.Markets.Remove(market);
db.SaveChanges();
}
{
if (disposing)

75
{
db.Dispose();
}
}
}
public class NamedPrice
{
Models.Stock name { get; set; }
Models.Price price { get; set; }
}
public class PriceListItemsController : Controller
{
// GET: PriceListItems
{
var pricesForList = db.Prices.Join(db.Stocks, a => a.stockID, b => b.stockID,
(a, b) => new { a, b }).
Select(c => new PriceListItem { ID = c.a.ID, stockID = c.a.stockID, Stamp
= c.a.Stamp, Pence = c.a.Pence, stockName = c.b.stockName }).
OrderBy(q => q.Stamp).GroupBy(s => s.stockName);
IQueryable<IGrouping<string, PriceListItem>> ListedPrices =
pricesForList;/*We want to controll the display order,
but we don't need the grouping order as a seperate data attribute so we will
take the items into a list*/
List <PriceListItem> DisplayList = new List<PriceListItem>();
foreach (IGrouping<string, PriceListItem> item in ListedPrices)
{
foreach (PriceListItem listItem in item)
{
DisplayList.Add(listItem);
}
}
//now we can pass the list for display
return View(DisplayList);
}
// GET: PriceListItems/Details/5
{
if (id == null)
{
}
PriceListItem priceListItem = db.PriceListItems.Find(id);
if (priceListItem == null)
{
}

76
return View(priceListItem);
}
// GET: PriceListItems/Create
{
return View();
}
// POST: PriceListItems/Create
[HttpPost]
public ActionResult Create([Bind(Include = "ID,stockID,Stamp,Pence,stockName")]
PriceListItem priceListItem)
{
{
db.PriceListItems.Add(priceListItem);
db.SaveChanges();
}
}
// GET: PriceListItems/Edit/5
{
if (id == null)
{
}
{
}
}
// POST: PriceListItems/Edit/5
[HttpPost]
public ActionResult Edit([Bind(Include = "ID,stockID,Stamp,Pence,stockName")]
PriceListItem priceListItem)
{
{
db.Entry(priceListItem).State = EntityState.Modified;
db.SaveChanges();
}
}
// GET: PriceListItems/Delete/5
{

77
if (id == null)
{
}
{
}
}
// POST: PriceListItems/Delete/5
{
db.PriceListItems.Remove(priceListItem);
db.SaveChanges();
}
{
if (disposing)
{
db.Dispose();
}
}
}
public class PricesController : Controller
{
// GET: Prices
{
var prices = db.Prices.Include(p => p.Stock);
return View(prices.ToList());
}
// GET: Prices/Details/5
{
if (id == null)
{
}
Price price = db.Prices.Find(id);
if (price == null)
{

78
}
return View(price);
}
// GET: Prices/Create
{
ViewBag.stockID = new SelectList(db.Stocks, "stockID", "stockName");
return View();
}
// POST: Prices/Create
[HttpPost]
public ActionResult Create([Bind(Include = "ID,stockID,Stamp,Pence")] Price
price)
{
{
db.Prices.Add(price);
db.SaveChanges();
}
ViewBag.stockID = new SelectList(db.Stocks, "stockID", "stockName",
price.stockID);
return View(price);
}
// GET: Prices/Edit/5
{
if (id == null)
{
}
if (price == null)
{
}
price.stockID);
return View(price);
}
// POST: Prices/Edit/5
[HttpPost]
public ActionResult Edit([Bind(Include = "ID,stockID,Stamp,Pence")] Price price)
{
{
db.Entry(price).State = EntityState.Modified;
db.SaveChanges();
}

79
price.stockID);
return View(price);
}
// POST: Prices/Chart/5
public ActionResult Chart(int? id)
{
if (id != null)
{
int stock;
int.TryParse(id.ToString(), out stock);//drag the int out of the ?int
string stockName = db.Stocks.Where(a => a.stockID == stock).Select(a =>
a.stockName).FirstOrDefault() ;
StockPriceModel SPModel = new StockPriceModel();
SPModel.ChartTitle = stockName;
SPModel.StampTitle = "DateTime";
SPModel.PenceTitle = "Pence";
SPModel.stockID = stock;
return View(SPModel);
}
else
{
}
}
public JsonResult GetChart(int stock)
{
var ChartData = db.Prices.Where(a => a.stockID.HasValue ? a.stockID == stock
: false)
.Select(p => new { Stamp = p.Stamp.HasValue ? p.Stamp.Value :
DateTime.Now, p.Pence }).
OrderBy(q => q.Stamp);//all the dates and prices in date order
List<StockPrice> CleanChartData = new List<StockPrice>();
CultureInfo culture = new CultureInfo("pt-BR");//so we get day before month!
int x = 0;
foreach (var t in ChartData)
{
string time = t.Stamp.ToString("G", culture);//give a date to display in
javascript
decimal price;
decimal.TryParse(t.Pence.ToString(), out price);//because t.pence is a
nullable decimal
StockPrice current = new StockPrice();
current.ID = x;
current.Stamp = time;
current.Pence = price;
CleanChartData.Add(current);
x++;
}
return Json(CleanChartData, JsonRequestBehavior.AllowGet);

80
}
// GET: Prices/Delete/5
{
if (id == null)
{
}
if (price == null)
{
}
return View(price);
}
// POST: Prices/Delete/5
{
db.Prices.Remove(price);
db.SaveChanges();
}
{
if (disposing)
{
db.Dispose();
}
}
}
public class StocksController : Controller
{
// GET: Stocks
{
var stocks = db.Stocks.Include(s => s.Market);
return View(stocks.ToList());
}
// GET: Stocks/Details/5
{
if (id == null)
{

81
}
Stock stock = db.Stocks.Find(id);
if (stock == null)
{
}
return View(stock);
}
// GET: Stocks/Create
{
ViewBag.marketID = new SelectList(db.Markets, "marketID", "marketName");
return View();
}
// POST: Stocks/Create
[HttpPost]
public ActionResult Create([Bind(Include = "stockID,stockName,marketID")] Stock
stock)
{
{
db.Stocks.Add(stock);
db.SaveChanges();
}
ViewBag.marketID = new SelectList(db.Markets, "marketID", "marketName",
stock.marketID);
return View(stock);
}
// GET: Stocks/Edit/5
{
if (id == null)
{
}
if (stock == null)
{
}
stock.marketID);
return View(stock);
}
// POST: Stocks/Edit/5
[HttpPost]
public ActionResult Edit([Bind(Include = "stockID,stockName,marketID")] Stock
stock)
{

82
{
db.Entry(stock).State = EntityState.Modified;
db.SaveChanges();
}
stock.marketID);
return View(stock);
}
// POST: Stocks/Chart/5
public ActionResult Chart(int? id)
{
if (id != null)
{
int stock;
int.TryParse(id.ToString(), out stock);//drag the int out of the ?int
string stockName = db.Stocks.Where(a => a.stockID == stock).Select(a =>
a.stockName).FirstOrDefault();
StockPriceModel SPModel = new StockPriceModel();
SPModel.ChartTitle = stockName;
SPModel.StampTitle = "DateTime";
SPModel.PenceTitle = "Pence";
SPModel.stockID = stock;
return View(SPModel);
}
else
{
}
}
public JsonResult GetChart(int stock)
{
var ChartData = db.Prices.Where(a => a.stockID.HasValue ? a.stockID == stock
: false)
.Select(p => new { Stamp = p.Stamp.HasValue ? p.Stamp.Value :
DateTime.Now, p.Pence }).
OrderBy(q => q.Stamp);//all the dates and prices in date order
List<StockPrice> CleanChartData = new List<StockPrice>();
CultureInfo culture = new CultureInfo("pt-BR");//so we get day before month!
int x = 0;
foreach (var t in ChartData)
{
string time = t.Stamp.ToString("d", culture);//give a date to display in
javascript
decimal price;
decimal.TryParse(t.Pence.ToString(), out price);//because t.pence is a
nullable decimal
StockPrice current = new StockPrice();
current.ID = x;
current.Stamp = time;
current.Pence = price;
CleanChartData.Add(current);

83
x++;
}
return Json(CleanChartData, JsonRequestBehavior.AllowGet);
}
// GET: Stocks/Delete/5
{
if (id == null)
{
}
if (stock == null)
{
}
return View(stock);
}
// POST: Stocks/Delete/5
{
db.Stocks.Remove(stock);
db.SaveChanges();
}
{
if (disposing)
{
db.Dispose();
}
}
}
}

84
WEB API OF PREVIOUS EXAMPLE
Markets

85
Stocks

86
Prices
Latest Prices

87

88

89
var SPapp = angular.module('SPModule', ['ngResource']);
(function () {
var MarketsController = function ($scope, $http) {
$scope.markets = [];
var markets = function (serviceResp) {
$scope.markets = serviceResp.data;
};
var errorDetails = function (serviceResp) {
$scope.Error = "Something went wrong ??";
};
$http.get("http://localhost:63579/api/Markets")
.then(markets, errorDetails);
$scope.Title = "Markets Page";
};
SPapp.controller("MarketsController", MarketsController);
}());
(function () {
var StocksController = function ($scope, $http) {
$scope.stocks = [];
var target = 'Stocks'
$scope.stocks = serviceResp.data;
};
};
$http.get("http://localhost:63579/api/Stocks")
$scope.Title = "Stocks Page";

90
};
SPapp.controller("StocksController", StocksController);
}());
(function () {
var PricesController = function ($scope, $http) {
$scope.prices = [];
$scope.prices = serviceResp.data;
};
};
$http.get("http://localhost:63579/api/PriceListItems")
$scope.Title = "Prices Page";
};
SPapp.controller("PricesController", PricesController);
}());
SPapp.controller('latestPricesController', ['$scope', '$http',
function ($scope, $http) {
$scope.latestPrices = [];
$scope.loading = true;
$scope.addMode = false;
//Used to display the data
//Alternative ports old WebAPI 63579 new WebAPI1 54488
$http({
method: 'GET',
url: 'http://localhost:63579/api/latestPrices'
})
.then(function successCallback(response) {
console.log('success');
$scope.latestPrices = response.data;
$scope.loading = false;
}, function errorCallback(response) {
console.log('error');
$scope.errorMsg = response.status + ': ' + response.data;
$scope.error = "An Error has occured while loading 63579 prices! Status: " +
status + "statusText: ";// + statusText + "oops";
$scope.failstatus = status;
$scope.loading = false;
});
}]);
Home
<!DOCTYPE html>
<html lang="en" ng-app="SPModule">
<head>
<title>Share Prices Home Page</title>

91
<script src="Scripts/jquery-2.1.4.min.js"></script>
<link href="Content/bootstrap.min.css" rel="stylesheet" />
<link href="Content/flatly.css" rel="stylesheet" />
<link href="Content/Site.css" rel="stylesheet" />
<script src="Scripts/bootstrap.min.js"></script>
<script src="Scripts/angular.min.js"></script>
<script src="Scripts/angular-resource.min.js"></script>
<script src="App/app.js"></script>
<script src="Services/latestPricesService.js"></script>
<script src="Services/TableService.js"></script>
<script src="Factories/latestPricesFactory.js"></script>
<script src="Factories/TableFactory.js"></script>
<script src="Factories/CrudFactory.js"></script>
<script src="Controllers/latestPricesController.js"></script>
<script src="Controllers/simlatestPricesController.js"></script>
</head>
<body ng-controller="latestPricesController">
<h1>  Welcome To Share Prices Stock Market Website</h1>
<h1> <a href="Views/Markets.html">Markets</a> <a
href="Views/Stocks.html">Stocks</a> <a href="Views/Prices.html">All
Prices</a> <a href="Views/LatestPrices.html">Latest Prices</a></h1>
<h2>  LatestPrices</h2>
<strong class="error">{{ error }}</strong><br />
<strong class="error">{{ errorMsg }}</strong><br />
<strong class="error">{{ failstatus }}</strong>
<div id="mydiv" ng-show="loading">
<img src="images/ajax-loader.gif" class="ajax-loader" />
</div>
<table id="pricesTable" class="table table-bordered table-hover"
style="width:800px">
<thead>
<tr>
<th>ID</th>
<th>Stock Name</th>
<th>Market Name</th>
<th>Price</th>
<th>Stamp</th>
</tr>
</thead>
<tbody>
<tr ng-repeat="latestPrice in latestPrices | orderBy: 'marketName'">
<td><strong>{{ latestPrice.id }}</strong></td>
<td>
<p>{{ latestPrice.stockName }}</p>
</td>
<td>
<p>{{ latestPrice.marketName }}</p>
</td>
<td>
<p>{{ latestPrice.pence }}</p>
</td>
<td>
<p>{{ latestPrice.stamp }}</p>

92
</td>
</tr>
</tbody>
<tfoot></tfoot>
</table>
<hr />
</div>
</body>
</html>
Markets
<!DOCTYPE html>
<head>
<title>Markets</title>
<script src="../Scripts/jquery-2.1.4.min.js"></script>
<link href="../Content/bootstrap.min.css" rel="stylesheet" />
<link href="../Content/flatly.css" rel="stylesheet" />
<link href="../Content/Site.css" rel="stylesheet" />
<script src="../Scripts/bootstrap.min.js"></script>
<script src="../Scripts/angular.min.js"></script>
<script src="../App/app.js"></script>
<script src="../Controllers/MarketsController.js"></script>
</head>
<body ng-controller="MarketsController">
<h1>  <a href="../Home.html">Home</a> <a
href="Stocks.html">Stocks</a> <a href="Prices.html">allPrices</a> <a
href="LatestPrices.html">LatestPrices</a></h1>
<h2>  Market Names</h2>
<img src="../images/ajax-loader.gif" class="ajax-loader" />
</div>
<thead>
<tr>
<th>ID</th>
</tr>
</thead>
<tbody>
<tr ng-repeat="market in markets">
<td><strong>{{ market.marketID }}</strong></td>
<td>
<p>{{ market.marketName }}</p>
</td>

93
</tr>
</tbody>
<tfoot></tfoot>
</table>
<hr />
</div>
</body>
</html>
Stocks
<!DOCTYPE html>
<head>
<script src="../Controllers/StocksController.js"></script>
</head>
<body ng-controller="StocksController">
href="Markets.html">Markets</a> <a href="Prices.html">allPrices</a> <a
<h2>  Stock Names</h2>
</div>
<thead>
<tr>
<th>ID</th>
<th>Stock Name</th>
</tr>
</thead>
<tbody>
<tr ng-repeat="stock in stocks">
<td><strong>{{ stock.stockID }}</strong></td>
<td>
<p>{{ stock.stockName }}</p>
</td>

94
</tr>
</tbody>
<tfoot></tfoot>
</table>
<hr />
</div>
</body>
</html>
Prices
<!DOCTYPE html>
<head>
<script src="../Controllers/PricesController.js"></script>
</head>
<body ng-controller="PricesController">
href="Markets.html">Markets</a> <a href="Stocks.html">Stocks</a> <a
<h2>  Stock Prices</h2>
</div>
<thead>
<tr>
<th>ID</th>
<th>Stock Name</th>
<th>Price</th>
<th>Date and Time</th>
</tr>
</thead>
<tbody>
<tr ng-repeat="price in prices">
<td><strong>{{ price.id }}</strong></td>

95
<td>
<p>{{ price.stockName }}</p>
</td>
<td>
<p>{{ price.pence }}</p>
</td>
<td>
<p>{{ price.stamp }}</p>
</td>
</tr>
</tbody>
<tfoot></tfoot>
</table>
<hr />
</div>
</body>
</html>
Latest Prices
<!DOCTYPE html>
<head>
<title>Latest Prices</title>
<script src="../Controllers/latestPricesController.js"></script>
<script src="../Controllers/simlatestPricesController.js"></script>
<script src="../Factories/latestPricesFactory.js"></script>
<script src="../Services/latestPricesService.js"></script>
</head>
<body ng-controller="latestPricesController">
href="Markets.html">Markets</a> <a href="Stocks.html">Stocks</a> <a
href="Prices.html">allPrices</a></h1>
<h2>  LatestPrices</h2>
</div>
<thead>
<tr>
<th>ID</th>

96
<th>Stock Name</th>
<th>Price</th>
<th>Stamp</th>
</tr>
</thead>
<tbody>
<tr ng-repeat="latestPrice in latestPrices">
<td><strong>{{ latestPrice.id }}</strong></td>
<td>
<p>{{ latestPrice.stockName }}</p>
</td>
<td>
<p>{{ latestPrice.marketName }}</p>
</td>
<td>
<p>{{ latestPrice.pence }}</p>
</td>
<td>
<p>{{ latestPrice.stamp }}</p>
</td>
</tr>
</tbody>
<tfoot></tfoot>
</table>
<hr />
</div>>
</body>
</html>

97
AT HOME TASK
There is a special cash machine, without any security, that dispenses money
(notes and coins). The machine has a given initial state of what coins and notes
it has available.
The initial state is: 100x1p, 100x2p, 100x5p, 100x10p, 100x20p, 100x50p,
100x£1, 100x£2, 50x£5, 50x£10, 50x£20, 50x£50.
You should create a program that is given the value to withdraw as an input.
Program the cash machine, so it has 2 algorithms that can be swapped
(swapping can be done by rebuilding and rerunning the application):
1. Algorithm that returns least number of items (coins or notes)
2. Algorithm that returns the highest number of £20 notes possible
Output the number of coins and notes given for each withdrawal.
The machine should output the count and value of coins and notes dispensed
and the balance amount left.
The program should be extendible and written using .NET framework. Use the
best approach you can to implement the solution.
Examples
Algorithm 1
Input (Withdrawal amount)
120.00
Output
£50x2, £20x1
£X.XX balance
Algorithm 2
Input
120.00
Output
£20x6
£X.XX balance

98
First Algorithm:

99
Second Algorithm with £20 note bias:
Program:
namespace CashMachine
{
class Program
{
{
Bank thisBank = new Bank();
thisBank.Algorithm = true;//allows the maximum twenties algorithm
while (true)
{
Console.WriteLine("Please enter required amount:");
string line = Console.ReadLine();
if (line != null)
{
Decimal debit;
if (Decimal.TryParse(line, out debit))
{
string response = thisBank.debit(debit);
Console.WriteLine(response);
}

100
else
{
Console.WriteLine("You have entered an invalid amount.");
}
}
}
}
}
}
Bank:
namespace CashMachine
{
class Bank
{
private Money[] Monies { get; set; }
public Boolean Algorithm { get; set; }
public Bank()
{
Monies = new Money[] {
new Money("£50", 50, 50 ),
new Money("£20", 20, 50 ),
new Money("£10", 10, 50 ),
new Money("£5", 5, 50 ),
new Money("£2", 2, 100 ),
new Money("£1", 1, 100 ),
new Money("50p", .5m, 100 ),//the appended m forces the Decimal type
new Money("20p", .2m, 100 ),
new Money("10p", .1m, 100 ),
new Money("5p", .05m, 100 ),
new Money("2p", .02m, 100 ),
new Money("1p", .01m, 100 )
};
Algorithm = false;//default to all denominations
}
public String debit(Decimal amount)
{
StringBuilder message = new StringBuilder();
Decimal debitvalue = amount;
if (amount <= getBalance())//check the money is available
{
debitAlgorithm(debitvalue, message);//takes the money by denomination
depending on the algorithm
message.Append("rnBalance remaining is £");
string balance = getBalance().ToString("#.##");
message.Append(balance);
return message.ToString();//tell them which notes and coins are being
supplied and how much is left in the machine.
}
else//we can't afford to service this request

101
{
return "The machine does not have sufficient funds to grant your
requestrn We are sorry for the inconvenience.";
}
}
private Decimal getBalance()
{
Decimal balance = 0;
foreach (Money money in Monies)
{
var value = money.value * money.quantity;
balance += value;
}
return balance;
}
private void debitAlgorithm(Decimal debitvalue, StringBuilder message)
{
int numberOfDenominations = Monies.Length;
int index = 0;//set the start point at fifties
Decimal requiredMoney = debitvalue;
Boolean messageAdded = false;
if (Algorithm)
{
index = 1;
requiredMoney = fullAlgorithm(index, messageAdded, requiredMoney,
message);//do the twenties first if set to that Algorithm
index = 0;
requiredMoney = fullAlgorithm(index, messageAdded, requiredMoney,
message);//do the fifties in case there weren't enough twenties left
index = 2;//carry on through the loop from £10 down
}
for (int i = index; i < numberOfDenominations; i++)
{
requiredMoney = fullAlgorithm(i, messageAdded, requiredMoney,
message);//we update the required amount each time
}
}
private Decimal fullAlgorithm(int i, Boolean messageAdded, Decimal debitvalue,
StringBuilder message)
{
Decimal requiredMoney = debitvalue;
int number = (int)(requiredMoney / Monies[i].value);//just the whole number
of this denomination
if (number > 0 && number < Monies[i].quantity)//We want some and that many
are available
{
requiredMoney = requiredMoney % Monies[i].value;//the leftover after the
above
Monies[i].quantity -= number;//debit the machine total for this
denomination

Portfolio2

Recommended

Recommended

More Related Content

What's hot

What's hot (8)

Similar to Portfolio2

Similar to Portfolio2 (20)

Recently uploaded

Recently uploaded (20)

Portfolio2