Introspeksi & generik kelas cepat

Saya mencoba untuk secara dinamis membuat classtipe berbasis contoh menggunakan obat generik, namun saya mengalami kesulitan dengan introspeksi kelas.

Inilah pertanyaannya:

• Apakah ada Swift yang setara dengan Obj-C self.class?
• Apakah ada cara untuk membuat instance kelas menggunakan AnyClasshasil dari NSClassFromString?
• Apakah ada cara untuk mendapatkan AnyClassatau mengetik informasi secara ketat dari parameter generik T? (Mirip dengan typeof(T)sintaks C # )

Yah, untuk satu, padanan Swift [NSString class]adalah .self(lihat dokumen Metatype , meskipun mereka cukup tipis).

Bahkan, NSString.classtidak berhasil! Anda harus menggunakan NSString.self.

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

Begitu pula dengan kelas yang sigap saya coba ...

class MyClass {

}

let MyClassRef = MyClass.self

// ERROR :(
let my_obj = MyClassRef()

Hmm… kesalahannya mengatakan:

Eksekusi Playground gagal: error:: 16: 1: error: membuat objek dengan tipe kelas 'X' dengan nilai metatype memerlukan penginisialisasi '@required'

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

Butuh beberapa saat bagi saya untuk memikirkan apa artinya ini… ternyata kelas itu ingin memiliki a @required init()

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

    required init () {

    }
}

let Y = X.self

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

Beberapa dokumen menyebut ini sebagai .Type, tetapi MyClass.Typememberi saya kesalahan di taman bermain.

Berikut cara menggunakannya NSClassFromString. Anda harus mengetahui superclass tentang apa yang akan Anda hasilkan. Berikut adalah pasangan superclass-subclass yang tahu bagaimana mendeskripsikan diri mereka sendiri 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"}
}

Perhatikan penggunaan @objsintaks khusus untuk mendikte nama Objective-C munged dari kelas-kelas ini; itu penting, karena jika tidak kita tidak tahu string munged yang menunjukkan setiap kelas.

Sekarang kita bisa gunakan NSClassFromStringuntuk membuat kelas Zork atau kelas Zilk, karena kita tahu kita bisa mengetiknya sebagai NSObject dan tidak crash nanti:

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

Dan itu bisa dibalik; println(NSStringFromClass(anObject.dynamicType))juga bekerja.

Versi modern:

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

Jika saya membaca dokumentasi dengan benar, jika Anda berurusan dengan instance dan misalnya ingin mengembalikan instance baru dari Type yang sama daripada objek yang telah Anda berikan dan Type dapat dibangun dengan init () Anda dapat melakukan:

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

Saya segera mengujinya dengan String:

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

yang bekerja dengan baik.

Dalam 3 cepat

object.dynamicType

sudah ditinggalkan.

Sebagai gantinya gunakan:

type(of:object)

Implementasi cepat untuk membandingkan tipe

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

CATATAN: Perhatikan bahwa itu juga bekerja dengan protokol objek mungkin atau mungkin tidak diperluas

Akhirnya ada sesuatu untuk dikerjakan. Agak malas tetapi bahkan rute NSClassFromString () tidak berfungsi untuk saya ...

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

dan bingo, "makeFoo" berisi instance Foo.

Kelemahannya adalah kelas Anda harus keluar dari FactoryObject dan mereka HARUS memiliki metode inisialisasi Obj-C + sehingga kelas Anda secara otomatis dimasukkan ke dalam peta kelas dengan fungsi global "mapClass".

Berikut adalah contoh lain yang menunjukkan implementasi hierarki kelas, mirip dengan jawaban yang diterima, diperbarui untuk rilis pertama 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()

Cetak hasil ini:

base
file
display
base
folder
display