【開源】OSharp3.0框架解說系列（6.2）：操作日志與數據日志

本文轉載自查看原文 2015-07-27 18:24 7898 osharp/ OSharp框架/ 架構設計/ 日志

OSharp是什么？

　　OSharp是個快速開發框架，但不是一個大而全的包羅萬象的框架，嚴格的說，OSharp中什么都沒有實現。與其他大而全的框架最大的不同點，就是OSharp只做抽象封裝，不做實現。依賴注入、ORM、對象映射、日志、緩存等等功能，都只定義了一套最基礎最通用的抽象封裝，提供了一套統一的API、約定與規則，並定義了部分執行流程，主要是讓項目在一定的規范下進行開發。所有的功能實現端，都是通過現有的成熟的第三方組件來實現的，除了EntityFramework之外，所有的第三方實現都可以輕松的替換成另一種第三方實現，OSharp框架正是要起隔離作用，保證這種變更不會對業務代碼造成影響，使用統一的API來進行業務實現，解除與第三方實現的耦合，保持業務代碼的規范與穩定。

本文已同步到系列目錄：OSharp快速開發框架解說系列

前言

　　在《【開源】OSharp框架解說系列（6.1）：日志系統設計》中，我們已經設計並實現了一個可擴展的日志系統，只要定義好輸出端的Adapter，就可以以任意形式輸出日志信息。

　　在系統開發中，有些日志記錄需求是常規需要的，比如操作日志，數據變更日志，系統異常日志等，我們希望把這些常規需求都集成到OSharp框架當中。有了內置的支持，在做開發的時候，只需要很簡單的配置，就可以實現相關需求。

　　關於三類日志，這里先簡要描述一下：

操作日志：粗略描述系統用戶（如管理員、業務人員、會員等）對系統的業務操作，只需要說清楚“XXX用戶在XXX時間做了XXX操作”
數據日志：有時候，為了追溯用戶的業務操作對系統產生的影響，需要記錄數據變更細節，這就是數據日志
系統日志：主要記錄系統在運行過程中產生的與業務無關的常規或異常的日志信息，這些日志信息通常由系統維護人員或開發人員查看

日志記錄准備

　　在OSharp框架中，操作日志與數據日志的記錄流程如下圖所示：

　　這里用文字簡單描述一下操作日志與數據日志記錄的實現思路：

定義了一個“功能信息記錄”的實體，用於提取系統中各個功能點的基礎信息（名稱、MVC的Area-Controller-Action、功能訪問類型（匿名訪問-登錄訪問-特定角色訪問）、是否啟用功能日志，是否啟用數據日志、功能URL等），並配置功能的行為

定義了一個“實體信息記錄”的實體，用於提取系統中各個數據實體類型的基礎信息（實體類型全名、實體名稱、是否啟用數據日志，實體屬性信息集），並配置實體的行為

系統初始化的時候，通過反射加載的程序集，提取並構建各個功能點（主要是MVC的Controller-Action）的功能信息記錄，更新到數據庫中

系統初始化的時候，通過反射加載的程序集，提取並構建各個實體類型的實體信息記錄，更新到數據庫中

利用MVC框架的ActionFilter進行AOP攔截，定義一個專門用於操作日志記錄的 OperateLogFilterAttribute ，重寫 OnActionExecuted 方法進行操作日志的記錄

操作日志與數據日志記錄的詳細流程如下：

在用戶的業務操作執行到保存數據的時候（EF執行SaveChanges時），根據操作涉及的實體獲取相應的實體信息記錄，確定是否創建數據日志，不需創建則跳過

需要創建時，根據實體的狀態（Added-Modified-Deleted），創建各個實體的新增-更新-刪除的數據日志信息，並存儲到臨時緩存中

執行到 OperateLogFilterAttribute 的 OnActionExecuted 方法的時候，根據ActionExecutedContext 中提供的Area，Controller，Action等信息，查詢出當前功能的功能信息記錄，確定是否記錄操作日志，不需記錄則返回

