Objective-C에서와 같은 방식으로 Swift에 속성을 저장하는 방법은 무엇입니까?

Objective-C에서 Swift로 응용 프로그램을 전환하고 있는데, 여기에는 저장된 속성이있는 몇 가지 범주가 있습니다.

@interface UIView (MyCategory)

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

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

@end

Swift 확장은 이와 같은 저장된 속성을 허용하지 않으므로 Objc 코드와 동일한 구조를 유지하는 방법을 모르겠습니다. 저장된 속성은 내 앱에서 정말 중요하며 Apple이 Swift에서 솔루션을 만들 수있는 솔루션을 만들어야한다고 생각합니다.

jou가 말했듯이, 내가 찾고 있던 것은 실제로 관련 객체를 사용하는 것이 었으므로 (다른 맥락에서)했습니다.

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))
        }
    }
}

그러나 나는 할 때 EXC_BAD_ACCESS를 얻습니다.

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

어떤 아이디어?

관련 객체 API는 사용하기에 약간 번거 롭습니다. 헬퍼 클래스를 사용하여 대부분의 상용구를 제거 할 수 있습니다.

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) }
    }
}

보다 읽기 쉬운 방식으로 objective-c 클래스에 속성을 "추가"할 수있는 경우 :

extension SomeType {

    private static let association = ObjectAssociation<NSObject>()

    var simulatedProperty: NSObject? {

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

해결책은 다음과 같습니다.

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 }
    }
}

Objective-C에서와 같이 기존 클래스에 저장된 속성을 추가 할 수 없습니다. Objective-C 클래스를 확장하는 경우 ( UIView확실히 하나임) 연결된 객체 를 사용 하여 저장된 속성을 에뮬레이션 할 수 있습니다.

스위프트 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))
        }
    }
}

연관 키는 각 연관에 고유해야하는 포인터입니다. 이를 위해 개인 전역 변수를 만들고 메모리 주소를 &연산자 의 키로 사용합니다 . Swift에서 포인터를 처리하는 방법에 대한 자세한 내용 은 Cocoa 및 Objective-C와 함께 Swift 사용을 참조하십시오 .

스위프트 2와 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)
        }
    }
}

Swift 4 용으로 업데이트

Swift 4에서는 훨씬 간단합니다. Holder 구조체는 계산 된 프로퍼티가 월드에 노출되는 프라이빗 값을 포함하고 대신 저장된 프로퍼티 동작의 환영을줍니다.

출처

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

그래서 전역 변수가 필요하지 않기 때문에 위의 방법보다 깨끗하게 작동하는 방법을 찾았습니다. 나는 여기에서 얻었습니다 : http://nshipster.com/swift-objc-runtime/

요점은 다음과 같은 구조체를 사용한다는 것입니다.

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)
                )
            }
        }
    }
}

스위프트 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)
    }
}

jou 가 지적한 솔루션은 값 유형을 지원하지 않습니다 .이 유형 도 잘 작동합니다.

포장지

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
    }
}

가능한 클래스 확장 (사용 예) :

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)
            }
        }
    }
}

이것은 정말 훌륭한 솔루션입니다. 옵션이 아닌 구조체와 값을 포함하는 다른 사용 예제를 추가하고 싶었습니다. 또한 AssociatedKey 값을 단순화 할 수 있습니다.

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)
        }
    }
}

새 저장소로 범주 (Swift 확장)를 정의 할 수 없습니다. 추가 속성은 저장하지 않고 계산 해야합니다 . @property범주에서 본질적으로 "게터와 세터를 제공하겠습니다"를 의미 하므로 구문은 목표 C에 적용 됩니다. Swift에서는 계산 된 속성을 얻기 위해이를 직접 정의해야합니다. 같은 :

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

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

잘 작동합니다. setter에 새 값을 저장할 수 없으며 기존의 사용 가능한 클래스 상태에서만 작동합니다.

내 $ 0.02. 이 코드는 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)
            }
        }
    }
}

많은 솔루션을 시도했지만 이것이 추가 변수 매개 변수로 클래스를 실제로 확장하는 유일한 방법이라는 것을 알았습니다.

