Myślałem, że wiem, co spowodowało ten błąd, ale nie mogę zrozumieć, co zrobiłem źle.

Oto pełny komunikat o błędzie:

Próba ustawienia obiektu listy innej niż właściwość (
   „<BC_Person: 0x8f3c140>”
) jako wartość NSUserDefaults dla kluczowego personDataArray

Mam Personklasę, która moim zdaniem jest zgodna z NSCodingprotokołem, w której mam obie te metody w mojej klasie person:

- (void)encodeWithCoder:(NSCoder *)coder {
    [coder encodeObject:self.personsName forKey:@"BCPersonsName"];
    [coder encodeObject:self.personsBills forKey:@"BCPersonsBillsArray"];
}

- (id)initWithCoder:(NSCoder *)coder {
    self = [super init];
    if (self) {
        self.personsName = [coder decodeObjectForKey:@"BCPersonsName"];
        self.personsBills = [coder decodeObjectForKey:@"BCPersonsBillsArray"];
    }
    return self;
}

W pewnym momencie aplikacji ustawiono opcję „ NSStringw” BC_PersonClassi mam DataSaveklasę, która, jak sądzę, obsługuje kodowanie właściwości w moim pliku BC_PersonClass. Oto kod, którego używam z DataSaveklasy:

- (void)savePersonArrayData:(BC_Person *)personObject
{
   // NSLog(@"name of the person %@", personObject.personsName);

    [mutableDataArray addObject:personObject];

    // set the temp array to the mutableData array
    tempMuteArray = [NSMutableArray arrayWithArray:mutableDataArray];

    // save the person object as nsData
    NSData *personEncodedObject = [NSKeyedArchiver archivedDataWithRootObject:personObject];

    // first add the person object to the mutable array
    [tempMuteArray addObject:personEncodedObject];

    // NSLog(@"Objects in the array %lu", (unsigned long)mutableDataArray.count);

    // now we set that data array to the mutable array for saving
    dataArray = [[NSArray alloc] initWithArray:mutableDataArray];
    //dataArray = [NSArray arrayWithArray:mutableDataArray];

    // save the object to NS User Defaults
    NSUserDefaults *userData = [NSUserDefaults standardUserDefaults];
    [userData setObject:dataArray forKey:@"personDataArray"];
    [userData synchronize];
}

Mam nadzieję, że to wystarczający kod, aby dać ci wyobrażenie o tym, co próbuję zrobić. Znów wiem, że mój problem leży w sposobie kodowania moich właściwości w mojej klasie BC_Person, po prostu nie mogę zrozumieć, co robię źle.

Dzięki za pomoc!

Wysłany kod próbuje zapisać tablicę niestandardowych obiektów NSUserDefaults. Nie możesz tego zrobić. Wdrożenie NSCodingmetod nie pomaga. Można przechowywać tylko takie rzeczy NSArray, NSDictionary, NSString, NSData, NSNumber, i NSDatew NSUserDefaults.

Musisz przekonwertować obiekt NSData(tak jak masz w kodzie) i zapisać go NSDataw NSUserDefaults. Można nawet przechowywać NSArrayz NSData, jeśli trzeba.

Po ponownym odczytaniu tablicy musisz cofnąć archiwizację, NSDataaby odzyskać swoje BC_Personobiekty.

Być może chcesz tego:

- (void)savePersonArrayData:(BC_Person *)personObject {
    [mutableDataArray addObject:personObject];

    NSMutableArray *archiveArray = [NSMutableArray arrayWithCapacity:mutableDataArray.count];
    for (BC_Person *personObject in mutableDataArray) { 
        NSData *personEncodedObject = [NSKeyedArchiver archivedDataWithRootObject:personObject];
        [archiveArray addObject:personEncodedObject];
    }

    NSUserDefaults *userData = [NSUserDefaults standardUserDefaults];
    [userData setObject:archiveArray forKey:@"personDataArray"];
}

Wydaje mi się, że marnowanie czasu przez tablicę i kodowanie obiektów w NSData jest raczej marnotrawstwem. Twój błąd BC_Person is a non-property-list objectmówi ci, że środowisko nie wie, jak serializować obiekt osoby.

Wystarczy więc upewnić się, że obiekt osoby jest zgodny z NSCoding, a następnie możesz po prostu przekonwertować tablicę niestandardowych obiektów na NSData i zapisać je w ustawieniach domyślnych. Oto plac zabaw:

Edycja : Zapisywanie do NSUserDefaultsXcode 7 jest przerwane, więc plac zabaw zarchiwizuje dane i utworzy kopię zapasową i wydrukuje dane wyjściowe. Krok UserDefaults jest zawarty w przypadku, gdy zostanie naprawiony w późniejszym punkcie

//: Playground - noun: a place where people can play

import Foundation

class Person: NSObject, NSCoding {
    let surname: String
    let firstname: String

    required init(firstname:String, surname:String) {
        self.firstname = firstname
        self.surname = surname
        super.init()
    }

