在C#中运用SQLDMO操作SQL Server 2000

最新推荐文章于 2024-09-14 02:04:54 发布
最新推荐文章于 2024-09-14 02:04:54 发布
阅读量382 收藏
点赞数
分类专栏： 数据库开发 文章标签： sql server c# string 数据库 exception sqlserver

在C#中运用SQLDMO能完成常用的SQL Server 2000管理工作。

SQLDMO(SQL Distributed Management Objects，SQL分布式管理对象)封装了SQL Server 2000数据库中的对象。

SQLDMO是SQL Server 2000中企业管理器所使用的应用程序接口，所以它可以执行很多功能，包括对数据库的创建、备份、恢复、删除、分离和和收缩以及各种对象信息的查询等等。

(SQLDMO.DLL放在C:/Program Files/Microsoft SQL Server/80/Tools/Binn目录下，使用前请添加该文件的引用。)

==========================================================================================

using System;
using System.Collections;
using System.Collections.Specialized;
using System.Data;
using System.Data.SqlClient;
using System.Configuration;
using System.IO;

/// <summary>
/// SQLDMO辅助类
/// </summary>
/// <remarks>
/// 使用前请添加 "SQLDMO.DLL"的引用。
/// </remarks>
public class SqlDmoHelper
{
private SQLDMO.SQLServer sqlServer;
SQLDMO.Application sqlApp;
private string server;//服务器名 (如：localhost)
private string loginname;//登录名 (如：sa)
private string password;//密码 (如：sa)

    public SqlDmoHelper(string server, string loginname, string password)
{
this.server = server;
this.loginname = loginname;
this.password = password;

        sqlApp = new SQLDMO.Application();
sqlServer = new SQLDMO.SQLServerClass();
sqlServer.Connect(server, loginname, password);
}

    #region DatabaseInfo
/// <summary>
/// 数据库信息
/// </summary>
public struct DatabaseInfo
{
public string Name;
public string Owner;
public string PrimaryFilePath;
public string CreateDate;
public int Size;
public float SpaceAvailable;
public string PrimaryName;
public string PrimaryFilename;
public int PrimarySize;
public int PrimaryMaxSize;
public string LogName;
public string LogFilename;
public int LogSize;
public int LogMaxSize;

        public override string ToString()
{
string s = "Name:{0}/r/n" +
"Owner:{1}/r/n" +
"PrimaryFilePath:{2}/r/n" +
"CreateDate:{3}/r/n" +
"Size:{4}MB/r/n" +
"SpaceAvailable:{5}MB/r/n" +
"PrimaryName:{6}/r/n" +
"PrimaryFilename:{7}/r/n" +
"PrimarySize:{8}MB/r/n" +
"PrimaryMaxSize:{9}MB/r/n" +
"LogName:{10}/r/n" +
"LogFilename:{11}/r/n" +
"LogSize:{12}MB/r/n" +
"LogMaxSize:{13}MB";

            return string.Format(s, Name, Owner, PrimaryFilePath, CreateDate, Size,
SpaceAvailable, PrimaryName, PrimaryFilename, PrimarySize,
PrimaryMaxSize, LogName, LogFilename, LogSize, LogMaxSize);
}
}
#endregion

    #region Property
/// <summary>
/// 获取主要版本信息
/// </summary>
public string Version
{
get
{
return string.Format("{0}.{1}",
sqlServer.VersionMajor, sqlServer.VersionMinor);
}
}
/// <summary>
/// 获取详细版本信息
/// </summary>
public string VersionString
{
get
{
return sqlServer.VersionString;
}
}
/// <summary>
/// 获取服务器时间
/// </summary>
public string ServerTime
{
get
{
return sqlServer.ServerTime;
}
}
/// <summary>
/// 获取或设置系统服务是否自动启动
/// </summary>
public bool AutostartServer
{
get
{
return sqlServer.Registry.AutostartServer;
}
set
{
sqlServer.Registry.AutostartServer = value;
}
}
/// <summary>
/// 获取字符集设置
/// </summary>
public string CharacterSet
{
get
{
return sqlServer.Registry.CharacterSet;
}
}
/// <summary>
/// 获取服务器物理内存大小(MB)
/// </summary>
public int PhysicalMemory
{
get
{
return sqlServer.Registry.PhysicalMemory;
}
}
/// <summary>
/// 获取服务器处理器(cpu)的数量
/// </summary>
public int NumberOfProcessors
{
get
{
return sqlServer.Registry.NumberOfProcessors;
}
}
#endregion

