/// <summary> /// Materializes the results of the given command. /// </summary> /// <param name="command">Command to execute.</param> /// <param name="commandBehavior">Command behavior to use when executing the command.</param> /// <returns>Shaped results.</returns> public IEnumerable <T> Materialize(DbCommand command, CommandBehavior commandBehavior) { EnitityUtility.CheckArgumentNotNull(command, "command"); using (command.Connection.CreateConnectionScope()) { using (DbDataReader reader = command.ExecuteReader(commandBehavior)) { foreach (T element in this.Materialize(reader)) { yield return(element); } } } }
public Expression OptimizeMethodCall(ReadOnlyCollection <string> fieldNames, ParameterExpression recordParameter, MethodCallExpression methodCall) { EnitityUtility.CheckArgumentNotNull(fieldNames, "fieldNames"); EnitityUtility.CheckArgumentNotNull(methodCall, "methodCall"); MethodPattern pattern = GetMethodPattern(methodCall); if (pattern == MethodPattern.Unsupported) { // Cannot optimize this method. return(methodCall); } // if the input record (arguments[0]) is not the record parameter, we cannot // leverage field names to optimize the shaper if (recordParameter != methodCall.Arguments[0]) { return(methodCall); } Expression ordinalExpression; if (!TryGetOrdinalExpression(fieldNames, methodCall, pattern, out ordinalExpression)) { return(methodCall); } Type returnType = methodCall.Method.GetGenericArguments().Single(); bool canAssignNull = returnType.IsClass || (returnType.IsGenericType && typeof(Nullable <>) == returnType.GetGenericTypeDefinition()); // argument[0].GetValue(ordinal) Expression result = Expression.Call(methodCall.Arguments[0], s_getValue, ordinalExpression); if (canAssignNull) { // (returnType)(argument[0].IsDBNull(ordinal) ? null : result) result = Expression.Condition( Expression.Call(methodCall.Arguments[0], s_isDBNull, ordinalExpression), Expression.Constant(null, typeof(object)), result); } // (returnType)result result = Expression.Convert(result, returnType); return(result); }
/// <summary> /// Materializes rows in the given reader. /// </summary> /// <param name="reader">Results to materialize.</param> /// <returns>Shaped results.</returns> public IEnumerable <T> Materialize(DbDataReader reader) { EnitityUtility.CheckArgumentNotNull(reader, "reader"); bool first = true; while (reader.Read()) { if (first) { InitializeShaper(reader); first = false; } yield return(this.shaperDelegate(reader)); } yield break; }
public static bool IsGenericAssignableFrom(this Type toType, Type fromType, out Type[] genericArguments) { EnitityUtility.CheckArgumentNotNull(toType, "toType"); EnitityUtility.CheckArgumentNotNull(fromType, "fromType"); if (!toType.IsGenericTypeDefinition || fromType.IsGenericTypeDefinition) { // if 'toType' is not generic or 'fromType' is generic, the assignment pattern // is not matched (e.g. toType<genericArguments>.IsAssignableFrom(fromType) // cannot be satisfied) genericArguments = null; return(false); } if (toType.IsInterface) { // if the toType is an interface, simply look for the interface implementation in fromType foreach (Type interfaceCandidate in fromType.GetInterfaces()) { if (interfaceCandidate.IsGenericType && interfaceCandidate.GetGenericTypeDefinition() == toType) { genericArguments = interfaceCandidate.GetGenericArguments(); return(true); } } } else { // if toType is not an interface, check hierarchy for match while (fromType != null) { if (fromType.IsGenericType && fromType.GetGenericTypeDefinition() == toType) { genericArguments = fromType.GetGenericArguments(); return(true); } fromType = fromType.BaseType; } } genericArguments = null; return(false); }
/// <summary> /// Removes an entity from the EntitySet. The entity will be deleted /// when ObjectContext.SaveChanges is called. /// </summary> /// <param name="entity">Entity to delete.</param> public void DeleteOnSaveChanges(T entity) { EnitityUtility.CheckArgumentNotNull(((object)entity), "entity"); // check that the entity actually exists first ObjectStateEntry stateEntry; if (!this.Context.ObjectStateManager.TryGetObjectStateEntry(entity, out stateEntry)) { //throw new ArgumentException(Messages.UntrackedEntity, "entity"); } // now check that the entity belongs to the current entity set if (this.metadata != stateEntry.EntitySet) { //throw new ArgumentException(Messages.DeletingFromWrongSet, "entity"); } this.Context.DeleteObject(entity); }
/// <summary> /// Gets key value for a non-compound reference key (e.g. one foreign key component). /// </summary> /// <typeparam name="T">EntityReference element type</typeparam> /// <param name="entityReference">Entity reference.</param> /// <returns>Key value from entity reference.</returns> public static object GetKey <T>(this EntityReference <T> entityReference) where T : class, IEntityWithRelationships { EnitityUtility.CheckArgumentNotNull(entityReference, "entityReference"); EntityKey entityKey = entityReference.EntityKey; if (null == entityKey) { if (entityReference.GetTargetEntitySet().ElementType.KeyMembers.Count != 1) { //throw new InvalidOperationException(Messages.SimpleKeyOnly); } return(null); } var entityKeyValues = entityKey.EntityKeyValues; if (entityKeyValues.Length != 1) { //throw new InvalidOperationException(Messages.SimpleKeyOnly); } return(entityKeyValues[0].Value); }
/// <summary> /// Gets a component of a key value for a (potentially compound) reference key. /// </summary> /// <typeparam name="T">EntityReference element type</typeparam> /// <param name="entityReference">Entity reference.</param> /// <param name="keyOrdinal">Index of the key component (with respect to the element type's /// EntityType.KeyMembers).</param> /// <returns>Key component value from entity reference.</returns> public static object GetKey <T>(this EntityReference <T> entityReference, int keyOrdinal) where T : class, IEntityWithRelationships { EnitityUtility.CheckArgumentNotNull(entityReference, "entityReference"); if (keyOrdinal < 0) { throw new ArgumentOutOfRangeException("keyOrdinal"); } EntityKey entityKey = entityReference.EntityKey; if (null == entityKey) { if (entityReference.GetTargetEntitySet().ElementType.KeyMembers.Count <= keyOrdinal) { throw new ArgumentOutOfRangeException("keyOrdinal"); } return(null); } if (entityKey.EntityKeyValues.Length <= keyOrdinal) { throw new ArgumentOutOfRangeException("keyOrdinal"); } return(entityKey.EntityKeyValues[keyOrdinal].Value); }
///// <summary> ///// Creates a store command based on the connection used by given object context. ///// </summary> ///// <param name="context">Object context.</param> ///// <param name="commandText">Command text.</param> ///// <param name="parameters">Parameters to pass to the store command.</param> ///// <returns>Store command.</returns> //public static DbCommand CreateStoreCommand(ObjectContext context, string commandText, params object[] parameters) //{ // return CreateStoreCommand(context, commandText, CommandType.Text, parameters); //} /// <summary> /// Creates a store command based on the connection used by given object context. /// </summary> /// <param name="context">Object context.</param> /// <param name="commandText">Command text.</param> /// <param name="commandType">Command type.</param> /// <param name="parameters">Parameters to pass to the store command.</param> /// <returns>Store command.</returns> public static DbCommand CreateStoreCommand(ObjectContext context, string commandText, CommandType commandType, params object[] parameters) { EnitityUtility.CheckArgumentNotNull(context, "context"); EntityConnection entityConnection = (EntityConnection)context.Connection; DbConnection storeConnection = entityConnection.StoreConnection; DbCommand storeCommand = storeConnection.CreateCommand(); // setup command storeCommand.CommandText = commandText; storeCommand.CommandType = commandType; if (null != parameters) { storeCommand.Parameters.AddRange(parameters); } // pass through command timeout as appropriate if (context.CommandTimeout.HasValue) { storeCommand.CommandTimeout = context.CommandTimeout.Value; } return(storeCommand); }
/// <summary> /// Attaches an existing entity to the current entity set. /// </summary> /// <param name="entity">Entity to attach.</param> public void Attach(T entity) { EnitityUtility.CheckArgumentNotNull(((object)entity), "entity"); this.Context.AttachTo(this.QualifiedEntitySetName, entity); }
/// <summary> /// Tracks a new entity for insertion when ObjectContext.SaveChanges is called. /// </summary> /// <param name="entity">Entity to insert.</param> public void InsertOnSaveChanges(T entity) { EnitityUtility.CheckArgumentNotNull(((object)entity), "entity"); this.Context.AddObject(this.QualifiedEntitySetName, entity); }
/// <summary> /// Expands all InvocationExpression instances within the given query. /// </summary> /// <param name="query">Query to expand.</param> /// <returns>Expanded query.</returns> public static IQueryable <TElement> ExpandInvocations <TElement>(this IQueryable <TElement> query) { EnitityUtility.CheckArgumentNotNull(query, "query"); return(query.Provider.CreateQuery <TElement>(query.Expression.ExpandInvocations())); }
/// <summary> /// Returns a handle on an IDisposable that can be used to safely control the lifetime /// of an open connection. If the connection is closed, it will be opened immediately /// and closed when the result of this method (the scope) is disposed. If the connection is already /// open, it remains open. /// <code> /// // Example with CreateConnectionScope /// using (command.Connection.CreateConnectionScope()) /// { /// command.ExecuteNonQuery(); /// } /// /// // Example without /// bool connectionOpened = command.Connection.State == ConnectionState.Closed; /// if (connectionOpened) /// { /// command.Connection.Open(); /// } /// try /// { /// command.ExecuteNonQuery(); /// } /// finally /// { /// if (connectionOpened && command.Connection.State == ConnectionState.Open) /// { /// command.Connection.Close(); /// } /// } /// </code> /// </summary> /// <param name="connection">Connection to open.</param> /// <returns>Scope closing the connection on dispose.</returns> public static IDisposable CreateConnectionScope(this DbConnection connection) { EnitityUtility.CheckArgumentNotNull(connection, "connection"); return(new OpenConnectionLifetime(connection)); }