使用AOP 使C#代码更清晰

http://blog.csdn.net/yanghua_kobe/article/details/6917228

 

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

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

简介

 

如果你很熟悉面向方面编程(AOP)，你就会知道给代码增加“切面”可以使代码更清晰并且具有可维护性。但是AOP通常都依赖于第三方类库或者硬编码的.net特性来工作。虽然这些实现方式的好处大于它们的复杂程度，但是我仍然在寻找一种实现AOP的更为简单的方式，来试我的代码更为清晰。我将它们单独移出来，并命名为AspectF。

 

Aspect Oriented Programming (AOP)的背景

“切面”指的是那些在你写的代码中在项目的不同部分且有相同共性的东西。它可能是你代码中处理异常、记录方法调用、时间处理、重新执行一些方法等等的一些特殊方式。如果你没有使用任何面向切面编程的类库来做这些事情，那么在你的整个项目中将会遗留一些很简单而又重复的代码，它将使你的代码很难维护。例如，在你的业务逻辑层有些方法需要被记录，有些异常需要被处理，有些执行需要计时，数据库操作需要重试等等。所以，也许你会写出下面这样的代码。

 

[csharp] view plaincopyprint?

 

    public bool InsertCustomer(string firstName,string lastName,int age,  

        Dictionary<string,string> attributes) 

    { 

        if (string.IsNullOrEmpty(firstName))  

            throw new ApplicationException("first name cannot be empty"); 

        if (string.IsNullOrEmpty(lastName)) 

            throw new ApplicationException("last name cannot be empty"); 

        if (age < 0) 

            throw new ApplicationException("Age must be non-zero"); 

        if (null == attributes) 

            throw new ApplicationException("Attributes must not be null"); 

           

        // Log customer inserts and time the execution 

        Logger.Writer.WriteLine("Inserting customer data..."); 

        DateTime start = DateTime.Now; 

           

        try 

        { 

            CustomerData data = new CustomerData(); 

            bool result = data.Insert(firstName, lastName, age, attributes); 

            if (result == true) 

            { 

                Logger.Writer.Write("Successfully inserted customer data in "  

                    + (DateTime.Now-start).TotalSeconds + " seconds"); 

            } 

            return result; 

        } 

        catch (Exception x) 

        { 

            // Try once more, may be it was a network blip or some temporary downtime 

            try 

            { 

                CustomerData data = new CustomerData(); 

                if (result == true) 

                { 

                    Logger.Writer.Write("Successfully inserted customer data in "  

                        + (DateTime.Now-start).TotalSeconds + " seconds"); 

                } 

                return result; 

            } 

            catch  

            { 

                // Failed on retry, safe to assume permanent failure. 

                // Log the exceptions produced 

                Exception current = x; 

                int indent = 0; 

                while (current != null) 

                { 

                    string message = new string(Enumerable.Repeat('\t', indent).ToArray()) 

                        + current.Message; 

                    Debug.WriteLine(message); 

                    Logger.Writer.WriteLine(message); 

                    current = current.InnerException; 

                    indent++; 

                } 

                Debug.WriteLine(x.StackTrace); 

                Logger.Writer.WriteLine(x.StackTrace); 

                return false; 

            } 

        } 

    }  

 

 

你会看到上面只有两行关键代码，它调用了CustomerData实例的一个方法插入了一个Customer。但去实现这样的业务逻辑，你真的很难去照顾所有的细节(日志记录、重试、异常处理、操作计时)。项目越成熟，在你的代码中需要维护的这些“边边角角”就更多了。所以你肯定经常会到处拷贝这些“样板”代码，但只在这些样板内写少了真是的东西。这多不值！你不得不对每个业务逻辑层的方法都这么做。比如现在你想在你的业务逻辑层中增加一个UpdateCustomer方法。你不得不再次拷贝所有的这些“样板”，然后将两行关键代码加入其中。

 

思考这样的场景，你需要做出一个项目级别的改变——针对如何处理异常。你不得不处理你写的这“上百”的方法，然后一个一个地修改它们。如果你想修改计时的逻辑，做法同样如此。

 

面向切面编程就可以很好地处理这些问题。当你采用AOP，你会以一种很酷的方式来实现它：

[csharp] view plaincopyprint?

 

    [EnsureNonNullParameters] 

    [Log] 

    [TimeExecution] 

    [RetryOnceOnFailure] 

    public void InsertCustomerTheCoolway(string firstName,string lastName,int age, 

        Dictionary<string,string> attributes) 

    { 

        CustomerData data = new CustomerData(); 

        data.Insert(firstName, lastName, age, attributes); 

    } 

 

 

这里你需要区分这些通用的东西，像日志记录、计时、重试、验证等这些通常被称为“边边角角”的东西，最重要的是完全与你的“真实”代码无关。这可以使方法将会变得美观而清晰。所有的这些细节都在方法外被处理，并且只是在代码外加上了一些属性。这里，每一个属性代表一个Aspect(切面)。例如，你可以增加“日志记录”切面到任何代码中，只需要增加一个Log属性。无论你使用何种AOP的类库，该类库都能够确保这些“切面”被有效地加入到代码中，当然时机不一，可能是在编译时，也可能是在运行时。

 