    //MARK: - NSCoding -
    required init(coder aDecoder: NSCoder) {
        surname = aDecoder.decodeObjectForKey("surname") as! String
        firstname = aDecoder.decodeObjectForKey("firstname") as! String
    }

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

//: ### Now lets define a function to convert our array to NSData

func archivePeople(people:[Person]) -> NSData {
    let archivedObject = NSKeyedArchiver.archivedDataWithRootObject(people as NSArray)
    return archivedObject
}

//: ### Create some people

let people = [Person(firstname: "johnny", surname:"appleseed"),Person(firstname: "peter", surname: "mill")]

//: ### Archive our people to NSData

let peopleData = archivePeople(people)

if let unarchivedPeople = NSKeyedUnarchiver.unarchiveObjectWithData(peopleData) as? [Person] {
    for person in unarchivedPeople {
        print("\(person.firstname), you have been unarchived")
    }
} else {
    print("Failed to unarchive people")
}

//: ### Lets try use NSUserDefaults
let UserDefaultsPeopleKey = "peoplekey"
func savePeople(people:[Person]) {
    let archivedObject = archivePeople(people)
    let defaults = NSUserDefaults.standardUserDefaults()
    defaults.setObject(archivedObject, forKey: UserDefaultsPeopleKey)
    defaults.synchronize()
}

func retrievePeople() -> [Person]? {
    if let unarchivedObject = NSUserDefaults.standardUserDefaults().objectForKey(UserDefaultsPeopleKey) as? NSData {
        return NSKeyedUnarchiver.unarchiveObjectWithData(unarchivedObject) as? [Person]
    }
    return nil
}

if let retrievedPeople = retrievePeople() {
    for person in retrievedPeople {
        print("\(person.firstname), you have been unarchived")
    }
} else {
    print("Writing to UserDefaults is still broken in playgrounds")
}

I Voila, zapisałeś tablicę niestandardowych obiektów w NSUserDefaults

Zapisać:

NSUserDefaults *currentDefaults = [NSUserDefaults standardUserDefaults];
NSData *data = [NSKeyedArchiver archivedDataWithRootObject:yourObject];
[currentDefaults setObject:data forKey:@"yourKeyName"];

Aby uzyskać:

NSData *data = [currentDefaults objectForKey:@"yourKeyName"];
yourObjectType * token = [NSKeyedUnarchiver unarchiveObjectWithData:data];

Do usunięcia

[currentDefaults removeObjectForKey:@"yourKeyName"];

Rozwiązanie Swift 3

Prosta klasa użyteczności

class ArchiveUtil {

    private static let PeopleKey = "PeopleKey"

    private static func archivePeople(people : [Human]) -> NSData {

        return NSKeyedArchiver.archivedData(withRootObject: people as NSArray) as NSData
    }

    static func loadPeople() -> [Human]? {

        if let unarchivedObject = UserDefaults.standard.object(forKey: PeopleKey) as? Data {

            return NSKeyedUnarchiver.unarchiveObject(with: unarchivedObject as Data) as? [Human]
        }

        return nil
    }

    static func savePeople(people : [Human]?) {

        let archivedObject = archivePeople(people: people!)
        UserDefaults.standard.set(archivedObject, forKey: PeopleKey)
        UserDefaults.standard.synchronize()
    }

}

Klasa modelu

class Human: NSObject, NSCoding {

    var name:String?
    var age:Int?

    required init(n:String, a:Int) {

        name = n
        age = a
    }


    required init(coder aDecoder: NSCoder) {

        name = aDecoder.decodeObject(forKey: "name") as? String
        age = aDecoder.decodeInteger(forKey: "age")
    }


