unmanaged, notnull, new() (C# 6 öykünmesi)

using System;

// Works only for reference types
public static class RefBox
{
  public static string Show<T>(T value) where T : class
  {
    return value == null ? "null ref" : "ref: " + value.ToString();
  }
}

// Works only for value types
public static class ValBox
{
  public static string Show<T>(T value) where T : struct
  {
    return "value: " + value.ToString();
  }
}

public class Program
{
  public static void Main(string[] args)
  {
    string s = "hello";
    int n = 42;

    Console.WriteLine(RefBox.Show<string>(s)); // OK
    Console.WriteLine(ValBox.Show<int>(n));    // OK

    // Console.WriteLine(RefBox.Show<int>(n)); // compile-time error (int is struct)
    // Console.WriteLine(ValBox.Show<string>(s)); // compile-time error (string is class)
  }
}

using System;

// Requires public parameterless ctor on T
public static class Factory
{
  public static T Create<T>() where T : new()
  {
    return new T(); // safe in C# 6 with new()
  }
}

public sealed class Sample
{
  public string Name { get; set; }
  public Sample() { Name = "default"; }
}

public class Program
{
  public static void Main(string[] args)
  {
    Sample x = Factory.Create<Sample>();
    Console.WriteLine("Created: " + x.Name);
  }
}

using System;

// C# 6 has no notnull constraint. Use where T : class and guard at runtime.
public static class NotNullApi
{
  public static int LengthOf<T>(T x) where T : class
  {
    if (x == null) throw new ArgumentNullException("x");
    return x.ToString().Length; // placeholder usage
  }
}

public class Program
{
  public static void Main(string[] args)
  {
    Console.WriteLine(NotNullApi.LengthOf<string>("hi")); // 2
    try
    {
      Console.WriteLine(NotNullApi.LengthOf<string>(null)); // throws
    }
    catch (Exception ex)
    {
      Console.WriteLine("Guard fired: " + ex.GetType().Name);
    }
  }
}

using System;

// No unmanaged constraint in C# 6.
// Use struct for value types and restrict API usage (document numeric-only intent).
public static class NumericOps
{
  public static T Max<T>(T a, T b) where T : struct, IComparable
  {
    // Works for numeric primitives because they implement IComparable
    return (a.CompareTo(b) >= 0) ? a : b;
  }
}

public class Program
{
  public static void Main(string[] args)
  {
    Console.WriteLine(NumericOps.Max<int>(3, 9));     // 9
    Console.WriteLine(NumericOps.Max<double>(2.5, 2)); // 2.5
  }
}