Лучший способ определить частные методы для класса в Objective-C

Question

Лучший способ определить частные методы для класса в Objective-C

Я только начал программировать Objective-C и, имея опыт работы с Java, удивляюсь, как люди, пишущие программы на Objective-C, имеют дело с приватными методами.

Я понимаю, что может быть несколько соглашений и привычек, и думаю, что этот вопрос объединяет лучшие методы, которые люди используют для работы с частными методами в Objective-C.

Пожалуйста, укажите аргумент в пользу вашего подхода при публикации. Почему это хорошо? Какие у него недостатки (о которых вы знаете) и как с ними справляться?

Что касается моих выводов до сих пор.

Для группировки частных методов можно использовать категории [например, MyClass (Private)], определенные в файле MyClass.m.

Этот подход имеет 2 проблемы:

Xcode (и компилятор?) Не проверяет, определяете ли вы все методы в частной категории в соответствующем блоке @implementation
Вы должны поместить @interface, объявляющий вашу личную категорию, в начале файла MyClass.m, в противном случае XCode жалуется сообщением типа "self может не отвечать на сообщение"privateFoo".

Первая проблема может быть решена с пустой категорией [например, MyClass ()].
Второй очень беспокоит меня. Я хотел бы видеть частные методы, реализованные (и определенные) в конце файла; Я не знаю, возможно ли это.

363

objective-c cocoa code-completion

Источник

user20294 05 окт '08 в 20:29

12 ответов

Другие вопросы по тегам objective-c cocoa code-completion

user35999 16 мар '09 в 19:37 2009-03-16 19:37 · Answer 1 · 2009-03-16 19:37

Как уже говорили другие, в Objective-C нет такого понятия, как закрытый метод. Однако, начиная с Objective-C 2.0 (имеется в виду Mac OS X Leopard, iPhone OS 2.0 и более поздние версии), вы можете создать категорию с пустым именем (т.е. @interface MyClass ()) называется расширением класса. Уникальным в расширении класса является то, что реализации метода должны идти в @implementation MyClass как публичные методы. Итак, я структурирую свои классы так:

В файле.h:

@interface MyClass {
    // My Instance Variables
}

- (void)myPublicMethod;

@end

И в файле.m:

@interface MyClass()

- (void)myPrivateMethod;

@end

@implementation MyClass

- (void)myPublicMethod {
    // Implementation goes here
}

- (void)myPrivateMethod {
    // Implementation goes here
}

@end

Я думаю, что наибольшим преимуществом этого подхода является то, что он позволяет группировать реализации методов по функциональности, а не по (иногда произвольному) общему / частному различию.

06 окт '08 в 05:49 2008-10-06 05:49 · Answer 2 · 2008-10-06 05:49

В Objective-C на самом деле не существует "закрытого метода", если среда выполнения может определить, какая реализация его использует. Но это не значит, что нет методов, которые не являются частью документированного интерфейса. Для этих методов я думаю, что категория хорошо. Вместо того, чтобы положить @interface в верхней части файла.m, как и в пункте 2, я бы поместил его в собственный файл.h. Соглашение, которому я следую (и видел в другом месте, я думаю, что это соглашение Apple, поскольку XCode теперь обеспечивает его автоматическую поддержку), заключается в том, чтобы называть такой файл после его класса и категории с +, разделяющим их, поэтому @interface GLObject (PrivateMethods) можно найти в GLObject+PrivateMethods.h, Причиной предоставления файла заголовка является то, что вы можете импортировать его в свои классы модульного теста:-).

Кстати, что касается реализации / определения методов в конце файла.m, вы можете сделать это с помощью категории, реализовав категорию в нижней части файла.m:

@implementation GLObject(PrivateMethods)
- (void)secretFeature;
@end

или с расширением класса (то, что вы называете "пустой категорией"), просто определите эти методы последними. Методы Objective-C могут быть определены и использованы в любом порядке в реализации, поэтому ничто не мешает вам помещать "частные" методы в конец файла.

Даже с расширениями классов я часто создаю отдельный заголовок (GLObject+Extension.h) чтобы я мог использовать эти методы при необходимости, имитируя видимость "друг" или "защищенный".

