Làm cách nào để lưu trữ các thuộc tính trong Swift, giống như cách tôi đã có trên Objective-C?

Tôi đang chuyển đổi một ứng dụng từ Objective-C sang Swift, ví dụ tôi có một vài loại với các thuộc tính được lưu trữ:

@interface UIView (MyCategory)

- (void)alignToView:(UIView *)view
          alignment:(UIViewRelativeAlignment)alignment;
- (UIView *)clone;

@property (strong) PFObject *xo;
@property (nonatomic) BOOL isAnimating;

@end

Vì các tiện ích mở rộng Swift không chấp nhận các thuộc tính được lưu trữ như thế này, tôi không biết cách duy trì cấu trúc giống như mã Objc. Các thuộc tính được lưu trữ thực sự quan trọng đối với ứng dụng của tôi và tôi tin rằng Apple phải tạo ra một số giải pháp để thực hiện điều đó trong Swift.

Như đã nói bởi jou, những gì tôi đang tìm kiếm thực sự là sử dụng các đối tượng liên quan, vì vậy tôi đã làm (trong một bối cảnh khác):

import Foundation
import QuartzCore
import ObjectiveC

extension CALayer {
    var shapeLayer: CAShapeLayer? {
        get {
            return objc_getAssociatedObject(self, "shapeLayer") as? CAShapeLayer
        }
        set(newValue) {
            objc_setAssociatedObject(self, "shapeLayer", newValue, UInt(OBJC_ASSOCIATION_RETAIN))
        }
    }

    var initialPath: CGPathRef! {
        get {
            return objc_getAssociatedObject(self, "initialPath") as CGPathRef
        }
        set {
            objc_setAssociatedObject(self, "initialPath", newValue, UInt(OBJC_ASSOCIATION_RETAIN))
        }
    }
}

Nhưng tôi nhận được EXC_BAD_ACCESS khi thực hiện:

class UIBubble : UIView {
    required init(coder aDecoder: NSCoder) {
        ...
        self.layer.shapeLayer = CAShapeLayer()
        ...
    }
}

Có ý kiến ​​gì không?

API đối tượng liên kết là một chút rườm rà để sử dụng. Bạn có thể loại bỏ hầu hết các mẫu soạn sẵn với lớp trợ giúp.

public final class ObjectAssociation<T: AnyObject> {

    private let policy: objc_AssociationPolicy

    /// - Parameter policy: An association policy that will be used when linking objects.
    public init(policy: objc_AssociationPolicy = .OBJC_ASSOCIATION_RETAIN_NONATOMIC) {

        self.policy = policy
    }

    /// Accesses associated object.
    /// - Parameter index: An object whose associated object is to be accessed.
    public subscript(index: AnyObject) -> T? {

        get { return objc_getAssociatedObject(index, Unmanaged.passUnretained(self).toOpaque()) as! T? }
        set { objc_setAssociatedObject(index, Unmanaged.passUnretained(self).toOpaque(), newValue, policy) }
    }
}

Với điều kiện bạn có thể "thêm" một thuộc tính vào lớp object-c theo cách dễ đọc hơn:

extension SomeType {

    private static let association = ObjectAssociation<NSObject>()

    var simulatedProperty: NSObject? {

        get { return SomeType.association[self] }
        set { SomeType.association[self] = newValue }
    }
}

Đối với giải pháp:

extension CALayer {

    private static let initialPathAssociation = ObjectAssociation<CGPath>()
    private static let shapeLayerAssociation = ObjectAssociation<CAShapeLayer>()

    var initialPath: CGPath! {
        get { return CALayer.initialPathAssociation[self] }
        set { CALayer.initialPathAssociation[self] = newValue }
    }

    var shapeLayer: CAShapeLayer? {
        get { return CALayer.shapeLayerAssociation[self] }
        set { CALayer.shapeLayerAssociation[self] = newValue }
    }
}

Như trong Objective-C, bạn không thể thêm thuộc tính được lưu trữ vào các lớp hiện có. Nếu bạn đang mở rộng một lớp Objective-C ( UIViewchắc chắn là một lớp), bạn vẫn có thể sử dụng Đối tượng liên kết để mô phỏng các thuộc tính được lưu trữ:

cho Swift 1

import ObjectiveC

private var xoAssociationKey: UInt8 = 0

extension UIView {
    var xo: PFObject! {
        get {
            return objc_getAssociatedObject(self, &xoAssociationKey) as? PFObject
        }
        set(newValue) {
            objc_setAssociatedObject(self, &xoAssociationKey, newValue, objc_AssociationPolicy(OBJC_ASSOCIATION_RETAIN))
        }
    }
}

Khóa kết hợp là một con trỏ phải là duy nhất cho mỗi liên kết. Vì vậy, chúng tôi tạo một biến toàn cục riêng và sử dụng địa chỉ bộ nhớ của nó làm khóa với &toán tử. Xem phần Sử dụng Swift với Ca cao và Mục tiêu-C để biết thêm chi tiết về cách xử lý con trỏ trong Swift.

CẬP NHẬT cho Swift 2 và 3

import ObjectiveC

private var xoAssociationKey: UInt8 = 0

extension UIView {
    var xo: PFObject! {
        get {
            return objc_getAssociatedObject(self, &xoAssociationKey) as? PFObject
        }
        set(newValue) {
            objc_setAssociatedObject(self, &xoAssociationKey, newValue, objc_AssociationPolicy.OBJC_ASSOCIATION_RETAIN)
        }
    }
}

CẬP NHẬT cho Swift 4

Trong Swift 4, nó đơn giản hơn nhiều. Cấu trúc Chủ sở hữu sẽ chứa giá trị riêng mà tài sản được tính toán của chúng tôi sẽ hiển thị với thế giới, tạo ảo giác về hành vi tài sản được lưu trữ thay thế.

Nguồn

extension UIViewController {
    struct Holder {
        static var _myComputedProperty:Bool = false
    }
    var myComputedProperty:Bool {
        get {
            return Holder._myComputedProperty
        }
        set(newValue) {
            Holder._myComputedProperty = newValue
        }
    }
}

Vì vậy, tôi nghĩ rằng tôi đã tìm thấy một phương pháp hoạt động sạch hơn các phương pháp trên bởi vì nó không yêu cầu bất kỳ biến toàn cục nào. Tôi đã nhận nó từ đây: http://nshipster.com/swift-objc-r nb /

Ý chính là bạn sử dụng một cấu trúc như vậy:

extension UIViewController {
    private struct AssociatedKeys {
        static var DescriptiveName = "nsh_DescriptiveName"
    }

    var descriptiveName: String? {
        get {
            return objc_getAssociatedObject(self, &AssociatedKeys.DescriptiveName) as? String
        }
        set {
            if let newValue = newValue {
                objc_setAssociatedObject(
                    self,
                    &AssociatedKeys.DescriptiveName,
                    newValue as NSString?,
                    UInt(OBJC_ASSOCIATION_RETAIN_NONATOMIC)
                )
            }
        }
    }
}

CẬP NHẬT cho Swift 2

private struct AssociatedKeys {
    static var displayed = "displayed"
}

//this lets us check to see if the item is supposed to be displayed or not
var displayed : Bool {
    get {
        guard let number = objc_getAssociatedObject(self, &AssociatedKeys.displayed) as? NSNumber else {
            return true
        }
        return number.boolValue
    }

    set(value) {
        objc_setAssociatedObject(self,&AssociatedKeys.displayed,NSNumber(bool: value),objc_AssociationPolicy.OBJC_ASSOCIATION_RETAIN_NONATOMIC)
    }
}

Giải pháp được chỉ ra bởi jou không hỗ trợ các loại giá trị , điều này cũng hoạt động tốt với chúng

Giấy gói

import ObjectiveC

final class Lifted<T> {
    let value: T
    init(_ x: T) {
        value = x
    }
}

private func lift<T>(x: T) -> Lifted<T>  {
    return Lifted(x)
}

func setAssociatedObject<T>(object: AnyObject, value: T, associativeKey: UnsafePointer<Void>, policy: objc_AssociationPolicy) {
    if let v: AnyObject = value as? AnyObject {
        objc_setAssociatedObject(object, associativeKey, v,  policy)
    }
    else {
        objc_setAssociatedObject(object, associativeKey, lift(value),  policy)
    }
}

