(转)EntityFramework.Extensions

转自：http://www.symbolsource.org/Public/Metadata/NuGet/Project/EntityFramework.Extended/1.0.0.20/Release/.NETFramework,Version%3Dv4.0/EntityFramework.Extended/EntityFramework.Extended/EntityFramework.Extended/Extensions/BatchExtensions.cs?ImageName=EntityFramework.Extended

 

using System;

using System.Collections.Generic;

using System.Data;

using System.Data.Common;

using System.Data.Common.CommandTrees;

using System.Data.Entity;

using System.Data.EntityClient;

using System.Data.Metadata.Edm;

using System.Data.Objects.DataClasses;

using System.Data.SqlClient;

using System.Linq;

using System.Linq.Dynamic;

using System.Linq.Expressions;

using System.Reflection;

using System.Text;

using System.Data.Objects;

using EntityFramework.Mapping;

using EntityFramework.Reflection;

 

namespace EntityFramework.Extensions

{

    /// <summary>

    /// An extensions class for batch queries.

    /// </summary>

    public static class BatchExtensions

    {

        /// <summary>

        /// Executes a delete statement using the query to filter the rows to be deleted.

        /// </summary>

        /// <typeparam name="TEntity">The type of the entity.</typeparam>

        /// <param name="source">The source used to determine the table to delete from.</param>

        /// <param name="query">The IQueryable used to generate the where clause for the delete statement.</param>

        /// <returns>The number of row deleted.</returns>

        /// <remarks>

        /// When executing this method, the statement is immediately executed on the database provider

        /// and is not part of the change tracking system.  Also, changes will not be reflected on

        /// any entities that have already been materialized in the current context.       

        /// </remarks>

        public static int Delete<TEntity>(

            this ObjectSet<TEntity> source,

            IQueryable<TEntity> query)

            where TEntity : class

        {

            if (source == null)

                throw new ArgumentNullException("source");

 

            if (query == null)

                throw new ArgumentNullException("query");

 

            ObjectContext objectContext = source.Context;

            if (objectContext == null)

                throw new ArgumentException("The ObjectContext for the source query can not be null.", "source");

 

            EntityMap entityMap = source.GetEntityMap<TEntity>();

            if (entityMap == null)

                throw new ArgumentException("Could not load the entity mapping information for the source ObjectSet.", "source");

 

            ObjectQuery<TEntity> objectQuery = query.ToObjectQuery();

            if (objectQuery == null)

                throw new ArgumentException("The query must be of type ObjectQuery or DbQuery.", "query");

 

            return Delete(objectContext, entityMap, objectQuery);

        }

 

        /// <summary>

        /// Executes a delete statement using an expression to filter the rows to be deleted.

        /// </summary>

        /// <typeparam name="TEntity">The type of the entity.</typeparam>

        /// <param name="source">The source used to determine the table to delete from.</param>

        /// <param name="filterExpression">The filter expression used to generate the where clause for the delete statement.</param>

        /// <returns>The number of row deleted.</returns>

        /// <example>Delete all users with email domain @test.com.

        /// <code><![CDATA[

        /// var db = new TrackerEntities();

        /// string emailDomain = "@test.com";

        /// int count = db.Users.Delete(u => u.Email.EndsWith(emailDomain));

        /// ]]></code>

        /// </example>

        /// <remarks>

        /// When executing this method, the statement is immediately executed on the database provider

        /// and is not part of the change tracking system.  Also, changes will not be reflected on

        /// any entities that have already been materialized in the current context.       

        /// </remarks>

        public static int Delete<TEntity>(

            this ObjectSet<TEntity> source,

            Expression<Func<TEntity, bool>> filterExpression)

            where TEntity : class

        {

            if (source == null)

                throw new ArgumentNullException("source");

            if (filterExpression == null)

                throw new ArgumentNullException("filterExpression");

 

            return source.Delete(source.Where(filterExpression));

        }

 

        /// <summary>

        /// Executes a delete statement using the query to filter the rows to be deleted.

        /// </summary>

        /// <typeparam name="TEntity">The type of the entity.</typeparam>

        /// <param name="source">The source used to determine the table to delete from.</param>

        /// <param name="query">The IQueryable used to generate the where clause for the delete statement.</param>

        /// <returns>The number of row deleted.</returns>

        /// <remarks>

        /// When executing this method, the statement is immediately executed on the database provider

        /// and is not part of the change tracking system.  Also, changes will not be reflected on

        /// any entities that have already been materialized in the current context.       

        /// </remarks>

