1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:

[Serializable]
public class Measurement
{
    public Measurement()
    {
    ListOfPoints = new List<PointValues>();
    }

    public string Name { get; set; }
    public DateTime Measurementdate { get; set; }

    public List<PointValues> ListOfPoints { get; set; }
}

[Serializable]
public class PointValues
{
    /// <summary>
    /// Time
    /// </summary>
    public int X { get; set; }
    /// <summary>
    /// Amplitude
    /// </summary>
    public int Y { get; set; }
}                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:

public class MySerializer
{
    public static void Serialize(object myClass, string directory, string file)
    {
        if (!Directory.Exists(directory))
            Directory.CreateDirectory(directory);

        string fileabs = Path.Combine(directory, file);

        using (FileStream myFileStream = new FileStream(fileabs, FileMode.Create))
        {
            BinaryFormatter binFormatter = new BinaryFormatter();
            binFormatter.Serialize(myFileStream, myClass);
        }
    }

    public static object Deserialize(string file)
    {
        object oldObject = null;

        if (File.Exists(file))
        {
            using (FileStream myFileStream = new FileStream(file, FileMode.Open))
            {
                BinaryFormatter binFormatter = new BinaryFormatter();
                oldObject = binFormatter.Deserialize(myFileStream) as object;
            }
        }
        return oldObject;
    }
}                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:

private void LoadSave()
{
    //Messung starten
    //================
    Measurement m = new Measurement() { Name = "Messung1", Measurementdate = DateTime.Now };

    for(int i = 0; i < 100; i++)
    {
        m.ListOfPoints.Add(new PointValues() { X = i, Y = i });
    }
    //================
    
    //Wegschreiben
    MySerializer.Serialize(m, @"c:\Test", "Messung1.mes");

    //Wieder einlesen
    var oldMes = MySerializer.Deserialize(System.IO.Path.Combine(@"c:\Test", "Messung1.mes"));
}                    

1:
2:
3:
4:
5:
6:
7:
8:

public class Measurement
{
    public int Size { get; set; }
    public DateTime Timestamp { get; set; }

    // Weitere Eigenschaften:
    // public int MyProperty { get; set; }
}                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:

var measurements = new List<Measurement>();

// So lange neue Einträge der Liste hinzufügen, wie gemessen wird
while (Measuring)
{
    var measurement = new Measurement();

    measurement.Size = GetSize();
    measurement.Timestamp = DateTime.Now;

    // Weitere Eigenschaften:
    // measurement.MyProperty = GetMyProperty();

    measurements.Add(measurement);
}

Serialize(measurements);                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:

public static void Serialize<T>(string xmlFile, T obj)
{
    var serializer = new XmlSerializer(typeof(T));

    // Erstellt einen neuen Datei-Stream, über den Du auf die Datei zugreifen kannst.
    // Das 'using' sorgt dafür, dass der Stream immer - auch bei einer Exception - geschlossen wird, sonst bleibt die Datei länger gesperrt als gewünscht
    using (var fileStream = File.Create(xmlFile))
    {
        // Das Objekt in die Datei serialisieren
        serializer.Serialize(file, obj);
    }
}
public static T Deserialize<T>(string xmlFile)
{
    var serializer = new XmlSerializer(typeof(T));

    using (var fileStream = File.OpenRead(xmlFile))
    {
        // Die Datei auslesen und die Daten deserialisieren
        return (T)serializer.Deserialize(file);
    }
}                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:

public class Measurement
{
    public int Size { get; set; }
    public DateTime Timestamp { get; set; }
    // Weitere Eigenschaften:
    // ...
}

// Das soll die Quelle der Messungen simulieren:
public static class MeasurementSource
{
    private static readonly Random _rnd = new Random();

    public static int GetNextSize()
    {
        return _rnd.Next(0, 1000);
    }

    // Weitere Werte:
    // ...
}

class Program
{
    static void Main(string[] args)
    {
        using (var csvFile = new CsvFile<Measurement>("measurements.csv"))
        {
            // Nur 10 Messungen, weil ich nicht so lange warten sollte :D
            for (int i = 0; i < 10; i++)
            {
                // Zwei Messungen pro Sekunde:
                Thread.Sleep(500);

                var measurement = new Measurement()
                {
                    Size = MeasurementSource.GetNextSize(),
                    Timestamp = DateTime.Now,
                    // Weitere Eigenschaften:
                    // ...
                };

                csvFile.Append(measurement);
            }
        }
    }
}                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:

Size;Timestamp
571;17.01.2016 12:17:59
159;17.01.2016 12:17:59
713;17.01.2016 12:18:00
872;17.01.2016 12:18:00
517;17.01.2016 12:18:01
135;17.01.2016 12:18:01
870;17.01.2016 12:18:02
761;17.01.2016 12:18:02
200;17.01.2016 12:18:03
591;17.01.2016 12:18:03                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:

using (var measurements = new CsvFileReader<Measurement>("measurements.csv"))
{
    foreach (var measurement in measurements)
    {
        Console.WriteLine("Size: " + measurement.Size);
        Console.WriteLine("Timestamp: " + measurement.Timestamp);
        Console.WriteLine("==============================");
    }
}

Console.ReadKey();                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:

Size: 571
Timestamp: 17.01.2016 12:17:59
==============================
Size: 159
Timestamp: 17.01.2016 12:17:59
==============================
Size: 713
Timestamp: 17.01.2016 12:18:00
==============================
Size: 872
Timestamp: 17.01.2016 12:18:00
==============================
Size: 517
Timestamp: 17.01.2016 12:18:01
==============================
Size: 135
Timestamp: 17.01.2016 12:18:01
==============================
Size: 870
Timestamp: 17.01.2016 12:18:02
==============================
Size: 761
Timestamp: 17.01.2016 12:18:02
==============================
Size: 200
Timestamp: 17.01.2016 12:18:03
==============================
Size: 591
Timestamp: 17.01.2016 12:18:03
==============================                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:

        using (var csvFile = new CsvFile<Measurement>("measurements.csv"))
        {
            for (int i = 0; i < 100; i++)
            {
                // Zwei Messungen pro Sekunde:
                Thread.Sleep(500);

                var measurement = new Measurement()
                {
                    Size = MeasurementSource.GetNextSize(),
                    Timestamp = DateTime.Now,
                    // Weitere Eigenschaften:
                    // ...
                };

                csvFile.Append(measurement);
            }
        }                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:

    public class Program
    {
        public static void Main()
        {
            var LED = new OutputPort(Pins.ONBOARD_LED, false);            

            var period = 1024;
            var maxi = 1000;

            while (true)
            {
                for (int i = 1; i < maxi; i++)
                {
                    LED.Write(true);
                    Delay(i);
                    LED.Write(false);
                    Delay(period - i);
                }

                for (int i = maxi - 1; i > 0; i--)
                {
                    LED.Write(true);
                    Delay(i);
                    LED.Write(false);
                    Delay(period - i);
                }
                Delay(period * maxi / 2);
            }
        }

        private static void Delay(long ticks)
        {
            var due = DateTime.Now.AddTicks(ticks*128);
            while (DateTime.Now < due) ;
            return;
        }
    }                    

1:
2:
3:
4:
5:

public interface IMeasurementSource : IEnumerator<Measurement>, IDiposible
{
    void StartMeasurement();
    void StopMeasurement();
}