Comment archiver et désarchiver des objets personnalisés dans Swift? Ou comment économiser de l'objet personnalisé à NSUserDefaults dans Swift?

testé avec XCode 7.1.1, Swift 2.1 & iOS 9

Vous avez un peu d'options pour enregistrer votre (tableau de) objets personnalisés :

• NSUserDefaults : pour stocker les paramètres de l'application, des préférences utilisateur par défaut 🙂
• NSKeyedArchiver : pour le stockage de données
• De base de données : pour les plus complexes de stockage de données (base de données comme)

Je laisse de données de Base de cette discussion, mais veux vous montrer pourquoi il est mieux d'utiliser NSKeyedArchiver sur NSUserdefaults.

J'ai mis à jour votre Lecteur de classe et les méthodes fournies pour les deux options. Bien que les deux options de travail, si vous comparez le "load & enregistrer" méthodes vous verrez que NSKeydArchiver nécessite moins de code pour gérer les tableaux d'objets personnalisés. Aussi avec NSKeyedArchiver vous pouvez facilement stocker des choses dans des fichiers séparés, plutôt que d'avoir à vous soucier unique " clé " des noms pour chaque propriété.

import UIKit
import Foundation
//a custom class like the one that you want to archive needs to conform to NSCoding, so it can encode and decode itself and its properties when it's asked for by the archiver (NSKeydedArchiver or NSUserDefaults)
//because of that, the class also needs to subclass NSObject
class Player: NSObject, NSCoding {
var name: String = ""
//designated initializer
init(name: String) {
print("designated initializer")
self.name = name
super.init()
}
//MARK: - Conform to NSCoding
func encodeWithCoder(aCoder: NSCoder) {
print("encodeWithCoder")
aCoder.encodeObject(name, forKey: "name")
}
//since we inherit from NSObject, we're not a final class -> therefore this initializer must be declared as 'required'
//it also must be declared as a 'convenience' initializer, because we still have a designated initializer as well
required convenience init?(coder aDecoder: NSCoder) {
print("decodeWithCoder")
guard let unarchivedName = aDecoder.decodeObjectForKey("name") as? String
else {
return nil
}
//now (we must) call the designated initializer
self.init(name: unarchivedName)
}
//MARK: - Archiving & Unarchiving using NSUserDefaults
class func savePlayersToUserDefaults(players: [Player]) {
//first we need to convert our array of custom Player objects to a NSData blob, as NSUserDefaults cannot handle arrays of custom objects. It is limited to NSString, NSNumber, NSDate, NSArray, NSData. There are also some convenience methods like setBool, setInteger, ... but of course no convenience method for a custom object
//note that NSKeyedArchiver will iterate over the 'players' array. So 'encodeWithCoder' will be called for each object in the array (see the print statements)
let dataBlob = NSKeyedArchiver.archivedDataWithRootObject(players)
//now we store the NSData blob in the user defaults
NSUserDefaults.standardUserDefaults().setObject(dataBlob, forKey: "PlayersInUserDefaults")
//make sure we save/sync before loading again
NSUserDefaults.standardUserDefaults().synchronize()
}
class func loadPlayersFromUserDefaults() -> [Player]? {
//now do everything in reverse : 
//
//- first get the NSData blob back from the user defaults.
//- then try to convert it to an NSData blob (this is the 'as? NSData' part in the first guard statement)
//- then use the NSKeydedUnarchiver to decode each custom object in the NSData array. This again will generate a call to 'init?(coder aDecoder)' for each element in the array
//- and when that succeeded try to convert this [NSData] array to an [Player]
guard let decodedNSDataBlob = NSUserDefaults.standardUserDefaults().objectForKey("PlayersInUserDefaults") as? NSData,
let loadedPlayersFromUserDefault = NSKeyedUnarchiver.unarchiveObjectWithData(decodedNSDataBlob) as? [Player]
else {
return nil
}
return loadedPlayersFromUserDefault
}
//MARK: - Archivig & Unarchiving using a regular file (using NSKeyedUnarchiver)
private class func getFileURL() -> NSURL {
//construct a URL for a file named 'Players' in the DocumentDirectory
let documentsDirectory = NSFileManager().URLsForDirectory((.DocumentDirectory), inDomains: .UserDomainMask).first!
let archiveURL = documentsDirectory.URLByAppendingPathComponent("Players")
return archiveURL
}
class func savePlayersToDisk(players: [Player]) {
let success = NSKeyedArchiver.archiveRootObject(players, toFile: Player.getFileURL().path!)
if !success {
print("failed to save") //you could return the error here to the caller
}
}
class func loadPlayersFromDisk() -> [Player]? {
return NSKeyedUnarchiver.unarchiveObjectWithFile(Player.getFileURL().path!) as? [Player]
}
}

