4

Aprofundando os Tipos de valor e referência em C#

#.NET #C#
Rickelme Dias
Rickelme Dias

APROFUNDANDO TIPOS (VALOR & REFERÊNCIA)


Introdução:

Olá marujos, gostaria de ajudar com um assunto de extrema importância para continuar de forma mais estruturada os estudos. Pode me chamar de Rick, estou nesse barco de estudos com vocês e estudei hoje um pouco mais a fundo o tema, pois gostaria de descomplicar esses dois tipos em C#, que por hoje são: valor e referência.


Acompanhando as aulas de C#, me surgiu algumas dúvidas sobre o tema, como: O que seria esses tipos? Exemplos deles e aplicações? Então eu fui atrás disso em documentações e fóruns. Ao obter o entendimento, achei interessante compartilhar com vocês o resultado e como fiz esse estudo de forma "autodidata", uma vez que é muito importante manter sempre em desenvolvimento essa skill.


Tipos:

Em C#, uma linguagem onde devemos conhecer os tipos, existe a separação por dois tipos de dados, são eles: Valor (value types) e Referência (reference types), sendo as principais categorias de tipo (C# types).


Valor:

Começando pelo Tipo de Valor, value types possuem uma instância de seu tipo, a qual é armazenada na stack, ou seja, variáveis do tipo valor possuem seu dado alocado em uma determinada parte da memória, dessa forma ele tem um espaço diretamente alocado ao valor, por isso a ideia de: Variáveis de tipos de valor contém diretamente seus dados.

Observe o exemplo de código em um dos sites referência (citados no fim desse post):

using System;

public struct MutablePoint
{
    public int X;
    public int Y;

    public MutablePoint(int x, int y) => (X, Y) = (x, y);

    public override string ToString() => $"({X}, {Y})";
}

public class Program
{
    public static void Main()
    {
        var p1 = new MutablePoint(1, 2);
        var p2 = p1;
        p2.Y = 200;
        Console.WriteLine($"{nameof(p1)} after {nameof(p2)} is modified: {p1}");
        Console.WriteLine($"{nameof(p2)}: {p2}");

        MutateAndDisplay(p2);
        Console.WriteLine($"{nameof(p2)} after passing to a method: {p2}");
    }

    private static void MutateAndDisplay(MutablePoint p)
    {
        p.X = 100;
        Console.WriteLine($"Point mutated in a method: {p}");
    }
}

/* === OUTPUT ESPERADO ===
    L1 => P1: (1, 2)
    L2 => P2: (1, 200)
    L3 => Mutate: (100, 200)
    L4 => P2 após método Mutate: (1, 200)
*/

Ao executar do código, as ações do P2 voltar ao valor anterior meio que "ignorando" o p.X atribuido em MutateAndDisplay só é possível, pois a característica do tipo de valor diz que se você atribui-lo a outra variável, o valor é copiado diretamente e as duas variáveis ​​funcionam independentemente. Tipo de Valor:

value_type
    : struct_type
    | enum_type
    ;


struct_type
    : type_name
    | simple_type
    | nullable_type
    ;


simple_type
    : numeric_type
    | 'bool'
    ;


numeric_type
    : integral_type
    | floating_point_type
    | 'decimal'
    ;


integral_type
    : 'sbyte'
    | 'byte'
    | 'short'
    | 'ushort'
    | 'int'
    | 'uint'
    | 'long'
    | 'ulong'
    | 'char'
    ;


floating_point_type
    : 'float'
    | 'double'
    ;


nullable_type
    : non_nullable_value_type '?'
    ;


non_nullable_value_type
    : type
    ;


enum_type
    : type_name
    ;


Referência:

Agora que entendemos o tipo de valor fica mais simples comparar com o Tipo de Referência. O tipo de referência, como o nome já diz, mantém um valor de endereço referênciando. Como possibilidade, duas variáveis podem ter o mesmo endereço, portanto uma alteração feita em var x que tenha o mesmo endereço apontado por var y, irá alterar as duas vars. Explicando de forma um pouco mais visual:

Endereco0000 = "Hi"
Var X => Endereco0000;
Var Y => Endereco0000;

  Se X sofrer uma alteração de "Hi" para "Hello", Y também será "Hello".

As variáveis de tipo referência tem seus dados armazenados na heap (gerenciada pelo Garbage Collector). Tipo de Referência:

reference_type
    : class_type
    | interface_type
    | array_type
    | delegate_type
    ;


class_type
    : type_name
    | 'object'
    | 'dynamic'
    | 'string'
    ;


interface_type
    : type_name
    ;


array_type
    : non_array_type rank_specifier+
    ;


non_array_type
    : type
    ;


rank_specifier
    : '[' dim_separator* ']'
    ;


dim_separator
    : ','
    ;


delegate_type
    : type_name
    ;


Conclusão:

Conhecer e saber fazer bom uso dos tipos é de extrema importância para base de um bom programador, logo noto isso e busco fortificar! Ser um autodidata e aprofundar esses conhecimentos será de grande desenvolvimento profissional, podendo trabalhar com qualidade no gerênciamento de memória.

Para aqueles que se interessaram vou deixar todo material de base dos meus estudos para aprofundamento do tema nas referências, espero ter ajudado! Caso queira adicionar comentários para alterações nesse artigo estou totalmente aberto as críticas construtivas.

Quem gostar do tema e se interessar por trocar assuntos ou agradecimentos, estou disponivel em redes como LinkedIn, basta clicar: Rickelme Dias.

Gostaria de ressaltar que o principal fator desse artigo, além do desenvolvimento de conhecimento, é impulsionar nossa skill autodidata e gerar mais motivação aos Devs!


Referências de Base:

Tipos

Tipos de valor

Tipos de referência

Tipos de dados em C#


Adoraria a interação de todos para poder fortificar o conhecimento! Até.

1
50

Comentários (1)

1
Paulo Silva

Paulo Silva

18/03/2021 11:18

Cara muito bom, eu estava justamente buscando entender essa aula! Obrigado por compartilhar! É sempre ótimo ver outros pontos de vistas e narrativas. Somente o fato de tu querer ajudar com o post já clareia as ideias. A leitura minuciosa da documentação já é um grande esclarecedor, mas se não tivermos cooperação/interação do que adianta?


;D valeu marujo!



A Tour of C# - C# Guide | Microsoft Docs Essa é a documentação MUST READ de C#! pela MS. Ótima leitura, e contéudo bastante agregador, para todos que estão iniciando com programação assim como eu. (recomendo usar o navegador "Edge" pois habilita melhor leitura do conteúdo, facilmente traduzido com o clique direito do mouse. Boa leitura ;)

Um desenvolvedor em constante desenvolvimento.