Enregistrer NSCache Contenu sur le Disque

Je suis en train d'écrire une application qui a besoin de garder
un cache en mémoire d'un tas de
des objets, mais cela ne veut pas sortir de
la main donc je suis à la planification sur l'utilisation de NSCache
pour stocker l'ensemble. Regarde comme il va
prendre soin de purge et pour moi,
ce qui est fantastique.
Je tiens également à rendre le cache
entre les lancements, donc j'ai besoin d'écrire
les données du cache sur le disque. Est-il un
moyen facile de sauvegarder le contenu NSCache
pour une plist ou quelque chose? Sont là
peut-être de meilleures façons de le faire
en utilisant quelque chose d'autre que NSCache?

Vous avez pratiquement décrit exactement ce qu'il CoreData n'; la persistance des objets graphiques à l'aide de la purge et de capacités de nettoyage.

NSCache n'est pas conçu pour aider avec une bonne persistance.

Étant donné que vous l'avez suggéré, la persistance d'une plist format, en utilisant la Base de Données au lieu de cela n'est pas que les grandes d'une différence de conception.

OriginalL'auteur bbum

Parfois, il peut être plus pratique de ne pas traiter avec les Données de Base et juste pour enregistrer le contenu du cache sur le disque. Vous pouvez réaliser cela avec NSKeyedArchiver et UserDefaults (je suis en utilisant Swift 3.0.2 dans les exemples de code ci-dessous).

Laissez-moi d'abord abstraite de NSCache et imaginons que nous voulons être en mesure de prolonger le cache qui est conforme au protocole:

protocol Cache {
    associatedtype Key: Hashable
    associatedtype Value

    var keys: Set<Key> { get }

    func set(value: Value, forKey key: Key)

    func value(forKey key: Key) -> Value?

    func removeValue(forKey key: Key)
}

extension Cache {
    subscript(index: Key) -> Value? {
        get {
            return value(forKey: index)
        }
        set {
            if let v = newValue {
                set(value: v, forKey: index)
            } else {
                removeValue(forKey: index)
            }
        }
    }
}

Key de type associé doit être Hashable parce que c'est la condition pour Set paramètre de type.

Ensuite, nous avons à mettre en œuvre NSCoding pour Cache à l'aide de la classe helper CacheCoding:

private let keysKey = "keys"
private let keyPrefix = "_"
class CacheCoding<C: Cache, CB: Builder>: NSObject, NSCoding
where
C.Key: CustomStringConvertible & ExpressibleByStringLiteral,
C.Key.StringLiteralType == String,
C.Value: NSCodingConvertible,
C.Value.Coding: ValueProvider,
C.Value.Coding.Value == C.Value,
CB.Value == C {
let cache: C
init(cache: C) {
self.cache = cache
}
required convenience init?(coder decoder: NSCoder) {
if let keys = decoder.decodeObject(forKey: keysKey) as? [String] {
var cache = CB().build()
for key in keys {
if let coding = decoder.decodeObject(forKey: keyPrefix + (key as String)) as? C.Value.Coding {
cache[C.Key(stringLiteral: key)] = coding.value
}
}
self.init(cache: cache)
} else {
return nil
}
}
func encode(with coder: NSCoder) {
for key in cache.keys {
if let value = cache[key] {
coder.encode(value.coding, forKey: keyPrefix + String(describing: key))
}
}
coder.encode(cache.keys.map({ String(describing: $0) }), forKey: keysKey)
}
}

Ici:

• C est le type qui est conforme à Cache.
• C.Key de type associé doit être conforme à:
  • Swift CustomStringConvertible protocole de conversion à String parce que NSCoder.encode(forKey:) méthode accepte String pour le paramètre clé.
  • Swift ExpressibleByStringLiteral protocole de convertir [String] retour à Set<Key>
• Nous avons besoin de convertir Set<Key> à [String] et de les stocker dans NSCoder avec keys clé, car il n'existe aucun moyen pour extraire durant le décodage de NSCoder clés qui ont été utilisés lors de l'encodage des objets. Mais il y a peut être de la situation quand nous avons également entrée dans le cache avec les principaux keysdonc de distinguer les clés de cache de spécial keys clé que nous préfixe cache avec les touches de _.