J'ai testé cette classe comme suit (vue unique de l'application, dans la méthode viewDidLoad de la ViewController)

import UIKit
class ViewController: UIViewController {
override func viewDidLoad() {
super.viewDidLoad()
//create some data
let player1 = Player(name: "John")
let player2 = Player(name: "Patrick")
let playersArray = [player1, player2]
print("--- NSUserDefaults demo ---")
Player.savePlayersToUserDefaults(playersArray)
if let retreivedPlayers = Player.loadPlayersFromUserDefaults() {
print("loaded \(retreivedPlayers.count) players from NSUserDefaults")
print("\(retreivedPlayers[0].name)")
print("\(retreivedPlayers[1].name)")
} else {
print("failed")
}
print("--- file demo ---")
Player.savePlayersToDisk(playersArray)
if let retreivedPlayers = Player.loadPlayersFromDisk() {
print("loaded \(retreivedPlayers.count) players from disk")
print("\(retreivedPlayers[0].name)")
print("\(retreivedPlayers[1].name)")
} else {
print("failed")
}
}
override func didReceiveMemoryWarning() {
super.didReceiveMemoryWarning()
//Dispose of any resources that can be recreated.
}
}

comme dit ci-dessus, les deux méthodes produisent le même résultat

Aussi dans la vie réelle demande que vous pourriez faire une meilleure gestion des erreurs dans le, archivage, & désarchivage pourrait échouer.

J'ai une classe

    class Player {
var name = ""
init(name: String) {
self.name = name
}
}

et je veux serialise et de l'enregistrer à l'utilisateur par défaut.

Dans Swift 4 /iOS 11, il y a une toute nouvelle façon de faire. Il a l'avantage d' tout Swift objet peut l'utiliser — et pas seulement les classes, mais aussi les structures et les énumérations.

Vous remarquerez que j'ai omis votre NSCoding méthodes liées, parce que vous n'aurez pas besoin d'eux pour ce but. Vous peut adopter NSCoding ici, comme vous le savez, mais vous n'avez pas à. (Et une structure ou enum ne peut pas adopter NSCoding à tous.)

Vous commencez par déclarer votre classe à l'adoption de la Codable protocole:

class Player : Codable {
var name = ""
init(name: String) {
self.name = name
}
}

Il devient alors une simple question de sérialiser un objet de Données (NSData) qui peut être stocké dans UserDefaults. La très plus simple est d'utiliser une liste de propriétés en tant qu'intermédiaire:

let player = Player(name:"matt")
try? UserDefaults.standard.set(PropertyListEncoder().encode(player), 
forKey:"player")

Si vous utilisez cette approche, nous allons maintenant prouver que vous pouvez tirer le même Joueur de retour de UserDefaults:

if let data = UserDefaults.standard.object(forKey:"player") as? Data {
if let p = try? PropertyListDecoder().decode(Player.self, from: data) {
print(p.name) //"matt"
}
}

Si vous préférez passer par un NSKeyedArchiver /NSKeyedUnarchiver, vous pouvez le faire à la place. En effet, il y a certains situations où vous aurez à faire: vous serez présenté avec un NSCoder, et vous aurez besoin d'encoder vos Codable objet à l'intérieur d'elle. Dans une récente bêta de Xcode 9 introduit une façon de le faire aussi. Par exemple, si vous êtes d'encodage, vous lancez la NSCoder vers le bas pour un NSKeyedArchiver et appel encodeEncodable.