需要根據功能信息記錄，創建操作日志信息，並指定當前用戶為日志操作人。

根據功能信息是否啟用數據日志的配置，確定是否記錄數據日志，需要記錄時，從臨時緩存中提取前面創建的數據日志，作為從數據配置到操作日志中

向系統外部保存操作日志信息，完成操作日志的記錄

功能信息與實體信息

　　記錄各個功能點的功能信息接口定義如下：

 1     /// <summary>
 2     /// 功能接口，最小功能信息
 3     /// </summary>
 4     public interface IFunction
 5     {
 6         /// <summary>
 7         /// 獲取或設置 功能名稱
 8         /// </summary>
 9         string Name { get; set; }
10 
11         /// <summary>
12         /// 獲取或設置 區域名稱
13         /// </summary>
14         string Area { get; set; }
15 
16         /// <summary>
17         /// 獲取或設置 控制器名稱
18         /// </summary>
19         string Controller { get; set; }
20 
21         /// <summary>
22         /// 獲取或設置 功能名稱
23         /// </summary>
24         string Action { get; set; }
25 
26         /// <summary>
27         /// 獲取或設置 功能類型
28         /// </summary>
29         FunctionType FunctionType { get; set; }
30 
31         /// <summary>
32         /// 獲取或設置 是否啟用操作日志
33         /// </summary>
34         bool OperateLogEnabled { get; set; }
35 
36         /// <summary>
37         /// 獲取或設置 是否啟用數據日志
38         /// </summary>
39         bool DataLogEnabled { get; set; }
40 
41         /// <summary>
42         /// 獲取或設置 是否鎖定
43         /// </summary>
44         bool IsLocked { get; set; }
45 
46         /// <summary>
47         /// 獲取或設置 功能地址
48         /// </summary>
49         string Url { get; set; }
50     }

　　記錄各個數據實體類型的實體信息接口定義如下：

 1     /// <summary>
 2     /// 實體數據接口
 3     /// </summary>
 4     public interface IEntityInfo
 5     {
 6         /// <summary>
 7         /// 獲取 實體數據類型名稱
 8         /// </summary>
 9         string ClassName { get; }
10 
11         /// <summary>
12         /// 獲取 實體數據顯示名稱
13         /// </summary>
14         string Name { get; }
15 
16         /// <summary>
17         /// 獲取 是否啟用數據日志
18         /// </summary>
19         bool DataLogEnabled { get; }
20 
21         /// <summary>
22         /// 獲取 實體屬性信息字典
23         /// </summary>
24         IDictionary<string, string> PropertyNames { get; } 
25     }

　　OSharp框架中，已經派生了 Function 與 EntityInfo 兩個實體類型，作為功能信息與實體信息的封裝。

　　功能信息與實體信息的初始化實現，主要定義在 FunctionHandlerBase<TFunction, TKey> 與 EntityInfoHandlerBase<TEntityInfo, TKey> 兩個基礎中，OSharp中已經派生了 public class DefaultFunctionHandler : FunctionHandlerBase<Function, Guid> 與 public class DefaultEntityInfoHandler : EntityInfoHandlerBase<EntityInfo, Guid> 作為系統初始化時，從程序集中提取並更新功能信息與數據信息的默認實現。

　　由代碼圖，我們能很直觀的看到實體與處理器之間的關系：

　　關於這兩個處理器的實現流程，不是本文的重點，將在后面講解OSharp初始化實現時再詳述，這里先略過。提取的數據展示如下：

　　提取的功能信息：

　　提取的實體數據信息：

操作日志與數據日志實體

