C# Database.Create方法代码示例

        //MICROSOFT STRUCTURE METHODS
        //
        public string EP_ADD_MSSQL_DB(string ConnAuth, string Name)
        {
            //Create Database in SqlServer
            try
            {
                String connectionString = System.Configuration.ConfigurationManager.ConnectionStrings["EP_MSSQLRootConn"].ToString();

                SqlConnection sqlConnection = new SqlConnection(connectionString);
                ServerConnection conn = new ServerConnection(sqlConnection);
                Server srv = new Server(conn);

                //Connect to the local, default instance of SQL Server.
                // Server srv = new Server);
                //Define a Database object variable by supplying the server and the database name arguments in the constructor.
                Database db;
                db = new Database(srv, Name);
                //Create the database on the instance of SQL Server.
                db.Create();
                //db.SetOwner(Name);
                db.Alter();
                //Reference the database and display the date when it was created.
                //db = srv.Databases["Test_SMO_Database"];
                //Console.WriteLine(db.CreateDate);
                //Remove the database.
                //db.Drop();

                return "SQL Server Database Created";
            }
            catch (Exception e)
            {
                return e.ToString();
            }
        }

 public void Create(string databaseName)
 {
     var server = new Server(Settings.DefaultConnection.Host);
     try
     {
         if (server.Databases.Contains(databaseName))
         {
             Logger.WriteLine("Database {0} already exists.", databaseName);
             return;
         }
         Logger.Write("Creating database [{0}] ...", databaseName);
         var database = new Database(server, databaseName);
         database.Create();
         Logger.WriteLine("OK");
     }
     finally
     {
         if (server.ConnectionContext.IsOpen)
         {
             Logger.Write("Disconnecting...");
             server.ConnectionContext.Disconnect();
             Logger.WriteLine("OK");
         }
     }
 }

        public static Database CreateDatabase(this Server server, string databaseName)
        {
            var db = new Database(server, databaseName);
            db.Create();

            return db;
        }

        public void CreateSnaphot(string SnapshotName, string SourceDatabase, string SnapshotLocation)
        {
            Database SrcDatabase = _Server.Databases[SourceDatabase];

            Database SnapshotDatabase = new Database(_Server, SnapshotName);
            SnapshotDatabase.DatabaseSnapshotBaseName = SourceDatabase;

            foreach (FileGroup Group in SrcDatabase.FileGroups)
            {
                SnapshotDatabase.FileGroups.Add(new FileGroup(SnapshotDatabase, Group.Name));
                foreach (DataFile File in Group.Files)
                {
                    SnapshotDatabase.FileGroups[Group.Name].Files.Add(
                        new DataFile(
                            SnapshotDatabase.FileGroups[Group.Name],
                            File.Name,
                            SnapshotLocation + @"\" + SnapshotName + "_" + File.Name + ".ss")
                    );
                }
            }

            DropSnapshot(SnapshotName);

            SnapshotDatabase.Create();

            _Repository.Connection.ChangeDatabase(SourceDatabase);
        }

        public void CreateDatabase()
        {
            var connectoinStringBuilder = new SqlConnectionStringBuilder(ConnectionString);
            string dbName = connectoinStringBuilder.InitialCatalog;
            connectoinStringBuilder.InitialCatalog = string.Empty;

            using (var connection = new SqlConnection(connectoinStringBuilder.ToString()))
            {
                try
                {
                    var serverConnection = new ServerConnection(connection);
                    var server = new Microsoft.SqlServer.Management.Smo.Server(serverConnection);
                    var db = new Database(server, dbName);
                    db.Create();
                }
                catch (Exception e)
                {
                    throw new Exception(string.Format("Ошибка при создании БД - {0}", e));
                }
                finally
                {
                    if (connection.State == ConnectionState.Open)
                    {
                        connection.Close();
                    }
                }
            }
        }

        public void Connect(string sqlInstance)
        {
            Database database;
            if (String.IsNullOrEmpty(this.DatabaseName))
            {
                throw new ApplicationException("DatabaseName Is Null");
            }
            else
            {
                try
                {
                    m_Server = new Server(sqlInstance);
                    
                    m_Server.ConnectionContext.LoginSecure = true;

                    if (m_Server.Databases[this.DatabaseName] == null)
                    {
                        // Instantiate a new database object
                        database = new Database(m_Server, this.DatabaseName);

                        // Create the database as defined.
                        database.Create();
                    }

                    m_Server.ConnectionContext.SqlExecutionModes = SqlExecutionModes.ExecuteAndCaptureSql;
                }
                catch (Exception)
                {
                    //Handle a more specific exception in a production application
                    throw new ApplicationException("Connection Exception");
                }
            }
        }

 internal void CreateDatabase(string serverName, string databaseName)
 {
     Server server = new Server(serverName);
     Database database = server.Databases[databaseName];
     if (database != null)
         server.KillDatabase(databaseName);
     database = new Database(server, databaseName);
     database.Create();
 }

 public Database GetDatabase()
 {
     if (null == _database)
     {
         _database = new Database(GetServer(), "Test_" + Guid.NewGuid());
         _database.Create();
         _toDrop.Add(_database);
     }
     return _database;
 }

 public void CreatDb(string fileName = null)
 {
     var db = new Database(_server, _dbName);
     if (fileName != null)
     {
         fileName = Path.GetFullPath(fileName);
         db.FileGroups.Add(new FileGroup(db, "PRIMARY"));
         db.FileGroups[0].Files.Add(new DataFile(db.FileGroups[0], _dbName, fileName));
     }
     db.Create();
 }

        private static void CreateDatabase(string connectionString)
        {
            ConnectionString conn = ConnectionString.Parse(connectionString);
            Server server = new Server(conn.Server);
            Database db = server.Databases[conn.Database];
            if(db != null)
                throw new InvalidOperationException(String.Format("Attempting to create database '{0}' failed because it already exists.", conn.Database));

            db = new Database(new Server(conn.Server), conn.Database);
            db.Create();
        }

        public SqlServerFixture()
        {
            using (var connection = new SqlConnection(this.connectionString))
            {
                var serverConnection = new ServerConnection(connection);
                var server = new Server(serverConnection);
                var database = new Database(server, this.databaseName);

                database.Create();
            }
        }

        public void SetupGenerateTest()
        {
            var database = ServerSmo.Databases[TestDbName2];
            if (database != null)
            {
                database.Drop();
            }

            _database2 = new Database(ServerSmo, TestDbName2);
            _database2.Create();
        }

        public SqlDatabase(Server server, string databaseName)
        {
            if (!server.Databases.Contains(databaseName))
            {
                database = new Database(server, databaseName);
                database.Create();
            }
            else
            {
                database = server.Databases[databaseName];
            }

            Console.WriteLine("CurrentVersion: " + CurrentVersion.ToString());
        }

        protected override void Execute(SchemaMetadataElement metadataElement)
        {
            var connectionString = _settings.GetConnectionString(metadataElement.ConnectionStringIdentity);
            var server = _smoConnectionFactory.CreateServerConnection(metadataElement.ConnectionStringIdentity);
            var targetDbName = GetDatabaseName(connectionString);
            var existingDb = server.Databases[targetDbName];
            if (existingDb != null)
            {
                return;
            }

            var newDb = new Database(server, targetDbName);
            newDb.Create();
        }

        public override void Setup()
        {
            base.Setup();

            var server = new Server(Server);

            var database = server.Databases[TestDbName];
            if (database != null)
            {
                database.Drop();
            }

            _database = new Database(server, TestDbName);
            _database.Create();
        }