Szybka introspekcja i typy ogólne

Próbuję dynamicznie tworzyć classtypy oparte na instancjach przy użyciu typów ogólnych, jednak napotykam trudności z introspekcją klas.

Oto pytania:

• Czy istnieje odpowiednik języka Swift dla Obj-C self.class?
• Czy istnieje sposób na utworzenie wystąpienia klasy przy użyciu AnyClasswyniku z NSClassFromString?
• Czy istnieje sposób, aby uzyskać AnyClasslub w inny sposób wpisać informacje wyłącznie z parametru ogólnego T? (Podobna do typeof(T)składni C # )

Cóż, po pierwsze, Swift odpowiednikiem [NSString class]jest .self(zobacz dokumentację Metatype , chociaż są dość cienkie).

W rzeczywistości NSString.classnawet nie działa! Musisz użyć NSString.self.

let s = NSString.self
var str = s()
str = "asdf"

Podobnie z szybką klasą próbowałem ...

class MyClass {

}

let MyClassRef = MyClass.self

// ERROR :(
let my_obj = MyClassRef()

Hmm… błąd mówi:

Wykonanie placu zabaw nie powiodło się: błąd:: 16: 1: błąd: skonstruowanie obiektu klasy typu „X” z wartością metatypu wymaga inicjatora „@required”

 Y().me()
 ^
 <REPL>:3:7: note: selected implicit initializer with type '()'
 class X {
       ^

Zajęło mi trochę czasu, zanim zrozumiałem, co to znaczy… okazuje się, że chce, aby klasa miała @required init()

class X {
    func me() {
        println("asdf")
    }

    required init () {

    }
}

let Y = X.self

// prints "asdf"
Y().me()

Niektóre dokumenty odnoszą się do tego jako .Type, ale wyświetla MyClass.Typemi błąd na placu zabaw.

Oto jak używać NSClassFromString. Musisz znać superklasę tego, z czym skończysz. Oto para nadklasa-podklasa, która wie, jak się opisać dla println:

@objc(Zilk) class Zilk : NSObject {
    override var description : String {return "I am a Zilk"}
}

@objc(Zork) class Zork : Zilk {
    override var description : String {return "I am a Zork"}
}

Zwróć uwagę na użycie specjalnej @objskładni, która dyktuje nazwę tych klas zmienioną przez Objective-C; jest to kluczowe, ponieważ w przeciwnym razie nie znamy połączonego łańcucha, który wyznacza każdą klasę.

Teraz możemy użyć NSClassFromStringdo stworzenia klasy Zork lub Zilk, ponieważ wiemy, że możemy wpisać go jako obiekt NSO i nie ulegnie awarii później:

let aClass = NSClassFromString("Zork") as NSObject.Type
let anObject = aClass()
println(anObject) // "I am a Zork"

I to jest odwracalne; println(NSStringFromClass(anObject.dynamicType))również działa.

Nowoczesna wersja:

    if let aClass = NSClassFromString("Zork") as? NSObject.Type {
        let anObject = aClass.init()
        print(anObject) // "I am a Zork"
        print(NSStringFromClass(type(of:anObject))) // Zork
    }

Jeśli dobrze czytam dokumentację, jeśli masz do czynienia z instancjami i np. Chcesz zwrócić nową instancję tego samego typu niż obiekt, który otrzymałeś, a Type można skonstruować za pomocą init (), możesz zrobić:

let typeOfObject = aGivenObject.dynamicType
var freshInstance = typeOfObject()

Szybko przetestowałem to ze Stringiem:

let someType = "Fooo".dynamicType
let emptyString = someType()
let threeString = someType("Three")

który działał dobrze.

W swift 3

object.dynamicType

jest przestarzałe.

Zamiast tego użyj:

type(of:object)

Szybka implementacja porównywania typów

protocol Decoratable{}
class A:Decoratable{}
class B:Decoratable{}
let object:AnyObject = A()
object.dynamicType is A.Type//true
object.dynamicType is B.Type//false
object.dynamicType is Decoratable.Type//true

UWAGA: Zauważ, że działa również z protokołami, których obiekt może, ale nie musi, rozszerzać się

Wreszcie mam coś do roboty. Jest trochę leniwy, ale nawet trasa NSClassFromString () nie działała dla mnie ...

import Foundation

var classMap = Dictionary<String, AnyObject>()

func mapClass(name: String, constructor: AnyObject) -> ()
{
    classMap[name] = constructor;
}

class Factory
{
    class func create(className: String) -> AnyObject?
    {
        var something : AnyObject?

        var template : FactoryObject? = classMap[className] as? FactoryObject

        if (template)
        {
            let somethingElse : FactoryObject = template!.dynamicType()

            return somethingElse
        }

        return nil
    }
}


 import ObjectiveC

 class FactoryObject : NSObject
{
    @required init() {}
//...
}

class Foo : FactoryObject
{
    class override func initialize()
    {
        mapClass("LocalData", LocalData())
    }
    init () { super.init() }
}

var makeFoo : AnyObject? = Factory.create("Foo")

i bingo, „makeFoo” zawiera instancję Foo.

Wadą jest to, że twoje klasy muszą pochodzić z FactoryObject i MUSZĄ mieć metodę inicjalizacji Obj-C +, aby Twoja klasa została automatycznie wstawiona do mapy klas przez globalną funkcję "mapClass".

Oto kolejny przykład pokazujący implementację hierarchii klas, podobną do zaakceptowanej odpowiedzi, zaktualizowaną dla pierwszej wersji Swift.

class NamedItem : NSObject {
    func display() {
        println("display")
    }

    required override init() {
        super.init()
        println("base")
    }
}

class File : NamedItem {
    required init() {
        super.init()
        println("folder")
    }
}

class Folder : NamedItem {
    required init() {
        super.init()
        println("file")
    }
}

let y = Folder.self
y().display()
let z = File.self
z().display()

Drukuje ten wynik:

base
file
display
base
folder
display