　　操作日志實體定義如下：

 1     /// <summary>
 2     /// 操作日志信息類
 3     /// </summary>
 4     [Description("系統-操作日志信息")]
 5     public class OperateLog : EntityBase<int>, ICreatedTime
 6     {
 7         /// <summary>
 8         /// 初始化一個<see cref="OperateLog"/>類型的新實例
 9         /// </summary>
10         public OperateLog()
11         {
12             DataLogs = new List<DataLog>();
13         }
14 
15         /// <summary>
16         /// 獲取或設置 執行的功能名稱
17         /// </summary>
18         [StringLength(100)]
19         public string FunctionName { get; set; }
20 
21         /// <summary>
22         /// 獲取或設置 操作人信息
23         /// </summary>
24         public Operator Operator { get; set; }
25 
26         /// <summary>
27         /// 獲取設置 信息創建時間
28         /// </summary>
29         public DateTime CreatedTime { get; set; }
30 
31         /// <summary>
32         /// 獲取或設置 數據日志集合
33         /// </summary>
34         public virtual ICollection<DataLog> DataLogs { get; set; }
35     }

　　數據日志實體定義如下：

 1     /// <summary>
 2     /// 數據日志信息類
 3     /// </summary>
 4     [Description("系統-數據日志信息")]
 5     public class DataLog : EntityBase<int>
 6     {
 7         /// <summary>
 8         /// 初始化一個<see cref="DataLog"/>類型的新實例
 9         /// </summary>
10         public DataLog()
11             : this(null, null, OperatingType.Query)
12         { }
13 
14         /// <summary>
15         /// 初始化一個<see cref="DataLog"/>類型的新實例
16         /// </summary>
17         public DataLog(string entityName, string name, OperatingType operatingType)
18         {
19             EntityName = entityName;
20             Name = name;
21             OperateType = operatingType;
22             LogItems = new List<DataLogItem>();
23         }
24 
25         /// <summary>
26         /// 獲取或設置 類型名稱
27         /// </summary>
28         [StringLength(500)]
29         [Display(Name = "類型名稱")]
30         public string EntityName { get; set; }
31 
32         /// <summary>
33         /// 獲取或設置 實體名稱
34         /// </summary>
35         [Display(Name = "實體名稱")]
36         public string Name { get; set; }
37 
38         /// <summary>
39         /// 獲取或設置 數據編號
40         /// </summary>
41         [StringLength(150)]
42         [DisplayName("主鍵值")]
43         public string EntityKey { get; set; }
44 
45         /// <summary>
46         /// 獲取或設置 操作類型
47         /// </summary>
48         [Description("操作類型")]
49         public OperatingType OperateType { get; set; }
50 
51         /// <summary>
52         /// 獲取或設置 操作日志信息
53         /// </summary>
54         public virtual OperateLog OperateLog { get; set; }
55 
56         /// <summary>
57         /// 獲取或設置 操作明細
58         /// </summary>
59         public virtual ICollection<DataLogItem> LogItems { get; set; }
60     }

　　數據日志操作變更明細項

 1     /// <summary>
 2     /// 實體操作日志明細
 3     /// </summary>
 4     [Description("系統-操作日志明細信息")]
 5     public class DataLogItem : EntityBase<Guid>
 6     {
 7         /// <summary>
 8         /// 初始化一個<see cref="DataLogItem"/>類型的新實例
 9         /// </summary>
10         public DataLogItem()
11             : this(null, null)
12         { }
13 
14        /// <summary>
15         ///初始化一個<see cref="DataLogItem"/>類型的新實例
16        /// </summary>
17        /// <param name="originalValue">舊值</param>
18        /// <param name="newValue">新值</param>
19         public DataLogItem(string originalValue, string newValue)
20         {
21             Id = CombHelper.NewComb();
22             OriginalValue = originalValue;
23             NewValue = newValue;
24         }
25 
26         /// <summary>
27         /// 獲取或設置 字段
28         /// </summary>
29         public string Field { get; set; }
30 
31         /// <summary>
32         /// 獲取或設置 字段名稱
33         /// </summary>
34         public string FieldName { get; set; }
35 
36         /// <summary>
37         /// 獲取或設置 舊值
38         /// </summary>
39         public string OriginalValue { get; set; }
40 
41         /// <summary>
42         /// 獲取或設置 新值
43         /// </summary>
44         public string NewValue { get; set; }
45 
46         /// <summary>
47         /// 獲取或設置 數據類型
48         /// </summary>
49         public string DataType { get; set; }
50 
51         /// <summary>
52         /// 獲取或設置 所屬數據日志
53         /// </summary>
54         public virtual DataLog DataLog { get; set; }
55     }

