Eu tenho uma função genérica que chama um serviço web e serializa a resposta JSON de volta para um objeto.

class func invokeService<T>(service: String, withParams params: Dictionary<String, String>, returningClass: AnyClass, completionHandler handler: ((T) -> ())) {

            /* Construct the URL, call the service and parse the response */
}

O que estou tentando realizar é o equivalente a este código Java

public <T> T invokeService(final String serviceURLSuffix, final Map<String, String> params,
                               final Class<T> classTypeToReturn) {
}

• Minha assinatura de método para o que estou tentando realizar está correta?
• Mais especificamente, especificar AnyClasscomo tipo de parâmetro a coisa certa a fazer?
• Ao chamar o método, estou passando MyObject.selfcomo o valor returnClass, mas recebo um erro de compilação "Não é possível converter o tipo da expressão '()' para o tipo 'String'"

CastDAO.invokeService("test", withParams: ["test" : "test"], returningClass: CityInfo.self) { cityInfo in /*...*/

}

Editar:

Tentei usar object_getClass, como mencionado pela holex, mas agora recebo:

erro: "O tipo 'CityInfo.Type' não está em conformidade com o protocolo 'AnyObject'"

O que precisa ser feito para estar em conformidade com o protocolo?

class CityInfo : NSObject {

    var cityName: String?
    var regionCode: String?
    var regionName: String?
}

Você está abordando isso da maneira errada: no Swift, ao contrário do Objective-C, as classes têm tipos específicos e até uma hierarquia de herança (ou seja, se a classe é Bherdada de A, então B.Typetambém é herdada de A.Type):

class A {}
class B: A {}
class C {}

// B inherits from A
let object: A = B()

// B.Type also inherits from A.Type
let type: A.Type = B.self

// Error: 'C' is not a subtype of 'A'
let type2: A.Type = C.self

É por isso que você não deve usar AnyClass, a menos que queira realmente permitir qualquer aula. Nesse caso, o tipo correto seria T.Type, porque expressa o link entre o returningClassparâmetro e o parâmetro do fechamento.

De fato, usá-lo em vez de AnyClasspermitir que o compilador deduza corretamente os tipos na chamada do método:

class func invokeService<T>(service: String, withParams params: Dictionary<String, String>, returningClass: T.Type, completionHandler handler: ((T) -> ())) {
    // The compiler correctly infers that T is the class of the instances of returningClass
    handler(returningClass())
}

Agora existe o problema de construir uma instância Tpara a qual passar handler: se você tentar executar o código agora, o compilador reclamará que Tnão é construtível (). E com razão: Tdeve ser explicitamente restringido para exigir que implemente um inicializador específico.

Isso pode ser feito com um protocolo como o seguinte:

protocol Initable {
    init()
}

class CityInfo : NSObject, Initable {
    var cityName: String?
    var regionCode: String?
    var regionName: String?

    // Nothing to change here, CityInfo already implements init()
}

Então você só precisa alterar as restrições genéricas de invokeServicede <T>para <T: Initable>.

Dica

Se você receber erros estranhos como "Não é possível converter o tipo da expressão '()' para o tipo 'String'", geralmente é útil mover todos os argumentos da chamada de método para sua própria variável. Ajuda a restringir o código que está causando o erro e a descobrir problemas de inferência de tipo:

let service = "test"
let params = ["test" : "test"]
let returningClass = CityInfo.self

CastDAO.invokeService(service, withParams: params, returningClass: returningClass) { cityInfo in /*...*/

}

Agora, existem duas possibilidades: o erro é movido para uma das variáveis ​​(o que significa que a parte errada está lá) ou você recebe uma mensagem enigmática como "Não é possível converter o tipo da expressão ()em tipo ($T6) -> ($T6) -> $T5".

A causa do último erro é que o compilador não pode inferir os tipos do que você escreveu. Nesse caso, o problema é que isso Té usado apenas no parâmetro do fechamento e o fechamento que você passou não indica nenhum tipo específico, portanto o compilador não sabe que tipo inferir. Alterando o tipo de returningClassinclusão, Tvocê fornece ao compilador uma maneira de determinar o parâmetro genérico.

você pode obter a aula AnyObjectdessa maneira:

Swift 3.x

let myClass: AnyClass = type(of: self)

Swift 2.x

let myClass: AnyClass = object_getClass(self)

e você pode passá-lo como paramater mais tarde, se desejar.

Eu tenho um caso de uso semelhante no swift5:

class PlistUtils {

    static let shared = PlistUtils()

    // write data
    func saveItem<T: Encodable>(url: URL, value: T) -> Bool{
        let encoder = PropertyListEncoder()
        do {
            let data = try encoder.encode(value)
            try data.write(to: url)
            return true
        }catch {
            print("encode error: \(error)")
            return false
        }
    }

    // read data

    func loadItem<T: Decodable>(url: URL, type: T.Type) -> Any?{
        if let data = try? Data(contentsOf: url) {
            let decoder = PropertyListDecoder()
            do {
                let result = try decoder.decode(type, from: data)
                return result
            }catch{
                print("items decode failed ")
                return nil
            }
        }
        return nil
    }

}

Use obj-getclass:

CastDAO.invokeService("test", withParams: ["test" : "test"], returningClass: obj-getclass(self)) { cityInfo in /*...*/

}

Supondo que o self é um objeto de informações da cidade.

Swift 5

Não é exatamente a mesma situação, mas eu estava tendo um problema semelhante. O que finalmente me ajudou foi isso:

func myFunction(_ myType: AnyClass)
{
    switch type
    {
        case is MyCustomClass.Type:
            //...
            break

        case is MyCustomClassTwo.Type:
            //...
            break

        default: break
    }
}

Então você pode chamá-lo dentro de uma instância da referida classe como esta:

myFunction(type(of: self))

Espero que isso ajude alguém na minha mesma situação.