C# EntityClient.EntityConnection类代码示例

        public void Prepare_returns_a_new_instance()
        {
            var objectQueryExecutionPlanFactory = new ObjectQueryExecutionPlanFactory(
                Common.Internal.Materialization.MockHelper.CreateTranslator<object>());

            var metadataWorkspace = new MetadataWorkspace();
            var edmItemCollection = new EdmItemCollection();
            metadataWorkspace.RegisterItemCollection(edmItemCollection);
            metadataWorkspace.RegisterItemCollection(new ObjectItemCollection());
            var fakeSqlProviderManifest = new FakeSqlProviderServices().GetProviderManifest("2008");
            var storeItemCollection = new StoreItemCollection(FakeSqlProviderFactory.Instance, fakeSqlProviderManifest, "2008");
            metadataWorkspace.RegisterItemCollection(storeItemCollection);
            metadataWorkspace.RegisterItemCollection(new StorageMappingItemCollection(edmItemCollection, storeItemCollection, Enumerable.Empty<XmlReader>()));

            var fakeSqlConnection = new FakeSqlConnection();
            fakeSqlConnection.ConnectionString = "foo";
            var entityConnection = new EntityConnection(metadataWorkspace, fakeSqlConnection, false);

            var objectContext = new ObjectContext(entityConnection);
            var dbExpression = new DbNullExpression(TypeUsage.Create(fakeSqlProviderManifest.GetStoreTypes().First()));
            var dbQueryCommandTree = new DbQueryCommandTree(metadataWorkspace, DataSpace.CSpace,
               dbExpression, validate: false);
            var parameters = new List<Tuple<ObjectParameter, QueryParameterExpression>>();

            var objectQueryExecutionPlan = objectQueryExecutionPlanFactory.Prepare(objectContext, dbQueryCommandTree, typeof(object),
                MergeOption.NoTracking, new Span(), parameters, aliasGenerator: null);

            Assert.NotNull(objectQueryExecutionPlan);
        }

        static void Main(string[] args)
        {


            EntityConnection cn = new EntityConnection("name=ASIEntities7");
            DbConnection dbcn = new SqlConnection( System.Configuration.ConfigurationManager.ConnectionStrings["base dados"].ConnectionString );

            var alnPedro = new Aluno { NumAl = 1001, Nome = "Pedro" };
            alnPedro.AlunosAssEsts = new HashSet<AlunosAssEst>();

            var alnPaula = new Aluno { NumAl = 1002, Nome = "Paula" };
            alnPaula.AlunosAssEsts = new HashSet<AlunosAssEst>();

            using (var ctx1 = new ASIEntities7(cn))
            {
                // em alternativa a usar o Sql Server Profiler, pode fazer:
                //ctx1.Database.Log = Console.Write;

                ctx1.Alunos.Add(alnPedro);
                ctx1.Alunos.Add(alnPaula);

                // ExecuteDML(dbcn, "A trocar as voltas ao EF6 inserindo o Jose ADO.Net(1001)...", "INSERT INTO [BD3_1].[dbo].[Alunos] ([NumAl],[Nome]) VALUES (1001, 'Jose ADO.Net')");
                SaveContextChanges(ctx1, PoliticaConcorrencia.UsarInfoBD);
            }
            
            using (var ctxPessimista = new ASIEntities7(cn))
            {
                // em alternativa a usar o Sql Server Profiler, pode fazer:
                //ctx4.Database.Log = Console.Write;

                Aluno alnPedroCtx = (from a in ctxPessimista.Alunos where a.NumAl == 1001 select a).First();
                alnPedroCtx.Nome = "Pedro ContextoEF6";

                ExecuteDML(dbcn, "O ADO.Net vai mudar o nome do Pedro para 'Pedro ADO.Net'.", "UPDATE [BD3_1].[dbo].[Alunos] SET [Nome] = 'Pedro ADO.Net' WHERE [NumAl] = 1001");
                
                Console.WriteLine("O EF6 vai mudar o nome do Pedro para 'Pedro ContextoEF6'. Antes de gravar, alnPedroCtx.Nome = {0}", alnPedroCtx.Nome);
                SaveContextChanges(ctxPessimista, PoliticaConcorrencia.UsarInfoBD);
                Console.WriteLine("Depois de gravadas as alteracoes com uma politica pessimista (vale o que esta na BD), o nome do Pedro no ambito do contexto EF6 é: alnPedroCtx.Nome = {0})", alnPedroCtx.Nome);
            }

            Console.WriteLine();

            using (var ctxOptimista = new ASIEntities7(cn))
            {
                // em alternativa a usar o Sql Server Profiler, pode fazer:
                //ctx5.Database.Log = Console.Write;

                Aluno alnPedroCtx = (from a in ctxOptimista.Alunos where a.NumAl == 1001 select a).First();
                alnPedroCtx.Nome = "Pedro ContextoEF6";

                ExecuteDML(dbcn, "O ADO.Net vai mudar o nome do Pedro para 'Pedro ADO.Net Outra Vez'.", "UPDATE [BD3_1].[dbo].[Alunos] SET [Nome] = 'Pedro ADO.Net Outra Vez' WHERE [NumAl] = 1001");
                
                Console.WriteLine("O EF6 vai mudar o nome do Pedro para 'Pedro ContextoEF6'. Antes de gravar, alnPedroCtx.Nome = {0}", alnPedroCtx.Nome);
                SaveContextChanges(ctxOptimista, PoliticaConcorrencia.UsarInfoCtx);
                Console.WriteLine("Depois de gravadas as alteracoes com uma politica optimista (vale o que esta no Contexto), o nome do Pedro no ambito do contexto EF6 é: alnPedroCtx.Nome = {0})", alnPedroCtx.Nome);
            }

            Console.WriteLine("Press any key to exit...");
            Console.ReadLine();
        }

 private EntityConnection GetEntityConnection()
 {
   string connectionString = String.Format(
       "metadata=TestDB.csdl|TestDB.msl|TestDB.ssdl;provider=MySql.Data.MySqlClient; provider connection string=\"{0}\"", GetConnectionString(true));
   EntityConnection connection = new EntityConnection(connectionString);
   return connection;
 }

        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 virtual bool Opening(EntityConnection entityConnection, DbInterceptionContext interceptionContext)
        {
            DebugCheck.NotNull(entityConnection);
            DebugCheck.NotNull(interceptionContext);

            return _internalDispatcher.Dispatch(true, (b, i) => i.ConnectionOpening(entityConnection, interceptionContext) && b);
        }

 /// <summary>
 ///     Constructs the DbContextTransaction object with the associated connection object
 ///     and with the given isolation level
 /// </summary>
 /// <param name="connection">The EntityConnection object owning this transaction </param>
 /// <param name="isolationLevel">The database isolation level with which the underlying store transaction will be created</param>
 internal DbContextTransaction(EntityConnection connection, IsolationLevel isolationLevel)
 {
     DebugCheck.NotNull(connection);
     _connection = connection;
     EnsureOpenConnection();
     _entityTransaction = _connection.BeginTransaction(isolationLevel);
 }

        internal EntityTransaction(EntityConnection connection, DbTransaction storeTransaction)
        {
            Contract.Requires(connection != null);
            Contract.Requires(storeTransaction != null);

            _connection = connection;
            _storeTransaction = storeTransaction;
        }

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

 internal virtual EntityStoreSchemaGeneratorDatabaseSchemaLoader CreateDbSchemaLoader(
     EntityConnection connection, Version storeSchemaModelVersion)
 {
     return
         new EntityStoreSchemaGeneratorDatabaseSchemaLoader(
             connection,
             storeSchemaModelVersion);
 }

        internal EntityTransaction(EntityConnection connection, DbTransaction storeTransaction)
        {
            DebugCheck.NotNull(connection);
            DebugCheck.NotNull(storeTransaction);

            _connection = connection;
            _storeTransaction = storeTransaction;
        }

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

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

        public void Verify_that_metadata_is_the_same_for_two_workspaces_created_from_two_entity_connections_with_same_connection_strings()
        {
            var connection1 = new EntityConnection(connectionString);
            var connection2 = new EntityConnection(connectionString);
            var workspace1 = connection1.GetMetadataWorkspace();
            var workspace2 = connection2.GetMetadataWorkspace();

            Assert.Same(workspace1.GetItemCollection(DataSpace.CSpace), workspace2.GetItemCollection(DataSpace.CSpace));
            Assert.Same(workspace1.GetItemCollection(DataSpace.SSpace), workspace2.GetItemCollection(DataSpace.SSpace));
            Assert.Same(workspace1.GetItemCollection(DataSpace.CSSpace), workspace2.GetItemCollection(DataSpace.CSSpace));
        }

        public virtual EntityConnectionProxy CreateNew(DbConnection storeConnection)
        {
            var clonedConnection = new EntityConnection(_entityConnection.GetMetadataWorkspace(), storeConnection);

            var currentTransaction = _entityConnection.CurrentTransaction;
            if (currentTransaction != null
                && DbInterception.Dispatch.Transaction.GetConnection(
                    currentTransaction.StoreTransaction, _entityConnection.InterceptionContext) == storeConnection)
            {
                clonedConnection.UseStoreTransaction(currentTransaction.StoreTransaction);
            }

            return new EntityConnectionProxy(clonedConnection);
        }

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