Bits: Generic C#

static void Demonstrate_Std_Library_Types() {

  Display.ShowNote("Demonstrate std library generic types", nl);

  Display.ShowOp("String[] array processed by generic function");
  String[] array = {"one", "two", "three"};
  Display.ShowTypeEnum(array, "array", 5, nl);

  Display.ShowOp("List<double>");
  List<double> aList =
  new List<double>{ 1.0, 1.5, 2.0, 2.5, 3.0, 3.5, 4.0 };
  Display.ShowTypeEnum(aList, "aList", 5, nl);

  Display.ShowOp("Dictionary<int, String>");
  var d1 = new Dictionary<int, String>
  {
    { 0, "zero"}, {1, "one"}, {2, "two"}
  };
  Display.ShowTypeEnum(d1, "d1", 5, nl);

}

public class Hello<T> where T:new() {
  public Hello() {
    datum = new T();
  }
  public Hello(T t) {
    datum = t;
  }
  public void show(String nm) {
    Console.Write("  {0}: {{ {1} }}\n", nm, datum);
  }
  public T datum { get; set; }  // property
}

Display.ShowOp("Hello<int>");
Hello<int> hi = new Hello<int>(42);
Display.ShowType(hi, "hi");
Console.WriteLine("value:");
hi.show("h");
Display.ShowOp("Hello<double>");
Hello<double> hd = new Hello<double>(3.1415927);
Console.WriteLine("access hd.datum: {0}", hd.datum);
hd.show("hd");
Console.WriteLine();

/*-------------------------------------------------------------------
  Stats.cs
  - provides definitions for user-defined class Stats<T>
*/

using System.Collections;
using System.Collections.Generic;   // IEnumerable<T>, List<T>, ...
using System.Numerics;              // INumber<T>
using Analysis;

namespace Stats {
  /*----------------------------------------------------------------------
    Stats<T> is a generic demo type
     - holds any finite number of generic values
     - computes several statistics on its values
  */
  public class Stats<T>
    where T: INumber<T>
  {
    /*--------------------------------------------------------------------
      Constructs a point with N coordinates each with default value
    */
    public List<T> items { get; set; }
    public Stats(List<T> l) {
      items = l;
    }
    public void check() {
      if (items == null) {
        throw new SystemException("stats is null");
      }
      else if (items.Count < 1)
        throw new SystemException("stats is empty");
    }
    public int size() {
      check();
      return items.Count;
    }
    public T max() {
      check();
      T max = items[0];
      foreach(T item in items) {
        if(max.CompareTo(item) < 0)
          max = item;
      }
      return max;
    }
    public T min() {
      check();
      T min = items[0];
      foreach(T item in items) {
        if(min.CompareTo(item) > 0)
          min = item;
      }
      return min;
    }
    public T? sum() {
      check();
      dynamic? sum = default(T);
      if(sum != null) {
        foreach(T item in items) {
          sum += item;
        }
        return sum;
      }
      return default(T);
    }
    public double avg() {
      check();
      dynamic? sum = this.sum();
      return Convert.ToDouble(sum)/Convert.ToDouble(items.Count);
    }
  }
}

Display.ShowOp("Stats<int>");
List<int> tmp1 = new List<int> { 1, 2, 3, 2, 1 };
Stats<int> si = new Stats<int>(tmp1);
ShowList(tmp1);
Console.WriteLine("  max: {0}", si.max());
Console.WriteLine("  min: {0}", si.min());
Console.WriteLine("  sum: {0}", si.sum());
Console.WriteLine("  avg: {0:0.00}", si.avg());
Console.WriteLine();

Display.ShowOp("Stats<double>");
List<double> tmp2 = new List<double> { 1.0, 1.5, 2.0, 1.5, 1.0 };
Stats<double> sd = new Stats<double>(tmp2);
ShowList(tmp2);
Console.WriteLine("  max: {0:0.0}", sd.max());
Console.WriteLine("  min: {0:0.0}", sd.min());
Console.WriteLine("  sum: {0:0.0}", sd.sum());
Console.WriteLine("  avg: {0:0.00}", sd.avg());
Console.WriteLine();

/*-------------------------------------------------------------------
  Points.cs
  - provides definitions for user-defined class Point<T>
*/

using System.Collections;
using System.Collections.Generic;   // IEnumerable<T>, List<T>
using Analysis;

