d的内省设计(dbi)

╰+攻爆jí腚メ 2022-08-28 07:45 125阅读 0赞

# 内省设计 #

[原地址][Link 1]  
作者:`H.S.Teoh`,`这是中国人`.  
`基本理念`很简单,但结果却`很强大`.传统代码:

auto myFunc(T data) {  ... }

这里`T`为具体`整/浮/构`等.然而该函数在实现中`不必`依赖`T`的所有细节.它可能只需要`.前/.空的`函数.  
因而,这里可`抽象`为只要有`带期望语义`的`.前/.空的`函数的`任意类型`.现在是:

auto myFunc(T)(T data) { 
        ... //利用`.前/.空的`函数.
    }

这是`模板函数`.而`内省设计`更进一步,假定`.空的`非必要,其只是可优化`效率`.因而可让无`.空的`类型传进来.现在,可用`静如`来检查它.

auto myFunc(T)(T data) { 
        static if (.../*如有空的*/) { 
            ... // 利用`空的/前`函数
        } else { 
            ... // 无`空的`的实现.
        }
    }

现在,可利用`两类类型`:有`空的/前`类型或有`前`类型.  
同样,不必限制在`存在`字段,也可为`编译时`可内省的`任意属性`.如基于`类型大小`用`静如`来切换实现,或`如何为大量实例最佳分配内存`,或根据`用定属`来改变`函数`行为.  
看起来作用不大,但我们可用`静如`来扩大`适用函数`的类型.`静如`越多`适用类型`越多.让`函数`适应调用者`需求`.  
传统中,是每个`构/类`有个`序化`方法.这很烦人.现在:

void save(S,T)(S storage, T data) { 
        static if (is(T == struct)) { 
            ... // 序化构
        } else static if (is(T == class)) { 
            ... // 序化类
        } else if (is(T == U[], U)) { 
            ... // 序化数组
        } else if (is(T : int)) { 
            ... // 序化整类
        }
        ... // 等等
        else static assert(0, "不能序化" ~ T.stringof~"类型");
    }

现在,这样使用:

S data;
    	storage.save(data);
    //序化S构
    	int data;
    	storage.save(data);
    //序化整
    	S[] data;
    	storage.save(data);
    //序化数组

超级简单.只改`类型`,连`data`都不必改.`自动适应`.  
如果,我想让`串`与`数组`不一样呢,可在`数组`的`静如`块前加处理`串`的`静如`块.

void save(S,T)(S storage, T data) { 
        static if ...
        ... else if (is(T == string)) { 
            ... // 特殊处理串.
        } else if (is(T == U[], U)) { 
            ... // 通用数组
        } else ...
    }

但如果想,`特殊处理`特殊类型呢?如`排除`某些字段.如`排除`下次可重新计算的`存储缓存`的`字段`.此时,就可用`用定属`.用`用定属`属性标记不想保存的字段.

struct DontSerialize { }
    
    struct MyStruct { 
        int i;		// 保存
        float f;	// 保存
        @DontSerialize string s; // 不保存
    }
    
    void save(S,T)(S storage, T data) { 
        ...
        static if (is(T == struct)) { 
            foreach (field; allMembers!T) { 
                // 跳过`DontSerialize`标记字段
                static if (!hasUDA!(mixin("data."~field), DontSerialize)) { 
                    ... // 这里序化.
                }
            }
        }
        ...
    }

传统方法,需要`黑名单/标志`,而基于`内省设计`,都不需要.

MyStruct[] data;
    storage.save(data);
    //使用代码如前.

只需要用`用定属`标记构中`字段`.并添加一个处理`用定属`的`静如`块,就行了.不需要`大规模`重构,就行了.  
利用`用定属`,还可做很多.如用不同`用定属`标记不同`序化`机制.如`可压缩`数据.`不必保存`数据,等等.而`保存`的`接口`完全一样.仍然是:

storage.save(data);

不必改动调用`保存`的代码.只需要`标记`类型定义,一切搞定.  
这就是`内省设计`的力量.

[Link 1]: https://forum.dlang.org/post/mailman.607.1633396288.21945.digitalmars-d@puremagic.com