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

        static void Main(string[] args)
        {

            using (var ts = new TransactionScope())
            {

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

                    //Em EF 5:
                    //((IObjectContextAdapter)ctx).ObjectContext.Connection.Open(); 
                    ctx.Database.Connection.Open();
                    var al = (from a in ctx.Alunos
                              where a.NumAl == 1111
                              select a)
                                .First();


                    al.Nome = "xico";


                   
                    using (var ctx1 = new ASIEntities7(cn))
                    {
					
					
					
                        //Em EF5:
                        //((IObjectContextAdapter)ctx1).ObjectContext.Connection.Open(); 
                        //ctx1.Database.Connection.Open();
                        var al1 = (from a in ctx.Alunos
                                   where a.NumAl == 4444
                                   select a)
                                .First();
                        al1.Nome = "xxxx";
						ctx1.SaveChanges();
                    }

                    ctx.SaveChanges();
                }
// ponto 1: observar no Sql Server Profiler
                ts.Complete();
            }
        }

        public static bool insertDataToTable1(SqlConnection connection, System.Data.SqlClient.SqlTransaction transaction, int numberID, string text)
        {
            bool response = false;

            MetadataWorkspace workspace = new MetadataWorkspace
                (
                    new string[]
                    {
                        string.Format("res://{0}/MyTestDB.csdl" , "*"),
                        string.Format("res://{0}/MyTestDB.ssdl" , "*"),
                        string.Format("res://{0}/MyTestDB.msl" , "*")
                    },
                    new Assembly[]
                    {
                        Assembly.GetAssembly(typeof (jfso.demos.SqlTransaction.DAL.MyTestDV))
                    }
                );

            EntityConnection _conn = new EntityConnection(workspace, connection);

            try
            {
                using (var ctx = new MyTestDV(_conn, false))
                {

                    ctx.Database.UseTransaction(transaction);

                    ctx.TestTable1.Add(
                        new TestTable1()
                        {
                            ID = numberID,
                            Text = text
                        });


                    ctx.SaveChanges();

                    response = true;
                }
            }
            catch (Exception)
            {
                response = false;
            }

            return response;
        }

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

        void Temp()
        {
            #region EntityConnectionCreationAndUsage

            EntityConnectionStringBuilder entityBuilder = new EntityConnectionStringBuilder
            {
                Provider = "System.Data.SqlClient",
                ProviderConnectionString = "the database connection string",
                Metadata = @"res://*/MySample.csdl|res://*/MySample.ssdl|res://*/MySample.msl"
            };

            EntityConnection entityConn = new EntityConnection(entityBuilder.ToString());

            using (MySampleContainer ctx = new MySampleContainer(entityConn))
            {
                //use the DbContext as required
            }

            #endregion
        }