Ícone de mensagem
Ir para o conteúdo do rodapé
  1. IronPDF
  2. Blog do IronPDF
  3. Ajuda do .NET
  4. Getter e Setter em C#
AJUDA DO .NET

Getters e setters em C# (Como funcionam para desenvolvedores)

Curtis Chau
Curtis Chau
Atualizado:

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.

Introdução aos Getters e Setters

O que são Getters e Setters?

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.

Por que precisamos deles?

Imagine ter um public class Car com uma propriedade private string description. Se alguém de fora desta classe quiser saber a descrição, não poderá acessá-la diretamente porque é privada. É aí que entra o papel dos getters e setters.

Um método 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.

Modificadores de acesso

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.

Getter e Setter simples

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());
    }
}
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

Friend Class Program
	Shared Sub Main()
		Dim person As New Person()
		person.SetName("John")
		Console.WriteLine(person.GetName())
	End Sub
End Class
$vbLabelText   $csharpLabel

No class Person acima, temos um getter (GetName) e um setter (SetName) para a propriedade name. Ao executar o método static void Main, ele imprimirá "John", pois definimos esse valor para o nome usando o método setter.

Propriedades implementadas automaticamente

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 fornecem 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
    }
}
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 Class
$vbLabelText   $csharpLabel

Na classe Student, a propriedade Name é tanto um getter quanto um setter, ambos implementados automaticamente. O compilador C# cria um campo private string name nos bastidores, e a propriedade Name fornece acesso a esse campo.

Modificadores de acesso avançados em propriedades

Propriedades somente leitura

À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 somente leitura string Description à 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 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(ByVal name As String, ByVal description As String)
		Me.Name = name
		Me.Description = description
	End Sub
End Class
$vbLabelText   $csharpLabel

Neste exemplo, a propriedade Description só pode ser definida dentro do construtor da classe Person. Uma vez configurado, não pode ser modificado externamente.

Setters particulares

Às vezes, você pode querer permitir que a propriedade seja lida de fora da classe, mas definida apenas de dentro da classe. Isso é conseguido 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
    }
}
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 Class
$vbLabelText   $csharpLabel

Na propriedade class Program, a propriedade Description possui um private set, o que significa que ela não pode ser alterada de fora da classe, garantindo a integridade dos dados.

Herança e Sobrescrita

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 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 Class
$vbLabelText   $csharpLabel

Neste exemplo, a classe Student herda de Person e sobrescreve o método 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.

Apresentando o Iron Suite para aprimorar seu desenvolvimento em C

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#.

IronPDF - Uma poderosa ferramenta de gerenciamento de PDFs

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");
    }
}
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

IronXL - Manipulação do Excel Simplificada

Ao 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#.

IronOCR - Reconhecimento Óptico de Caracteres 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.

IronBarcode - Biblioteca de Leitura e Gravação de Códigos de Barras

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#.

Iron Suite e Getters e Setters

O pacote Iron Suite integra-se perfeitamente ao desenvolvimento em C#, incluindo getters e setters. Essas ferramentas agregam valor a qualquer projeto C#.

Conclusão

Em resumo:

  1. Getter and Setter: Eles ajudam a acessar e modificar os campos privados de uma classe.
  2. Auto Properties: Uma maneira elegante de ter getters e setters automáticos com a ajuda de propriedades autoimplementadas.
  3. 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 estiver pronto para se comprometer, as licenças individuais começam a partir de $799. 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.

Perguntas frequentes

Qual é a finalidade dos getters e setters em C#?

Em C#, getters e setters são usados para controlar o acesso às propriedades privadas de uma classe. Os getters recuperam o valor de uma propriedade, enquanto os setters permitem que uma propriedade seja modificada. Esse encapsulamento garante acesso seguro e controlado aos dados da classe.

Como os modificadores de acesso afetam a visibilidade das propriedades em C#?

Modificadores de acesso como public e private determinam a visibilidade e a acessibilidade das propriedades de uma classe em C#. Propriedades Public são acessíveis de qualquer lugar, enquanto propriedades private são restritas à classe em que foram declaradas.

O que são propriedades autoimplementadas em C#?

Propriedades autoimplementadas oferecem uma maneira abreviada de declarar propriedades em C#. Elas permitem definir uma propriedade sem escrever explicitamente um campo, getter e setter separados. O compilador cria automaticamente um campo de suporte para você.

Como criar uma propriedade somente leitura em C#?

Em C#, você pode criar uma propriedade somente leitura omitindo o método setter na declaração da propriedade. Isso significa que a propriedade só pode ser definida dentro da classe, como em um construtor, e não pode ser modificada externamente.

Como usar métodos setters privados em C#?

Em C#, os métodos setters privados permitem que uma propriedade seja modificada apenas dentro da classe em que foi declarada, ao mesmo tempo que permitem que código externo leia a propriedade. Isso é útil para manter a integridade dos dados, proporcionando acesso controlado.

É possível sobrescrever o comportamento de propriedades em classes derivadas em C#?

Sim, em C# você pode sobrescrever o comportamento de uma propriedade em classes derivadas marcando a propriedade na classe base como virtual e usando a palavra-chave override na classe derivada. Isso permite a personalização do comportamento dos métodos getter e setter.

Como converter HTML para PDF em C#?

Você pode usar o método RenderHtmlAsPdf do IronPDF para converter strings HTML em PDFs. Você também pode converter arquivos HTML em PDFs usando o RenderHtmlFileAsPdf .

Quais ferramentas estão disponíveis para aprimorar o desenvolvimento em C# com funcionalidades de PDF e código de barras?

O Iron Suite fornece ferramentas como o IronPDF e o IronBarcode, que aprimoram o desenvolvimento em C# oferecendo funcionalidades como gerenciamento de PDFs e leitura/gravação de códigos de barras. Essas ferramentas se integram perfeitamente a projetos C#.

O que torna o Iron Suite benéfico para desenvolvedores C#?

O Iron Suite é benéfico para desenvolvedores C#, pois oferece uma gama de ferramentas poderosas que se integram perfeitamente a projetos C#. Essas ferramentas fornecem funcionalidades avançadas, como gerenciamento de PDF, manipulação de Excel, recursos de OCR e leitura/gravação de código de barras.

Curtis Chau
Curtis Chau
  Converse agora mesmo com a equipe de engenharia.
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

Artigos relacionados

Teste grátis por 30 dias → Produto completo. Sem limites. Sem cartão. Teste gratuito

Equipe de suporte de ferro

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