Introspection et génériques de classe Swift

J'essaye de créer dynamiquement un class type basé sur instance en utilisant des génériques, mais je rencontre des difficultés avec l'introspection de classe.

Voici les questions:

• Y a-t-il un équivalent Swift aux Obj-C self.class ?
• Existe-t-il un moyen d'instancier une classe en utilisant le AnyClassrésultat deNSClassFromString ?
• Existe-t-il un moyen d'obtenir AnyClassou de taper des informations strictement à partir d'un paramètre générique T? (Similaire à la typeof(T)syntaxe de C # )

Eh bien, d'une part, l'équivalent Swift de [NSString class]is .self(voir la documentation Metatype , bien qu'elle soit assez mince).

En fait, NSString.classça ne marche même pas! Vous devez utiliser NSString.self.

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

De même, avec une classe rapide, j'ai essayé ...

class MyClass {

}

let MyClassRef = MyClass.self

// ERROR :(
let my_obj = MyClassRef()

Hmm… l'erreur dit:

L'exécution de Playground a échoué: erreur:: 16: 1: erreur: la construction d'un objet de type de classe 'X' avec une valeur de métatype nécessite un initialiseur '@required'

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

Il m'a fallu un certain temps pour comprendre ce que cela signifie ... il s'avère qu'il veut que la classe ait un @required init()

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

    required init () {

    }
}

let Y = X.self

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

Certains documents appellent cela .Type, mais MyClass.Typeme donne une erreur dans la cour de récréation.

Voici comment l'utiliser NSClassFromString. Vous devez connaître la superclasse avec laquelle vous allez vous retrouver. Voici une paire superclasse-sous-classe qui sait se décrire pour 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"}
}

Notez l'utilisation de la @objsyntaxe spéciale pour dicter le nom en Objective-C de ces classes; c'est crucial, car sinon nous ne connaissons pas la chaîne munged qui désigne chaque classe.

Maintenant, nous pouvons utiliser NSClassFromStringpour créer la classe Zork ou la classe Zilk, car nous savons que nous pouvons le saisir en tant que NSObject et ne pas planter plus tard:

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

Et c'est réversible; println(NSStringFromClass(anObject.dynamicType))fonctionne également.

Version moderne:

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

Si je lis bien la documentation, si vous traitez avec des instances et que vous voulez par exemple renvoyer une nouvelle instance du même type que l'objet que vous avez reçu et que le type peut être construit avec un init (), vous pouvez faire:

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

Je l'ai rapidement testé avec String:

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

qui a bien fonctionné.

Dans Swift 3

object.dynamicType

est obsolète.

Utilisez plutôt:

type(of:object)

Implémentation rapide de la comparaison des types

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

REMARQUE: notez qu'il fonctionne également avec les protocoles que l'objet peut étendre ou non

J'ai enfin quelque chose à travailler. C'est un peu paresseux mais même la route NSClassFromString () n'a pas fonctionné pour moi ...

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

et bingo, "makeFoo" contient une instance Foo.

L'inconvénient est que vos classes doivent dériver de FactoryObject et qu'elles DOIVENT avoir la méthode d'initialisation Obj-C + pour que votre classe soit automatiquement insérée dans la carte de classe par la fonction globale "mapClass".

Voici un autre exemple montrant l'implémentation de la hiérarchie de classes, similaire à la réponse acceptée, mis à jour pour la première version de 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()

Imprime ce résultat:

base
file
display
base
folder
display