        public static int Delete<TEntity>(

           this DbSet<TEntity> source,

           IQueryable<TEntity> query)

           where TEntity : class

        {

            if (source == null)

                throw new ArgumentNullException("source");

            if (query == null)

                throw new ArgumentNullException("query");

 

            ObjectQuery<TEntity> sourceQuery = source.ToObjectQuery();

            if (sourceQuery == null)

                throw new ArgumentException("The query must be of type ObjectQuery or DbQuery.", "source");

 

            ObjectContext objectContext = sourceQuery.Context;

            if (objectContext == null)

                throw new ArgumentException("The ObjectContext for the source query can not be null.", "source");

 

            EntityMap entityMap = sourceQuery.GetEntityMap<TEntity>();

            if (entityMap == null)

                throw new ArgumentException("Could not load the entity mapping information for the source ObjectSet.", "source");

 

            ObjectQuery<TEntity> objectQuery = query.ToObjectQuery();

            if (objectQuery == null)

                throw new ArgumentException("The query must be of type ObjectQuery or DbQuery.", "query");

 

            return Delete(objectContext, entityMap, objectQuery);

        }

 

        /// <summary>

        /// Executes a delete statement using an expression to filter the rows to be deleted.

        /// </summary>

        /// <typeparam name="TEntity">The type of the entity.</typeparam>

        /// <param name="source">The source used to determine the table to delete from.</param>

        /// <param name="filterExpression">The filter expression used to generate the where clause for the delete statement.</param>

        /// <returns>The number of row deleted.</returns>

        /// <example>Delete all users with email domain @test.com.

        /// <code><![CDATA[

        /// var db = new TrackerContext();

        /// string emailDomain = "@test.com";

        /// int count = db.Users.Delete(u => u.Email.EndsWith(emailDomain));

        /// ]]></code>

        /// </example>

        /// <remarks>

        /// When executing this method, the statement is immediately executed on the database provider

        /// and is not part of the change tracking system.  Also, changes will not be reflected on

        /// any entities that have already been materialized in the current context.       

        /// </remarks>

        public static int Delete<TEntity>(

            this DbSet<TEntity> source,

            Expression<Func<TEntity, bool>> filterExpression)

            where TEntity : class

        {

            if (source == null)

                throw new ArgumentNullException("source");

            if (filterExpression == null)

                throw new ArgumentNullException("filterExpression");

 

            return source.Delete(source.Where(filterExpression));

        }

 

 

        /// <summary>

        /// Executes an update statement using the query to filter the rows to be updated.

        /// </summary>

        /// <typeparam name="TEntity">The type of the entity.</typeparam>

        /// <param name="source">The source used to determine the table to update.</param>

        /// <param name="query">The query used to generate the where clause.</param>

        /// <param name="updateExpression">The MemberInitExpression used to indicate what is updated.</param>

        /// <returns>The number of row updated.</returns>

        /// <remarks>

        /// When executing this method, the statement is immediately executed on the database provider

        /// and is not part of the change tracking system.  Also, changes will not be reflected on

        /// any entities that have already been materialized in the current context.       

        /// </remarks>

        public static int Update<TEntity>(

            this ObjectSet<TEntity> source,

            IQueryable<TEntity> query,

            Expression<Func<TEntity, TEntity>> updateExpression)

            where TEntity : class

        {

            if (source == null)

                throw new ArgumentNullException("source");

            if (query == null)

                throw new ArgumentNullException("query");

            if (updateExpression == null)

                throw new ArgumentNullException("updateExpression");

 

            ObjectContext objectContext = source.Context;

            if (objectContext == null)

                throw new ArgumentException("The ObjectContext for the source query can not be null.", "source");

 

            EntityMap entityMap = source.GetEntityMap<TEntity>();

            if (entityMap == null)

                throw new ArgumentException("Could not load the entity mapping information for the source ObjectSet.", "source");

 

            ObjectQuery<TEntity> objectQuery = query.ToObjectQuery();

            if (objectQuery == null)

                throw new ArgumentException("The query must be of type ObjectQuery or DbQuery.", "query");

 

            return Update(objectContext, entityMap, objectQuery, updateExpression);

        }

 

        /// <summary>

        /// Executes an update statement using an expression to filter the rows that are updated.

        /// </summary>

        /// <typeparam name="TEntity">The type of the entity.</typeparam>

        /// <param name="source">The source used to determine the table to update.</param>

        /// <param name="filterExpression">The filter expression used to generate the where clause.</param>

        /// <param name="updateExpression">The MemberInitExpression used to indicate what is updated.</param>

