객관적인 -c 동적 바인딩을 신속하게 변환 2

Question

obj-c 프로젝트를 신속하게 변환하는 상황이 있습니다. 다음과 같습니다.

// few lazy property initializers as, 
    @property (nonatomic, strong) MyObject *property1; 
    @property (nonatomic, strong) MyObject *property2; 
    @property (nonatomic, strong) MyObject *property3; 
    ... 

    // I keep an index value to map these into a dictionary for reference 
    - (NSDictionary *)indexMap 
    { 
    if (!_indexMap) 
    { 
    _indexMap = @{ 
    @(index1) : [NSValue valueWithPointer:@selector(property1)], 
    @(index2) : [NSValue valueWithPointer:@selector(property2)], 
    ... 
    }; 
    } 
    return _indexMap; 
    } 

// other dictionary for index to class map 
- (NSDictionary *)classMap 
{ 
return @{ 

NSStringFromClass(@"MyClassA") : @(index1), 
NSStringFromClass(@"MyClassB") : @(index1), 
NSStringFromClass(@"MyClassC") : @(index1), 

NSStringFromClass(@"MyClassD") : @(index2), 
NSStringFromClass(@"MyClassE") : @(index2), 

NSStringFromClass(@"MyClassF") : @(index3), 
... 
}; 
} 

// finally i have method to pass in the class name & it will first find corresponding index, then use the index to return the property selector. 

걱정되는 점은 무엇입니까?

Answer 1

이렇게하는 한 가지 방법은 초기화를 수행하는 콜백 목록을 유지하는 것입니다.

class ComponentManager { 

    // Global singleton: ComponentManager.sharedManager 
    static let sharedManager = ComponentManager() 

    // Define a callback type which is used to create instances. 
    // This is the lazy initialiser. 
    typealias Constructor =() -> NSObject? 

    private var constructor = [String: Constructor]() 
    private var instances = [String: NSObject]() 

    func register(name: String, constructor: Constructor) { 
     self.constructor[name] = constructor 
    } 

    func instanceNamed(name: String) -> NSObject? { 

     if let instance = instances[name] { 
      return instance 
     } 

     guard let constructor = constructor[name] else { 
      return nil 
     } 

     guard let instance = constructor() else { 
      return nil 
     } 

     instances[name] = instance 

     return instance 
    } 
} 

그것을 사용하려면 :

class A: NSObject { 
    let foo: String 
    init(foo: String) { 
     self.foo = foo 
    } 
} 

class B: NSObject { 
    let bar: Int 
    init(bar: Int) { 
     self.bar = bar 
    } 
} 

let manager = ComponentManager.sharedManager 

// Register our classes. 
// Note the callback functions which actually perform the 
// initialisation, these are only called when the class is requested the 
// first time. 
manager.register("A") { return A(foo: "fizz") } 
manager.register("B") { return B(bar: 47) } 

// Create some instances 
let a = manager.instanceNamed("A") as? A 
let b = manager.instanceNamed("B") as? B 
let a2 = manager.instanceNamed("A") as? A 

print("a = \(a?.foo)") 
print("a2 = \(a?.foo)") 
print("b = \(b?.bar)")