.net - usa - ¿Qué es la inicialización lenta y por qué es útil?
que es un destructor en c++ (9)
Aquí puede leer sobre Inicialización diferida con código de muestra.
Cuando tiene un objeto que es costoso de crear, y el programa puede no usarlo. Por ejemplo, suponga que tiene en memoria un objeto Cliente que tiene una propiedad Pedidos que contiene una gran matriz de objetos Orden que, para inicializarse, requiere una conexión a la base de datos. Si el usuario nunca solicita mostrar las Órdenes o usar los datos en un cálculo, entonces no hay razón para usar la memoria del sistema o los ciclos de cálculo para crearla. Al utilizar Lazy para declarar el objeto Orders para la inicialización lenta, puede evitar el desperdicio de recursos del sistema cuando el objeto no se utiliza.
Cuando tiene un objeto que es costoso de crear, y desea diferir su creación hasta después de que se hayan completado otras costosas operaciones. Por ejemplo, suponga que su programa carga varias instancias de objeto cuando se inicia, pero solo algunas de ellas se requieren inmediatamente. Puede mejorar el rendimiento de inicio del programa posponiendo la inicialización de los objetos que no son necesarios hasta que se hayan creado los objetos necesarios.
¿Qué es la inicialización lenta de los objetos? ¿Cómo lo haces y cuáles son las ventajas?
Como lo que he entendido sobre init flojo hasta ahora, es que el programa no carga / solicita todos los datos a una vez. Espera su uso antes de solicitarlo, por ejemplo. un servidor SQL.
Si tiene una base de datos con una tabla grande unida con una gran cantidad de subtablas y no necesita los detalles unidos desde las otras tablas, a menos que vaya a "editar" o "ver detalles", entonces Lazy Init. ayudará a la aplicación a ir más rápido y la primera "carga lenta" a los datos detallados según sea necesario.
En SQL o LINQ puede establecer esta "configuración" en su modelo de base de datos pr. elemento de datos
Espero que esto tenga sentido para tu pregunta?
Un cliente web (por ejemplo, un navegador) hace lo mismo. Las imágenes son "cargadas de forma diferida" después del HTML y AJAX también es un "tipo de iniciación lenta" si se usa correctamente.
Como otros han mencionado, la inicialización lenta está retrasando la inicialización hasta que se usa un componente u objeto. Puede ver la inicialización lenta como una aplicación en tiempo de ejecución del principio YAGNI : " You ain''t gonna need it ".
Las ventajas desde una perspectiva de aplicación de inicialización lenta son que los usuarios no tienen que pagar el tiempo de inicialización para las características que no usarán. Supongamos que debe inicializar cada componente de su aplicación por adelantado. Esto podría crear un tiempo de inicio potencialmente largo: los usuarios tendrían que esperar docenas de segundos o minutos antes de que su aplicación esté lista para usar. Están esperando y pagando por la inicialización de las características que nunca pueden usar o no usar de inmediato.
En cambio, si pospone la inicialización de esos componentes hasta el tiempo de uso, su aplicación se iniciará mucho más rápido. El usuario aún tendrá que pagar el costo de inicio cuando use otros componentes, pero ese costo se amortizará durante la ejecución del programa y no se condensará desde el principio, y el usuario puede asociar el tiempo de inicialización de estos objetos con las características que son utilizando.
En términos informáticos generales, ''evaluación diferida'' significa diferir el procesamiento en algo hasta que realmente lo necesite. La idea principal es que a veces puede evitar costosas operaciones si resulta que no las necesita, o si el valor cambiaría antes de usarlo.
Un ejemplo simple de esto es System.Exception.StackTrace. Esta es una propiedad de cadena en una excepción, pero en realidad no se genera hasta que accede a ella. Internamente hace algo como:
String StackTrace{
get{
if(_stackTrace==null){
_stackTrace = buildStackTrace();
}
return _stackTrace;
}
}
Esto le ahorra la sobrecarga de llamar realmente a buildStackTrace hasta que alguien quiera ver de qué se trata.
Las propiedades son una forma de proporcionar este tipo de comportamiento.
Inicialización lenta de un objeto significa que su creación se difiere hasta que se utiliza por primera vez. (Para este tema, los términos inicialización diferida e instanciación diferida son sinónimos.) La inicialización diferida se usa principalmente para mejorar el rendimiento, evitar el cálculo inútil y reducir los requisitos de memoria del programa. Estos son los escenarios más comunes:
Cuando tiene un objeto que es costoso de crear, y el programa puede no usarlo. Por ejemplo, suponga que tiene en memoria un objeto Cliente que tiene una propiedad Pedidos que contiene una gran matriz de objetos Orden que, para inicializarse, requiere una conexión a la base de datos. Si el usuario nunca solicita mostrar las Órdenes o usar los datos en un cálculo, entonces no hay razón para usar la memoria del sistema o los ciclos de cálculo para crearla. Al utilizar Lazy para declarar el objeto Orders para la inicialización lenta, puede evitar el desperdicio de recursos del sistema cuando el objeto no se utiliza.
Cuando tiene un objeto que es costoso de crear, y desea diferir su creación hasta después de que se hayan completado otras costosas operaciones. Por ejemplo, suponga que su programa carga varias instancias de objeto cuando se inicia, pero solo algunas de ellas se requieren inmediatamente. Puede mejorar el rendimiento de inicio del programa posponiendo la inicialización de los objetos que no son necesarios hasta que se hayan creado los objetos necesarios.
Aunque puede escribir su propio código para realizar una inicialización lenta, le recomendamos que utilice Lazy en su lugar. Lazy y sus tipos relacionados también son compatibles con la seguridad de subprocesos y proporcionan una política de propagación de excepciones consistente.
Lazy Initialization es el concepto de diferir la creación de objetos hasta que el objeto se usa por primera vez. Si se usa correctamente, puede generar ganancias de rendimiento significativas.
Personalmente, utilicé Inicialización diferida al crear mi propio ORM enrollado a mano en .NET 2.0. Al cargar mis colecciones desde la base de datos, los elementos reales de la colección se inicializaron de forma diferida. Esto significaba que las colecciones se creaban rápidamente, pero cada objeto se cargaba solo cuando lo requería.
Si está familiarizado con el patrón de Singleton, probablemente también haya visto la inicialización lenta en acción.
public class SomeClassSingleton
{
private static SomeClass _instance = null;
private SomeClassSingleton()
{
}
public static SomeClass GetInstance()
{
if(_instance == null)
_instance = new SomeClassSingleton();
return _instance;
}
}
En este caso, la instancia de SomeClass no se inicializa hasta que el consumidor SomeClassSingleton la necesita por primera vez.
Lazy Initialization es una optimización del rendimiento en la que difiere la creación de objetos (potencialmente caros) hasta justo antes de que realmente lo necesite.
Un buen ejemplo es no crear una conexión de base de datos por adelantado, sino solo justo antes de que necesite obtener datos de la base de datos.
La razón clave para hacer esto es que (a menudo) puede evitar crear el objeto completamente si nunca lo necesita.
Los ejemplos de bases de datos que se han mencionado hasta ahora son buenos, pero no se limitan solo a la capa de acceso a datos. Podría aplicar los mismos principios a cualquier situación donde el rendimiento o la memoria puedan ser una preocupación. Un buen ejemplo (aunque no .NET) es en Cocoa, donde puede esperar hasta que el usuario solicite una ventana para cargarlo (y sus objetos asociados) desde el plumín. Esto puede ayudar a mantener el uso de la memoria baja y acelerar la carga inicial de la aplicación, especialmente cuando se trata de cosas como ventanas de Preferencias que no serán necesarias hasta algún momento posterior, si es que alguna vez lo hace.
//Lazy instantiation delays certain tasks.
//It typically improves the startup time of a C# application.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace LazyLoad
{
class Program
{
static void Main(string[] args)
{
Lazy<MyClass> MyLazyClass = new Lazy<MyClass>(); // create lazy class
Console.WriteLine("IsValueCreated = {0}",MyLazyClass.IsValueCreated); // print value to check if initialization is over
MyClass sample = MyLazyClass.Value; // real value Creation Time
Console.WriteLine("Length = {0}", sample.Length); // print array length
Console.WriteLine("IsValueCreated = {0}", MyLazyClass.IsValueCreated); // print value to check if initialization is over
Console.ReadLine();
}
}
class MyClass
{
int[] array;
public MyClass()
{
array = new int[10];
}
public int Length
{
get
{
return this.array.Length;
}
}
}
}
// out put
// IsValueCreated = False
// Length = 10
// IsValueCreated = True