Entity Framework 与 面向对象

        public MyFirstEntity Create()
        {
            //创建新的DbContext
            var entities = new EntityFrameworkDemoContainer();
            //创建新的实体
            var newMyFirstEntity = new MyFirstEntity();
            //将新对象插入到序列中
            entities.MyFirstEntities.Add(newMyFirstEntity);
            //执行数据操作
            entities.SaveChanges();
            //返回最新创建的实体
            return newMyFirstEntity;
        }

        public MyFirstEntity Retrieve(int id)
        {
            //创建新的DbContext
            var entities = new EntityFrameworkDemoContainer();
            //查找到实体
            var myFirstEntity = entities.MyFirstEntities.First(entity => entity.Id == id);
            //返回查找到的实体
            return myFirstEntity;
        }

        public void Update(int id)
        {
            //创建新的DbContext
            var entities = new EntityFrameworkDemoContainer();
            //查找到实体
            var myFirstEntity = entities.MyFirstEntities.First(entity => entity.Id == id);
            //修改实体
            /*此处略去修改实体代码*/
            //保存修改
            entities.SaveChanges();
        }

        public void Delete(int id)
        {
            //创建新的DbContext
            var entities = new EntityFrameworkDemoContainer();
            //查找到实体
            var myFirstEntity = entities.MyFirstEntities.First(entity => entity.Id == id);
            //删除实体
            entities.MyFirstEntities.Remove(myFirstEntity);
            //保存修改
            entities.SaveChanges();
        }

 1     /// <summary>
 2     /// 依赖于Entity Framework做数据存储的方法的类的接口
 3     /// 包含同步Entity Framework DbContext的方法，已实事务处理
 4     /// </summary>
 5     public interface IEfDbContextDependency
 6     {
 7         /// <summary>
 8         /// 设置当前对象的Entity Framework DbContext
 9         /// </summary>
10         /// <param name="dbContext">传入的dbContext</param>
11         void SetDbContext(Finance2Container dbContext);
12 
13         /// <summary>
14         /// 设置当前对象的Entity Framework DbContext
15         /// </summary>
16         /// <param name="dbContext">传入的DbContext</param>
17         /// <param name="lastContext">当前对象原来使用的DbContext</param>
18         void SetDbContext(Finance2Container dbContext, out Finance2Container lastContext);
19 
20         /// <summary>
21         /// 临时注入DbContext，并执行Callback
22         /// 在执行过程中会用lock锁住本对象
23         /// 在执行完成后会被还原
24         /// </summary>
25         /// <param name="dbContext">需要注入的DbContext</param>
26         /// <param name="callback">回调</param>
27         void InjectDbContextTemporarily(Finance2Container dbContext, Action callback);
28 
29         /// <summary>
30         /// 临时注入DbContext，并执行Callback
31         /// 在执行过程中会用lock锁住本对象
32         /// 在执行完成后会被还原
33         /// </summary>
34         /// <typeparam name="TOut">回调后返回的类型</typeparam>
35         /// <param name="dbContext">需要注入的DbContext</param>
36         /// <param name="callback">回调</param>
37         /// <returns>回调后返回值</returns>
38         TOut InjectDbContextTemporarily<TOut>(Finance2Container dbContext, Func<TOut> callback);
39     }

  1     /// <summary>
  2     /// 依赖于Entity Framework做数据存储的方法的类的基类
  3     /// 包含同步Entity Framework DbContext的方法，已实事务处理
  4     /// </summary>
  5     public abstract class EfDbContextDependencyBase : IEfDbContextDependency
  6     {
  7         #region dependencies
  8 
  9         /// <summary>
 10         /// DbContext对象，以Repoisitory模式设计，所以使用仓库名entities
 11         /// 任何对entities的赋值操作都会对iEfOperatorsToSync进行同步
 12         /// </summary>
 13         /// <value>The entities.</value>
 14         protected Finance2Container entities
 15         {
 16             get
 17             {
 18                 return this._entities;
 19             }
 20             set
 21             {
 22                 this._entities = value;
 23 
 24                 //同步DbContext
 25                 this.syncIEfDbContextDependencies();
 26             }
 27         } Finance2Container _entities;
 28 
 29         #endregion
 30 
 31 
 32         #region constructors
 33 
 34         /// <summary>
 35         /// 初始化<see cref="EfDbContextDependencyBase" />类
 36         /// </summary>
 37         /// <param name="_entities">必须传入一个DbContext对象</param>
 38         /// <param name="efDbContextDependencies">需要自动同步DbContext的业务对象</param>
 39         public EfDbContextDependencyBase(Finance2Container _entities, params IEfDbContextDependency[] efDbContextDependencies)
 40         {
 41             this.entities = _entities;
 42 
 43             //设置业务对象DbContext自动同步
 44             this.SetSyncIEfDbContextDependencies(efDbContextDependencies);
 45         }
 46 
 47         #endregion
 48 
 49 
 50         #region private methods
 51 
 52         /// <summary>
 53         /// 需要同步DbContext的IEfDbContextDependency序列
 54         /// </summary>
 55         private IEfDbContextDependency[] iEfOperatorsToSync;
 56 
 57         /// <summary>
 58         /// 同步IEfOpertors中的DbContext
 59         /// </summary>
 60         private void syncIEfDbContextDependencies()
 61         {
 62             if (iEfOperatorsToSync != null)
 63             {
 64                 foreach (var @operator in iEfOperatorsToSync)
 65                 {
 66                     @operator.SetDbContext(this.entities);
 67                 }
 68             }
 69         }
 70 
 71         /// <summary>
 72         /// 设置需要同步DbContext的IEfDbContextDependency对象，设置之后被设置的对象会在本对象被调用时
 73         /// 设置之后，当本对象的entities被作任何set操作都会导致operators内容的同步
 74         /// </summary>
 75         /// <param name="operators">The operators.</param>
 76         protected void SetSyncIEfDbContextDependencies(params IEfDbContextDependency[] operators)
 77         {
 78             this.iEfOperatorsToSync = operators;
 79 
 80             //通过重新复制entities进行同步
 81             this.entities = this.entities;
 82         }
 83 
 84         /// <summary>
 85         /// 临时注入DbContext，并执行Callback
 86         /// 在执行过程中会用lock锁住所有注入对象
 87         /// 在执行完成后会被还原
 88         /// </summary>
 89         /// <param name="dbContext">需要注入的DbContext</param>
 90         /// <param name="callback">回调</param>
 91         /// <param name="efDbContextDependencies">需要被注入的对象列表</param>
 92         protected void InjectAllDbContextsTemporarily(Finance2Container dbContext, Action callback, params IEfDbContextDependency[] efDbContextDependencies)
 93         {
 94             if (efDbContextDependencies == null || efDbContextDependencies.Count() == 0)
 95             {
 96                 callback();
 97                 return;
 98             }
 99             //递归注入
100             efDbContextDependencies
101                 .First()
102                 .InjectDbContextTemporarily(dbContext,
103                 () =>
104                 {
105                     this
106                         .InjectAllDbContextsTemporarily(dbContext, callback, efDbContextDependencies.Skip(1).ToArray());
107                 });
108         }
109 
110         /// <summary>
111         /// 临时注入本对象的DbContext，并执行Callback
112         /// 在执行过程中会用lock锁住所有注入对象
113         /// 在执行完成后会被还原
114         /// </summary>
115         /// <param name="callback">回调</param>
116         /// <param name="efDbContextDependencies">需要被注入的对象列表</param>
117         protected void InjectAllDbContextsTemporarily(Action callback, params IEfDbContextDependency[] efDbContextDependencies)
118         {
119             this
120                 .InjectAllDbContextsTemporarily(this.entities, callback, efDbContextDependencies);
121         }
122 
123         /// <summary>
124         /// 临时注入DbContext，并执行Callback
125         /// 在执行过程中会用lock锁住所有注入对象
126         /// 在执行完成后会被还原
127         /// </summary>
128         /// <typeparam name="TOut">回调后返回的类型</typeparam>
129         /// <param name="dbContext">需要注入的DbContext</param>
130         /// <param name="callback">回调</param>
131         /// <param name="efDbContextDependencies">需要被注入的对象列表</param>
132         /// <returns>回调后返回值</returns>
133         protected TOut InjectAllDbContextsTemporarily<TOut>(Finance2Container dbContext, Func<TOut> callback, params IEfDbContextDependency[] efDbContextDependencies)
134         {
135             if (efDbContextDependencies == null || efDbContextDependencies.Length == 0)
136             {
137                 return callback();
138             }
139             //递归注入
140             return efDbContextDependencies[0]
141                 .InjectDbContextTemporarily(dbContext,
142                 () =>
143                 {
144                     return this
145                         .InjectAllDbContextsTemporarily(dbContext, callback, efDbContextDependencies.Skip(1).ToArray());
146                 });
147         }
148 
149         /// <summary>
150         /// 临时注入本对象的DbContext，并执行Callback
151         /// 在执行过程中会用lock锁住所有注入对象
152         /// 在执行完成后会被还原
153         /// </summary>
154         /// <typeparam name="TOut">回调后返回的类型</typeparam>
155         /// <param name="callback">回调</param>
156         /// <param name="efDbContextDependencies">需要被注入的对象列表</param>
157         /// <returns>回调后返回值</returns>
158         protected TOut InjectAllDbContextsTemporarily<TOut>(Func<TOut> callback, params IEfDbContextDependency[] efDbContextDependencies)
159         {
160             return this
161                 .InjectAllDbContextsTemporarily(this.entities, callback, efDbContextDependencies);
162         }
163 
164         #endregion
165 
166 
167         #region IEfDbContextDependency members
168 
169         /// <summary>
170         /// 设置当前对象的Entity Framework DbContext
171         /// </summary>
172         /// <param name="dbContext">传入的dbContext</param>
173         public virtual void SetDbContext(Finance2Container dbContext)
174         {
175             this.entities = dbContext;
176         }
177 
178         /// <summary>
179         /// 设置当前对象的Entity Framework DbContext
180         /// </summary>
181         /// <param name="dbContext">传入的DbContext</param>
182         /// <param name="lastContext">当前对象原来使用的DbContext</param>
183         public virtual void SetDbContext(Finance2Container dbContext, out Finance2Container lastContext)
184         {
185             lastContext = this.entities;
186 
187             this.SetDbContext(dbContext);
188         }
189 
190         /// <summary>
191         /// 临时注入DbContext，并执行Callback
192         /// 在执行过程中会用lock锁住本对象
193         /// 在执行完成后会被还原
194         /// </summary>
195         /// <param name="dbContext">需要注入的DbContext</param>
196         /// <param name="callback">回调</param>
197         public virtual void InjectDbContextTemporarily(Finance2Container dbContext, Action callback)
198         {
199             //在强行替换DbContext时需要锁住对象以免出现数据乱流问题
200             lock (this)
201             {
202                 //替换并暂存原有DbContext
203                 Finance2Container lastFinanceDbContext;
204                 this.SetDbContext(dbContext, out lastFinanceDbContext);
205 
206                 //回调
207                 callback();
208 
209                 //还原原有DbContext
210                 this.SetDbContext(lastFinanceDbContext);
211             }
212         }
213 
214         /// <summary>
215         /// 临时注入DbContext，并执行Callback
216         /// 在执行过程中会用lock锁住本对象
217         /// 在执行完成后会被还原
218         /// </summary>
219         /// <typeparam name="TOut">回调后返回的类型</typeparam>
220         /// <param name="dbContext">需要注入的DbContext</param>
221         /// <param name="callback">回调</param>
222         /// <returns>回调后返回值</returns>
223         public virtual TOut InjectDbContextTemporarily<TOut>(Finance2Container dbContext, Func<TOut> callback)
224         {
225             //在强行替换DbContext时需要锁住对象以免出现数据乱流问题
226             lock (this)
227             {
228                 //替换并暂存原有DbContext
229                 Finance2Container lastFinanceDbContext;
230                 this.SetDbContext(dbContext, out lastFinanceDbContext);
231 
232                 //获取执行结果
233                 var result = callback();
234 
235                 //还原原有DbContext
236                 this.SetDbContext(lastFinanceDbContext);
237 
238                 //返回执行结果
239                 return result;
240             }
241         }
242 
243         #endregion
244     }

