博客园-空空儿

在C#里使用属性

空空儿 — Sat, 28 Jun 2008 09:09:00 GMT

原文:Using Attribute In C#
绪论
     属性是一种新的声明性信息.使用属性既可以定义设计级信息(例如一个帮助文件或一个文档链接)又可以定义运行时信息(例如使一个XML和一个类相关联).也可以使用属性创建"自描述"组件.通过此篇教程,我们将了解如何创建并附加属性到不同的程序实体,和在运行时如何找到属性信息.
定义
   MSDN的描述是(ms-help://MS.MSDNQTR.2002APR.1033/csspec/html/vclrfcsharpspec_17_2.htm):"属性是附加说明的信息,既一个声明的详细说明".
使用预定义属性
  在C#里有一小部分预定义属性.在学习如何创建我们自定义属性前,我们先看看如何在我们的代码里使用那些属性.

using System;
public class AnyClass
{
  [Obsolete("Don't use Old method, use New method", true)]
  static void Old( ) { }

  static void New( ) { }

  public static void Main( )
  {
    Old( );
  }
}

    在这个例子里.我们使用Obsolete属性,标记一个不应再使用的程序实体.第一个参数是字符串,用来说明项为什么被作废和用什么代替.事实上,可以在这里写任何内容.第二个参数告诉编译器应将使用这项的地方当作一个错误.该参数的默认值是false,这意味着编译器会生成一个警告.
   当我们试图编译上面的程序,我们将得到一个错误:
   AnyClass.Old()' is obsolete: 'Don't use Old method, use New method'
开发自定义属性
   现在,我们将了解如何开发自己的属性.这里有个创建自定义属性的小窍门.
   按C#语言规范,将我们的属性类继承自System. Attribute就完成了我们的自定义属性(继承自抽象类System. Attribute,就直接或间接的成为一个属性类.属性类的声明从理论上定义了一种可被置于声明上的新属性).

using System;
public class HelpAttribute : Attribute
{
}

不管你是否相信,我们已经正确的创建了一个自定义属性.我们可以像使用Obsolete属性一样用上面的属性来装饰我们的类.

[Help()]
public class AnyClass
{
}

Note:使用关键字Attribute作为属性类名的后缀是一个约定.但是,当我们将属性附加到程序实体上时可以不用包含Attribute后缀.编译器首先在System.Attribute里查找属性.如果没有找到,编译器将关键字Attribute加到指定的属性名后然后再查找.
目前这个属性还没有什么用,让我们添加一些东西使它有用些.

using System;
public class HelpAttribute : Attribute
{
  public HelpAttribute(String Description_in)
  {
    this.description = Description_in;
  }
  protected String description;
  public String Description
  {
    get
    {
      return this.description;

    }
  }
}
[Help("this is a do-nothing class")]
public class AnyClass
{
}

   在上面的例子里,我们在属性类里添加了一个属性(property),在下一节里我们将在运行时查找这个属性(Description).
定义或控制自定义属性的用法
   AttributeUsage是另一个预定义类,这个类可以帮我们控制自定义属性类的使用.也就是说我们可以给自定义属性类定义属性.它说明了该如何使用一个自定义属性类.
   在自定义属性上使用AttributeUsage时,可以对AttributeUsage的3个属性(properties)进行赋值.下面我们来讨论这3个属性(properties).
ValidOn
   通过这个属性,我们可以定义自定义属性可以使用在那些程序体上. AttributeTargets枚举列出了属性可以使用的所有程序体.使用OR运算符可以联合使用多个AttributeTargets值.
AllowMultiple
   该属性(property)标明在同一个程序体上是否可以使用多个自定义属性.
Inherited
   此特性标志着属性是否可被从自定义属性类别中获得的类别所继承.

  让我们来实践下.我们将在Help属性类上使用AttrubuteUsage属性来控制Help属性类的用法.

using System;
[AttributeUsage(AttributeTargets.Class),
                AllowMultiple = false, Inherited = false ]
public class HelpAttribute : Attribute
{
  public HelpAttribute(String Description_in)
  {
    this.description = Description_in;
  }
  protected String description;
  public String Description
  {
    get
    {
      return this.description;
    }
  }
}

首先,看看AttributeTargets.Class.它规定Help属性只能用在类上.这意味着下面的代码将产生一个错误:
AnyClass.cs: Attribute 'Help' is not valid on this declaration type. It is valid on 'class' declarations only.
现在将它用在一个方法上.

Help("this is a do-nothing class")]
public class AnyClass
{
  [Help("this is a do-nothing method")]      //error
  public void AnyMethod()
  {
  }
}