    #region Public Method
/// <summary>
/// 获取网络内所有可用的服务器
/// </summary>
/// <returns>string[]</returns>
public static string[] GetListAvailableSQLServers()
{
SQLDMO.Application sqlApp = new SQLDMO.ApplicationClass();
SQLDMO.NameList servers = sqlApp.ListAvailableSQLServers();
if (servers.Count <= 0)
return new string[0];
ArrayList list = new ArrayList(servers.Count);
foreach (object server in servers)
{
list.Add(server);
}
return (string[])list.ToArray(typeof(string));
}

    /// <summary>
/// 杀死正在使用指定的数据库进程
/// </summary>
/// <param name="dbName">数据库名</param>
/// <returns>是否杀死进程</returns>
public bool KillAllProcess(string dbName)
{
bool flag = false;
try
{
SQLDMO.QueryResults qr = sqlServer.EnumProcesses(-1);
// 获取SPID和DBNAME字段列序号
int iColPIDNum = -1;
int iColDbName = -1;
for (int i = 1; i < qr.Columns; i++)
{
string strName = qr.get_ColumnName(i);
if (strName.ToUpper().Trim() == "SPID")
{
iColPIDNum = i;
}
else if (strName.ToUpper().Trim() == "DBNAME")
{
iColDbName = i;
}
if (iColPIDNum != -1 && iColDbName != -1)
{
break;
}
}
// 杀死正在使用指定的数据库进程  
for (int i = 1; i < qr.Rows; i++)
{
int IPID = qr.GetColumnLong(i, iColPIDNum);
string strDBName = qr.GetColumnString(i, iColDbName);

                if (string.Compare(strDBName, dbName, true) == 0)
{
sqlServer.KillProcess(IPID);
}
}
flag = true;
}
catch (Exception ex)
{
flag = false;
throw ex;
}
return flag;
}

    /// <summary>
/// 获取数据库实体信息
/// </summary>
/// <param name="dbName">数据库名</param>
/// <returns>数据库实体信息</returns>
public DatabaseInfo GetDatabaseInfo(string dbName)
{
SQLDMO.Database db = GetDBObj(dbName);
if (db == null)
{
throw new Exception("Database not exists!");
}
DatabaseInfo info = new DatabaseInfo();
info.Name = db.Name;
info.Owner = db.Owner;
info.PrimaryFilename = db.PrimaryFilePath;
info.CreateDate = db.CreateDate;
info.Size = db.Size;
info.SpaceAvailable = db.SpaceAvailableInMB;

        SQLDMO.DBFile primary = db.FileGroups.Item("PRIMARY").DBFiles.Item(1);
info.PrimaryName = primary.Name;
info.PrimaryFilename = primary.PhysicalName.Trim();
info.PrimarySize = primary.Size;
info.PrimaryMaxSize = primary.MaximumSize;

        SQLDMO._LogFile log = db.TransactionLog.LogFiles.Item(1);
info.LogName = log.Name;
info.LogFilename = log.PhysicalName;
info.LogSize = log.Size;
info.LogMaxSize = log.MaximumSize;
return info;
}

