public void StoreConnection_state_mimics_EntityConnection_state_if_only_EntityConnection_is_used_without_txn() { var storeConnectionState = ConnectionState.Closed; var storeConnectionMock = new Mock <DbConnection>(MockBehavior.Strict); storeConnectionMock.Setup(m => m.OpenAsync(It.IsAny <CancellationToken>())).Callback( () => storeConnectionState = ConnectionState.Open).Returns(Task.FromResult(1)); storeConnectionMock.Setup(m => m.Close()).Callback(() => storeConnectionState = ConnectionState.Closed); storeConnectionMock.SetupGet(m => m.State).Returns(() => storeConnectionState); var metadataWorkspaceMock = new Mock <MetadataWorkspace>(MockBehavior.Strict); metadataWorkspaceMock.Setup(m => m.IsItemCollectionAlreadyRegistered(DataSpace.SSpace)).Returns(true); var entityConnection = new EntityConnection(metadataWorkspaceMock.Object, storeConnectionMock.Object, true); Assert.Equal(ConnectionState.Closed, entityConnection.State); // entityConnection state Assert.Equal(ConnectionState.Closed, entityConnection.StoreConnection.State); // underlying storeConnection state // open entityConnection (automatically opens store connection) entityConnection.OpenAsync().Wait(); Assert.Equal(ConnectionState.Open, entityConnection.State); // entityConnection state Assert.Equal(ConnectionState.Open, entityConnection.StoreConnection.State); // underlying storeConnection state // close entityConnection without explicitly closing underlying store connection entityConnection.Close(); Assert.Equal(ConnectionState.Closed, entityConnection.State); // entityConnection state Assert.Equal(ConnectionState.Closed, entityConnection.StoreConnection.State); // underlying storeConnection state }
private void ejemploentity() { using (EntityConnection conn = new EntityConnection("name=travelEntitiesGeneral")) { conn.Open(); EntityCommand cmd = conn.CreateCommand(); cmd.CommandText = @"select c.BlogID from travelEntitiesGeneral.Blogs as c where c.BlogPosts.Count > 0"; EntityDataReader reader = cmd.ExecuteReader(CommandBehavior.SequentialAccess); while (reader.Read()) { Console.WriteLine("BlogID = {0}", reader["BlogID"]); } conn.Close(); } }
public void StoreConnection_state_mimics_EntityConnection_state_if_only_EntityConnection_is_used_without_txn() { var storeConnectionState = ConnectionState.Closed; var storeConnectionMock = new Mock<DbConnection>(MockBehavior.Strict); storeConnectionMock.Setup(m => m.OpenAsync(It.IsAny<CancellationToken>())).Callback( () => storeConnectionState = ConnectionState.Open).Returns(Task.FromResult(1)); storeConnectionMock.Setup(m => m.Close()).Callback(() => storeConnectionState = ConnectionState.Closed); storeConnectionMock.SetupGet(m => m.State).Returns(() => storeConnectionState); storeConnectionMock.SetupGet(m => m.DataSource).Returns("fake"); var entityConnection = new EntityConnection(CreateMetadataWorkspaceMock().Object, storeConnectionMock.Object, true, true); Assert.Equal(ConnectionState.Closed, entityConnection.State); // entityConnection state Assert.Equal(ConnectionState.Closed, entityConnection.StoreConnection.State); // underlying storeConnection state // open entityConnection (automatically opens store connection) entityConnection.OpenAsync().Wait(); storeConnectionMock.Raise( conn => conn.StateChange += null, new StateChangeEventArgs(ConnectionState.Closed, ConnectionState.Open)); Assert.Equal(ConnectionState.Open, entityConnection.State); // entityConnection state Assert.Equal(ConnectionState.Open, entityConnection.StoreConnection.State); // underlying storeConnection state // close entityConnection without explicitly closing underlying store connection entityConnection.Close(); storeConnectionMock.Raise( conn => conn.StateChange -= null, new StateChangeEventArgs(ConnectionState.Open, ConnectionState.Closed)); Assert.Equal(ConnectionState.Closed, entityConnection.State); // entityConnection state Assert.Equal(ConnectionState.Closed, entityConnection.StoreConnection.State); // underlying storeConnection state }
private static void test() { // Specify the provider name, server and database. string providerName = "System.Data.SqlClient"; string serverName = "."; string databaseName = "AdventureWorks"; // Initialize the connection string builder for the // underlying provider. SqlConnectionStringBuilder sqlBuilder = new SqlConnectionStringBuilder(); // Set the properties for the data source. sqlBuilder.DataSource = serverName; sqlBuilder.InitialCatalog = databaseName; sqlBuilder.IntegratedSecurity = true; // Build the SqlConnection connection string. string providerString = sqlBuilder.ToString(); // Initialize the EntityConnectionStringBuilder. EntityConnectionStringBuilder entityBuilder = new EntityConnectionStringBuilder(); //Set the provider name. entityBuilder.Provider = providerName; // Set the provider-specific connection string. entityBuilder.ProviderConnectionString = providerString; // Set the Metadata location. entityBuilder.Metadata = @"res://*/AdventureWorksModel.csdl| res://*/AdventureWorksModel.ssdl| res://*/AdventureWorksModel.msl"; Console.WriteLine(entityBuilder.ToString()); using (EntityConnection conn = new EntityConnection(entityBuilder.ToString())) { conn.Open(); Console.WriteLine("Just testing the connection."); conn.Close(); } }
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 Should_use_interception() { var mockConnection = new Mock<DbConnection>(); mockConnection.SetupGet(m => m.DataSource).Returns("Foo"); mockConnection.SetupGet(m => m.State).Returns(ConnectionState.Open); var mockStoreItemCollection = new Mock<StoreItemCollection>(); mockStoreItemCollection .SetupGet(m => m.ProviderFactory) .Returns(DbProviderServices.GetProviderFactory(new SqlConnection())); var mockMetadataWorkspace = new Mock<MetadataWorkspace>(); mockMetadataWorkspace .Setup(m => m.GetItemCollection(DataSpace.SSpace)) .Returns(mockStoreItemCollection.Object); var objectContext = new ObjectContext(); var mockConnectionInterceptor = new Mock<IDbConnectionInterceptor>(); mockConnectionInterceptor .Setup(m => m.Closing(mockConnection.Object, It.IsAny<DbConnectionInterceptionContext>())) .Callback<DbConnection, DbConnectionInterceptionContext>( (_, c) => Assert.Equal(new[] { objectContext }, c.ObjectContexts)); mockConnectionInterceptor .Setup(m => m.Closed(mockConnection.Object, It.IsAny<DbConnectionInterceptionContext>())) .Callback<DbConnection, DbConnectionInterceptionContext>( (_, c) => mockConnection.Verify(m => m.Close(), Times.Once())); mockConnection .Setup(m => m.Close()) .Callback( () => { mockConnection.SetupGet(m => m.State).Returns(ConnectionState.Closed); mockConnection.Raise( m => m.StateChange += null, new StateChangeEventArgs(ConnectionState.Open, ConnectionState.Closed)); }); EntityConnection connection; DbInterception.Add(mockConnectionInterceptor.Object); try { connection = new EntityConnection( mockMetadataWorkspace.Object, mockConnection.Object, true, true); connection.AssociateContext(objectContext); connection.Close(); } finally { DbInterception.Remove(mockConnectionInterceptor.Object); } mockConnectionInterceptor.Verify(m => m.Closing(mockConnection.Object, It.IsAny<DbConnectionInterceptionContext>()), Times.Once()); mockConnectionInterceptor.Verify(m => m.Closing(mockConnection.Object, It.IsAny<DbConnectionInterceptionContext>()), Times.Once()); mockConnection.Verify(m => m.Close(), Times.Once()); mockConnectionInterceptor.Verify( m => m.StateGetting(It.IsAny<DbConnection>(), It.IsAny<DbConnectionInterceptionContext<ConnectionState>>()), Times.Exactly(2)); mockConnectionInterceptor.Verify( m => m.StateGot(It.IsAny<DbConnection>(), It.IsAny<DbConnectionInterceptionContext<ConnectionState>>()), Times.Exactly(2)); mockConnection.Verify(m => m.State, Times.Exactly(2)); Assert.Equal(ConnectionState.Closed, connection.State); }
public void Closing_EntityConnection_sets_its_State_to_Closed() { var dbConnectionState = ConnectionState.Open; var dbConnectionMock = new Mock<DbConnection>(MockBehavior.Strict); dbConnectionMock.Setup(m => m.Close()).Callback( () => { dbConnectionState = ConnectionState.Closed; dbConnectionMock.Raise( conn => conn.StateChange += null, new StateChangeEventArgs(ConnectionState.Open, ConnectionState.Closed)); }); dbConnectionMock.SetupGet(m => m.State).Returns(() => dbConnectionState); dbConnectionMock.SetupGet(m => m.DataSource).Returns(() => "foo"); var metadataWorkspaceMock = CreateMetadataWorkspaceMock(); var metadataWorkspace = metadataWorkspaceMock.Object; var entityConnection = new EntityConnection(metadataWorkspace, dbConnectionMock.Object, true, true); entityConnection.Close(); Assert.Equal(ConnectionState.Closed, entityConnection.State); }
public void Noop_if_dbConnection_is_null() { var metadataWorkspaceMock = new Mock<MetadataWorkspace>(MockBehavior.Strict); var metadataWorkspace = metadataWorkspaceMock.Object; var entityConnection = new EntityConnection(metadataWorkspace, null, true, true); entityConnection.Close(); }