[Help("this is a do-nothing class")]
[Help("it contains a do-nothing method")]
public class AnyClass
{
  [Help("this is a do-nothing method")]      //error
  public void AnyMethod()
  {
  }
}

    上面的代码产生一个编译时错误: AnyClass.cs: Duplicate 'Help' attribute
    现在让我们来讨论下最后一个属性(property). 继承意味着当一个属性被置于基类上时同时也被由基类衍生出来的类别所继承,如果属性类的Inherited为true,改属性可被继承.但是,如果属性类的Inherited为false或没有指定,该属性不能被继承.
    让我们来推想下面类关系的结果:

[AttributeUsage(AttributeTargets.Class, AllowMultiple = false, Inherited = false ]
[AttributeUsage(AttributeTargets.Class, AllowMultiple = true, Inherited = false ]
[AttributeUsage(AttributeTargets.Class, AllowMultiple = false, Inherited = true ]
[AttributeUsage(AttributeTargets.Class, AllowMultiple = true, Inherited = true ]

First Case
     如果我们查找Derive类的Help属性,我们将找不到它的属性(attribute),因为inherited值为false.
Second Case
     与上例没有什么不同, inherited值也为false.
Third Case
     为了解释第3和第4个例子,让我们给Derive类添加和Base类相同的属性.

[Help("BaseClass")]
public class Base
{
}
[Help("DeriveClass")]
public class Derive : Base
{
}

    如果我们现在查找Help属性,我们将仅得到Drive类的属性,因为继承属性值为true,但是不允许多重属性,所以基类的Help属性被Derive类的Help属性覆盖了.
Fourth Case
    在第4个例子里,当我们查找Derive类的Help属性时将得到所有的属性,因为继承和多重属性是被允许的.

    Note: AttributeUsage属性使用在继承自System.Attribute的类上才有效, AllowMultiple和Inherited默认都为false.
定位参数对命名参数
    定位参数是属性构造函数的参数.它们是一种强制值,无论属性被置于何种程序实体,此参数都必须传递给构造函数.另方面,命名参数实际上使用的是可选的无参构造函数.
    为了更详细的解释,让我们添加一些其他的属性(property)到Help属性类.

[AttributeUsage(AttributeTargets.Class,AllowMultiple = false,Inherited = false)]
public class HelpAttribute : Attribute
{
  public HelpAttribute(String Description_in)
  {
    this.description = Description_in;
    this.version = "No Version is defined for this class";
  }
  protected String description;
  public String Description
  {
    get
    {
      return this.description;
    }
  }
  protected String version;
  public String Version
  {
    get
    {
      return this.version;
    }
    //if we ever want our attribute user to set this property,
    //we must specify set method for it
    set
    {
      this.version = value;
    }
  }
}
[Help("This is Class1")]
public class Class1
{
}

[Help("This is Class2", Version = "1.0")]
public class Class2
{
}

[Help("This is Class3", Version = "2.0",Description = "This is do-nothing class")]
public class Class3
{
}

    当我们查找Class1的Help属性和它的属性(properties),我们将得到:
Help.Description : This is Class1
Help.Version :No Version is defined for this class
   因为我们没有为Version属性(property)指定任何值,所以使用构造函数里给定的值.如果没有指定值,则使用类型的默认值(例如,在本例,默认值为0).
   现在查找Class2的自定义属性及其属性(property)会得到如下结果:
Help.Description : This is Class2
Help.Version : 1.0
   不要为可选参数使用多个构造函数.应使用命名参数替代.当我们在构造函数里给它们赋值,我们需要他们的名字,这就是我们称之为命名的原因.例如,在第2个例子里,我们这样定义Help属性类.

[Help("This is Class2", Version = "1.0")]

    在AttributeUsage例子里, ValidOn是定位参数, Inherited和AllowMultiple是命名参数.
    Note:在属性的构造函数里给命名参数赋值,我们需要提供属性(property)的SET访问器.
'Version' : Named attribute argument can't be a read-only property
    在Class3里查找Help属性及其属性(property)会得到什么结果呢?结果同样是编译时错误.
'Description' : Named attribute argument can't be a read- only property
    现在修改Hele属性类,为Description添加一个Set访问器.现在输出将是:
Help.Description : This is do-nothing class Help.Version : 2.0
    在后台发生的事情是:使用定位参数调用第一个构造函数,然后依次调用命名参数的Set访问器.构造器里赋的值被SET访问器里赋的值覆盖了.
参数类型
属性类的参数类型被限制为下列类型:

bool, byte, char, double, float, int, long, short, string
System. Type
object
An enum type, provided that it and any types in which it is nested are publicly accessible
A one-dimensional array involving any of the types listed above

属性标志符
    假如我们要将Help属性应用到整个程序集,出现的第一个问题是:我们需要确定Help属性放在哪里编译器才能识别这是应用在整个程序集上的?另一种情况:要将属性应用在一个有返回类型的方法上时.编译器如何识别这是应用在一个返回类型的方法上而不是所有的方法上?
    我们使用属性标识符来解决这种模棱两可的问题.通过属性标识符,可以很明确地陈述要将属性应用于哪个实体.
    例如:

[assembly: Help("this a do-nothing assembly")]

在Help属性之前的Assembly标志符明确的告诉编译器当前属性应用于整个程序集,可能的标志符是:

assembly
module
type
method
property
event
field
param
return

在运行时查找属性
    我们已经了解了如何创建属性并如何将它们应用到程序单元上.现在我们来学习如何在运行时查找这些信息.
    我们可用.NET Framework的反射APIS通过程序集的元数据去迭代并生成由程序集所定义的包括所有类别,类型和方法的清单.
    还记得前面的Help属性和AnyClass类吗?

using System;
using System.Reflection;
using System.Diagnostics;

//attaching Help attribute to entire assembly
[assembly : Help("This Assembly demonstrates custom attributes creation and their run-time query.")]
//our custom attribute class
public class HelpAttribute : Attribute
{
  public HelpAttribute(String Description_in)
  {
    //
    // TODO: Add constructor logic here
    this.description = Description_in;
    //
  }
  protected String description;
  public String Description
  {
    get
    {
      return this.description;
    }
  }
}
//attaching the Help attribute to our AnyClass
[HelpString("This is a do-nothing Class.")]
public class AnyClass
{
//attaching the Help attribute to our AnyMethod
  [Help("This is a do-nothing Method.")]
  public void AnyMethod()
  {
  }
//attaching Help attribute to our AnyInt Field
  [Help("This is any Integer.")]
  public int AnyInt;
}
class QueryApp
{
  public static void Main()
  {
  }
}

在下2节我们将在Main方法里添加属性查找代码.
查找程序集属性
在下面的代码里,我们获取当前进程名并使用Assembly类的LoadFrom方法加载程序集.然后,使用GetCustomAttributes方法获取当前程序集里附加的所有自定义属性.其次,遍历所有的属性并尝试将属性转换为Help属性(如果转换是不合法的,使用as关键字转换对象比较有利,我们不用担心会抛出异常,因为转化的结果值为NULL).跟随的行检查转换是否合法和转换结果是否为NULL,然后显示Help属性.

class QueryApp
{
  public static void Main()
  {
    HelpAttribute HelpAttr;

    //Querying Assembly Attributes
    String assemblyName;
    Process p = Process.GetCurrentProcess();
    assemblyName = p.ProcessName + ".exe";

    Assembly a = Assembly.LoadFrom(assemblyName);

    foreach (Attribute attr in a.GetCustomAttributes(true))
    {
      HelpAttr = attr as HelpAttribute;
      if (null != HelpAttr)
      {
        Console.WriteLine("Description of {0}:\n{1}",
                           assemblyName,HelpAttr.Description);
      }
    }
}
}

上面的程序输出结果是:
Description of QueryAttribute.exe: This Assembly demonstrates custom attributes creation and their run-time query.
Press any key to continue.
查找类,方法,字段属性
在下面的代码里,唯一陌生的东西就是Main方法的第一行.

Type type = typeof(AnyClass);

使用typeof运算符获得AnyClass类的类型.其余的代码和前面的代码一样查找类里的属性,就不用再解释了.
要查找方法和字段的属性,首先需要获得类里定义的所有的方法和字段;然后像查找类属性一样查找相关联的属性.

class QueryApp
{
  public static void Main()
  {
    Type type = typeof(AnyClass);
    HelpAttribute HelpAttr;
    //Querying Class Attributes
    foreach (Attribute attr in type.GetCustomAttributes(true))
    {
      HelpAttr = attr as HelpAttribute;
      if (null != HelpAttr)
      {
        Console.WriteLine("Description of AnyClass:\n{0}",HelpAttr.Description);
      }
    }
    //Querying Class-Method Attributes
    foreach(MethodInfo method in type.GetMethods())
    {
      foreach (Attribute attr in method.GetCustomAttributes(true))
      {
        HelpAttr = attr as HelpAttribute;
        if (null != HelpAttr)
        {
          Console.WriteLine("Description of {0}:\n{1}",method.Name, HelpAttr.Description);
        }
      }
    }
    //Querying Class-Field (only public) Attributes
    foreach(FieldInfo field in type.GetFields())
    {
      foreach (Attribute attr in field.GetCustomAttributes(true))
      {
        HelpAttr= attr as HelpAttribute;
        if (null != HelpAttr)
        {
             Console.WriteLine("Description of {0}:\n{1}",field.Name,HelpAttr.Description);
        }
      }
    }
  }
}

上面的程序输出的结果是:
Description of AnyClass: This is a do-nothing Class.
Description of AnyMethod: This is a do-nothing Method.
Description of AnyInt: This is any Integer.
Press any key to continue

相关应用:Generate SQL Statements with objects, Attributes and Reflection

[新闻]51.COM技术副总裁邵辉跳槽百度
博客园首页社区新闻频道小组博问网摘闪存

Read text file (txt, csv, log, tab, fixed length)

空空儿 — Thu, 19 Jun 2008 09:10:00 GMT

绪论
我们经常需要读取并处理文本文件的数据，通常是用StreamReader (.NET) / FileSystemObject (VB 6.0)逐行读取.
假如我们可以像查询数据库的表一样读取文件并处理数据,我们会发现上面的方法有一些劣势.
一些劣势是:
1.保持连接环境.一直锁住文件直到处理完毕.
2.需要分隔每一行以得到部分列的数据.某些行的数据要是包含逗号处理起来就比较困难了.Example: “Yes, comma is here”,2,”Hello, another comma”,4,5,6
3.在读完数据开始处理之前我们没有筛选数据的选项.
4.要统计文件的记录条数或者统计包含特别类型的记录条数需要读完整个文件.
我们可以列举出更多的劣势.相对逐行读取的劣势而言使用数据库的表查询更有价值.
我们可以像读取一个数据库表一样读取文本文件吗?
如果答案是否定的也就没有这篇讨论的文章了.是的,我们可以像读取数据库表一样读取文件并且可以轻松克服前面提及的劣势.
读取数据
连接一个数据库并从表里查询数据是比较简单的.既然这样,我们就将文本文件当作表,将文件所在的目录当作数据库.
读取数据的步骤:
1.打开数据库连接
Note:这里的连接字符串很重要.它因我们要读的文件类型而有所不同.我们将在本文后面讨论.
2.使用基础查询语言获取结果集.
3.遍历结果集以读取字段.
C# Code:

DataSet myData = new DataSet();
string myXML;
string strFilePath = "C:\\";
string mySelectQuery = "SELECT * FROM SampleFile.CSV";
OleDbConnection myConnection = new OleDbConnection("Provider=Microsoft.Jet.OLEDB.4.0;Data Source=D:\\;" +
"Extended Properties=\"text;HDR=YES;FMT=Delimited\"");
OleDbDataAdapter dsCmd = new OleDbDataAdapter(mySelectQuery, myConnection);
//Fill the DataSet object
dsCmd.Fill(myData, "CustomerOwners");
//Create a XML document with the table data
myData.WriteXml("D:\\TestXML.xml");
myConnection.Close();

VB 6.0 code:

'Set the database connection
objConnection.Open "Provider=Microsoft.Jet.OLEDB.4.0;" & _
                   "Data Source=" & strFilePath & ";" & _
                   "Extended Properties=""text;HDR=YES;FMT=Delimited"""

'Query from the file assuming it as a database table
objRecordset.Open "SELECT * FROM " & fileName, _
          objConnection, adOpenStatic, adLockOptimistic, adCmdText

'Loop through the records and insert in to the table
Do Until objRecordset.EOF
    Debug.Print objRecordset.Fields.Item("Number")
    Debug.Print objRecordset.Fields.Item("Name")
objRecordset.MoveNext
Loop

我们像读取数据库表一样读取文本文件.让我们来看看这种方法的优势:
1.这种处理比较快
2.首先要说明下它处理数据行并分离数据的的方式.假如你的文本的某一列包含里有一个逗号(上面列出的第2点劣势),程序将自动处理这种情况.我们不必处理这种个别情况.
3.如果给定筛选标准我们可以查询出指定的记录行.
4.现在看来,很显然,在查询的时候可以使用非常有用的WHERE,HAVING或者GROUP子句
Ex: "SELECT Number, Count(Name) FROM SampleFile1.CSV GROUP BY Number HAVING Count(Name) >= 1"
5.我们可以基于条件过滤数据,一次性获取文件里符合条件的全部数据.这些可以使用 RowFilter/Filter属性或 DataView/RecordSe完成.如我曾说过的,一旦我们将数据读到 Dataset/RecordSet,我们可以使用它们完成所有的操作.包括筛选,排序等..
其他文件格式
我们讨论了读取使用逗号分隔的文件(CSV).那么如何使用这种方式处理TAB分隔的文件和固定长度的文件呢? 重点就是我们所提供的连接字符串。
让我们来看看连接字符串的具体内容:

Provider=Microsoft.Jet.OLEDB.4.0;Data Source=C:\FolderName;Extended Properties="text;HDR=YES;FMT=Delimited"

Provider – 代表数据库类型.我们使用OLEDB连接类型.
Data Source – 文件夹被当作数据库.
Extended Properties – 这些属性说明我们将使用哪种方式读取文件.
字符串的第一部分定义了文件类型.尽管文件格式可以分类为逗号分割,TAB分割或者固定长度的数据,但他们都是简单文本.如果我们读取EXCEL文件则需要使用EXCEL X.X,X.X是EXCEL的版本号.

HDR (Header) – 用来指定header(文件头)是否是可用的.YES - 文件的第一行被当作文件头,其他行是数据. NO - 数据从第一行开始. FMT (Format) –指定格式类型.可以是下面的值:

Delimited	数据以逗号分割的文件.逗号是默认的分割符.
Delimited(x)	数据以'X'分割符分割的文件.
TabDelimited	数据以TAB分割的文件.
FixedLength	以指定的长度读取数据.你可以通过 Col1, Col2 等指定列长度和类型. More at MSDN.

如果指定的格式是'Delimited',那么默认值是逗号(,),这个值存储在注册表里.可以修改HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Jet\4.0\Engines\Text\Format来改变默认设置.
不要随意修改注册表.对此MS提供了另一个可选的方法:提供我们一个Schema.ini文件.如果我们读取一个定长的文件,我们应当使用Schema.ini文件.在Schema.ini里指定字段的长度.
读取多文件
如果要将同列的多文件和数据合并与筛选，我们可以像在SQL里一样处理.我们可以连接表以得到合并后的数据.需要注意的是输出的数据是CROSS JOIN所有的文件的行.请确保你筛选的数据是基于相同的列.
Example:
SampleFile1.CSV – (EmpID, Name, Address)
SampleFile2.CSV – (EmpID, Salary, Month)

//Where clause is used to get ‘Natural Join’
string mySelectQuery = "SELECT * FROM SampleFile.CSV As Sample1, SampleFile2.CSV As Sample2 " +
                       "Where Sample1.Number=Sample2.Number";
'Where clause is used to get ‘Natural Join’
objRecordset.Open "SELECT * FROM SampleFile.CSV As Sample1, SampleFile2.CSV As Sample2 " & _
                  "Where Sample1.Number=Sample2.Number", _
                  objConnection, adOpenStatic, adLockOptimistic, adCmdText

别名(Sample1是SampleFile.CSV的别名)在JOIN查询里是必须的,尤其是当表有相同的列名时.在本列,表名(文件名)包含有点号(.),因此查询解析器将被表名里的点号误导,以致将‘CSV.Number’ 当作列名.
原文:Read text file (txt, csv, log, tab, fixed length)

[新闻]Mono 2.0终于到来
博客园首页社区新闻频道小组博问网摘闪存

批量写数据---将XML数据批量写入数据库

空空儿 — Fri, 23 May 2008 19:05:00 GMT

    将数据批量写入数据库的需求是比较多的，方法也有很多种，在.net 里使用程序比较好的方法是使用 Bulk Copy 将大量数据复制到数据库。如果数据源为XML文件，使用SQL BULK COPY就需要将XML数据导入到DataTable，下面的方法可以直接将XML数据传到SQL SERVER然后处理，另外还可以直接使用T-SQL将XML文件的数据导入到数据库。
这里最主要的是要使用二个系统存储过程：SP_XML_PREPAREDOCUMENT 和 SP_XML_REMOVEDOCUMENT
    SP_XML_PREPAREDOCUMENT 的功能是：读取XML文件后使用 MSXML 分析器 (Msxmlsql.dll) 对XML数据进行分析，并提供分析后的文档供使用。分析后得到的数据是对 XML 文件中的各节点（元素、属性、文本和注释等）以树状形式表现。分析后的数据存储在 SQL Server 的内部缓存中。
    SP_XML_REMOVEDOCUMENT 的功能是：根据文档句柄释放文档所占的内存。
    先建立一个XML字符串和一个表：

>
    <USER ID="1" Name="SBQCEL"/>
    <USER ID="2" Name="PEACELI"/>
    <USER ID="3" Name="SHEEPCHANG"/>
>

CREATE TABLE Users
(
UserId INT,
UserName VARCHAR(20)
)

处理的方法很简单：

DECLARE @HDOC INT    --文档句柄
DECLARE @XMLSTRING VARCHAR(200)        --XML字符串
SET @xmlString ='




'
--使用系统存储过程SP_XML_PREPAREDOCUMENT分析XML字符串
EXEC SP_XML_PREPAREDOCUMENT @HDOC OUTPUT, @XMLSTRING
--使用OPENXML从SQL Server 的内部缓存查询数据
INSERT INTO Users SELECT * FROM OPENXML(@HDOC,N'/ROOT/USER')
WITH
(
    ID INT,
    Name VARCHAR(10)
)
--使用系统存储过程SP_XML_REMOVEDOCUMENT释放内存
EXEC SP_XML_REMOVEDOCUMENT @HDOC

如果要用T-SQL直接读取一个XML文件并将数据导入到表里，需要做一些额外的处理：先要用XP_CMDSHELL将XML数据读到一个临时表（变量表），然后将每行数据组合成一个字符串，再用上面的方法处理。需要注意的是XP_CMDSHELL以行来处理数据的。下面是一个简单的事例：

--定义一个变量表临时存储调用XP_CMDSHELL后得到的数据
DECLARE @TEMP TABLE
(
    ID INT IDENTITY(1,1),
    XMLSTRING VARCHAR(200)
)
--使用XP_CMDSHELL将XML文件的数据插入到变量表里
INSERT INTO @TEMP EXEC MASTER.DBO.XP_CMDSHELL 'TYPE E:\A.XML'
DECLARE @LOOP INT,    --循环计数
        @COUNT INT,    --行数
        @XMLSTRING VARCHAR(200)    --存储XML字符串
SELECT  @LOOP = 1,    --从第1行开始
        @XMLSTRING='',    --初始化
        @COUNT = (SELECT COUNT(1) FROM @TEMP)    --获得行数
--做一个循环，将数据组合成一个字符串以便处理
WHILE (@LOOP<=@COUNT)
BEGIN
    SELECT @XMLSTRING = @XMLSTRING + XMLSTRING FROM @TEMP WHERE ID = @LOOP
    SET @LOOP = @LOOP + 1
END
--查看处理结果
SELECT @XMLSTRING

用上面的方法处理后就将一个XML文件的数据组合成一个字符串了，然后就可以用上面的方法将数据导入到数据库了。

[新闻]百度任命李一男担任首席技术官
博客园首页社区新闻频道小组博问网摘闪存

对对象类型和调用方法属性进行存储以提升反射性能

空空儿 — Fri, 25 Apr 2008 05:55:00 GMT

反射的性能差是一个公认的事实.而最耗性能的还是根据程序集获取要调用的对象,而在对象里搜索要调用的方法所耗性能到不不是很多,如果对象里的方法不是特别的多,而去可以指定相关参数提高搜索的效率,比如BindingFlags,Binder.
如果将对象的类型和方法属性进行一下存储,性能方法应该会得到改观.
简单的做了下测试:

    class Program
    {
        static IDictionary<string , Type> typeList = new Dictionary<string , Type>();

        static IDictionary<string , MethodInfo> methodList = new Dictionary<string , MethodInfo>();

        static void Main ( string[] args )
        {
            int iBegin = Environment.TickCount;
            for ( int i = 0 ; i < 1000 ; i++ )
            {
                Test1( "Test.TestClass,Test" );
                Test1( "Test1.Class1,Test1" );
            }
            Console.WriteLine( "普通：{0}" , Environment.TickCount - iBegin );

            GC.Collect();
            iBegin = Environment.TickCount;
            for ( int i = 0 ; i < 1000 ; i++ )
            {
                Test2( "Test.TestClass,Test" );
                Test2( "Test1.Class1,Test1" );
            }
            Console.WriteLine( "存储Type：{0}" , Environment.TickCount - iBegin );
            GC.Collect();

            iBegin = Environment.TickCount;
            for ( int i = 0 ; i < 1000 ; i++ )
            {
                Test3( "Test.TestClass,Test" );
                Test3( "Test1.Class1,Test1" );
            }
            Console.WriteLine( "存储MethodInfo：{0}" , Environment.TickCount - iBegin );
            GC.Collect();

            Console.ReadLine();
        }

        static void Test1 ( string typeName )
        {
            Type type = Type.GetType( typeName );
            object instance = Activator.CreateInstance( type , 1 );
            MethodInfo methodInfo = type.GetMethod( "GetValue" );
            methodInfo.Invoke( instance , null );

            instance = Activator.CreateInstance( type , null );
            methodInfo = type.GetMethod( "Add" , new Type[] { typeof( int ) , typeof( int ) } );
            methodInfo.Invoke( instance , new object[] { 1 , 2 } );
        }

        //存储Type
        static void Test2 ( string typeName )
        {
            Type type = GetType( typeName );

            object instance = Activator.CreateInstance( type , 1 );
            MethodInfo methodInfo = type.GetMethod( "GetValue" );
            methodInfo.Invoke( instance , null );

            instance = Activator.CreateInstance( type , null );
            methodInfo = type.GetMethod( "Add" , new Type[] { typeof( int ) , typeof( int ) } );
            methodInfo.Invoke( instance , new object[] { 1 , 2 } );
        }

        //存储MethodInfo
        static void Test3 ( string typeName )
        {
            Type type = GetType( typeName );
            object instance = Activator.CreateInstance( type , 1 );
            MethodInfo methodInfo = GetMethod( typeName , "GetValue" , type , new Type[0] );
            methodInfo.Invoke( instance , null );

            instance = Activator.CreateInstance( type , null );
            methodInfo = GetMethod( typeName , "Add" , type , new Type[] { typeof( int ) , typeof( int ) } );
            methodInfo.Invoke( instance , new object[] { 1 , 2 } );
        }

        static Type GetType ( string typeName )
        {
            Type type = null;
            if ( !typeList.ContainsKey( typeName ) )
            {
                type = Type.GetType( typeName );
                typeList.Add( typeName , type );
            }
            else
                type = typeList[typeName];
            return type;
        }

        static MethodInfo GetMethod ( string typeName , string methodName , Type type , params Type[] types )
        {
            MethodInfo methodInfo = null;
            if ( !methodList.ContainsKey( typeName + methodName ) )
            {
                methodInfo = type.GetMethod( methodName , types );
                methodList.Add( typeName + methodName , methodInfo );
            }
            else
                methodInfo = methodList[typeName + methodName];
            return methodInfo;
        }
    }

其中 Test.TestClass 类和 Test1.Class1 都有一个无参构造函数和一个int类型的参数及2个方法:

int val = 0;
public Class1 ( int val )
{
     this.val = val;
}
public string GetValue ()
{
     return string.Format( "the value is {0}" , val );
}
public int Add ( int a , int b )
{
     return a + b;
}

为了测试,上面2个类里都加了几个方法(只是定义,并没有具体的实现代码).
测试了下不进行任何处理,时间都在130左右波动,对Type进行存储,时间在32左右,基本上没什么波幅,而对Type和MethodInfo进行存储时间维持在31.
看来这样处理下对性能的改善还是起到了作用.

[新闻]Google Knol 开始尝试有声版
博客园首页社区新闻频道小组博问网摘闪存

过程 sp_addlinkedsrvlogin，第 91 行解密过程中出错的解决办法

空空儿 — Thu, 27 Mar 2008 13:43:00 GMT

今天用连接服务器实现分布式查询时注册了连接服务器后，在创建服务器间的远程登录映射时报错，错误消息如下：
消息 15466，级别 16，状态 2，过程 sp_addlinkedsrvlogin，第 91 行
解密过程中出错。
消息 15185，级别 16，状态 1，过程 sp_addlinkedsrvlogin，第 98 行
没有从远程服务器 'XXXXXX' 映射到本地用户 '(null)' 的远程用户 'XXXXXXX'。
开始还以为是语句写错了，看了下联机帮助，语句写得没问题,折腾了一番终于找到解决办法:
在本地服务器上执行: ALTER SERVICE MASTER KEY FORCE REGENERATE.
这个语句的功能是重新生成本地服务器的主密钥。

[新闻]12日电脑与人进行世纪对话可思考机器或诞生
博客园首页社区新闻频道小组博问网摘闪存

生成大量随机字符串不同实现方式的效率对比

空空儿 — Fri, 07 Mar 2008 16:31:00 GMT

在26位英文字母中随即选取10个字符组成字符串，产生一定数量的唯一字符串，对比几种方式：
1.使用 System.Security.Cryptography.RNGCryptoServiceProvider 生成 Random 的种子和使用普通声称随机数进行对比.
2.使用 IDictionary 其中TKey是 Int 型存放字符串的HashCode,TValue 是 String 型,存放生成的字符串,通过对比键判断是否项是否已经存在和使用 IList 存储字符串进行对比.
3.使用随机截取字符串和随机字符串数组索引获取组成字符串.

生成构建 Random 实例种子的方法:

static int GetRandomSeed( )
{
        byte[] bytes = new byte[4];
        System.Security.Cryptography.RNGCryptoServiceProvider rng = new System.Security.Cryptography.RNGCryptoServiceProvider( );
        rng.GetBytes( bytes );
        return BitConverter.ToInt32( bytes , 0 );
}

生成随机字符串的方法:

static string GetRandomString( )
{
        StringBuilder sbPwd = new StringBuilder( );
        Random random = new Random( GetRandomSeed( ) );
        for ( int i = 0 ; i < length ; i++ )
        {
             sbPwd.Append( strSource.Substring( random.Next( 0 , 25 ) , 1 ) );
             //sbPwd.Append( sourceArray[random.Next( 0 , 25 )] );
        }
        return sbPwd.ToString( );
}

对比结果:

1.使用 GetRandomSeed( )方法生成 Random 种子并使用字符截取使用IDictionary 耗时 20688MS 产生重复项 359 生成项:1000000
2.不使用 GetRandomSeed( )方法生成 Random 种子并使用字符截取使用IDictionary 耗时 1562547MS 产生重复项 127749442 生成项:100000
3.使用 GetRandomSeed( )方法生成 Random 种子并使用字符串数组使用IDictionary 耗时36125MS 产生重复项 381 生成项:1000000(使用Char数组效率更低,随机取得Char转换成String时要进行装箱)
4.使用GetRandomSeed( )方法生成 Random 种子并使用字符截取使用IList 耗时 214719MS 产生重复项2 生成项:100000(生成项越多耗时越长)

可见使用 System.Security.Cryptography.RNGCryptoServiceProvider 生成 Random 种子产生的效率要高很多,特别是要连续生成大量的随机数，因为 Random 生成值的重复率非常低.
使用字符串的HashCode对比字符串比直接对比字符串效率要高很多.
使用字符串截取比使用字符串数组效率要高点.

[新闻]人民网评:中国移动为什么要抛弃iPhone?
博客园首页社区新闻频道小组博问网摘闪存