Guardar clases Swift personalizadas con NSCoding en UserDefaults

nsuserdefaults sigabrt

Question

Actualmente estoy intentando guardar una clase Swift personalizada en NSUserDefaults. Aquí está el código de mi área de juegos:

import Foundation

class Blog : NSObject, NSCoding {

    var blogName: String?

    override init() {}

    required init(coder aDecoder: NSCoder) {
        if let blogName = aDecoder.decodeObjectForKey("blogName") as? String {
            self.blogName = blogName
        }
    }

    func encodeWithCoder(aCoder: NSCoder) {
        if let blogName = self.blogName {
            aCoder.encodeObject(blogName, forKey: "blogName")
        }
    }

}

var blog = Blog()
blog.blogName = "My Blog"

let ud = NSUserDefaults.standardUserDefaults()    
ud.setObject(blog, forKey: "blog")

Cuando ejecuto el código, obtengo el siguiente error

La ejecución fue interrumpida, razón: señal SIGABRT.

en la última línea ( ud.setObject ...)

El mismo código también falla cuando en una aplicación con el mensaje

"La lista de propiedades no es válida para el formato: 200 (las listas de propiedades no pueden contener objetos del tipo ''CFType'')"

¿Alguien puede ayudar? Estoy usando Xcode 6.0.1 en Maverick. Gracias.

Answer 1

Como @ dan-beaulieu sugirió que respondiera mi propia pregunta:

Aquí está el código de trabajo ahora:

Nota: El cambio de nombre de la clase no fue necesario para que el código funcione en Playgrounds.

import Foundation

class Blog : NSObject, NSCoding {

    var blogName: String?

    override init() {}

    required init(coder aDecoder: NSCoder) {
        if let blogName = aDecoder.decodeObjectForKey("blogName") as? String {
            self.blogName = blogName
        }
    }

    func encodeWithCoder(aCoder: NSCoder) {
        if let blogName = self.blogName {
            aCoder.encodeObject(blogName, forKey: "blogName")
        }
    }

}

let ud = NSUserDefaults.standardUserDefaults()

var blog = Blog()
blog.blogName = "My Blog"

ud.setObject(NSKeyedArchiver.archivedDataWithRootObject(blog), forKey: "blog")

if let data = ud.objectForKey("blog") as? NSData {
    let unarc = NSKeyedUnarchiver(forReadingWithData: data)
    let newBlog = unarc.decodeObjectForKey("root") as Blog
}

Answer 2

El primer problema es que debes asegurarte de que tienes un nombre de clase no destruido:

@objc(Blog)
class Blog : NSObject, NSCoding {

Luego, debe codificar el objeto (en un NSData) antes de poder almacenarlo en los valores predeterminados del usuario:

ud.setObject(NSKeyedArchiver.archivedDataWithRootObject(blog), forKey: "blog")

Del mismo modo, para restaurar el objeto necesitarás desarchivarlo:

if let data = ud.objectForKey("blog") as? NSData {
    let unarc = NSKeyedUnarchiver(forReadingWithData: data)
    unarc.setClass(Blog.self, forClassName: "Blog")
    let blog = unarc.decodeObjectForKey("root")
}

Tenga en cuenta que si no lo está utilizando en el patio de recreo es un poco más simple ya que no tiene que registrar la clase a mano:

if let data = ud.objectForKey("blog") as? NSData {
    let blog = NSKeyedUnarchiver.unarchiveObjectWithData(data)
}

Answer 3

En Swift 4 tiene un nuevo protocolo que reemplaza el protocolo NSCoding. Se llama Codable y admite clases y tipos Swift. (Enum, structs):

struct CustomStruct: Codable {
    let name: String
    let isActive: Bool
}

Answer 4

No puede almacenar un objeto en la lista de propiedades directamente; solo puede almacenar cadenas individuales u otros tipos primitivos (enteros, etc.). Por lo tanto, debe almacenarlo como cadenas individuales, como por ejemplo:

   override init() {
   }

   required public init(coder decoder: NSCoder) {
      func decode(obj:AnyObject) -> AnyObject? {
         return decoder.decodeObjectForKey(String(obj))
      }

      self.login = decode(login) as! String
      self.password = decode(password) as! String
      self.firstname = decode(firstname) as! String
      self.surname = decode(surname) as! String
      self.icon = decode(icon) as! UIImage
   }

