/// <summary>
        /// Creates the entity connection with wrappers.
        /// </summary>
        /// <param name="entityConnectionString">The original entity connection string.</param>
        /// <param name="wrapperProviders">List for wrapper providers.</param>
        /// <returns>EntityConnection object which is based on a chain of providers.</returns>
        public static EntityConnection CreateEntityConnectionWithWrappers(string entityConnectionString, params string[] wrapperProviders)
        {
            EntityConnectionStringBuilder ecsb = new EntityConnectionStringBuilder(entityConnectionString);

            // if connection string is name=EntryName, look up entry in the config file and parse it
            if (!String.IsNullOrEmpty(ecsb.Name))
            {
                var connStr = System.Configuration.ConfigurationManager.ConnectionStrings[ecsb.Name];
                if (connStr == null)
                {
                    throw new ArgumentException("Specified named connection string '" + ecsb.Name + "' was not found in the configuration file.");
                }

                ecsb.ConnectionString = connStr.ConnectionString;
            }

            MetadataWorkspace workspace;
            if (!metadataWorkspaceMemoizer.TryGetValue(ecsb.ConnectionString, out workspace))
            {
                workspace = CreateWrappedMetadataWorkspace(ecsb.Metadata, wrapperProviders);
                metadataWorkspaceMemoizer.Add(ecsb.ConnectionString, workspace);
            }

            var storeConnection = DbProviderFactories.GetFactory(ecsb.Provider).CreateConnection();
            storeConnection.ConnectionString = ecsb.ProviderConnectionString;
            var newEntityConnection = new EntityConnection(workspace, DBConnectionWrapper.WrapConnection(storeConnection, wrapperProviders));
            return newEntityConnection;
        }

        /// <summary>
        /// Constructs a grouper based on the contents of the given entity state manager.
        /// </summary>
        /// <param name="stateManager">Entity state manager containing changes to be processed.</param>
        /// <param name="metadataWorkspace">Metadata workspace.</param>
        /// <param name="connection">Map connection</param>
        /// <param name="commandTimeout">Timeout for update commands; null means 'use provider default'</param>
        private UpdateTranslator(IEntityStateManager stateManager, MetadataWorkspace metadataWorkspace, EntityConnection connection, int? commandTimeout)
        {
            EntityUtil.CheckArgumentNull(stateManager, "stateManager");
            EntityUtil.CheckArgumentNull(metadataWorkspace, "metadataWorkspace");
            EntityUtil.CheckArgumentNull(connection, "connection");

            // propagation state
            m_changes = new Dictionary<EntitySetBase, ChangeNode>();
            m_functionChanges = new Dictionary<EntitySetBase, List<ExtractedStateEntry>>();
            m_stateEntries = new List<IEntityStateEntry>();
            m_knownEntityKeys = new Set<EntityKey>();
            m_requiredEntities = new Dictionary<EntityKey, AssociationSet>();
            m_optionalEntities = new Set<EntityKey>();
            m_includedValueEntities = new Set<EntityKey>();

            // workspace state
            m_metadataWorkspace = metadataWorkspace;
            m_viewLoader = metadataWorkspace.GetUpdateViewLoader();
            m_stateManager = stateManager;

            // ancillary propagation services
            m_recordConverter = new RecordConverter(this);
            m_constraintValidator = new RelationshipConstraintValidator(this);

            m_providerServices = DbProviderServices.GetProviderServices(connection.StoreProviderFactory);
            m_connection = connection;
            m_commandTimeout = commandTimeout;

            // metadata cache
            m_extractorMetadata = new Dictionary<Tuple<EntitySetBase, StructuralType>, ExtractorMetadata>(); ;

            // key management
            KeyManager = new KeyManager(this);
            KeyComparer = CompositeKey.CreateComparer(KeyManager);
        }

        static void Main(string[] args)
        {
            using (var c = new EntityConnection("name=AdventureWorksEntities"))
            {
                c.StateChange += EStateChange;

                var cmd = "SELECT VALUE C FROM AdventureWorksEntities.Contatos AS C WHERE [email protected]";

                using (var k = new EntityCommand(cmd, c))
                {
                    k.Parameters.AddWithValue("ContactID", 1);

                    c.Open();

                    var dr = k.ExecuteReader(CommandBehavior.SequentialAccess);

                    if (dr.Read()) //while se existir mais de um registro
                    {
                        Console.WriteLine(dr["Nome"]);
                    }

                    if (c.State != ConnectionState.Closed) c.Close();
                }
            }

            Console.ReadKey();
        }

 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 Test1()
        {
            string SELECT_PERSONS_ALL = "SELECT p.id as person_id, p.fname, p.lname, ph.id as phone_id , " +
                "ph.phonevalue as phonevalue, a.id as address_id , a.addressvalue as addressvalue " +
                "FROM Entities.People as p INNER JOIN Entities.Addresses as a ON a.personid = p.id " +
                "INNER JOIN Entities.Phones as ph ON ph.personid = p.id";

            EntityConnection m_connection = new EntityConnection("name=Entities");
            List<Mock.PhoneBook.Phone> list = new List<Mock.PhoneBook.Phone>();

            m_connection.Open();
            Infrastructure.PhoneBook.IMockConvertor convertor = new ERDBArch.Modules.PhoneBook.BLL.PersonConvertor();

            using (EntityCommand cmd = new EntityCommand(SELECT_PERSONS_ALL, m_connection))
            {
                using (DbDataReader reader = cmd.ExecuteReader(CommandBehavior.SequentialAccess))
                {
                    while (reader.Read())
                    {
                        System.Diagnostics.Debug.WriteLine(reader["person_id"]);

                    }
                }
            }
            m_connection.Close();
        }

        /// <summary>
        /// Creates the entity connection with wrappers.
        /// </summary>
        /// <param name="entityConnectionString">The original entity connection string. This may also be a single word, e.g., "MyEntities", in which case it is translated into "name=MyEntities" and looked up in the application configuration.</param>
        /// <param name="wrapperProviders">List for wrapper providers.</param>
        /// <returns>EntityConnection object which is based on a chain of providers.</returns>
        public static EntityConnection CreateEntityConnectionWithWrappers(string entityConnectionString, params string[] wrapperProviders)
        {
            // If there is only a single word in the connection string, treat it as the value for Name.
            if (!entityConnectionString.Contains('='))
                entityConnectionString = "name=" + entityConnectionString;

            EntityConnectionStringBuilder ecsb = new EntityConnectionStringBuilder(entityConnectionString);

            // if connection string is name=EntryName, look up entry in the config file and parse it
            if (!String.IsNullOrEmpty(ecsb.Name))
            {
                var connStr = ConfigurationManager.ConnectionStrings[ecsb.Name];
                if (connStr == null)
                {
                    throw new ArgumentException("Specified named connection string '" + ecsb.Name + "' was not found in the configuration file.");
                }

                ecsb.ConnectionString = connStr.ConnectionString;

            }

            var workspace = metadataWorkspaceMemoizer.GetOrAdd(ecsb.ConnectionString, _ => CreateWrappedMetadataWorkspace(ecsb.Metadata, wrapperProviders));
            var storeConnection = DbProviderFactories.GetFactory(ecsb.Provider).CreateConnection();
            storeConnection.ConnectionString = ecsb.ProviderConnectionString;
            var newEntityConnection = new EntityConnection(workspace, DbConnectionWrapper.WrapConnection(storeConnection, wrapperProviders));
            return newEntityConnection;
        }

        public HERBProject_DataBaseEntities GetEntitiesContext()
        {
            // Initialize Entity Connection String Builder
            EntityConnectionStringBuilder entityConnectionStringBuilder = new EntityConnectionStringBuilder();

            // Set the provider name
            entityConnectionStringBuilder.Provider = "System.Data.SqlClient";

            // Set the provider-specific connection string
            entityConnectionStringBuilder.ProviderConnectionString = _connectionString;
            entityConnectionStringBuilder.ProviderConnectionString += ";MultipleActiveResultSets=True";

            // Set the Metadata location
            entityConnectionStringBuilder.Metadata = string.Format("{0}|{1}|{2}",
                                            "res://*/Repositories.CustomBoundedRepository.HERBProject_DataBase.csdl",
                                            "res://*/Repositories.CustomBoundedRepository.HERBProject_DataBase.ssdl",
                                            "res://*/Repositories.CustomBoundedRepository.HERBProject_DataBase.msl");

            // Build Entity Connection
            EntityConnection entityConnection = new EntityConnection(entityConnectionStringBuilder.ToString());

            // Initialize Entity Object
            return new HERBProject_DataBaseEntities(entityConnection)
            {
                CommandTimeout = _commandTimeOut
            };
        }

        public IList<Club> GetClubAutoComplete(string searchText)
        {
            var clubs = new List<Club>();

            using (var connection = new EntityConnection("name=CoreContainer"))
            {
                _core = new CoreContainer(connection);

                if(searchText.Equals("**"))
                {
                    clubs = _core.Clubs
                                    .Where(c => c.DateActivated.HasValue
                                                && !c.DateCancelled.HasValue)
                                    .OrderBy(c => c.FullName)
                                    .ToList();
                }
                else
                {
                    clubs = _core.Clubs
                                    .Where(c => c.DateActivated.HasValue
                                                && !c.DateCancelled.HasValue
                                                && (c.FullName.ToLower().Contains(searchText)
                                                || c.Acronym.ToLower().Contains(searchText)))
                                    .OrderBy(c => c.FullName)
                                    .ToList();
                }
            }

            return clubs;
        }

        public static void ReadContents()
        {
            using (EntityConnection cn = new EntityConnection("name=DESEDMEntities"))
            {
                cn.Open();

                string query = "SELECT VALUE DESContent FROM DESEDMEntities.DESContents AS DESContent";

                using (EntityCommand cmd = cn.CreateCommand())
                {
                    cmd.CommandText = query;

                    // Finally, get the data reader and process records.
                    using (EntityDataReader dr = cmd.ExecuteReader(CommandBehavior.SequentialAccess))
                    {
                        Console.WriteLine("Count: " + dr.FieldCount);
                        Console.WriteLine("Row:" + dr.HasRows);

                        if (dr.HasRows)
                        {
                            while (dr.Read())
                            {
                                Console.WriteLine("****RECORD*****");
                                Console.WriteLine("ID: {0}", dr["Id"]);
                                Console.WriteLine("Input File Name: {0}", dr["InputFileName"]);
                                Console.WriteLine("Output File Name: {0}", dr["OutputFileName"]);
                            }
                        }
                    }
                }
            }
        }

        public void AddTeam(string name, string email, bool isExclusive, bool isActive)
        {

            // Initialize the connection string builder for the
            // underlying provider.
            EntityConnectionStringBuilder entityBuilder = GetEntityBuilder();

            using (EntityConnection conn =
                    new EntityConnection(entityBuilder.ToString()))
            {
                using (AMS_DMEntities entities = new AMS_DMEntities(conn))
                {
                    Console.WriteLine("connection Ok.");

                    Team team = new Team();
                    team.Name = name;
                    team.Email = email;
                    team.IsExclusive = isExclusive;
                    team.IsActive = isActive;

                    entities.AddToTeams(team);
                    entities.SaveChanges();
                }
            }
        }

 public TestEntities(EntityConnection connection)
     : base(connection, ContainerName)
 {
     this.ContextOptions.LazyLoadingEnabled = true;
     // 不使用代理类.
     this.ContextOptions.ProxyCreationEnabled = false;
 }

        public static void RunESQLExample()
        {
            System.Console.WriteLine("\nUsing Entity SQL");

            var esqlQuery = @"SELECT order.SalesOrderID, order.OrderDate, order.DueDate, order.ShipDate FROM AdventureWorksEntities.SalesOrderHeaders AS order where order.SalesOrderID = 43661";

            using (var conn = new EntityConnection("name=AdventureWorksEntities"))
            {
                conn.Open();

                // Create an EntityCommand.
                using (EntityCommand cmd = conn.CreateCommand())
                {
                    cmd.CommandText = esqlQuery;

                    // Execute the command.
                    using (EntityDataReader rdr = cmd.ExecuteReader(CommandBehavior.SequentialAccess))
                    {
                        // Start reading results.
                        while (rdr.Read())
                        {
                            System.Console.WriteLine("\nSalesOrderID: {0} \nOrderDate: {1} \nDueDate: {2} \nShipDate: {3}", rdr[0], rdr[1], rdr[2], rdr[3]);
                        }
                    }
                }
                conn.Close();
            }
        }

        private static void FunWithEntityDataReader()
        {
            // Make a connection object, based on our *.config file.
            using (EntityConnection cn = new EntityConnection("name=AutoLotEntities"))
            {
                cn.Open();

                // Now build an Entity SQL query.
                string query = "SELECT VALUE car FROM AutoLotEntities.Cars AS car";

                // Create a command object.
                using (EntityCommand cmd = cn.CreateCommand())
                {
                    cmd.CommandText = query;

                    // Finally, get the data reader and process records.
                    using (EntityDataReader dr = cmd.ExecuteReader(CommandBehavior.SequentialAccess))
                    {
                        while (dr.Read())
                        {
                            Console.WriteLine("***** RECORD *****");
                            Console.WriteLine("ID: {0}", dr["CarID"]);
                            Console.WriteLine("Make: {0}", dr["Make"]);
                            Console.WriteLine("Color: {0}", dr["Color"]);
                            Console.WriteLine("Pet Name: {0}", dr["CarNickname"]);
                            Console.WriteLine();
                        }
                    }
                }
            }
        }

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

            _connection = connection;
            _storeTransaction = storeTransaction;
        }

 public void Test()
 {
     var connection = new EntityConnection(@"metadata=res://*/ProductCatalog.csdl|res://*/ProductCatalog.ssdl|res://*/ProductCatalog.msl;provider=System.Data.SqlClient;provider connection string='Data Source=sr01.lutecia.ge\SQLEXPRESS,1433;Initial Catalog=ProductCatalog;User ID=sa;Password=tatu;MultipleActiveResultSets=True';");
     using (var context = new ProductCatalogContainer(connection))
     {
         Console.WriteLine(context.ProductDetailViewModels.FirstOrDefault());
     }
 }

        /// <summary>
        /// Constructs the EntityTransaction object with an associated connection and the underlying store transaction
        /// </summary>
        /// <param name="connection">The EntityConnetion object owning this transaction</param>
        /// <param name="storeTransaction">The underlying transaction object</param>
        internal EntityTransaction(EntityConnection connection, DbTransaction storeTransaction)
            : base()
        {
            Debug.Assert(connection != null && storeTransaction != null);

            this._connection = connection;
            this._storeTransaction = storeTransaction;
        }

        public static void SetConnection(String conn)
        {
            var cb = new EntityConnectionStringBuilder();
            cb.Provider = "System.Data.SqlClient";
            cb.ProviderConnectionString = conn;
            cb.Metadata = "res://*/DataModel.csdl|res://*/DataModel.ssdl|res://*/DataModel.msl";

            _connrction = new EntityConnection(cb.ConnectionString);
        }

 public void SaveMessage(Message message)
 {
     using (EntityConnection connection = new EntityConnection("name=CoreContainer"))
     {
         _core = new CoreContainer(connection);
         _core.Messages.AddObject(message);
         _core.SaveChanges();
     }
 }

 public static EntityConnection CreateTableAndPopulateData()
 {
     // clear the old connection
     entityConnection = null;
     EntityConnection.Open();
     CreateTable((SqlConnection)EntityConnection.StoreConnection);
     Populate(new CustomObjectContext());
     return EntityConnection;
 }

        private AlcionaDataBaseConnection()
        {
            EntityConnection connection = new EntityConnection();
            string connectionString = ConfigurationManager.ConnectionStrings["AlcionaEntities"].ConnectionString;
            connection.ConnectionString = connectionString;
            connection.Open();
            _context = new AlcionaEntities(connection, false);
            ((IObjectContextAdapter)_context).ObjectContext.CommandTimeout = 3600;

        }