Partilhar via

Tutorial: Criar tipos em C#

Este tutorial ensina-te a criar tipos em C#. Você escreve pequenas quantidades de código e, em seguida, compila e executa esse código. O tutorial contém uma série de lições que exploram diferentes tipos de tipos em C#. Estas lições ensinam os fundamentos da linguagem C#.

Os tutoriais anteriores trabalhavam com texto e números. Cadeias e números são tipos simples: cada um armazena um único valor. À medida que seus programas crescem, você precisa trabalhar com estruturas de dados mais sofisticadas. O C# fornece diferentes tipos de tipos que você pode definir quando precisar de estruturas de dados com mais campos, propriedades ou comportamento. Vamos começar a explorar esses tipos.

Neste tutorial, você:

  • Cria e manipula tipos de tuplas.
  • Crie tipos de registo.
  • Aprenda sobre struct, classes e tipos de interface.

Pré-requisitos

Deve ter um dos seguintes:

Para usar o CodeSpaces, precisas de uma conta no GitHub. Se ainda não tiver uma, pode criar uma conta gratuita no GitHub.com.

Tuplas

Para iniciar um GitHub Codespace com o ambiente de tutorial, abra uma janela do navegador para o repositório tutorial codespace. Selecione o botão verde de Código e o separador Codespaces . Depois seleciona o + sinal para criar um novo Codespace usando este ambiente. Se completaste outros tutoriais desta série, podes abrir esse espaço de código em vez de criares um novo.

  1. Quando o seu espaço de código carregar, crie um novo ficheiro na pasta tutoriais chamado tuples.cs.

  2. Abra o seu novo ficheiro.

  3. Digite ou copie o seguinte código para tuples.cs:

    var pt = (X: 1, Y: 2);

var slope = (double)pt.Y / (double)pt.X;
Console.WriteLine($"A line from the origin to the point {pt} has a slope of {slope}.");

  4. Execute o seu programa escrevendo os seguintes comandos na janela do terminal integrado:

    cd tutorials
dotnet tuples.cs

    As tuplas são uma sequência ordenada de valores com um comprimento fixo. Cada elemento de uma tupla tem um tipo e um nome opcional.

    Sugestão

    Ao explorar C# (ou qualquer linguagem de programação), você comete erros ao escrever código. O compilador encontra esses erros e os relata para você. Quando a saída contém mensagens de erro, olhe atentamente tanto para o código de exemplo quanto para o seu código para identificar o que deve ser corrigido. Também podes pedir ao Copilot para encontrar diferenças ou identificar erros. Esse exercício ajuda você a aprender a estrutura do código C#.

  5. Adicione o seguinte código após o código anterior para modificar um membro da tupla:

    pt.X = pt.X + 5;
Console.WriteLine($"The point is now at {pt}.");

  6. Você também pode criar uma nova tupla que é uma cópia modificada do original usando uma with expressão. Adicione o seguinte código após o código existente e digite dotnet tuples.cs na janela do terminal para ver os resultados:

    var pt2 = pt with { Y = 10 };
Console.WriteLine($"The point 'pt2' is at {pt2}.");

    A tupla pt2 contém o X valor de pt (6) e pt2.Y é 10. As tuplas são tipos estruturais. Em outras palavras, os tipos de tupla não têm nomes como string ou int. Um tipo de tupla é definido pelo número de membros, referido como aridade, e os tipos desses membros. Os nomes dos membros são por conveniência. Você pode atribuir uma tupla a uma tupla com a mesma aridade e tipos, mesmo que os membros tenham nomes diferentes.

  7. Pode adicionar o seguinte código depois do código que já escreveu:

    var subscript = (A: 0, B: 0);
subscript = pt;
Console.WriteLine(subscript);

  8. Experimenta escrevendo dotnet tuples.cs na janela do terminal. A variável subscript tem dois membros, ambos inteiros. Ambos subscript e pt representam instâncias do mesmo tipo de tupla: uma tupla que contém dois int membros.

    Tuplas são fáceis de criar: você declara vários membros entre parênteses. Todas as declarações seguintes definem diferentes tuplas com diferentes aridades e tipos de membros.

  9. Adicione o seguinte código para criar novos tipos de tupla:

    var namedData = (Name: "Morning observation", Temp: 17, Wind: 4);
var person = (FirstName: "", LastName: "");
var order = (Product: "guitar picks", style: "triangle", quantity: 500, UnitPrice: 0.10m);

  10. Tente esta alteração escrevendo dotnet tuples.cs novamente na janela do terminal.

Embora as tuplas sejam fáceis de criar, as suas capacidades são limitadas. Os tipos de tupla não têm nomes, então você não pode transmitir significado para o conjunto de valores. Os tipos de tupla não podem adicionar comportamento. C# tem outros tipos de tipos que você pode criar quando seu tipo define comportamento.

Criar tipos de registro