• C.Value de type associé doit être conforme aux NSCodingConvertible protocole pour obtenir NSCoding les instances à partir de valeurs stockées dans la mémoire cache:

  protocol NSCodingConvertible {
  associatedtype Coding: NSCoding
  var coding: Coding { get }
  }

• Value.Coding doit être conforme aux ValueProvider protocole parce que vous avez besoin pour obtenir des valeurs de retour de NSCoding instances:

  protocol ValueProvider {
  associatedtype Value
  var value: Value { get }
  }

• C.Value.Coding.Value et C.Value être équivalent, car la valeur à partir de laquelle nous obtenons NSCoding exemple lors de l'encodage doit être du même type que la valeur que nous revenons de NSCoding lors du décodage.

• CB est un type qui est conforme à Builder protocole et qui contribue à créer instance de cache de C type:

  protocol Builder {
  associatedtype Value
  init()
  func build() -> Value
  }

Prochaine, nous allons faire des NSCache conforme à Cache protocole. Ici, nous avons un problème. NSCache a le même problème que NSCoder t - il ne fournit pas de moyen d'extraire les clés pour les objets stockés. Il existe trois façons de contourner ce problème:

1. Envelopper NSCache personnalisé pour le type qui détiennent les clés de Set et de l'utiliser partout, au lieu de NSCache:

   class BetterCache<K: AnyObject & Hashable, V: AnyObject>: Cache {
   private let nsCache = NSCache<K, V>()
   private(set) var keys = Set<K>()
   func set(value: V, forKey key: K) {
   keys.insert(key)
   nsCache.setObject(value, forKey: key)
   }
   func value(forKey key: K) -> V? {
   let value = nsCache.object(forKey: key)
   if value == nil {
   keys.remove(key)
   }
   return value
   }
   func removeValue(forKey key: K) {
   return nsCache.removeObject(forKey: key)
   }
   }

2. Si vous avez encore besoin de passer NSCache quelque part, alors vous pouvez essayer de l'étendre en Objective-C faire la même chose, comme je l'ai fait ci-dessus avec BetterCache.

3. Utiliser un autre cache de mise en œuvre.

Maintenant vous avez un type qui est conforme à Cache protocole et vous êtes prêt à l'utiliser.

Nous allons définir le type Book les instances qui nous permettra de stocker dans le cache et NSCoding pour ce type:

class Book {
let title: String
init(title: String) {
self.title = title
}
}
class BookCoding: NSObject, NSCoding, ValueProvider {
let value: Book
required init(value: Book) {
self.value = value
}
required convenience init?(coder decoder: NSCoder) {
guard let title = decoder.decodeObject(forKey: "title") as? String else {
return nil
}
print("My Favorite Book")
self.init(value: Book(title: title))
}
func encode(with coder: NSCoder) {
coder.encode(value.title, forKey: "title")
}
}
extension Book: NSCodingConvertible {
var coding: BookCoding {
return BookCoding(value: self)
}
}

Certains typealiases pour une meilleure lisibilité:

typealias BookCache = BetterCache<StringKey, Book>
typealias BookCacheCoding = CacheCoding<BookCache, BookCacheBuilder>

Et le constructeur qui va nous aider à instancier Cache exemple:

class BookCacheBuilder: Builder {
required init() {
}
func build() -> BookCache {
return BookCache()
}
}

Tester:

let cacheKey = "Cache"
let bookKey: StringKey = "My Favorite Book"
func test() {
var cache = BookCache()
cache[bookKey] = Book(title: "Lord of the Rings")
let userDefaults = UserDefaults()
let data = NSKeyedArchiver.archivedData(withRootObject: BookCacheCoding(cache: cache))
userDefaults.set(data, forKey: cacheKey)
userDefaults.synchronize()
if let data = userDefaults.data(forKey: cacheKey),
let cache = (NSKeyedUnarchiver.unarchiveObject(with: data) as? BookCacheCoding)?.cache,
let book = cache.value(forKey: bookKey) {
print(book.title)
}
}

OriginalL'auteur mixel