Foundation Objective-c：带数组的字典；字典与字典

假设我有一个 NSDictionary，其中包含 NSArray 和 NSDictionary 的两个子集合：

NSMutableDictionary *mkDict(void){
    NSMutableDictionary *dict=[NSMutableDictionary dictionary];
    NSMutableDictionary *sub=[NSMutableDictionary dictionary];
    NSMutableArray *array= [NSMutableArray array];
    [dict setObject:array forKey:@"array_key"];
    [dict setObject:sub forKey:@"dict_key"];
    return dict;
}

有多种方法可以访问子集合的单个元素，我选择对其中三种进行计时。

第一种方法是通过访问父元素的键来间接访问子元素：

void KVC1(NSMutableDictionary *dict, int count){

    for(int i=0; i<count; i++){
        char buf1[40], buf2[sizeof buf1];
        snprintf(buf1,sizeof(buf1),"element %i", i);
        snprintf(buf2, sizeof buf2, "key %i", i);

        [[dict objectForKey:@"array_key"] 
          addObject:
             [NSString stringWithUTF8String:buf1]];
        [[dict objectForKey:@"dict_key"] 
          setObject:[NSString stringWithUTF8String:buf1] 
          forKey:[NSString stringWithUTF8String:buf2]];
    }
}

第二种是使用KeyPath访问：

void KVC2(NSMutableDictionary *dict, int count){

    for(int i=0; i<count; i++){
        char buf1[40], buf2[sizeof buf1], buf3[sizeof buf1];
        snprintf(buf1,sizeof(buf1),"element %i", i);
        snprintf(buf2, sizeof buf2, "key %i", i);
        snprintf(buf3, sizeof buf3, "dict_key.key %i",i);

        [dict insertValue:
             [NSString stringWithUTF8String:buf1] 
            atIndex:i inPropertyWithKey:@"array_key"];
        [dict setValue:
             [NSString stringWithUTF8String:buf1] 
            forKeyPath:
             [NSString stringWithUTF8String:buf3]];
    }
}

第三种与第一种类似，是访问指向子元素的指针，然后使用该指针：

void KVC3(NSMutableDictionary *dict, int count){

    NSMutableArray *subArray = [dict objectForKey:@"array_key"];
    NSMutableDictionary *subDict = [dict objectForKey:@"dict_key"];

    for(int i=0; i<count; i++){
        char buf1[40], buf2[sizeof buf1];
        snprintf(buf1,sizeof(buf1),"element %i", i);
        snprintf(buf2, sizeof buf2, "key %i", i);

        [subArray addObject:[NSString stringWithUTF8String:buf1]];
        [subDict 
           setObject:
            [NSString stringWithUTF8String:buf1] 
           forKey:
            [NSString stringWithUTF8String:buf2]];
    }
}

这是计时代码：

#import <Foundation/Foundation.h>
#import <mach/mach_time.h>

// KVC1, KVC2 and KVC3 from above...

#define TIME_THIS(func,times) \
({\
mach_timebase_info_data_t info; \
mach_timebase_info(&info); \
uint64_t start = mach_absolute_time(); \
for(int i=0; i<(int)times; i++) \
func ; \
uint64_t duration = mach_absolute_time() - start; \
duration *= info.numer; \
duration /= info.denom; \
duration /= 1000000; \
NSLog(@"%i executions of line %i took %lld milliseconds", times, __LINE__, duration); \
});

int main (int argc, const char * argv[]) {
    NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
    NSMutableDictionary *dict=mkDict();
    NSMutableDictionary *dict2=mkDict();
    NSMutableDictionary *dict3=mkDict();

    TIME_THIS(KVC1(dict,1000),10);
    TIME_THIS(KVC2(dict2,1000),10);
    TIME_THIS(KVC3(dict3,1000),10);

    if([dict isEqualToDictionary:dict2])
        NSLog(@"And they are the same...");
    [pool drain];
    return 0;
}

结果如下：

10 executions of line 256 took 57 milliseconds
10 executions of line 257 took 7930 milliseconds
10 executions of line 258 took 46 milliseconds
And they are the same...

问：为什么 OS X Snow Leopard / Lion 建议的使用 KeyPaths 的方法如此缓慢？如果你增加尺寸count到 10,000 或更多时，KVC2 变得无限慢，而其他两种方法则线性增加。

难道我做错了什么？是否有更好的习惯用法来访问字典中子集合的单个元素？

In KVC2()，你发送

[dict insertValue:[NSString stringWithUTF8String:buf1] 
          atIndex:i
inPropertyWithKey:@"array_key"]; 

该方法的文档说明如下：

方法insertIn<Key>:atIndex:如果存在则被调用。如果没有相应的符合脚本 KVC 的方法（insertIn<Key>:atIndex:) 被发现，该方法调用mutableArrayValueForKey:并改变结果。

由于消息正在发送至dict，一个实例NSDictionary，没有-insertIn<Key>:atIndex:方法，因此-mutableArrayValueForKey:已发送。此方法的文档说明如下：

返回值一个可变数组代理，提供对 key 指定的有序对多关系的读写访问。

讨论添加到可变数组中的对象将与接收者相关，而从可变数组中删除的对象将变得无关。默认实现识别与 valueForKey: 相同的简单访问器方法和数组访问器方法，并遵循相同的直接实例变量访问策略，但始终返回可变集合代理对象，而不是 valueForKey: 将返回的不可变集合。

所以发生的事情是这样的在每次迭代时：

1. 代理可变数组被创建为可变副本原始数组的；
2. 一个对象被添加到代理数组中；
3. 代理数组将相同的对象添加到原始数组中。

如果您使用 Instruments 来分析您的程序，您会注意到大约 50% 的处理时间花费在-[NSKeyValueSlowMutableArray insertObject:atIndex:]— 我认为可以肯定地假设NSKeyValueSlowMutableArray是代理数组，它的名称应该是其性能的线索。