        /// <returns>The number of row updated.</returns>

        /// <example>Update all users in the test.com domain to be inactive.

        /// <code><![CDATA[

        /// var db = new TrackerEntities();

        /// string emailDomain = "@test.com";

        /// int count = db.Users.Update(

        ///   u => u.Email.EndsWith(emailDomain),

        ///   u => new User { IsApproved = false, LastActivityDate = DateTime.Now });

        /// ]]></code>

        /// </example>

        /// <remarks>

        /// When executing this method, the statement is immediately executed on the database provider

        /// and is not part of the change tracking system.  Also, changes will not be reflected on

        /// any entities that have already been materialized in the current context.       

        /// </remarks>

        public static int Update<TEntity>(

            this ObjectSet<TEntity> source,

            Expression<Func<TEntity, bool>> filterExpression,

            Expression<Func<TEntity, TEntity>> updateExpression)

            where TEntity : class

        {

            if (source == null)

                throw new ArgumentNullException("source");

            if (filterExpression == null)

                throw new ArgumentNullException("filterExpression");

 

            return source.Update(source.Where(filterExpression), updateExpression);

        }

 

        /// <summary>

        /// Executes an update statement using the query to filter the rows to be updated.

        /// </summary>

        /// <typeparam name="TEntity">The type of the entity.</typeparam>

        /// <param name="source">The source used to determine the table to update.</param>

        /// <param name="query">The query used to generate the where clause.</param>

        /// <param name="updateExpression">The MemberInitExpression used to indicate what is updated.</param>

        /// <returns>The number of row updated.</returns>

        /// <remarks>

        /// When executing this method, the statement is immediately executed on the database provider

        /// and is not part of the change tracking system.  Also, changes will not be reflected on

        /// any entities that have already been materialized in the current context.       

        /// </remarks>

        public static int Update<TEntity>(

            this DbSet<TEntity> source,

            IQueryable<TEntity> query,

            Expression<Func<TEntity, TEntity>> updateExpression)

            where TEntity : class

        {

            if (source == null)

                throw new ArgumentNullException("source");

            if (query == null)

                throw new ArgumentNullException("query");

            if (updateExpression == null)

                throw new ArgumentNullException("updateExpression");

 

            ObjectQuery<TEntity> sourceQuery = source.ToObjectQuery();

            if (sourceQuery == null)

                throw new ArgumentException("The query must be of type ObjectQuery or DbQuery.", "source");

 

            ObjectContext objectContext = sourceQuery.Context;

            if (objectContext == null)

                throw new ArgumentException("The ObjectContext for the source query can not be null.", "source");

 

            EntityMap entityMap = sourceQuery.GetEntityMap<TEntity>();

            if (entityMap == null)

                throw new ArgumentException("Could not load the entity mapping information for the source.", "source");

 

            ObjectQuery<TEntity> objectQuery = query.ToObjectQuery();

            if (objectQuery == null)

                throw new ArgumentException("The query must be of type ObjectQuery or DbQuery.", "query");

 

            return Update(objectContext, entityMap, objectQuery, updateExpression);

        }

 

        /// <summary>

        /// Executes an update statement using an expression to filter the rows that are updated.

        /// </summary>

        /// <typeparam name="TEntity">The type of the entity.</typeparam>

        /// <param name="source">The source used to determine the table to update.</param>

        /// <param name="filterExpression">The filter expression used to generate the where clause.</param>

        /// <param name="updateExpression">The MemberInitExpression used to indicate what is updated.</param>

        /// <returns>The number of row updated.</returns>

        /// <example>Update all users in the test.com domain to be inactive.

        /// <code><![CDATA[

        /// var db = new TrackerContext();

        /// string emailDomain = "@test.com";

        /// int count = db.Users.Update(

        ///   u => u.Email.EndsWith(emailDomain),

        ///   u => new User { IsApproved = false, LastActivityDate = DateTime.Now });

        /// ]]></code>

        /// </example>

        /// <remarks>

        /// When executing this method, the statement is immediately executed on the database provider

        /// and is not part of the change tracking system.  Also, changes will not be reflected on

        /// any entities that have already been materialized in the current context.       

        /// </remarks>

        public static int Update<TEntity>(

            this DbSet<TEntity> source,

            Expression<Func<TEntity, bool>> filterExpression,

            Expression<Func<TEntity, TEntity>> updateExpression)

            where TEntity : class

        {

            if (source == null)

                throw new ArgumentNullException("source");

            if (filterExpression == null)

                throw new ArgumentNullException("filterExpression");

 

            return source.Update(source.Where(filterExpression), updateExpression);

        }

 

 

