+load
+load
is to be used only as a last resort. Because it is
executed very early, most of the Objective-C runtime machinery will
not be ready when +load
is executed; hence +load
works
best for executing C code that is independent on the Objective-C
runtime.
The +load
implementation in the GNU runtime guarantees you the
following things:
+load
implementation of all super classes of a class are
executed before the +load
of that class is executed;
+load
implementation of a class is executed before the
+load
implementation of any category.
In particular, the following things, even if they can work in a particular case, are not guaranteed:
@"this is a
constant string"
);
You should make no assumptions about receiving +load
in sibling
classes when you write +load
of a class. The order in which
sibling classes receive +load
is not guaranteed.
The order in which +load
and +initialize
are called could
be problematic if this matters. If you don’t allocate objects inside
+load
, it is guaranteed that +load
is called before
+initialize
. If you create an object inside +load
the
+initialize
method of object’s class is invoked even if
+load
was not invoked. Note if you explicitly call +load
on a class, +initialize
will be called first. To avoid possible
problems try to implement only one of these methods.
The +load
method is also invoked when a bundle is dynamically
loaded into your running program. This happens automatically without any
intervening operation from you. When you write bundles and you need to
write +load
you can safely create and send messages to objects whose
classes already exist in the running program. The same restrictions as
above apply to classes defined in bundle.