O que é Lazy Loading?

O que é Lazy Loading?

[Edite depois de ler algumas respostas] Por que as pessoas usam esse termo com tanta frequência?

Digamos que você apenas use um conjunto de registros ASP / ADO e carregue-o com dados ou fonte de dados ADO.NET para um gridview.

Acho que deveria ter perguntado por que as pessoas usam o termo Lazy Loading, quais são os "outros" tipos deles?

É chamado de carregamento lento porque, como uma pessoa preguiçosa, você está adiando fazer algo que não quer. O oposto é o Eager Loading, em que você carrega algo imediatamente, muito antes de precisar dele.

Se você está curioso para saber por que as pessoas usam o carregamento lento, considere um aplicativo que leva muito tempo para iniciar. Este aplicativo provavelmente está carregando muito ... carregando coisas do disco, e fazendo cálculos e outras coisas, muito antes de ser necessário.

Compare isso com o carregamento lento, o aplicativo iniciaria muito mais rápido, mas na primeira vez que você precisar fazer algo que requer uma carga de longa duração, pode haver uma pequena pausa enquanto ele é carregado pela primeira vez. Assim, com o carregamento lento, você está amortizando o tempo de carregamento durante a execução de seu aplicativo ... e pode realmente evitar o carregamento de coisas que o usuário talvez nunca tenha a intenção de usar.

O Lazy Loading é uma prática de programação na qual você carrega ou inicializa um objeto apenas quando precisa dele pela primeira vez. Isso pode potencialmente dar a você um grande impulso de desempenho, especialmente se você tiver muitos componentes em seu aplicativo.

Como de costume, a Wikipedia tem mais detalhes.

O carregamento lento é um conceito em que atrasamos o carregamento da unidade do objeto até o ponto em que precisamos. Colocando em palavras simples o carregamento de objetos sob demanda, em vez de carregar os objetos desnecessariamente. Por exemplo, se você tiver uma classe "Cliente" que possui o objeto "Pedidos" agregado. Então, você gostaria de carregar os dados do cliente, mas os objetos de pedidos que gostaria de atrasar até que seu aplicativo precise deles.

Abaixo está um vídeo do youtube que demonstra como usar o carregamento lento, como podemos implementar o carregamento lento e as vantagens e desvantagens do mesmo.

http://www.youtube.com/watch?v=2SrfdAkwmFo

Definição da wikipedia O carregamento lento é um padrão de design comumente usado em programação de computador para adiar a inicialização de um objeto até o ponto em que é necessário. ...

http://en.wikipedia.org/wiki/Lazy%20loading

O termo carregamento lento geralmente é usado ao falar sobre mapeadores relacionais de objetos. Se você usar o ADO.NET diretamente, sempre terá um carregamento rápido (ou seja, ele sempre carrega apenas o que você especificar).

Os mapeadores OR, como o nHibernate, oferecem suporte ao retorno de objetos proxy que são "preenchidos" com os dados corretos apenas quando você acessa os dados. Dessa forma, você só carrega os dados que realmente usa. Este é um recurso útil quando você especifica muitas relações entre objetos que podem ser carregados do banco de dados, você não quer que o mapeador OR carregue todos os objetos relacionados e os objetos relacionados aos objetos relacionados e assim por diante. Isso pode resultar no carregamento de todo o banco de dados.

Este problema também pode ser evitado pelo design cuidadoso do seu modelo de objeto. (usar agregados e carregar apenas raízes agregadas como no design orientado por domínio é uma maneira de contornar isso sem usar o carregamento lento).

O carregamento lento pode resultar no mapeador ou fazendo muitos acessos pequenos ao banco de dados, em vez de recuperar todos os dados de que você precisa de uma vez. Isso também pode resultar em problemas de desempenho.

Aqui está um exemplo de algum código Python real que escrevi:

class Item(Model):
    ...
    @property
    def total(self):
        if not hasattr(self, "_total"):
            self._total = self.quantity \
                  + sum(bi.quantity for bi in self.borroweditem_set.all())
        return self._total

Basicamente, tenho uma classe Item que representa um item em nosso estoque. O número total de itens que temos é o número que possuímos mais a soma de todos os itens que tomamos emprestado de várias fontes. Esses números estão todos armazenados em nosso banco de dados, e seria inútil calcular isso até que o total seja realmente solicitado (já que muitas vezes os Itens serão usados ​​sem que o total seja solicitado).

Portanto, a propriedade total verifica se o campo _total existe. Do contrário, o código de propriedade consulta o banco de dados e o calcula e, a seguir, armazena o valor no campo _total para que não precise ser recalculado na próxima vez que for solicitado.

Carregamento lento: você não perde seu tempo (nem sua memória) com coisas que você pode não precisar. Então, quando você precisa, demora mais, mas tudo bem.

Exemplo da vida: em vez de realmente aprender aquele livro de frases em francês, você aprende as frases uma de cada vez, conforme necessário. Quando isso faz sentido? Se você vai ficar na França por pouco tempo (ou seja, você não vai precisar de muitas frases) ou se você precisar sair muito em breve. Se você estiver lá por dois anos e / ou tiver muito tempo para estudar, então pode ser muito mais eficiente aprender o livro de frases inteiro logo de cara (carregamento antecipado).

[Inspirado no Atom, conforme ensinado em termos de gangue por Venus no WKRP .]

Carregamento lento é um termo freqüentemente usado em bancos de dados para se referir ao conceito de carregamento de partes das informações necessárias apenas quando necessário.

Suponho que você precise ter um registro com junção de várias tabelas. Se você buscasse tudo de uma vez, demoraria mais tempo do que se buscasse, digamos, apenas a tabela principal. Usando o carregamento lento, o restante das informações será obtido apenas se for necessário. Portanto, é realmente um 'carregamento eficiente' em certos cenários.

Os outros tipos de 'carregamento' são:

1. Eager Loading - Carregar todas as tabelas conectadas de uma vez.

é um padrão de design.

Carregamento lento: até que seu código exija alguma operação feita por um objeto específico, o objeto não é inicializado e, uma vez inicializado, ele não reinicializa o objeto, mas usa o objeto inicializado anteriormente.

Isso torna seu código muito mais eficiente e ajuda a gerenciar o uso de memória.

Aplicativos de exemplo de carregamento lento:

Detentor do valor de inicialização lenta do Ghost

Algumas das vantagens do carregamento lento:

1. Minimiza o tempo de inicialização do aplicativo.
2. O aplicativo consome menos memória devido ao carregamento sob demanda.
3. A solicitação desnecessária ao servidor é evitada.

Um exemplo de Lazy Loading seria uma grade ou tabela com muitos dados em uma página da web para visualizar onde o aplicativo carrega apenas o tamanho do ponto de vista do navegador do usuário naquele momento. Quando eles rolam para baixo para ver mais conteúdo ou dados, mais dados são carregados na exibição naquele momento.

Isso está se tornando mais um padrão de design visual / interação comum também por meio de ajax ou jQuery.

E, como mencionado acima, o oposto seria o Eager Loading, onde você não leva o cliente em consideração, portanto, potencialmente, tendo um impacto de desempenho.

Lazy<T>agora faz parte do c # 4.0 - há uma página interessante no MSDN que explica o conceito.

De acordo com geeksforgeeks, o carregamento lento é um padrão de design de software em que a inicialização de um objeto ocorre apenas quando é realmente necessário e não antes para preservar a simplicidade de uso e melhorar o desempenho.

https://www.geeksforgeeks.org/lazy-loading-design-pattern/