　　數據日志操作類型的枚舉：

 1     /// <summary>
 2     /// 實體數據日志操作類型
 3     /// </summary>
 4     public enum OperatingType
 5     {
 6         /// <summary>
 7         /// 查詢
 8         /// </summary>
 9         Query = 0,
10 
11         /// <summary>
12         /// 新建
13         /// </summary>
14         Insert = 10,
15 
16         /// <summary>
17         /// 更新
18         /// </summary>
19         Update = 20,
20 
21         /// <summary>
22         /// 刪除
23         /// </summary>
24         Delete = 30
25     }

　　下圖以較直觀的方式顯示操作日志與數據日志之間的關系：

數據日志的創建

　　數據日志，主要記錄業務操作過程中涉及到的各個數據實體的變更，而這里的變更，主要是實體的新增、更新、刪除三種情況。

　　在EntityFramework的數據操作中，實體經過業務處理之后，都是有狀態跟蹤的，即是 EntityState 枚舉類型：

1     public enum EntityState
2     {
3         Detached = 1,
4         Unchanged = 2,
5         Added = 4,
6         Deleted = 8,
7         Modified = 16,
8     }

　　我們要關心的狀態，主要是Added、Deleted、Modified三個值，分別對應着新增、刪除、更新三種狀態，在EntityFramework執行到 SaveChanges 的時候，各個實體的狀態已經確定。OSharp將在這個時機獲取變更的實體並創建數據日志信息。

 1     /// <summary>
 2     /// 提交當前單元操作的更改
 3     /// </summary>
 4     /// <param name="validateOnSaveEnabled">提交保存時是否驗證實體約束有效性。</param>
 5     /// <returns>操作影響的行數</returns>
 6     internal virtual int SaveChanges(bool validateOnSaveEnabled)
 7     {
 8         bool isReturn = Configuration.ValidateOnSaveEnabled != validateOnSaveEnabled;
 9         try
10         {
11             Configuration.ValidateOnSaveEnabled = validateOnSaveEnabled;
12             //記錄實體操作日志
13 List<DataLog> logs = new List<DataLog>(); 14 if (DataLoggingEnabled) 15 { 16 logs = this.GetEntityDataLogs().ToList(); 17 } 18             int count = base.SaveChanges();
19 if (count > 0 && DataLoggingEnabled) 20 { 21 Logger.Info(logs, true); 22 } 23             TransactionEnabled = false;
24             return count;
25         }
26         catch (DbUpdateException e)
27         {
28             if (e.InnerException != null && e.InnerException.InnerException is SqlException)
29             {
30                 SqlException sqlEx = e.InnerException.InnerException as SqlException;
31                 string msg = DataHelper.GetSqlExceptionMessage(sqlEx.Number);
32                 throw new OSharpException("提交數據更新時發生異常：" + msg, sqlEx);
33             }
34             throw;
35         }
36         finally
37         {
38             if (isReturn)
39             {
40                 Configuration.ValidateOnSaveEnabled = !validateOnSaveEnabled;
41             }
42         }
43     }

　　以上代碼中， DataLoggingEnabled 屬性是當前上下文是否開啟數據日志的總開關，當開啟數據日志記錄功能時，才進行數據日志的創建。

