¿Qué es global ::?

En C # veo que se global::usa con bastante frecuencia en código generado automáticamente. No es algo que haya usado nunca, así que no sé cuál es el propósito. ¿Alguien puede explicar esto?

global se refiere al espacio de nombres global, se puede utilizar para resolver problemas mediante los cuales puede redefinir tipos. Por ejemplo:

class foo
{
    class System
    {

    }

}

Si tuviera que usar System donde tendría un alcance local en la clase foo, podría usar:

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

para acceder al espacio de nombres global.

Ejemplo

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
        }
    }
}

Es un prefijo necesario en ocasiones que indica el espacio de nombres raíz.

A menudo se agrega al código generado para evitar conflictos de nombres con el código de usuario.

Por ejemplo, imagina que tienes una clase llamada System, pero luego quieres usar System.String. Podría utilizar global::System.Stringpara diferenciar.

Creo que ::proviene de C ++, donde se usa como separador de espacios de nombres.

En la práctica, nunca lo he usado, salvo para generar código. Tenga en cuenta que también puede solucionar algunos conflictos mediante el uso de alias. Por ejemplousing String = System.String;

La globalpalabra clave contextual, cuando viene antes del operador ::, se refiere al espacio de nombres global, que es el espacio de nombres predeterminado para cualquier programa de C # y, por lo demás, no tiene nombre.

El global::especificador le dice al compilador que comience a buscar el espacio de nombres o la clase comenzando desde la raíz. Lo verá en código generado por el sistema para que el código siempre funcione. De esa manera, si tiene un espacio de nombres justo debajo de su espacio de nombres actual que es el mismo que el espacio de nombres de nivel superior al que el código está intentando acceder, no habrá un conflicto.

Por ejemplo, digamos que tiene un espacio de nombres A y un espacio de nombres B y un espacio de nombres BA si escribo código en el espacio de nombres BA que necesita hacer referencia a una clase en el espacio de nombres A, sin global :: No tengo forma de acceder a él. Si hago referencia a A.classname, el compilador buscará classname en BA Con global :: Puedo decirle que busque classname en global :: A.classname y encontrará classname en la ubicación adecuada.

El global::espacio de nombres y su identificador no es lo que la mayoría de la gente piensa. No es un identificador universal de todo lo creado en una aplicación que se encuentra fuera de uno de los espacios de nombres definidos de su aplicación y que está adjunto a alguna raíz global.

Si crea una clase o un tipo fuera de sus espacios de nombres de nivel superior, asumirá que automáticamente forma parte del espacio de nombres GLOBAL y que el global::identificador puede acceder a ellos en todos los archivos de su aplicación o ensamblado. De hecho, esos nombres se encuentran más a menudo en el alcance LOCAL compilado de ese archivo solamente, pero son accesibles a través del global::identificador.

Si crea una clase de nivel superior o un espacio de nombres en un archivo aspx.cs, se puede acceder a él a través global::del espacio de nombres global en ese archivo. Pero si escribe global::en otro archivo, esa clase y espacio de nombres no existen en el espacio de nombres global. Sin embargo, si crea esa misma clase o espacio de nombres en un archivo class.cs, esos elementos están disponibles para todos los demás archivos a través global::y en el espacio de nombres global, así como el alcance local de los archivos. ¿Por qué?

Resulta que en global::realidad es una referencia a los nombres LOCALES de nivel superior bajo el alcance del archivo, así como a los nombres GLOBALES compartidos por el ensamblado (como lo que podría compilarse en sus archivos de clase App_Code en un proyecto ASP.NET típico).

Encontré esto muy confuso y no consistente, ya que global::implica acceso a espacios de nombres de nivel superior y tipos creados en la aplicación que están vinculados al espacio de nombres global. Algunos como "Sistema" están vinculados al espacio de nombres global de forma predeterminada en todos los archivos, pero los personalizados pueden o no depender del alcance de ese archivo. Es por eso que el identificador global también tiene una función secundaria de resolver referencias a los nombres de alcance raíz local.

Puede probar esto creando espacios de nombres y clases de nivel superior en partes de su aplicación y luego usar global::para ver a cuáles puede acceder en el espacio de nombres global desde diferentes partes de su aplicación y a cuáles no. Los que no pueden acceder están claramente asignados a un "ámbito global local" solo en ese archivo, lo que le global::ayuda a acceder a los conflictos de nombres.