Ir para o conteúdo do rodapé
AJUDA DO .NET

C# Novo (Como funciona para desenvolvedores)

A nova palavra-chave operator em C# é versátil, desempenhando múltiplas funções essenciais na linguagem. Desde a instanciação de objetos até o ocultamento de membros herdados, entender suas aplicações é crucial para um desenvolvimento eficaz em C#. Este guiaexplora os diversos usos da nova palavra-chave , fornecendo exemplos claros para ilustrar seu poder e flexibilidade. Mais adiante neste guia, também exploraremos a visão geral da biblioteca IronPDF no IronSoftware .

Introdução à instanciação de objetos

A instanciação de objetos é o processo pelo qual o operador new cria uma instância de uma classe ou estrutura. Em C#, isso é conseguido principalmente usando a palavra-chave new , que chama o construtor do tipo especificado e aloca memória para o novo objeto.

Criando instâncias com new

Para criar uma instância de um objeto, o operador new é seguido pelo nome da classe e um par de parênteses. Se a classe tiver um construtor que recebe parâmetros, os argumentos devem ser fornecidos dentro desses parênteses.

public class Book
{
    public string Title { get; set; }

    public Book(string title)
    {
        Title = title;
    }
}

Book book = new Book("The C# Programming Language");
public class Book
{
    public string Title { get; set; }

    public Book(string title)
    {
        Title = title;
    }
}

Book book = new Book("The C# Programming Language");
Public Class Book
	Public Property Title() As String

	Public Sub New(ByVal title As String)
		Me.Title = title
	End Sub
End Class

Private book As New Book("The C# Programming Language")
$vbLabelText   $csharpLabel

Construtores padrão e sem parâmetros

O C# fornece um construtor padrão caso nenhum construtor seja definido explicitamente em uma classe. No entanto, uma vez definido um construtor com parâmetros, um construtor sem parâmetros deve ser declarado explicitamente, se necessário.

public class ExampleClass
{
    // Parameterless constructor
    public ExampleClass()
    {
        // Initialization code here
    }
}
public class ExampleClass
{
    // Parameterless constructor
    public ExampleClass()
    {
        // Initialization code here
    }
}
Public Class ExampleClass
	' Parameterless constructor
	Public Sub New()
		' Initialization code here
	End Sub
End Class
$vbLabelText   $csharpLabel

Técnicas avançadas de criação de objetos

Em C#, a criação de objetos não se resume apenas à instanciação de classes; É uma porta de entrada para aproveitar os recursos poderosos da linguagem, resultando em um código mais eficiente, legível e conciso. Aqui, exploramos técnicas avançadas como trabalhar com arrays, utilizar tipos e empregar inicializadores de objetos para agilizar seus esforços de codificação.

Matrizes e Coleções

Criar arrays de um tipo específico em C# é uma habilidade fundamental, mas são as nuances que elevam suas capacidades de programação. Usando a palavra-chave new , você pode instanciar arrays, especificando seu tipo e o número de elementos que eles devem conter. Isso é crucial para gerenciar conjuntos de variáveis ​​de forma estruturada. Além dos arrays básicos, a nova funcionalidade facilita a criação de arrays multidimensionais e irregulares, acomodando estruturas de dados complexas.

// Single-dimensional array
int[] numbers = new int[5]; // Initializes an array for 5 integers

// Multidimensional array
int[,] matrix = new int[3, 2]; // A 3x2 matrix

// Jagged array (an array of arrays)
int[][] jaggedArray = new int[3][];
jaggedArray[0] = new int[4]; // First row has 4 columns
jaggedArray[1] = new int[5]; // Second row has 5 columns
jaggedArray[2] = new int[3]; // Third row has 3 columns
// Single-dimensional array
int[] numbers = new int[5]; // Initializes an array for 5 integers

// Multidimensional array
int[,] matrix = new int[3, 2]; // A 3x2 matrix

// Jagged array (an array of arrays)
int[][] jaggedArray = new int[3][];
jaggedArray[0] = new int[4]; // First row has 4 columns
jaggedArray[1] = new int[5]; // Second row has 5 columns
jaggedArray[2] = new int[3]; // Third row has 3 columns
' Single-dimensional array
Dim numbers(4) As Integer ' Initializes an array for 5 integers

' Multidimensional array
Dim matrix(2, 1) As Integer ' A 3x2 matrix

' Jagged array (an array of arrays)
Dim jaggedArray(2)() As Integer
jaggedArray(0) = New Integer(3){} ' First row has 4 columns
jaggedArray(1) = New Integer(4){} ' Second row has 5 columns
jaggedArray(2) = New Integer(2){} ' Third row has 3 columns
$vbLabelText   $csharpLabel

Tipos Anônimos