/// <summary>
/// 用ID获取Entity的接口
/// </summary>
/// <typeparam name="TEntity">Entity的类型</typeparam>
public interface IId<TEntity>
{
    /// <summary>
    /// 获取拥有ID的Entity
    /// </summary>
    /// <param name="id">ID</param>
    /// <returns>Entity</returns>
    TEntity this[int id] { get; }
}

/// <summary>
/// 所有Entity的接口
/// </summary>
/// <typeparam name="TEntity">Entity的类型</typeparam>
public interface IAll<TEntity>
{
    /// <summary>
    /// 获取所有Entity
    /// </summary>
    /// <value>所有Entity</value>
    IEnumerable<TEntity> All { get; }
}

/// <summary>
/// 创建实体的接口
/// </summary>
/// <typeparam name="TEntity">Entity的类型</typeparam>
public interface ICreate<TEntity>
{
    /// <summary>
    /// 创建新Entity
    /// </summary>
    /// <returns>新Entity</returns>
    TEntity Create();
}

/// <summary>
/// 添加Entity的接口
/// </summary>
/// <typeparam name="TEntity">Entity的类型</typeparam>
public interface IAdd<TEntity>
{
    /// <summary>
    /// 添加一个新项
    /// </summary>
    /// <param name="newItem">需要添加的新项</param>
    /// <returns>添加后的项</returns>
    TEntity Add(TEntity newItem);
}