    /// <summary>
/// 分离数据库
/// </summary>
/// <param name="dbName">数据库名</param>
/// <returns>分离是否成功</returns>
/// <remarks>
/// 分离前要调用KillAllProcess关闭所有连接，否则分离可能失败。
/// </remarks>
/// <example>
/// <code>
/// SqlDmoHelper dmo = new SqlDmoHelper("(local)", "sa", "sa");
/// dmo.DetachDB("test");
/// </code>
/// </example>
public bool DetachDB(string dbName)
{
bool flag = false;
try
{
KillAllProcess(dbName);
sqlServer.DetachDB(dbName, true);
flag = true;
}
catch (Exception ex)
{
flag = false;
throw ex;
}
return flag;
}

    /// <summary>
/// 附加数据库
/// </summary>
/// <param name="dbName">数据库名</param>
/// <param name="dbFile">dbFile</param>
/// <returns>附加是否成功</returns>
/// <example>
/// <code>
/// SqlDmoHelper dmo = new SqlDmoHelper("(local)", "sa", "sa");
/// dmo.AttachDB("test", @"d:/temp/database/test_data.mdf");
/// </code>
/// </example>
public bool AttachDB(string dbName, string dbFile)
{
bool flag = false;
try
{
sqlServer.AttachDB(dbName,dbFile);
flag = true;
}
catch (Exception ex)
{
flag = false;
throw ex;
}
return flag;
}

    /// <summary>
/// 物理删除数据库
/// </summary>
/// <param name="dbName">数据库名</param>
/// <returns>删除是否成功</returns>
/// <remarks>
/// 删除前要调用KillAllProcess关闭所有连接，否则删除可能失败。
/// </remarks>
/// <example>
/// <code>
/// SqlDmoHelper dmo = new SqlDmoHelper("(local)", "sa", "sa");
/// dmo.DeleteDB("test");
/// </code>
/// </example>
public bool DeleteDB(string dbName)
{
bool flag = false;
try
{
KillAllProcess(dbName); //先杀死正在使用中的数据库进程
sqlServer.KillDatabase(dbName);
flag = true;
}
catch (Exception ex)
{
flag = false;
throw ex;
}
return flag;
}

    /// <summary>
/// 创建数据库
/// </summary>
/// <param name="dbName">数据库名称</param>
/// <param name="path">数据文件保存路径</param>
/// <param name="primaryFileName">数据库文件名(不含路径)</param>
/// <param name="logFileName">日志文件名(不含路径)</param>
/// <returns>创建是否成功</returns>
/// <example>
/// <code>
/// SqlDmoHelper dmo = new SqlDmoHelper("(local)", "sa", "sa");
/// dmo.CreateDB("test1", @"d:/temp/database", "abc.mdf", "abc1.ldf");
/// </code>
/// </example>
public bool CreateDB(string dbName, string path, string primaryFileName, string logFileName)
{
bool flag = false;
try
{
//创建数据库文件
SQLDMO.DBFile dbFile = new SQLDMO.DBFileClass();
dbFile.Name = dbName + "_Data";
dbFile.PhysicalName = Path.Combine(path, primaryFileName);
dbFile.PrimaryFile = true;
dbFile.Size = 2;//初始化大小(MB)
dbFile.FileGrowthType = SQLDMO.SQLDMO_GROWTH_TYPE.SQLDMOGrowth_MB;
dbFile.FileGrowth = 1;//设置增长幅度

            //创建日志文件
SQLDMO._LogFile logFile = new SQLDMO.LogFileClass();
logFile.Name = dbName + "_Log";
logFile.PhysicalName = Path.Combine(path, logFileName);
logFile.Size = 3;
logFile.FileGrowthType = SQLDMO.SQLDMO_GROWTH_TYPE.SQLDMOGrowth_MB;
logFile.FileGrowth = 1;

            //创建数据库
SQLDMO.Database db = new SQLDMO.Database();
db.Name = dbName;
db.FileGroups.Item("PRIMARY").DBFiles.Add(dbFile);
db.TransactionLog.LogFiles.Add(logFile);

            //建立数据库连接，并添加数据库到服务器
sqlServer.Databases.Add(db);
flag = true;
}
catch (Exception ex)
{
flag = false; ;
throw ex;
}
return flag;
}

