Perché il compilatore C # non genera errori nel codice in cui un metodo statico chiama un metodo di istanza?

Il seguente codice ha un metodo statico, Foo(), chiamando un metodo di istanza, Bar():

public sealed class Example
{
    int count;

    public static void Foo( dynamic x )
    {
        Bar(x);
    }

    void Bar( dynamic x )
    {
        count++;
    }
}

Si compila senza errori * ma genera un'eccezione del binder di runtime in fase di runtime. La rimozione del parametro dinamico a questi metodi causa un errore del compilatore, come previsto.

Allora perché avere un parametro dinamico consente di compilare il codice? Anche ReSharper non lo mostra come un errore.

Modifica 1: * in Visual Studio 2008

Modifica 2: aggiunta sealedpoiché è possibile che una sottoclasse possa contenere un Bar(...)metodo statico . Anche la versione sigillata viene compilata quando non è possibile che un metodo diverso dal metodo dell'istanza possa essere chiamato in fase di esecuzione.

AGGIORNAMENTO: la risposta seguente è stata scritta nel 2012, prima dell'introduzione di C # 7.3 (maggio 2018) . In Novità di C # 7.3 , la sezione Candidati all'overload migliorati , elemento 1, viene spiegato come sono cambiate le regole di risoluzione dell'overload in modo che gli overload non statici vengano scartati in anticipo. Quindi la risposta di seguito (e l'intera domanda) ha per lo più solo interesse storico ormai!

(Pre C # 7.3 :)

Per qualche ragione, la risoluzione dell'overload trova sempre la migliore corrispondenza prima di controllare statico e non statico. Prova questo codice con tutti i tipi statici:

class SillyStuff
{
  static void SameName(object o) { }
  void SameName(string s) { }

  public static void Test()
  {
    SameName("Hi mom");
  }
}

Questo non verrà compilato perché il miglior sovraccarico è quello che prende un file string. Ma hey, questo è un metodo di istanza, quindi il compilatore si lamenta (invece di prendere il secondo miglior sovraccarico).

Aggiunta: quindi penso che la spiegazione dynamicdell'esempio della domanda originale sia che, per essere coerenti, quando i tipi sono dinamici troviamo prima anche il miglior sovraccarico (controllando solo il numero di parametro e i tipi di parametro ecc., Non statico vs. non -static), e solo allora verifica la presenza di static. Ma ciò significa che il controllo statico deve attendere fino al runtime. Da qui il comportamento osservato.

Aggiunta tardiva: alcune informazioni sul motivo per cui hanno scelto di fare le cose con questo divertente ordine possono essere dedotte da questo post sul blog di Eric Lippert .

Foo ha un parametro "x" che è dinamico, il che significa che Bar (x) è un'espressione dinamica.

Sarebbe perfettamente possibile per Example avere metodi come:

static Bar(SomeType obj)

In tal caso il metodo corretto verrebbe risolto, quindi l'istruzione Bar (x) è perfettamente valida. Il fatto che esista un metodo di istanza Bar (x) è irrilevante e nemmeno considerato: per definizione , poiché Bar (x) è un'espressione dinamica, abbiamo rimandato la risoluzione al runtime.

L'espressione "dinamica" verrà associata durante il runtime, quindi se si definisce un metodo statico con la firma corretta o un metodo di istanza, il compilatore non lo controllerà.

Il metodo "corretto" verrà determinato durante il runtime. Il compilatore non può sapere se esiste un metodo valido durante il runtime.

La parola chiave "dinamica" è definita per linguaggi dinamici e script, dove il Metodo può essere definito in qualsiasi momento, anche durante il runtime. Roba da matti

Qui un esempio che gestisce gli interi ma non le stringhe, poiché il metodo è sull'istanza.

class Program {
    static void Main(string[] args) {
        Example.Foo(1234);
        Example.Foo("1234");
    }
}
public class Example {
    int count;

    public static void Foo(dynamic x) {
        Bar(x);
    }

    public static void Bar(int a) {
        Console.WriteLine(a);
    }

    void Bar(dynamic x) {
        count++;
    }
}

È possibile aggiungere un metodo per gestire tutte le chiamate "sbagliate", che non è stato possibile gestire

public class Example {
    int count;

    public static void Foo(dynamic x) {
        Bar(x);
    }

    public static void Bar<T>(T a) {
        Console.WriteLine("Error handling:" + a);
    }

    public static void Bar(int a) {
        Console.WriteLine(a);
    }

    void Bar(dynamic x) {
        count++;
    }
}