namespace Points {
  /*----------------------------------------------------------------------
    Point<T> represents a point in N-dimensional space
     - C# generics do not accept integers as generic parameters
       so we cannot declare P<T,N> where N is an integer like
       we did for C++ and Rust
     - Point holds any finite number of generic coordinates
     - coordinates are held in a List<T>
     - implements IEnumerable<T> so it can be indexed and iterated
     - it is a reference type because it is implemented with a class.
       its List<T> is also a reference type
  */
  public class Point<T> : IEnumerable<T>, Analysis.IShow
  {
    /*--------------------------------------------------------------------
      Constructs an empty point
    */
    public Point() {
      coor = new List<T>();
    }
    /*--------------------------------------------------------------------
      Constructs a point with N coordinates each with default value
    */
    public Point(int N) {
      coor = new List<T>();
      for(int i = 0; i<N; ++i) {
        T? test = default(T);
        if(test != null) {
          coor.Add(test);
        }
      }
    }
    /* translates IShow::show() for needs of Point class */
    public void Show(string name, int _width = 5, int _left = 2) {
      int SaveWidth = Width;
      int SaveLeft = Left;
      Width = _width;
      Left = _left;
      PrintSelf(name);
      Width = SaveWidth;
      Left = SaveLeft;
    }
    /*
      Displays structure and state of N-dimensional point.
      - state is a set of rows of coordinate data
      - property Width specifies number of elements in each row
      - property Left specifies offset of row from terminal Left edge
    */
    public void PrintSelf(string name) {
      Console.Write(Display.Indent(Left));
      Console.Write("{0} {{\n{1}", name, Display.Indent(Left + 2));
      for(int i=0; i<coor.Count; ++i) {
        Console.Write("{0}", coor[i]);
        if(i < coor.Count - 1) {
          Display.print(", ");
        }
        if((i+1) % Width == 0 && i != coor.Count - 1) {
          Console.Write("\n");
          Console.Write(Display.Indent(Left + Indent));
        }
      }
      Console.Write("\n{0}", Display.Indent(Left));
      Console.WriteLine("}");
      String callname = "  " + dt;
      Console.WriteLine(callname);
    }
    /* The three functions below support indexing and iterating */
    public T this[int index] {
      get { return coor[index]; }
      set { coor.Insert(index, value); }
    }
    public IEnumerator<T> GetEnumerator() {
      return coor.GetEnumerator();
    }
    IEnumerator IEnumerable.GetEnumerator() {
      return this.GetEnumerator();
    }
    /* supports inializer list */
    public void Add(T t) {
      coor.Add(t);
    }
    public void AddRange(IEnumerable<T> list) {
      coor.AddRange(list);
    }
    public List<T> coor { get; set; }
    public DateTime dt { get; set; } = DateTime.Now;
    public int Length { get { return coor.Count; } }
    public int Width { get; set; } = 5;   // default row size
    public int Left { get; set; } = 2;    // default offset
    public int Indent { get; set; } = 2;
    /* initializers */
    public Point<T> width(int w) {
      this.Width = w;
      return this;
    }
    public Point<T> left(int l) {
      this.Left = l;
      return this;
    }
    public Point<T> indent(int i) {
      this.Indent = i;
      return this;
    }
  }
}

Display.ShowOp("Point<double>");

Point<double> p = new Point<double>(5);
List<double> tmp = new List<double>{ 1.0, 2.5, 3.0, -2.5, 1.0 };
p.coor = tmp;
Display.ShowTypeEnum(p, "p");
Display.ShowOp("use indexing to retrieve and modify coordinates");
Console.WriteLine("  value of p[1] is {0}", p[1]);
p[1] = -2.5;
Display.ShowOp("using p.show(callName)");
p.Show("p");
Console.WriteLine();

/* uses default constructor with initializer list */
Display.ShowOp("new Point<int> { 1, 2, 3, 4, 5}");
Point<int> pi = new Point<int> { 1, 2, 3, 4, 5 };
pi.Show("pi");
List<int> rng = new List<int> {4,3,2,1};
Display.ShowOp("pi.AddRange(rng)");
pi.AddRange(rng);
int[] arr = { 0, -1, -2 };
pi.AddRange(arr);
pi.width(6);
pi.Show("pi");
Console.WriteLine();

/*-------------------------------------------------------------------
  Analysis.cs
  - provides several type analysis and display methods in the
    class Display
*/
using System;
using System.Collections;
using System.Collections.Generic;     // IEnumerable<T>, List<T>
using System.Linq;                    // IEnumerable<T>.ToArray
using System.Text;                    // StringBuilder
using System.Reflection;
using System.Reflection.Emit;         // managed size
using System.Runtime.InteropServices; // GCHandle

