Dove memorizzare le costanti globali in un'applicazione iOS?

La maggior parte dei modelli nella mia app iOS interroga un server web. Vorrei avere un file di configurazione che memorizzi l'URL di base del server. Assomiglierà a questo:

// production
// static NSString* const baseUrl = "http://website.com/"

// testing
static NSString* const baseUrl = "http://192.168.0.123/"

Commentando una riga o l'altra, posso cambiare istantaneamente il server a cui puntano i miei modelli. La mia domanda è: qual è la procedura migliore per memorizzare le costanti globali in iOS? Nella programmazione Android, abbiamo questo file di risorse di stringhe integrato . In qualsiasi attività (l'equivalente di un UIViewController ), possiamo recuperare quelle costanti di stringa con:

String string = this.getString(R.string.someConstant);

Mi chiedevo se iOS SDK ha un posto analogo per memorizzare le costanti. In caso negativo, qual è la migliore pratica in Objective-C per farlo?

Potresti anche fare un file

#define kBaseURL @"http://192.168.0.123/"

in un file di intestazione "costanti", ad esempio constants.h. Quindi fa

#include "constants.h"

all'inizio di ogni file in cui è necessaria questa costante.

In questo modo, puoi passare da un server all'altro a seconda dei flag del compilatore, come in:

#ifdef DEBUG
    #define kBaseURL @"http://192.168.0.123/"
#else
    #define kBaseURL @"http://myproductionserver.com/"
#endif

Bene, vuoi la dichiarazione locale alle interfacce a cui si riferisce: il file delle costanti a livello di app non è una buona cosa.

Inoltre, è preferibile dichiarare semplicemente un extern NSString* constsimbolo, piuttosto che utilizzare un #define:

SomeFile.h

extern NSString* const MONAppsBaseUrl;

SomeFile.m

#import "SomeFile.h"

#ifdef DEBUG
NSString* const MONAppsBaseUrl = @"http://192.168.0.123/";
#else
NSString* const MONAppsBaseUrl = @"http://website.com/";
#endif

A parte l'omissione della dichiarazione Extern compatibile con C ++, questo è ciò che generalmente vedrai usato nei framework Obj-C di Apple.

Se la costante deve essere visibile a un solo file o funzione, allora static NSString* const baseUrlnel tuo *.mva bene.

Il modo in cui definisco le costanti globali:

AppConstants.h

extern NSString* const kAppBaseURL;

AppConstants.m

#import "AppConstants.h"

#ifdef DEBUG
NSString* const kAppBaseURL = @"http://192.168.0.123/";
#else
NSString* const kAppBaseURL = @"http://website.com/";
#endif

Quindi nel tuo file {$ APP} -Prefix.pch:

#ifdef __OBJC__
  #import <UIKit/UIKit.h>
  #import <Foundation/Foundation.h>
  #import "AppConstants.h"
#endif

In caso di problemi, assicurarsi prima di avere l'opzione Precompile Prefix Header impostata su NO.

Puoi anche concatenare costanti stringa in questo modo:

  #define kBaseURL @"http://myServer.com"
  #define kFullURL kBaseURL @"/api/request"

Penso che un altro modo per farlo sia molto più semplice e lo includerai semplicemente nei file in cui devi includerli, non in TUTTI i file, come con il file prefisso .pch:

#ifndef Constants_h
#define Constants_h

//Some constants
static int const ZERO = 0;
static int const ONE = 1;
static int const TWO = 2;

#endif /* Constants_h */

Dopodiché includi questo file di intestazione nel file di intestazione che desideri. Lo includi nel file di intestazione per la classe specifica in cui desideri includerlo:

#include "Constants.h"

1. Definisco la costante globale nel file YOURPROJECT-Prefix.pch.
2. #define BASEURl @"http://myWebService.appspot.com/xyz/xx"

3. quindi ovunque nel progetto per utilizzare BASEURL:

   NSString *LOGIN_URL= [BASEURl stringByAppendingString:@"/users/login"];

Aggiornato: in Xcode 6 non troverai il file .pch predefinito creato nel tuo progetto. Quindi, usa il file PCH in Xcode 6 per inserire il file .pch nel tuo progetto.

Aggiornamenti: per SWIFT

1. Crea un nuovo file Swift [vuoto senza classe] dì [AppGlobalMemebers]

