Cree objects dinámicamente en Swift

En Objective-C tenía una categoría:

@implementation NSObject (Entity) + (instancetype)entity{ Class cl = self.class; NSObject *obj = [[cl alloc] init]; return obj; } @end 

Supongamos que hay classs A y B:

 @interface A : NSObject @end @interface B : NSObject @end 

Y luego puedo usar el método de entity estática para crear objects como:

 NSObject *o = [NSObject entity]; // type of NSObject A *a = [A entity]; // type of A B *b = [B entity]; // type of B 

¿Cómo puedo escribir esa categoría en Swift? Sé que es posible crear un object conociendo el tipo como let s = NSString.self; var str = s.init() let s = NSString.self; var str = s.init() , pero aquí no conozco la class, debería ser algo así como self.self que no tiene sentido y no funciona con security.

Gracias por adelantado

Como mencioné en mi comentario, la razón es que no hay una class base en Swift. Todavía puede hacerlo implementando su propia class base o subclassando NSObject .

 class A : NSObject {} class B : NSObject {} extension NSObject { class func entity() -> Self { return self.init() } } A.entity() B.entity() NSObject.entity() 
 let s = NSString.self; var str = s.init(); 

Si necesita la class, es solo:

 print(s) // "NSString" 

s es del tipo "NSString.Type", representa la class Object;

Si necesita la class de un object, creo que está buscando "dynamicType":

 let object = "toto" let t = object.dynamicType // String.Type var newObject = t.init("toto"); 

Como lo mencionaron otros, todo apunta a que Objective-C proporciona una class base para todas las classs, mientras que Swift no. NSObject en obj-C proporciona los methods alloc e init , de ahí que uno pueda esperar que un descendiente de NSObject implementará o henetworkingará esos methods, por lo tanto, puede tener la categoría de acceso directo que mencionó en su pregunta.

En Swift no hay classs base, por lo tanto, no puede saber qué class (u otro tipo) proporciona qué inicializadores. De una forma u otra, tendrás que recurrir a especificarlos para tus propósitos, y creo que los protocolos son la mejor manera de hacerlo.

Por ejemplo, considere esto:

 protocol DefaultInstantiatable { init() } extension DefaultInstantiatable { static func entity() -> Self { return Self() } } 

Si sus types adoptan el protocolo DefaultInstantiatable , entonces podría usar cláusulas como:

 struct Foo: DefaultInstantiatable { init() { } } class Bar: DefaultInstantiatable { requinetworking init() { } } let foo = Foo.entity() // Creates an instance of Foo structure let bar = Bar.entity() // Creates an instance of Bar object