有许多AOP类库通过使用编译事件和IL操作允许你在编译时“处理”这些方面，例如PostSharp；而某些类库使用DynamicProxy在运行时处理；某些要求你的类继承自ContextBoundObject使用C#内建特性来supportAspects。所有的这些都有某些“不便”。你不得不使用某些外部库，做足够的性能测试来那些类库可扩展等等。而你需要的只是一个非常简单的方式来实现“隔离”，可能并不是想要完全实现AOP。记住，你的目的是隔离那些并不重要的核心代码，来让一切变得简单并且清晰！

 

AspectF如何来让这一切变得简单！

 

让我展示一种简答的方式来实现这种隔离，仅仅使用标准的C#代码，类和代理的简单调用，没有用到“特性”或者“IL操作”这些东西。它提供了可重用性和可维护性。最好的一点是它的“轻量级”——仅仅一个很小得类。

[csharp] view plaincopyprint?

 

    public void InsertCustomerTheEasyWay(string firstName,string lastName,int age, 

        Dictionary<string,string> attributes) 

    { 

        AspectF.Define 

            .Log(Logger.Writer,"Inserting customer the easy way") 

            .HowLong(Logger.Writer,"Starting customer insert",  

            "Inserted customer in {1} seconds") 

            .Retry() 

            .Do(() => 

                { 

                    CustomerData data = new CustomerData(); 

                    data.Insert(firstName, lastName, age, attributes); 

                }); 

    } 

 

 

让我们看看它与通常的AOP类库有何不同：

 

(1)     不在方法的外面定义“切面”，而是在方法的内部直接定义。

 

(2)     取代将“切面”做成类，而是将其构建成方法

 

现在，看看它有什么优势：

 

(1)     没有很“深奥”的要求(Attributes, ContextBoundObject, Post build event, IL Manipulation,DynamicProxy)

 

(2)     没有对其他依赖的性能担忧

 

(3)     直接随意组合你要的“切面”。例如，你可以只对日志记录一次，但尝试很多次操作。

 

(4)     你可以传递参数，局部变量等到“切面”中，而你在使用第三方类库的时候，通常不能这么做

 

(5)     这不是一个完整的框架或类库，而仅仅是一个叫做AspectF的类

 

(6)     可能以在代码的任何地方定义方面，例如你可以将一个for 循环包裹成一个“切面”

 

让我们看看使用这种方案构建一个“切面”有多简单！这个方案中“切面”都是以方法来定义的。AspectExtensions类包含了所有的这些“预构建”的切面，比如：Log、Retry、TrapLog、TrapLogThrow等。例如，这里展示一下Retry是如何工作的：

[csharp] view plaincopyprint?

 

    [DebuggerStepThrough] 

    public static AspectF Retry(this AspectF aspects) 

    { 

        return aspects.Combine((work) =>  

            Retry(1000, 1, (error) => DoNothing(error), DoNothing, work)); 

    } 

       

    [DebuggerStepThrough] 

    public static void Retry(int retryDuration,int retryCount,  

        Action<Exception> errorHandler, Action retryFailed, Action work) 

    { 

        do 

        { 

            try 

            { 

                work(); 

            } 

            catch (Exception x) 

            { 

                errorHandler(x); 

                System.Threading.Thread.Sleep(retryDuration); 

            } 

        }while (retryCount-- > 0); 

        retryFailed(); 

    } 

 

 

你可以让“切面”调用你的代码任意多次。很容易在Retry切面中包裹对数据库、文件IO、网络IO、Web Service的调用，因为它们经常由于各种基础设施问题而失败，并且有时重试一次就可以解决问题。我有个习惯是总是去尝试数据库插入，更新，删除、web service调用，处理文件等等。而这样的“切面”无疑让我对处理这样的问题时轻松了许多。

 

下面展示了一下它是如何工作的，它创建了一个代理的组合。而结果就像如下这段代码：

[csharp] view plaincopyprint?

 

    Log(() => 

    { 

        HowLong(() => 

        { 

            Retry(() => 

            { 

                Do(() => 

                { 

                    CustomerData data = new CustomerData(); 

                    data.Insert(firstName, lastName, age, attributes); 

                }); 

            }); 

        }); 

    }); 

 

 

AspectF类除了压缩这样的代码之外，其他什么都没有。

 

下面展示，你怎样创建你自己的“切面”。首先为AspectF类创建一个扩展方法。比如说，我们创建一个Log：

[csharp] view plaincopyprint?

 

    [DebuggerStepThrough] 

    public static AspectF Log(this AspectF aspect, TextWriter logWriter,  

                string beforeMessage,string afterMessage) 

    { 

        return aspect.Combine((work) => 

        { 

            logWriter.Write(DateTime.Now.ToUniversalTime().ToString()); 

            logWriter.Write('\t'); 

            logWriter.Write(beforeMessage); 

            logWriter.Write(Environment.NewLine); 

       

            work(); 

       

            logWriter.Write(DateTime.Now.ToUniversalTime().ToString()); 

            logWriter.Write('\t'); 

            logWriter.Write(afterMessage); 

            logWriter.Write(Environment.NewLine); 

        }); 

    } 

 

 

