Pergunta

O que é carregamento lento?

Editar 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 Load, quais são os "outros" tipos?

Foi útil?

Solução

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

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

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

Outras dicas

Lazy Load é uma prática de programação na qual você só carrega ou inicializa um objeto quando precisa dele pela primeira vez.Isso pode potencialmente proporcionar um grande aumento de desempenho, especialmente se você tiver muitos componentes em seu aplicativo.

Como sempre, Wikipédia tem mais detalhes.

O carregamento lento é um conceito em que atrasamos o carregamento da unidade do objeto no ponto onde precisamos dele.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 tenha o objeto "Pedidos" agregado.Então você gosta de carregar os dados do cliente, mas os objetos de pedidos você 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 preguiçoso é um padrão de design comumente usado na 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 quando se fala sobre mapeadores relacionais de objetos.Se você usar o ADO.NET diretamente, você sempre terá um carregamento antecipado (ou seja, ele sempre carrega exatamente o que você especifica).

Mapeadores OR como o nHibernate suportam o retorno de objetos proxy que são "preenchidos" com os dados corretos somente quando você acessa os dados.Dessa forma você carrega apenas os dados que realmente utiliza.Este é um recurso útil quando você especifica muitas relações entre objetos que podem ser carregados do banco de dados, você não deseja 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 seu 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 carregamento lento).

O carregamento lento pode fazer com que o mapeador faça muitos pequenos acessos ao banco de dados em vez de recuperar todos os dados necessários 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 inventário.O número total de itens que temos é o número que possuímos mais a soma de todos os itens que pegamos emprestado de diversas fontes.Esses números estão todos armazenados em nosso banco de dados, e seria inútil calculá-los 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.Caso contrário, o código de propriedade consulta o banco de dados e o calcula, depois 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 talvez não precise.Aí quando você precisar 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, não vai precisar de muitas frases) ou se precisa 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 todo o livro de frases antecipadamente (carregamento rápido).

[Inspirado no Atom conforme ensinado em termos de gangue por Vênus no WKRP.]

Carregamento lento é um termo frequentemente usado em bancos de dados para se referir ao conceito de carregar partes das informações necessárias somente quando necessário.

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

Os outros tipos de 'carregamento' são:

  1. Carregamento Eager - Carregando 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, não o reinicializa, mas usa o objeto inicializado anteriormente.

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

Exemplos de aplicações de carregamento lento:

Ghost Lazy Initialization Value titular

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. Solicitações desnecessárias ao servidor são evitadas.

Um exemplo de carregamento lento 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 rolassem para baixo para visualizar mais conteúdo ou dados, mais dados seriam carregados para visualização naquele momento.

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

E, como mencionado acima, o oposto seria o Eager Load, onde você não leva o cliente em consideração, podendo ter um impacto no desempenho.

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

De acordo com geeksforgeeks, carregamento lento é um padrão de design de software onde 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/

Licenciado em: CC-BY-SA com atribuição
Não afiliado a StackOverflow
scroll top