func getAssociatedObject<T>(object: AnyObject, associativeKey: UnsafePointer<Void>) -> T? {
    if let v = objc_getAssociatedObject(object, associativeKey) as? T {
        return v
    }
    else if let v = objc_getAssociatedObject(object, associativeKey) as? Lifted<T> {
        return v.value
    }
    else {
        return nil
    }
}

Một phần mở rộng Class có thể (Ví dụ về cách sử dụng):

extension UIView {

    private struct AssociatedKey {
        static var viewExtension = "viewExtension"
    }

    var referenceTransform: CGAffineTransform? {
        get {
            return getAssociatedObject(self, associativeKey: &AssociatedKey.viewExtension)
        }

        set {
            if let value = newValue {
                setAssociatedObject(self, value: value, associativeKey: &AssociatedKey.viewExtension, policy: objc_AssociationPolicy.OBJC_ASSOCIATION_RETAIN_NONATOMIC)
            }
        }
    }
}

Đây thực sự là một giải pháp tuyệt vời, tôi muốn thêm một ví dụ sử dụng khác bao gồm các cấu trúc và giá trị không phải là tùy chọn. Ngoài ra, các giá trị AssociatedKey có thể được đơn giản hóa.

struct Crate {
    var name: String
}

class Box {
    var name: String

    init(name: String) {
        self.name = name
    }
}

extension UIViewController {

    private struct AssociatedKey {
        static var displayed:   UInt8 = 0
        static var box:         UInt8 = 0
        static var crate:       UInt8 = 0
    }

    var displayed: Bool? {
        get {
            return getAssociatedObject(self, associativeKey: &AssociatedKey.displayed)
        }

        set {
            if let value = newValue {
                setAssociatedObject(self, value: value, associativeKey: &AssociatedKey.displayed, policy: objc_AssociationPolicy.OBJC_ASSOCIATION_RETAIN_NONATOMIC)
            }
        }
    }

    var box: Box {
        get {
            if let result:Box = getAssociatedObject(self, associativeKey: &AssociatedKey.box) {
                return result
            } else {
                let result = Box(name: "")
                self.box = result
                return result
            }
        }

        set {
            setAssociatedObject(self, value: newValue, associativeKey: &AssociatedKey.box, policy: objc_AssociationPolicy.OBJC_ASSOCIATION_RETAIN_NONATOMIC)
        }
    }

    var crate: Crate {
        get {
            if let result:Crate = getAssociatedObject(self, associativeKey: &AssociatedKey.crate) {
                return result
            } else {
                let result = Crate(name: "")
                self.crate = result
                return result
            }
        }

        set {
            setAssociatedObject(self, value: newValue, associativeKey: &AssociatedKey.crate, policy: objc_AssociationPolicy.OBJC_ASSOCIATION_RETAIN_NONATOMIC)
        }
    }
}

Bạn không thể xác định danh mục (tiện ích mở rộng Swift) với bộ nhớ mới; bất kỳ thuộc tính bổ sung nào phải được tính toán thay vì được lưu trữ. Cú pháp hoạt động cho Objective C vì @propertytrong một danh mục về cơ bản có nghĩa là "Tôi sẽ cung cấp getter và setter". Trong Swift, bạn sẽ cần tự xác định những thứ này để có được một tài sản được tính toán; cái gì đó như:

extension String {
    public var Foo : String {
        get
        {
            return "Foo"
        }

        set
        {
            // What do you want to do here?
        }
    }
}

Nên làm việc tốt. Hãy nhớ rằng, bạn không thể lưu trữ các giá trị mới trong setter, chỉ hoạt động với trạng thái lớp khả dụng hiện có.

0,02 đô la của tôi. Mã này được viết bằng Swift 2.0

extension CALayer {
    private struct AssociatedKeys {
        static var shapeLayer:CAShapeLayer?
    }

    var shapeLayer: CAShapeLayer? {
        get {
            return objc_getAssociatedObject(self, &AssociatedKeys.shapeLayer) as? CAShapeLayer
        }
        set {
            if let newValue = newValue {
                objc_setAssociatedObject(self, &AssociatedKeys.shapeLayer, newValue as CAShapeLayer?, objc_AssociationPolicy.OBJC_ASSOCIATION_RETAIN_NONATOMIC)
            }
        }
    }
}