你调用AspectF的Combine方法来压缩一个将要被放进委托链的委托。委托链在最后将会被Do方法调用。

[csharp] view plaincopyprint?

 

    public class AspectF 

    { 

        /// <summary> 

        /// Chain of aspects to invoke 

        /// </summary> 

        public Action<Action> Chain = null; 

        /// <summary> 

        /// Create a composition of function e.g. f(g(x)) 

        /// </summary> 

        /// <param name="newAspectDelegate">A delegate that offers an aspect's behavior.  

        /// It's added into the aspect chain</param> 

        /// <returns></returns> 

        [DebuggerStepThrough] 

        public AspectF Combine(Action<Action> newAspectDelegate) 

        { 

            if (this.Chain == null) 

            { 

                this.Chain = newAspectDelegate; 

            } 

            else 

            { 

                Action<Action> existingChain = this.Chain; 

                Action<Action> callAnother = (work) =>  

                    existingChain(() => newAspectDelegate(work)); 

                this.Chain = callAnother; 

            } 

            return this; 

        } 

 

 

这里Combine方法操作的是被“切面”扩展方法传递过来的委托，例如Log，然后它将该委托压入之前加入的一个“切面”的委托中，来保证第一个切面调用第二个，第二个调用第三个，知道最后一个调用真实的(你想要真正执行的)代码。

 

Do/Return方法做最后的执行操作。

[csharp] view plaincopyprint?

 

    /// <summary> 

    /// Execute your real code applying the aspects over it 

    /// </summary> 

    /// <param name="work">The actual code that needs to be run</param> 

    [DebuggerStepThrough] 

    public void Do(Action work) 

    { 

        if (this.Chain == null) 

        { 

            work(); 

        } 

        else 

        { 

            this.Chain(work); 

        } 

    } 

 

 

就是这些，现在你有一个非常简单的方式来分隔那些你不想过度关注的代码，并使用C#享受AOP风格的编程模式。

 

AspectF类还有其他几个方便的“切面”，大致如下（当然你完全可以DIY你自己的‘切面’）。

 

[csharp] view plaincopyprint?

 

    public static class AspectExtensions 

        { 

            [DebuggerStepThrough] 

            public static void DoNothing() 

            { 

       

            } 

       

            [DebuggerStepThrough] 

            public static void DoNothing(params object[] whatever) 

            { 

       

            } 

       

            [DebuggerStepThrough] 

            public static AspectF Delay(this AspectF aspect, int milliseconds) 

            { 

                return aspect.Combine((work) => 

                { 

                    System.Threading.Thread.Sleep(milliseconds); 

                    work(); 

                }); 

            } 

       

            [DebuggerStepThrough] 

            public static AspectF MustBeNonNull(this AspectF aspect, params object[] args) 

            { 

                return aspect.Combine((work) => 

                { 

                    for (int i = 0; i < args.Length; i++) 

                    { 

                        object arg = args[i]; 

                        if (arg == null) 

                        { 

                            throw new ArgumentException(string.Format("Parameter at index {0} is null", i)); 

                        } 

                    } 

                    work(); 

                }); 

            } 

       

            [DebuggerStepThrough] 

            public static AspectF MustBeNonDefault<T>(this AspectF aspect, params T[] args) where T : IComparable 

            { 

                return aspect.Combine((work) => 

                { 

                    T defaultvalue = default(T); 

                    for (int i = 0; i < args.Length; i++) 

                    { 

                        T arg = args[i]; 

                        if (arg == null || arg.Equals(defaultvalue)) 

                        { 

                            throw new ArgumentException(string.Format("Parameter at index {0} is null", i)); 

                        } 

                    } 

                    work(); 

                }); 

            } 

       

            [DebuggerStepThrough] 

            public static AspectF WhenTrue(this AspectF aspect, params Func<bool>[] conditions) 

            { 

                return aspect.Combine((work) => 

                { 

                    foreach (Func<bool> condition in conditions) 

                    { 

                        if (!condition()) 

                        { 

                            return; 

                        } 

                    } 

                    work(); 

                }); 

            } 

       

            [DebuggerStepThrough] 

            public static AspectF RunAsync(this AspectF aspect, Action completeCallback) 

            { 

                return aspect.Combine((work) => work.BeginInvoke(asyncresult => 

                { 

                    work.EndInvoke(asyncresult); completeCallback(); 

                },null)); 

            } 

       

            [DebuggerStepThrough] 

            public static AspectF RunAsync(this AspectF aspect) 

            { 

                return aspect.Combine((work) => work.BeginInvoke(asyncresult => 

                { 

                    work.EndInvoke(asyncresult); 

                },null)); 

            } 

        } 

 

 

现在，你已经拥有了一个简洁的方式来隔离那些细枝末节的代码，去享受AOP形式的编程而无需使用任何“笨重”的框架。