Os tipos anônimos se destacam em cenários que exigem estruturas de dados temporárias sem a sobrecarga de declarar uma classe formal. Ao usar new com uma sintaxe de inicializador de propriedade, você pode criar objetos dinamicamente. Essa funcionalidade é incrivelmente útil para consultas LINQ em que você precisa selecionar um subconjunto de propriedades de um objeto maior ou para agrupar dados rapidamente sem criar um tipo específico.

var person = new { Name = "Alice", Age = 30 };
Console.WriteLine($"Name: {person.Name}, Age: {person.Age}");

// In LINQ
var results = from p in people
              select new { p.Name, p.Age };
var person = new { Name = "Alice", Age = 30 };
Console.WriteLine($"Name: {person.Name}, Age: {person.Age}");

// In LINQ
var results = from p in people
              select new { p.Name, p.Age };
Dim person = New With {
	Key .Name = "Alice",
	Key .Age = 30
}
Console.WriteLine($"Name: {person.Name}, Age: {person.Age}")

' In LINQ
Dim results = From p In people
	Select New With {
		Key p.Name,
		Key p.Age
	}
$vbLabelText   $csharpLabel

Inicializadores de objetos

Um inicializador de objeto representa uma conveniência sintática, permitindo criar uma instância de uma classe e definir imediatamente suas propriedades sem chamar um construtor com parâmetros. Isso não só torna o código mais legível, como também reduz a probabilidade de erros, eliminando a necessidade de múltiplos construtores para diferentes cenários. Os inicializadores de objetos são particularmente úteis ao trabalhar com objetos complexos, permitindo que você defina apenas as propriedades necessárias.

public class Rectangle
{
    public int Width { get; set; }
    public int Height { get; set; }
    public Point Location { get; set; }
}

Rectangle rect = new Rectangle
{
    Width = 100,
    Height = 50,
    Location = new Point { X = 0, Y = 0 }
};
public class Rectangle
{
    public int Width { get; set; }
    public int Height { get; set; }
    public Point Location { get; set; }
}

Rectangle rect = new Rectangle
{
    Width = 100,
    Height = 50,
    Location = new Point { X = 0, Y = 0 }
};
Public Class Rectangle
	Public Property Width() As Integer
	Public Property Height() As Integer
	Public Property Location() As Point
End Class

Private rect As New Rectangle With {
	.Width = 100,
	.Height = 50,
	.Location = New Point With {
		.X = 0,
		.Y = 0
	}
}
$vbLabelText   $csharpLabel

Funções locais e expressão lambda

O C# oferece suporte a funções locais e expressões lambda, aumentando a flexibilidade e a concisão do código.

Função Local

Uma função local é um método definido dentro do escopo de outro método, servindo como uma ferramenta poderosa para organizar o código e encapsular funcionalidades.

public void PerformOperation()
{
    int LocalFunction(int x)
    {
        return x * x;
    }
    Console.WriteLine(LocalFunction(5)); // Output: 25
}
public void PerformOperation()
{
    int LocalFunction(int x)
    {
        return x * x;
    }
    Console.WriteLine(LocalFunction(5)); // Output: 25
}
Public Sub PerformOperation()
'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
'	int LocalFunction(int x)
'	{
'		Return x * x;
'	}
	Console.WriteLine(LocalFunction(5)) ' Output: 25
End Sub
$vbLabelText   $csharpLabel

Expressões Lambda

A expressão lambda oferece uma maneira concisa de escrever expressões ou métodos embutidos sem a necessidade de tipos delegados explícitos.

Func<int, int> square = x => x * x;
Console.WriteLine(square(5)); // Output: 25
Func<int, int> square = x => x * x;
Console.WriteLine(square(5)); // Output: 25
Dim square As Func(Of Integer, Integer) = Function(x) x * x
Console.WriteLine(square(5)) ' Output: 25
$vbLabelText   $csharpLabel

Usando 'novo' na herança

Na herança de classes, o atributo new pode ocultar membros herdados, permitindo que classes derivadas introduzam um membro com o mesmo nome daqueles em suas classes base.

Ocultar membros herdados

Usar new para ocultar um membro em uma classe derivada não sobrescreve o mesmo membro; Em vez disso, introduz um novo membro que é distinto da versão da classe base.

public class BaseClass
{
    public void Display()
    {
        Console.WriteLine("Base display");
    }
}

public class DerivedClass : BaseClass
{
    public new void Display()
    {
        Console.WriteLine("Derived display");
    }
}
public class BaseClass
{
    public void Display()
    {
        Console.WriteLine("Base display");
    }
}

public class DerivedClass : BaseClass
{
    public new void Display()
    {
        Console.WriteLine("Derived display");
    }
}
Public Class BaseClass
	Public Sub Display()
		Console.WriteLine("Base display")
	End Sub
End Class

Public Class DerivedClass
	Inherits BaseClass

	Public Shadows Sub Display()
		Console.WriteLine("Derived display")
	End Sub
