Cómo usar NSCache

Question

¿Alguien puede dar un ejemplo sobre cómo usar NSCache para almacenar en caché una cadena? ¿O alguien tiene un enlace a una buena explicación? Parece que no puedo encontrar ninguno ..

Answer 1

Lo usa de la misma manera que usaría NSMutableDictionary. La diferencia es que cuando NSCache detecta una presión de memoria excesiva (es decir, almacena en caché demasiados valores) liberará algunos de esos valores para hacer espacio.

Si puede recrear esos valores en tiempo de ejecución (descargándolos de Internet, haciendo cálculos, lo que sea), entonces NSCache puede satisfacer sus necesidades. Si los datos no se pueden volver a crear (por ejemplo, es una entrada del usuario, es sensible al tiempo, etc.), entonces no debe almacenarlos en un NSCache porque se destruirán allí.

ejemplo, no teniendo en cuenta la seguridad de rosca:

// Your cache should have a lifetime beyond the method or handful of methods 
// that use it. For example, you could make it a field of your application 
// delegate, or of your view controller, or something like that. Up to you. 
NSCache *myCache = ...; 
NSAssert(myCache != nil, @"cache object is missing"); 

// Try to get the existing object out of the cache, if it's there. 
Widget *myWidget = [myCache objectForKey: @"Important Widget"]; 
if (!myWidget) { 
    // It's not in the cache yet, or has been removed. We have to 
    // create it. Presumably, creation is an expensive operation, 
    // which is why we cache the results. If creation is cheap, we 
    // probably don't need to bother caching it. That's a design 
    // decision you'll have to make yourself. 
    myWidget = [[[Widget alloc] initExpensively] autorelease]; 

    // Put it in the cache. It will stay there as long as the OS 
    // has room for it. It may be removed at any time, however, 
    // at which point we'll have to create it again on next use. 
    [myCache setObject: myWidget forKey: @"Important Widget"]; 
} 

// myWidget should exist now either way. Use it here. 
if (myWidget) { 
    [myWidget runOrWhatever]; 
} 

Answer 2

@implementation ViewController 
{  
    NSCache *imagesCache;  
} 


- (void)viewDidLoad 
{  
    imagesCache = [[NSCache alloc] init]; 
} 


// How to save and retrieve NSData into NSCache 
NSData *imageData = [imagesCache objectForKey:@"KEY"]; 
[imagesCache setObject:imageData forKey:@"KEY"]; 

Answer 3

sample Project Añadir CacheController.h y el archivo .m del proyecto de ejemplo para su proyecto. En la clase en la que desea almacenar los datos en caché, coloque el siguiente código.

[[CacheController storeInstance] setCache:@"object" forKey:@"objectforkey" ]; 

puede establecer cualquier objeto que utiliza este

[[CacheController storeInstance] getCacheForKey:@"objectforkey" ]; 

retrive

Importante: La clase NSCache incorpora diversas políticas de eliminación automática. si desea almacenar en caché los datos para permanentes o si desea eliminar los datos en caché en un tiempo específico see this answer.

Answer 4

Código de ejemplo para el almacenamiento en caché de una cadena usando NSCache en Swift:

var cache = NSCache() 
cache.setObject("String for key 1", forKey: "Key1") 
var result = cache.objectForKey("Key1") as String 
println(result) // Prints "String for key 1" 

Para crear una instancia única de toda la aplicación de NSCache (un producto único), se puede ampliar fácilmente NSCache para añadir una propiedad sharedInstance. Sólo hay que poner el siguiente código en un archivo llamado algo así como NSCache + Singleton.swift:

import Foundation 

extension NSCache { 
    class var sharedInstance : NSCache { 
     struct Static { 
      static let instance : NSCache = NSCache() 
     } 
     return Static.instance 
    } 
} 

continuación, puede utilizar la memoria caché en cualquier lugar de la aplicación:

NSCache.sharedInstance.setObject("String for key 2", forKey: "Key2") 
var result2 = NSCache.sharedInstance.objectForKey("Key2") as String 
println(result2) // Prints "String for key 2" 

Answer 5

En caso de que no los objetos en caché implementar el NSDiscardableContent protocol?

De la referencia de clase NSCache: Un tipo de datos común almacenado en objetos NSCache es un objeto que implementa el protocolo NSDiscardableContent. Almacenar este tipo de objetos en una memoria caché tiene sus ventajas, ya que su contenido puede descartarse cuando ya no es necesario, lo que permite ahorrar memoria. De forma predeterminada, los objetos NSDiscardableContent en la memoria caché se eliminan automáticamente de la memoria caché si su contenido se descarta, aunque esta política de eliminación automática se puede cambiar. Si un objeto NSDiscardableContent se coloca en el caché, el caché llama a descarteContenidoIfPossible sobre él una vez eliminado.