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();
}