    /// <summary>
/// 创建数据库
/// </summary>
/// <param name="dbName">数据库名</param>
/// <returns></returns>
public string CreateDB(string dbName)
{
//函数返回结果
string rvCDB = "";
//新建数据库(包括路径)
string dbPath = sqlServer.Registry.SQLDataRoot + "//DATA//" + dbName;
bool DBExist = false;
foreach (SQLDMO.Database db in sqlServer.Databases)
{
if (db.Name == dbName)
{
DBExist = true;
}
}
try
{
if (DBExist)
{
rvCDB = "此数据库存名已存在请选择其它名称!";
sqlServer.Close();
sqlApp.Quit();
return rvCDB;
}
else
{
rvCDB = "创建数据库成功!";
}
SQLDMO.Database nDB = new SQLDMO.Database();
SQLDMO.DBFile nDBFile = new SQLDMO.DBFile();
SQLDMO.LogFile nLogFile = new SQLDMO.LogFile();

            nDB.Name = dbName;//数据库名
nDBFile.Name = dbName + "file";//数据库文件名
nDBFile.PhysicalName = dbPath + "_Data.mdf";//数据库文件在硬盘上存储的实际名称
nDBFile.PrimaryFile = true;
nDBFile.FileGrowthType = 0;
nDBFile.FileGrowth = 1;
nDB.FileGroups.Item("primary").DBFiles.Add(nDBFile);

            nLogFile.Name = dbName + "log";//日志文件名
nLogFile.PhysicalName = dbPath + "_Log.ldf";//日志文件在硬盘上存储的实际名称
nDB.TransactionLog.LogFiles.Add(nLogFile);
sqlServer.Databases.Add(nDB);
sqlServer.Close();
sqlApp.Quit();
}
catch (Exception ex)
{
throw new Exception("创建数据库失败! 错误信息：" + ex.Message);
}
return rvCDB;
}

    /// <summary>
/// 备份数据库
/// </summary>
/// <param name="dbName">要备份的数据库名</param>
/// <param name="bakFile">备份文件名(全路径)</param>
/// <param name="bakSetName">设置的备份文件名</param>
/// <param name="bakDesc">备份说明</param>
/// <returns>备份是否成功</returns>
/// <example>
/// <code>
/// SqlDmoHelper dmo = new SqlDmoHelper("(local)", "sa", "sa");
/// dmo.BackupDB("test", @"d:/temp/database/test.bak", "手动备份1", "备份说明...");
/// </code>
/// </example>
public bool BackupDB(string dbName, string bakFilePath, string bakSetName, string bakDesc)
{
bool flag = false;
try
{
SQLDMO.Backup oBackup = new SQLDMO.Backup();
oBackup.Action = SQLDMO.SQLDMO_BACKUP_TYPE.SQLDMOBackup_Database;
oBackup.Database = dbName;
oBackup.Files = bakFilePath;
oBackup.BackupSetName = bakSetName;
oBackup.BackupSetDescription = bakDesc;
oBackup.Initialize = true;
oBackup.SQLBackup(sqlServer);
flag = true;
}
catch (Exception ex)
{
flag = false;
throw ex;
}
return flag;
}

    /// <summary>
/// 恢复(还原)数据库
/// </summary>
/// <param name="dbName">数据库名</param>
/// <param name="bakFilePath">数据库备份文件的完整路径名</param>
/// <returns>恢复(还原)是否成功</returns>
/// <remarks>
/// 恢复前最好调用KillAllProcess关闭所有连接，否则恢复可能失败。
/// </remarks>
/// <example>
/// <code>
/// SqlDmoHelper dmo = new SqlDmoHelper("(local)", "sa", "sa");
/// dmo.RestoreDB("test", @"d:/temp/database/test.bak");
/// </code>
/// </example>
public bool RestoreDB(string dbName, string bakFilePath)
{
bool flag = false;
try
{
KillAllProcess(dbName); //先杀死正在使用中的数据库进程
SQLDMO.Restore oRestore = new SQLDMO.Restore();
oRestore.Action = SQLDMO.SQLDMO_RESTORE_TYPE.SQLDMORestore_Database;
oRestore.Database = dbName;
oRestore.Files = bakFilePath;
oRestore.FileNumber = 1;
oRestore.ReplaceDatabase = true;
oRestore.SQLRestore(sqlServer);
flag = true;
}
catch (Exception ex)
{
flag = false;
throw ex;
}
return flag;
}

