当前位置：网站首页>d实验新异常

d实验新异常

2022-08-08 09:33:00 【51CTO】

原文串不好,应用变量.很容易创建新类型.如std.algorithm中管道一样,隐式实例化模板的返回值.
我构建了arsd.exception模块,新异常重点是改进enforce.

用法

       
       import 
       
       exception2;
       
       enum 
       
       MyError;
       
       enum 
       
       OtherError;
       
       void 
       
       main() {
       
       int 
       
       a;
       
       try {
       
       throw 
       
       Exception2
       
       !
       
       MyError(
       
       a, 
       
       "更多信息");
       
    } 
       
       catch(
       
       Exception2
       
       !(
       
       OtherError) 
       
       e) {
       
       // 不会抓它,因为它是另一个错误
       
       import 
       
       std.
       
       stdio;
       
       writeln(
       
       "wrong");
       
    } 
       
       catch(
       
       Exception2
       
       !(
       
       MyError, 
       
       int) 
       
       e) {
       
       // 会抓!
       
       import 
       
       std.
       
       stdio;
       
       writeln(
       
       "CAUGHT!");
       
       writeln(
       
       e);
       
    }
       
}
      
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.

我抛了整/串,但只抓了整.想法细节只是进一步特化,可根据是否感兴趣来处理它们.如果不关心附加数据,可只catch(Exception2!MyError).
或静态列举MyError构中数据,而不是用MyError来枚举.另一方面,可丢弃所有命名空间类型的区分,而只使用Exception2!("somestring",data).

       
       import 
       
       exception2;
       
       void 
       
       main() {
       
       int 
       
       a;
       
       try {
       
       //串错误类型而不是命名空间的D类型仍可附加信息
       
       throw 
       
       Exception2
       
       !
       
       "foo bar"(
       
       a);
       
    } 
       
       catch(
       
       Exception2
       
       !
       
       "foo bar") { 
       
       //按串抓
       
       import 
       
       std.
       
       stdio;
       
       writeln(
       
       "caught");
       
    }
       
}
      
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.

