private void Validate(int index, object value) { Check.NotNull <object>(value, nameof(value)); EntityParameter entityParameter = (EntityParameter)value; object obj = entityParameter.CompareExchangeParent((object)this, (object)null); if (obj != null) { if (this != obj) { throw new ArgumentException(Strings.EntityParameterContainedByAnotherCollection); } if (index != this.IndexOf(value)) { throw new ArgumentException(Strings.EntityParameterContainedByAnotherCollection); } } if (entityParameter.ParameterName.Length != 0) { return; } index = 1; string parameterName; do { parameterName = "Parameter" + index.ToString((IFormatProvider)CultureInfo.CurrentCulture); ++index; }while (-1 != this.IndexOf(parameterName)); entityParameter.ParameterName = parameterName; }
/// <summary> /// Add a EntityParameter with the given name and value to the collection /// </summary> /// <param name="parameterName">The name of the parameter to add</param> /// <param name="value">The value of the parameter to add</param> /// <returns>The index of the new parameter within the collection</returns> public EntityParameter AddWithValue(string parameterName, object value) { var param = new EntityParameter(); param.ParameterName = parameterName; param.Value = value; return Add(param); }
/// <summary> /// Add a EntityParameter with the given name and value to the collection /// </summary> /// <param name="parameterName"> The name of the parameter to add </param> /// <param name="value"> The value of the parameter to add </param> /// <returns> The index of the new parameter within the collection </returns> public EntityParameter AddWithValue(string parameterName, object value) { var param = new EntityParameter(); param.ParameterName = parameterName; param.Value = value; return(Add(param)); }
private void RemoveIndex(int index) { List <EntityParameter> innerList = this.InnerList; EntityParameter entityParameter = innerList[index]; innerList.RemoveAt(index); entityParameter.ResetParent(); }
/// <summary> /// Adds a value to the end of the <see cref="T:System.Data.Entity.Core.EntityClient.EntityParameterCollection" />. /// </summary> /// <returns> /// A <see cref="T:System.Data.Entity.Core.EntityClient.EntityParameter" /> object. /// </returns> /// <param name="parameterName">The name of the parameter.</param> /// <param name="value">The value to be added.</param> public EntityParameter AddWithValue(string parameterName, object value) { EntityParameter entityParameter = new EntityParameter(); entityParameter.ParameterName = parameterName; entityParameter.Value = value; return(this.Add(entityParameter)); }
private void Replace(int index, object newValue) { List <EntityParameter> innerList = this.InnerList; EntityParameterCollection.ValidateType(newValue); this.Validate(index, newValue); EntityParameter entityParameter = innerList[index]; innerList[index] = (EntityParameter)newValue; entityParameter.ResetParent(); }
private EntityParameter(EntityParameter source) : this() { source.CloneHelper(this); ICloneable cloneable = this._value as ICloneable; if (cloneable == null) { return; } this._value = cloneable.Clone(); }
private EntityParameter(EntityParameter source) : this() { DebugCheck.NotNull(source); source.CloneHelper(this); var cloneable = (_value as ICloneable); if (null != cloneable) { _value = cloneable.Clone(); } }
private void CloneHelper(EntityParameter destination) { destination._value = this._value; destination._direction = this._direction; destination._size = this._size; destination._sourceColumn = this._sourceColumn; destination._sourceVersion = this._sourceVersion; destination._sourceColumnNullMapping = this._sourceColumnNullMapping; destination._isNullable = this._isNullable; destination._parameterName = this._parameterName; destination._dbType = this._dbType; destination._edmType = this._edmType; destination._precision = this._precision; destination._scale = this._scale; }
/// <summary> /// Copies all the elements of the current <see cref="T:System.Data.Entity.Core.EntityClient.EntityParameterCollection" /> to the specified /// <see /// cref="T:System.Data.Entity.Core.EntityClient.EntityParameterCollection" /> /// starting at the specified destination index. /// </summary> /// <param name="array"> /// The <see cref="T:System.Data.Entity.Core.EntityClient.EntityParameterCollection" /> that is the destination of the elements copied from the current /// <see /// cref="T:System.Data.Entity.Core.EntityClient.EntityParameterCollection" /> /// . /// </param> /// <param name="index"> /// A 32-bit integer that represents the index in the /// <see /// cref="T:System.Data.Entity.Core.EntityClient.EntityParameterCollection" /> /// at which copying starts. /// </param> public void CopyTo(EntityParameter[] array, int index) { CopyTo((Array)array, index); }
/// <summary> /// Adds an array of <see cref="T:System.Data.Entity.Core.EntityClient.EntityParameter" /> values to the end of the /// <see /// cref="T:System.Data.Entity.Core.EntityClient.EntityParameterCollection" /> /// . /// </summary> /// <param name="values"> /// The <see cref="T:System.Data.Entity.Core.EntityClient.EntityParameter" /> values to add. /// </param> public void AddRange(EntityParameter[] values) { AddRange((Array)values); }
/// <summary> /// Clones this parameter object /// </summary> /// <returns>The new cloned object</returns> private void CloneHelper(EntityParameter destination) { destination._value = _value; destination._direction = _direction; destination._size = _size; destination._sourceColumn = _sourceColumn; destination._sourceVersion = _sourceVersion; destination._sourceColumnNullMapping = _sourceColumnNullMapping; destination._isNullable = _isNullable; destination._parameterName = _parameterName; destination._dbType = _dbType; destination._edmType = _edmType; destination._precision = _precision; destination._scale = _scale; }
private EntityParameter(EntityParameter source) : this() { Contract.Requires(source != null); source.CloneHelper(this); var cloneable = (_value as ICloneable); if (null != cloneable) { _value = cloneable.Clone(); } }
/// <summary> /// Add a EntityParameter to the collection /// </summary> /// <param name="value"> The parameter to add to the collection </param> /// <returns> The index of the new parameter within the collection </returns> public EntityParameter Add(EntityParameter value) { Add((object)value); return(value); }
/// <summary> /// Add a EntityParameter with the given value to the collection at a location indicated by the index /// </summary> /// <param name="index"> The index at which the parameter is to be inserted </param> /// <param name="value"> The value of the parameter </param> public void Insert(int index, EntityParameter value) { Insert(index, (object)value); }
/// <summary> /// Removes the specified <see cref="T:System.Data.Entity.Core.EntityClient.EntityParameter" /> from the collection. /// </summary> /// <param name="value"> /// A <see cref="T:System.Data.Entity.Core.EntityClient.EntityParameter" /> object to remove from the collection. /// </param> /// <exception cref="T:System.InvalidCastException"> /// The parameter is not a <see cref="T:System.Data.Entity.Core.EntityClient.EntityParameter" />. /// </exception> /// <exception cref="T:System.SystemException">The parameter does not exist in the collection. </exception> public void Remove(EntityParameter value) { Remove((object)value); }
private static int ValueSize(object value) { return(EntityParameter.ValueSizeCore(value)); }
public ActionResult EntitySQL(int id = 0) { string esqlQuery = @"SELECT VALUE customers FROM AdventureWorksEntities.Customers AS customers WHERE customers.CustomerID == @id"; var customers = new List<Customer2>(); using(var conn = new EntityConnection("name=AdventureWorksEntities")) { conn.Open(); using(var cmd = conn.CreateCommand()) { cmd.CommandText = esqlQuery; var param = new EntityParameter { ParameterName = "id", Value = id }; cmd.Parameters.Add(param); using(var reader = cmd.ExecuteReader(System.Data.CommandBehavior.SequentialAccess)) { while (reader.Read()) { var customer = new Customer2 { CustomerID = int.Parse(reader["CustomerID"].ToString()), CustomerName = reader["FirstName"] + " " + reader["MiddleName"] + " " + reader["LastName"] }; customers.Add(customer); } } } conn.Close(); } return View(customers); }
public void Executes_in_a_transaction_using_ExecutionStrategy_clears_parameters_for_retry() { var dbCommandMock = new Mock<DbCommand>(); dbCommandMock.Protected().Setup<Task<DbDataReader>>( "ExecuteDbDataReaderAsync", ItExpr.IsAny<CommandBehavior>(), ItExpr.IsAny<CancellationToken>()) .Throws(new InvalidOperationException("Foo")); var parameter = new EntityParameter(); var entityParameterCollection = new EntityParameterCollection(); dbCommandMock.Protected().SetupGet<DbParameterCollection>("DbParameterCollection").Returns(() => entityParameterCollection); var objectContext = Mock.Get(CreateObjectContext(dbCommandMock.Object)); var executionStrategyMock = new Mock<IDbExecutionStrategy>(); executionStrategyMock.Setup(m => m.RetriesOnFailure).Returns(true); executionStrategyMock.Setup( m => m.ExecuteAsync(It.IsAny<Func<Task<ObjectResult<object>>>>(), It.IsAny<CancellationToken>())) .Returns<Func<Task<ObjectResult<object>>>, CancellationToken>( (f, c) => { var result = f().Result; return Task.FromResult(result); }); MutableResolver.AddResolver<Func<IDbExecutionStrategy>>(key => (Func<IDbExecutionStrategy>)(() => executionStrategyMock.Object)); try { // To simulate the retry, we will execute the query twice. // and we validate that in both ocassions the same exception is received // if parameter were not cleared, the second call would fail with the // sql paramters contained in an another sql collection error. Assert.Equal( "Foo", Assert.Throws<InvalidOperationException>( () => ExceptionHelpers.UnwrapAggregateExceptions( () => objectContext.Object.ExecuteStoreQueryAsync<object>("Bar", parameter).GetAwaiter().GetResult())) .Message); Assert.Equal( "Foo", Assert.Throws<InvalidOperationException>( () => ExceptionHelpers.UnwrapAggregateExceptions( () => objectContext.Object.ExecuteStoreQueryAsync<object>("Bar", parameter).GetAwaiter().GetResult())) .Message); } finally { MutableResolver.ClearResolvers(); } }
/// <summary> /// Gets the location of the specified <see cref="T:System.Data.Entity.Core.EntityClient.EntityParameter" /> in the collection. /// </summary> /// <returns> /// The zero-based location of the specified <see cref="T:System.Data.Entity.Core.EntityClient.EntityParameter" /> that is a /// <see /// cref="T:System.Data.Entity.Core.EntityClient.EntityParameter" /> /// in the collection. Returns -1 when the object does not exist in the /// <see /// cref="T:System.Data.Entity.Core.EntityClient.EntityParameterCollection" /> /// . /// </returns> /// <param name="value"> /// The <see cref="T:System.Data.Entity.Core.EntityClient.EntityParameter" /> to find. /// </param> public int IndexOf(EntityParameter value) { return IndexOf((object)value); }
/// <summary> /// Remove a EntityParameter with the given value from the collection /// </summary> /// <param name="value"> The parameter to remove </param> public void Remove(EntityParameter value) { Remove((object)value); }
/// <summary> /// Inserts a <see cref="T:System.Data.Entity.Core.EntityClient.EntityParameter" /> object into the /// <see /// cref="T:System.Data.Entity.Core.EntityClient.EntityParameterCollection" /> /// at the specified index. /// </summary> /// <param name="index">The zero-based index at which value should be inserted.</param> /// <param name="value"> /// A <see cref="T:System.Data.Entity.Core.EntityClient.EntityParameter" /> object to be inserted in the /// <see /// cref="T:System.Data.Entity.Core.EntityClient.EntityParameterCollection" /> /// . /// </param> public void Insert(int index, EntityParameter value) { Insert(index, (object)value); }
public void Executes_in_a_transaction_using_ExecutionStrategy_clears_parameters_for_retry() { var dbCommandMock = new Mock<DbCommand>(); dbCommandMock.Setup(m => m.ExecuteNonQuery()).Throws(new InvalidOperationException("Foo")); var objectContextMock = Mock.Get(CreateObjectContext(dbCommandMock.Object)); var executionStrategyMock = new Mock<IDbExecutionStrategy>(); var parameter = new EntityParameter(); var entityParameterCollection = new EntityParameterCollection(); dbCommandMock.Protected().SetupGet<DbParameterCollection>("DbParameterCollection").Returns(() => entityParameterCollection); objectContextMock.Setup( m => m.ExecuteInTransaction(It.IsAny<Func<int>>(), It.IsAny<IDbExecutionStrategy>(), It.IsAny<bool>(), It.IsAny<bool>())) .Returns<Func<int>, IDbExecutionStrategy, bool, bool>( (f, t, s, r) => { var result = f(); return result; }); executionStrategyMock.Setup(m => m.Execute(It.IsAny<Func<int>>())) .Returns<Func<int>>( f => { var result = f(); return result; }); MutableResolver.AddResolver<Func<IDbExecutionStrategy>>( key => (Func<IDbExecutionStrategy>)(() => executionStrategyMock.Object)); try { // To simulate the retry, we will execute the query twice. // and we validate that in both ocassions the same exception is received // if parameter were not cleared, the second call would fail with the // sql paramters contained in an another sql collection error. Assert.Equal( "Foo", Assert.Throws<InvalidOperationException>( () => objectContextMock.Object.ExecuteStoreCommand("foo", parameter)).Message); Assert.Equal( "Foo", Assert.Throws<InvalidOperationException>( () => objectContextMock.Object.ExecuteStoreCommand("foo", parameter)).Message); } finally { MutableResolver.ClearResolvers(); } }
/// <summary> /// Adds the specified <see cref="T:System.Data.Entity.Core.EntityClient.EntityParameter" /> object to the /// <see /// cref="T:System.Data.Entity.Core.EntityClient.EntityParameterCollection" /> /// . /// </summary> /// <returns> /// A new <see cref="T:System.Data.Entity.Core.EntityClient.EntityParameter" /> object. /// </returns> /// <param name="value"> /// The <see cref="T:System.Data.Entity.Core.EntityClient.EntityParameter" /> to add to the collection. /// </param> /// <exception cref="T:System.ArgumentException"> /// The <see cref="T:System.Data.Entity.Core.EntityClient.EntityParameter" /> specified in the value parameter is already added to this or another /// <see /// cref="T:System.Data.Entity.Core.EntityClient.EntityParameterCollection" /> /// . /// </exception> /// <exception cref="T:System.InvalidCastException"> /// The parameter passed was not a <see cref="T:System.Data.Entity.Core.EntityClient.EntityParameter" />. /// </exception> /// <exception cref="T:System.ArgumentNullException">The value parameter is null. </exception> public EntityParameter Add(EntityParameter value) { Add((object)value); return value; }
/// <summary> /// Finds the index in the collection of the given parameter object /// </summary> /// <param name="value"> The parameter to search for </param> /// <returns> The index of the parameter, -1 if not found </returns> public int IndexOf(EntityParameter value) { return(IndexOf((object)value)); }