    public func encode(with aCoder: NSCoder) {

        aCoder.encode(name, forKey: "name")
        aCoder.encode(age, forKey: "age")

    }
}

Jak zadzwonić

var people = [Human]()

people.append(Human(n: "Sazzad", a: 21))
people.append(Human(n: "Hissain", a: 22))
people.append(Human(n: "Khan", a: 23))

ArchiveUtil.savePeople(people: people)

let others = ArchiveUtil.loadPeople()

for human in others! {

    print("name = \(human.name!), age = \(human.age!)")
}

Swift-4 Xcode 9.1

wypróbuj ten kod

nie możesz przechowywać mapera w NSUserDefault, możesz przechowywać tylko NSData, NSString, NSNumber, NSDate, NSArray lub NSDictionary.

let myData = NSKeyedArchiver.archivedData(withRootObject: myJson)
UserDefaults.standard.set(myData, forKey: "userJson")

let recovedUserJsonData = UserDefaults.standard.object(forKey: "userJson")
let recovedUserJson = NSKeyedUnarchiver.unarchiveObject(with: recovedUserJsonData)

Po pierwsze, odpowiedź rmaddy'ego (powyżej) jest poprawna: implementacja NSCodingnie pomaga. Musisz jednak wdrożyć, NSCodingaby używać NSKeyedArchiveri tak dalej, więc jest to tylko jeden krok ... konwersja za pośrednictwem NSData.

Przykładowe metody

- (NSUserDefaults *) defaults {
    return [NSUserDefaults standardUserDefaults];
}

- (void) persistObj:(id)value forKey:(NSString *)key {
    [self.defaults setObject:value  forKey:key];
    [self.defaults synchronize];
}

- (void) persistObjAsData:(id)encodableObject forKey:(NSString *)key {
    NSData *data = [NSKeyedArchiver archivedDataWithRootObject:encodableObject];
    [self persistObj:data forKey:key];
}    

- (id) objectFromDataWithKey:(NSString*)key {
    NSData *data = [self.defaults objectForKey:key];
    return [NSKeyedUnarchiver unarchiveObjectWithData:data];
}

Więc można owinąć swoje NSCodingobiekty w sposób NSArraylub NSDictionaryczy cokolwiek ...

Miałem problem z zapisaniem słownika NSUserDefaults. Okazuje się, że nie zapisałby, ponieważ zawierał NSNullwartości. Właśnie skopiowałem słownik do słownika zmiennego, usunąłem null, a następnie zapisałemNSUserDefaults

NSMutableDictionary* dictionary = [NSMutableDictionary dictionaryWithDictionary:dictionary_trying_to_save];
[dictionary removeObjectForKey:@"NullKey"];
[[NSUserDefaults standardUserDefaults] setObject:dictionary forKey:@"key"];

W tym przypadku wiedziałem, które klucze mogą być NSNullwartościami.

Swift 5: Zamiast NSKeyedArchiever można zastosować protokół Codable .

struct User: Codable {
    let id: String
    let mail: String
    let fullName: String
}

Struktura Pref jest niestandardowym opakowaniem wokół standardowego obiektu UserDefaults.

struct Pref {
    static let keyUser = "Pref.User"
    static var user: User? {
        get {
            if let data = UserDefaults.standard.object(forKey: keyUser) as? Data {
                do {
                    return try JSONDecoder().decode(User.self, from: data)
                } catch {
                    print("Error while decoding user data")
                }
            }
            return nil
        }
        set {
            if let newValue = newValue {
                do {
                    let data = try JSONEncoder().encode(newValue)
                    UserDefaults.standard.set(data, forKey: keyUser)
                } catch {
                    print("Error while encoding user data")
                }
            } else {
                UserDefaults.standard.removeObject(forKey: keyUser)
            }
        }
    }
}

Możesz więc użyć tego w ten sposób:

Pref.user?.name = "John"

if let user = Pref.user {...

Szybki z@propertyWrapper

Zapisz Codableobiekt wUserDefault

@propertyWrapper
    struct UserDefault<T: Codable> {
        let key: String
        let defaultValue: T

        init(_ key: String, defaultValue: T) {
            self.key = key
            self.defaultValue = defaultValue
        }

        var wrappedValue: T {
            get {

                if let data = UserDefaults.standard.object(forKey: key) as? Data,
                    let user = try? JSONDecoder().decode(T.self, from: data) {
                    return user

                }

                return  defaultValue
            }
            set {
                if let encoded = try? JSONEncoder().encode(newValue) {
                    UserDefaults.standard.set(encoded, forKey: key)
                }
            }
        }
    }




enum GlobalSettings {

    @UserDefault("user", defaultValue: User(name:"",pass:"")) static var user: User
}

Przykład Model użytkownika potwierdź Kodowalny

struct User:Codable {
    let name:String
    let pass:String
}

Jak tego użyć

//Set value 
 GlobalSettings.user = User(name: "Ahmed", pass: "Ahmed")

//GetValue
print(GlobalSettings.user)

https://developer.apple.com/reference/foundation/userdefaults

Obiektem domyślnym musi być lista właściwości - czyli instancja (lub w przypadku kolekcji, kombinacja instancji): NSData, NSString, NSNumber, NSDate, NSArray lub NSDictionary.

Jeśli chcesz przechowywać dowolny inny typ obiektu, zwykle powinieneś go zarchiwizować, aby utworzyć instancję NSData. Aby uzyskać więcej informacji, zobacz Preferencje i ustawienia Podręcznik programowania.

Swift 5 Bardzo łatwy sposób

//MARK:- First you need to encoded your arr or what ever object you want to save in UserDefaults
//in my case i want to save Picture (NMutableArray) in the User Defaults in
//in this array some objects are UIImage & Strings

//first i have to encoded the NMutableArray 
let encodedData = NSKeyedArchiver.archivedData(withRootObject: yourArrayName)
//MARK:- Array save in UserDefaults
defaults.set(encodedData, forKey: "YourKeyName")

//MARK:- When you want to retreive data from UserDefaults
let decoded  = defaults.object(forKey: "YourKeyName") as! Data
yourArrayName = NSKeyedUnarchiver.unarchiveObject(with: decoded) as! NSMutableArray

//MARK: Enjoy this arrry "yourArrayName"