@ (Referência de C#)@ (C# Reference)

O caractere especial @ serve como um identificador textual.The @ special character serves as a verbatim identifier. Ele pode ser usado das seguintes maneiras:It can be used in the following ways:

  1. Para habilitar palavras-chave de C# a serem usadas como identificadores.To enable C# keywords to be used as identifiers. O caractere @ atua como prefixo de um elemento de código que o compilador deve interpretar como um identificador e não como uma palavra-chave de C#.The @ character prefixes a code element that the compiler is to interpret as an identifier rather than a C# keyword. O exemplo a seguir usa o caractere @ para definir um identificador chamado for que usa em um loop for.The following example uses the @ character to define an identifier named for that it uses in a for loop.

    string[] @for = { "John", "James", "Joan", "Jamie" };
    for (int ctr = 0; ctr < @for.Length; ctr++)
    {
       Console.WriteLine($"Here is your gift, {@for[ctr]}!");
    }
    // The example displays the following output:
    //     Here is your gift, John!
    //     Here is your gift, James!
    //     Here is your gift, Joan!
    //     Here is your gift, Jamie!
    
  2. Para indicar que um literal de cadeia de caracteres é interpretado de forma textual.To indicate that a string literal is to be interpreted verbatim. O caractere @ neste exemplo define um literal de cadeia de caracteres textual.The @ character in this instance defines a verbatim string literal. Sequências de escape simples (como "\\" para uma barra invertida), sequências de escape hexadecimais (como um "\x0041" para um A maiúsculo) e sequências de escape Unicode (como "\u0041" para um A maiúsculo) são interpretadas de forma textual.Simple escape sequences (such as "\\" for a backslash), hexadecimal escape sequences (such as "\x0041" for an uppercase A), and Unicode escape sequences (such as "\u0041" for an uppercase A) are interpreted literally. Somente uma sequência de escape de aspas ("") não é interpretada literalmente; ela produz aspas simples.Only a quote escape sequence ("") is not interpreted literally; it produces a single quotation mark. Além disso, no caso de uma cadeia de caracteres interpolada textual, as sequências de escape de chave ({{ e }}) não são interpretadas de forma textual; elas geram caracteres de chave única.Additionally, in case of a verbatim interpolated string brace escape sequences ({{ and }}) are not interpreted literally; they produce single brace characters. O exemplo a seguir define dois caminhos de arquivo idênticos, um usando um literal de cadeia de caracteres regular e o outro usando um literal de cadeia de caracteres textual.The following example defines two identical file paths, one by using a regular string literal and the other by using a verbatim string literal. Este é um dos usos mais comuns de literais de cadeias de caracteres textuais.This is one of the more common uses of verbatim string literals.

    string filename1 = @"c:\documents\files\u0066.txt";
    string filename2 = "c:\\documents\\files\\u0066.txt";
    
    Console.WriteLine(filename1);
    Console.WriteLine(filename2);
    // The example displays the following output:
    //     c:\documents\files\u0066.txt
    //     c:\documents\files\u0066.txt
    

    O exemplo a seguir ilustra o efeito de definir um literal de cadeia de caracteres regular e um literal de cadeia de caracteres textual que contêm sequências de caracteres idênticas.The following example illustrates the effect of defining a regular string literal and a verbatim string literal that contain identical character sequences.

    string s1 = "He said, \"This is the last \u0063hance\x0021\"";
    string s2 = @"He said, ""This is the last \u0063hance\x0021""";
    
    Console.WriteLine(s1);
    Console.WriteLine(s2);
    // The example displays the following output:
    //     He said, "This is the last chance!"
    //     He said, "This is the last \u0063hance\x0021"      
    
  3. Para habilitar o compilador a distinguir entre os atributos em caso de um conflito de nomenclatura.To enable the compiler to distinguish between attributes in cases of a naming conflict. Um atributo é um tipo que deriva de Attribute.An attribute is a class that derives from Attribute. Seu nome de tipo normalmente inclui o sufixo Attribute, embora o compilador não imponha essa convenção.Its type name typically includes the suffix Attribute, although the compiler does not enforce this convention. O atributo pode, então, ser referenciado no código por seu nome de tipo completo (por exemplo, [InfoAttribute] ou pelo nome abreviado (por exemplo, [Info]).The attribute can then be referenced in code either by its full type name (for example, [InfoAttribute] or its shortened name (for example, [Info]). No entanto, um conflito de nomenclatura ocorre se dois nomes de tipo abreviados forem idênticos e um nome de tipo incluir o sufixo Attribute e o outro não incluir.However, a naming conflict occurs if two shortened attribute type names are identical, and one type name includes the Attribute suffix but the other does not. Por exemplo, o código a seguir não é compilado porque o compilador não consegue determinar se o atributo Info ou InfoAttribute é aplicado à classe Example.For example, the following code fails to compile because the compiler cannot determine whether the Info or InfoAttribute attribute is applied to the Example class. Veja CS1614 para obter mais informações.See CS1614 for more information.

    using System;
    
    [AttributeUsage(AttributeTargets.Class)]
    public class Info : Attribute
    {
       private string information;
       
       public Info(string info)
       {
          information = info;
       }
    }
    
    [AttributeUsage(AttributeTargets.Method)]
    public class InfoAttribute : Attribute
    {
       private string information;
       
       public InfoAttribute(string info)
       {
          information = info;
       }
    }
    
    [Info("A simple executable.")] // Generates compiler error CS1614. Ambiguous Info and InfoAttribute. 
    // Prepend '@' to select 'Info'. Specify the full name 'InfoAttribute' to select it.
    public class Example
    {
       [InfoAttribute("The entry point.")]
       public static void Main()
       {
       }
    }
    

Veja tambémSee also