　　創建數據日志的實現如下，主要是從對象管理器中篩選出指定狀態的實體對象，再由實體類型全名獲取相應實體的“實體信息記錄”，確定是否執行數據日志的創建，然后創建數據日志信息：

 1     /// <summary>
 2     /// 獲取數據上下文的變更日志信息
 3     /// </summary>
 4     public static IEnumerable<DataLog> GetEntityDataLogs(this DbContext dbContext)
 5     {
 6         ObjectContext objectContext = ((IObjectContextAdapter)dbContext).ObjectContext;
 7         ObjectStateManager manager = objectContext.ObjectStateManager;
 8 
 9         IEnumerable<DataLog> logs = from entry in manager.GetObjectStateEntries(EntityState.Added).Where(entry => entry.Entity != null)
10             let entityInfo = OSharpContext.Current.EntityInfoHandler.GetEntityInfo(entry.Entity.GetType()) 11             where entityInfo != null && entityInfo.DataLogEnabled
12             select GetAddedLog(entry, entityInfo);
13 
14         logs = logs.Concat(from entry in manager.GetObjectStateEntries(EntityState.Modified).Where(entry => entry.Entity != null)
15             let entityInfo = OSharpContext.Current.EntityInfoHandler.GetEntityInfo(entry.Entity.GetType())
16             where entityInfo != null && entityInfo.DataLogEnabled
17             select GetModifiedLog(entry, entityInfo));
18 
19         logs = logs.Concat(from entry in manager.GetObjectStateEntries(EntityState.Deleted).Where(entry => entry.Entity != null)
20             let entityInfo = OSharpContext.Current.EntityInfoHandler.GetEntityInfo(entry.Entity.GetType())
21             where entityInfo != null && entityInfo.DataLogEnabled
22             select GetDeletedLog(entry, entityInfo));
23 
24         return logs;
25     }

　　創建“新增”實體的數據日志：

 1     /// <summary>
 2     /// 獲取添加數據的日志信息
 3     /// </summary>
 4     /// <param name="entry">實體狀態跟蹤信息</param>
 5     /// <param name="entityInfo">實體數據信息</param>
 6     /// <returns>新增數據日志信息</returns>
 7     private static DataLog GetAddedLog(ObjectStateEntry entry, IEntityInfo entityInfo)
 8     {
 9         DataLog log = new DataLog(entityInfo.ClassName, entityInfo.Name, OperatingType.Insert);
10         for (int i = 0; i < entry.CurrentValues.FieldCount; i++)
11         {
12             string name = entry.CurrentValues.GetName(i);
13             if (name == "Timestamp")
14             {
15                 continue;
16             }
17             object value = entry.CurrentValues.GetValue(i);
18             if (name == "Id")
19             {
20                 log.EntityKey = value.ToString();
21             }
22             Type fieldType = entry.CurrentValues.GetFieldType(i);
23             DataLogItem logItem = new DataLogItem()
24             {
25                 Field = name,
26                 FieldName = entityInfo.PropertyNames[name],
27                 NewValue = value == null ? null : value.ToString(),
28                 DataType = fieldType == null ? null : fieldType.Name
29             };
30             log.LogItems.Add(logItem);
31         }
32         return log;
33     }

　　創建“更新”實體的數據日志：

 1     /// <summary>
 2     /// 獲取修改數據的日志信息
 3     /// </summary>
 4     /// <param name="entry">實體狀態跟蹤信息</param>
 5     /// <param name="entityInfo">實體數據信息</param>
 6     /// <returns>修改數據日志信息</returns>
 7     private static DataLog GetModifiedLog(ObjectStateEntry entry, IEntityInfo entityInfo)
 8     {
 9         DataLog log = new DataLog(entityInfo.ClassName, entityInfo.Name, OperatingType.Update);
10         for (int i = 0; i < entry.CurrentValues.FieldCount; i++)
11         {
12             string name = entry.CurrentValues.GetName(i);
13             if (name == "Timestamp")
14             {
15                 continue;
16             }
17             object currentValue = entry.CurrentValues.GetValue(i);
18             object originalValue = entry.OriginalValues[name];
19             if (name == "Id")
20             {
21                 log.EntityKey = originalValue.ToString();
22             }
23             if (currentValue.Equals(originalValue))
24             {
25                 continue;
26             }
27             Type fieldType = entry.CurrentValues.GetFieldType(i);
28             DataLogItem logItem = new DataLogItem()
29             {
30                 Field = name,
31                 FieldName = entityInfo.PropertyNames[name],
32                 NewValue = currentValue == null ? null : currentValue.ToString(),
33                 OriginalValue = originalValue == null ? null : originalValue.ToString(),
34                 DataType = fieldType == null ? null : fieldType.Name
35             };
36             log.LogItems.Add(logItem);
37         }
38         return log;
39     }