        private static int Delete<TEntity>(ObjectContext objectContext, EntityMap entityMap, ObjectQuery<TEntity> query)

            where TEntity : class

        {

            DbConnection deleteConnection = null;

            DbTransaction deleteTransaction = null;

            DbCommand deleteCommand = null;

            bool ownConnection = false;

            bool ownTransaction = false;

 

            try

            {

                // get store connection and transaction

                var store = GetStore(objectContext);

                deleteConnection = store.Item1;

                deleteTransaction = store.Item2;

 

                if (deleteConnection.State != ConnectionState.Open)

                {

                    deleteConnection.Open();

                    ownConnection = true;

                }

 

                if (deleteTransaction == null)

                {

                    deleteTransaction = deleteConnection.BeginTransaction();

                    ownTransaction = true;

                }

 

 

                deleteCommand = deleteConnection.CreateCommand();

                deleteCommand.Transaction = deleteTransaction;

                if (objectContext.CommandTimeout.HasValue)

                    deleteCommand.CommandTimeout = objectContext.CommandTimeout.Value;

 

                var innerSelect = GetSelectSql(query, entityMap, deleteCommand);

 

                var sqlBuilder = new StringBuilder(innerSelect.Length * 2);

 

                sqlBuilder.Append("DELETE ");

                sqlBuilder.Append(entityMap.TableName);

                sqlBuilder.AppendLine();

 

                sqlBuilder.AppendFormat("FROM {0} AS j0 INNER JOIN (", entityMap.TableName);

                sqlBuilder.AppendLine();

                sqlBuilder.AppendLine(innerSelect);

                sqlBuilder.Append(") AS j1 ON (");

 

                bool wroteKey = false;

                foreach (var keyMap in entityMap.KeyMaps)

                {

                    if (wroteKey)

                        sqlBuilder.Append(" AND ");

 

                    sqlBuilder.AppendFormat("j0.{0} = j1.{0}", keyMap.ColumnName);

                    wroteKey = true;

                }

                sqlBuilder.Append(")");

 

                deleteCommand.CommandText = sqlBuilder.ToString();

 

                int result = deleteCommand.ExecuteNonQuery();

 

                // only commit if created transaction

                if (ownTransaction)

                    deleteTransaction.Commit();

 

                return result;

            }

            finally

            {

                if (deleteCommand != null)

                    deleteCommand.Dispose();

                 

                if (deleteTransaction != null && ownTransaction)

                    deleteTransaction.Dispose();

 

                if (deleteConnection != null && ownConnection)

                    deleteConnection.Close();

            }

        }

 

        private static int Update<TEntity>(ObjectContext objectContext, EntityMap entityMap, ObjectQuery<TEntity> query, Expression<Func<TEntity, TEntity>> updateExpression)

            where TEntity : class

