Getters e setters são conceitos essenciais em linguagens de programação orientadas a objetos como C#. Esses dois métodos nos permitem controlar o acesso e a modificação das propriedades da classe. Neste tutorial, exploraremos aspectos básicos e intermediários de getters e setters privados em C# usando blocos de código.
Em sua essência, getters e setters nada mais são do que métodos que permitem o acesso a variáveis privadas em uma classe. O método getter retorna o valor de uma variável de campo privada, enquanto o método setter a modifica. Esses métodos garantem que os dados internos (campos) de uma classe sejam acessados ou modificados de forma segura e correta.
Imagine ter um public class Car com uma propriedade private string description. Se alguém de fora desta turma quiser saber a descrição, não poderá acessá-la diretamente porque é privada. É aí que entra o papel dos levantadores e dos criadores de jogadas.
Um getter permitiria aos usuários recuperar o valor de um private string description sem lhes dar acesso direto para modificá-lo. Por outro lado, um setter permitiria que os usuários modificassem a descrição de acordo com as condições que definimos.
Os modificadores de acesso definem o nível de visibilidade e acessibilidade de um campo ou propriedade fora da classe. Os modificadores mais comumente usados são public e private.
Public: Campos ou propriedades declarados public podem ser acessados de qualquer lugar em seu programa. Por exemplo, você pode ter uma propriedade public int Age que pode ser acessada e modificada por qualquer parte do seu código.Private: Propriedades ou campos declarados private só podem ser acessados dentro da classe definida, por exemplo, private int age. Esse encapsulamento ajuda a prevenir modificações não autorizadas e garante que o estado interno da classe seja mantido adequadamente.Vamos começar com um exemplo simples.
using System;
public class Person
{
private string name; // This is a private string name property variable
// This is the getter
public string GetName()
{
return name;
}
// This is the setter
public void SetName(string newName)
{
name = newName;
}
}
class Program
{
static void Main()
{
Person person = new Person();
person.SetName("John");
Console.WriteLine(person.GetName());
}
}Imports System
Public Class Person
Private name As String ' This is a private string name property variable
' This is the getter
Public Function GetName() As String
Return name
End Function
' This is the setter
Public Sub SetName(ByVal newName As String)
name = newName
End Sub
End Class
Module Program
Sub Main()
Dim person As New Person()
person.SetName("John")
Console.WriteLine(person.GetName())
End Sub
End ModuleNo class Person acima, temos tanto um getter (GetName) quanto um setter (SetName) para a propriedade name. Quando você executa o método static void Main, ele imprimirá 'John' porque definimos esse valor para o nome usando o setter.
Você pode estar pensando: "Preciso sempre escrever métodos separados para getters e setters?" A resposta é "não". O C# introduziu um conceito chamado "propriedades autoimplementadas" ou "propriedades automáticas" para simplificar isso.
Em C#, você pode usar propriedades automáticas, que permitem uma forma abreviada de declarar um private field e sua propriedade associada. Eis um exemplo:
using System;
public class Student
{
public string Name { get; set; } // This is an auto-implemented or automatic property
public string Title { get; set; } // Another auto-implemented property
}
class Program
{
static void Main()
{
Student student = new Student();
student.Name = "Alice"; // Using setter
Console.WriteLine(student.Name); // Using getter
}
}Imports System
Public Class Student
Public Property Name() As String ' - This is an auto-implemented or automatic property
Public Property Title() As String ' - Another auto-implemented property
End Class
Friend Class Program
Shared Sub Main()
Dim student As New Student()
student.Name = "Alice" ' Using setter
Console.WriteLine(student.Name) ' Using getter
End Sub
End ClassNa classe Student, a propriedade Name é tanto um getter quanto um setter, que são automaticamente implementados. O compilador C# cria um campo private string name nos bastidores, e a propriedade Name fornece acesso a esse campo.
Às vezes, você pode querer fornecer uma propriedade que possa ser lida, mas não modificada externamente. É aí que as propriedades somente leitura se tornam úteis. Você pode omitir o método setter em uma propriedade para torná-la somente leitura.
Digamos que queremos adicionar uma propriedade string Description somente leitura à nossa classe Person:
public class Person
{
public string Name { get; set; }
public string Description { get; }
public Person(string name, string description)
{
Name = name;
Description = description;
}
}Public Class Person
Public Property Name As String
Public ReadOnly Property Description As String
Public Sub New(name As String, description As String)
Me.Name = name
Me.Description = description
End Sub
End ClassNeste exemplo, a propriedade Description só pode ser definida dentro do construtor da classe Person. Uma vez configurado, não pode ser modificado externamente.
Às vezes, você pode querer permitir que a propriedade seja lida de fora da classe, mas definida apenas de dentro da classe. Isso é alcançado usando um private set.
using System;
public class Program
{
public string Description { get; private set; }
public Program()
{
Description = "This is a program about getters and setters.";
}
}
class ProgramTest
{
static void Main()
{
Program myProgram = new Program();
Console.WriteLine(myProgram.Description); // Allowed
// myProgram.Description = "New Description"; // Not allowed
}
}Imports System
Public Class Program
Private privateDescription As String
Public Property Description() As String
Get
Return privateDescription
End Get
Private Set(ByVal value As String)
privateDescription = value
End Set
End Property
Public Sub New()
Description = "This is a program about getters and setters."
End Sub
End Class
Friend Class ProgramTest
Shared Sub Main()
Dim myProgram As New Program()
Console.WriteLine(myProgram.Description) ' Allowed
' myProgram.Description = "New Description"; // Not allowed
End Sub
End ClassNo class Program, a propriedade Description tem um private set, o que significa que não pode ser alterada de fora da classe, garantindo a integridade dos dados.
Ao trabalhar com classes derivadas, você pode sobrescrever os métodos getter e setter para personalizar seu comportamento. Isso permite adicionar lógica adicional ao obter ou definir valores.
public class Person
{
public virtual string Name { get; set; }
}
public class Student : Person
{
private string studentID;
public override string Name
{
get { return base.Name; }
set
{
if (!string.IsNullOrEmpty(value))
base.Name = value;
}
}
}Public Class Person
Public Overridable Property Name() As String
End Class
Public Class Student
Inherits Person
Private studentID As String
Public Overrides Property Name() As String
Get
Return MyBase.Name
End Get
Set(ByVal value As String)
If Not String.IsNullOrEmpty(value) Then
MyBase.Name = value
End If
End Set
End Property
End ClassNeste exemplo, a classe Student herda de Person e substitui o setter da propriedade Name. Adiciona uma verificação de validação antes de definir o nome, garantindo que ele não esteja vazio ou seja nulo.
O Iron Suite é um conjunto de ferramentas de pesquisa que aprimoram significativamente os recursos de desenvolvimento em C#. Inclui IronPDF, IronXL, IronOCR e IronBarcode. Cada uma dessas ferramentas tem uma finalidade única e pode ser integrada a vários aspectos do C#.
Saiba mais sobre o IronPDF , uma biblioteca que permite aos desenvolvedores criar, ler e editar documentos PDF em C#. Seja para converter HTML em PDF ou para gerenciar metadados de PDF por meio de getters e setters, o IronPDF oferece tudo o que você precisa.
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");
}
}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 ClassAo trabalhar com arquivos do Excel, a biblioteca IronXL Excel simplifica o processo de leitura e gravação. Essa ferramenta pode ser usada para manipular strings ou números inteiros públicos e privados de arquivos do Excel, de forma semelhante à manipulação de dados dentro de uma classe usando a mesma sintaxe de getters e setters em C#.
Explore o IronOCR , uma biblioteca de Reconhecimento Óptico de Caracteres que traduz imagens em texto pesquisável. Se sua aplicação envolve a leitura de texto de documentos digitalizados, os poderosos recursos do IronOCR podem ser facilmente integrados. Ele pode lidar com campos privados e descrições de string públicas, exatamente como você esperaria em uma classe Pessoa ou classe Aluno do exemplo de configuração anterior.
Descubra os recursos do IronBarcode para aplicações que exigem leitura e gravação de códigos de barras. Permite tanto o acesso direto aos dados do código de barras quanto a personalização por meio de propriedades automáticas, assim como os getters e setters usados na programação em C#.
O pacote Iron Suite integra-se perfeitamente ao desenvolvimento em C#, incluindo getters e setters. Essas ferramentas agregam valor a qualquer projeto C#.
Em resumo:
Getter and Setter: Eles ajudam a acessar e modificar os campos privados de uma classe.Auto Properties: Uma forma elegante de ter getters e setters automáticos com a ajuda de propriedades autoimplementadas.Access Modifiers: Eles ajudam a ajustar a acessibilidade das propriedades.A esta altura, você já deve ter um bom domínio de como usar getters e setters em C#.
O conjunto de ferramentas do Iron Suite oferece funcionalidades incríveis para desenvolvedores C#. Cada um desses produtos, incluindo IronPDF, IronXL, IronOCR e IronBarcode, vem com um período de avaliação gratuito das ferramentas da Iron Software , permitindo que você explore e integre essas poderosas bibliotecas em seus projetos sem nenhum investimento inicial.
Quando você estiver pronto para se comprometer, licenças individuais começam a partir de $999. Se você constatar que mais de uma dessas ferramentas atende às suas necessidades, poderá aproveitar a oportunidade de adquirir o pacote completo Iron Suite pelo preço de apenas duas licenças individuais.
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.
