.

Masuit.Tools.Core/Mapping/Core/MapperConfigurationBase.cs

@@ -414,6 +414,7 @@ namespace Masuit.Tools.Mapping.Core
                                     Expression toListExp = Expression.Call(_toListMethod.MakeGenericMethod(sourceType), assignExpression);
                                     Expression setIf = Expression.IfThen(checkIfNull, Expression.Assign(propToAssign, assignExpression));
                                     finalAssign.Add(setIf);
+                                    finalAssign.Add(toListExp);
                                 }
                             }
                         }
@@ -437,7 +438,7 @@ namespace Masuit.Tools.Mapping.Core
                             }
                             else
                             {
-                                Expression selectExp = Expression.Call(_selectMethod.MakeGenericMethod(sourceType), Expression.Constant(mapper.GetDelegate()));
+                                //Expression selectExp = Expression.Call(_selectMethod.MakeGenericMethod(sourceType), Expression.Constant(mapper.GetDelegate()));
                                 Expression checkIfNull = Expression.NotEqual(propToAssign, defaultExpression);
                                 Expression setIf = Expression.IfThen(checkIfNull, Expression.Assign(propToAssign, assignExpression));
                                 assignExpression = setIf;
@@ -596,7 +597,7 @@ namespace Masuit.Tools.Mapping.Core
                 Expression mapExpression = externalMapper.GetMemberInitExpression();
                 Expression defaultExpression = Expression.Constant(MapperHelper.GetDefaultValue(configExpression.Item1.Type), configExpression.Item1.Type);
                 // 修改成员
-                Expression expSource = visitorMapper.Visit(configExpression.Item1, false);
+                Expression expSource = visitorMapper.Visit(configExpression.Item1);
                 ChangParameterExpressionVisitor changeParamaterVisitor = new ChangParameterExpressionVisitor(expSource);
                 mapExpression = changeParamaterVisitor.Visit(mapExpression);
                 // 现在可以创建正确的参数。
@@ -639,7 +640,7 @@ namespace Masuit.Tools.Mapping.Core
                 // 为了与EF / LINQ2SQL兼容。
                 LambdaExpression expMappeur = externalMapper.GetGenericLambdaExpression();
                 // 创建对Select方法的调用，在Enumerable的Select中插入一个lambda表达式（参数是一个委托），通常情况下，这是不可能的，但（个人认为）编译器就像这样创建并且LINQ2SQL / EF是可以进行sql查询的
-                Expression select = Expression.Call(_selectMethod.MakeGenericMethod(sourceTypeList, destTypeList), new Expression[]
+                Expression select = Expression.Call(_selectMethod.MakeGenericMethod(sourceTypeList, destTypeList), new[]
                 {
                     expSource,
                     expMappeur

Masuit.Tools.Core/Mapping/Core/TypePairMapper.cs

@@ -11,8 +11,8 @@ namespace Masuit.Tools.Mapping.Core
             Name = name;
         }
 
-        public Type Source { get; private set; }
-        public Type Target { get; private set; }
+        public Type Source { get; }
+        public Type Target { get; }
 
         public string Name { get; private set; }
 
@@ -21,9 +21,9 @@ namespace Masuit.Tools.Mapping.Core
             return new TypePairMapper(source, target, name);
         }
 
-        public static TypePairMapper Create<TSource, TTarget>(string name = null)
+        public static TypePairMapper Create<TSource, TDest>(string name = null)
         {
-            return new TypePairMapper(typeof(TSource), typeof(TTarget), name);
+            return new TypePairMapper(typeof(TSource), typeof(TDest), name);
         }
 
         public override bool Equals(object obj)

Masuit.Tools.Core/Mapping/ExpressionMapper.cs

@@ -17,13 +17,13 @@ namespace Masuit.Tools.Mapping
         /// 映射指定的源。
         /// </summary>
         /// <typeparam name="TSource">源类型</typeparam>
-        /// <typeparam name="TTarget">目标类型</typeparam>
+        /// <typeparam name="TDest">目标类型</typeparam>
         /// <param name="source">源对象</param>
         /// <param name="name">别名</param>
         /// <returns>
         /// 目标对象的新实例
         /// </returns>
-        public static TTarget Map<TSource, TTarget>(this TSource source, string name = null) where TSource : class where TTarget : class
+        public static TDest Map<TSource, TDest>(this TSource source, string name = null) where TSource : class where TDest : class
         {
             if (source == null)
             {
@@ -34,9 +34,9 @@ namespace Masuit.Tools.Mapping
             {
                 Initialize();
             }
-            TTarget result = null;
-            MapperConfiguration<TSource, TTarget> mapper = GetMapper<TSource, TTarget>(name);
-            Func<TSource, TTarget> query = mapper.GetFuncDelegate();
+            TDest result = null;
+            MapperConfiguration<TSource, TDest> mapper = GetMapper<TSource, TDest>(name);
+            Func<TSource, TDest> query = mapper.GetFuncDelegate();
             if (query != null)
             {
                 result = query(source);
@@ -50,19 +50,19 @@ namespace Masuit.Tools.Mapping
         /// 将指定的源映射到目标。
         /// </summary>
         /// <typeparam name="TSource">源类型</typeparam>
-        /// <typeparam name="TTarget">目标类型</typeparam>
+        /// <typeparam name="TDest">目标类型</typeparam>
         /// <param name="source">源对象</param>
         /// <param name="target">目标对象</param>
         /// <param name="name">别名</param>
-        public static void Map<TSource, TTarget>(this TSource source, TTarget target, string name = null) where TSource : class where TTarget : class
+        public static void Map<TSource, TDest>(this TSource source, TDest target, string name = null) where TSource : class where TDest : class
         {
             if (!_initialized)
             {
                 Initialize();
             }
-            TTarget result = null;
-            MapperConfiguration<TSource, TTarget> mapper = GetMapper<TSource, TTarget>(name);
-            Action<TSource, TTarget> query = mapper.GetDelegateForExistingTarget() as Action<TSource, TTarget>;
+            TDest result = null;
+            MapperConfiguration<TSource, TDest> mapper = GetMapper<TSource, TDest>(name);
+            Action<TSource, TDest> query = mapper.GetDelegateForExistingTarget() as Action<TSource, TDest>;
             if (query != null)
             {
                 query(source, target);
@@ -75,29 +75,29 @@ namespace Masuit.Tools.Mapping
         /// 获取查询表达式树
         /// </summary>
         /// <typeparam name="TSource">源类型</typeparam>
-        /// <typeparam name="TTarget">目标类型</typeparam>
+        /// <typeparam name="TDest">目标类型</typeparam>
         /// <returns></returns>
-        public static Expression<Func<TSource, TTarget>> GetQueryExpression<TSource, TTarget>() where TSource : class where TTarget : class
+        public static Expression<Func<TSource, TDest>> GetQueryExpression<TSource, TDest>() where TSource : class where TDest : class
         {
-            return GetMapper<TSource, TTarget>().GetLambdaExpression();
+            return GetMapper<TSource, TDest>().GetLambdaExpression();
         }
 
         /// <summary>
         /// 创建mapper对象
         /// </summary>
         /// <typeparam name="TSource">源类型</typeparam>
-        /// <typeparam name="TTarget">目标类型</typeparam>
+        /// <typeparam name="TDest">目标类型</typeparam>
         /// <returns></returns>
-        public static MapperConfiguration<TSource, TTarget> CreateMap<TSource, TTarget>(string name = null) where TSource : class where TTarget : class
+        public static MapperConfiguration<TSource, TDest> CreateMap<TSource, TDest>(string name = null) where TSource : class where TDest : class
         {
-            MapperConfigurationBase map = MapperConfigurationCollectionContainer.Instance.Find(typeof(TSource), typeof(TTarget), name);
+            MapperConfigurationBase map = MapperConfigurationCollectionContainer.Instance.Find(typeof(TSource), typeof(TDest), name);
             if (map == null)
             {
                 string finalName = string.IsNullOrEmpty(name) ? "s" + MapperConfigurationCollectionContainer.Instance.Count.ToString() : name;
-                map = new MapperConfiguration<TSource, TTarget>(finalName);
+                map = new MapperConfiguration<TSource, TDest>(finalName);
                 MapperConfigurationCollectionContainer.Instance.Add(map);
             }
-            return map as MapperConfiguration<TSource, TTarget>;
+            return map as MapperConfiguration<TSource, TDest>;
         }
 
         /// <summary>

Masuit.Tools.Core/Mapping/Extensions/QueryableExtentions.cs

@@ -14,93 +14,93 @@ namespace Masuit.Tools.Mapping.Extensions
         /// 根据键按升序对序列的元素进行排序。
         /// </summary>
         /// <typeparam name="TSource">源类型</typeparam>
-        /// <typeparam name="TTarget">目标类型</typeparam>
+        /// <typeparam name="TDest">目标类型</typeparam>
         /// <param name="query">分类化的序列值</param>
         /// <param name="sortedPropertyDestName">目标属性的名称</param>
         /// <returns></returns>
-        public static IOrderedQueryable<TSource> OrderBy<TSource, TTarget>(this IQueryable<TSource> query, string sortedPropertyDestName) where TSource : class where TTarget : class
+        public static IOrderedQueryable<TSource> OrderBy<TSource, TDest>(this IQueryable<TSource> query, string sortedPropertyDestName) where TSource : class where TDest : class
         {
             // 没有使用MethodBase.GetCurrentMethod().Name，因为效率不高
-            return CreateSortedMethodCall<TSource, TTarget, IOrderedQueryable<TSource>>(query, "OrderBy", sortedPropertyDestName);
+            return CreateSortedMethodCall<TSource, TDest, IOrderedQueryable<TSource>>(query, "OrderBy", sortedPropertyDestName);
         }
 
         /// <summary>
         /// 根据键按降序对序列的元素进行排序。
         /// </summary>
         /// <typeparam name="TSource">源类型</typeparam>
-        /// <typeparam name="TTarget">目标类型</typeparam>
+        /// <typeparam name="TDest">目标类型</typeparam>
         /// <param name="query">分类化的序列值</param>
         /// <param name="sortedPropertyDestName">目标属性的名称</param>
         /// <returns></returns>
-        public static IOrderedQueryable<TSource> OrderByDescending<TSource, TTarget>(this IQueryable<TSource> query, string sortedPropertyDestName) where TSource : class where TTarget : class
+        public static IOrderedQueryable<TSource> OrderByDescending<TSource, TDest>(this IQueryable<TSource> query, string sortedPropertyDestName) where TSource : class where TDest : class
         {
-            return CreateSortedMethodCall<TSource, TTarget, IOrderedQueryable<TSource>>(query, "OrderByDescending", sortedPropertyDestName);
+            return CreateSortedMethodCall<TSource, TDest, IOrderedQueryable<TSource>>(query, "OrderByDescending", sortedPropertyDestName);
         }
 
         /// <summary>
         ///  根据键按升序对序列的元素进行排序。
         /// </summary>
         /// <typeparam name="TSource">源类型</typeparam>
-        /// <typeparam name="TTarget">目标类型</typeparam>
+        /// <typeparam name="TDest">目标类型</typeparam>
         /// <param name="query">分类化的序列值</param>
         /// <param name="sortedPropertyDestName">目标属性的名称</param>
-        public static IOrderedQueryable<TSource> ThenBy<TSource, TTarget>(this IQueryable<TSource> query, string sortedPropertyDestName) where TSource : class where TTarget : class
+        public static IOrderedQueryable<TSource> ThenBy<TSource, TDest>(this IQueryable<TSource> query, string sortedPropertyDestName) where TSource : class where TDest : class
         {
-            return CreateSortedMethodCall<TSource, TTarget, IOrderedQueryable<TSource>>(query, "ThenBy", sortedPropertyDestName);
+            return CreateSortedMethodCall<TSource, TDest, IOrderedQueryable<TSource>>(query, "ThenBy", sortedPropertyDestName);
         }
 
         /// <summary>
         /// 根据键按降序对序列的元素进行排序。
         /// </summary>
         /// <typeparam name="TSource">源类型</typeparam>
-        /// <typeparam name="TTarget">目标类型</typeparam>
+        /// <typeparam name="TDest">目标类型</typeparam>
         /// <param name="query">分类化的序列值</param>
         /// <param name="sortedPropertyDestName">目标属性的名称</param>
-        public static IOrderedQueryable<TSource> ThenByDescending<TSource, TTarget>(this IQueryable<TSource> query, string sortedPropertyDestName) where TSource : class where TTarget : class
+        public static IOrderedQueryable<TSource> ThenByDescending<TSource, TDest>(this IQueryable<TSource> query, string sortedPropertyDestName) where TSource : class where TDest : class
         {
-            return CreateSortedMethodCall<TSource, TTarget, IOrderedQueryable<TSource>>(query, "ThenByDescending", sortedPropertyDestName);
+            return CreateSortedMethodCall<TSource, TDest, IOrderedQueryable<TSource>>(query, "ThenByDescending", sortedPropertyDestName);
         }
 
         /// <summary>
         /// 通过合并目标对象将序列的每个元素投影到新表单中。
         /// </summary>
         /// <typeparam name="TSource">源类型.</typeparam>
-        /// <typeparam name="TTarget">目标类型.</typeparam>
+        /// <typeparam name="TDest">目标类型.</typeparam>
         /// <param name="query">分类化的序列值</param>
-        public static IQueryable<TTarget> Select<TSource, TTarget>(this IQueryable<TSource> query) where TSource : class where TTarget : class
+        public static IQueryable<TDest> Select<TSource, TDest>(this IQueryable<TSource> query) where TSource : class where TDest : class
         {
-            return GetSelect<TSource, TTarget>(query, null);
+            return GetSelect<TSource, TDest>(query, null);
         }
 
         /// <summary>
         /// 通过合并目标对象将序列的每个元素投影到新表单中。
         /// </summary>
         /// <typeparam name="TSource">源类型.</typeparam>
-        /// <typeparam name="TTarget">目标类型.</typeparam>
+        /// <typeparam name="TDest">目标类型.</typeparam>
         /// <param name="query">分类化的序列值</param>
         /// <param name="mapperName">mapper别名</param>
         /// <returns></returns>
-        public static IQueryable<TTarget> Select<TSource, TTarget>(this IQueryable<TSource> query, string mapperName) where TSource : class where TTarget : class
+        public static IQueryable<TDest> Select<TSource, TDest>(this IQueryable<TSource> query, string mapperName) where TSource : class where TDest : class
         {
-            return GetSelect<TSource, TTarget>(query, mapperName);
+            return GetSelect<TSource, TDest>(query, mapperName);
         }
 
         /// <summary>
         /// 根据谓词过滤一系列值。
         /// </summary>
         /// <typeparam name="TSource">源类型</typeparam>
-        /// <typeparam name="TTarget">目标类型</typeparam>
+        /// <typeparam name="TDest">目标类型</typeparam>
         /// <param name="query">分类化的序列值</param>
         /// <param name="predicate">用于根据条件测试每个元素的功能。</param>
         /// <returns></returns>
-        public static IQueryable<TTarget> Where<TSource, TTarget>(this IQueryable<TTarget> query, Expression<Func<TSource, bool>> predicate)
+        public static IQueryable<TDest> Where<TSource, TDest>(this IQueryable<TDest> query, Expression<Func<TSource, bool>> predicate)
         {
-            return Queryable.Where(query, predicate.ConvertTo<TSource, TTarget>());
+            return Queryable.Where(query, predicate.ConvertTo<TSource, TDest>());
         }
 
-        private static TQueryable CreateSortedMethodCall<TSource, TTarget, TQueryable>(IQueryable<TSource> query, string methodName, string sortedPropertySourceName) where TSource : class where TTarget : class where TQueryable : class, IQueryable<TSource>
+        private static TQueryable CreateSortedMethodCall<TSource, TDest, TQueryable>(IQueryable<TSource> query, string methodName, string sortedPropertySourceName) where TSource : class where TDest : class where TQueryable : class, IQueryable<TSource>
         {
-            MapperConfiguration<TSource, TTarget> mapper = ExpressionMapper.GetMapper<TSource, TTarget>();
+            MapperConfiguration<TSource, TDest> mapper = ExpressionMapper.GetMapper<TSource, TDest>();
             var prop = mapper.GetLambdaDest(sortedPropertySourceName);
             var lambda = mapper.GetSortedExpression(sortedPropertySourceName);
             MethodCallExpression resultExp = Expression.Call(typeof(Queryable), methodName, new Type[]
@@ -111,14 +111,14 @@ namespace Masuit.Tools.Mapping.Extensions
             return query.Provider.CreateQuery<TSource>(resultExp) as TQueryable;
         }
 
-        private static IQueryable<TTarget> GetSelect<TSource, TTarget>(IQueryable<TSource> query, string mapperName) where TSource : class where TTarget : class
+        private static IQueryable<TDest> GetSelect<TSource, TDest>(IQueryable<TSource> query, string mapperName) where TSource : class where TDest : class
         {
             // 不需要mapper
-            if (typeof(TSource) == typeof(TTarget))
+            if (typeof(TSource) == typeof(TDest))
             {
-                return (IQueryable<TTarget>)query;
+                return (IQueryable<TDest>)query;
             }
-            return query.Select(ExpressionMapper.GetMapper<TSource, TTarget>(mapperName).GetLambdaExpression());
+            return query.Select(ExpressionMapper.GetMapper<TSource, TDest>(mapperName).GetLambdaExpression());
         }
     }
 }

Masuit.Tools.UnitTest/Mvc/ResumeFileResultTests.cs

@@ -8,507 +8,504 @@ using System.Threading;
 
 namespace Masuit.Tools.UnitTest.Mvc
 {
-    namespace Adstream.Web.Common.test
+    [TestFixture]
+    public class ResumeFileResultTests : BaseTests
     {
-        [TestFixture]
-        public class ResumeFileResultTests : BaseTests
-        {
-            private FileInfo _file;
-            private FileInfo _file2;
+        private FileInfo _file;
+        private FileInfo _file2;
 
-            [SetUp]
-            public void Setup()
-            {
-                _file = new FileInfo(FilePath("download-test-file.txt"));
-                _file2 = new FileInfo(FilePath("download-test-file2.txt"));
-                Request.Headers.Clear();
-                Response.ClearTestResponse();
-            }
+        [SetUp]
+        public void Setup()
+        {
+            _file = new FileInfo(FilePath("download-test-file.txt"));
+            _file2 = new FileInfo(FilePath("download-test-file2.txt"));
+            Request.Headers.Clear();
+            Response.ClearTestResponse();
+        }
 
-            [Test]
-            public void FormatDateTest()
-            {
-                var dateToTest = new DateTime(2010, 5, 25, 7, 44, 57);
-                Assert.AreEqual(dateToTest.ToString("R"), ResumeFileResult.Util.FormatDate(dateToTest));
-            }
+        [Test]
+        public void FormatDateTest()
+        {
+            var dateToTest = new DateTime(2010, 5, 25, 7, 44, 57);
+            Assert.AreEqual(dateToTest.ToString("R"), ResumeFileResult.Util.FormatDate(dateToTest));
+        }
 
-            [Test]
-            public void CanCalculateEtagForFile()
-            {
-                Assert.IsNotNull(ResumeFileResult.Util.Etag(_file));
-            }
+        [Test]
+        public void CanCalculateEtagForFile()
+        {
+            Assert.IsNotNull(ResumeFileResult.Util.Etag(_file));
+        }
 
-            [Test]
-            public void EtagDoesNotDependOnTime()
-            {
-                var etag1 = ResumeFileResult.Util.Etag(_file);
-                Thread.Sleep(100);
-                var etag2 = ResumeFileResult.Util.Etag(_file);
-                Assert.AreEqual(etag1, etag2);
-            }
+        [Test]
+        public void EtagDoesNotDependOnTime()
+        {
+            var etag1 = ResumeFileResult.Util.Etag(_file);
+            Thread.Sleep(100);
+            var etag2 = ResumeFileResult.Util.Etag(_file);
+            Assert.AreEqual(etag1, etag2);
+        }
 
-            [Test]
-            public void EtagDoesDependOnFile()
-            {
-                var etag1 = ResumeFileResult.Util.Etag(_file);
-                Thread.Sleep(100);
-                var etag2 = ResumeFileResult.Util.Etag(_file2);
-                Assert.AreNotEqual(etag1, etag2);
-            }
+        [Test]
+        public void EtagDoesDependOnFile()
+        {
+            var etag1 = ResumeFileResult.Util.Etag(_file);
+            Thread.Sleep(100);
+            var etag2 = ResumeFileResult.Util.Etag(_file2);
+            Assert.AreNotEqual(etag1, etag2);
+        }
 
-            [Test]
-            public void IsNotModified_Is_False_If_IfNoneMatch_And_IfModifiedSince_Are_Empty()
-            {
-                Request.Headers[HttpHeaders.IfNoneMatch] = null;
-                Request.Headers[HttpHeaders.IfModifiedSince] = null;
-                Assert.IsFalse(new MockResumeFileResult(_file.FullName, Request).IsNotModified());
-            }
+        [Test]
+        public void IsNotModified_Is_False_If_IfNoneMatch_And_IfModifiedSince_Are_Empty()
+        {
+            Request.Headers[HttpHeaders.IfNoneMatch] = null;
+            Request.Headers[HttpHeaders.IfModifiedSince] = null;
+            Assert.IsFalse(new MockResumeFileResult(_file.FullName, Request).IsNotModified());
+        }
 
-            [Test]
-            public void IsNotModified_Is_False_If_Etag_Is_Invalid_And_IfModifiedSince_Is_Null()
-            {
-                var etag = "invalid etag";
-                Request.Headers[HttpHeaders.IfNoneMatch] = etag;
-                Request.Headers[HttpHeaders.IfModifiedSince] = null;
-                Assert.IsFalse(new MockResumeFileResult(_file.FullName, Request).IsNotModified());
-            }
+        [Test]
+        public void IsNotModified_Is_False_If_Etag_Is_Invalid_And_IfModifiedSince_Is_Null()
+        {
+            var etag = "invalid etag";
+            Request.Headers[HttpHeaders.IfNoneMatch] = etag;
+            Request.Headers[HttpHeaders.IfModifiedSince] = null;
+            Assert.IsFalse(new MockResumeFileResult(_file.FullName, Request).IsNotModified());
+        }
 
-            [Test]
-            public void IsNotModified_Is_True_If_Etag_Is_Valid()
-            {
-                var etag = ResumeFileResult.Util.Etag(_file);
-                Request.Headers[HttpHeaders.IfNoneMatch] = etag;
-                Assert.IsTrue(new MockResumeFileResult(_file.FullName, Request).IsNotModified());
-            }
+        [Test]
+        public void IsNotModified_Is_True_If_Etag_Is_Valid()
+        {
+            var etag = ResumeFileResult.Util.Etag(_file);
+            Request.Headers[HttpHeaders.IfNoneMatch] = etag;
+            Assert.IsTrue(new MockResumeFileResult(_file.FullName, Request).IsNotModified());
+        }
 
-            [Test]
-            public void IsNotModified_Is_True_If_Etag_Is_Star()
-            {
-                var etag = "*";
-                Request.Headers[HttpHeaders.IfNoneMatch] = etag;
-                Assert.IsTrue(new MockResumeFileResult(_file.FullName, Request).IsNotModified());
-            }
+        [Test]
+        public void IsNotModified_Is_True_If_Etag_Is_Star()
+        {
+            var etag = "*";
+            Request.Headers[HttpHeaders.IfNoneMatch] = etag;
+            Assert.IsTrue(new MockResumeFileResult(_file.FullName, Request).IsNotModified());
+        }
 
-            [Test]
-            public void IsNotModified_Is_False_If_Etag_Is_Empty_And_IfModifiedSince_Is_Invalid()
-            {
-                Request.Headers[HttpHeaders.IfModifiedSince] = ResumeFileResult.Util.FormatDate(DateTime.Now);
-                Assert.IsFalse(new MockResumeFileResult(_file.FullName, Request).IsNotModified());
-            }
+        [Test]
+        public void IsNotModified_Is_False_If_Etag_Is_Empty_And_IfModifiedSince_Is_Invalid()
+        {
+            Request.Headers[HttpHeaders.IfModifiedSince] = ResumeFileResult.Util.FormatDate(DateTime.Now);
+            Assert.IsFalse(new MockResumeFileResult(_file.FullName, Request).IsNotModified());
+        }
 
-            [Test]
-            public void IsNotModified_Is_False_If_Etag_Is_Empty_And_IfModifiedSince_Is_LastFileWriteTime()
-            {
-                Request.Headers[HttpHeaders.IfModifiedSince] = ResumeFileResult.Util.FormatDate(_file.LastWriteTime);
-                Assert.IsTrue(new MockResumeFileResult(_file.FullName, Request).IsNotModified());
-            }
+        [Test]
+        public void IsNotModified_Is_False_If_Etag_Is_Empty_And_IfModifiedSince_Is_LastFileWriteTime()
+        {
+            Request.Headers[HttpHeaders.IfModifiedSince] = ResumeFileResult.Util.FormatDate(_file.LastWriteTime);
+            Assert.IsTrue(new MockResumeFileResult(_file.FullName, Request).IsNotModified());
+        }
 
-            [Test]
-            public void IsPreconditionFailedTest_Is_False_If_ifMatch_And_ifUnmodifiedSince_Are_Empty()
-            {
-                Request.Headers[HttpHeaders.IfMatch] = null;
-                Request.Headers[HttpHeaders.IfUnmodifiedSince] = null;
-                Assert.IsFalse(new MockResumeFileResult(_file.FullName, Request).IsPreconditionFailed());
-            }
+        [Test]
+        public void IsPreconditionFailedTest_Is_False_If_ifMatch_And_ifUnmodifiedSince_Are_Empty()
+        {
+            Request.Headers[HttpHeaders.IfMatch] = null;
+            Request.Headers[HttpHeaders.IfUnmodifiedSince] = null;
+            Assert.IsFalse(new MockResumeFileResult(_file.FullName, Request).IsPreconditionFailed());
+        }
 
-            [Test]
-            public void IsPreconditionFailedTest_Is_IsTrue_If_ifMatch_Doesnot_Match_Etag_Of_The_File()
-            {
-                Request.Headers[HttpHeaders.IfMatch] = "incorrect";
-                Assert.IsTrue(new MockResumeFileResult(_file.FullName, Request).IsPreconditionFailed());
-            }
+        [Test]
+        public void IsPreconditionFailedTest_Is_IsTrue_If_ifMatch_Doesnot_Match_Etag_Of_The_File()
+        {
+            Request.Headers[HttpHeaders.IfMatch] = "incorrect";
+            Assert.IsTrue(new MockResumeFileResult(_file.FullName, Request).IsPreconditionFailed());
+        }
 
-            [Test]
-            public void IsPreconditionFailedTest_Is_IsFalse_If_ifMatch_Matches_Etag_Of_The_File()
-            {
-                Request.Headers[HttpHeaders.IfMatch] = ResumeFileResult.Util.Etag(_file);
-                Assert.IsFalse(new MockResumeFileResult(_file.FullName, Request).IsPreconditionFailed());
-            }
+        [Test]
+        public void IsPreconditionFailedTest_Is_IsFalse_If_ifMatch_Matches_Etag_Of_The_File()
+        {
+            Request.Headers[HttpHeaders.IfMatch] = ResumeFileResult.Util.Etag(_file);
+            Assert.IsFalse(new MockResumeFileResult(_file.FullName, Request).IsPreconditionFailed());
+        }
 
-            [Test]
-            public void IsPreconditionFailedTest_Is_IsFalse_If_ifMatch_Equals_Star()
-            {
-                Request.Headers[HttpHeaders.IfMatch] = "*";
-                Assert.IsFalse(new MockResumeFileResult(_file.FullName, Request).IsPreconditionFailed());
-            }
+        [Test]
+        public void IsPreconditionFailedTest_Is_IsFalse_If_ifMatch_Equals_Star()
+        {
+            Request.Headers[HttpHeaders.IfMatch] = "*";
+            Assert.IsFalse(new MockResumeFileResult(_file.FullName, Request).IsPreconditionFailed());
+        }
 
-            [Test]
-            public void IsPreconditionFailedTest_Is_IsTrue_If_ifUnmodifiedSince_Doesnot_Equal_FileLastWriteTime()
-            {
-                Request.Headers[HttpHeaders.IfUnmodifiedSince] = ResumeFileResult.Util.FormatDate(DateTime.Now);
-                Assert.IsTrue(new MockResumeFileResult(_file.FullName, Request).IsPreconditionFailed());
-            }
+        [Test]
+        public void IsPreconditionFailedTest_Is_IsTrue_If_ifUnmodifiedSince_Doesnot_Equal_FileLastWriteTime()
+        {
+            Request.Headers[HttpHeaders.IfUnmodifiedSince] = ResumeFileResult.Util.FormatDate(DateTime.Now);
+            Assert.IsTrue(new MockResumeFileResult(_file.FullName, Request).IsPreconditionFailed());
+        }
 
-            [Test]
-            public void IsPreconditionFailedTest_Is_IsFalse_If_ifUnmodifiedSince_Equals_FileLastWriteTime()
-            {
-                Request.Headers[HttpHeaders.IfUnmodifiedSince] = ResumeFileResult.Util.FormatDate(_file.LastWriteTime);
-                Assert.IsFalse(new MockResumeFileResult(_file.FullName, Request).IsPreconditionFailed());
-            }
+        [Test]
+        public void IsPreconditionFailedTest_Is_IsFalse_If_ifUnmodifiedSince_Equals_FileLastWriteTime()
+        {
+            Request.Headers[HttpHeaders.IfUnmodifiedSince] = ResumeFileResult.Util.FormatDate(_file.LastWriteTime);
+            Assert.IsFalse(new MockResumeFileResult(_file.FullName, Request).IsPreconditionFailed());
+        }
 
-            [Test]
-            public void IsRangeNotSatisfiable_Is_True_If_Range_Header_Has_Invalid_Format()
-            {
-                Request.Headers[HttpHeaders.Range] = "blah";
-                Assert.IsTrue(new MockResumeFileResult(_file.FullName, Request).IsRangeNotSatisfiable());
-            }
+        [Test]
+        public void IsRangeNotSatisfiable_Is_True_If_Range_Header_Has_Invalid_Format()
+        {
+            Request.Headers[HttpHeaders.Range] = "blah";
+            Assert.IsTrue(new MockResumeFileResult(_file.FullName, Request).IsRangeNotSatisfiable());
+        }
 
-            [Test]
-            public void IsRangeNotSatisfiable_Is_True_If_Start_Greater_Than_End()
-            {
-                Request.Headers[HttpHeaders.Range] = "bytes=100-0";
-                Assert.IsTrue(new MockResumeFileResult(_file.FullName, Request).IsRangeNotSatisfiable());
-            }
+        [Test]
+        public void IsRangeNotSatisfiable_Is_True_If_Start_Greater_Than_End()
+        {
+            Request.Headers[HttpHeaders.Range] = "bytes=100-0";
+            Assert.IsTrue(new MockResumeFileResult(_file.FullName, Request).IsRangeNotSatisfiable());
+        }
 
-            [Test]
-            public void IsRangeNotSatisfiable_Is_True_If_End_Equals_Total_File_Size()
-            {
-                Request.Headers[HttpHeaders.Range] = "bytes=0-" + _file.Length;
-                Assert.IsTrue(new MockResumeFileResult(_file.FullName, Request).IsRangeNotSatisfiable());
-            }
+        [Test]
+        public void IsRangeNotSatisfiable_Is_True_If_End_Equals_Total_File_Size()
+        {
+            Request.Headers[HttpHeaders.Range] = "bytes=0-" + _file.Length;
+            Assert.IsTrue(new MockResumeFileResult(_file.FullName, Request).IsRangeNotSatisfiable());
+        }
 
-            [Test]
-            public void IsRangeNotSatisfiable_Is_True_If_End_Greater_Than_Total_File_Size()
-            {
-                Request.Headers[HttpHeaders.Range] = "bytes=0-" + _file.Length + 10;
-                Assert.IsTrue(new MockResumeFileResult(_file.FullName, Request).IsRangeNotSatisfiable());
-            }
+        [Test]
+        public void IsRangeNotSatisfiable_Is_True_If_End_Greater_Than_Total_File_Size()
+        {
+            Request.Headers[HttpHeaders.Range] = "bytes=0-" + _file.Length + 10;
+            Assert.IsTrue(new MockResumeFileResult(_file.FullName, Request).IsRangeNotSatisfiable());
+        }
 
-            [Test]
-            public void IsRangeNotSatisfiable_Is_False_If_Range_Header_Is_Null()
-            {
-                Request.Headers[HttpHeaders.Range] = null;
-                Assert.IsFalse(new MockResumeFileResult(_file.FullName, Request).IsRangeNotSatisfiable());
-            }
+        [Test]
+        public void IsRangeNotSatisfiable_Is_False_If_Range_Header_Is_Null()
+        {
+            Request.Headers[HttpHeaders.Range] = null;
+            Assert.IsFalse(new MockResumeFileResult(_file.FullName, Request).IsRangeNotSatisfiable());
+        }
 
-            [Test]
-            public void IsRangeNotSatisfiable_Is_False_If_Range_Has_StartsWith_Format()
-            {
-                Request.Headers[HttpHeaders.Range] = "bytes=0-";
-                Assert.IsFalse(new MockResumeFileResult(_file.FullName, Request).IsRangeNotSatisfiable());
-            }
+        [Test]
+        public void IsRangeNotSatisfiable_Is_False_If_Range_Has_StartsWith_Format()
+        {
+            Request.Headers[HttpHeaders.Range] = "bytes=0-";
+            Assert.IsFalse(new MockResumeFileResult(_file.FullName, Request).IsRangeNotSatisfiable());
+        }
 
-            [Test]
-            public void IsRangeNotSatisfiable_Is_False_If_Range_Has_LastXbytes_Format()
-            {
-                Request.Headers[HttpHeaders.Range] = "bytes=-100";
-                Assert.IsFalse(new MockResumeFileResult(_file.FullName, Request).IsRangeNotSatisfiable());
-            }
+        [Test]
+        public void IsRangeNotSatisfiable_Is_False_If_Range_Has_LastXbytes_Format()
+        {
+            Request.Headers[HttpHeaders.Range] = "bytes=-100";
+            Assert.IsFalse(new MockResumeFileResult(_file.FullName, Request).IsRangeNotSatisfiable());
+        }
 
-            [Test]
-            public void IsRangeNotSatisfiable_Is_False_If_Range_Ends_With_Last_Byte_Position()
-            {
-                Request.Headers[HttpHeaders.Range] = "bytes=100-" + (_file.Length - 1);
-                Assert.IsFalse(new MockResumeFileResult(_file.FullName, Request).IsRangeNotSatisfiable());
-            }
+        [Test]
+        public void IsRangeNotSatisfiable_Is_False_If_Range_Ends_With_Last_Byte_Position()
+        {
+            Request.Headers[HttpHeaders.Range] = "bytes=100-" + (_file.Length - 1);
+            Assert.IsFalse(new MockResumeFileResult(_file.FullName, Request).IsRangeNotSatisfiable());
+        }
 
-            [Test]
-            public void SendRange_Is_False_If_Range_And_ifRange_Headers_Are_Null()
-            {
-                Assert.IsFalse(new MockResumeFileResult(_file.FullName, Request).SendRange());
-            }
+        [Test]
+        public void SendRange_Is_False_If_Range_And_ifRange_Headers_Are_Null()
+        {
+            Assert.IsFalse(new MockResumeFileResult(_file.FullName, Request).SendRange());
+        }
 
-            [Test]
-            public void SendRange_Is_False_If_Range_Is_Null_And_ifRange_Is_Correct()
-            {
-                Request.Headers[HttpHeaders.IfRange] = ResumeFileResult.Util.Etag(_file);
-                Assert.IsFalse(new MockResumeFileResult(_file.FullName, Request).SendRange());
-            }
+        [Test]
+        public void SendRange_Is_False_If_Range_Is_Null_And_ifRange_Is_Correct()
+        {
+            Request.Headers[HttpHeaders.IfRange] = ResumeFileResult.Util.Etag(_file);
+            Assert.IsFalse(new MockResumeFileResult(_file.FullName, Request).SendRange());
+        }
 
-            [Test]
-            public void SendRange_Is_True_If_Range_Is_Correct_And_ifRange_Is_Null()
-            {
-                Request.Headers[HttpHeaders.Range] = "bytes=0-100";
-                Assert.IsTrue(new MockResumeFileResult(_file.FullName, Request).SendRange());
-            }
+        [Test]
+        public void SendRange_Is_True_If_Range_Is_Correct_And_ifRange_Is_Null()
+        {
+            Request.Headers[HttpHeaders.Range] = "bytes=0-100";
+            Assert.IsTrue(new MockResumeFileResult(_file.FullName, Request).SendRange());
+        }
 
-            [Test]
-            public void SendRange_Is_True_If_Range_And_ifRange_Are_Correct()
-            {
-                Request.Headers[HttpHeaders.IfRange] = ResumeFileResult.Util.Etag(_file);
-                Request.Headers[HttpHeaders.Range] = "bytes=0-100";
-                Assert.IsTrue(new MockResumeFileResult(_file.FullName, Request).SendRange());
-            }
+        [Test]
+        public void SendRange_Is_True_If_Range_And_ifRange_Are_Correct()
+        {
+            Request.Headers[HttpHeaders.IfRange] = ResumeFileResult.Util.Etag(_file);
+            Request.Headers[HttpHeaders.Range] = "bytes=0-100";
+            Assert.IsTrue(new MockResumeFileResult(_file.FullName, Request).SendRange());
+        }
 
-            [Test]
-            public void SendRange_Is_False_If_Range_Is_Correct_But_ifRange_Is_InCorrect()
-            {
-                Request.Headers[HttpHeaders.IfRange] = "incorrect etag";
-                Request.Headers[HttpHeaders.Range] = "bytes=0-100";
-                Assert.IsFalse(new MockResumeFileResult(_file.FullName, Request).SendRange());
-            }
+        [Test]
+        public void SendRange_Is_False_If_Range_Is_Correct_But_ifRange_Is_InCorrect()
+        {
+            Request.Headers[HttpHeaders.IfRange] = "incorrect etag";
+            Request.Headers[HttpHeaders.Range] = "bytes=0-100";
+            Assert.IsFalse(new MockResumeFileResult(_file.FullName, Request).SendRange());
+        }
 
-            [Test]
-            public void HeadersTest_Should_Not_Send_File_If_File_Has_Not_Been_Changed()
-            {
-                Request.Headers[HttpHeaders.IfNoneMatch] = ResumeFileResult.Util.Etag(_file);
-                var result = new MockResumeFileResult(_file.FullName, Request);
-                Assert.IsTrue(result.IsNotModified());
-                result.WriteFileTest(Response);
-                Assert.AreEqual((int)HttpStatusCode.NotModified, Response.StatusCode);
-                Assert.IsNotNull(Response.Headers[HttpHeaders.Etag]);
-                Assert.IsNotNull(Response.Headers[HttpHeaders.Expires]);
-                Assert.IsNotNull(Response.Headers[HttpHeaders.LastModified]);
-                Assert.IsNull(Response.Headers[HttpHeaders.ContentRange]);
-                Assert.AreEqual(0, Response.OutputStream.Length);
-            }
+        [Test]
+        public void HeadersTest_Should_Not_Send_File_If_File_Has_Not_Been_Changed()
+        {
+            Request.Headers[HttpHeaders.IfNoneMatch] = ResumeFileResult.Util.Etag(_file);
+            var result = new MockResumeFileResult(_file.FullName, Request);
+            Assert.IsTrue(result.IsNotModified());
+            result.WriteFileTest(Response);
+            Assert.AreEqual((int)HttpStatusCode.NotModified, Response.StatusCode);
+            Assert.IsNotNull(Response.Headers[HttpHeaders.Etag]);
+            Assert.IsNotNull(Response.Headers[HttpHeaders.Expires]);
+            Assert.IsNotNull(Response.Headers[HttpHeaders.LastModified]);
+            Assert.IsNull(Response.Headers[HttpHeaders.ContentRange]);
+            Assert.AreEqual(0, Response.OutputStream.Length);
+        }
 
-            [Test]
-            public void HeadersTest_Should_Not_Send_File_IfPreconditionFailed()
-            {
-                Request.Headers[HttpHeaders.IfMatch] = "invalid";
-                var result = new MockResumeFileResult(_file.FullName, Request);
-                Assert.IsTrue(result.IsPreconditionFailed());
-
-                result.WriteFileTest(Response);
-                Assert.AreEqual((int)HttpStatusCode.PreconditionFailed, Response.StatusCode);
-                Assert.IsNotNull(Response.Headers[HttpHeaders.Etag]);
-                Assert.IsNotNull(Response.Headers[HttpHeaders.Expires]);
-                Assert.IsNotNull(Response.Headers[HttpHeaders.LastModified]);
-                Assert.IsNull(Response.Headers[HttpHeaders.ContentRange]);
-                Assert.AreEqual(0, Response.OutputStream.Length);
-            }
+        [Test]
+        public void HeadersTest_Should_Not_Send_File_IfPreconditionFailed()
+        {
+            Request.Headers[HttpHeaders.IfMatch] = "invalid";
+            var result = new MockResumeFileResult(_file.FullName, Request);
+            Assert.IsTrue(result.IsPreconditionFailed());
+
+            result.WriteFileTest(Response);
+            Assert.AreEqual((int)HttpStatusCode.PreconditionFailed, Response.StatusCode);
+            Assert.IsNotNull(Response.Headers[HttpHeaders.Etag]);
+            Assert.IsNotNull(Response.Headers[HttpHeaders.Expires]);
+            Assert.IsNotNull(Response.Headers[HttpHeaders.LastModified]);
+            Assert.IsNull(Response.Headers[HttpHeaders.ContentRange]);
+            Assert.AreEqual(0, Response.OutputStream.Length);
+        }
 
-            [Test]
-            public void HeadersTest_Should_Not_Send_File_Is_RangeNotSatisfiable()
-            {
-                Request.Headers[HttpHeaders.Range] = "invalid";
-                var result = new MockResumeFileResult(_file.FullName, Request);
-                Assert.IsTrue(result.IsRangeNotSatisfiable());
-                result.WriteFileTest(Response);
-                Assert.AreEqual((int)HttpStatusCode.RequestedRangeNotSatisfiable, Response.StatusCode);
-                Assert.IsNotNull(Response.Headers[HttpHeaders.Etag]);
-                Assert.IsNotNull(Response.Headers[HttpHeaders.Expires]);
-                Assert.IsNotNull(Response.Headers[HttpHeaders.LastModified]);
-                Assert.AreEqual("bytes */" + _file.Length, Response.Headers[HttpHeaders.ContentRange]);
-                Assert.AreEqual(0, Response.OutputStream.Length);
-            }
+        [Test]
+        public void HeadersTest_Should_Not_Send_File_Is_RangeNotSatisfiable()
+        {
+            Request.Headers[HttpHeaders.Range] = "invalid";
+            var result = new MockResumeFileResult(_file.FullName, Request);
+            Assert.IsTrue(result.IsRangeNotSatisfiable());
+            result.WriteFileTest(Response);
+            Assert.AreEqual((int)HttpStatusCode.RequestedRangeNotSatisfiable, Response.StatusCode);
+            Assert.IsNotNull(Response.Headers[HttpHeaders.Etag]);
+            Assert.IsNotNull(Response.Headers[HttpHeaders.Expires]);
+            Assert.IsNotNull(Response.Headers[HttpHeaders.LastModified]);
+            Assert.AreEqual("bytes */" + _file.Length, Response.Headers[HttpHeaders.ContentRange]);
+            Assert.AreEqual(0, Response.OutputStream.Length);
+        }
 
-            [Test]
-            public void HeadersTest_Should_Send_File_If_All_Headers_Are_Null()
-            {
-                var result = new MockResumeFileResult(_file.FullName, Request);
-                result.WriteFileTest(Response);
-                Assert.AreEqual((int)HttpStatusCode.OK, Response.StatusCode);
-                Assert.IsNotNull(Response.Headers[HttpHeaders.Etag]);
-                Assert.IsNotNull(Response.Headers[HttpHeaders.Expires]);
-                Assert.IsNotNull(Response.Headers[HttpHeaders.LastModified]);
-                Assert.IsNotNull(Response.Headers[HttpHeaders.ContentRange]);
-                Assert.IsNotNull(Response.Headers[HttpHeaders.ContentLength]);
-                Assert.AreEqual(_file.Length, Response.OutputStream.Length);
-            }
+        [Test]
+        public void HeadersTest_Should_Send_File_If_All_Headers_Are_Null()
+        {
+            var result = new MockResumeFileResult(_file.FullName, Request);
+            result.WriteFileTest(Response);
+            Assert.AreEqual((int)HttpStatusCode.OK, Response.StatusCode);
+            Assert.IsNotNull(Response.Headers[HttpHeaders.Etag]);
+            Assert.IsNotNull(Response.Headers[HttpHeaders.Expires]);
+            Assert.IsNotNull(Response.Headers[HttpHeaders.LastModified]);
+            Assert.IsNotNull(Response.Headers[HttpHeaders.ContentRange]);
+            Assert.IsNotNull(Response.Headers[HttpHeaders.ContentLength]);
+            Assert.AreEqual(_file.Length, Response.OutputStream.Length);
+        }
 
-            [Test]
-            public void Range_First_500b()
-            {
-                var stream = GetResponseStream("bytes=0-499");
-                Assert.AreEqual(500, stream.Length);
-                Assert.AreEqual(206, Response.StatusCode);
-                Assert.AreEqual($"bytes 0-499/{_file.Length}", Response.Headers[HttpHeaders.ContentRange]);
-            }
+        [Test]
+        public void Range_First_500b()
+        {
+            var stream = GetResponseStream("bytes=0-499");
+            Assert.AreEqual(500, stream.Length);
+            Assert.AreEqual(206, Response.StatusCode);
+            Assert.AreEqual($"bytes 0-499/{_file.Length}", Response.Headers[HttpHeaders.ContentRange]);
+        }
 
-            [Test]
-            public void Range_From_500b_to_899b()
-            {
-                var stream = GetResponseStream("bytes=500-899");
-                Assert.AreEqual(400, stream.Length);
-                Assert.AreEqual(206, Response.StatusCode);
-                Assert.AreEqual($"bytes 500-899/{_file.Length}", Response.Headers[HttpHeaders.ContentRange]);
-            }
+        [Test]
+        public void Range_From_500b_to_899b()
+        {
+            var stream = GetResponseStream("bytes=500-899");
+            Assert.AreEqual(400, stream.Length);
+            Assert.AreEqual(206, Response.StatusCode);
+            Assert.AreEqual($"bytes 500-899/{_file.Length}", Response.Headers[HttpHeaders.ContentRange]);
+        }
 
-            [Test]
-            public void Range_Last_300b()
-            {
-                var stream = GetResponseStream("bytes=-300");
-                Assert.AreEqual(300, stream.Length);
-                Assert.AreEqual(206, Response.StatusCode);
-                var from = _file.Length - 300;
-                var to = _file.Length - 1;
+        [Test]
+        public void Range_Last_300b()
+        {
+            var stream = GetResponseStream("bytes=-300");
+            Assert.AreEqual(300, stream.Length);
+            Assert.AreEqual(206, Response.StatusCode);
+            var from = _file.Length - 300;
+            var to = _file.Length - 1;
 
-                Assert.AreEqual($"bytes {from}-{to}/{_file.Length}", Response.Headers[HttpHeaders.ContentRange]);
-            }
+            Assert.AreEqual($"bytes {from}-{to}/{_file.Length}", Response.Headers[HttpHeaders.ContentRange]);
+        }
 
-            [Test]
-            public void Range_From_100b_toThe_End()
-            {
-                var stream = GetResponseStream($"bytes={(_file.Length - 100)}-");
-                Assert.AreEqual(100, stream.Length);
-                Assert.AreEqual(206, Response.StatusCode);
-                var from = _file.Length - 100;
-                var to = _file.Length - 1;
-                Assert.AreEqual($"bytes {from}-{to}/{_file.Length}", Response.Headers[HttpHeaders.ContentRange]);
-            }
+        [Test]
+        public void Range_From_100b_toThe_End()
+        {
+            var stream = GetResponseStream($"bytes={(_file.Length - 100)}-");
+            Assert.AreEqual(100, stream.Length);
+            Assert.AreEqual(206, Response.StatusCode);
+            var from = _file.Length - 100;
+            var to = _file.Length - 1;
+            Assert.AreEqual($"bytes {from}-{to}/{_file.Length}", Response.Headers[HttpHeaders.ContentRange]);
+        }
 
-            [Test]
-            public void Range_First_1b()
-            {
-                var stream = GetResponseStream("bytes=0-0");
-                Assert.AreEqual(1, stream.Length);
-                Assert.AreEqual(206, Response.StatusCode);
-                Assert.AreEqual($"bytes 0-0/{_file.Length}", Response.Headers[HttpHeaders.ContentRange]);
-            }
+        [Test]
+        public void Range_First_1b()
+        {
+            var stream = GetResponseStream("bytes=0-0");
+            Assert.AreEqual(1, stream.Length);
+            Assert.AreEqual(206, Response.StatusCode);
+            Assert.AreEqual($"bytes 0-0/{_file.Length}", Response.Headers[HttpHeaders.ContentRange]);
+        }
 
-            [Test]
-            public void Range_Last_1b()
-            {
-                var stream = GetResponseStream("bytes=-1");
-                Assert.AreEqual(1, stream.Length);
-                Assert.AreEqual(206, Response.StatusCode);
-                var from = _file.Length - 1;
-                var to = _file.Length - 1;
-                Assert.AreEqual($"bytes {from}-{to}/{_file.Length}", Response.Headers[HttpHeaders.ContentRange]);
-            }
+        [Test]
+        public void Range_Last_1b()
+        {
+            var stream = GetResponseStream("bytes=-1");
+            Assert.AreEqual(1, stream.Length);
+            Assert.AreEqual(206, Response.StatusCode);
+            var from = _file.Length - 1;
+            var to = _file.Length - 1;
+            Assert.AreEqual($"bytes {from}-{to}/{_file.Length}", Response.Headers[HttpHeaders.ContentRange]);
+        }
 
-            [Test]
-            public void Range_Whole_File_With_RangeHeader()
-            {
-                var stream = GetResponseStream("bytes=0-" + (_file.Length - 1));
-                Assert.AreEqual(_file.Length, stream.Length);
-                Assert.AreEqual(206, Response.StatusCode);
-                Assert.AreEqual($"bytes 0-{(_file.Length - 1)}/{_file.Length}", Response.Headers[HttpHeaders.ContentRange]);
-            }
+        [Test]
+        public void Range_Whole_File_With_RangeHeader()
+        {
+            var stream = GetResponseStream("bytes=0-" + (_file.Length - 1));
+            Assert.AreEqual(_file.Length, stream.Length);
+            Assert.AreEqual(206, Response.StatusCode);
+            Assert.AreEqual($"bytes 0-{(_file.Length - 1)}/{_file.Length}", Response.Headers[HttpHeaders.ContentRange]);
+        }
 
-            [Test]
-            public void Range_Whole_File_Without_RangeHeader()
-            {
-                var stream = GetResponseStream(null);
-                Assert.AreEqual(_file.Length, stream.Length);
-                Assert.AreEqual(200, Response.StatusCode);
-                Assert.AreEqual($"bytes 0-{(_file.Length - 1)}/{_file.Length}", Response.Headers[HttpHeaders.ContentRange]);
-            }
+        [Test]
+        public void Range_Whole_File_Without_RangeHeader()
+        {
+            var stream = GetResponseStream(null);
+            Assert.AreEqual(_file.Length, stream.Length);
+            Assert.AreEqual(200, Response.StatusCode);
+            Assert.AreEqual($"bytes 0-{(_file.Length - 1)}/{_file.Length}", Response.Headers[HttpHeaders.ContentRange]);
+        }
 
-            [Test]
-            public void TransmissionRange_From_0_To_0()
-            {
-                Request.Headers[HttpHeaders.Range] = "bytes=0-0";
-                new MockResumeFileResult(_file.FullName, Request).WriteFileTest(Response);
+        [Test]
+        public void TransmissionRange_From_0_To_0()
+        {
+            Request.Headers[HttpHeaders.Range] = "bytes=0-0";
+            new MockResumeFileResult(_file.FullName, Request).WriteFileTest(Response);
 
-                Assert.AreEqual(1, Response.OutputStream.Length);
-                AssertBytes(_file, Response.OutputStream, 0, 1);
-            }
+            Assert.AreEqual(1, Response.OutputStream.Length);
+            AssertBytes(_file, Response.OutputStream, 0, 1);
+        }
 
-            [Test]
-            public void TransmissionRange_From_1_To_100()
-            {
-                Request.Headers[HttpHeaders.Range] = "bytes=1-100";
-                new MockResumeFileResult(_file.FullName, Request).WriteFileTest(Response);
+        [Test]
+        public void TransmissionRange_From_1_To_100()
+        {
+            Request.Headers[HttpHeaders.Range] = "bytes=1-100";
+            new MockResumeFileResult(_file.FullName, Request).WriteFileTest(Response);
 
-                Assert.AreEqual(100, Response.OutputStream.Length);
-                AssertBytes(_file, Response.OutputStream, 1, 100);
-            }
+            Assert.AreEqual(100, Response.OutputStream.Length);
+            AssertBytes(_file, Response.OutputStream, 1, 100);
+        }
 
-            [Test]
-            public void TransmissionRange_From_101_To_theEnd()
-            {
-                Request.Headers[HttpHeaders.Range] = "bytes=101-";
-                new MockResumeFileResult(_file.FullName, Request).WriteFileTest(Response);
+        [Test]
+        public void TransmissionRange_From_101_To_theEnd()
+        {
+            Request.Headers[HttpHeaders.Range] = "bytes=101-";
+            new MockResumeFileResult(_file.FullName, Request).WriteFileTest(Response);
 
-                Assert.AreEqual(_file.Length - 101, Response.OutputStream.Length);
-                AssertBytes(_file, Response.OutputStream, 101, (int)_file.Length);
-            }
+            Assert.AreEqual(_file.Length - 101, Response.OutputStream.Length);
+            AssertBytes(_file, Response.OutputStream, 101, (int)_file.Length);
+        }
 
-            [Test]
-            public void TransmissionRange_WholeFile_WithRangeHeader()
-            {
-                Request.Headers[HttpHeaders.Range] = "bytes=0-";
-                new MockResumeFileResult(_file.FullName, Request).WriteFileTest(Response);
+        [Test]
+        public void TransmissionRange_WholeFile_WithRangeHeader()
+        {
+            Request.Headers[HttpHeaders.Range] = "bytes=0-";
+            new MockResumeFileResult(_file.FullName, Request).WriteFileTest(Response);
 
-                Assert.AreEqual(_file.Length, Response.OutputStream.Length);
-                AssertBytes(_file, Response.OutputStream, 0, (int)_file.Length);
-            }
+            Assert.AreEqual(_file.Length, Response.OutputStream.Length);
+            AssertBytes(_file, Response.OutputStream, 0, (int)_file.Length);
+        }
 
-            [Test]
-            public void TransmissionRange_WholeFile_WithoutRangeHeader()
-            {
-                Request.Headers[HttpHeaders.Range] = null;
-                new MockResumeFileResult(_file.FullName, Request).WriteFileTest(Response);
+        [Test]
+        public void TransmissionRange_WholeFile_WithoutRangeHeader()
+        {
+            Request.Headers[HttpHeaders.Range] = null;
+            new MockResumeFileResult(_file.FullName, Request).WriteFileTest(Response);
 
-                Assert.AreEqual(_file.Length, Response.OutputStream.Length);
-                AssertBytes(_file, Response.OutputStream, 0, (int)_file.Length);
-            }
+            Assert.AreEqual(_file.Length, Response.OutputStream.Length);
+            AssertBytes(_file, Response.OutputStream, 0, (int)_file.Length);
+        }
 
-            [Test]
-            public void ShouldSend206If_Range_HeaderExists()
-            {
-                Request.Headers[HttpHeaders.Range] = "bytes=0-";
-                new MockResumeFileResult(_file.FullName, Request).WriteFileTest(Response);
-                Assert.AreEqual(206, Response.StatusCode);
-            }
+        [Test]
+        public void ShouldSend206If_Range_HeaderExists()
+        {
+            Request.Headers[HttpHeaders.Range] = "bytes=0-";
+            new MockResumeFileResult(_file.FullName, Request).WriteFileTest(Response);
+            Assert.AreEqual(206, Response.StatusCode);
+        }
 
-            [Test]
-            public void ShouldSend200If_Range_HeaderDoesNotExist()
-            {
-                Request.Headers[HttpHeaders.Range] = null;
-                new MockResumeFileResult(_file.FullName, Request).WriteFileTest(Response);
-                Assert.AreEqual(200, Response.StatusCode);
-            }
+        [Test]
+        public void ShouldSend200If_Range_HeaderDoesNotExist()
+        {
+            Request.Headers[HttpHeaders.Range] = null;
+            new MockResumeFileResult(_file.FullName, Request).WriteFileTest(Response);
+            Assert.AreEqual(200, Response.StatusCode);
+        }
 
-            [Test]
-            public void IfRangeHeader_Should_Be_Ignored_If_ItNotEquals_Etag()
-            {
-                Request.Headers[HttpHeaders.IfRange] = "ifRange fake header";
-                var mock = new MockResumeFileResult(_file.FullName, Request);
-                mock.WriteFileTest(Response);
+        [Test]
+        public void IfRangeHeader_Should_Be_Ignored_If_ItNotEquals_Etag()
+        {
+            Request.Headers[HttpHeaders.IfRange] = "ifRange fake header";
+            var mock = new MockResumeFileResult(_file.FullName, Request);
+            mock.WriteFileTest(Response);
 
-                Assert.AreNotEqual(ResumeFileResult.Util.Etag(_file), Request.Headers[HttpHeaders.IfRange]);
-                Assert.AreEqual(200, Response.StatusCode);
-            }
+            Assert.AreNotEqual(ResumeFileResult.Util.Etag(_file), Request.Headers[HttpHeaders.IfRange]);
+            Assert.AreEqual(200, Response.StatusCode);
+        }
 
-            [Test]
-            public void Etag_Should_Be_Added_To_Response_If_It_Equals_With_IfRange_In_Request()
-            {
-                var etag = ResumeFileResult.Util.Etag(_file);
-                Request.Headers[HttpHeaders.IfRange] = etag;
-                var mock = new MockResumeFileResult(_file.FullName, Request);
-                mock.WriteFileTest(Response);
-                Assert.AreEqual(Response.Headers[HttpHeaders.Etag], etag);
-                Assert.AreEqual(200, Response.StatusCode);
-            }
+        [Test]
+        public void Etag_Should_Be_Added_To_Response_If_It_Equals_With_IfRange_In_Request()
+        {
+            var etag = ResumeFileResult.Util.Etag(_file);
+            Request.Headers[HttpHeaders.IfRange] = etag;
+            var mock = new MockResumeFileResult(_file.FullName, Request);
+            mock.WriteFileTest(Response);
+            Assert.AreEqual(Response.Headers[HttpHeaders.Etag], etag);
+            Assert.AreEqual(200, Response.StatusCode);
+        }
 
-            [Test]
-            public void Etag_Should_Be_Added_To_Response_If_It_Equals_With_IfRange_In_Request__PartialResponse()
-            {
-                var etag = ResumeFileResult.Util.Etag(_file);
-                Request.Headers[HttpHeaders.IfRange] = etag;
-                Request.Headers[HttpHeaders.Range] = "bytes=0-";
-                new MockResumeFileResult(_file.FullName, Request).WriteFileTest(Response);
-                Assert.AreEqual(Response.Headers[HttpHeaders.Etag], etag);
-                Assert.IsNotNull(Response.Headers[HttpHeaders.ContentRange]);
-                Assert.AreEqual(206, Response.StatusCode);
-            }
+        [Test]
+        public void Etag_Should_Be_Added_To_Response_If_It_Equals_With_IfRange_In_Request__PartialResponse()
+        {
+            var etag = ResumeFileResult.Util.Etag(_file);
+            Request.Headers[HttpHeaders.IfRange] = etag;
+            Request.Headers[HttpHeaders.Range] = "bytes=0-";
+            new MockResumeFileResult(_file.FullName, Request).WriteFileTest(Response);
+            Assert.AreEqual(Response.Headers[HttpHeaders.Etag], etag);
+            Assert.IsNotNull(Response.Headers[HttpHeaders.ContentRange]);
+            Assert.AreEqual(206, Response.StatusCode);
+        }
 
-            [Test]
-            public void It_Should_Attach_Content_Disposition_If_There_Is_Download_File_Name()
-            {
-                new MockResumeFileResult(_file.FullName, Request, "test.name").WriteFileTest(Response);
-                Assert.IsNotNull(Response.Headers[HttpHeaders.ContentDisposition]);
-            }
+        [Test]
+        public void It_Should_Attach_Content_Disposition_If_There_Is_Download_File_Name()
+        {
+            new MockResumeFileResult(_file.FullName, Request, "test.name").WriteFileTest(Response);
+            Assert.IsNotNull(Response.Headers[HttpHeaders.ContentDisposition]);
+        }
 
-            private Stream GetResponseStream(string range)
-            {
-                Response.ClearTestResponse();
-                Response.StatusCode = 500;
+        private Stream GetResponseStream(string range)
+        {
+            Response.ClearTestResponse();
+            Response.StatusCode = 500;
 
-                Request.Headers[HttpHeaders.Range] = range;
-                new MockResumeFileResult(_file.FullName, Request).WriteFileTest(Response);
+            Request.Headers[HttpHeaders.Range] = range;
+            new MockResumeFileResult(_file.FullName, Request).WriteFileTest(Response);
 
-                return Response.OutputStream;
-            }
+            return Response.OutputStream;
+        }
 
-            private void AssertBytes(FileInfo file, Stream responseStream, int from, int to)
+        private void AssertBytes(FileInfo file, Stream responseStream, int from, int to)
+        {
+            using (var fileStream = file.OpenRead())
             {
-                using (var fileStream = file.OpenRead())
+                responseStream.Seek(0, SeekOrigin.Begin);
+                fileStream.Seek(from, SeekOrigin.Begin);
+                for (var byteIndex = from; byteIndex < to; byteIndex++)
                 {
-                    responseStream.Seek(0, SeekOrigin.Begin);
-                    fileStream.Seek(from, SeekOrigin.Begin);
-                    for (var byteIndex = from; byteIndex < to; byteIndex++)
-                    {
-                        var responseByte = responseStream.ReadByte();
-                        var fileByte = fileStream.ReadByte();
-                        Assert.AreEqual(responseByte, fileByte);
-                    }
+                    var responseByte = responseStream.ReadByte();
+                    var fileByte = fileStream.ReadByte();
+                    Assert.AreEqual(responseByte, fileByte);
                 }
             }
         }
     }
-}
+}

Masuit.Tools/Mapping/Core/MapperConfigurationBase.cs

@@ -414,6 +414,7 @@ namespace Masuit.Tools.Mapping.Core
                                     Expression toListExp = Expression.Call(_toListMethod.MakeGenericMethod(sourceType), assignExpression);
                                     Expression setIf = Expression.IfThen(checkIfNull, Expression.Assign(propToAssign, assignExpression));
                                     finalAssign.Add(setIf);
+                                    finalAssign.Add(toListExp);
                                 }
                             }
                         }
@@ -437,7 +438,7 @@ namespace Masuit.Tools.Mapping.Core
                             }
                             else
                             {
-                                Expression selectExp = Expression.Call(_selectMethod.MakeGenericMethod(sourceType), Expression.Constant(mapper.GetDelegate()));
+                                //Expression selectExp = Expression.Call(_selectMethod.MakeGenericMethod(sourceType), Expression.Constant(mapper.GetDelegate()));
                                 Expression checkIfNull = Expression.NotEqual(propToAssign, defaultExpression);
                                 Expression setIf = Expression.IfThen(checkIfNull, Expression.Assign(propToAssign, assignExpression));
                                 assignExpression = setIf;
@@ -596,7 +597,7 @@ namespace Masuit.Tools.Mapping.Core
                 Expression mapExpression = externalMapper.GetMemberInitExpression();
                 Expression defaultExpression = Expression.Constant(MapperHelper.GetDefaultValue(configExpression.Item1.Type), configExpression.Item1.Type);
                 // 修改成员
-                Expression expSource = visitorMapper.Visit(configExpression.Item1, false);
+                Expression expSource = visitorMapper.Visit(configExpression.Item1);
                 ChangParameterExpressionVisitor changeParamaterVisitor = new ChangParameterExpressionVisitor(expSource);
                 mapExpression = changeParamaterVisitor.Visit(mapExpression);
                 // 现在可以创建正确的参数。
@@ -639,7 +640,7 @@ namespace Masuit.Tools.Mapping.Core
                 // 为了与EF / LINQ2SQL兼容。
                 LambdaExpression expMappeur = externalMapper.GetGenericLambdaExpression();
                 // 创建对Select方法的调用，在Enumerable的Select中插入一个lambda表达式（参数是一个委托），通常情况下，这是不可能的，但（个人认为）编译器就像这样创建并且LINQ2SQL / EF是可以进行sql查询的
-                Expression select = Expression.Call(_selectMethod.MakeGenericMethod(sourceTypeList, destTypeList), new Expression[]
+                Expression select = Expression.Call(_selectMethod.MakeGenericMethod(sourceTypeList, destTypeList), new[]
                 {
                     expSource,
                     expMappeur

Masuit.Tools/Mapping/Core/TypePairMapper.cs

@@ -11,8 +11,8 @@ namespace Masuit.Tools.Mapping.Core
             Name = name;
         }
 
-        public Type Source { get; private set; }
-        public Type Target { get; private set; }
+        public Type Source { get; }
+        public Type Target { get; }
 
         public string Name { get; private set; }
 
@@ -21,9 +21,9 @@ namespace Masuit.Tools.Mapping.Core
             return new TypePairMapper(source, target, name);
         }
 
-        public static TypePairMapper Create<TSource, TTarget>(string name = null)
+        public static TypePairMapper Create<TSource, TDest>(string name = null)
         {
-            return new TypePairMapper(typeof(TSource), typeof(TTarget), name);
+            return new TypePairMapper(typeof(TSource), typeof(TDest), name);
         }
 
         public override bool Equals(object obj)

Masuit.Tools/Mapping/ExpressionMapper.cs

@@ -17,13 +17,13 @@ namespace Masuit.Tools.Mapping
         /// 映射指定的源。
         /// </summary>
         /// <typeparam name="TSource">源类型</typeparam>
-        /// <typeparam name="TTarget">目标类型</typeparam>
+        /// <typeparam name="TDest">目标类型</typeparam>
         /// <param name="source">源对象</param>
         /// <param name="name">别名</param>
         /// <returns>
         /// 目标对象的新实例
         /// </returns>
-        public static TTarget Map<TSource, TTarget>(this TSource source, string name = null) where TSource : class where TTarget : class
+        public static TDest Map<TSource, TDest>(this TSource source, string name = null) where TSource : class where TDest : class
         {
             if (source == null)
             {
@@ -34,9 +34,9 @@ namespace Masuit.Tools.Mapping
             {
                 Initialize();
             }
-            TTarget result = null;
-            MapperConfiguration<TSource, TTarget> mapper = GetMapper<TSource, TTarget>(name);
-            Func<TSource, TTarget> query = mapper.GetFuncDelegate();
+            TDest result = null;
+            MapperConfiguration<TSource, TDest> mapper = GetMapper<TSource, TDest>(name);
+            Func<TSource, TDest> query = mapper.GetFuncDelegate();
             if (query != null)
             {
                 result = query(source);
@@ -50,19 +50,19 @@ namespace Masuit.Tools.Mapping
         /// 将指定的源映射到目标。
         /// </summary>
         /// <typeparam name="TSource">源类型</typeparam>
-        /// <typeparam name="TTarget">目标类型</typeparam>
+        /// <typeparam name="TDest">目标类型</typeparam>
         /// <param name="source">源对象</param>
         /// <param name="target">目标对象</param>
         /// <param name="name">别名</param>
-        public static void Map<TSource, TTarget>(this TSource source, TTarget target, string name = null) where TSource : class where TTarget : class
+        public static void Map<TSource, TDest>(this TSource source, TDest target, string name = null) where TSource : class where TDest : class
         {
             if (!_initialized)
             {
                 Initialize();
             }
-            TTarget result = null;
-            MapperConfiguration<TSource, TTarget> mapper = GetMapper<TSource, TTarget>(name);
-            Action<TSource, TTarget> query = mapper.GetDelegateForExistingTarget() as Action<TSource, TTarget>;
+            TDest result = null;
+            MapperConfiguration<TSource, TDest> mapper = GetMapper<TSource, TDest>(name);
+            Action<TSource, TDest> query = mapper.GetDelegateForExistingTarget() as Action<TSource, TDest>;
             if (query != null)
             {
                 query(source, target);
@@ -75,29 +75,29 @@ namespace Masuit.Tools.Mapping
         /// 获取查询表达式树
         /// </summary>
         /// <typeparam name="TSource">源类型</typeparam>
-        /// <typeparam name="TTarget">目标类型</typeparam>
+        /// <typeparam name="TDest">目标类型</typeparam>
         /// <returns></returns>
-        public static Expression<Func<TSource, TTarget>> GetQueryExpression<TSource, TTarget>() where TSource : class where TTarget : class
+        public static Expression<Func<TSource, TDest>> GetQueryExpression<TSource, TDest>() where TSource : class where TDest : class
         {
-            return GetMapper<TSource, TTarget>().GetLambdaExpression();
+            return GetMapper<TSource, TDest>().GetLambdaExpression();
         }
 
         /// <summary>
         /// 创建mapper对象
         /// </summary>
         /// <typeparam name="TSource">源类型</typeparam>
-        /// <typeparam name="TTarget">目标类型</typeparam>
+        /// <typeparam name="TDest">目标类型</typeparam>
         /// <returns></returns>
-        public static MapperConfiguration<TSource, TTarget> CreateMap<TSource, TTarget>(string name = null) where TSource : class where TTarget : class
+        public static MapperConfiguration<TSource, TDest> CreateMap<TSource, TDest>(string name = null) where TSource : class where TDest : class
         {
-            MapperConfigurationBase map = MapperConfigurationCollectionContainer.Instance.Find(typeof(TSource), typeof(TTarget), name);
+            MapperConfigurationBase map = MapperConfigurationCollectionContainer.Instance.Find(typeof(TSource), typeof(TDest), name);
             if (map == null)
             {
                 string finalName = string.IsNullOrEmpty(name) ? "s" + MapperConfigurationCollectionContainer.Instance.Count.ToString() : name;
-                map = new MapperConfiguration<TSource, TTarget>(finalName);
+                map = new MapperConfiguration<TSource, TDest>(finalName);
                 MapperConfigurationCollectionContainer.Instance.Add(map);
             }
-            return map as MapperConfiguration<TSource, TTarget>;
+            return map as MapperConfiguration<TSource, TDest>;
         }
 
         /// <summary>

Masuit.Tools/Mapping/Extensions/QueryableExtentions.cs

@@ -14,96 +14,96 @@ namespace Masuit.Tools.Mapping.Extensions
         /// 根据键按升序对序列的元素进行排序。
         /// </summary>
         /// <typeparam name="TSource">源类型</typeparam>
-        /// <typeparam name="TTarget">目标类型</typeparam>
+        /// <typeparam name="TDest">目标类型</typeparam>
         /// <param name="query">分类化的序列值</param>
         /// <param name="sortedPropertyDestName">目标属性的名称</param>
         /// <returns></returns>
-        public static IOrderedQueryable<TSource> OrderBy<TSource, TTarget>(this IQueryable<TSource> query, string sortedPropertyDestName) where TSource : class where TTarget : class
+        public static IOrderedQueryable<TSource> OrderBy<TSource, TDest>(this IQueryable<TSource> query, string sortedPropertyDestName) where TSource : class where TDest : class
         {
             // 没有使用MethodBase.GetCurrentMethod().Name，因为效率不高
-            return CreateSortedMethodCall<TSource, TTarget, IOrderedQueryable<TSource>>(query, "OrderBy", sortedPropertyDestName);
+            return CreateSortedMethodCall<TSource, TDest, IOrderedQueryable<TSource>>(query, "OrderBy", sortedPropertyDestName);
         }
 
         /// <summary>
         /// 根据键按降序对序列的元素进行排序。
         /// </summary>
         /// <typeparam name="TSource">源类型</typeparam>
-        /// <typeparam name="TTarget">目标类型</typeparam>
+        /// <typeparam name="TDest">目标类型</typeparam>
         /// <param name="query">分类化的序列值</param>
         /// <param name="sortedPropertyDestName">目标属性的名称</param>
         /// <returns></returns>
-        public static IOrderedQueryable<TSource> OrderByDescending<TSource, TTarget>(this IQueryable<TSource> query, string sortedPropertyDestName) where TSource : class where TTarget : class
+        public static IOrderedQueryable<TSource> OrderByDescending<TSource, TDest>(this IQueryable<TSource> query, string sortedPropertyDestName) where TSource : class where TDest : class
         {
-            return CreateSortedMethodCall<TSource, TTarget, IOrderedQueryable<TSource>>(query, "OrderByDescending", sortedPropertyDestName);
+            return CreateSortedMethodCall<TSource, TDest, IOrderedQueryable<TSource>>(query, "OrderByDescending", sortedPropertyDestName);
         }
 
         /// <summary>
         ///  根据键按升序对序列的元素进行排序。
         /// </summary>
         /// <typeparam name="TSource">源类型</typeparam>
-        /// <typeparam name="TTarget">目标类型</typeparam>
+        /// <typeparam name="TDest">目标类型</typeparam>
         /// <param name="query">分类化的序列值</param>
         /// <param name="sortedPropertyDestName">目标属性的名称</param>
-        public static IOrderedQueryable<TSource> ThenBy<TSource, TTarget>(this IQueryable<TSource> query, string sortedPropertyDestName) where TSource : class where TTarget : class
+        public static IOrderedQueryable<TSource> ThenBy<TSource, TDest>(this IQueryable<TSource> query, string sortedPropertyDestName) where TSource : class where TDest : class
         {
-            return CreateSortedMethodCall<TSource, TTarget, IOrderedQueryable<TSource>>(query, "ThenBy", sortedPropertyDestName);
+            return CreateSortedMethodCall<TSource, TDest, IOrderedQueryable<TSource>>(query, "ThenBy", sortedPropertyDestName);
         }
 
         /// <summary>
         /// 根据键按降序对序列的元素进行排序。
         /// </summary>
         /// <typeparam name="TSource">源类型</typeparam>
-        /// <typeparam name="TTarget">目标类型</typeparam>
+        /// <typeparam name="TDest">目标类型</typeparam>
         /// <param name="query">分类化的序列值</param>
         /// <param name="sortedPropertyDestName">目标属性的名称</param>
-        public static IOrderedQueryable<TSource> ThenByDescending<TSource, TTarget>(this IQueryable<TSource> query, string sortedPropertyDestName) where TSource : class where TTarget : class
+        public static IOrderedQueryable<TSource> ThenByDescending<TSource, TDest>(this IQueryable<TSource> query, string sortedPropertyDestName) where TSource : class where TDest : class
         {
-            return CreateSortedMethodCall<TSource, TTarget, IOrderedQueryable<TSource>>(query, "ThenByDescending", sortedPropertyDestName);
+            return CreateSortedMethodCall<TSource, TDest, IOrderedQueryable<TSource>>(query, "ThenByDescending", sortedPropertyDestName);
         }
 
         /// <summary>
         /// 通过合并目标对象将序列的每个元素投影到新表单中。
         /// </summary>
         /// <typeparam name="TSource">源类型.</typeparam>
-        /// <typeparam name="TTarget">目标类型.</typeparam>
+        /// <typeparam name="TDest">目标类型.</typeparam>
         /// <param name="query">分类化的序列值</param>
-        public static IQueryable<TTarget> Select<TSource, TTarget>(this IQueryable<TSource> query) where TSource : class where TTarget : class
+        public static IQueryable<TDest> Select<TSource, TDest>(this IQueryable<TSource> query) where TSource : class where TDest : class
         {
-            return GetSelect<TSource, TTarget>(query, null);
+            return GetSelect<TSource, TDest>(query, null);
         }
 
         /// <summary>
         /// 通过合并目标对象将序列的每个元素投影到新表单中。
         /// </summary>
         /// <typeparam name="TSource">源类型.</typeparam>
-        /// <typeparam name="TTarget">目标类型.</typeparam>
+        /// <typeparam name="TDest">目标类型.</typeparam>
         /// <param name="query">分类化的序列值</param>
         /// <param name="mapperName">mapper别名</param>
         /// <returns></returns>
-        public static IQueryable<TTarget> Select<TSource, TTarget>(this IQueryable<TSource> query, string mapperName) where TSource : class where TTarget : class
+        public static IQueryable<TDest> Select<TSource, TDest>(this IQueryable<TSource> query, string mapperName) where TSource : class where TDest : class
         {
-            return GetSelect<TSource, TTarget>(query, mapperName);
+            return GetSelect<TSource, TDest>(query, mapperName);
         }
 
         /// <summary>
         /// 根据谓词过滤一系列值。
         /// </summary>
         /// <typeparam name="TSource">源类型</typeparam>
-        /// <typeparam name="TTarget">目标类型</typeparam>
+        /// <typeparam name="TDest">目标类型</typeparam>
         /// <param name="query">分类化的序列值</param>
         /// <param name="predicate">用于根据条件测试每个元素的功能。</param>
         /// <returns></returns>
-        public static IQueryable<TTarget> Where<TSource, TTarget>(this IQueryable<TTarget> query, Expression<Func<TSource, bool>> predicate)
+        public static IQueryable<TDest> Where<TSource, TDest>(this IQueryable<TDest> query, Expression<Func<TSource, bool>> predicate)
         {
-            return Queryable.Where(query, predicate.ConvertTo<TSource, TTarget>());
+            return Queryable.Where(query, predicate.ConvertTo<TSource, TDest>());
         }
 
-        private static TQueryable CreateSortedMethodCall<TSource, TTarget, TQueryable>(IQueryable<TSource> query, string methodName, string sortedPropertySourceName) where TSource : class where TTarget : class where TQueryable : class, IQueryable<TSource>
+        private static TQueryable CreateSortedMethodCall<TSource, TDest, TQueryable>(IQueryable<TSource> query, string methodName, string sortedPropertySourceName) where TSource : class where TDest : class where TQueryable : class, IQueryable<TSource>
         {
-            MapperConfiguration<TSource, TTarget> mapper = ExpressionMapper.GetMapper<TSource, TTarget>();
+            MapperConfiguration<TSource, TDest> mapper = ExpressionMapper.GetMapper<TSource, TDest>();
             var prop = mapper.GetLambdaDest(sortedPropertySourceName);
             var lambda = mapper.GetSortedExpression(sortedPropertySourceName);
-            MethodCallExpression resultExp = Expression.Call(typeof(Queryable), methodName, new Type[]
+            MethodCallExpression resultExp = Expression.Call(typeof(Queryable), methodName, new[]
             {
                 typeof(TSource),
                 prop.Type
@@ -111,14 +111,14 @@ namespace Masuit.Tools.Mapping.Extensions
             return query.Provider.CreateQuery<TSource>(resultExp) as TQueryable;
         }
 
-        private static IQueryable<TTarget> GetSelect<TSource, TTarget>(IQueryable<TSource> query, string mapperName) where TSource : class where TTarget : class
+        private static IQueryable<TDest> GetSelect<TSource, TDest>(IQueryable<TSource> query, string mapperName) where TSource : class where TDest : class
         {
             // 不需要mapper
-            if (typeof(TSource) == typeof(TTarget))
+            if (typeof(TSource) == typeof(TDest))
             {
-                return (IQueryable<TTarget>)query;
+                return (IQueryable<TDest>)query;
             }
-            return query.Select(ExpressionMapper.GetMapper<TSource, TTarget>(mapperName).GetLambdaExpression());
+            return query.Select(ExpressionMapper.GetMapper<TSource, TDest>(mapperName).GetLambdaExpression());
         }
     }
 }