　　創建“刪除”實體的數據日志：

 1     /// <summary>
 2     /// 獲取刪除數據的日志信息
 3     /// </summary>
 4     /// <param name="entry">實體狀態跟蹤信息</param>
 5     /// <param name="entityInfo">實體數據信息</param>
 6     /// <returns>刪除數據日志信息</returns>
 7     private static DataLog GetDeletedLog(ObjectStateEntry entry, IEntityInfo entityInfo)
 8     {
 9         DataLog log = new DataLog(entityInfo.ClassName, entityInfo.Name, OperatingType.Delete);
10         for (int i = 0; i < entry.OriginalValues.FieldCount; i++)
11         {
12             string name = entry.OriginalValues.GetName(i);
13             if (name == "Timestamp")
14             {
15                 continue;
16             }
17             object originalValue = entry.OriginalValues[i];
18             if (name == "Id")
19             {
20                 log.EntityKey = originalValue.ToString();
21             }
22             Type fieldType = entry.OriginalValues.GetFieldType(i);
23             DataLogItem logItem = new DataLogItem()
24             {
25                 Field = name,
26                 FieldName = entityInfo.PropertyNames[name],
27                 OriginalValue = originalValue == null ? null : originalValue.ToString(),
28                 DataType = fieldType == null ? null : fieldType.Name
29             };
30             log.LogItems.Add(logItem);
31         }
32         return log;
33     }

數據日志的傳遞

　　前面我們已經完成了數據日志創建，但數據日志是由數據層的EntityFramework的SaveChanges方法創建的，而創建的數據日志，最終將傳遞到上層定義的 OperateLogFilterAttribute 中進行使用，這就需要我們通過一定的機制將數據日志往上傳遞。在這里，使用的是日志組件。

　　OSharp中定義了一個數據日志緩存，專門用於接收數據層創建的數據日志信息：

 1     /// <summary>
 2     /// 數據日志緩存接口
 3     /// </summary>
 4     public interface IDataLogCache : IDependency
 5     {
 6         /// <summary>
 7         /// 獲取 數據日志集合
 8         /// </summary>
 9         IEnumerable<DataLog> DataLogs { get; }
10 
11         /// <summary>
12         /// 向緩存中添加數據日志信息
13         /// </summary>
14         /// <param name="dataLog">數據日志信息</param>
15         void AddDataLog(DataLog dataLog);
16     }

　　在專用於數據日志記錄的 DatabaseLog 的 Write 方法重寫時，判斷數據是否是 DataLog 類型，並存入 IDataLogCache 中，這里使用MVC的依賴注入功能獲取IDataLogCache的實現，以保證其在同一Http請求中，獲取的是同一實例：

 1     /// <summary>
 2     /// 獲取日志輸出處理委托實例
 3     /// </summary>
 4     /// <param name="level">日志輸出級別</param>
 5     /// <param name="message">日志消息</param>
 6     /// <param name="exception">日志異常</param>
 7     /// <param name="isData">是否數據日志</param>
 8     protected override void Write(LogLevel level, object message, Exception exception, bool isData = false)
 9     {
10         if (!isData)
11         {
12             return;
13         }
14         IEnumerable<DataLog> dataLogs = message as IEnumerable<DataLog>;
15         if (dataLogs == null)
16         {
17             return;
18         }
19         IDataLogCache logCache = DependencyResolver.Current.GetService<IDataLogCache>();
20         foreach (DataLog dataLog in dataLogs)
21         {
22             logCache.AddDataLog(dataLog);
23         }
24     }

