Declarações de declaração

Uma instrução de declaração declara uma nova variável local, constante local ou variável de referência local.

A referência da linguagem C# documenta a versão mais recentemente lançada da linguagem C#. Contém também documentação inicial para funcionalidades em pré-visualizações públicas para o próximo lançamento linguístico.

A documentação identifica qualquer funcionalidade introduzida pela primeira vez nas últimas três versões da língua ou em pré-visualizações públicas atuais.

Sugestão

Para saber quando uma funcionalidade foi introduzida pela primeira vez em C#, consulte o artigo sobre o histórico de versões da linguagem C#.

Para declarar uma variável local, especifique seu tipo e forneça seu nome. Você pode declarar várias variáveis do mesmo tipo em uma instrução, como mostra o exemplo a seguir:

string greeting;
int a, b, c;
List<double> xs;

Em uma instrução de declaração, você também pode inicializar uma variável com seu valor inicial:

string greeting = "Hello";
int a = 3, b = 2, c = a + b;
List<double> xs = new();

Os exemplos anteriores especificam explicitamente o tipo de uma variável. Você também pode permitir que o compilador infera o tipo de uma variável a partir de sua expressão de inicialização. Para fazer isso, use a var palavra-chave em vez do nome de um tipo. Para obter mais informações, consulte a seção Variáveis locais digitadas implicitamente.

Para declarar uma constante local, use a const palavra-chave, como mostra o exemplo a seguir:

const string Greeting = "Hello";
const double MinLimit = -10.0, MaxLimit = -MinLimit;

Ao declarar uma constante local, você também deve inicializá-la.

Para obter informações sobre variáveis de referência locais, consulte a seção Variáveis de referência.

Variáveis locais escritas implicitamente

Ao declarar uma variável local, você pode permitir que o compilador infera o tipo da variável a partir da expressão de inicialização. Para isso, use a var palavra-chave em vez do nome de um tipo:

var greeting = "Hello";
Console.WriteLine(greeting.GetType());  // output: System.String

var a = 32;
Console.WriteLine(a.GetType());  // output: System.Int32

var xs = new List<double>();
Console.WriteLine(xs.GetType());  // output: System.Collections.Generic.List`1[System.Double]

Como mostra o exemplo anterior, variáveis locais implicitamente tipadas são fortemente tipadas.

Nota

Quando você usa var no contexto de reconhecimento nulo habilitado e o tipo de uma expressão de inicialização é um tipo de referência, o compilador sempre infere um tipo de referência anulável, mesmo que o tipo de uma expressão de inicialização não seja anulável.

Um uso comum de é com uma var de invocação do construtor. O uso de var permite evitar repetir o nome de um tipo numa declaração de variável e na instanciação de objetos, como mostra o exemplo seguinte:

var xs = new List<int>();

Você pode usar uma new de destino digitada como alternativa:

List<int> xs = new();
List<int>? ys = new();

Quando trabalha com tipos anónimos, deve usar variáveis locais tipadas implicitamente. O exemplo a seguir mostra uma expressão de consulta que usa um tipo anônimo para armazenar o nome e o número de telefone de um cliente:

var fromPhoenix = from cust in customers
                  where cust.City == "Phoenix"
                  select new { cust.Name, cust.Phone };

foreach (var customer in fromPhoenix)
{
    Console.WriteLine($"Name={customer.Name}, Phone={customer.Phone}");
}

No exemplo anterior, não é possível especificar explicitamente o tipo da fromPhoenix variável. O tipo é IEnumerable<T> , mas neste caso T é um tipo anônimo e você não pode fornecer seu nome. É por isso que você precisa usar varo . Pelo mesmo motivo, você deve usar var quando declarar a customer variável de iteração na foreach instrução.

Para mais informações sobre variáveis locais implicitamente tipadas, veja Variáveis locais implicitamente tipadas.

Na correspondência de padrões, a var palavra-chave é usada em um var padrão.

Variáveis de referência

Quando você declara uma variável local e adiciona a ref palavra-chave antes do tipo da variável, você declara uma :

ref int aliasOfvariable = ref variable;

Uma variável de referência é uma variável que se refere a outra variável, que é chamada de referente. Ou seja, uma variável de referência é um alias para o seu referente. Quando atribuis um valor a uma variável de referência, atribuis esse valor ao referente. Quando lês o valor de uma variável de referência, devolves o valor do referente. O exemplo a seguir demonstra esse comportamento:

int a = 1;
ref int aliasOfa = ref a;
Console.WriteLine($"(a, aliasOfa) is ({a}, {aliasOfa})");  // output: (a, aliasOfa) is (1, 1)

a = 2;
Console.WriteLine($"(a, aliasOfa) is ({a}, {aliasOfa})");  // output: (a, aliasOfa) is (2, 2)