Поскольку этот ответ был изначально написан, компилятор clang начал выполнять два этапа для методов Objective-C. Это означает, что вы можете избежать полного объявления ваших "приватных" методов, и независимо от того, находятся они выше или ниже вызывающего сайта, они будут найдены компилятором.

user3857 05 окт '08 в 22:03 2008-10-05 22:03 · Answer 3 · 2008-10-05 22:03

Хотя я не эксперт Objective-C, я лично определяю метод в реализации моего класса. Конечно, он должен быть определен до (выше) любых методов, вызывающих его, но он определенно требует наименьшего количества работы.

39

Источник

user3857 05 окт '08 в 22:03

user191596 26 май '13 в 09:45 2013-05-26 09:45 · Answer 4 · 2013-05-26 09:45

Определение ваших личных методов в @implementation Блок идеально подходит для большинства целей. Clang увидит это в @implementationнезависимо от порядка декларирования. Нет необходимости объявлять их в продолжении класса (он же расширение класса) или именованной категории.

В некоторых случаях вам нужно будет объявить метод в продолжении класса (например, если используется селектор между продолжением класса и @implementation).

static функции очень хороши для особо чувствительных или критичных по скорости частных методов.

Соглашение о присвоении имен префиксам может помочь вам избежать случайного переопределения закрытых методов (я считаю имя класса безопасным для префикса).

Названные категории (например, @interface MONObject (PrivateStuff)) не особенно хорошая идея из-за возможных конфликтов имен при загрузке. Они действительно полезны только для друзей или защищенных методов (которые очень редко бывают хорошими). Чтобы убедиться, что вы предупреждены о неполных реализациях категорий, вы должны реализовать их:

@implementation MONObject (PrivateStuff)
...HERE...
@end

Вот небольшая аннотированная шпаргалка:

MONObject.h

@interface MONObject : NSObject

// public declaration required for clients' visibility/use.
@property (nonatomic, assign, readwrite) bool publicBool;

// public declaration required for clients' visibility/use.
- (void)publicMethod;

@end

MONObject.m

@interface MONObject ()
@property (nonatomic, assign, readwrite) bool privateBool;

// you can use a convention where the class name prefix is reserved
// for private methods this can reduce accidental overriding:
- (void)MONObject_privateMethod;

@end

// The potentially good thing about functions is that they are truly
// inaccessible; They may not be overridden, accidentally used,
// looked up via the objc runtime, and will often be eliminated from
// backtraces. Unlike methods, they can also be inlined. If unused
// (e.g. diagnostic omitted in release) or every use is inlined,
// they may be removed from the binary:
static void PrivateMethod(MONObject * pObject) {
    pObject.privateBool = true;
}

@implementation MONObject
{
    bool anIvar;
}

static void AnotherPrivateMethod(MONObject * pObject) {
    if (0 == pObject) {
        assert(0 && "invalid parameter");
        return;
    }

    // if declared in the @implementation scope, you *could* access the
    // private ivars directly (although you should rarely do this):
    pObject->anIvar = true;
}

- (void)publicMethod
{
    // declared below -- but clang can see its declaration in this
    // translation:
    [self privateMethod];
}

// no declaration required.
- (void)privateMethod
{
}

- (void)MONObject_privateMethod
{
}

@end

Другой подход, который может быть неочевиден: тип C++ может быть очень быстрым и обеспечивать гораздо более высокую степень контроля, минимизируя при этом количество экспортируемых и загружаемых методов objc.

user10320 16 мар '09 в 18:54 2009-03-16 18:54 · Answer 5 · 2009-03-16 18:54

Вы можете попытаться определить статическую функцию ниже или выше вашей реализации, которая принимает указатель на ваш экземпляр. Он сможет получить доступ к любой из ваших переменных экземпляров.

//.h file
@interface MyClass : Object
{
    int test;
}
- (void) someMethod: anArg;

@end


//.m file    
@implementation MyClass

static void somePrivateMethod (MyClass *myClass, id anArg)
{
    fprintf (stderr, "MyClass (%d) was passed %p", myClass->test, anArg);
}


- (void) someMethod: (id) anArg
{
    somePrivateMethod (self, anArg);
}

@end

user513736 19 ноя '10 в 16:21 2010-11-19 16:21 · Answer 6 · 2010-11-19 16:21