/// <summary>
/// 移除Entity的接口
/// </summary>
/// <typeparam name="TEntity">Entity的类型</typeparam>
public interface IRemove<TEntity>
{
    /// <summary>
    /// 移除Entity的接口
    /// </summary>
    /// <param name="id">Entity的ID</param>
    void Remove(int id);
}

public interface IApplicationManager
    : IEfDbContextDependency
    , IId<Application>
{
    void Edit(int applicationId, string content);   
}

 1 /// <summary>
 2 /// 添加新汇率
 3 /// </summary>
 4 /// <param name="exchangeRateRuleId">汇率规则ID</param>
 5 /// <param name="time">添加到的时间点</param>
 6 /// <param name="rate">比率</param>
 7 /// <param name="inverseRate">反向比率</param>
 8 /// <returns>新添加的汇率</returns>
 9 /// <exception cref="GM.OA.Finance2.Domain.FinancialBase.ExchangeRate.RateIsZeroException">比率或反向比率为0时抛出此异常</exception>
10 /// <exception cref="GM.OA.Finance2.Domain.FinancialBase.ExchangeRate.ExchangeRateAlreadyExistException">当天的汇率已设置时抛出此异常</exception>
11 public DataAccess.ExchangeRate Add(int exchangeRateRuleId, DateTime time, decimal rate, decimal inverseRate)
12 {
13     //比率不得为0
14     if (rate == 0 || inverseRate == 0)
15     {
16         throw new RateIsZeroException();
17     }
18 
19     //如果同时间点汇率已存在，则抛出异常
20     var existExchangeRate = entities
21         .ExchangeRates
22         .FirstOrDefault(item =>
23             item.ExchangeRateRule.Id == exchangeRateRuleId
24             && item.Time == time);
25     if (existExchangeRate != null)
26     {
27         throw new ExchangeRateAlreadyExistException(existExchangeRate);
28     }
29 
30     //获取汇率规则
31     var exchangeRateRule = this.ExchangeRateRuleManager[exchangeRateRuleId];
32 
33     //创建一对正反的兑换汇率
34     //正兑换汇率
35     var exchangeRate = new DataAccess.ExchangeRate
36     {
37         Time = time,
38         ExchangeRateRule = exchangeRateRule//关联汇率规则
39     };
40     //反兑换汇率
41     var inverseExchangeRate = new DataAccess.ExchangeRate
42     {
43         Time = time,
44         ExchangeRateRule = exchangeRateRule.InverseExchangeRateRule//关联反向的汇率规则
45     };
46     exchangeRate.InverseExchangeRate = inverseExchangeRate;//互相设置为反向汇率
47     //设置汇率
48     exchangeRate.SetRate(rate, inverseRate);
49 
50     //由于汇率互为反向汇率，导致数据对象环状，所以需要规范顺序进行事务插入
51     using (var scope = new TransactionScope())
52     {
53         //持久化数据
54         this.entities.ExchangeRates.Add(exchangeRate);
55         this.entities.SaveChanges();
56 
57         //设置反向汇率
58         inverseExchangeRate.InverseExchangeRate = exchangeRate;
59         this.entities.SaveChanges();
60 
61         scope.Complete();
62     }
63 
64     //返回插入后的新对象
65     return exchangeRate;
66 }

  1 /// <summary>
  2 /// 从指定账户转入指定金额到另一个指定账户
  3 /// 兑换四舍五入保留两位小数
  4 /// </summary>
  5 /// <param name="withdrawalAccountId">转出账户ID</param>
  6 /// <param name="depositAccountId">转入账户ID</param>
  7 /// <param name="transferAmount">转账金额</param>
  8 /// <param name="withdrawalCurrencyCode">币别英文单位，为空则使用默认币别，一般认为是人民币</param>
  9 /// <param name="exchangeRateId">汇率ID，如果不为空则使用该汇率进行转账</param>
 10 /// <param name="remarks">备注</param>
 11 /// <returns>转账日志</returns>
 12 public TBalanceTransferRecord TransferTo(int withdrawalAccountId, int depositAccountId,
 13     decimal transferAmount,
 14     string depositCurrencyCode = null,
 15     int? exchangeRateId = null,
 16     string remarks = null)
 17 {
 18     //如果币别为空则设置默认币别
 19     if (depositCurrencyCode == null)
 20     {
 21         depositCurrencyCode = Configurations.DefaultCurrencyCode;
 22     }
 23 
 24     //处理汇率和转入转出具体值
 25     DataAccess.ExchangeRate exchangeRate;
 26     decimal withdrawalAmount;
 27     decimal depositAmount = transferAmount;
 28 
 29     //根据不同的汇率情况计算转入转出金额
 30     if (exchangeRateId == null)//没有汇率的情况
 31     {
 32         exchangeRate = null;
 33         //没有汇率的情况下转入和转出对等
 34         withdrawalAmount = depositAmount;
 35     }
 36     else
 37     {
 38         //获取汇率
 39         exchangeRate = exchangeRateManager[exchangeRateId.Value];
 40 
 41         //如果汇率为空，则抛出异常
 42         if (exchangeRate == null)
 43         {
 44             throw new ExchangeRateNullException(exchangeRateId.Value);
 45         }
 46 
 47         //如果汇率的外币不是转入币别，则使用反向汇率
 48         if (exchangeRate.ExchangeRateRule.ForeignCurrency.Code != depositCurrencyCode)
 49         {
 50             exchangeRate = exchangeRate.InverseExchangeRate;
 51         }
 52 
 53         //如果汇率外币依旧不是转入币别，则无法使用该汇率，抛出异常
 54         if (exchangeRate.ExchangeRateRule.ForeignCurrency.Code != depositCurrencyCode)
 55         {
 56             throw new ExchangeRateNotMatchException(currencyManager[depositCurrencyCode], exchangeRate);
 57         }
 58 
 59         //转出金额通过汇率换算，四舍五入保留两位小数
 60         withdrawalAmount = Math.Round(depositAmount * exchangeRate.InverseExchangeRate.Rate, 2, MidpointRounding.AwayFromZero);
 61     }
 62 
 63     //需要使用以下汇率业务，注入DbContext
 64     var record = exchangeRateManager
 65         .InjectDbContextTemporarily(this.entities, () =>
 66         {
 67             //将转入转出集中在一个事务中
 68             using (var scope = new TransactionScope())
 69             {
 70                 var withdrawalRecord = this
 71                     .AdjustBalance(withdrawalAccountId,
 72                     -withdrawalAmount,//!Attension!: 注意这里为负数，因为为转出
 73                     exchangeRate == null
 74                     ? depositCurrencyCode
 75                     : exchangeRate.ExchangeRateRule.DomesticCurrency.Code);
 76                 var depositRecord = this
 77                     .AdjustBalance(depositAccountId,
 78                     depositAmount,
 79                     depositCurrencyCode);
 80 
 81                 //创建新日志
 82                 var newTransferRecord = createNewTransferRecord(withdrawalRecord, depositRecord, transferAmount, exchangeRate);
 83 
 84                 //如果类型不匹配，则抛出异常
 85                 if (newTransferRecord.GetType() != typeof(TBalanceTransferRecord))
 86                 {
 87                     throw new BalanceTransferRecordTypeNotMatchException<TBalanceTransferRecord>();
 88                 }
 89 
 90                 //设置日志内容
 91                 var transferRecord = (TBalanceTransferRecord)newTransferRecord;
 92                 transferRecord.WithdrawalBalanceChangeRecord = withdrawalRecord;
 93                 transferRecord.DepositBalanceChangeRecord = depositRecord;
 94                 transferRecord.ExchangeRate = exchangeRate;
 95                 transferRecord.Remarks = remarks;
 96 
 97                 //持久化日志
 98                 this.entities.BalanceTransferRecords.Add(transferRecord);
 99                 this.entities.SaveChanges();
100 
101                 //结束事务
102                 scope.Complete();
103 
104                 return transferRecord;
105             }
106         });
107 
108     return record;
109 }