Expressões new com tipo de destino
Simplifique a criação de objetos com a tipagem pelo destino.
Expressões new com tipo de destino é uma aula grátis de C# Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de C# Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de C# Academy inclui 4 aulas no total.
new com tipo de destino
Desde o C# 9, você pode escrever Type x = new(); e omitir o tipo depois de new quando o tipo de destino for conhecido.
using System;
using System.Collections.Generic;
class Program {
static void Main() {
List<int> numbers = new();
numbers.Add(1);
Console.WriteLine(numbers.Count);
}
}Removendo redundância
Quando a variável já informa o tipo, repeti-lo depois de new é excesso. O new() vazio o remove.
using System;
using System.Text;
class Program {
static void Main() {
StringBuilder sb = new();
sb.Append("Hi");
Console.WriteLine(sb.ToString());
}
}Passando argumentos para o construtor
O new() com tipo de destino ainda aceita argumentos do construtor dentro dos parênteses.
using System;
class Point {
public int X, Y;
public Point(int x, int y) { X = x; Y = y; }
}
class Program {
static void Main() {
Point p = new(3, 4);
Console.WriteLine(p.X + ", " + p.Y);
}
}Com inicializadores de objetos
Você pode combinar new com tipo de destino com um bloco inicializador de objeto.
using System;
class User {
public string Name;
public int Age;
}
class Program {
static void Main() {
User u = new() { Name = "Ann", Age = 30 };
Console.WriteLine(u.Name + " " + u.Age);
}
}Em campos
new com tipo de destino também funciona para inicializadores de campos, mantendo as declarações concisas.
using System;
using System.Collections.Generic;
class Program {
static List<string> items = new();
static void Main() {
items.Add("a");
Console.WriteLine(items.Count);
}
}Em argumentos de métodos
Quando um parâmetro tem um tipo conhecido, você pode passar new() diretamente como argumento.
using System;
using System.Collections.Generic;
class Program {
static void Print(List<int> list) {
Console.WriteLine(list.Count);
}
static void Main() {
Print(new());
}
}Retornando new()
Se o tipo retornado por um método for conhecido, você poderá retornar new() sem repetir o nome do tipo.
using System;
using System.Collections.Generic;
class Program {
static List<int> Make() {
return new() { 1, 2, 3 };
}
static void Main() {
Console.WriteLine(Make().Count);
}
}Contraste com var
var x = new List<int>() informa o tipo à direita; List<int> x = new() informa-o à esquerda. Escolha a forma que for mais legível.
using System;
using System.Collections.Generic;
class Program {
static void Main() {
var a = new List<int>();
List<int> b = new();
Console.WriteLine(a.Count + b.Count);
}
}A ambiguidade é um erro
Se o compilador não puder determinar o tipo de destino, new() falhará. O tipo de destino precisa estar claro pelo contexto.
using System;
class Program {
static void Main() {
object o = new object();
Console.WriteLine(o.GetType().Name);
}
}Legibilidade com tipos longos
new com tipo de destino é especialmente útil para tipos genéricos extensos, pois evita escrever o tipo duas vezes.
using System;
using System.Collections.Generic;
class Program {
static void Main() {
Dictionary<string, List<int>> map = new();
map["a"] = new() { 1, 2 };
Console.WriteLine(map["a"].Count);
}
}Um estilo moderno
new com tipo de destino mantém as declarações limpas, preservando a tipagem estática completa e as verificações do compilador.
using System;
using System.Collections.Generic;
class Program {
static void Main() {
Queue<string> q = new();
q.Enqueue("first");
Console.WriteLine(q.Dequeue());
}
}Verificação rápida
Teste sua compreensão das expressões new com tipo de destino.
Recapitulação
new() com tipo de destino permite omitir o tipo depois de new quando o tipo de destino já é conhecido, reduzindo a duplicação em declarações, campos, argumentos e retornos.
Ele ainda aceita argumentos de construtores e inicializadores, falha quando o tipo é ambíguo e complementa var como um estilo moderno e totalmente seguro quanto aos tipos.
Perguntas Frequentes
A aula “Expressões new com tipo de destino” é grátis?
Sim — o texto completo de “Expressões new com tipo de destino” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de C# Academy, atualize para CoddyKit PRO. O curso de C# Academy inclui 4 aulas no total.
O que vou aprender em “Expressões new com tipo de destino”?
Simplifique a criação de objetos com a tipagem pelo destino. Você pratica C# Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar C# Academy?
Nenhuma experiência prévia é necessária. C# Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.
Quanto tempo leva a aula “Expressões new com tipo de destino”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de C# Academy?
Sim. Cada aula de C# Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- Inferência de tipo de variável local com var
- Quando evitar var
- O tipo dynamic
- Expressões new com tipo de destino