aliasOfa = 3;
Console.WriteLine($"(a, aliasOfa) is ({a}, {aliasOfa})");  // output: (a, aliasOfa) is (3, 3)

Use o ref operador= ref de atribuição para alterar o referente de uma variável de referência, como mostra o exemplo a seguir:

void Display(int[] s) => Console.WriteLine(string.Join(" ", s));

int[] xs = [0, 0, 0];
Display(xs);

ref int element = ref xs[0];
element = 1;
Display(xs);

element = ref xs[^1];
element = 3;
Display(xs);
// Output:
// 0 0 0
// 1 0 0
// 1 0 3

No exemplo anterior, a element variável de referência é inicializada como um alias para o primeiro elemento de matriz. Em seguida, ele é reatribuído para se referir ao último elemento da ref matriz.

Você pode definir uma ref readonly variável local. Não é possível atribuir um valor a uma ref readonly variável. No entanto, pode ref reatribuir tal variável de referência, como mostra o exemplo seguinte:

int[] xs = [1, 2, 3];

ref readonly int element = ref xs[0];
// element = 100;  error CS0131: The left-hand side of an assignment must be a variable, property or indexer
Console.WriteLine(element);  // output: 1

element = ref xs[^1];
Console.WriteLine(element);  // output: 3

Você pode atribuir um retorno de referência a uma variável de referência, como mostra o exemplo a seguir:

using System;

public class NumberStore
{
    private readonly int[] numbers = [1, 30, 7, 1557, 381, 63, 1027, 2550, 511, 1023];

    public ref int GetReferenceToMax()
    {
        ref int max = ref numbers[0];
        for (int i = 1; i < numbers.Length; i++)
        {
            if (numbers[i] > max)
            {
                max = ref numbers[i];
            }
        }
        return ref max;
    }

    public override string ToString() => string.Join(" ", numbers);
}

public static class ReferenceReturnExample
{
    public static void Run()
    {
        var store = new NumberStore();
        Console.WriteLine($"Original sequence: {store.ToString()}");
        
        ref int max = ref store.GetReferenceToMax();
        max = 0;
        Console.WriteLine($"Updated sequence:  {store.ToString()}");
        // Output:
        // Original sequence: 1 30 7 1557 381 63 1027 2550 511 1023
        // Updated sequence:  1 30 7 1557 381 63 1027 0 511 1023
    }
}

No exemplo anterior, o GetReferenceToMax método é um método returns-by-ref . Ele não retorna o valor máximo em si, mas um retorno de referência que é um alias para o elemento de matriz que contém o valor máximo. O Run método atribui um retorno de referência à max variável de referência. Em seguida, atribuindo ao max, ele atualiza o armazenamento interno da store instância. Você também pode definir um ref readonly método. Os chamadores de um ref readonly método não podem atribuir um valor ao seu retorno de referência.

A variável de iteração da foreach instrução pode ser uma variável de referência. Para obter mais informações, consulte a foreach seção de instrução do artigo Instruções de iteração.

Em cenários críticos de desempenho, o uso de variáveis de referência e retornos pode aumentar o desempenho, evitando operações de cópia potencialmente caras.

O compilador garante que uma variável de referência não sobreviva ao seu referente e permaneça válida durante todo o seu tempo de vida. Para obter mais informações, consulte a seção Contextos seguros Ref da especificação da linguagem C#.

Para obter informações sobre os ref campos, consulte arefseção de campos do ref artigo Tipos de estrutura.

escopo ref

A palavra-chave scoped contextual restringe o tempo de vida de um valor. O scoped modificador restringe o tempo de vida ref-safe-to-escape ou safe-to-escape, respectivamente, ao método atual. Ao adicionar o scoped modificador, afirma que o seu código não prolonga a vida útil da variável.

Aplica scoped a um parâmetro ou variável local. Pode aplicar o scoped modificador a parâmetros e locais quando o tipo for um ref struct. Caso contrário, aplicar o scoped modificador apenas a variáveis de referência locais. Essa regra inclui variáveis locais declaradas com o ref modificador e parâmetros declarados com os in, ref, ou out modificadores.

O scoped modificador é implicitamente adicionado em this métodos declarados em a struct, out parâmetros e ref parâmetros quando o tipo é um ref struct.

Especificação da linguagem C#

Para obter mais informações, consulte as seguintes seções da especificação da linguagem C#:

• Declarações de declaração
• Variáveis de referência e retornos

Para obter mais informações sobre o scoped modificador, consulte a nota da proposta de melhorias de estrutura de baixo nível.

Consulte também

• Inicializadores de objeto e coleção
• palavra-chave ref
• Reduza as alocações de memória usando os novos recursos do C#
• preferências 'var' (regras de estilo IDE0007 e IDE0008)