-------------------------
  Value Types
-------------------------

--- bool b = true; ---
b: Type: Boolean
value: True
size: 1

--- int i = 42 ---
i: Type: Int32
value: 42
size: 4

--- char c = 'z' ---
c: Type: Char
value: z
size: 2

--- double d = 3.1415927; ---
d: Type: Double
value: 3.1415927
size: 8

--- decimal dc = 100_000_000.00m; ---
dec: Type: Decimal
value: 100000000.00
size: 16

  --- int[]array = { 1, 2, 3, 2, 1} ---
array: Type: Int32[]
value: System.Int32[]
size: 8
{ 1, 2, 3, 2, 1 }

--- (int, double, char)tup = (42, 3.14159, 'z'); ---
tup: Type: ValueTuple`3
value: (42, 3.14159, z)
size: 16

--- S s = new S(42, 3.1415927); ---
s: Type: S
value: CSharpData.Program+S
size: 16
S { 42, 3.1415927 }

  --- object o = new object(); ---
o: Type: Object
value: System.Object
size: 8

--- string str = "a string" ---
str: Type: String
value: a string
size: 8

--- dynamic dyn = 42; ---
dyn: Type: Int32
value: 42
size: 4
dyn: Type: Double
value: 3.1415927
size: 8

--- X x = new X(42, 3.1415927); ---
x: Type: X
value: CSharpData.Program+X
size: 8
X { 42, 3.1415927 }

        

  /*-- List<int> li = new List<intgt; { 1, 2, 3, 2, 1 }; --*/
li: Type: List`1
value: System.Collections.Generic.List`1[System.Int32]
size: 8
/*-- li.Insert(5, 0) --*/
List<int> { 1, 2, 3, 2, 1, 0 }

/*-- Dict dict = new Dict(); --*/
dict: Type: Dictionary`2
value: System.Collections.Generic.Dictionary`2[ ...
size: 8
dict: { [three, 3], [zero, 0], [one, 1], [two, 2] }


        

  -----------------------------------
Demonstrate Copy Operations
-----------------------------------

--- int i = 42; ---
i: address: 0xb2f397e958
--- int j = i; // copy of value ---
j: address: 0xb2f397e948
--------------------------------------------------
Addresses of i and j are unique, demonstrating
value of i was copied to new j location.
--------------------------------------------------

--- List<int> li = new List<int> { 1, 2, 3, 2, 1 } ---
li: address: 0xb2f397e938
--- List<int> lj = li  // copy of reference ---
lj: address: 0xb2f397e928
-------------------------------------------------------
Addresses of li and lj are adjacent, and adjacent to
addresses of i and j in the stack frame.

That demonstrates that lj is a copy of the handle li
both of which point to the managed heap-based list
instance.
-------------------------------------------------------

--- lj.Add(-1) ---
lj: { 1, 2, 3, 2, 1, -1 }
li: { 1, 2, 3, 2, 1, -1 }
-------------------------------------------------------
Note: changing lj results in the same change to li.
This demonstrates that both variables refer to the
same List<int> instance in the managed heap.
-------------------------------------------------------

Using ReferenceEquals(li, lj) we find:

li is same object as lj
        

  class Anal {

/*--------------------------------------------- 
  display the type of t using reflection 
---------------------------------------------*/
public static void ShowType<T>(
  T t, String nm, String suffix = ""
)
{
  #pragma warning disable CS8602 // possible null ref
  Type tt = t.GetType();
  Console.WriteLine("{0}: Type: {1}", nm, tt.Name);
  int size = Anal.GetManagedSize(tt);
  Console.WriteLine(
    "value: {0}\nsize: {1}{2}", t, size, suffix
  );
  #pragma warning restore CS8602
}
/*---------------------------------------------
  return a string with type information 
---------------------------------------------*/
public static string GetTypeString<T>(
  T t, String nm, String suffix = ""
) {
  #pragma warning disable CS8602 // possible null ref
  Type tt = t.GetType();
  string typeInfo = 
    String.Format("{0}: Type: {1}\n", nm, tt.Name);
  int size = Anal.GetManagedSize(tt);
  string instanceInfo = 
    String.Format(
      "value: {0}\nsize: {1}{2}", t, size, suffix
    );
  return typeInfo + instanceInfo;
  #pragma warning restore CS8602
}
/*--------------------------------------------- 
  do t1 and t2 refer to same object? 
---------------------------------------------*/
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
  );
  }
}
/*---------------------------------------------
  - GetMangedSize(Type type) is function that
    returns size of value types and handles.
  - It uses advanced techniques that will 
    eventually be covered elsewhere in this
    site. Knowing how it works is not essential 
    for things we are examining in this demo.
  - uses advanced relection
---------------------------------------------*/
// https://stackoverflow.com/questions/8173239/...
public static int GetManagedSize(Type type)
{
  var method = new DynamicMethod(
    "GetManagedSizeImpl", 
    typeof(uint), new Type[0],
    typeof(TypeExtensions), false
  );

  ILGenerator gen = method.GetILGenerator();
  gen.Emit(OpCodes.Sizeof, type);
  gen.Emit(OpCodes.Ret);

  var func = 
    (Func<uint>)method.CreateDelegate(
      typeof(Func<uint>)
    );
  return checked((int)func());
}
/*--------------------------------------------- 
  return string rep of argument's address 
---------------------------------------------*/
#pragma warning disable 8500
/*
  Suppress warning about taking address of 
  managed type. Pointer is used only to show 
  address of ptr as part of analysis of copy 
  operations.
*/
public static unsafe string 
  ToStringAddress<T>(T* ptr) {
  if(ptr == null) {
    return "";
  }
  IntPtr addr = (IntPtr)ptr;
  string addrstr = 
    string.Format(
      "address: 0x" + addr.ToString("x")
    );
  return addrstr;
}
#pragma warning restore 8500
}
class Display
{
/*---------------------------------------------
  show string description of operation 
---------------------------------------------*/
public static void ShowOp(
  String op, String suffix = ""
) {
  Console.WriteLine(
    "--- {0} ---{1}", op, suffix
  );
}
/*--------------------------------------------- 
  Display all elements of object's tree
  - uses advanced reflection
---------------------------------------------*/
// https://stackoverflow.com/questions/7613782/...
public static void Iterate<T>(T t) {
  Console.WriteLine("fields:");
  foreach(
    var field in typeof(T).GetFields(
      BindingFlags.Instance | 
      BindingFlags.NonPublic | 
      BindingFlags.Public
    )
  ) {
    Console.WriteLine(
      "{0} = {1}", field.Name, field.GetValue(t)
    );
  }
  Console.WriteLine("methods:");
  foreach(
    var method in typeof(T).GetMethods(
      BindingFlags.Instance | BindingFlags.Public
    )
  ) {
    Console.WriteLine(
      "{0}", method.Name
    );
  }
}
/*---------------------------------------------
  shorthand for console write command 
----------------------------------------------*/
public static void Print(String s = "") {
  Console.WriteLine(s);
}
/*---------------------------------------------
  Show text wrapped in horizontal lines
---------------------------------------------*/
public static void ShowNote(
  string s, string suffix = "", int length = 35
) {
  string line = new string('-', length);
  Console.WriteLine(line);
  Console.WriteLine("  {0}", s);
  Console.WriteLine(line + suffix);
}
/*---------------------------------------------
  Build string rep of array of type T
---------------------------------------------*/
public static string ToStringRepArray<T>(T[] arr) {
  StringBuilder sb = new StringBuilder();
  sb.Append("{ ");
  bool first = true;
  foreach(T item in arr) {
    if(item == null) {
      break;
    }
    if(first) {
      sb.Append(item.ToString());
      first = false;
    }
    else {
      sb.AppendFormat(", {0}", item);
    }
  }
  sb.Append(" }\n");
  return sb.ToString();
}
/*---------------------------------------------
  Build string rep of IEnumerable collection
  T<U>. Works for array too.
---------------------------------------------*/
public static string 
  ToStringRepIEnumerable<T,U>(T enu)
  where T:IEnumerable<U>
{
  StringBuilder sb = new StringBuilder();
  sb.Append("{ ");
  bool first = true;
  foreach(U item in enu) {
    if(item == null) {
      break;
    }
    if(first) {
      sb.Append(item.ToString());
      first = false;
    }
    else {
      sb.AppendFormat(", {0}", item);
    }
  }
  sb.Append(" }\n");
  return sb.ToString();
}
}
/*-----------------------------------------------------
Direct implementation of enumerating associative
collection.  This can also be done with 
ToStringRepIEnumerable<Dict,KVPair>(dict).
-----------------------------------------------------*/
public static string 
ToStringRepAssocCont<Dict,Key,Value>(Dict assoc)
where Dict:IDictionary<Key,Value>
{
StringBuilder sb = new StringBuilder();
sb.Append("{ ");
bool first = true;
foreach(var item in assoc) {
  if(first) {
    var sf = String.Format(
      "{{ {0}, {1} }}", item.Key, item.Value
    );
    sb.Append(sf);
    first = false;
  }
  else {
    sb.AppendFormat(
      ", {{ {0}, {1} }}", item.Key, item.Value
    );
  }
}
sb.Append(" }\n");
return sb.ToString();
}
}