Forward-Deklaration vs #import wenn

Question

Subklassen Ich habe MyClassA, die eine Eigenschaft des Typs MyClassB

// 
// MyClassA.h 
// 

@interface MyClassA : NSObject 

@property (strong, nonatomic, readonly) MyClassB *myClassB; 

@end 

MyClassB eine Eigenschaft hat myString hat.

// 
// MyClassB.h 
// 

@interface MyClassB : NSObject 

@property (copy, nonatomic, readonly) NSString *myString; 

@end 

Ich habe MyClassC die myString zugreifen muss darin Umsetzung ist.

Sollte ich -

a) Vorwärts Deklarieren MyClassB in MyClassA.h und #import "MyClassB.h" in MyClassC.m

oder

b) #import MyClassB.h in MyClassA.h

Answer 1

In der Regel sollten Sie mit weiterzuleiten erklären @class wo möglich in Ihren Header-Dateien. Die einzige Zeit, die Sie wahrscheinlich nicht möchten, ist, wenn Sie von einer Superklasse erben oder Protokollkonformität deklarieren, weil der Compiler wissen muss, was in dieser Klasse oder diesem Protokoll vor sich geht.

Für diese Instanz würde ich @class für alle Ihre Eigenschaftsdeklarationen in Ihren Header-Dateien und #import MyClassB.h in Ihrer MyClassC.m-Datei verwenden. Dadurch kann MyClassC alle Eigenschaften von MyClassB kennen.

Answer 2

Wenn Sie dies aus einem etwas anderen Blickwinkel betrachten ... müssen Sie sich entscheiden, ob Sie die Welt wirklich über myClassB wissen möchten, die eine Eigenschaft von MyClassA ist. Zum Beispiel, wenn Sie nur die myString werben möchten, die durch MyClassA erhalten werden kann. Dies isoliert andere Klassen davon, die zugrunde liegende Implementierung von myString zu kennen. Sofern Sie keine Notwendigkeit haben, MyClassB zu exponieren, sollten Sie es vor dem "Rest der Welt" verstecken.

In diesem Fall würde sich ändern Sie MyClassA.h wie folgt:

// 
// MyClassA.h 
// 

@interface MyClassA : NSObject 

@property (strong, nonatomic, readonly) NSString *myString; 

@end 

In MyClassA.m, würden Sie die folgende tun.

// 
// MyClassA.m 
// 

#import "MyClassA.h" 
#import "MyClassB.h" 

@interface MyClassA() 

@property (strong, nonatomic) MyClassB *myClassB;; 

@end 

@implementation MyClassA 

// Other meaningful code omitted 

- (NSString *)myString { 
    return self.myClassB.myString; 
} 

@end 

Beachten Sie, dass hier getan, was ich habe, ist eine anonyme Kategorie verwenden, um intern Eigenschaft definieren für myClassB.

Der Schlüssel hier ist, ob es sinnvoll ist, MyClassB anderen nicht freizugeben. Der Hauptvorteil dieses Ansatzes ist, dass Ihr Code flexibler ist. Nehmen wir an, myString wird auf andere Weise abgeleitet. Von einer anderen Klasse oder einer anderen Methode insgesamt. Der Code, der myString verbrauchen muss, ist immunisiert.

Wenn Sie MyClassB freilegen müssen, können Sie entweder @class wie von Tyler empfohlen oder #import MyClassB.h von MyClassA.h verwenden. Best Practices schreiben vor, @class zu deklarieren. Aber manchmal kann der Komfort, sich nicht daran zu erinnern, viele Dateien in der Implementierungsdatei zu importieren, gewinnen. Es ist deine Code-Basis, also kannst du auswählen, welche am besten für dich funktioniert. Ich verwende normalerweise eine Kombination der beiden.