@ (Referencia de C#)@ (C# Reference)

El carácter especial @ actúa como un identificador textual.The @ special character serves as a verbatim identifier. Se puede usar de estas formas:It can be used in the following ways:

  1. Para habilitar el uso de palabras clave de C# como identificadores.To enable C# keywords to be used as identifiers. El carácter @ actúa como prefijo de un elemento de código que el compilador debe interpretar como un identificador en lugar de como una palabra clave de C#.The @ character prefixes a code element that the compiler is to interpret as an identifier rather than a C# keyword. En el ejemplo siguiente se usa el carácter @ para definir un identificador denominado for que se usa en un bucle 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 un literal de cadena se debe interpretar literalmente.To indicate that a string literal is to be interpreted verbatim. El carácter @ de esta instancia define un literal de cadena textual.The @ character in this instance defines a verbatim string literal. Las secuencias de escape sencillas (como "\\", que es una barra diagonal inversa), las secuencias de escape hexadecimales (como "\x0041", que es una A mayúscula) y las secuencias de escape Unicode (como "\u0041" que es una A mayúscula) se interpretan literalmente.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. Solo las secuencias de escape de comillas ("") no se interpretan literalmente, sino que generan comillas dobles.Only a quote escape sequence ("") is not interpreted literally; it produces one double quotation mark. De igual modo, en el caso de una cadena interpolada literal, las secuencias de escape de llave ({{ y }}) no se interpretan literalmente, sino que generan caracteres de llave simple.Additionally, in case of a verbatim interpolated string brace escape sequences ({{ and }}) are not interpreted literally; they produce single brace characters. En el siguiente ejemplo se definen dos rutas de archivo idénticas, una mediante un literal de cadena normal y otra mediante el uso de un literal de cadena 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 es uno de los usos más comunes de los literales de cadena textual.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
    

    En el ejemplo siguiente se muestra el efecto de definir un literal de cadena normal y un literal de cadena textual que contienen secuencias de caracteres idénticos.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 permitir que el compilador distinga entre los atributos en caso de conflicto de nomenclatura.To enable the compiler to distinguish between attributes in cases of a naming conflict. Un atributo es una clase que deriva de Attribute.An attribute is a class that derives from Attribute. Normalmente, su nombre de tipo incluye el sufijo Attribute, aunque el compilador no exige el cumplimiento de esta convención.Its type name typically includes the suffix Attribute, although the compiler does not enforce this convention. Es posible hacer referencia al atributo en el código mediante su nombre de tipo completo (por ejemplo, [InfoAttribute]) o mediante su nombre abreviado (por ejemplo, [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]). Pero se produce un conflicto de nomenclatura si dos nombres abreviados de tipo de atributo son idénticos, y un nombre de tipo incluye el sufijo Attribute y el otro no.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 ejemplo, el código siguiente produce un error al compilarse porque el compilador no puede determinar si el atributo Info o InfoAttribute se aplica a la clase 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. Vea CS1614 para obtener más información.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()
       {
       }
    }
    

Vea tambiénSee also