        {

            DbConnection updateConnection = null;

            DbTransaction updateTransaction = null;

            DbCommand updateCommand = null;

            bool ownConnection = false;

            bool ownTransaction = false;

 

            try

            {

                // get store connection and transaction

                var store = GetStore(objectContext);

                updateConnection = store.Item1;

                updateTransaction = store.Item2;

 

                if (updateConnection.State != ConnectionState.Open)

                {

                    updateConnection.Open();

                    ownConnection = true;

                }

 

                // use existing transaction or create new

                if (updateTransaction == null)

                {

                    updateTransaction = updateConnection.BeginTransaction();

                    ownTransaction = true;

                }

 

                updateCommand = updateConnection.CreateCommand();

                updateCommand.Transaction = updateTransaction;

                if (objectContext.CommandTimeout.HasValue)

                    updateCommand.CommandTimeout = objectContext.CommandTimeout.Value;

 

                var innerSelect = GetSelectSql(query, entityMap, updateCommand);

                var sqlBuilder = new StringBuilder(innerSelect.Length * 2);

 

                sqlBuilder.Append("UPDATE ");

                sqlBuilder.Append(entityMap.TableName);

                sqlBuilder.AppendLine(" SET ");

 

                var memberInitExpression = updateExpression.Body as MemberInitExpression;

                if (memberInitExpression == null)

                    throw new ArgumentException("The update expression must be of type MemberInitExpression.", "updateExpression");

 

                int nameCount = 0;

                bool wroteSet = false;

                foreach (MemberBinding binding in memberInitExpression.Bindings)

                {

                    if (wroteSet)

                        sqlBuilder.AppendLine(", ");

 

                    string propertyName = binding.Member.Name;

                    string columnName = entityMap.PropertyMaps

                        .Where(p => p.PropertyName == propertyName)

                        .Select(p => p.ColumnName)

                        .FirstOrDefault();

 

                    string parameterName = "p__update__" + nameCount++;

 

                    var memberAssignment = binding as MemberAssignment;

                    if (memberAssignment == null)

                        throw new ArgumentException("The update expression MemberBinding must only by type MemberAssignment.", "updateExpression");

 

                    object value;

                    if (memberAssignment.Expression.NodeType == ExpressionType.Constant)

                    {

                        var constantExpression = memberAssignment.Expression as ConstantExpression;

                        if (constantExpression == null)

                            throw new ArgumentException("The MemberAssignment expression is not a ConstantExpression.", "updateExpression");

 

                        value = constantExpression.Value;

                    }

                    else

                    {

                        LambdaExpression lambda = Expression.Lambda(memberAssignment.Expression, null);

                        value = lambda.Compile().DynamicInvoke();

                    }

 

                    var parameter = updateCommand.CreateParameter();

                    parameter.ParameterName = parameterName;

                    parameter.Value = value;

                    updateCommand.Parameters.Add(parameter);

 

                    sqlBuilder.AppendFormat("{0} = @{1}", columnName, parameterName);

                    wroteSet = true;

                }

 

                sqlBuilder.AppendLine(" ");

                sqlBuilder.AppendFormat("FROM {0} AS j0 INNER JOIN (", entityMap.TableName);

                sqlBuilder.AppendLine();

                sqlBuilder.AppendLine(innerSelect);

                sqlBuilder.Append(") AS j1 ON (");

 

                bool wroteKey = false;

                foreach (var keyMap in entityMap.KeyMaps)

                {

                    if (wroteKey)

                        sqlBuilder.Append(" AND ");

 

                    sqlBuilder.AppendFormat("j0.{0} = j1.{0}", keyMap.ColumnName);

                    wroteKey = true;

                }

                sqlBuilder.Append(")");

 

                updateCommand.CommandText = sqlBuilder.ToString();

 

                int result = updateCommand.ExecuteNonQuery();

 

                // only commit if created transaction

                if (ownTransaction)

                    updateTransaction.Commit();

 

                return result;

            }

            finally

            {

                if (updateCommand != null)

                    updateCommand.Dispose();

                if (updateTransaction != null && ownTransaction)

                    updateTransaction.Dispose();

                if (updateConnection != null && ownConnection)

                    updateConnection.Close();

            }

        }

 

        private static Tuple<DbConnection, DbTransaction> GetStore(ObjectContext objectContext)

        {

            DbConnection dbConnection = objectContext.Connection;

            var entityConnection = dbConnection as EntityConnection;

 

            // by-pass entity connection

            if (entityConnection == null)

                return new Tuple<DbConnection, DbTransaction>(dbConnection, null);

 

            DbConnection connection = entityConnection.StoreConnection;

 

            // get internal transaction

            dynamic connectionProxy = new DynamicProxy(entityConnection);

            dynamic entityTransaction = connectionProxy.CurrentTransaction;

            if (entityTransaction == null)

                return new Tuple<DbConnection, DbTransaction>(connection, null);

 

            DbTransaction transaction = entityTransaction.StoreTransaction;

            return new Tuple<DbConnection, DbTransaction>(connection, transaction);

        }

 

        private static string GetSelectSql<TEntity>(ObjectQuery<TEntity> query, EntityMap entityMap, DbCommand command)

            where TEntity : class

        {

            // changing query to only select keys

            var selector = new StringBuilder(50);

            selector.Append("new(");

            foreach (var propertyMap in entityMap.KeyMaps)

            {

                if (selector.Length > 4)

                    selector.Append((", "));

 

                selector.Append(propertyMap.PropertyName);

            }

            selector.Append(")");

 

            var selectQuery = DynamicQueryable.Select(query, selector.ToString());

            var objectQuery = selectQuery as ObjectQuery;

 

            if (objectQuery == null)

                throw new ArgumentException("The query must be of type ObjectQuery.", "query");

 

            string innerJoinSql = objectQuery.ToTraceString();

 

            // create parameters

            foreach (var objectParameter in objectQuery.Parameters)

            {

                var parameter = command.CreateParameter();

                parameter.ParameterName = objectParameter.Name;

                parameter.Value = objectParameter.Value;

 

                command.Parameters.Add(parameter);

            }

 

            return innerJoinSql;

        }

 

    }

}