As tuplas são ótimas para aqueles momentos em que você quer vários valores na mesma estrutura. São leves, e podes defini-los à medida que os utilizas. À medida que o teu programa cresce, podes descobrir que usas o mesmo tipo de tupla em todo o teu código. Se a tua aplicação funciona no espaço de gráficos 2D, as tuplas que representam pontos podem ser comuns. Quando encontrares este padrão, podes declarar um record tipo que armazena esses valores e oferece mais capacidades.

  1. Adicione o seguinte código para declarar e use um record tipo para representar um Point:

    public record Point(int X, int Y);

    O código anterior deve estar no final do ficheiro fonte. Declarações de tipo como record devem seguir declarações executáveis numa app baseada em ficheiros.

  2. Adicione o seguinte código antes da record declaração:

    Point pt3 = new Point(1, 1);
var pt4 = pt3 with { Y = 10 };
Console.WriteLine($"The two points are {pt3} and {pt4}");

    Uma declaração record é uma única linha de código para o tipo Point que armazena os valores X e Y em propriedades de leitura apenas. Você usa o nome Point onde quer que use esse tipo. Tipos nomeados corretamente, como Point, fornecem informações sobre como o tipo é usado. O código adicional mostra como usar uma with expressão para criar um novo ponto que seja uma cópia modificada do ponto existente. A linha pt4 = pt3 with { Y = 10 } diz "pt4 tem os mesmos valores que pt3, exceto que Y é atribuído o valor 10". Pode-se adicionar qualquer número de propriedades a serem alteradas numa única expressão with.

    A declaração anterior record é uma única linha de código que termina em ;. Você pode adicionar comportamento a um record tipo declarando membros. Um membro de registo pode ser uma função ou vários elementos de dados. Os membros de um tipo estão na declaração de tipo, entre { e } caracteres.

  3. Apague o ; e adicione as seguintes linhas de código após a declaração record:

    {
    public double Slope() => (double)Y / (double)X;
}

  4. Adicione o seguinte código antes da record declaração, após a linha que contém a with expressão:

    double slopeResult = pt4.Slope();
Console.WriteLine($"The slope of {pt4} is {slopeResult}");

  5. Digite dotnet tuples.cs na janela do terminal para executar esta versão.

    Você acrescentou formalidade à tupla representando um X e Y valor. Fizeste um record que definia um tipo com nome e incluía um membro para calcular a inclinação. Um record tipo é uma abreviação de record class: um class tipo que inclui comportamento extra.

  6. Você pode modificar o Point tipo para torná-lo um record struct também:

    public record struct Point(int X, int Y)

    A record struct é um struct tipo que inclui o comportamento extra adicionado a todos os record tipos.

  7. Experimenta esta versão escrevendo dotnet tuples.cs na janela do terminal.

Tipos de estrutura, classe e interface

Todos os tipos concretos nomeados em C# são tipos class, struct ou record. A class é um tipo de referência. A struct é um tipo de valor. As variáveis de um tipo de valor armazenam o conteúdo da instância diretamente na memória. Em outras palavras, um record struct Point armazena dois inteiros: X e Y. As variáveis de um tipo de referência armazenam uma referência ou um ponteiro para a memória onde está a instância. Em outras palavras, um record class Point armazena uma referência a um bloco de memória que contém os valores para X e Y.

Na prática, isso significa que os tipos de valor são copiados quando atribuídos, mas uma cópia de uma instância de classe é uma cópia da referência. Essa referência copiada refere-se à mesma instância de um ponto, com o mesmo armazenamento para X e Y.

O record modificador instrui o compilador a escrever vários membros para você. Você pode saber mais no artigo sobre tipos de registro na seção de fundamentos.

Ao declarar um record tipo, você declara que seu tipo deve usar um conjunto padrão de comportamentos para comparações de igualdade, atribuição e cópia de instâncias desse tipo. Os registros são a melhor escolha quando o armazenamento de dados relacionados é a principal responsabilidade do seu tipo. À medida que se adicionam mais comportamentos, considere usar tipos struct ou class, sem o modificador record.

Use struct tipos para tipos de valor quando precisar de comportamentos mais sofisticados, mas a responsabilidade principal é armazenar valores. Use class tipos para usar idiomas orientados a objetos como encapsulamento, herança e polimorfismo.

Você também pode definir interface tipos para declarar contratos comportamentais que diferentes tipos devem implementar. Ambos os tipos struct e class podem implementar interfaces.

Normalmente, você usa todos esses tipos em programas e bibliotecas maiores. Depois de instalar o SDK do .NET, você pode explorar esses tipos usando tutoriais sobre classes na seção de fundamentos.

Completaste o tutorial "Criar tipos em C#". Você pode saber mais sobre tipos em C# nos seguintes artigos:

Recursos de limpeza

O GitHub apaga automaticamente o seu Codespace após 30 dias de inatividade. Se planeia explorar mais tutoriais nesta série, pode deixar o seu Codespace provisionado. Se estiver pronto para visitar o site .NET para descarregar o SDK .NET, pode eliminar o seu Codespace. Para eliminar o seu Codespace, abra uma janela do navegador e navegue até aos seus Codespaces. Deves ver uma lista dos teus codespaces na janela. Selecione os três pontos (...) na entrada para o espaço de código do tutorial de aprendizado e selecione apagar.

Próximo passo

Desvios e ciclos

  • Last updated on