2. & Immediatamente dichiara / definisce membro

   Esempio:

   var STATUS_BAR_GREEN : UIColor  = UIColor(red: 106/255.0, green: 161/255.0, blue: 7/255.0, alpha: 1)  //

   3. Se si desidera definire il membro globale dell'app in qualsiasi file di classe, ad esempio Appdelegate o Singleton class o qualsiasi altra, dichiara il membro specificato sopra la definizione della classe

Le dichiarazioni globali sono interessanti ma, per me, ciò che ha cambiato profondamente il mio modo di scrivere codice è stato avere istanze globali di classi. Mi ci sono voluti un paio di giorni per capire davvero come lavorarci, quindi l'ho riassunto rapidamente qui

Uso istanze globali di classi (1 o 2 per progetto, se necessario), per raggruppare l'accesso ai dati di base o alcune logiche commerciali.

Ad esempio, se vuoi avere un oggetto centrale che gestisca tutti i tavoli del ristorante che crei, fai l'oggetto all'avvio e basta. Questo oggetto può gestire gli accessi al database OPPURE gestirlo in memoria se non è necessario salvarlo. È centralizzato, mostri solo interfacce utili ...!

È un grande aiuto, orientato agli oggetti e un buon modo per ottenere tutte le tue cose nello stesso posto

Poche righe di codice:

@interface RestaurantManager : NSObject
    +(id) sharedInstance;
    -(void)registerForTable:(NSNumber *)tableId;
@end 

e implementazione dell'oggetto:

@implementation RestaurantManager

+ (id) sharedInstance {
    static dispatch_once_t onceQueue;

    dispatch_once(&onceQueue, ^{
        sharedInstance = [[self alloc] init];
        NSLog(@"*** Shared instance initialisation ***");
    });
    return sharedInstance;
}

-(void)registerForTable:(NSNumber *)tableId {
}
@end

per usarlo è davvero semplice:

[[RestaurantManager sharedInstance] registerForTable: [NsNumber numberWithInt: 10]]

La risposta accettata ha 2 punti deboli. In primo luogo, come altri hanno sottolineato l'utilizzo di #definecui è più difficile eseguire il debug, utilizzare invece la extern NSString* const kBaseUrlstruttura. Secondo, definisce un singolo file per le costanti. IMO, questo è sbagliato perché la maggior parte delle classi non ha bisogno dell'accesso a quelle costanti o per accedere a tutte e il file può diventare gonfio se tutte le costanti vengono dichiarate lì. Una soluzione migliore sarebbe modulare le costanti a 3 diversi livelli:

1. Livello di sistema: SystemConstants.ho AppConstants.h che descrive le costanti a livello globale, a cui può accedere qualsiasi classe del sistema. Dichiara qui solo quelle costanti a cui è necessario accedere da classi diverse che non sono correlate.

2. Livello ModuleNameConstants.hmodulo / sottosistema :, descrive un insieme di costanti tipiche di un insieme di classi correlate, all'interno di un modulo / sottosistema.

3. Livello di classe: le costanti risiedono nella classe e vengono utilizzate solo da essa.

Solo 1,2 sono correlati alla domanda.

Un approccio che ho usato prima è creare un file Settings.pliste caricarlo NSUserDefaultsall'avvio utilizzando registerDefaults:. È quindi possibile accedere ai suoi contenuti con quanto segue:

// Assuming you've defined some constant kMySettingKey.
[[NSUserDefaults standardUserDefaults] objectForKey:kMySettingKey];

Anche se non ho fatto alcuno sviluppo per Android, sembra che sia analogo al file di risorse delle stringhe che hai descritto. L'unico svantaggio è che non puoi usare il preprocessore per scambiare le impostazioni (ad esempio in DEBUGmodalità). Suppongo che potresti caricare in un file diverso, però.

NSUserDefaults documentazione.

Per un numero puoi usarlo come

#define MAX_HEIGHT 12.5

Userei un oggetto di configurazione che inizializza da un file plist. Perché disturbare le altre classi con cose esterne irrilevanti?

Ho creato solo eppz!settignsper questo motivo. Vedere l'articolo Metodo avanzato ma semplice per salvare in NSUserDefaults per incorporare i valori predefiniti da un file plist.