C# EntityConnection.Close方法代码示例

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

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