Cos'è global ::?

In C # vedo global::usato abbastanza spesso nel codice generato automaticamente. Non è qualcosa che abbia mai usato io stesso, quindi non so quale sia lo scopo. Qualcuno può spiegarlo?

global si riferisce allo spazio dei nomi globale, può essere utilizzato per risolvere problemi per cui è possibile ridefinire i tipi. Per esempio:

class foo
{
    class System
    {

    }

}

Se dovessi usare System dove sarebbe localmente con scope nella classe foo, potresti usare:

global::System.Console.WriteLine("foobar");

per accedere allo spazio dei nomi globale.

Esempio

using System;

class Foo
{
    public void baz()
    {
        Console.WriteLine("Foo 1");
    }
}

namespace Demo
{
    class Foo
    {
        public void baz()
        {
            Console.WriteLine("Foo 2");
        }
    }

    class Program
    {
        protected static global::Foo bar = new global::Foo();

        static void Main(string[] args)
        {
            bar.baz(); // would write Foo 1 to console as it refers to global scope
            Foo qux = new Foo();
            qux.baz(); // would write Foo 2 to the console as it refers to the Demo namespace
        }
    }
}

È un prefisso talvolta necessario che indica lo spazio dei nomi di root.

Viene spesso aggiunto al codice generato per evitare conflitti di nome con il codice utente.

Ad esempio, immagina di avere una classe chiamata System, ma poi volevi usare System.String. Potresti usare global::System.Stringper differenziare.

Credo che ::provenga da C ++ dove è usato come separatore dello spazio dei nomi.

In pratica non l'ho mai usato, se non per generare codice. Nota che puoi anche aggirare alcuni conflitti utilizzando gli alias. Per esempiousing String = System.String;

La globalparola chiave contestuale, quando viene prima dell'operatore ::, fa riferimento allo spazio dei nomi globale, che è lo spazio dei nomi predefinito per qualsiasi programma C # ed è altrimenti senza nome.

Lo global::specificatore dice al compilatore di iniziare a cercare lo spazio dei nomi o la classe a partire dalla radice. Lo vedrai nel codice generato dal sistema in modo che funzioni sempre. In questo modo, se hai uno spazio dei nomi proprio sotto lo spazio dei nomi corrente che è lo stesso dello spazio dei nomi di livello superiore a cui il codice sta tentando di accedere, non ci sarà un conflitto.

Ad esempio, supponi di avere lo spazio dei nomi A e lo spazio dei nomi B e lo spazio dei nomi BA se scrivo codice nello spazio dei nomi BA che deve fare riferimento a una classe nello spazio dei nomi A, senza global :: non ho modo di arrivarci. Se faccio riferimento ad A.classname, il compilatore cercherà classname in BA Con global :: posso dirgli di cercare classname in global :: A.classname e troverà classname nella posizione corretta.

Lo global::spazio dei nomi e il suo identificatore non sono ciò che pensa la maggior parte delle persone. Non è un identificatore universale di tutto ciò che viene creato in un'applicazione che si trova al di fuori di uno degli spazi dei nomi definiti dall'applicazione e che è collegato a una radice globale.

Se crei una classe o un tipo al di fuori dei tuoi spazi dei nomi di livello superiore, presumerai che sia automaticamente una parte dello spazio dei nomi GLOBAL e accessibile global::dall'identificatore in tutti i file nella tua applicazione o assembly. In effetti, questi nomi sono più spesso solo nell'ambito LOCALE compilato di quel file, ma sono accessibili tramite l' global::identificatore.

Se crei una classe o uno spazio dei nomi di primo livello in un file aspx.cs, è accessibile tramite global::dallo spazio dei nomi globale in quel file. Ma se digiti global::un altro file, quella classe e lo spazio dei nomi non esistono nello spazio dei nomi globale. Tuttavia, se si crea la stessa classe o spazio dei nomi in un file class.cs, tali elementi sono disponibili per tutti gli altri file tramite global::e nello spazio dei nomi globale, nonché nell'ambito locale di quel file. Perché?

Si scopre che global::è davvero un riferimento ai nomi LOCALI di primo livello nell'ambito del file, nonché ai nomi GLOBALI condivisi dall'assembly (come ciò che potrebbe essere compilato nei file di classe App_Code in un tipico progetto ASP.NET).

L'ho trovato molto confuso e non coerente, poiché global::implica l'accesso a spazi dei nomi e tipi di primo livello creati nell'applicazione che sono legati allo spazio dei nomi globale. Alcuni come "Sistema" sono legati allo spazio dei nomi globale per impostazione predefinita in tutti i file, ma quelli personalizzati possono o meno dipendere dall'ambito di quel file. Questo è il motivo per cui l'identificatore globale ha un ruolo secondario nel risolvere anche i riferimenti ai nomi dell'ambito radice locale.

Puoi verificarlo creando spazi dei nomi e classi di primo livello in parti della tua applicazione, quindi utilizzarli global::per vedere a quali può accedere nello spazio dei nomi globale da diverse parti della tua applicazione e quali non può. Quelli a cui non può accedere sono chiaramente assegnati a un "ambito globale locale" solo in quel file, che global::ti aiuta ad accedere ai conflitti di denominazione.