End Class
$vbLabelText   $csharpLabel

Entendendo o básico com genéricos

Os genéricos introduzem um nível de abstração na programação em C#, permitindo que os desenvolvedores criem classes, métodos e interfaces que operam em tipos genéricos. Quando combinados com a palavra-chave new , os genéricos permitem instanciar tipos dinamicamente, aprimorando ainda mais a reutilização de código e reduzindo a redundância.

A restrição new() em um tipo genérico.

A restrição new() é fundamental para o uso de new com genéricos, especificando que um argumento de tipo em uma classe ou método genérico deve ter um construtor público sem parâmetros. Essa restrição permite criar instâncias do seu tipo genérico dentro da classe ou do método, tornando suas classes e métodos genéricos mais flexíveis e poderosos.

public class Container<t> where T : new()
{
    public T CreateItem()
    {
        return new T();
    }
}
public class Container<t> where T : new()
{
    public T CreateItem()
    {
        return new T();
    }
}
Public Class Container(Of T As {New})
    Public Function CreateItem() As T
        Return New T()
    End Function
End Class
$vbLabelText   $csharpLabel

Neste exemplo, o contêiner É possível criar instâncias de T , desde que T possua um construtor sem parâmetros. Essa capacidade é inestimável ao desenvolver bibliotecas ou frameworks que exigem a criação de objetos, mas cujos tipos específicos não são conhecidos antecipadamente.

Introdução ao IronPDF

IronPDF – Biblioteca C# para Geração e Manipulação de PDFs – destaca-se como uma ferramenta poderosa que utiliza os recursos do C# para trabalhar com arquivos PDF. Ao incorporar o IronPDF, os desenvolvedores podem criar novos documentos PDF programaticamente a partir de strings HTML , arquivos ou URLs, manipular PDFs existentes e extrair conteúdo, tudo através da sintaxe familiar do C# e aproveitando a nova palavra-chave para instanciação de objetos.

O IronPDF se destaca na conversão de HTML para PDF , garantindo a preservação precisa dos layouts e estilos originais. É perfeito para criar PDFs a partir de conteúdo da web, como relatórios, faturas e documentação. Com suporte para arquivos HTML, URLs e strings HTML brutas, o IronPDF produz facilmente documentos PDF de alta qualidade.

using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();

        // 1. Convert HTML String to PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");

        // 2. Convert HTML File to PDF
        var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");

        // 3. Convert URL to PDF
        var url = "http://ironpdf.com"; // Specify the URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}
using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();

        // 1. Convert HTML String to PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");

        // 2. Convert HTML File to PDF
        var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");

        // 3. Convert URL to PDF
        var url = "http://ironpdf.com"; // Specify the URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}
Imports IronPdf

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim renderer = New ChromePdfRenderer()

		' 1. Convert HTML String to PDF
		Dim htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>"
		Dim pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent)
		pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf")

		' 2. Convert HTML File to PDF
		Dim htmlFilePath = "path_to_your_html_file.html" ' Specify the path to your HTML file
		Dim pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath)
		pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf")

		' 3. Convert URL to PDF
		Dim url = "http://ironpdf.com" ' Specify the URL
		Dim pdfFromUrl = renderer.RenderUrlAsPdf(url)
		pdfFromUrl.SaveAs("URLToPDF.pdf")
	End Sub
End Class
$vbLabelText   $csharpLabel

Exemplo de código

using IronPdf;
using System;

namespace IronPdfExample
{
    class Program
    {
        static void Main(string[] args)
        {
            IronPdf.License.LicenseKey = "License-Key";

            // Create a new PDF document from HTML content
            var renderer = new ChromePdfRenderer();
            var pdf = renderer.RenderHtmlAsPdf("<h1>Hello, World!</h1><p>This is a PDF generated from HTML using IronPDF.</p>");

            // Save the PDF to a file
            string filePath = "HelloWorld.pdf";
            pdf.SaveAs(filePath);

            // Confirmation message
            Console.WriteLine($"PDF file has been generated at: {Environment.CurrentDirectory}\\{filePath}");
        }
    }
}
using IronPdf;
using System;

namespace IronPdfExample
{
    class Program
    {
        static void Main(string[] args)
        {
            IronPdf.License.LicenseKey = "License-Key";

            // Create a new PDF document from HTML content
            var renderer = new ChromePdfRenderer();
            var pdf = renderer.RenderHtmlAsPdf("<h1>Hello, World!</h1><p>This is a PDF generated from HTML using IronPDF.</p>");

            // Save the PDF to a file
            string filePath = "HelloWorld.pdf";
            pdf.SaveAs(filePath);

            // Confirmation message
            Console.WriteLine($"PDF file has been generated at: {Environment.CurrentDirectory}\\{filePath}");
        }
    }
}
Imports IronPdf
Imports System