    /// <summary>
/// 收缩数据库
/// </summary>
/// <param name="dbName">数据库名</param>
/// <returns>收缩是否成功</returns>
public bool ShrinkDB(string dbName)
{
bool flag = false;
try
{
SQLDMO.Database db = new SQLDMO.Database();
if (db == null)
throw new Exception("Database not exists!");
db.Shrink(0, SQLDMO.SQLDMO_SHRINK_TYPE.SQLDMOShrink_Default);
flag = true;
}
catch (Exception ex)
{
flag = false;
throw ex;
}
return flag;
}

    /// <summary>
/// 获取所有的数据库名
/// </summary>
/// <returns>string[]</returns>
public string[] GetAllDatabasesList()
{
ArrayList list = new ArrayList();
foreach (SQLDMO.Database d in sqlServer.Databases)
{
list.Add(d.Name);
}

        if (list.Count == 0)
return new string[0];
else
return (string[])list.ToArray(typeof(string));
}

    /// <summary>
/// 获取所有登录用户
/// </summary>
/// <returns>string[]</returns>
/// <remarks>
/// 管理工具 "安全性->登录"
/// </remarks>
public string[] GetAllLoginsList()
{
ArrayList list = new ArrayList();
foreach (SQLDMO.Login d in sqlServer.Logins)
{
list.Add(d.Name);
}

        if (list.Count == 0)
return new string[0];
else
return (string[])list.ToArray(typeof(string));
}

    /// <summary>
/// 获取所有数据表名称
/// </summary>
/// <param name="dbName">数据库名</param>
/// <returns>string[]</returns>
public string[] GetAllTablesList(string dbName)
{
SQLDMO.Database db = GetDBObj(dbName);
if (db == null)
throw new Exception("Data not exists!");
ArrayList list = new ArrayList();
foreach (SQLDMO.Table t in db.Tables)
{
list.Add(t.Name);
}

        if (list.Count == 0)
return new string[0];
else
return (string[])list.ToArray(typeof(string));
}

    /// <summary>
/// 获取数据库的所有存储过程名
/// </summary>
/// <param name="dbName">数据库名</param>
/// <returns>string[]</returns>
public string[] GetAllStoredProceduresList(string dbName)
{
SQLDMO.Database db = GetDBObj(dbName);
if (db == null)
throw new Exception("Data not exists!");
ArrayList list = new ArrayList();
foreach (SQLDMO.StoredProcedure sp in db.StoredProcedures)
{
list.Add(sp.Name);
}

        if (list.Count == 0)
return new string[0];
else
return (string[])list.ToArray(typeof(string));
}

    /// <summary>
/// 获取数据库对象
/// </summary>
/// <param name="dbName">数据库名</param>
/// <returns>SQLDMO.Database</returns>
/// <remarks>
/// 可以通过数据库对象获取数据库内表、存储过程、触发器、数据类型等信息。
/// </remarks>
/// <example>
/// 显示数据库中所有表及其结构
/// <code>
/// SqlDmoHelper dmo = new SqlDmoHelper("(local)", "sa", "sa");
/// SQLDMO.Database db = dmo.GetDBObj("test");
/// foreach(SQLDMO.Table t in db.Tables)
/// {
///     Console.WriteLine("Table:{0}", t.Name);
///     for (int i = 1; i <= t.Columns.Count; i++) // SQLDMO所有索引序号从1开始
///     {
///       SQLDMO._Column col = t.Columns.Item(i);
///       Console.WriteLine(" Column:{0} DataType:{1}", col.Name, col.Datatype);
///     }
///     Console.WriteLine("---------------");
/// }
/// </code>
/// </example>
public SQLDMO.Database GetDBObj(string dbName)
{
foreach (SQLDMO.Database db in sqlServer.Databases)
{
if (string.Compare(db.Name, dbName, true) == 0)
return db;
}
return null;
}
#endregion
}