我不大喜欢,串不能区分不同库.而使用enum,可通过模块导入和命名空间规则区分.
优点是可不提前声明,可在抛点声明,并在抓点确认.我不大喜欢这种风格,但与throw new Exception("一些串")一样方便,且可附加数据.
你可能反驳说,声明新类,并用mixin template.声明结构,枚举,并在那里声明相关数据.好处不大.
我要说,枚声明,得到了异常族的静态列表,然后根据需要添加数据.
考虑InvalidValue族,附加信息,给了int valueGiven, int maxValue,或int valueGiven, int minValue, int maxValue,或string valueGiven, string expectedPattern.一个族,可合理地附加不同值.
这,也是为何需要结构化数据.
如果得到两个int值,哪个是valueGiven,哪个是maxValue?还是给出了两个值(如矩阵坐标)?
用该机制,你可

       
       throw 
       
       Exception2
       
       !
       
       InvalidValue(
       
       MyStruct(
       
       structured, 
       
       information, 
       
       here);
      
1.

别人可

       
       catch(
       
       Exception2
       
       !
       
       InvalidValue)
       
       //或
       
       catch(
       
       Exception2
       
       !(
       
       InvalidValue, 
       
       MyStruct))
      
1.
2.
3.

来抓族或细节.
仍然工作,只是参数,

       
       struct 
       
       MyStruct {}
       
       //从上面,变成下面.
       
       class 
       
       InvalidValueExceptionWithMyStruct : 
       
       InvalidValueException { 
       
       MyStruct 
       
       data; 
       
       mixin 
       
       ExceptionCtor;
       
       s }
      
1.
2.
3.

当前,异常的信息不足.

我想用IFTI:隐式函数模板实例化,来附加数据,即要创建新子类.它不能用普通的构造函数.但可用opCall.
此外,我还想确保派生类可在声明点外命名,这样你可轻松抓异常.这排除了匿名类,但仍可用opCall.

深入代码

       
       module 
       
       exception2;
       
       /+
       
       它使用长格式模板编写,
       
       因为我想单独定义父
       
       这样更容易.
       
       +/
       
       template 
       
       Exception2(
       
       alias 
       
       Type, 
       
       T...) {
       
       //每条添加数据都是更一般情况的特化
       
       //这是通过父类不变,但切掉了一块来实现
       
       //或作为所有`Exception2`的通用父级,并回退到`Exception`
       
       static 
       
       if(
       
       T.
       
       length)
       
       alias 
       
       Parent 
       
       = 
       
       Exception2
       
       !(
       
       Type, 
       
       T[
       
       0 .. 
       
       $
       
       -
       
       1]);
       
       else
       
       alias 
       
       Parent 
       
       = 
       
       Exception;
       
       class 
       
       Exception2 : 
       
       Parent {
       
       //应该以不同的方式命名,或至少是`const`之类的
       
       //但它保存在抛点传递的数据
       
       T 
       
       t;
       
       //这是抛的主要入口点,注意它如何像`标库`中工厂模式一样,取参数并转发给新类
       
       //在`Phobos`中用于构造,如,来自`map()`的`MapResult.`
       
       //如果你直接使用`newException2`,必须指定所有要传递类型,但通过`opCall`,可隐式推导`R`.
       
       //注意推导的返回值是传递过来的完整静态类型.
       
       static 
       
       opCall(
       
       R...)(
       
       R 
       
       r, 
       
       string 
       
       file 
       
       = 
       
       __FILE__, 
       
       size_t 
       
       line 
       
       = 
       
       __LINE__) {
       
       return 
       
       new 
       
       Exception2
       
       !(
       
       Type, 
       
       T, 
       
       R)(
       
       r, 
       
       "", 
       
       file, 
       
       line); 
       
       //串可包含任意
       
        }
       
       //你不能直接调用它!我甚至使它为`保护`
       
       this(
       
       T 
       
       t, 
       
       string 
       
       msg, 
       
       string 
       
       file 
       
       = 
       
       __FILE__, 
       
       size_t 
       
       line 
       
       = 
       
       __LINE__) {
       
       this.
       
       t 
       
       = 
       
       t;
       
       static 
       
       if(
       
       is(
       
       Parent 
       
       == 
       
       Exception))
       
       super(
       
       msg, 
       
       file, 
       
       line);
       
       else
       
       super(
       
       t[
       
       0 .. 
       
       $
       
       -
       
       1], 
       
       msg, 
       
       file, 
       
       line);
       
        }
       
       //这与旧的arsd.exception`基本相同
       
       override 
       
       void 
       
       toString(
       
       scope 
       
       void 
       
       delegate(
       
       in 
       
       char[]) 
       
       sink) 
       
       const {
       
       import 
       
       std.
       
       conv;
       
       sink(
       
       typeid(
       
       this).
       
       name); 
       
       //待办,同名长串.
       
       sink(
       
       "@");
       
       sink(
       
       file);
       
       sink(
       
       ":");
       
       sink(
       
       to
       
       !
       
       string(
       
       line));
       
       sink(
       
       "\n");
       
       sink(
       
       "玩笑");
       
       //这部分是真实的:打印时,循环访问附加的数据并显示出来
       
       foreach(
       
       idx, 
       
       item; 
       
       t) {
       
       sink(
       
       "\n");
       
       sink(
       
       typeof((
       
       cast() 
       
       this).
       
       t[
       
       idx]).
       
       stringof);
       
       sink(
       
       " = ");
       
       sink(
       
       to
       
       !
       
       string(
       
       item));
       
            }
       
       if(
       
       info) {
       
       try {
       
       sink(
       
       "\n----------------");
       
       foreach (
       
       t; 
       
       info) {
       
       sink(
       
       "\n"); 
       
       sink(
       
       t);
       
                    }
       
                }
       
       catch (
       
       Throwable) {
       
       // 忽略更多错误.
       
                }
       
            }
       
        }
       
    }
       
}
      
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.
63.
64.
65.
66.
67.
68.
69.
70.
71.
72.
73.
74.
75.

这是灵活的类,它允许你定义catch(Exception2!X)和throw Exception2!X(data),声明了返回为你构造的更子类的对象的opCall.不是常见的静态opCall,是我以前的旧模式,并且它工作得很好.
我很满意.可方便地使用具更多结构的throw new Exception("stuff").

原网站

版权声明
本文为[51CTO]所创，转载请带上原文链接，感谢
https://blog.51cto.com/u_4139404/5554335

当前位置：网站首页>d实验新异常

d实验新异常

用法

深入代码

边栏推荐

猜你喜欢

随机推荐