Namespace IronPdfExample
	Friend Class Program
		Shared Sub Main(ByVal args() As String)
			IronPdf.License.LicenseKey = "License-Key"

			' Create a new PDF document from HTML content
			Dim renderer = New ChromePdfRenderer()
			Dim pdf = renderer.RenderHtmlAsPdf("<h1>Hello, World!</h1><p>This is a PDF generated from HTML using IronPDF.</p>")

			' Save the PDF to a file
			Dim filePath As String = "HelloWorld.pdf"
			pdf.SaveAs(filePath)

			' Confirmation message
			Console.WriteLine($"PDF file has been generated at: {Environment.CurrentDirectory}\{filePath}")
		End Sub
	End Class
End Namespace
$vbLabelText   $csharpLabel

Neste trecho de código Program, new IronPdf.ChromePdfRenderer() demonstra a instanciação de um objeto renderizador IronPDF . Esse objeto é então usado para criar um novo PDF a partir de uma string HTML, demonstrando a integração perfeita de bibliotecas de terceiros com os padrões de criação de objetos do C#. O IronPDF exige o uso da palavra-chave new para instanciar suas classes, tornando-se um exemplo relevante para desenvolvedores que estão aprendendo sobre instanciação de objetos e explorando recursos avançados do C#.

Conclusão

A nova palavra-chave em C# é um pilar da programação orientada a objetos, permitindo que os desenvolvedores instanciem objetos, gerenciem herança e utilizem genéricos com precisão e facilidade. Por meio de exemplos práticos, desde a criação de instâncias de classe simples até o aproveitamento de recursos avançados como tipos anônimos e inicializadores de objetos, este guia demonstra a versatilidade e o poder do novo .

A integração do IronPDF demonstra como o C# pode estender seu alcance além das aplicações tradicionais, permitindo a geração e manipulação de arquivos PDF por meio de código. O IronPDF oferece um período de teste gratuito e opções de licenciamento para que os desenvolvedores explorem seus recursos, com licenças a preços competitivos.

Perguntas frequentes

Como a palavra-chave `new` facilita a instanciação de objetos em C#?

Em C#, a palavra-chave `new` facilita a instanciação de objetos, chamando o construtor da classe para alocar memória para um novo objeto. Isso é essencial para a criação de instâncias de classes ou structs.

Qual é o papel da palavra-chave `new` na herança de classes em C#?

A nova palavra-chave na herança de classes permite que uma classe derivada introduza um membro com o mesmo nome de um membro herdado, ocultando efetivamente o membro da classe base sem sobrescrevê-lo.

Como converter HTML para PDF usando C#?

Você pode usar os recursos do IronPDF para converter HTML em PDF em C#. A biblioteca permite a renderização de strings e arquivos HTML em PDFs, preservando o layout e o estilo originais.

Qual é a finalidade da restrição `new()` em genéricos C#?

A restrição `new()` em genéricos C# especifica que um argumento de tipo deve ter um construtor público sem parâmetros, permitindo a criação de instâncias do tipo genérico dentro de uma classe ou método.

Como os inicializadores de objetos beneficiam os desenvolvedores C#?

Os inicializadores de objetos em C# permitem que os desenvolvedores criem uma instância de uma classe e definam suas propriedades em uma única instrução, melhorando a legibilidade do código e reduzindo a necessidade de múltiplos construtores.

Como gerar e manipular PDFs em C#?

Você pode gerar e manipular PDFs em C# usando a biblioteca IronPDF. Ela oferece funcionalidades para criar PDFs a partir de HTML, manipular PDFs existentes e extrair conteúdo usando a sintaxe C#.

O que são tipos anônimos em C# e quando você os usaria?

Em C#, os tipos anônimos são usados para criar estruturas de dados leves e temporárias sem a necessidade de declarar formalmente uma classe. Eles são úteis em cenários como consultas LINQ, onde apenas um subconjunto de propriedades é necessário.

Como a nova palavra-chave aprimora o uso de bibliotecas de terceiros em C#?

A nova palavra-chave aprimora o uso de bibliotecas de terceiros em C#, permitindo que os desenvolvedores instanciem objetos dessas bibliotecas, como a criação de objetos IronPDF para gerar PDFs a partir de fontes HTML.

Curtis Chau
Redator Técnico

Curtis Chau é bacharel em Ciência da Computação (Universidade Carleton) e se especializa em desenvolvimento front-end, com experiência em Node.js, TypeScript, JavaScript e React. Apaixonado por criar interfaces de usuário intuitivas e esteticamente agradáveis, Curtis gosta de trabalhar com frameworks modernos e criar manuais ...

Leia mais

Equipe de suporte de ferro

Estamos online 24 horas por dia, 5 dias por semana.
Bater papo
E-mail
Liga para mim