[System.Obsolete("use class B")]
class A
{
    public void Method() { }
}
class B
{
    [System.Obsolete("use NewMethod", true)]
    public void OldMethod()  { }
    public void NewMethod()  { }
}

在此例中，Obsolete 属性应用于类 A 和方法 B.OldMethod。由于应用于 B.OldMethod 的属性构造函数的第二个参数设置为 true，因此使用此方法将导致编译器错误，而使用类 A 只会产生警告。但是，调用 B.NewMethod 既不产生警告也不产生错误。

向属性构造函数提供的作为第一个参数的字符串将显示为警告或错误的一部分。例如，当与前面的定义一起使用时，下面的代码将生成两个警告和一个错误：

// Generates 2 warnings:
A a = new A();
// Generate no errors or warnings:
B b = new B();
b.NewMethod();
// Generates an error, terminating compilation:
b.OldMethod();

为类 A 产生两个警告：一个用于声明类引用，一个用于类构造函数。

一、首先引用几个命名空间

using System.IO;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;

二、定义可序列化的类

[Serializable]
public class Student
{
  
    private string name;
    private string id;
    private string studentNum;
    private ArrayList scores;

   /// <summary>
   /// 姓名
   /// </summary>
   public string Name
   {
    get { return name; }
    set { name = value; }
   }

   /// <summary>
   /// 编号
   /// </summary>
   public string Id
   {
    get { return id; }
    set { id = value; }
   }

   /// <summary>
   /// 学号
   /// </summary>
   public string StudentNum
   {
    get { return studentNum; }
    set { studentNum = value; }
   }

   /// <summary>
   /// 成绩表
   /// </summary>
   public ArrayList Scores
   {
    get { return scores; }
    set { scores = value; }
   }

}

三、序列化到硬盘文件中

    Student student = new Student();
    student.Id = "002";
    student.Name = "senty";
    student.StudentNum = "090325";
    ArrayList scores = new ArrayList();
    scores.Add(90);
    scores.Add(67);
    scores.Add(89);
    scores.Add(73);
    student.Scores = scores;

    #region 序列化对象
    IFormatter formatter = new BinaryFormatter();
    Stream stream = new FileStream("f:/student.dat", FileMode.Create, FileAccess.Write, FileShare.None);
    formatter.Serialize(stream, student);
    stream.Close();
    #endregion

四、从文件中反序列类实例

    #region 反序列化
    IFormatter formatter = new BinaryFormatter();
    Stream stream = new FileStream("f:/student.dat", FileMode.Open, FileAccess.Read, FileShare.Read);
    Student student = formatter.Deserialize(stream) as Student;
    this.label1.Text = "反序列化完成：";
    this.label1.Text += "\r\n编号：" + student.Id;
    this.label1.Text += "\r\n姓名：" + student.Name;
    this.label1.Text += "\r\n学号：" + student.StudentNum;
    this.label1.Text += "\r\n成绩：" + student.Scores[0] + "," + student.Scores[1] + "," + student.Scores[2] + "," + student.Scores[3] + ",";
    #endregion

除了可以序列化类实例到文件中外，还可以保存到数据库中，至于如何保存Stream到数据库中，不在本文关注的范围，有兴趣可以自己百度一下。

System.Net.Mail是.NET2.0新增的组件，利用它可以很方便实现邮件的收发，下面是通过SMTP发送邮件的方法

//先引用命名空间
using System.Net.Mail;

//方法一：纯代码的方法
MailMessage message = new MailMessage();
message.From = new MailAddress("name@gmail.com", "盛天");
message.To.Add(new MailAddress("to@qq.com")); // the email you want to send email to
message.Subject = "A test email" ;

message.IsBodyHtml = true;
message.BodyEncoding = System.Text.Encoding.UTF8;
message.Body = "this is just a simple test!<br> Jack";
message.Priority = MailPriority.Normal;

