Existe uma palavra-chave específica em C# que possui uma importância especial: a palavra-chave this. Essa palavra-chave se refere à instância de classe atual onde é usada. Pode ser usado para distinguir entre variáveis de nível de classe e parâmetros de método que compartilham o mesmo nome, entre outras coisas. Por exemplo, se você tiver uma variável de instância e um parâmetro de método com o mesmo nome, this pode ser um salva-vidas!
Em uma classe pública, como Employee, por exemplo, você pode ter variáveis de instância públicas como id ou name. Se você quiser atribuir valores a essas variáveis de instância dentro de um método, poderá se deparar com um problema comum: e se os parâmetros do método tiverem o mesmo nome que as variáveis de instância?
Aqui está uma solução: Use a palavra-chave this na documentação C#! No exemplo a seguir de um método dentro da classe pública Employee, a palavra-chave this é usada para distinguir entre as variáveis de instância e os parâmetros do método que compartilham os mesmos nomes.
public class Employee
{
private int id;
private string name;
public void Display(int id, string name)
{
// Use `this.id` to refer to the instance variable,
// and `id` for the method parameter.
this.id = id;
this.name = name;
}
}Public Class Employee
Private id As Integer
Private name As String
Public Sub Display(id As Integer, name As String)
' Use `Me.id` to refer to the instance variable,
' and `id` for the method parameter.
Me.id = id
Me.name = name
End Sub
End ClassNeste caso, this.id refere-se à variável de instância, e id é o parâmetro do método.
this Palavra-chave em Sobrecarga de ConstrutorAproveitando a palavra-chave this, a sobrecarga de construtor torna-se uma técnica poderosa dentro da mesma classe. Quando uma classe, como uma classe Student, tem vários construtores com parâmetros variados, a palavra-chave this permite que um construtor chame outro, eliminando a necessidade de código redundante.
Considere o exemplo a seguir onde this é usado em um construtor parametrizado:
public class Student
{
private string name;
private int id;
public Student() : this("Default", 0)
{
// Default constructor delegates to the parameterized constructor
// with "Default" as the name and 0 as the id.
}
public Student(string name, int id)
{
// Assign the parameters to the instance variables
this.name = name;
this.id = id;
}
}Public Class Student
Private name As String
Private id As Integer
Public Sub New()
Me.New("Default", 0)
' Default constructor delegates to the parameterized constructor
' with "Default" as the name and 0 as the id.
End Sub
Public Sub New(ByVal name As String, ByVal id As Integer)
' Assign the parameters to the instance variables
Me.name = name
Me.id = id
End Sub
End ClassNo construtor sem parâmetros, this("Default", 0) chama o construtor parametrizado, definindo Default como o nome e 0 como o ID.
this em Métodos de ExtensãoOs métodos de extensão em C# fornecem uma maneira de adicionar métodos a tipos existentes sem modificar o tipo original. É aqui que a palavra-chave this faz algo mágico. É usado na lista de parâmetros do método de extensão para se referir ao tipo que está sendo estendido.
Considere o seguinte exemplo de um método de extensão:
public static class StringExtensions
{
// This extension method can be called on any string instance
public static bool IsNullOrEmpty(this string str)
{
return string.IsNullOrEmpty(str);
}
}Public Module StringExtensions
' This extension method can be called on any string instance
<System.Runtime.CompilerServices.Extension> _
Public Function IsNullOrEmpty(ByVal str As String) As Boolean
Return String.IsNullOrEmpty(str)
End Function
End ModuleAqui, this string str informa ao C# que este é um método de extensão para o tipo string. Agora você pode usar este método em qualquer objeto string, como if(myString.IsNullOrEmpty()).
this em IndexadoresA palavra-chave this também pode ser usada na definição de indexadores. Um indexador permite que instâncias de uma classe sejam indexadas da mesma forma que arrays. Isso permite acessar dados dentro de objetos usando uma notação semelhante a um índice. Em um indexador, this é seguido por um índice de array, que geralmente é int index.
Aqui está um exemplo básico de um indexador:
public class Test
{
private int[] array = new int[100];
// Define an indexer for the class
public int this[int index]
{
get { return array[index]; }
set { array[index] = value; }
}
}Public Class Test
Private array(99) As Integer
' Define an indexer for the class
Default Public Property Item(ByVal index As Integer) As Integer
Get
Return array(index)
End Get
Set(ByVal value As Integer)
array(index) = value
End Set
End Property
End ClassNesta classe Test, a palavra-chave this define um indexador que pode ser usado para obter ou definir valores no campo de instância array.
this e Membros EstáticosUma coisa a observar sobre this é que não pode ser usado para referenciar membros ou métodos estáticos. Isso se deve ao fato de que this refere-se à instância atual, e os membros estáticos pertencem à própria classe, não a uma instância da classe.
public class Program
{
public static void Main(string[] args)
{
// Can't use `this` here, because 'Main' is a static method.
}
}Public Class Program
Public Shared Sub Main(ByVal args() As String)
' Can't use `this` here, because 'Main' is a static method.
End Sub
End ClassEntão, lembre-se, this é para instâncias, não para membros de classe ou estáticos!
this Palavra-chave e PropriedadesAssim como variáveis de instância e parâmetros de método, a palavra-chave this também pode ser usada com propriedades. Em C#, uma propriedade é um membro que fornece um mecanismo flexível para ler, escrever ou calcular o valor de um campo privado. As propriedades podem ser usadas como se fossem membros de dados públicos, mas na verdade são métodos especiais chamados acessadores.
Vamos dar uma olhada em um exemplo simples usando this em uma propriedade:
public class Employee
{
private string name;
public string Name
{
get { return this.name; }
set { this.name = value; } // Use `this` to refer to the instance variable
}
}Public Class Employee
'INSTANT VB NOTE: The field name was renamed since Visual Basic does not allow fields to have the same name as other class members:
Private name_Conflict As String
Public Property Name() As String
Get
Return Me.name_Conflict
End Get
Set(ByVal value As String)
Me.name_Conflict = value
End Set ' Use `this` to refer to the instance variable
End Property
End ClassNa classe acima, a palavra-chave this é usada para se referir à string privada name nos acessadores get e set da propriedade Name.
this and DelegatesOutro lugar onde this aparece é em delegados. Em C#, um delegate é semelhante a um ponteiro de função em C ou C++. É uma variável de tipo referência que armazena a referência a um método. Métodos delegados, assim como métodos de extensão, podem usar this para acessar a instância atual.
Aqui está um exemplo de um delegado usando this:
public delegate void DisplayDelegate();
public class Student
{
public int Id { get; set; }
public string Name { get; set; }
public void Display()
{
// `this.DisplayDetails` refers to the method instance of the current object.
DisplayDelegate displayDelegate = new DisplayDelegate(this.DisplayDetails);
displayDelegate();
}
private void DisplayDetails()
{
Console.WriteLine("ID: " + Id + ", Name: " + Name);
}
}Public Delegate Sub DisplayDelegate()
Public Class Student
Public Property Id() As Integer
Public Property Name() As String
Public Sub Display()
' `this.DisplayDetails` refers to the method instance of the current object.
Dim displayDelegate As New DisplayDelegate(AddressOf Me.DisplayDetails)
displayDelegate()
End Sub
Private Sub DisplayDetails()
Console.WriteLine("ID: " & Id & ", Name: " & Name)
End Sub
End ClassNa classe estudante, this.DisplayDetails cria uma nova instância do delegado que se refere ao método DisplayDetails do objeto atual.
this Palavra-chave com IronPDFVamos nos aprofundar em um exemplo onde você pode usar a palavra-chave this em conjunto com IronPDF, uma poderosa biblioteca .NET para edição e criação de arquivos PDF usando HTML.
Considere uma classe chamada PDFHandler que utiliza a biblioteca IronPDF para realizar várias operações em arquivos PDF:
using IronPdf;
public class PDFHandler
{
private string path;
public PDFHandler(string path)
{
this.path = path;
}
public void GeneratePDF(string content)
{
// Creating a renderer to convert HTML content to PDF
var Renderer = new IronPdf.ChromePdfRenderer();
var PDF = Renderer.RenderHtmlAsPdf(content);
// Save the generated PDF to the path specified by the current instance
PDF.SaveAs(this.path);
}
}Imports IronPdf
Public Class PDFHandler
Private path As String
Public Sub New(ByVal path As String)
Me.path = path
End Sub
Public Sub GeneratePDF(ByVal content As String)
' Creating a renderer to convert HTML content to PDF
Dim Renderer = New IronPdf.ChromePdfRenderer()
Dim PDF = Renderer.RenderHtmlAsPdf(content)
' Save the generated PDF to the path specified by the current instance
PDF.SaveAs(Me.path)
End Sub
End ClassNesta classe PDFHandler, a palavra-chave this é usada para se referir ao campo path da instância atual. Este campo é utilizado para salvar o PDF gerado no caminho especificado.
Quando criamos uma nova instância de PDFHandler e chamamos o método GeneratePDF, a palavra-chave this nos permite utilizar o path especificado durante a criação do objeto:
class Program
{
static void Main(string[] args)
{
// Initialize PDFHandler with a specified file path
PDFHandler pdfHandler = new PDFHandler("C:\\ThisKeyword.pdf");
pdfHandler.GeneratePDF("Hello World!");
}
}Friend Class Program
Shared Sub Main(ByVal args() As String)
' Initialize PDFHandler with a specified file path
Dim pdfHandler As New PDFHandler("C:\ThisKeyword.pdf")
pdfHandler.GeneratePDF("Hello World!")
End Sub
End ClassAqui, this torna o código mais legível e compreensível, especialmente ao lidar com bibliotecas como IronPDF.
Até agora, você deve ter uma boa compreensão da palavra-chave this em C#, incluindo seus amplos usos, desde variáveis de instância simples até contextos complexos como construtores, métodos de extensão, propriedades, delegados, métodos anônimos e até mesmo ao usar bibliotecas populares como IronPDF.
Lembre-se, o IronPDF oferece um período de IronPDF gratuito , para que você possa colocar em prática tudo o que aprendeu hoje. Se você decidir continuar com isso, as licenças começam a partir de apenas $999. O IronPDF pode ser uma adição valiosa ao seu conjunto de ferramentas de desenvolvimento C#, simplificando a tarefa de manipular arquivos PDF em seus aplicativos.
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 bem estruturados e visualmente atraentes.
IronPDF faz parte do IRON SUITE.
10 produtos de API .NET para seus documentos de escritório
Quando você precisa que seu PDF tenha a aparência de HTML, rapidamente.