longge7685
关注
专栏目录
C#中运用SQLDMO备份和恢复SQLServer数据库
08-15 214
SQLDMO(SQL Distributed Management Objects，SQL分布式管理对象)封装了Microsoft SQL Server数据库中的对象。SQLDMO是Microsoft SQL Server中企业管理器所使用的应用程序接口，所以它可以执行很多功能，其中当然也包括对数据库的备份和恢复。     SQLDMO由Microsoft SQL Server自带的SQLD
C#使用SQLDMO操作数据库的方法
12-31
SQLDMO.dll是随SQL Server2000一起发布的。SQLDMO.dll自身是一个COM对象 SQLDMO（SQL Distributed Management Objects，SQL分布式管理对象）封装 Microsoft SQL Server 2000 数据库中的对象。SQL-DMO 允许用支持自动...
C#引用sqldmo.dll的方法
eben_8292的博客
02-21 1051
找到 sqldmo.dll这个文件 C:\Program Files\Microsoft SQL Server\80\Tools\Binn\sqldmo.dll 用.Net框架提供的工具转成受托管代码 tlbimp sqldmo.dll /out: c:\SQLDMO.dll 如题，有没有办法呢？ 如果必须使用sqldmo，那么如何在没有安装sql的机器上使用这个com组件。...
SQLDMO的应用(一)列出可用服务器、连接服务器
06-18 996
SQL分布式管理对象(SQL-DMO)是Microsoft SQL Server 数据库管理对象封装的集合。它能实现：1. 完成Sql server管理任务 2. 创建和管理Sql Server对象 3. 创建和管理Sql Server Agent任务、警报等 4. Sql Server安装和配置要在C#中使用SQL-DMO，你必须在项目中添加COM引用。组件名称为：Microsoft S
C# 中使用SQL Server分布式管理对象（SQL-DMO）(转)
01-13 246
我们曾经在以前的应用中多次需要得到SQL Server的详细信息，过去，我们必须使用API和效率低下的ADO的 调用才能得到，现在，我们有了一个新的方法，就是SQLDMO（SQL Distributed Management Objects，SQL分布式管 理对象），尽管它目前还不被人所知和使用，但是SQLDMO提供了许多强有力的、和利用代码从SQL Server获得 信息相类似的许多
C#取数据库名称与数据库中表名的方法
cuanji3287的博客
10-22 464
在很多情况下我们需要将指定的数据库中的所有表都列出来。在使用c#进行软件开发时，我们有哪些方法可是实现这个目的呢？本人对此进行概要的总结，有以下6中方式可以实现这个目的。1、sqldmoSQLDMO是操作SQLServe...
在C#中运用SQLDMO备份SQL Server数据库
weixin_30726161的博客
10-02 60
DMO由一个动态链接库SQLDMO.DLL文件(在C:\Program Files\Microsoft SQL Server\80\Tools\Binn目录下) using System; using System.Collections.Generic; using System.Text; class Program { sta...
在C#中运用SQLDMO备份和恢复Microsoft SQL Server数据库
a683712的博客
10-24 88
摘自http://blog.csdn.net/chrch/archive/2004/06/04/18140.aspx SQLDMO(SQL Distributed Management Objects，SQL分布式管理对象)封装了Microsoft SQL Server数据库中的对象。SQLDMO是Microsoft SQL Server中企业管理器所使用的应用程序接口，所以它...
C#封装SQLDMO操作SQL Server 2000的类
专栏
08-28 550
封装SQLDMO操作的类，能完成常用的SQL Server 2000管理工作。 使用前请添加 "Microsoft SQLDMO Object Library" COM 引用。 有部分代码借鉴网络资料，再次向原作者表示感谢。 /* ********************************************** * Rainsoft Development Library
C#中运用SQLDMO备份和恢复Microsoft SQL Server数据库
gxj022的专栏
02-06 569
C#中运用SQLDMO备份和恢复Microsoft SQL Server数据库【转】  http://hi.baidu.com/zzj05142129/blog/item/6f50f53ef1d02ec47c1e7140.html  当不使用要恢复的数据库时以上方法可行，但当你使用了数据库时就必须杀死该进程   代码如下：       ///      ///   还原数据库函数 
C#列出局域网中可用SQL Server服务器
09-14
#### 使用SQLDMO在C#中列出局域网中的SQL Server服务器 为了使用SQLDMO，首先需要在.NET项目中添加对SQLDMO.dll的引用。这可以通过添加COM引用完成。通常情况下，SQLDMO.dll位于系统安装目录下的`Microsoft SQL ...
C# 获取本地SQL服务器SMO，非SQLDMO
11-15
1. 引入SMO库：在C#项目中，需要添加对`Microsoft.SqlServer.Smo.dll`和`Microsoft.SqlServer.ConnectionInfo.dll`的引用。这两个库通常位于SQL Server安装目录的`Assemblies`子目录下。 2. 使用Server类：SMO中的`...
c# program中引用日志组件
逍遥游的博客
09-11 251
// 应用程序的主入口点。
C#复习之内部类和分布类
2402_83809362的博客
09-05 752
知识点一：内部类 知识点二：分布类 知识点三：分部方法
C# WPF中实现数据库增删改查的三种方式
zls365365的博客
09-10 558
在C# WPF应用程序中，与数据库进行交互是一项常见且关键的任务。这通常涉及到执行增删改查（CRUD）操作。以下是三种在WPF中实现数据库CRUD操作的常见方式：使用ADO.NET、Entity Framework Core和Dapper。每种方式都有其特定的使用场景和优缺点。1. 使用ADO.NET代码示例：using System.Data.SqlClient; public class D...
C# 如何检查两个给定的线段是否相交（How to check if two given line segments intersect）
csdn_aspnet的专栏
09-11 921
( p1 , q1 , p2 )、( p1 , q1 , q2 )、( p2 , q2 , p1 ) 和 ( p2 , q2 , q1 ) 均为共线，且 – ( p1 , q1 ) 和 ( p2 , q2 )– ( p1 , q1 , p2 ) 和 ( p1 , q1 , q2 ) 具有不同的方向，并且。– ( p2 , q2 , p1 ) 和 ( p2 , q2 , q1 ) 具有不同的方向。的 x 投影相交 – ( p1 , q1 ) 和 ( p2 , q2 )的 y 投影相交。
说说synchronized的锁升级过程
最新发布
qq_62923382的博客
09-14 619
在 JDK 1.6之前，synchronized 是一个重量级、效率比较低下的锁，但是在JDK 1.6后，JVM 为了提高锁的获取与释放效，,对 synchronized 进行了优化，引入了和。锁升级就是的一个过程，注意，依次从耗费资源最少，性能最高，到耗费资源多，性能最差（Header）、（Instance Data）和：分为Mark Word 和 类型指针：存储对象的实际有效信息，也就是我们在类中所定义的各种类型的字段内容。
NLP基础及其代码-tokenizer
靓仔沾点健忘症，写给时间下游的自己
09-10 859
BPE、wordpiece、ulm、sentencepiece
C#使用SQLDMO进行SQL Server数据库备份与恢复
总结来说，这个示例展示了如何使用C#和SQLDMO库来实现SQL Server数据库的自动备份和恢复功能，这在系统维护和灾难恢复计划中是非常关键的。不过，考虑到SQLDMO已过时，对于新的开发项目，建议使用SMO，它提供了更多...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值