outro fundamento importante pra gente conhecer é como funciona a memória hiip vimos préviamente ali a memória stack que na memória stack existem alocações e escopos onde a gente aloca ali variáveis definições de métodos os métodos que você vai rodar as variáveis internas também que tem o seu escopo previamente definido e rapidamente destruído e também apontamento de memória certo mas no dia a dia quando a gente trabalha também com software Seja lá qual for o software que a gente vai desenvolver a gente costuma trabalhar também com classes e tudo mais né para fazer a modelagem ali
do nosso domínio dos nossos dados e existe uma área de memória que lida diretamente com essa gestão vamos falar assim com essa alocação de memória desses objetos maiores eu falei previamente que a memória stc éa é uma memória de menor capacidade então então sendo uma memória um pouco mais rápida ela tem menos capacidade e o objetivo dela realmente não é guardar objetos maiores quando eu falo objetos maiores a alocação de memória por exemplo de uma classe ela é substancialmente né ela precisa muito mais espaço de memória do que a stack então aqui a gente vai
falar um pouquinho sobre o fundamentos da memória hiip que é um tema bem importante aqui para você conhecer caso você não saiba mas é de extrema importância você conhecer a memória hiip quando você inicializa ali um novo processo no seu runtime do dnet seja no dnet Framework seja no dnet Core e agora enquanto a gente grava essa aula aqui estamos indo já pro dnet 9 já tá em preview mas basicamente é quase que a mesma coisa o conceito tá porque o Framework foi evoluindo mas o conceito de alocação de memória ali ele se Manteve ao
longo do tempo então basicamente quando você inicia um novo processo runtime vai fazer uma reserva e vai ver primeiramente se existe exe espaço na memória existindo espaço na memória ele vai alocar Ali vai fazer uma reserva em alguma região pro endereço de memória para rodar aquele processo Então imagina que você tá fazendo um console app você dá ali um start ou você publicou isso em algum lugar então aquele processo vai iniciar uma tred vai se iniciar e a primeira coisa que vai ser feita vai ser isso uma locação de memória tá esse espaço de endereço
de memória que a gente tá falando aqui que é reservado é comumente chamado também de memória hiip ou hiip Ger AD porque o Framework dnet ele é um Framework gerenciado basicamente no ciclo todo ali então ele mantém basicamente um ponteiro pro endereço a qual o próximo objeto da hiip vai ser alocado Então imagina que você começou um console app E aí você tem uma duas três classes então cada vez que você vai instanciando essas classes ele vai olhando ali um espaço de memória disponível fazendo essa alocação colocando ali os ponteiros necessários E é assim que
ele vai Ger gerenciando mais ou menos ali a memória hiip tá então quando esse app que você tá criando vai criar o primeiro tipo de referência a memória sempre é alocada nesse endereço base vamos falar assim e é disponibilizado ali para que o Framework saiba Qual método que tá sendo chamado qual classe que está sendo instanciado e tudo mais isso tudo por debaixo dos panos tá nós como programadores aqui a gente não tem acesso a isso ali durante tempo de desenvolvimento e para falar a verdade a gente nem precisa disso explicando um pouquinho melhor na
outra aula eu falei ali né na na na outra explicação sobre a memória stack então a gente fez um exemplo do do draw Square ali então aqui nessa região aqui da stack basicamente a gente tá falando que quando a gente é é colocado né um novo frame aqui ele vai ter ali os métodos as referências e tudo mais as variáveis e o retorno né agora uma coisa interessante é você já se perguntou o que que acontece ali quando você faz um Class dá um nome igual New Class esse keyw New que a gente tem no
dnet ele serve geralmente né e especificamente na verdade para fazer isso né para ele pegar e criar a Instância daquela classe em uma outra área da memória Então nesse caso aqui a gente tá falando da memória stack desse lado aqui e agora tem uma nova área de memória que é a memória hiip a hiip ela contém né ela Gerencia um espaço maior de memória e essa alocação aqui ela é feita para esses outros tipos de objeto Então deixa eu mostrar na prática aqui o que a gente acabou de fazer então aquele mesmo projeto que a
gente estava trabalhando a gente tinha um stack eu criei aqui um exemplo da hiip né então eu basicamente a diferença que a gente tem com aquela outra classe é que aqui a gente estava fazendo aquele draw Line né e e e a gente exemplificou aqui passando os parâmetros e fazendo também a chamada da do método de forma recursiva a diferença é que aqui a gente fez um exemplo só para mostrar que deu um stack overflow E essas alocações de memória estavam fe feitas na stack agora aqui eu fiz o código um pouquinho diferente né e
é só um código ilustrativo então basicamente o que que eu fiz aqui eu criei uma classe Line tá essa classe aqui tem as suas propriedades tem os métodos e tudo mais né aqui a gente tá instanciando aqui quando instancia ele vai entrar nesse código e fazer as alocações da as variáveis aqui X1 para X1 e tudo mais e aqui eu fiz um pouquinho diferente né então aqui eu fiz um draw Square né Vamos desenhar o quadrado aqui e a diferença aqui desse código é que eu tô criando esse objeto Lines aqui tô criando eh alguns
arrs aqui de line e tô dando a Instância aqui de Line determinando Qual é o tamanho nesse momento aqui que eu faço esse Nil Aqui é onde aquele processo que eu acabei de falar vai acontecer então a alocação de memória vai acontecer no dnet basicamente o dnet vai pegar e vai reservar espaço na memória Tá mas O interessante é que aqui a gente tem uma mistura dos dois mundos agora aqui na stack a gente mostrou que essa locação de memória ela vai ser feita só na memória stack certo porque aqui ele tá chamando basicamente eh
os inteiros e pegando as definições desses métodos aqui Aqui já é um pouco diferente aqui a gente teria também a mesma coisa né A gente vai fazer as alocações aqui dessas variáveis aqui dessas variáveis internas que estão válidas só dentro desse escopo mas ao mesmo tempo ele também começou a fazer a locação de memória essa locação de memória dessa classe Line aqui é um pouco diferente então aqui eu vou ter pedaço ou referências desse código em uma parte de memória e vou ter referências desse código né alocações Desse código em outra fia algo similar a
isso então ficaria como eu falei algo similar a isso aqui a gente tem aqui o nosso código que foi instanciado lá na stack pras variáveis pra chamada dos métodos e tudo mais ele vai dar um push e logo em seguida ele vai fazer isso aqui ele vai colocar Line aqui na memória hiip né aquele a rade Line que a gente criou vai pegar essas referências aqui da dos indexes que a gente colocou 0 1 2 e 3 e para cada um desses também vai fazer uma referência para um objeto criado né então ou seja dentro
desse objeto aqui eu tenho referências que estão colocadas aqui né algumas variáveis principalmente do tipo inteiro que a gente colocou e ele faz essa referência para cá ou seja a memória stack tá lidando ali com os tipos primitivos né que é inteiro e tudo mais e aí ele alocou esse Line array lá do outro lado aqui por quê Porque o o tipo da classe por exemplo ele é um tipo que tem uma locação maior Então como que o Framework faz para gerenciar isso ele gerencia desse lado aqui essas informações esses metadados E essas alocações de
memória na hiip só que por outro lado aqui ficaria basicamente as referências então ele teria aqui o endereço de memória vamos falar assim X1 2 qualquer número aleatório ali que o nosso processo do Framework vai dar e ele busca essa referência tá agora aqui tem outro ponto o que que acontece eh quando esse método que tá na hiip aqui ele é executado por exemplo o draw Lines a gente entrou fez o draw Lines ele fez o que tinha que fazer aquele método e retornou inteiro quando isso acontece esse espaço de memória aqui ele vai ser
liberado ele é muito mais rápido a liberação de memória aqui então o que acontece aqui é que essas informações que estão na hiip elas vão ficar literalmente orfão durante um tempo tá não existe desalocação de memória aqui na hiip instantaneamente mente então aquele Meu método draw Line ou draw polígono lá que a gente criou que que ele vai fazer ele vai executar o método pegar os valores da variáveis fazer os trabalhos que tem que fazer ali para fazer uma soma alguma coisa assim e beleza e aí acabou o escopo dele ele vai fazer uma limpeza
de memória aqui na stack só que a limpeza de memória na hiip não acontece automaticamente Isso aqui vai ser marcado como desalocada tá então esse esse código aqui é essa alocação desse código que foi feita ele não vai ser excluído de novo ele vai ser desalocada ele vai ser marcado como desalocada mas isso aqui ainda existe em memória fazendo um paralelo paraa performance imagina o seguinte imagina que você faz a locação de um monte de string por exemplo né dentro de um método ali né ou de uma classe que consome ou que manipula muito string
isso vai tudo direto aqui pra sala de memória paraa hiip e aí em algum momento você chama de novo aquele novo método então Ou seja você vai enchendo a sua memória hiip de coisa só que não necessariamente quando você não tá usando mais aquele método Ou aquele trecho de código significa que aquele código não tá mais na memória então É como se você tivesse que começar a programar pensando nas alocações de memória que você vai fazer pros tipos de dados que você vai trabalhar e aqui um disclaimer né basicamente o os códigos que usam ali
inteiros e tudo mais na stec em alguns cenários eles são mais rápidos do do que os códigos que usam objetos na hip Então o que eu quero dizer aqui é que aquele primeiro código que a gente fez do draw Line aqui ele se eu fosse fazer uma comparação de performance aqui logicamente o código é mais enxuto e tudo mais mas eh se eu não fizesse alocação nenhuma de classes aqui se eu não criasse classe que nem eu fiz aqui esse código tende a ser mais rápido porque ele vai trabalhar só na memória stack a memória
stack memória menor e há uma memória que é mais rápida Então por esse motivo eu teria um pouco mais de performance aqui e o Draw Line aqui quando eu fiz esse código eu fiz um mix então aqui eu tenho o código que parte dele vai ser alocado na stack parte dele vai ser alocado na hip e justamente porque na hip eu tô criando aqui novas alocações tô criando classes estruturas e tudo mais então assim o dnet sendo um Framework Ele sempre vai adiantar a limpeza de memória Então nesse cenário aqui que eu acabei de passar
para vocês o que que acontece quando isso aqui sai de escopo né quando memória stack s scope ou seja eu chamei o método get user by ID passei o ID do usuário eu vou alocar o ID na stack E aí dentro daquele método por exemplo eu tenho uma classe de usuário ali que eu vou formatar vou criar um New user para pegar dados de banco de dados e alocar dentro da minha classe Então seria mais ou menos isso ele vai colocar essa informação aqui e vai colocar a classe na memória hiip legal a memória hiip
ela ainda continua lá durante um tempo tá mesmo que o método já foi executado e ela vai ser marcada pra limpeza depois e aí o que que acontece em algum momento o Framework o dotnet ele vai executar um processo chamado garbage collector Porque a partir do momento que aqui ó eu fiz essa limpeza aqui isso aqui eu tô indicando pro Framework que isso aqui já tá órfão e eu não preciso mais dele então isso aqui vai ser marcado pra limpeza certo posso limpar isso aqui Não no naquele momento né mas vai passar um outro processinho
agora que é o garbage collector E aí o garbage collector vai desalocar aquela memória para mim que tá lá na hiip esse processo ele é muito comum a gente não costuma a ver isso no dia a dia mas em cenários de performance a gente precisa entender a locação de memória a gente precisa entender que existe um processo do próprio Framework que vai lá e vai fazer a desalocação de memória ali que é aquela memória que foi desalocada em algum momento e tá lá e aí eu quero que vocês reflitam isso quero que você vocês pensem
em cenários onde vocês fazem muita alocação de classe muita alocação de string e se realmente dá para você otimizar aquele código de alguma forma mais eficiente para que isso aconteça e que o garbage collector seja menos possível utilizado durante o processo ali e aí um resumo da memória hiip é basicamente isso a keyw ali a palavra-chave new ela sempre cria objetos na hip os códigos que são objetos eles são quase sempre menos performático se a gente comparar eles com a steack então o exemplo que foi dado ali eu tinha inteiros e tava tentando desenhar ali
um quadrado Só passando inteiro Ok só vou rodar na memória stack costuma ser mais rápido porque eu não fiz a locação na memória hiip quant as variáveis ficam na stack elas vão ficar fora de escopo por algum motivo né ou seja Já chamei o método já utilizei os objetos correspondentes na hiip aquela alocação de classe lá eu fiz o new Class eles vão perder a referência mas não são destruídos e o dnet como eu falei eventualmente vai chamar um processo garbage collector para desalocar e remover as referências na memória isso impacta onde consumo de memória
então na sua aplicação se você tá vendo altos consumos de memória se eventualmente você em períodos de pico você vê que realmente ali tá gastando muita memória se a sua aplicação faz muito uso de memória vale a pena você dar uma olhada pro seu código e entender eh Que tipo de objeto que você tá alocando como que você tá alocando isso e se não dá para você reaproveitar um bom exemplo é o string builder né o método string builder ele usa uma referência de string que já foi criado ao invés de ficar criando novas Strings
Strings é caro pro Framework Então desse jeito tem algumas dicas aí que a gente vai fazendo ao longo do curso aqui para vocês verem quais são as melhores formas de gerenciar memória também