Все объекты в Objective C соответствуют протоколу NSObject, который поддерживает метод executeSelector:. Ранее я также искал способ создания "вспомогательных или частных" методов, которые мне не нужны были бы показывать на публичном уровне. Если вы хотите создать приватный метод без дополнительных затрат и не определять его в заголовочном файле, тогда попробуйте...

определите ваш метод с такой же сигнатурой, как в коде ниже...

-(void)myHelperMethod: (id) sender{
     // code here...
}

тогда, когда вам нужно обратиться к методу, просто вызовите его как селектор...

[self performSelector:@selector(myHelperMethod:)];

эта строка кода вызовет созданный вами метод и не будет раздражать предупреждением о том, что он не определен в заголовочном файле.

user379163 17 июн '12 в 04:35 2012-06-17 04:35 · Answer 7 · 2012-06-17 04:35

Вы могли бы использовать блоки?

@implementation MyClass

id (^createTheObject)() = ^(){ return [[NSObject alloc] init];};

NSInteger (^addEm)(NSInteger, NSInteger) =
^(NSInteger a, NSInteger b)
{
    return a + b;
};

//public methods, etc.

- (NSObject) thePublicOne
{
    return createTheObject();
}

@end

Я знаю, что это старый вопрос, но он один из первых, который я нашел, когда искал ответ на этот вопрос. Я не видел, чтобы это решение обсуждалось где-либо еще, поэтому дайте мне знать, если в этом есть что-то глупое.

user363522 03 авг '10 в 23:48 2010-08-03 23:48 · Answer 8 · 2010-08-03 23:48

Если вы хотели избежать @interface блок сверху вы всегда можете поместить частные объявления в другой файл MyClassPrivate.h не идеально, но это не загромождает реализацию.

MyClass.h

interface MyClass : NSObject {
 @private
  BOOL publicIvar_;
  BOOL privateIvar_;
}

@property (nonatomic, assign) BOOL publicIvar;
//any other public methods. etc
@end

MyClassPrivate.h

@interface MyClass ()

@property (nonatomic, assign) BOOL privateIvar;
//any other private methods etc.
@end

MyClass.m

#import "MyClass.h"
#import "MyClassPrivate.h"
@implementation MyClass

@synthesize privateIvar = privateIvar_;
@synthesize publicIvar = publicIvar_;

@end

user2023738 14 фев '13 в 03:08 2013-02-14 03:08 · Answer 9 · 2013-02-14 03:08

Еще одна вещь, о которой я не упоминал, упоминается здесь - Xcode поддерживает файлы.h с именем "_private". Допустим, у вас есть класс MyClass - у вас есть MyClass.m и MyClass.h, и теперь у вас также может быть MyClass_private.h. XCode распознает это и включит его в список "контрагентов" в помощнике редактора.

//MyClass.m
#import "MyClass.h"
#import "MyClass_private.h"

user838444 08 авг '11 в 07:31 2011-08-08 07:31 · Answer 10 · 2011-08-08 07:31

Есть преимущество отсутствия частных методов. Вы можете переместить логику, которую вы намеревались скрыть, в отдельный класс и использовать ее в качестве делегата. В этом случае вы можете пометить объект делегата как закрытый, и он не будет виден снаружи. Перемещение логики в отдельный класс (может быть, несколько) делает лучший дизайн вашего проекта. Потому что ваши классы становятся проще, а ваши методы сгруппированы в классы с собственными именами.

user2140 16 мар '09 в 18:33 2009-03-16 18:33 · Answer 11 · 2009-03-16 18:33

Нет способа обойти проблему № 2. Именно так работает компилятор C (и, следовательно, компилятор Objective-C). Если вы используете редактор XCode, всплывающая функция должна облегчать навигацию по @interface а также @implementation блоки в файле.

1

Источник

user2140 16 мар '09 в 18:33

user1998518 24 окт '18 в 23:32 2018-10-24 23:32 · Answer 12 · 2018-10-24 23:32

Как говорили другие люди, определяя частные методы в @implementation блок в порядке для большинства целей.

На тему организации кода - мне нравится держать их вместе под pragma mark private для более удобной навигации в Xcode

@implementation MyClass 
// .. public methods

# pragma mark private 
// ...

@end

0

Источник

user1998518 24 окт '18 в 23:32