Tôi đã thử nhiều giải pháp và thấy đây là cách duy nhất để thực sự mở rộng một lớp với các tham số biến phụ.

Tại sao phải dựa vào thời gian chạy objc? Tôi không nhận được điểm. Bằng cách sử dụng một cái gì đó như sau, bạn sẽ đạt được hành vi gần như giống hệt của một tài sản được lưu trữ, bằng cách chỉ sử dụng một cách tiếp cận Swift thuần túy :

extension UIViewController {
    private static var _myComputedProperty = [String:Bool]()

    var myComputedProperty:Bool {
        get {
            let tmpAddress = String(format: "%p", unsafeBitCast(self, to: Int.self))
            return UIViewController._myComputedProperty[tmpAddress] ?? false
        }
        set(newValue) {
            let tmpAddress = String(format: "%p", unsafeBitCast(self, to: Int.self))
            UIViewController._myComputedProperty[tmpAddress] = newValue
        }
    }
}

Tôi thích làm mã trong Swift thuần túy và không dựa vào di sản Objective-C. Vì điều này tôi đã viết giải pháp Swift thuần túy với hai ưu điểm và hai nhược điểm.

Ưu điểm:

1. Mã Swift tinh khiết

2. Hoạt động trên các lớp và hoàn thành hoặc cụ thể hơn trên Anyđối tượng

Nhược điểm:

1. Mã nên gọi phương thức willDeinit()để giải phóng các đối tượng được liên kết với thể hiện của lớp cụ thể để tránh rò rỉ bộ nhớ

2. Bạn không thể tạo tiện ích mở rộng trực tiếp cho UIView cho ví dụ chính xác này vì đây var framelà tiện ích mở rộng cho UIView, không phải là một phần của lớp.

BIÊN TẬP:

import UIKit

var extensionPropertyStorage: [NSObject: [String: Any]] = [:]

var didSetFrame_ = "didSetFrame"

extension UILabel {

    override public var frame: CGRect {

        get {
            return didSetFrame ?? CGRectNull
        }

        set {
            didSetFrame = newValue
        }
    }

    var didSetFrame: CGRect? {

        get {
            return extensionPropertyStorage[self]?[didSetFrame_] as? CGRect
        }

        set {
            var selfDictionary = extensionPropertyStorage[self] ?? [String: Any]()

            selfDictionary[didSetFrame_] = newValue

            extensionPropertyStorage[self] = selfDictionary
        }
    }

    func willDeinit() {
        extensionPropertyStorage[self] = nil
    }
}

Với Danh mục Obj-c, bạn chỉ có thể thêm các phương thức, không phải các biến thể hiện.

Trong ví dụ của bạn, bạn đã sử dụng @property như một lối tắt để thêm khai báo phương thức getter và setter. Bạn vẫn cần phải thực hiện các phương pháp đó.

Tương tự như vậy trong Swift, bạn có thể thêm các tiện ích mở rộng để thêm các phương thức cá thể, các thuộc tính được tính toán, v.v. nhưng không được lưu trữ các thuộc tính.

Tôi cũng nhận được một vấn đề EXC_BAD_ACCESS. Giá trị trong objc_getAssociatedObject()và objc_setAssociatedObject()phải là một Đối tượng. Và objc_AssociationPolicynên phù hợp với Object.

Tôi đã thử sử dụng objc_setAssociatedObject như được đề cập trong một vài câu trả lời ở đây, nhưng sau khi thất bại với nó một vài lần tôi đã lùi lại và nhận ra không có lý do gì tôi cần điều đó. Mượn từ một vài ý tưởng ở đây, tôi đã nghĩ ra mã này chỉ đơn giản là lưu trữ một mảng của bất kỳ dữ liệu bổ sung nào của tôi (MyClass trong ví dụ này) được lập chỉ mục bởi đối tượng tôi muốn liên kết với nó:

class MyClass {
    var a = 1
    init(a: Int)
    {
        self.a = a
    }
}

extension UIView
{
    static var extraData = [UIView: MyClass]()

    var myClassData: MyClass? {
        get {
            return UIView.extraData[self]
        }
        set(value) {
            UIView.extraData[self] = value
        }
    }
}

