¿Es posible usar Swift's Enum en Obj-C?

Estoy tratando de convertir parte de mi clase de Obj-C a Swift. Y algunas otras clases de Obj-C todavía usan enum en esa clase convertida. Busqué en los documentos de prelanzamiento y no pude encontrarlo o tal vez lo perdí. ¿Hay alguna manera de usar Swift enum en Obj-C Class? ¿O un enlace al documento de este número?

Así es como declaró mi enumeración en mi antiguo código Obj-C y el nuevo código Swift.

mi antiguo código Obj-C:

typedef NS_ENUM(NSInteger, SomeEnum)
{
    SomeEnumA,
    SomeEnumB,
    SomeEnumC
};

@interface SomeClass : NSObject

...

@end

mi nuevo código Swift:

enum SomeEnum: NSInteger
{
    case A
    case B
    case C
};

class SomeClass: NSObject
{
    ...
}

Actualización: de las respuestas. No se puede hacer en la versión anterior de Swift que la 1.2. Pero según este blog oficial de Swift . En Swift 1.2 que se lanzó junto con XCode 6.3, puede usar Swift Enum en Objective-C agregando @objcdelante deenum

A partir de la versión 1.2 de Swift (Xcode 6.3) puede hacerlo. Simplemente prefija la declaración enum con@objc

@objc enum Bear: Int {
    case Black, Grizzly, Polar
}

Descaradamente tomado del Blog Swift

Nota: Esto no funcionaría para las enumeraciones de cadena o enumeraciones con valores asociados. Su enumeración tendrá que estar vinculada internamente

En Objective-C esto se vería así

Bear type = BearBlack;
switch (type) {
    case BearBlack:
    case BearGrizzly:
    case BearPolar:
       [self runLikeHell];
}

Para ampliar la respuesta seleccionada ...

Es posible compartir enumeraciones de estilo Swift entre Swift y Objective-C usando NS_ENUM().

Solo necesitan definirse en un contexto Objective-C usando NS_ENUM()y están disponibles usando la notación de puntos Swift.

Del uso de Swift con cacao y Objective-C

Swift importa como una enumeración Swift cualquier enumeración de estilo C marcada con la NS_ENUMmacro. Esto significa que los prefijos de los nombres de valores de enumeración se truncan cuando se importan a Swift, ya sea que estén definidos en los marcos del sistema o en el código personalizado.

C objetivo

typedef NS_ENUM(NSInteger, UITableViewCellStyle) {
   UITableViewCellStyleDefault,
   UITableViewCellStyleValue1,
   UITableViewCellStyleValue2,
   UITableViewCellStyleSubtitle
};

Rápido

let cellStyle: UITableViewCellStyle = .Default

De la guía Uso de Swift con cacao y Objective-C :

Una clase o protocolo Swift debe estar marcado con el atributo @objc para que sea accesible y utilizable en Objective-C. [...]

Tendrá acceso a cualquier cosa dentro de una clase o protocolo que esté marcado con el atributo @objc siempre que sea compatible con Objective-C. Esto excluye las funciones solo de Swift, como las que se enumeran aquí:

Tuplas genéricas / Enumeraciones definidas en Swift / Estructuras definidas en Swift / Funciones de nivel superior definidas en Swift / Variables globales definidas en Swift / Typealiases definidas en Swift / Variadas de estilo Swift / Tipos anidados / Funciones curry

Entonces, no, no puedes usar una enumeración Swift en una clase Objective-C.

Swift 4.1, Xcode 9.4.1:

1) Swift enum debe tener el prefijo @objcy ser Inttype:

// in .swift file:
@objc enum CalendarPermission: Int {
    case authorized
    case denied
    case restricted
    case undetermined
}

2) El nombre de Objective-C es enum name + case name, por ejemplo CalendarPermissionAuthorized:

// in .m file:
// point to something that returns the enum type (`CalendarPermission` here)
CalendarPermission calPermission = ...;