SmtpClient client = new SmtpClient("smtp.gmail.com", 587); // 587是Gmail使用的端口
client.Credentials = new System.Net.NetworkCredential("name@gmail.com", "123456"); // Your user name & password
client.EnableSsl = true; //经过ssl加密
object userState = message;
try
{
    client.Send(message);
    MessageBox.Show("邮件成功发送到" + message.To.ToString());
}
catch (Exception exp)
{
    MessageBox.Show(exp.Message + "\n" + exp.InnerException.Message);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//方法二：通过配置文件

MailMessage message = new MailMessage();
message.To.Add(new MailAddress("to@qq.com")); // the email you want to send email to
message.Subject = "A test email";

message.IsBodyHtml = true;
message.BodyEncoding = System.Text.Encoding.UTF8;
message.Body = "this is just a simple test!<br> Jack";
message.Priority = MailPriority.Normal;

SmtpClient client = new SmtpClient();
client.EnableSsl = true; //经过ssl加密
try
{
    client.Send(message);
    MessageBox.Show("邮件成功发送到" + message.To.ToString());
}
catch (Exception exp)
{
    MessageBox.Show(exp.Message + "\n" + exp.InnerException.Message);
}

//配置文件
<system.net>
    <mailSettings>
      <smtp from="from@gmail.com">
        <network host="smtp.gmail.com" port="587" userName="name@gmail.com" password="123456" />
        <!-- if has 'defaultCredentials="true"' , using Gmail can not send success -->
      </smtp>
    </mailSettings>
</system.net>

(图1)

现在来看看下面的执行计划：

(图2)

从图中可以看出来，根本没应用到Index_User_2索引，而是应用主键索引，开始对SQLServer摇头了；不着急，更严重的问题还在后面，再来看看下面的执行计划：

(图3)

没有什么比这更糟糕了，竟然也没使用到Index_User_2索引，这是怎么回事？难道SQLServer的优化程序是白痴吗？看了下来的执行计划，我终于明白了－－

这回终于使用上索引了，SQLServer果然非常“高明”，相当地佩服！！！

建议使用 sp_executesql 而不要使用 EXECUTE 语句执行字符串。支持参数替换不仅使 sp_executesql 比 EXECUTE 更通用，而且还使 sp_executesql 更有效，因为它生成的执行计划更有可能被 SQL Server 重新使用。

自包含批处理

sp_executesql 或 EXECUTE 语句执行字符串时，字符串被作为其自包含批处理执行。SQL Server 将Transact-SQL 语句或字符串中的语句编译进一个执行计划，该执行计划独立于包含 sp_executesql 或 EXECUTE 语句的批处理的执行计划。下列规则适用于自含的批处理：

• 直到执行 sp_executesql 或EXECUTE 语句时才将sp_executesql 或 EXECUTE 字符串中的 Transact-SQL 语句编译进执行计划。执行字符串时才开始分析或检查其错误。执行时才对字符串中引用的名称进行解析。
• 执行的字符串中的 Transact-SQL 语句，不能访问 sp_executesql 或 EXECUTE 语句所在批处理中声明的任何变量。包含 sp_executesql 或 EXECUTE 语句的批处理不能访问执行的字符串中定义的变量或局部游标。
• 如果执行字符串有更改数据库上下文的 USE 语句，则对数据库上下文的更改仅持续到 sp_executesql 或 EXECUTE 语句完成。

通过执行下列两个批处理来举例说明：

/* Show not having access to variables from the calling batch. */
DECLARE @CharVariable CHAR(3)
SET @CharVariable = 'abc'
/* sp_executesql fails because @CharVariable has gone out of scope. */
sp_executesql N'PRINT @CharVariable'
GO

/* Show database context resetting after sp_executesql completes. */
USE pubs
GO
sp_executesql N'USE Northwind'
GO
/* This statement fails because the database context
   has now returned to pubs. */
SELECT * FROM Shippers
GO

替换参数值

sp_executesql 支持对 Transact-SQL 字符串中指定的任何参数的参数值进行替换，但是 EXECUTE 语句不支持。因此，由 sp_executesql 生成的 Transact-SQL 字符串比由 EXECUTE 语句所生成的更相似。SQL Server 查询优化器可能将来自 sp_executesql 的 Transact-SQL 语句与以前所执行的语句的执行计划相匹配，以节约编译新的执行计划的开销。

使用 EXECUTE 语句时，必须将所有参数值转换为字符或 Unicode 并使其成为 Transact-SQL 字符串的一部分：

DECLARE @IntVariable INT
DECLARE @SQLString NVARCHAR(500)
/* Build and execute a string with one parameter value. */
SET @IntVariable = 35
SET @SQLString = N'SELECT * FROM pubs.dbo.employee WHERE job_lvl = ' +
                 CAST(@IntVariable AS NVARCHAR(10))
EXEC(@SQLString)
/* Build and execute a string with a second parameter value. */
SET @IntVariable = 201
SET @SQLString = N'SELECT * FROM pubs.dbo.employee WHERE job_lvl = ' +
                 CAST(@IntVariable AS NVARCHAR(10))
EXEC(@SQLString)

如果语句重复执行，则即使仅有的区别是为参数所提供的值不同，每次执行时也必须生成全新的 Transact-SQL 字符串。从而在下面几个方面产生额外的开销：

• SQL Server 查询优化器具有将新的 Transact-SQL 字符串与现有的执行计划匹配的能力，此能力被字符串文本中不断更改的参数值妨碍，特别是在复杂的 Transact-SQL 语句中。
• 每次执行时均必须重新生成整个字符串。
• 每次执行时必须将参数值（不是字符或 Unicode 值）投影到字符或 Unicode 格式。

sp_executesql 支持与 Transact-SQL 字符串相独立的参数值的设置：

DECLARE @IntVariable INT
DECLARE @SQLString NVARCHAR(500)
DECLARE @ParmDefinition NVARCHAR(500)

/* Build the SQL string once. */
SET @SQLString =
     N'SELECT * FROM pubs.dbo.employee WHERE job_lvl = @level'
/* Specify the parameter format once. */
SET @ParmDefinition = N'@level tinyint'

/* Execute the string with the first parameter value. */
SET @IntVariable = 35
EXECUTE sp_executesql @SQLString, @ParmDefinition,
                      @level = @IntVariable
/* Execute the same string with the second parameter value. */
SET @IntVariable = 32
EXECUTE sp_executesql @SQLString, @ParmDefinition,
                      @level = @IntVariable

此 sp_executesql 示例完成的任务与前面的 EXECUTE 示例所完成的相同，但有下列额外优点：

• 因为 Transact-SQL 语句的实际文本在两次执行之间未改变，所以查询优化器应该能将第二次执行中的 Transact-SQL 语句与第一次执行时生成的执行计划匹配。这样，SQL Server 不必编译第二条语句。
• Transact-SQL 字符串只生成一次。
• 整型参数按其本身格式指定。不需要转换为 Unicode。

说明   为了使 SQL Server 重新使用执行计划，语句字符串中的对象名称必须完全符合要求。

重新使用执行计划

在 SQL Server 早期的版本中要重新使用执行计划的唯一方式是，将 Transact-SQL 语句定义为存储过程然后使应用程序执行此存储过程。这就产生了管理应用程序的额外开销。使用 sp_executesql 有助于减少此开销，并使 SQL Server 得以重新使用执行计划。当要多次执行某个 Transact-SQL 语句，且唯一的变化是提供给该 Transact-SQL 语句的参数值时，可以使用 sp_executesql 来代替存储过程。因为 Transact-SQL 语句本身保持不变仅参数值变化，所以 SQL Server 查询优化器可能重复使用首次执行时所生成的执行计划。

下例为服务器上除四个系统数据库之外的每个数据库生成并执行 DBCC CHECKDB 语句：

USE master
GO
SET NOCOUNT ON
GO
DECLARE AllDatabases CURSOR FOR
SELECT name FROM sysdatabases WHERE dbid > 4

OPEN AllDatabases

DECLARE @DBNameVar NVARCHAR(128)
DECLARE @Statement NVARCHAR(300)

FETCH NEXT FROM AllDatabases INTO @DBNameVar
WHILE (@@FETCH_STATUS = 0)
BEGIN
   PRINT N'CHECKING DATABASE ' + @DBNameVar
   SET @Statement = N'USE ' + @DBNameVar + CHAR(13)
      + N'DBCC CHECKDB (' + @DBNameVar + N')'
   EXEC sp_executesql @Statement
   PRINT CHAR(13) + CHAR(13)
   FETCH NEXT FROM AllDatabases INTO @DBNameVar
END

CLOSE AllDatabases
DEALLOCATE AllDatabases
GO
SET NOCOUNT OFF
GO

当目前所执行的 Transact-SQL 语句包含绑定参数标记时，SQL Server ODBC 驱动程序使用 sp_executesql 完成 SQLExecDirect。但例外情况是 sp_executesql 不用于执行中的数据参数。这使得使用标准 ODBC 函数或使用在 ODBC 上定义的 API（如 RDO）的应用程序得以利用 sp_executesql 所提供的优势。定位于 SQL Server 2000 的现有的 ODBC 应用程序不需要重写就可以自动获得性能增益。有关更多信息，请参见使用语句参数。

用于 SQL Server 的 Microsoft OLE DB 提供程序也使用 sp_executesql 直接执行带有绑定参数的语句。使用 OLE DB 或 ADO 的应用程序不必重写就可以获得 sp_executesql 所提供的优势。