// Test Code: (Ran in a Swift Playground)
var view1 = UIView()
var view2 = UIView()

view1.myClassData = MyClass(a: 1)
view2.myClassData = MyClass(a: 2)
print(view1.myClassData?.a)
print(view2.myClassData?.a)

Đây là giải pháp đơn giản và biểu cảm hơn. Nó hoạt động cho cả hai loại giá trị và tham chiếu. Cách tiếp cận nâng được lấy từ câu trả lời của @HepaKKes.

Mã hiệp hội:

import ObjectiveC

final class Lifted<T> {
    let value: T
    init(_ x: T) {
        value = x
    }
}

private func lift<T>(_ x: T) -> Lifted<T>  {
    return Lifted(x)
}

func associated<T>(to base: AnyObject,
                key: UnsafePointer<UInt8>,
                policy: objc_AssociationPolicy = .OBJC_ASSOCIATION_RETAIN,
                initialiser: () -> T) -> T {
    if let v = objc_getAssociatedObject(base, key) as? T {
        return v
    }

    if let v = objc_getAssociatedObject(base, key) as? Lifted<T> {
        return v.value
    }

    let lifted = Lifted(initialiser())
    objc_setAssociatedObject(base, key, lifted, policy)
    return lifted.value
}

func associate<T>(to base: AnyObject, key: UnsafePointer<UInt8>, value: T, policy: objc_AssociationPolicy = .OBJC_ASSOCIATION_RETAIN) {
    if let v: AnyObject = value as AnyObject? {
        objc_setAssociatedObject(base, key, v, policy)
    }
    else {
        objc_setAssociatedObject(base, key, lift(value), policy)
    }
}

Ví dụ về cách sử dụng:

1) Tạo phần mở rộng và liên kết các thuộc tính với nó. Hãy sử dụng cả hai thuộc tính loại giá trị và tham chiếu.

extension UIButton {

    struct Keys {
        static fileprivate var color: UInt8 = 0
        static fileprivate var index: UInt8 = 0
    }

    var color: UIColor {
        get {
            return associated(to: self, key: &Keys.color) { .green }
        }
        set {
            associate(to: self, key: &Keys.color, value: newValue)
        }
    }

    var index: Int {
        get {
            return associated(to: self, key: &Keys.index) { -1 }
        }
        set {
            associate(to: self, key: &Keys.index, value: newValue)
        }
    }

}

2) Bây giờ bạn có thể sử dụng như các thuộc tính thông thường:

    let button = UIButton()
    print(button.color) // UIExtendedSRGBColorSpace 0 1 0 1 == green
    button.color = .black
    print(button.color) // UIExtendedGrayColorSpace 0 1 == black

    print(button.index) // -1
    button.index = 3
    print(button.index) // 3

Thêm chi tiết:

1. Nâng là cần thiết để bọc các loại giá trị.
2. Hành vi đối tượng liên quan mặc định được giữ lại. Nếu bạn muốn tìm hiểu thêm về các đối tượng liên quan, tôi khuyên bạn nên kiểm tra bài viết này .

Một ví dụ khác với việc sử dụng các đối tượng liên quan đến Objective-C và các thuộc tính được tính cho Swift 3 và Swift 4

import CoreLocation

extension CLLocation {

    private struct AssociatedKeys {
        static var originAddress = "originAddress"
        static var destinationAddress = "destinationAddress"
    }

    var originAddress: String? {
        get {
            return objc_getAssociatedObject(self, &AssociatedKeys.originAddress) as? String
        }
        set {
            if let newValue = newValue {
                objc_setAssociatedObject(
                    self,
                    &AssociatedKeys.originAddress,
                    newValue as NSString?,
                    .OBJC_ASSOCIATION_RETAIN_NONATOMIC
                )
            }
        }
    }

    var destinationAddress: String? {
        get {
            return objc_getAssociatedObject(self, &AssociatedKeys.destinationAddress) as? String
        }
        set {
            if let newValue = newValue {
                objc_setAssociatedObject(
                    self,
                    &AssociatedKeys.destinationAddress,
                    newValue as NSString?,
                    .OBJC_ASSOCIATION_RETAIN_NONATOMIC
                )
            }
        }
    }

}

