C# EntityConnection.Open方法代码示例

        public void DependencyResolver_used_to_resolve_DbProviderServices()
        {
            const string query = @"
SELECT VALUE p 
FROM CodeFirstContainer.Products AS p
WHERE p.ID > 3";

            var mockResolver = new Mock<IDbDependencyResolver>();
            mockResolver
                .Setup(
                    r => r.GetService(
                        It.Is<Type>(t => t == typeof(DbProviderServices)),
                        It.Is<string>(s => s == "System.Data.SqlClient")))
                .Returns(SqlProviderServices.Instance);

            using (var connection = new EntityConnection(SimpleModelEntityConnectionString))
            {
                connection.Open();

                new EntityCommand(query, connection, mockResolver.Object)
                    .ExecuteReader(CommandBehavior.SequentialAccess);
            }

            mockResolver.Verify(m => m.GetService(typeof(DbProviderServices), "System.Data.SqlClient"), Times.Once());
        }

        public EntityConnectionX()
        {
            EntityConnection connection = new EntityConnection("name=NorthwindEntities");

            // Open the connection.
            connection.Open();
            this.Connection = connection;
        }

        public void Verify_that_opening_connection_does_not_create_new_MetadataWorkspace()
        {
            var connection = new EntityConnection(connectionString);
            var workspace = connection.GetMetadataWorkspace();

            connection.Open();
            Assert.Same(workspace, connection.GetMetadataWorkspace());
        }

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

 static void Main(string[] args)
 {
     string city = "London";
     using (EntityConnection cn = new EntityConnection("Name=Entities"))
     {
         cn.Open();
         EntityCommand cmd = cn.CreateCommand();
         cmd.CommandText = @"SELECT VALUE c FROM Entities.Customers AS c WHERE
              c.Address.City = @city";
         cmd.Parameters.AddWithValue("city", city);
         DbDataReader rdr = cmd.ExecuteReader(CommandBehavior.SequentialAccess);
         while (rdr.Read())
             Console.WriteLine(rdr["CompanyName"].ToString());
         rdr.Close();
     }
 }

        public SGCoopSTEntities()
            : base("name=SGCoopSTEntities")
        {
            string providerName = "System.Data.SqlClient";
            string serverName = "10.10.11.115";
            string databaseName = "SGCoopST";
            string password="[email protected]@";
            string userid = "sa";
            // 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 = false;
            sqlBuilder.Password = password;
            sqlBuilder.UserID = userid;

            // 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://*/GOLDMEM.Entity.GMModel.csdl
                                                    |res://*/GOLDMEM.Entity.GMModel.ssdl
                                                    |res://*/GOLDMEM.Entity.GMModel.msl";
            EntityConnection enCon = new EntityConnection(entityBuilder.ToString());
            if (enCon.State== System.Data.ConnectionState.Closed)
            {
                enCon.Open();
            }
        }

        public void When_Same_Primary_Key_Name_Is_Used_For_Two_Tables_Correct_Number_Of_MetaData_Rows_Is_Returned()
        {
            this.CreateIfNotExists();
            var workspace = CreateMetadataWorkspace();            
            var connection = new EntityConnection(workspace, new SqlCeConnection(dbConnectionString));
            connection.Open();
            var command = connection.CreateCommand();
            command.CommandText = TableDetailSql;
            var rowCount = 0;

            using (var reader = command.ExecuteReader(CommandBehavior.SequentialAccess))
            {
                while (reader.Read())
                {
                    rowCount++;
                }
            }

            Assert.Equal(4, rowCount);
        }

        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 UserDefinedFunction()
    {
      using (EntityConnection conn = new EntityConnection("name=testEntities"))
      {
        conn.Open();

        string query = @"SELECT e.FirstName AS Name FROM testEntities.Employees AS e 
                    WHERE testModel.Store.spFunc(e.Id, '') = 6";
        using (EntityCommand cmd = new EntityCommand(query, conn))
        {
          EntityDataReader reader = cmd.ExecuteReader(CommandBehavior.SequentialAccess);
          Assert.IsTrue(reader.Read());
          Assert.AreEqual("Scooby", reader[0]);
        }
      }
    }

        private void MetadataCachingWithGarbageCollectionTemplate(Action garbageCollection)
        {
            MetadataWorkspace.ClearCache();
            var weakReferences = new WeakReference[3];

            // load metadata
            using (var connection1 = new EntityConnection(connectionString))
            {
                connection1.Open();

                weakReferences[0] = new WeakReference(connection1.GetMetadataWorkspace().GetItemCollection(DataSpace.CSpace));
                weakReferences[1] = new WeakReference(connection1.GetMetadataWorkspace().GetItemCollection(DataSpace.SSpace));
                weakReferences[2] = new WeakReference(connection1.GetMetadataWorkspace().GetItemCollection(DataSpace.CSSpace));
            }

            // perform necessary garbage collection steps
            garbageCollection();

            // verify that metadata was cached
            using (var connection2 = new EntityConnection(connectionString))
            {
                connection2.Open();

                Assert.Same(weakReferences[0].Target, connection2.GetMetadataWorkspace().GetItemCollection(DataSpace.CSpace));
                Assert.Same(weakReferences[1].Target, connection2.GetMetadataWorkspace().GetItemCollection(DataSpace.SSpace));
                Assert.Same(weakReferences[2].Target, connection2.GetMetadataWorkspace().GetItemCollection(DataSpace.CSSpace));
            }
        }

            public void Should_use_interception()
            {
                var mockConnection = new Mock<DbConnection>();
                mockConnection.SetupGet(m => m.DataSource).Returns("Foo");
                mockConnection.SetupGet(m => m.State).Returns(ConnectionState.Closed);

                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.Opening(mockConnection.Object, It.IsAny<DbConnectionInterceptionContext>()))
                    .Callback<DbConnection, DbConnectionInterceptionContext>(
                        (_, c) => Assert.Equal(new[] { objectContext }, c.ObjectContexts));

                mockConnectionInterceptor
                    .Setup(m => m.Opened(mockConnection.Object, It.IsAny<DbConnectionInterceptionContext>()))
                    .Callback<DbConnection, DbConnectionInterceptionContext>(
                        (_, c) => mockConnection.Verify(m => m.Open(), Times.Once()));

                mockConnection
                    .Setup(m => m.Open())
                    .Callback(
                        () =>
                        {
                            mockConnection
                                .SetupGet(m => m.State).Returns(ConnectionState.Open);
                            mockConnection.Raise(
                                m => m.StateChange += null, new StateChangeEventArgs(ConnectionState.Closed, ConnectionState.Open));
                        });

                EntityConnection connection;
                DbInterception.Add(mockConnectionInterceptor.Object);
                try
                {
                    connection
                        = new EntityConnection(
                            mockMetadataWorkspace.Object,
                            mockConnection.Object,
                            true,
                            true);
                    connection.AssociateContext(objectContext);
                    connection.Open();
                }
                finally
                {
                    DbInterception.Remove(mockConnectionInterceptor.Object);
                }

                mockConnectionInterceptor.Verify(m => m.Opening(mockConnection.Object, It.IsAny<DbConnectionInterceptionContext>()),
                    Times.Once());
                mockConnectionInterceptor.Verify(m => m.Opened(mockConnection.Object, It.IsAny<DbConnectionInterceptionContext>()),
                    Times.Once());
                mockConnectionInterceptor
                    .Verify(m => m.Opened(mockConnection.Object, It.IsAny<DbConnectionInterceptionContext>()), Times.Once());

                mockConnectionInterceptor.Verify(
                    m => m.StateGetting(It.IsAny<DbConnection>(), It.IsAny<DbConnectionInterceptionContext<ConnectionState>>()),
                    Times.Exactly(3));
                mockConnectionInterceptor.Verify(
                    m => m.StateGot(It.IsAny<DbConnection>(), It.IsAny<DbConnectionInterceptionContext<ConnectionState>>()),
                    Times.Exactly(3));
                mockConnection.Verify(m => m.State, Times.Exactly(3));

                Assert.Equal(ConnectionState.Open, connection.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 void Underlying_dbConnection_is_not_being_closed_if_it_was_initially_opened_such_that_it_cannot_be_reopend()
            {
                var dbConnectionMock = new Mock<DbConnection>(MockBehavior.Strict);
                dbConnectionMock.Setup(m => m.Open()).Verifiable();
                dbConnectionMock.Setup(m => m.Close()).Verifiable();
                dbConnectionMock.SetupGet(m => m.State).Returns(ConnectionState.Open);
                dbConnectionMock.SetupGet(m => m.DataSource).Returns(() => "foo");

                var entityConnection = new EntityConnection(
                    new Mock<MetadataWorkspace>(MockBehavior.Strict).Object, dbConnectionMock.Object, true, true);

                Assert.Equal(
                    Strings.EntityClient_CannotReopenConnection,
                    Assert.Throws<InvalidOperationException>(() => entityConnection.Open()).Message);

                dbConnectionMock.Verify(m => m.Close(), Times.Never());

                Assert.Equal(ConnectionState.Open, entityConnection.StoreConnection.State);
            }

        private static void FunWithEntityDataReader() {
            using (EntityConnection cn = new EntityConnection("name=AutoLotEntities")) {
                cn.Open();
                string queryString = "SELECT VALUE car from AutoLotEntities.Cars as car WHERE car.Color='Black'";
                using (EntityCommand cmd = cn.CreateCommand()) {
                    cmd.CommandText = queryString;

                    using (EntityDataReader dr = cmd.ExecuteReader(System.Data.CommandBehavior.SequentialAccess)) {
                        while (dr.Read()) {
                            Console.WriteLine(dr["CarID"]);
                        }
                    }
                }
            }                
        }