using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        var y = new List<int> {1, 2, 3};
        var z = y.ConvertAll(ConvertToString);
    }

    static string ConvertToString<T>(T x)
    {
        return x.ToString();
    }

    static string ConvertToString(Guid x)
    {
        return x.ToString("N");
    }
}

• We then examine each bound for Xi in turn: For each exact bound U of Xi all types Uj which are not identical to U are removed from the candidate set. For each lower bound U of Xi all types Uj to which there is not an implicit conversion from U are removed from the candidate set. For each upper bound U of Xi all types Uj from which there is not an implicit conversion to U are removed from the candidate set.

var dict = new Dictionary<,> {
    { 1, "abc" },
    { 2, "def" }
};

П>>

П>>var dict = new Dictionary<,> {
П>>    { 1, "abc" },
П>>    { 2, "def" }
П>>};
П>>

Другое дело в том, насколько это будет непонятно

let foo =
    let d = new Dictionary<_,_>()
    d.Add(1, "abc")
    d.Add(2, "def")
    d

П>let foo =
П>    let d = new Dictionary<_,_>()
П>    d.Add(1, "abc")
П>    d.Add(2, "def")
П>    d
П>

П>Мне всё же кажется, что это неспроста

using System.Collections.Generic;
using System.Console;

module Program
{
  Main() : void
  {
    def d = Dictionary();

    d.Add(1, "abc");
    d.Add(2, "def");

    foreach (x in d)
      WriteLine($"$(x.Key)=$(x.Value)");
  }
}

class Foo
{
  public this(a : int) { }
}

class Foo[T]
{
  public this(a : T) { }
}

module Program
{
  Main() : void
  {
    def x = Foo(5);
  }
}

    def x = Foo(5) : Foo[int];

П>class Foo
П>{
П>  public this(a : int) { }
П>}

П>class Foo[T]
П>{
П>  public this(a : T) { }
П>}

П>module Program
П>{
П>  Main() : void
П>  {
П>    def x = Foo(5);
П>  }
П>}
П>

def x = Foo.[int](5);

def x = Foo.[_](5);

using System;

class Program
{
  static void Method<T>(Func<T> action) { }

  static int Foo() { return 1; }

  static void Main()
  {
    Method(Foo);
    // Error: The type arguments for method 'Program.Method<T>(System.Func<T>)'
    // cannot be inferred from the usage. Try specifying the type arguments explicitly.

    Method<int>(Foo); // ok
    Method(() => 1); //ok
  }
}

module Program
{
  Main() : void
  {
    def x = A(1);
    x.Foo();
  }
}

class A
{
    public this(_ : long) { }
}

class A[T]
{
    public this(_ : T) { }
    public Foo() : void { }
}

    def x = A.[int](1);
    x.Foo();

N>module Program
N>{
N>  Main() : void
N>  {
N>    def x = A(1);
N>    x.Foo();
N>  }
N>}

N>class A
N>{
N>    public this(_ : long) { }
N>}

N>class A[T]
N>{
N>    public this(_ : T) { }
N>    public Foo() : void { }
N>}
N>

module Program
{
  Main() : void
  {
    def x = A(1);
    x.Foo();
  }
}

class A
{
    public this(_ : long?) { } // Поменяли 'long' на 'long?'
}

class A[T]
{
    public this(_ : T) { }
    public Foo() : void { }
}

N>module Program
N>{
N>  Main() : void
N>  {
N>    def x = A(1);
N>    x.Foo();
N>  }
N>}

N>class A
N>{
N>    public this(_ : long?) { } // Поменяли 'long' на 'long?'
N>}

N>class A[T]
N>{
N>    public this(_ : T) { }
N>    public Foo() : void { }
N>}
N>

Error: in argument #1 (_N_wildcard_2658), needed a System.Nullable[long], got int: System.Int32 is not a subtype of System.Nullable.[T] [simple require]

Main.n(10,5):Error: there is no member named 'Foo' in A with type ?
Main.n(10,5):Error: unbound name 'Foo' in 'x'

class Foo
{
    virual Foo(){}
}
class Bar: Foo
{
    override Bar(): Base(){}
}
metaclass FooClass: Foo;
FooClass fc = Foo;
Foo Instance = new fc(); // создали экзэмпляр Foo
fc = Bar;
Instance = new fc(); // создали экзэмпляр Bar

public void Consumer(FooFactory f)
{
  var foo = f();
}

IFooFactory
{
  Foo NewFoo(); // default constructor
  Foo NewFoo(SerializationInfo info, StreamingContext context); // serialization constructore
  Foo NewFoo(int a, int b); // constructor+initializer
}

М>Просто мне непонятно это стремление засунуть функциональщину куда надо и не надо. Функциональный подход, без сомнения, имеет свои сильные стороны, но господа, надо-же и меру знать

М>Да нет, я просто не понимаю, что не так с кэшированием Ваш Customer ожидает фабричный делегат?

public class Foo
{
  public static virtual int ClassId{ get {return 1;}}
}
public class Bar: Foo
{
  public static override int ClassId{ get {return 2;}}
}