Disk and File Capacity

Lazy initialization

Lazy initialization is the tactic of delaying the creation of an object, the calculation of a value, or some other expensive process until the first time it is needed.

This is typically accomplished by maintaining a flag indicating whether the process has taken place. Each time the desired object is summoned, the flag is tested. If it is ready, it is returned. If not, it is initialized on the spot. In multithreaded code, access to the flag must be synchronized to guard against a race condition.

See lazy evaluation for a general treatment of this idea. In heavily imperative languages this pattern carries hidden dangers, as does any programming habit that relies on shared state.

 Lazy<Fruit> lazyFruit = new Lazy<Fruit>();  
 Fruit fruit = lazyFruit.Value;  

Here is a dummy example in C#.

The Fruit class itself doesn't do anything here, The class variable _typesDictionary is a Dictionary/Map used to store Fruit instances by typeName.

 using System;  
 using System.Collections;  
 using System.Collections.Generic;  
 public class Fruit  
 {  
   private string _typeName;  
   private static Dictionary<string, Fruit> _typesDictionary = new Dictionary<string, Fruit>();  
   private Fruit(String typeName)  
   {  
     this._typeName = typeName;  
   }  
   public static Fruit GetFruitByTypeName(string type)  
   {  
     Fruit fruit;  
     if (!_typesDictionary.TryGetValue(type, out fruit))  
     {  
       // Lazy initialization  
       fruit = new Fruit(type);  
       _typesDictionary.Add(type, fruit);  
     }  
     return fruit;  
   }  
   public static void ShowAll()  
   {  
     if (_typesDictionary.Count > 0)  
     {  
       Console.WriteLine("Number of instances made = {0}", _typesDictionary.Count);  
       foreach (KeyValuePair<string, Fruit> kvp in _typesDictionary)  
       {  
         Console.WriteLine(kvp.Key);  
       }  
       Console.WriteLine();  
     }  
   }  
   public Fruit()  
   {  
     // required so the sample compiles  
   }  
 }  
 class Program  
 {  
   static void Main(string[] args)  
   {  
     Fruit.GetFruitByTypeName("Banana");  
     Fruit.ShowAll();  
     Fruit.GetFruitByTypeName("Apple");  
     Fruit.ShowAll();  
     // returns pre-existing instance from first   
     // time Fruit with "Banana" was created  
     Fruit.GetFruitByTypeName("Banana");  
     Fruit.ShowAll();  
     Console.ReadLine();  
   }  
 }  

 

Multiton pattern

The multiton pattern is a design pattern similar to the singleton, which allows only one instance of a class to be created. The multiton pattern expands on the singleton concept to manage a map of named instances as key-value pairs.

Rather than have a single instance per application (e.g. the java.lang.Runtime object in the Java programming language) the multiton pattern instead ensures a single instance per key.

using System.Collections.Generic;  
 namespace MyApplication {  
   class FooMultiton {  
     private static readonly Dictionary<object, FooMultiton> _instances = new Dictionary<object, FooMultiton>();  
     private FooMultiton() {  
     }  
     public static FooMultiton GetInstance(object key) {  
       lock (_instances) {    
         FooMultiton instance;  
         if (!_instances.TryGetValue(key, out instance)) {  
           instance = new FooMultiton();  
           _instances.Add(key, instance);  
         }  
         return instance;  
       }  
     }  
   }  
 }