Introspezione e generici di classe rapida

Sto cercando di creare dinamicamente un classtipo basato su istanze utilizzando generici, tuttavia riscontro difficoltà con l'introspezione della classe.

Ecco le domande:

• Esiste un equivalente Swift di Obj-C self.class?
• C'è un modo per istanziare una classe usando il AnyClassrisultato di NSClassFromString?
• C'è un modo per ottenere AnyClasso altrimenti digitare le informazioni rigorosamente da un parametro generico T? (Simile alla typeof(T)sintassi di C # )

Bene, per uno, l'equivalente Swift di [NSString class]è .self(vedi i documenti Metatype , anche se sono piuttosto sottili).

In effetti, NSString.classnon funziona nemmeno! Devi usare NSString.self.

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

Allo stesso modo, con una lezione rapida ho provato ...

class MyClass {

}

let MyClassRef = MyClass.self

// ERROR :(
let my_obj = MyClassRef()

Hmm ... l'errore dice:

Esecuzione del parco giochi non riuscita: errore:: 16: 1: errore: la costruzione di un oggetto di tipo classe "X" con un valore di metatipo richiede un inizializzatore "@required"

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

Mi ci è voluto un po 'per capire cosa significa ... si scopre che vuole che la classe abbia un @required init()

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

    required init () {

    }
}

let Y = X.self

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

Alcuni documenti si riferiscono a questo come .Type, ma MyClass.Typemi danno un errore nel playground.

Ecco come si usa NSClassFromString. Devi conoscere la superclasse con cui finirai. Ecco una coppia superclasse-sottoclasse che sa come descrivere se stessa per 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"}
}

Notare l'uso della @objsintassi speciale per dettare il nome munged Objective-C di queste classi; questo è cruciale, perché altrimenti non conosciamo la stringa mungata che designa ogni classe.

Ora possiamo usare NSClassFromStringper creare la classe Zork o la classe Zilk, perché sappiamo che possiamo digitarla come NSObject e non andare in crash in seguito:

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

Ed è reversibile; println(NSStringFromClass(anObject.dynamicType))funziona anche.

Versione moderna:

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

Se sto leggendo correttamente la documentazione, se ti occupi di istanze e ad esempio vuoi restituire una nuova istanza dello stesso tipo dell'oggetto che ti è stato dato e il tipo può essere costruito con un init () puoi fare:

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

L'ho testato rapidamente con String:

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

che ha funzionato bene.

In swift 3

object.dynamicType

è deprecato.

Usa invece:

type(of:object)

Rapida implementazione del confronto dei tipi

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

NOTA: si noti che funziona anche con i protocolli che l'oggetto può estendere o meno

Finalmente ho qualcosa su cui lavorare. È un po 'pigro ma anche il percorso NSClassFromString () non ha funzionato per me ...

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

e bingo, "makeFoo" contiene un'istanza Foo.

Lo svantaggio è che le tue classi devono allontanarsi da FactoryObject e DEVONO avere il metodo di inizializzazione Obj-C + in modo che la tua classe venga automaticamente inserita nella mappa delle classi dalla funzione globale "mapClass".

Ecco un altro esempio che mostra l'implementazione della gerarchia di classi, simile alla risposta accettata, aggiornata per la prima versione di 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()

Stampa questo risultato:

base
file
display
base
folder
display