/// <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>
        /// Retrieves and builds an entity connection string given one specified in web.config.
        /// </summary>
        /// <returns>Connection String for a store that is intended to host tokens.</returns>
        internal static string GetEntityConnectionString()
        {
            string cs = string.Empty;
            System.Configuration.Configuration rootWebConfig = System.Web.Configuration.WebConfigurationManager.OpenWebConfiguration("/MyWebSiteRoot");
            System.Configuration.ConnectionStringSettings connString;

            if (rootWebConfig.ConnectionStrings.ConnectionStrings.Count > 0)
            {
                connString = rootWebConfig.ConnectionStrings.ConnectionStrings["AppTokenStorage"];

                if (connString != null)
                {
                    cs = connString.ConnectionString;
                }
                else
                {
                    throw new Exception("No connection string named 'AppTokenStorage' was declared in web.config.");
                }
            }

            EntityConnectionStringBuilder ecsb = new EntityConnectionStringBuilder();

            ecsb.ProviderConnectionString = cs + ";MultipleActiveResultSets=True;Application Name=EntityFramework";
            ecsb.Provider = "System.Data.SqlClient";
            ecsb.Metadata = "res://*/TokenStore.csdl|res://*/TokenStore.ssdl|res://*/TokenStore.msl";

            return ecsb.ToString();
        }

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

            protected override string CreateConnectionString()
            {              
                // Specify the provider name, server and database.
                string providerName = "System.Data.SqlClient";
                string serverName = ".\\SQLEXPRESS";
                string databaseName = "ZMTdb";

                // 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://EF_ZMTdbConnection/EF_ZMTdbModel.csdl|res://EF_ZMTdbConnection/EF_ZMTdbModel.ssdl|res://EF_ZMTdbConnection/EF_ZMTdbModel.msl";
                return entityBuilder.ToString();
            }

        public static void Create()
        {
            using (YomContainer container = new YomContainer())
            {
                container.Database.Create();
            }

            string connectionstring = ConfigurationManager.ConnectionStrings["YomContainer"].ConnectionString;

            EntityConnectionStringBuilder builder = new EntityConnectionStringBuilder(connectionstring);

            string providerconnectionstring = builder.ProviderConnectionString;

            Process process = new Process();
            process.StartInfo.FileName = @"C:\Windows\Microsoft.NET\Framework64\v4.0.30319\aspnet_regsql.exe";
            process.StartInfo.Arguments = string.Format("-A mr  -C \"{0}\"", providerconnectionstring);
            process.StartInfo.UseShellExecute = false;
            process.StartInfo.RedirectStandardOutput = true;

            process.Start();

            Console.WriteLine(process.StandardOutput.ReadToEnd());

            Console.ReadKey();
        }

        /// <summary>
        /// Gets the entity framework connection string.
        /// </summary>
        /// <param name="contextType">Type of the context.</param>
        /// <param name="connectionString">The connection string.</param>
        /// <returns>The entity framework connection string.</returns>
        /// <exception cref="ArgumentNullException">The <paramref name="contextType"/> is <c>null</c>.</exception>
        /// <exception cref="ArgumentException">The <paramref name="connectionString" /> is <c>null</c> or whitespace.</exception>
        public static string GetEntityFrameworkConnectionString(Type contextType, string connectionString)
        {
            Argument.IsNotNull("contextType", contextType);
            Argument.IsNotNullOrWhitespace("connectionString", connectionString);

            if (connectionString.Contains("res://"))
            {
                // already EF connection string
                return connectionString;
            }

            var fullName = contextType.FullName;
            if (fullName.EndsWith("Container"))
            {
                fullName = fullName.Substring(0, fullName.Length - "Container".Length);
            }

            var assemblyNameParts = contextType.Assembly.GetName().Name.Split(new[] { '.' });
            foreach (var assemblyNamePart in assemblyNameParts)
            {
                string itemToReplace = string.Format("{0}.", assemblyNamePart);
                if (fullName.StartsWith(itemToReplace))
                {
                    fullName = fullName.Remove(0, itemToReplace.Length);
                }
            }

            var connectionBuilder = new EntityConnectionStringBuilder();
            connectionBuilder.Provider = "System.Data.SqlClient";
            connectionBuilder.Metadata = string.Format("res://*/{0}.csdl|res://*/{0}.ssdl|res://*/{0}.msl", fullName);

            connectionBuilder.ProviderConnectionString = connectionString;

            return connectionBuilder.ToString();
        }

    //-------------------------------------------------------------------------------------------
    protected void Page_Load(object sender, EventArgs e)
    {
        IsPublic = true;

          if (Request.UserHostAddress != "127.0.0.1" || ConfigurationManager.AppSettings["install_mode"] == "false")
          {
               Response.Write("This page is unavailable to the general internet. Please visit from the server machine.");
               Response.End();
          }

          WeavverMaster.SetToolbarVisibility(false);
          WeavverMaster.FormTitle = "Weavver First-Time Set-Up";
          WeavverMaster.FormDescription = "This wizard will help you configure Weavver for your first use.";

          //"Notice: To deploy the schema you need to change your web.config setting 'install_mode' from false to true to install Weavver.";

          //NHibernate.Cfg.ConfigurationSchema.HibernateConfiguration cfg = (NHibernate.Cfg.ConfigurationSchema.HibernateConfiguration)ConfigurationManager.GetSection("hibernate-configuration");
          //string con1 = ConfigurationManager.ConnectionStrings["weavver"].ConnectionString;
          //string con2 = cfg.SessionFactory.Properties["connection.connection_string"];
          //if (con1 != con2)
          //{
          //     ShowError("Your connection strings are out of sync. Please fix this in the web.config file.");
          //}

          string connectionString = ConfigurationManager.ConnectionStrings["WeavverEntityContainer"].ConnectionString;
          var entityBuilder = new System.Data.EntityClient.EntityConnectionStringBuilder(connectionString);
          var sqlBuilder = new System.Data.SqlClient.SqlConnectionStringBuilder(entityBuilder.ProviderConnectionString);
          DatabaseHost.Text = sqlBuilder.DataSource;
          DatabaseUsername.Text = sqlBuilder.UserID;
          DatabaseName.Text = sqlBuilder.InitialCatalog;
    }

        // Метод для асинхронного создания подключения к БД
        private async Task<bool> DbConnectAsync(string dbname)
        {                        
            try
            {
                // Создаем строку подключения
                EntityConnectionStringBuilder ConnectionString = new EntityConnectionStringBuilder();
                ConnectionString.ProviderConnectionString = "data source=" + Uchet.Properties.Settings.Default.dbDir
                                                             + dbname;
                ConnectionString.Provider = Uchet.Properties.Settings.Default.dbProvider;
                ConnectionString.Metadata = @Uchet.Properties.Settings.Default.dbMetadata;

                // Асинхронно создаем подключение
                await Task.Run(() => { 
                    this.DB = new DBEntity(ConnectionString.ToString());                    

                    // Задаем DataSource для таблиц в соответствии с таблицами БД приложения  
                    this.Invoke((Action)delegate{
                        gearCountEntityBindingSource.DataSource = DB.GC.ToList<GearCountEntity>();
                        gearCountEntityBindingSource.DataSource = DB.GC.Local.ToBindingList<GearCountEntity>();
                        gearPriceEntityBindingSource.DataSource = DB.GP.ToList<GearPriceEntity>();
                        gearSumEntityBindingSource.DataSource = DB.GS.ToList<GearSumEntity>();
                        gearSumEntityBindingSource.DataSource = DB.GS.Local.ToBindingList<GearSumEntity>();                    
                    });                    
                });                

                return true;
            }

            catch (Exception exeption)
            {                
                MessageBox.Show(exeption.Message, "Ошибка!");
            }

            return false;
        }

        public DBConnection()
        {
            // Specify the provider name, server and database.

            // 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 [email protected]"res://*/ShoeShopEntity.csdl|res://*/ShoeShopEntity.ssdl|res://*/ShoeShopEntity.msl";

            entity = new SHOESHOPEntities(entityBuilder.ToString());
        }

        public string GetConnectionString(string connection)
        {
            string connectionString = connection;

            try
            {
                DataConnectionConfiguration dcs = new DataConnectionConfiguration(null);
                DataConnectionDialog dcd = new DataConnectionDialog();

                //EF CONN STR to SQL CONNECTION
                EntityConnectionStringBuilder efstr = new EntityConnectionStringBuilder(connection);

                dcs.LoadConfiguration(dcd);
                dcd.ConnectionString = efstr.ProviderConnectionString;

                if (DataConnectionDialog.Show(dcd) == System.Windows.Forms.DialogResult.OK)
                {
                    connectionString = dcd.ConnectionString;
                }
                dcs.SaveConfiguration(dcd);

                //SQL CONNECTION TO EF CONN STR
                SqlConnectionStringBuilder sqlstr = new SqlConnectionStringBuilder(dcd.ConnectionString);
                efstr.ProviderConnectionString = sqlstr.ConnectionString;
                connectionString = efstr.ConnectionString;

            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }

            return connectionString;
        }

 public static ResetDatabase CreateFromEFConnectionString(string efConnStr)
 {
     var builder = new EntityConnectionStringBuilder(efConnStr);
     var connStr = builder.ProviderConnectionString;
     var conn = new SqlConnectionAdapterUsingSqlConnection(new SqlConnection(connStr));
     return new ResetDatabase(conn);
 }

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

        private EntityConnectionStringBuilder GetEntityBuilder()
        {
            SqlConnectionStringBuilder sqlBuilder =
                new SqlConnectionStringBuilder();

            // Set the properties for the data source.
            sqlBuilder.DataSource = serverName;
            sqlBuilder.InitialCatalog = databaseName;
            sqlBuilder.IntegratedSecurity = true;
            //sqlBuilder.UserID = user;
            //sqlBuilder.Password = pwd;

            // 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://*/MyEntities.csdl|
                            res://*/MyEntities.ssdl|
                            res://*/MyEntities.msl";
            return entityBuilder;
        }

        public ConnectionString(IConfigurationManager configuration, string name, string edmFilesPath,
            string ssdlFileName, string csdlFileName, string mslFileName)
        {
            if(String.IsNullOrEmpty(edmFilesPath))
            {
                edmFilesPath=_demFilesPath;
            }

            if(String.IsNullOrEmpty(ssdlFileName))
            {
                ssdlFileName=_ssdlFileName;
            }

            if(String.IsNullOrEmpty(csdlFileName))
            {
                csdlFileName=_csdlFileName;
            }
            if(String.IsNullOrEmpty(mslFileName))
            {
                mslFileName=_mslFileName;
            }

            string providerConnectionString=configuration.GetConnectionString(name);
            string providerName=configuration.GetProviderName(name);
            string metadata = String.Format(CultureInfo.InvariantCulture,
                _demMetadataFormat, edmFilesPath, csdlFileName, ssdlFileName, mslFileName);
            _entityBuilder = new EntityConnectionStringBuilder
            {
                ProviderConnectionString = providerConnectionString,
                Provider = providerName,
                Metadata = metadata
            };
        }

        // Обработчик загрузки страницы
        protected void Page_Load(object sender, EventArgs e)
        {            
            // Формируем список городов для просмотра 
            // погодных данных            
            CityList.Add(new City("Челябинск", 0));
            CityList.Add(new City("Москва", 1));
            CityList.Add(new City("Самара", 2));

            // Формируем список погодных сервисов            
            EntityConnectionStringBuilder ConnectionString =
                new EntityConnectionStringBuilder();
            ConnectionString.ProviderConnectionString =
                @"data source=|DataDirectory|YahooWeatherDB.sqlite";
            ConnectionString.Provider = @"System.Data.SQLite";
            ConnectionString.Metadata =
                @"res://*/Model1.csdl|res://*/Model1.ssdl|res://*/Model1.msl";
            WeatherServiceList.Add(new WeatherService("Yahoo! Weather",
                ConnectionString.ToString()));
            ConnectionString.ProviderConnectionString =
                @"data source=|DataDirectory|YandexWeatherDB.sqlite";
            WeatherServiceList.Add(new WeatherService("Яндекс Погода",
                ConnectionString.ToString()));

            // Привязываем список городов и погодных сервисов
            // к элементам интерфейса            
            foreach (City item in CityList)            
                if (!CityDropDownList.Items.Contains(new ListItem(item.Name)))
                    CityDropDownList.Items.Add(new ListItem(item.Name));                       
            foreach (var item in WeatherServiceList)
                if (!ServiceDropDownList.Items.Contains(new ListItem(item.Name)))
                    ServiceDropDownList.Items.Add(new ListItem(item.Name));                
        }

 public static string createInstanceConString()
 {
     EntityConnectionStringBuilder sb = new EntityConnectionStringBuilder();
     sb.Metadata = "res://*/CarPooling.csdl|res://*/CarPooling.ssdl|res://*/CarPooling.msl";
     sb.Provider = "System.Data.SqlClient";
     sb.ProviderConnectionString = @"data source=SCSBWIN-119391\SQLEXPRESS;initial catalog=VDSI_CARP;integrated security=True;MultipleActiveResultSets=True;App=EntityFramework";
     return sb.ConnectionString;
 }

 public static string GetEnityConnectionString(string providerConnectionString, string metadata)
 {
     System.Data.SqlClient.SqlConnectionStringBuilder scsb = new System.Data.SqlClient.SqlConnectionStringBuilder(providerConnectionString);
     EntityConnectionStringBuilder ecb = new EntityConnectionStringBuilder();
     ecb.Metadata = metadata;
     ecb.Provider = "System.Data.SqlClient";
     ecb.ProviderConnectionString = scsb.ConnectionString;
     return ecb.ConnectionString;
 }

 public static string LocalMachine(string databaseName)
 {
     var entityBuilder = new EntityConnectionStringBuilder();
         entityBuilder.Provider = "System.Data.SqlClient";
         entityBuilder.ProviderConnectionString =
             string.Format("data source=.;initial catalog={0};persist security info=True;user id=sa;password=d3hPOTraPC;multipleactiveresultsets=True;App={0}", databaseName);
         entityBuilder.Metadata = "res://*/Domain.csdl|res://*/Domain.ssdl|res://*/Domain.msl";
         return entityBuilder.ToString();
 }

        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 static EntityConnection Get(string schema)
        {
            var b = new EntityConnectionStringBuilder();
            b.Metadata = string.Format("res://*/{0}.csdl|res://*/{0}.ssdl|res://*/{0}.msl", schema);
            b.Provider = "System.Data.SqlClient";
            b.ProviderConnectionString = ConfigurationManager.ConnectionStrings["Bnh.Entities"].ConnectionString + "multipleactiveresultsets=True;App=EntityFramework";

            return new EntityConnection(b.ConnectionString);
        }