• P.O.O
• Conceitos de P.O.O

O tipo Struct é um tipo de dados complexo composto de outros tipos de dados. Diferente de linguagens como C, em C# tipo Struct foi extendido com a adição de suporte a construtor, métodos e herança.

Para declararmos uma struct utilizamos a sintaxe abaixo. Seus membros ou campos são delimitados por { e }, terminados por (;) e possuem modificador de acesso.

Sintaxe

modificador_acesso struct nome_struct
{
  modificador_acesso tipo_dado nome_membro1;
  modificador_acesso tipo_dado nome_membroN;
}

Exemplo 1

using System;
public class Program 
{
  public struct MinhaStruct
  {
    public int codigo;
    public string nome;
  }
  
  static void Main() {

    //omitido
  }
}

Saída

-

A palavra reservada public é utilizada para que os membros sejam acessados de qualquer classe onde uma struct é utilizada. Public e outros modificadores de acessos serão vistos em C# POO: Atributos e Encapsulamento.

A declaração de variáveis struct é feita de forma semelhante ao que foi visto. Utilizamos o nome da struct seguida do nome da variável. A palavra reservada new é usada para iniciar uma struct.

Sintaxe

nome_struct nome_variavel; //não iniciada

nome_struct nome_variavel = new nome_struct(); //iniciada valores default 

Exemplo 2

using System;
public class Program 
{
  public struct MinhaStruct
  {
    public int codigo;
    public string nome;
  }
  
  static void Main() {

    MinhaStruct ms;
    MinhaStruct ms2 = new MinhaStruct();
  }
 
}

Saída

-

Para acessarmos os membros de uma struct, utilizamos o operador de acesso a membros (.) seguido do nome do membros desejado. Esse acesso é usado tanto para recuperar seu valor quanto para alterar:

Sintaxe

nome_struct.nome_membro; //acesso

nome_struct.nome_membro = valor; //atribuição 

Exemplo 3

using System;
public class Program 
{
  public struct MinhaStruct
  {
    public int codigo;
    public string nome;
  }
  
  static void Main() {

    MinhaStruct ms;
    ms.codigo = 999;
    ms.nome = "teste";
    
    Console.WriteLine(ms.codigo);
    Console.WriteLine(ms.nome);
  }
}

Saída

999
teste

Como o tipo de dado struct não é referenciado, sempre que atribuimos uma variável struct à uma outra variável do mesmo tipo, uma cópia é feita automaticamente.

Sintaxe

variavel_struct_destino = variavel_struct_origem; 

Exemplo 4

using System;
public class Program 
{
  public struct MinhaStruct
  {
    public int codigo;
    public string nome;
  }
  
  static void Main() {

    MinhaStruct ms = new MinhaStruct(),
                ms2 = new MinhaStruct();
    
    ms.codigo = 999;
    ms2 = ms; //cópia
    ms2.codigo = 888; //alteração cópia
    
    Console.WriteLine(ms.codigo);
    Console.WriteLine(ms2.codigo);
  }
}

Saída

999
888

C# fornece a palavra reservada with que nos permite fazer uma cópia de uma struct, usada como base ou origem, e escolhendo quais campos desejamos copiar ou quais desejamos manter como na original.

Sintaxe

nova_var_struct = var_struct_origem with 
                { 
                    campo1 = novo_valor1, 
                    campo2 = novo_valor2,
                    //campos omitidos mantidos
                }; 

Exemplo 5

using System;
public class Program
{
	public struct Test
    {
		public int cod;
		public string desc;
		
}

	public static void Main()
	{
		Test tst1 = new Test();
		tst1.cod = 1;
		tst1.desc = "teste";
		
		Test tst2;
		
		tst2 = tst1 with { cod = 2}; //desc mantido
		
		Console.WriteLine("{0} \n{1}", tst1.desc, tst2.desc);	
	}
}

Saída

teste
teste

Em C#, o tipo de dado struct suporta algumas características O.O, como construtor, métodos e herança. Esses assuntos serão vistos com mais detalhes em C#: P.O.O.

Sintaxe: construtor

modificador_acesso nome_struct(<lista_parametros>)
{
    //atribuição
} 

No exemplo abaixo, declaramos um método construtor para iniciar nossa struct com valores passados como argumento.

Exemplo 6

using System;
public class Program 
{
  public struct MinhaStruct
  {
    public int codigo;
    
    public MinhaStruct(int c)
    {
        codigo = c;
    }
  }
  
  static void Main() 
  {
    MinhaStruct ms = new MinhaStruct(999);
    Console.WriteLine(ms.codigo);
  }
}

Saída

999

Para a declaração de métodos dentros de structs, seguimos a sintaxe abaixo:

Sintaxe: método

modificador_acesso tipo_retorno nome_metodo(<lista_parametros>)
{
    //corpo
} 

O acesso ao método é feito utilizando o operador de acesso a membros (.):

Sintaxe

nome_struct.nome_metodo(lista_argumentos); 

Exemplo 7

using System;
public class Program 
{
  public struct MinhaStruct
  {
    //membros omitidos
    public void metodo(int valor)
    {
        Console.WriteLine(valor);
    }
  }
  
  static void Main() {
    
    MinhaStruct ms = new MinhaStruct();
    ms.metodo(999);
  }
}

Saída

999

A herança utilizada com struct podem ser feitas de forma semelhante à classes. A diferença é que a struct não possui suporte a herança de classes, apenas interfaces. O assunto interface será visto com mais detalhes em C# POO: Interface.

Sintaxe

modificador_acesso nome_struct: nome_interface
{
    //corpo
} 

Exemplo 8

using System;
public class Program
{
	public interface ITeste
    { 
		string metodo(int val);
	}
	
	public struct Teste: ITeste
    {
        //campos omitidos

		public string metodo(int val){
			return val.ToString();
		}
	}
	public static void Main()
	{
		Teste teste = new Teste();
		Console.WriteLine(teste.metodo(999));
	}
}

Saída

999

A forma mais básica para comparação entre structs é utilizando a comparação campo a campo. Os operadores relacionais podem ser utilizados.

Sintaxe

nome_variavel1.nome_campo1 operador nome_variavel1.nome_campo1 

Onde

operador: operadores relacionais

Exemplo 9

using System;
public class Program
{
	public struct Test
    {
		public int cod;
		public string desc;
		
		public Test(int c, string d)
		{
			cod = c;
			desc = d;
		}
	}

	public static void Main()
	{
		Test tst1 = new Test(1,"str");
		Test tst2 = new Test(1,"str");
		
		bool iguais = tst1.cod == tst2.cod && 
					  tst1.desc == tst2.desc;
		
		Console.WriteLine("tst1 == tst2 ?\n{0}",iguais);	
	}
}

Saída

tst1 == tst2 ?
True

1. 08/08/2025 - revisão 2 - Ajustes: pontuais, Objetivos e sintaxes; Adição: Cópia c/ 'with' e 'Comparando'
2. 14/10/2024 - revisão 1 - Melhorias e ajustes pontuais
3. 12/03/2024 - versão inicial