objc 런타임에 의존하는 이유는 무엇입니까? 나는 요점을 모른다. 다음과 같은 것을 사용하면 순수한 스위프트 접근 방식 만 사용하여 저장된 속성과 거의 동일한 동작을 달성 할 수 있습니다 .

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
        }
    }
}

순수한 Swift에서 코드를 작성하는 것을 선호하며 Objective-C 유산에 의존하지 않습니다. 이 때문에 두 가지 장점과 두 가지 단점이있는 순수한 Swift 솔루션을 작성했습니다.

장점 :

1. 순수한 스위프트 코드

2. 수업 및 완료 또는 더 구체적으로 Any객체에서 작동

단점 :

1. 코드는 willDeinit()메모리 누수를 피하기 위해 특정 클래스 인스턴스에 연결된 객체를 해제하는 메소드 를 호출해야합니다.

2. var frame클래스의 일부가 아닌 UIView에 대한 확장이므로이 정확한 예제를 위해 UIView에 직접 확장 할 수 없습니다 .

편집하다:

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
    }
}

Obj-c 카테고리를 사용하면 인스턴스 변수가 아닌 메소드 만 추가 할 수 있습니다.

예를 들어, @property를 getter 및 setter 메소드 선언을 추가하는 바로 가기로 사용했습니다. 여전히 이러한 메소드를 구현해야합니다.

마찬가지로 Swift에서 사용 확장을 추가하여 인스턴스 메소드, 계산 된 속성 등을 추가 할 수 있지만 저장된 속성은 추가 할 수 없습니다.

나는 또한에 EXC_BAD_ACCESS 것은 문제도 값을 얻을 objc_getAssociatedObject()및 objc_setAssociatedObject()객체이어야한다. 그리고 objc_AssociationPolicy객체와 일치해야합니다.

여기에 몇 가지 답변에서 언급 한 것처럼 objc_setAssociatedObject를 사용해 보았지만 몇 번 실패하면 다시 물러나서 그럴 필요가 없다는 것을 깨달았습니다. 여기 몇 가지 아이디어를 빌려서이 코드를 생각해 냈습니다.이 코드는 연결하려는 객체에 의해 색인 된 추가 데이터 (이 예제에서는 MyClass)의 배열을 간단히 저장합니다.

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)

여기에 간단하고 표현력있는 솔루션이 있습니다. 값과 참조 유형 모두에서 작동합니다. 리프팅 방법은 @HepaKKes 답변에서 가져옵니다.

협회 코드 :

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)
    }
}

사용 예 :

1) 확장을 만들고 속성을 연결하십시오. 값과 참조 유형 속성을 모두 사용합시다.

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) 이제 일반 속성처럼 사용할 수 있습니다.

    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

자세한 내용은:

1. 래핑 값 유형에는 리프팅이 필요합니다.
2. 연관된 기본 개체 동작은 유지입니다. 관련 객체에 대한 자세한 내용은 이 기사를 확인 하는 것이 좋습니다 .

Swift 3 및 Swift 4에 Objective-C 관련 객체 및 계산 된 속성을 사용하는 또 다른 예

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
                )
            }
        }
    }

}

사용자 정의 문자열 속성을 UIView로 설정하려는 경우 Swift 4에서 수행 한 방법입니다.

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
    }
}

이 확장을 사용하려면

let key = "COLOR"

let redView = UIView() 

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

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

정적 맵을 다음과 같이 확장되는 클래스에 저장하는 방법은 다음과 같습니다.

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 }
    }

}

운없이 objc_getAssociatedObject, objc_setAssociatedObject를 사용하여 속성을 저장하려고했습니다. 내 목표는 텍스트 입력 문자 길이를 확인하기 위해 UITextField의 확장을 만드는 것이 었습니다. 다음 코드는 잘 작동합니다. 이것이 누군가를 도울 수 있기를 바랍니다.

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)
    }
}

다음은 또한 작동하는 대안입니다.

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 )

이 솔루션이 더 실용적이라는 것을 알았습니다.

스위프트 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)
    }

}

... 그런 다음 코드에서

class gameController: UIViewController {

    @IBOutlet var game: gameClass!

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

    }
}