Dynamically Creating Classes and Assigning Properties at Runtime

Why We Need Dynamic Class Creation

In conventional development, we define classes in .h and .m files, and the compiler determines the class structure at compile time. But some scenarios require class structures that can’t be determined at compile time — for example, dynamically generating models from JSON data, or creating a new class with only specific methods. Additionally, KVO’s underlying implementation dynamically creates a subclass of the target class and overrides property setters to achieve observer notifications.

The core of dynamic class creation is the combination of four functions: objc_allocateClassPair, class_addIvar, class_addMethod, and objc_registerClassPair.

The Complete Flow of Dynamic Class Creation

Step 1: Call objc_allocateClassPair to allocate a class object

This function allocates a class object and returns a Class pointer. Pass in the superclass, class name, and extra memory space size.

Class MyClass = objc_allocateClassPair([NSObject class], "MyDynamicClass", 0);
if (!MyClass) {
    // Class name already exists or allocation failed
    return;
}

If the class name already exists, objc_allocateClassPair returns Nil. So in real projects, you typically use objc_getClass to check if the class already exists first.

Step 2: Add member variables

class_addIvar adds member variables to the class. It must be called before objc_registerClassPair. The reason: a class’s instance memory layout is determined at compile time, and member variables belong to class_ro_t (the read-only part). Once the class is registered with the runtime, the ro is locked and can no longer be modified.

BOOL success = class_addIvar(MyClass, "name", sizeof(NSString *), log2(sizeof(NSString *)), "@");

The fifth parameter is the type encoding, where "@" denotes an object type. log2(sizeof(NSString *)) calculates the alignment — for pointer types, this is 3 (since 8 = 2^3).

Step 3: Add methods

class_addMethod can be called before or after class registration. Unlike member variables, methods are stored in class_rw_t (the read-write part) and can be dynamically added at runtime.

void sayHello(id self, SEL _cmd) {
    NSLog(@"Hello from dynamic class!");
}

class_addMethod(MyClass, @selector(sayHello), (IMP)sayHello, "v@:");

The fourth parameter "v@:" is the method type encoding: v means void return, @ means the first parameter is id (self), and : means the second parameter is SEL (_cmd).

Step 4: Register the class

objc_registerClassPair registers the class with the runtime, making it usable. After registration, you can no longer add member variables, but you can continue adding methods and properties.

objc_registerClassPair(MyClass);

Using Dynamically Created Classes and Assigning Properties

Once the class is created, member properties can be assigned in two ways: KVC and object_setIvar.

Method 1: Assignment via KVC

KVC is the most common approach, reading and writing values directly using string keys.

id instance = [[MyClass alloc] init];
[instance setValue:@"John" forKey:@"name"];
NSString *name = [instance valueForKey:@"name"];
NSLog(@"%@", name);  // Output: John

Method 2: Direct manipulation via object_setIvar

object_setIvar bypasses KVC’s lookup process and directly operates on member variables, offering better performance. You first need to get the Ivar reference via class_getInstanceVariable.

id instance = [[MyClass alloc] init];
Ivar nameIvar = class_getInstanceVariable(MyClass, "name");
object_setIvar(instance, nameIvar, @"Jane");
NSString *name = object_getIvar(instance, nameIvar);
NSLog(@"%@", name);  // Output: Jane

A Complete Dynamic Class Creation Example

#import <objc/runtime.h>

// Dynamic method implementation
void dynamicMethodIMP(id self, SEL _cmd, NSString *param) {
    Ivar ivar = class_getInstanceVariable([self class], "name");
    id value = object_getIvar(self, ivar);
    NSLog(@"name = %@, param = %@", value, param);
}

- (void)createDynamicClass {
    // 1. Allocate the class
    Class MyClass = objc_allocateClassPair([NSObject class], "Person", 0);
    if (!MyClass) return;

    // 2. Add member variables
    class_addIvar(MyClass, "name", sizeof(NSString *), log2(sizeof(NSString *)), "@");
    class_addIvar(MyClass, "age", sizeof(NSInteger), log2(sizeof(NSInteger)), "i");

    // 3. Add methods
    class_addMethod(MyClass, @selector(print:), (IMP)dynamicMethodIMP, "v@:@");

    // 4. Register the class
    objc_registerClassPair(MyClass);

    // 5. Use it
    id person = [[MyClass alloc] init];
    [person setValue:@"John" forKey:@"name"];
    [person setValue:@25 forKey:@"age"];

    // Call the dynamically added method
    [person performSelector:@selector(print:) withObject:@"hello"];
}

Important Considerations for Dynamic Class Creation

Member variables must be added before registration: After class registration, class_ro_t is locked — you can’t add more member variables. But methods and properties can still be added after registration since they live in class_rw_t.

Class names must be unique: If the class name already exists, objc_allocateClassPair returns Nil. Use objc_getClass to check first.

Dynamic classes also need memory management: Under ARC, dynamically created classes are also managed by automatic reference counting — instances created with alloc/init are released normally.