namespace Analysis {
  /*----------------------------------------------------------
    IShow interface allows analysis functions to operate on
    instances of any class that implements it.
    - See ShowTypeShowable<T>(T t, ...), below.
  */
  public interface IShow {
    void Show(string name, int Width = 5, int Left = 2);   // show instance state as rows of elements
    int Length { get; }       // total number of elements
    int Width { get; set; }   // number of elements per row
    int Left { get; set; }    // offset from terminal Left
    int Indent {get; set; }   // element indent from braces
  }
  /*-----------------------------------------------------------------------
    Collection of static functions that present information about types
    and data values on the terminal line.
  */
  public class Display {
    public static String Spaces(int i) {
      return new String(' ', i);
    }
    public static bool IsAssociativeColl(IEnumerable coll) {
      return coll is IDictionary;
    }
    /*-------------------------------------------------
      Show static type with some formatting adjustments
      and name at callsite.
    */
    public static void ShowType<T>(T t, string nm) {
      Type tt = t!.GetType();
      string tnm = tt.Name;
      if(tt.IsGenericType) {
        if(tnm.Length > 1) {
          tnm = tnm.Remove(tnm.Length - 2) + "<T>";
        }
      }
      Console.Write("{0}: {1}, ", nm, tnm);
      int size = GetManagedSize(tt);
      Console.Write("size: {0}, ", size);
      if (tt.IsValueType) {
        Console.WriteLine("value type");
      }
      else {
        Console.WriteLine("reference type");
      }
    }
    /*-------------------------------------------------
      Display information about the type of any scalar type.
      - scalar types are those with a single value like:
          int, double, string, ...
      - This function directly uses only simple reflection
    */
    public static void ShowTypeScalar<T>(
      T t, string nm, string suffix = ""
    )
    {
      ShowType(t, nm);
      Console.WriteLine("value: \"{0}\"{1}", t, suffix);
    }
    /*-------------------------------------------------
      Show type information for any type that implements
      IEnumerable<T> interface.
    */
    public static void ShowTypeEnum<T> (
    IEnumerable<T> t, string nm, int w = 5, string suffix = ""
    )
    {
      Type tt = t!.GetType();
      string tnm = tt.Name;
      if(tt.IsGenericType) {
        if(tnm.Length > 1) {
          tnm = tnm.Remove(tnm.Length - 2);
          if(IsAssociativeColl(t)) {
            tnm += "<K,V>";
          }
          else {
            tnm += "<T>";
          }
        }
      }
      Console.Write("{0}: {1}, ", nm, tnm);
      int size = GetManagedSize(tt);
      Console.Write("size: {0}, ", size);
      if (tt.IsValueType) {
        Console.WriteLine("value type");
      }
      else {
        Console.WriteLine("reference type");
      }
      Console.WriteLine("value:\n{0}{1} {{", "  ", nm);
      /*
        beautify value list into rows of w elements
        indented by 4 spaces
      */
      string tmp = FoldArray(t.ToArray(), w, 4);
      Console.Write(tmp);
      Console.WriteLine("\n  }");
      Console.Write(suffix);
    }
    /*-------------------------------------------------
      Show type information for any type that implements
      the IShow interface
    */
    public static void ShowTypeShowable<T>(
      T t, string nm, string suffix=""
    )
    where T:IShow
    {
      ShowType(t, nm);
      Console.WriteLine("value:");
      t.Show(nm);     // guaranteed by IShow implementation
      Console.Write(suffix);
    }
    /*-------------------------------------------------
      Provides name of caller, nm, as label for IShow() information.
      - works for all Showable instances
    */
    public static void ShowLabeledObject<T>(
      T t, string nm
    ) where T:IShow {
      // Console.Write(nm);
      t.Show(nm);
    }
    /*-------------------------------------------------
      Provides name of caller, nm, as label for value.
      - works for all T with ToString.
    */
    public static void DisplayLabeledObject<T>(T t, string nm) {
      Console.WriteLine("{0}: {1}", nm, t!.ToString());
    }
    /*-------------------------------------------------
      create string of count spaces, used to offset output
    */
    public static string Indent(int count) {
      StringBuilder sb = new StringBuilder();
      sb.Append(' ', count);
      return sb.ToString();
    }
    /*-------------------------------------------------
      Truncate string to length of N, but only if
      its length is greater than N
    */
    public static string truncate(int N, string bigStr) {
      if(bigStr.Length <= N) {
        return bigStr;
      }
      StringBuilder sb =  new StringBuilder();
      sb.Append(bigStr);
      sb.Length = N;  // move back pointer to desired length
      return sb.ToString();
    }
    /*-------------------------------------------------
      fold array elements into rows of w elements
    */
    public static string FoldArray<T>(T[] arr, int w, int Left) {
      StringBuilder tmp = new StringBuilder();
      tmp.Append(Indent(Left));
      for(int i=0; i< arr.Length; ++i) {
        tmp.Append(arr[i]!.ToString());
        tmp.Append(", ");
        if((i+1) % w == 0 && i != arr.Length - 1) {
          tmp.Append("\n");
          tmp.Append(Indent(Left));
        }
      }
      if(tmp.Length > 1) {
        tmp.Length -= 2;  // don't return last comma and space
      }
      return tmp.ToString();
    }
    /*-------------------------------------------------
      do t1 and t2 share the same address?
    */
    public static void IsSameObj<T>(
      T t1, String n1, T t2, String n2, string suffix = ""
    ) {
      if(ReferenceEquals(t1, t2)) {
        Console.WriteLine(
          "{0} is same object as {1}{2}", n1, n2, suffix
        );
    }
      else {
        Console.WriteLine(
        "{0} is not same object as {1}{2}", n1, n2, suffix);
      }
    }
    /*-------------------------------------------------
      Beware, two distinct objects may have same hashcode.
      - Not used in this demo for that reason.
    */
    public static void showIdent<T>(
      T t, String n, string suffix = ""
    ) {
      int id = t!.GetHashCode();
      Console.WriteLine("{0}, {1}{2}", n, id, suffix);
    }
    /*-------------------------------------------------
      Display function call or operation to help turn
      output data into information
    */
    public static void ShowOp(string op, string suffix = "") {
      Console.WriteLine("--- {0} ---{1}", op, suffix);
    }
    public static void print(String s = "") {
      Console.Write(s);
    }
    public static void println(String s = "") {
      Console.WriteLine(s);
    }
    public static void Println(String s) {
      Console.WriteLine(s);
    }
    /*-------------------------------------------------
      Emphasize text with borders
    */
    public static void ShowNote(string s, int n=60, string suffix = "") {
      string line = new string('-', n);
      Console.WriteLine(
        "--------------------------------------------------"
      );
      Console.WriteLine("{0}", s);
      Console.WriteLine(
        "--------------------------------------------------{0}",
        suffix
      );
    }
    /*-------------------------------------------------
      Surround note with empty lines
    */
    public static void ShowLabel(string s) {
      Console.WriteLine();
      ShowNote(s);
      Console.WriteLine();
    }
  }
}

