O que é global ::?

Em C #, vejo que é global::usado com bastante frequência em código gerado automaticamente. Não é algo que eu já usei, então não sei qual é o propósito. Alguém pode explicar isso?

global refere-se ao namespace global, ele pode ser usado para resolver problemas por meio do qual você pode redefinir os tipos. Por exemplo:

class foo
{
    class System
    {

    }

}

Se você fosse usar System onde teria escopo local na classe foo, você poderia usar:

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

para acessar o namespace global.

Exemplo

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

É um prefixo às vezes necessário que indica o namespace raiz.

Geralmente, é adicionado ao código gerado para evitar conflitos de nome com o código do usuário.

Por exemplo, imagine que você tenha uma classe chamada System, mas deseja usá-la System.String. Você pode usar global::System.Stringpara diferenciar.

Eu acredito que ::vem do C ++, onde é usado como separador de namespace.

Na prática, nunca usei, a não ser para gerar código. Observe que você também pode contornar alguns conflitos usando aliases. Por exemplousing String = System.String;

A globalpalavra-chave contextual, quando vem antes do operador ::, refere-se ao namespace global, que é o namespace padrão para qualquer programa C # e não tem nome.

O global::especificador diz ao compilador para começar a procurar pelo namespace ou classe começando na raiz. Você o verá no código gerado pelo sistema para que o código sempre funcione. Dessa forma, se você tiver um namespace logo abaixo de seu namespace atual que seja igual ao namespace de nível superior que o código está tentando acessar, não haverá conflito.

Por exemplo, digamos que você tenha o namespace A e o namespace B e o namespace BA se eu escrever um código no namespace BA que precisa fazer referência a uma classe no namespace A, sem global :: Não tenho como chegar a isso. Se eu fizer referência a A.classname, o compilador procurará classname em BA Com global :: posso dizer a ele para procurar classname em global :: A.classname e encontrará classname no local apropriado.

O global::namespace e seu identificador não é o que a maioria das pessoas pensa. Não é um identificador universal de tudo o que é criado em um aplicativo que está fora de um dos namespaces definidos do aplicativo e que está anexado a alguma raiz global.

Se você criar uma classe ou tipo fora de seus namespaces de nível superior, você assumiria que automaticamente faz parte do namespace GLOBAL e está acessível pelo global::identificador em todos os arquivos em seu aplicativo ou assembly. Na verdade, esses nomes estão mais frequentemente no escopo LOCAL compilado desse arquivo, mas são acessíveis por meio do global::identificador.

Se você criar uma classe de nível superior ou namespace em um arquivo aspx.cs, ele poderá ser acessado por meio global::do namespace global nesse arquivo. Mas se você digitar global::outro arquivo, essa classe e esse namespace não existirão no namespace global. Se você criar essa mesma classe ou namespace em um arquivo class.cs, no entanto, esses itens estarão disponíveis para todos os outros arquivos por meio de global::e no namespace global, bem como no escopo local dos arquivos. Por quê?

Acontece que global::é realmente uma referência a nomes LOCAL de nível superior no escopo do arquivo, bem como nomes GLOBAL compartilhados pelo assembly (como o que pode ser compilado em seus arquivos de classe App_Code em um projeto ASP.NET típico).

Achei isso muito confuso e não consistente, pois global::implica acesso a namespaces de nível superior e tipos criados no aplicativo que estão vinculados ao namespace global. Alguns, como "Sistema", estão vinculados ao namespace global por padrão em todos os arquivos, mas os personalizados podem ou não ser, dependendo do escopo desse arquivo. É por isso que o identificador global tem uma função secundária de resolver as referências aos nomes de escopo da raiz local também.

Você pode testar isso criando namespaces e classes de nível superior em partes de seu aplicativo e, em seguida, usando global::para ver quais podem ser acessados ​​no namespace global de diferentes partes de seu aplicativo e quais não. Os que não podem ser acessados ​​são claramente atribuídos a um "escopo global local" apenas naquele arquivo, o que global::ajuda a acessar em conflitos de nomenclatura.