   public func encodeWithCoder(coder: NSCoder) {
      func encode(obj:AnyObject) {
         coder.encodeObject(obj, forKey:String(obj))
      }

      encode(login)
      encode(password)
      encode(firstname)
      encode(surname)
      encode(icon)
   }

Answer 5

Para mí uso mi estructura es más fácil

struct UserDefaults {
    private static let kUserInfo = "kUserInformation"

    var UserInformation: DataUserInformation? {
        get {
            guard let user = NSUserDefaults.standardUserDefaults().objectForKey(UserDefaults.kUserInfo) as? DataUserInformation else {
                return nil
            }
            return user
        }
        set {

            NSUserDefaults.standardUserDefaults().setObject(newValue, forKey: UserDefaults.kUserInfo)
            NSUserDefaults.standardUserDefaults().synchronize()
        }
    }

}



Use : let userinfo = UserDefaults.UserInformation

Answer 6

Probado con Swift 2.1 y Xcode 7.1.1

Si no necesitas que blogName sea una opción (que creo que no), te recomendaría una implementación ligeramente diferente:

class Blog : NSObject, NSCoding {

    var blogName: String

    // designated initializer
    //
    // ensures you''ll never create a Blog object without giving it a name
    // unless you would need that for some reason?
    //
    // also : I would not override the init method of NSObject

    init(blogName: String) {
        self.blogName = blogName

        super.init()        // call NSObject''s init method
    }

    func encodeWithCoder(aCoder: NSCoder) {
        aCoder.encodeObject(blogName, forKey: "blogName")
    }

    required convenience init?(coder aDecoder: NSCoder) {
        // decoding could fail, for example when no Blog was saved before calling decode
        guard let unarchivedBlogName = aDecoder.decodeObjectForKey("blogName") as? String
            else {
                // option 1 : return an default Blog
                self.init(blogName: "unnamed")
                return

                // option 2 : return nil, and handle the error at higher level
        }

        // convenience init must call the designated init
        self.init(blogName: unarchivedBlogName)
    }
}

el código de prueba podría verse así:

    let blog = Blog(blogName: "My Blog")

    // save
    let ud = NSUserDefaults.standardUserDefaults()
    ud.setObject(NSKeyedArchiver.archivedDataWithRootObject(blog), forKey: "blog")
    ud.synchronize()

    // restore
    guard let decodedNSData = ud.objectForKey("blog") as? NSData,
    let someBlog = NSKeyedUnarchiver.unarchiveObjectWithData(decodedNSData) as? Blog
        else {
            print("Failed")
            return
    }

    print("loaded blog with name : /(someBlog.blogName)")

Finalmente, me gustaría señalar que sería más fácil usar NSKeyedArchiver y guardar su matriz de objetos personalizados en un archivo directamente, en lugar de usar NSUserDefaults. Puedes encontrar más sobre sus diferencias en mi respuesta here .

Answer 7

Swift 3 versión:

class CustomClass: NSObject, NSCoding {

var name = ""
var isActive = false

init(name: String, isActive: Bool) {
    self.name = name
    self.isActive = isActive
}

// MARK: NSCoding

required convenience init?(coder decoder: NSCoder) {
    guard let name = decoder.decodeObject(forKey: "name") as? String,
        let isActive = decoder.decodeObject(forKey: "isActive") as? Bool
        else { return nil }

    self.init(name: name, isActive: isActive)
}

func encode(with coder: NSCoder) {
    coder.encode(self.name, forKey: "name")
    coder.encode(self.isActive, forKey: "isActive")
}

}

Answer 8

En Swift 4, use codificable.

En tu caso, usa el siguiente código.

struct Blog : NSObject, Codable {

   var blogName: String?

}

Ahora crea su objeto. Por ejemplo:

var blog = Blog()
blog.blogName = "My Blog"

Ahora codifícalo así:

if let encoded = try? JSONEncoder().encode(blog) {
    UserDefaults.standard.set(encoded, forKey: "blog")
}

y decodifícalo así:

if let blogData = UserDefaults.standard.data(forKey: "blog"),
    let blog = try? JSONDecoder().decode(Blog.self, from: blogData) {
}