/*-------------------------------------------------------------------
  Cs_Generic::Program.cs
  - demonstrates creating and using std library generic types:
      array, List<T>, Dictionary<K,V>
  - demonstrates creating and using user-defined generic types:
      Demo<T>, Stats<T>, and Point<T, N>
  - depends on PointsGeneric.cs to provide user-defined Point class
  - depends on Stats.cs to provide user-defined Stats class
  - depends on AnalysisGeneric.cs for several display and analysis
    functions
*/
using System;
using System.Collections;
using System.Collections.Generic;   // IEnumerable<T>, List<T>
using System.Linq;                  // IEnumerable<T>.ToArray
using System.Text;                  // StringBuilder
using Points;                       // defined in Points.cs
using Analysis;                     // defined in Analysis.cs
using Stats;                        // defined in Stats.cs
/*-----------------------------------------------
Note:
Find all Bits code, including this in
https://github.com/JimFawcett/Bits
You can clone the repo from this link.
-----------------------------------------------*/
namespace CSharpGenerics
{
  /* definition of Hello<T> code elided */

  /*-- Generic demonstration begins here --*/

  class Program
  {
    const string nl = "\n";

    static void ShowList<T>(List<T> lst) {
      /* code elided */
    }

    static void Demonstrate_Std_Library_Types() {
      /* code elided */
    }
    static void Demonstrate_User_defined_Types() {
      /* code elided */
    }
    static void Demostrate_generic_functions() {
      /* code elided */
    }
    static void Main(string[] args)
    {
      Display.ShowLabel(" Demonstrate C# generics");

      Demonstrate_Std_Library_Types();
      Demonstrate_User_defined_Types();
      Demostrate_generic_functions();

      Console.WriteLine("\nThat's all Folks!\n");
    }
  }
}