nếu bạn đang tìm cách đặt thuộc tính chuỗi tùy chỉnh thành UIView, đây là cách tôi đã thực hiện trên Swift 4

Tạo tiện ích mở rộng UIView

extension UIView {

    func setStringValue(value: String, key: String) {
        layer.setValue(value, forKey: key)
    }

    func stringValueFor(key: String) -> String? {
        return layer.value(forKey: key) as? String
    }
}

Để sử dụng tiện ích mở rộng này

let key = "COLOR"

let redView = UIView() 

// To set
redView.setStringAttribute(value: "Red", key: key)

// To read
print(redView.stringValueFor(key: key)) // Optional("Red")

Cách lưu trữ bản đồ tĩnh đến lớp đang mở rộng như thế này:

extension UIView {

    struct Holder {
        static var _padding:[UIView:UIEdgeInsets] = [:]
    }

    var padding : UIEdgeInsets {
        get{ return UIView.Holder._padding[self] ?? .zero}
        set { UIView.Holder._padding[self] = newValue }
    }

}

Tôi đã cố gắng lưu trữ các thuộc tính bằng cách sử dụng objc_getAssociatedObject, objc_setAssociatedObject, mà không gặp may mắn. Mục tiêu của tôi là tạo tiện ích mở rộng cho UITextField, để xác thực độ dài ký tự nhập văn bản. Mã sau hoạt động tốt cho tôi. Hy vọng điều này sẽ giúp được ai đó.

private var _min: Int?
private var _max: Int?

extension UITextField {    
    @IBInspectable var minLength: Int {
        get {
            return _min ?? 0
        }
        set {
            _min = newValue
        }
    }

    @IBInspectable var maxLength: Int {
        get {
            return _max ?? 1000
        }
        set {
            _max = newValue
        }
    }

    func validation() -> (valid: Bool, error: String) {
        var valid: Bool = true
        var error: String = ""
        guard let text = self.text else { return (true, "") }

        if text.characters.count < minLength {
            valid = false
            error = "Textfield should contain at least \(minLength) characters"
        }

        if text.characters.count > maxLength {
            valid = false
            error = "Textfield should not contain more then \(maxLength) characters"
        }

        if (text.characters.count < minLength) && (text.characters.count > maxLength) {
            valid = false
            error = "Textfield should contain at least \(minLength) characters\n"
            error = "Textfield should not contain more then \(maxLength) characters"
        }

        return (valid, error)
    }
}

Đây là một thay thế cũng hoạt động

public final class Storage : AnyObject {

    var object:Any?

    public init(_ object:Any) {
        self.object = object
    }
}

extension Date {

    private static let associationMap = NSMapTable<NSString, AnyObject>()
    private struct Keys {
        static var Locale:NSString = "locale"
    }

    public var locale:Locale? {
        get {

            if let storage = Date.associationMap.object(forKey: Keys.Locale) {
                return (storage as! Storage).object as? Locale
            }
            return nil
        }
        set {
            if newValue != nil {
                Date.associationMap.setObject(Storage(newValue), forKey: Keys.Locale)
            }
        }
    }
}



var date = Date()
date.locale = Locale(identifier: "pt_BR")
print( date.locale )

Tôi thấy giải pháp này thiết thực hơn

CẬP NHẬT cho Swift 3

extension UIColor {

    static let graySpace = UIColor.init(red: 50/255, green: 50/255, blue: 50/255, alpha: 1.0)
    static let redBlood = UIColor.init(red: 102/255, green: 0/255, blue: 0/255, alpha: 1.0)
    static let redOrange = UIColor.init(red: 204/255, green: 17/255, blue: 0/255, alpha: 1.0)

    func alpha(value : CGFloat) -> UIColor {
        var r = CGFloat(0), g = CGFloat(0), b = CGFloat(0), a = CGFloat(0)
        self.getRed(&r, green: &g, blue: &b, alpha: &a)
        return UIColor(red: r, green: g, blue: b, alpha: value)
    }

}

... sau đó trong mã của bạn

class gameController: UIViewController {

    @IBOutlet var game: gameClass!

    override func viewDidLoad() {
        self.view.backgroundColor = UIColor.graySpace

    }
}