.NET

Not only does .NET enforce runtime type safety, but it is actually possible to create new generic types at runtime! Please take a look at the following program:

  1. using System;
  2. using System.Runtime;
  3. using System.Reflection;
  4. using System.Collections;
  6. namespace console
  7. {
  8.     class Program
  9.     {
  10.         static void printLen(IList list) {
  11.             Console.Out.WriteLine(list.Count);
  12.         }
  14.         static IList newGenericListFor(String className) {
  15.             // We can get the Class based on a string value -- a useful feature
  16.             // for some meta programming.
  17.             var clazz = TypeInfo.GetType(className);
  19.             // Build a new list constructor using the class information.
  20.             var listCtor = typeof(List<>).MakeGenericType(clazz);
  22.             // Construct a new List<clazz> like we did before, only this time
  23.             // using reflection at runtime.
  24.             //
  25.             // Please note the result is cast to a List. This is to ensure
  26.             // the standard List methods such as Add, and fields such as Count,
  27.             // are accessible via the ints variable.
  28.             return (IList) Activator.CreateInstance(listCtor);
  29.         }
  31.         static void Main(string[] args) {
  33.             // Create a List<Int32>.
  34.             var ints = newGenericListFor("System.Int32");
  36.             // Add some numbers to the list.
  37.             ints.Add(1);
  38.             ints.Add(2);
  39.             ints.Add(3);
  41.             if (args.Length > 0 && args[0] == "fail") {
  42.                 // If this program is executed with a single argument "fail",
  43.                 // then we try to add "Hello" to the ints list.
  44.                 //
  45.                 // This will compile because ints is not known to the compiler
  46.                 // yet as a List<Int32>, even though that is what it is.
  47.                 //
  48.                 // At runtime,however, this will fail because you cannot add a
  49.                 // String to a List<Int32>.
  50.                 ints.Add("Hello");
  51.             }
  53.             // Create a List<String>.
  54.             var strs = newGenericListFor("System.String");
  56.             // Add some strings to the list.
  57.             strs.Add("Hello");
  58.             strs.Add("world");
  60.             printLen(ints);
  61.             printLen(strs);
  62.         }
  63.     }
  64. }

The code comments in the above program demonstrate that .NET does in fact allow runtime instantiation from generic types, and maintains their runtime type safety, even if this does not exist at compile time due to the meta programming involved.

To run the above program, please follow these instructions:

  1. Launch the container:

    1.  docker run -it --rm --cap-add=SYS_PTRACE --security-opt seccomp=unconfined go-generics-the-hard-way

    Please note the --cap-add=SYS_PTRACE --security-opt seccomp=unconfined flags are required in order to use the lldb debugger to attach to a .NET process.

  2. Compile the above program:

    1.  dotnet build --debug -p:UseSharedCompilation=false -o ./05-internals/03-runtime-instantiation/dotnet/bin ./05-internals/03-runtime-instantiation/dotnet

  3. Run the program normally:

    1.  ./05-internals/03-runtime-instantiation/dotnet/bin/dotnet
    1.  3
    2.  2

  4. Run the program again forcing a runtime type check error:

    1.  ./05-internals/03-runtime-instantiation/dotnet/bin/dotnet fail
    1.  Unhandled exception. System.ArgumentException: The value "Hello" is not of type "System.Int32" and cannot be used in this generic collection. (Parameter 'value')
    2.     at System.Collections.Generic.List`1.System.Collections.IList.Add(Object item)
    3.     at console.Program.Main(String[] args) in /go-generics-the-hard-way/05-internals/03-runtime-instantiation/dotnet/main.cs:line 66
    4.  Aborted

  5. Type exit to stop and remove the container.

.NET clearly knows what it is doing when it comes to generics and runtime instantiation. Does Go keep up?

Next: Golang