Qual è il punto del modificatore "nuovo statico" per una funzione?

Question

Oggi ho trovato qualcosa nel codice legacy. Ha "nuovo statico" per una funzione. Sembra così.

class Foo
{
    public static void Do()
    {
        Console.WriteLine("Foo.Do");
    }
}

class Bar: Foo
{
    public static new void Do()
    {
        Console.WriteLine("Bar.Do");
    }
}

Non capisco il statico nuovo modificatore per il Fare metodo in classe Sbarra. In C#, il metodo statico può essere invocato solo con il nome della classe anziché il nome dell'oggetto. Quindi, non penso che ci sia alcuna differenza tra avere il "nuovo" e no.

In generale, se una certa sintassi non è necessaria, C# trattalo è un errore. Qualcuno ha idea del perché C# consente tale sintassi?

Answer 1

Se rimuovi il nuovo Dal tuo codice che ottieni:

AVVERTENZA CS0108: 'bar.do ()' nasconde il membro ereditato 'foo.do ()'. Utilizzare la nuova parola chiave se si prevede il nascondiglio.

Il compilatore C# ti avverte solo che potresti fare qualcosa che non intendevi e ti chiede di inserire il nuovo Parole chiave per confermare che sai cosa stai facendo. Oltre a sopprimere l'avvertimento, non ha altri effetti.

Answer 2

Questo vale solo per i chiamanti esterni. Ricorda che puoi chiamare un metodo statico della classe base, quindi qualcosa del genere è valido:

class Foo
{
    public static void Do() { Console.WriteLine("Foo.Do"); }
}
class Bar : Foo // :Foo added
{
    public static void Something()
    {
        Do();
    }
}

Ecco perché l'avvertimento ti dice di mettere il nuovo, vuoi evitare qualsiasi confusione quando lo fai:

class Foo
{
    public static void Do() { Console.WriteLine("Foo.Do"); }
}
class Bar : Foo // :Foo added
{
    public static void Something()
    {
        Do();
    }
    public static new void Do() { Console.WriteLine("Bar.Do"); }
}

Answer 3

dai un'occhiata a questo

public class BaseC
{
    public static int x = 55;
    public static int y = 22;
}

public class DerivedC : BaseC
{
    // Hide field 'x'.
    new public static int x = 100;

    static void Main()
    {
        // Display the new value of x:
        Console.WriteLine(x);

        // Display the hidden value of x:
        Console.WriteLine(BaseC.x);

        // Display the unhidden member y:
        Console.WriteLine(y);
    }
}
/*
Output:
100
55
22
*/

Il tuo esempio, per chiarire, dovrebbe essere

public class Foo
{
    public static void Do() {}
}
public class Bar :Foo
{
    public new static void Do() {}
}

Answer 4

Nel tuo esempio, la barra di seconda classe non sembra ereditare da Foo. Questo sembra essere un errore di battitura perché altrimenti non ha senso.

Supponendo che sia un errore di battitura, il modificatore "nuovo" nasconde esplicitamente la versione della classe base della funzione Do(). Ciò significa che la versione derivata del Do() Il metodo sostituisce efficacemente la versione della classe base.

Usando "Nuovo" qui documenta il fatto che il metodo ereditato sia inteso come sostituto per la versione di classe base di Do().

Per ulteriori informazioni, vedere Nuovo modificatore (C#)