Adding CList_ICollection source code.

Author: Clément

source/code/projects/CList_ICollection/CList_ICollection/CList.cs

@@ -0,0 +1,161 @@
+using System;
+using System.Collections.Generic;
+using System.Collections;
+
+public class CList<T>:ICollection<T>
+{
+    /*
+     * https://learn.microsoft.com/en-us/dotnet/api/system.collections.generic.icollection-1?view=net-9.0
+     * A class realizing the ICollection interface must have the following properties:
+     * - A `Count` property that gets the number of elements contained in the ICollection<T>.
+     * - A `IsReadOnly` property that gets a value indicating whether the ICollection<T> is read-only.
+     * and the following methods:
+     * - Add(T): Adds an item to the ICollection<T>.
+     * - Clear(): Removes all items from the ICollection<T>.
+     * Contains(T): Determines whether the ICollection<T> contains a specific value.
+     * CopyTo(T[], Int32): Copies the elements of the ICollection<T> to an Array, starting at a particular Array index.
+     * GetEnumerator(): Returns an enumerator that iterates through a collection. (Inherited from IEnumerable)
+     * Remove(T): Removes the first occurrence of a specific object from the ICollection<T>.
+     */    
+
+    /* Same implementation of Cell as usual.*/
+    private Cell first;
+
+   public CList()
+    {
+        first = null;
+    }
+
+    private class Cell
+    {
+        public T Data { get; set; }
+        public Cell Next { get; set; }
+
+        public Cell(T dataP = default(T), Cell nextP =null) // We provide default values
+        {
+            Data = dataP;
+            Next = nextP;
+        }
+    }
+
+    /* Done with Cell.*/
+
+    // Empty
+    public bool IsEmpty() { return first == null; }
+
+    // Add is simply "AddF", slightly revisited.
+    public void Add(T value)
+    {
+        if (isReadonly) { throw new InvalidOperationException("List is read-only."); }
+        Cell cCell = first;
+        if (cCell != null)
+        {
+            while (cCell.Next != null)
+            // As long as the cCell Cell has a neighbour…
+            {
+                cCell = cCell.Next;
+                // We move the cCell cell to this neighbour.
+            }
+            cCell.Next = new Cell(value, null);
+        }
+        else
+        {
+            first = new Cell(value, null);
+        }
+    }
+
+    public void Clear()
+    {
+        first = null;
+    }
+
+    public bool Contains(T value)
+    {
+        bool found = false;
+        Cell cCell = first;
+        while (cCell != null && !found)
+        {
+            if (cCell.Data.Equals(value)) { found = true; }
+            cCell = cCell.Next;
+        }
+        return found;
+    }
+
+    // Copies the elements of the ICollection to an Array, starting at a particular Array index.
+    public void CopyTo(T[] array, int arrayIndex)
+    {
+        if (array == null)
+            throw new ArgumentNullException("The array cannot be null.");
+        if (arrayIndex < 0)
+            throw new ArgumentOutOfRangeException("The starting array index cannot be negative.");
+        if (Count > array.Length - arrayIndex)
+            throw new ArgumentException("The destination array has fewer elements than the collection.");
+
+        Cell cCell = first;
+        int i = 0; // keeping track of how many elements were copied.
+        while (cCell != null)
+        {
+            array[i + arrayIndex] = cCell.Data;
+            i++;
+            cCell = cCell.Next;
+        }
+    }
+
+    public bool Remove(T value)
+    {
+        if (isReadonly) { throw new InvalidOperationException("List is read-only"); }
+        bool removed = false;
+        if (!IsEmpty())
+        {
+            if (first.Data.Equals(value)) { first = first.Next; removed = true; }
+            else
+            {
+                Cell cCell = first;
+                while (cCell.Next != null)
+                {
+                    if (cCell.Next.Data.Equals(value)) { cCell.Next = cCell.Next.Next; removed = true; }
+                }
+            }
+        }
+        return removed;
+    }
+
+    public int Count
+    {
+        get
+        {
+            int size = 0;
+            Cell cCell = first;
+            while (cCell != null)
+            {
+                cCell = cCell.Next;
+                size++;
+            }
+            return size;
+        }
+    }
+
+    public bool isReadonly = false;
+    public bool IsReadOnly
+    {
+        get { return isReadonly; }
+        set { isReadonly = value; }
+    }
+
+    public IEnumerator<T> GetEnumerator()
+    {
+        Cell cCell = first;
+        while (cCell != null)
+        {
+            yield return cCell.Data;
+            cCell = cCell.Next;
+        }
+    }
+
+    IEnumerator IEnumerable.GetEnumerator()
+    {
+            return this.GetEnumerator(); // call the generic version of the method
+    }
+
+    /* We are done realizing the ICollection class. */
+}

source/code/projects/CList_ICollection/CList_ICollection/Program.cs

@@ -0,0 +1,59 @@
+using System;
+
+class Program
+{
+  static void Main(string[] args)
+  {
+    /* Simple example. */
+    CList<int> myList1 = new CList<int>();
+    Console.WriteLine(myList1);
+    myList1.Add(1);
+    myList1.Add(5);
+    myList1.Add(2);
+    myList1.Add(2);
+    myList1.Add(1);
+    myList1.Add(1);
+    myList1.Add(3);
+    myList1.Add(4);
+    myList1.Add(5);
+    myList1.Add(5);
+    myList1.Add(5);
+    myList1.Add(2);
+    myList1.Add(2);
+    Console.WriteLine(myList1);
+
+        // A benefit of realizing the ICollection interface
+        // is that we can iterate over elements of lists now:
+        foreach (var item in myList1)
+        {
+            Console.WriteLine(item);
+        }
+
+        Console.WriteLine("Our list is read-only:" + myList1.IsReadOnly + ".");
+        myList1.IsReadOnly = true;
+        Console.WriteLine("Our list is read-only:" + myList1.IsReadOnly + ".");
+        try
+        {
+            myList1.Add(12);
+        }
+        catch(Exception ex) { Console.WriteLine(ex.Message); }
+        try
+        {
+            myList1.Remove(1);
+        }
+        catch (Exception ex) { Console.WriteLine(ex.Message); }
+
+        int[] array = new int[15];
+        try
+        {
+            myList1.CopyTo(array, 6);
+        } catch(Exception ex) { Console.WriteLine(ex.Message); }
+
+        array[0] = -10;
+        myList1.CopyTo(array, 1);
+        Console.WriteLine("The array contains:");
+        foreach (int i in array){ Console.Write(i + " "); }
+
+    }
+
+}

source/lectures/data/CList_as_ICollection.md

@@ -5,16 +5,16 @@ tags:
 
 # List as ICollection
 
-Another way of implementing lists is to make our class realize the [ICollection abstract class](https://learn.microsoft.com/en-us/dotnet/api/system.collections.generic.icollection-1?view=net-9.0):
+Another way of implementing lists is to make our class realize the [ICollection interface](https://learn.microsoft.com/en-us/dotnet/api/system.collections.generic.icollection-1?view=net-9.0):
 
 
 !include diag/cla/ICollection.md
 
 This requires implementing a series of properties and methods:
 
 
-```{download="./code/projects/CList_Icollection.zip"}
-!include`snippetStart="/* Done with Cell.*/", snippetEnd="/* We are done realizing the ICollection class. */"` code/projects/CList_Icollection/CList_Icollection.cs
+```{download="./code/projects/CList_ICollection.zip"}
+!include`snippetStart="/* Done with Cell.*/", snippetEnd="/* We are done realizing the ICollection class. */"` code/projects/CList_ICollection/CList_ICollection/CList.cs
 ```