// use the enum values with their adjusted names
switch (calPermission) {
    case CalendarPermissionAuthorized:
    {
        // code here
        break;
    }
    case CalendarPermissionDenied:
    case CalendarPermissionRestricted:
    {
        // code here
        break;
    }
    case CalendarPermissionUndetermined:
    {
        // code here
        break;
    }
}

Y, por supuesto, recuerde importar su encabezado de puente Swift como último elemento en la lista de importación del archivo Objective-C:

#import "MyAppViewController.h"
#import "MyApp-Swift.h"

Si prefiere mantener los códigos ObjC tal como están, puede agregar un archivo de encabezado auxiliar en su proyecto:

Swift2Objc_Helper.h

en el archivo de encabezado agregue este tipo de enumeración:

typedef NS_ENUM(NSInteger, SomeEnum4ObjC)
{
   SomeEnumA,
   SomeEnumB
};

Puede haber otro lugar en su archivo .m para hacer un cambio: para incluir el archivo de encabezado oculto:

#import "[YourProjectName]-Swift.h"

reemplace [YourProjectName] con el nombre de su proyecto. Este archivo de encabezado expone todas las clases @objc definidas por Swift, enumeraciones a ObjC.

Puede recibir un mensaje de advertencia sobre la conversión implícita del tipo de enumeración ... Está bien.

Por cierto, podría usar este archivo auxiliar de encabezado para mantener algunos códigos ObjC como #define constantes.

Si usted (como yo) realmente quiere utilizar las enumeraciones de String, puede crear una interfaz especializada para el objetivo-c. Por ejemplo:

enum Icon: String {
    case HelpIcon
    case StarIcon
    ...
}

// Make use of string enum when available:
public func addIcon(icon: Icon) {
    ...
}

// Fall back on strings when string enum not available (objective-c):
public func addIcon(iconName:String) {
    addIcon(Icon(rawValue: iconName))
}

Por supuesto, esto no le dará la conveniencia de autocompletar (a menos que defina constantes adicionales en el entorno del objetivo-c).

esto podría ayudar un poco más

Planteamiento del problema : - Tengo una enumeración en la clase rápida, a la que estoy accediendo desde otras clases rápidas, y ahora necesito acceder a ella desde mi clase C objetiva.

Antes de acceder desde la clase objetiva-c: -

enum NTCType   {
    case RETRYNOW
    case RETRYAFTER
}
 var viewType: NTCType? 

Cambios para acceder desde la clase objetiva c

@objc  enum NTCType :Int  {
    case RETRYNOW
    case RETRYAFTER
}

y agregue una función para pasarla al valor

  @objc  func setNtc(view:NTCType)  {
        self.viewType = view; // assign value to the variable
    }

Después de investigar esto, seguí encontrando solo respuestas parciales, así que creé un ejemplo completo de una aplicación Swift unida al Objetivo C que tiene enumeraciones Swift utilizadas por el código Objective C y enumeraciones Objective C utilizadas por el código Swift. Es un proyecto Xcode simple con el que puede ejecutar y experimentar. Fue escrito usando Xcode 10.3 con Swift 5.0

Proyecto de ejemplo

En caso de que esté tratando de observar una enumeración que se ve así:

enum EnumName: String {
    case one = "One"
    case two = "Two"
}

Esta solución me ayudó.

Clase observable:

• crear @objc dynamic var observable: String?

• cree su instancia de enumeración de esta manera:

  private var _enumName: EnumName? {
      didSet {
          observable = _enumName!.rawValue
      }
  }

Clase de observador:

• crear private var _enumName: EnumName?
• crear private let _instance = ObservableClass()

• crear

  private var _enumObserver: NSKeyValueObservation = _instance.observe(\.observable, options: .new, changeHandler: { [weak self] (_, value) in
      guard let newValue = value.newValue else { return }
      self?._enumName = EnumName(rawValue: period)!
  })

De eso se trata. Ahora, cada vez que cambie el _enumNameen la clase observable, también se actualizará inmediatamente una instancia apropiada en la clase observador.

Por supuesto, esta es una implementación demasiado simplificada, pero debería darle una idea de cómo observar las propiedades incompatibles con KVO.