Comment utiliser NSCache

Vous l'utiliser de la même manière que vous le feriez utiliser NSMutableDictionary. La différence est que lorsque NSCache détecte trop de mémoire de la pression (c'est à dire qu'il cache trop grand nombre de valeurs), il va libérer une partie de ces valeurs pour faire de la place.

Si vous pouvez recréer ces valeurs au moment de l'exécution (par téléchargement à partir d'Internet, en faisant les calculs, peu importe) puis NSCache peuvent répondre à vos besoins. Si les données ne peuvent être reproduites (par exemple c'est la saisie de l'utilisateur, il est sensible au temps, etc.) ensuite, vous ne devriez pas conserver dans un NSCache, car il sera détruite.

Exemple, ne prenant pas la sécurité des threads en compte:

//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];
}

Exemple de code pour la mise en cache d'une chaîne à l'aide de NSCache dans 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"

Pour créer une seule application à l'échelle de l'instance de NSCache (un singleton), vous pouvez facilement étendre NSCache pour ajouter un sharedInstance de la propriété. Viens de mettre le code suivant dans un fichier appelé quelque chose comme NSCache+Singleton.swift:

import Foundation

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

Vous pouvez ensuite utiliser le cache n'importe où dans l'application:

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

Ne pas les objets mis en cache de mettre en œuvre la NSDiscardableContent protocole?

De la NSCache classe de référence:
Une commune, le type de données stockées dans NSCache objets est un objet qui implémente l'NSDiscardableContent protocole. Le stockage de ce type d'objet dans un cache a des avantages, car son contenu peut être éliminé quand il n'est plus nécessaire, et ainsi de gagner de la mémoire. Par défaut, NSDiscardableContent d'objets dans le cache sont automatiquement supprimés de la mémoire cache si leur contenu est ignoré, bien que cette suppression automatique de la politique peut être modifiée. Si un NSDiscardableContent objet est mis en cache, le cache des appels discardContentIfPossible sur elle lors de son retrait.