操作日志的記錄

　　定義了一個 OperateLogFilterAttribute 的ActionFilter，專門用於攔截並記錄操作日志。

 1     /// <summary>
 2     /// 操作日志記錄過濾器
 3     /// </summary>
 4     public class OperateLogFilterAttribute : ActionFilterAttribute
 5     {
 6         /// <summary>
 7         /// 獲取或設置 數據日志緩存
 8         /// </summary>
 9         public IDataLogCache DataLogCache { get; set; }
10 
11         /// <summary>
12         /// 獲取或設置 操作日志輸出者
13         /// </summary>
14         public IOperateLogWriter OperateLogWriter { get; set; }
15 
16         /// <summary>
17         /// Called after the action method executes.
18         /// </summary>
19         /// <param name="filterContext">The filter context.</param>
20         public override void OnActionExecuted(ActionExecutedContext filterContext)
21         {
22             string area = filterContext.GetAreaName();
23             string controller = filterContext.GetControllerName();
24             string action = filterContext.GetActionName();
25 
26             IFunction function = OSharpContext.Current.FunctionHandler.GetFunction(area, controller, action);
27             if (function == null || !function.OperateLogEnabled)
28             {
29                 return;
30             }
31             Operator @operator = new Operator()
32             {
33                 Ip = filterContext.HttpContext.Request.GetIpAddress(),
34             };
35             if (filterContext.HttpContext.Request.IsAuthenticated)
36             {
37                 ClaimsIdentity identity = filterContext.HttpContext.User.Identity as ClaimsIdentity;
38                 if (identity != null)
39                 {
40                     @operator.UserId = identity.GetClaimValue(ClaimTypes.NameIdentifier);
41                     @operator.Name = identity.GetClaimValue(ClaimTypes.Name);
42                     @operator.NickName = identity.GetClaimValue(ClaimTypes.GivenName);
43                 }
44             }
45 
46             OperateLog operateLog = new OperateLog()
47             {
48                 FunctionName = function.Name,
49                 Operator = @operator
50             };
51             if (function.DataLogEnabled)
52             {
53                 foreach (DataLog dataLog in DataLogCache.DataLogs)
54                 {
55                     operateLog.DataLogs.Add(dataLog);
56                 } 
57             }
58             OperateLogWriter.Write(operateLog);
59         }
60     }

　　最后，操作日志將由 IOperateLogWriter 進行輸出，定義如下：

 1     /// <summary>
 2     /// 操作日志輸出接口
 3     /// </summary>
 4     public interface IOperateLogWriter : IDependency
 5     {
 6         /// <summary>
 7         /// 輸出操作日志
 8         /// </summary>
 9         /// <param name="operateLog">操作日志信息</param>
10         void Write(OperateLog operateLog);
11     }

　　默認的，操作日志將被記錄到數據庫中：

 1     /// <summary>
 2     /// 操作日志數據庫輸出實現
 3     /// </summary>
 4     public class DatabaseOperateLogWriter : IOperateLogWriter
 5     {
 6         private readonly IRepository<OperateLog, int> _operateLogRepository;
 7 
 8         /// <summary>
 9         /// 初始化一個<see cref="DatabaseOperateLogWriter"/>類型的新實例
10         /// </summary>
11         public DatabaseOperateLogWriter(IRepository<OperateLog, int> operateLogRepository)
12         {
13             _operateLogRepository = operateLogRepository;
14         }
15 
16         /// <summary>
17         /// 輸出操作日志
18         /// </summary>
19         /// <param name="operateLog">操作日志信息</param>
20         public void Write(OperateLog operateLog)
21         {
22             operateLog.CheckNotNull("operateLog" );
23             _operateLogRepository.Insert(operateLog);
24         }
25     }