VID和PID通常情况下有两种存储方式，第一种是主控生产商的VID和PID，存储在主控的bootcode中；第二种是设备生产商的VID和PID，该VID和PID存储在主控外部的非易失性存储设备中（EEPROM或Flash）的设备固件中，当USB设备连接主机时，如果固件中有设备生产商的VID和PID，会将该VID和PID报告给主机，而忽略主控生产商的VID和PID。所以理论上一个USB存储设备的VID应该是设备生产商的VID，而不是主控生产商的VID，这两个VID应该是不同的（主控生产商自己生产的设备除外）。

      由于VID和PID重复并不会对产品的使用带来严重影响，很多USB设备生产商（山寨厂居多）为了方便，并不会向USB执行论坛申请自己的VID，而是依然沿用主控生产商的VID或随便向产品写入VID和PID；同时，正规厂家只需要申请VID，PID由厂家自行确定，所以存在相同型号的产品，可能采用了不同的主控（商业需要，很正常），而他们的PID是一样的，基于上述原因通过VID和PID就不能准确识别USB设备的主控型号，这个问题大家在使用USB设备的过程中需要注意。

理解SynchronizationContext

运行结果：
1、No context for this thread
2、We got a context
     
     从运行结果来看，在Form1 form = new Form1()之前，SynchronizationContext对象是为空，而当实例化Form1窗体后，SynchronizationContext对象就被附加到这个线程上了。所以可以得出答案了：当Control对象被创建的同时，SynchronizationContext对象也会被创建并附加到线程上。
     好的，我们既然已经基本了解了SynchronizationContext，接下来的事情就是使用它了！

如何使用SynchronizationContext

运行结果：

mToolStripButtonThreads_Click thread: 10
Run thread: 3
UpdateUI thread:10
UpdateUI thread:10
UpdateUI thread:10
UpdateUI thread:10
 (x1000 times)

　　 当你运行的时候， 你可能希望在UI线程上面去抛出，但是结果往往出忽你的意料，异常信息都在Run方法的线程上被捕获了。这时候你可能想问：WHY？！
　　 解释之前，我们先看下，Send VS Post的结果:
　　 Send 方法启动一个同步请求以发送消息
　　 Post 方法启动一个异步请求以发送消息。    
　　 哈哈，异常处理的答案迎韧而解了吧！

    今天就写到这里吧，下一篇和大家讨论下SynchronizationContext是否在所有线程中都适用...
 

漂漂 2010-09-07 12:10 发表评论

]]>

这个问题网上有成型的解决方法，引起闪烁的问题有两个：

一，是加入删除大量数据引起。

二，是没有开启LISTVIEW的双缓存功能。

我需要用一个TIMER实时更新LISTVIEW，遇到的是第二个问题，重载LISTVIEW，写一个新组件，然后在FORM.DESIGNER文件里将LISTVIEW替换为这个类即可：

 class DoubleBufferListView: ListView
    {
        public DoubleBufferListView()
        {
            SetStyle(ControlStyles.DoubleBuffer | ControlStyles.OptimizedDoubleBuffer | ControlStyles.AllPaintingInWmPaint, true);
            UpdateStyles(); 
        }
    } 

另外：加入删除大量数据

防止闪烁的ListView显示方案

相信做Win Form程序的朋友们一定遇到过在ListView中插入数据时，界面上一直在闪烁，而且速度很慢的情况吧。究其原因，还是在Windows消息机制没有使用好的原因。

本文对于ListView闪烁的原因，进行探究，并对于不同种的情况给出解决方案。

闪烁的原因

ListView闪烁的原因有以下几点或几种情况：
1：在数据多次插入间，存在时间间隔。
2：使用普通的Items.Add方法插入的数据量过大。
3：界面上有多个ListView在进行数据插入。

最根本的原因是因为，每次调用ListView实例进行插入的时候，都需要向系统发送一个窗口消息（相信做C＋＋的朋友应该很清楚），然后窗口接到消息就会刷新对应控件的界面。所以，如果间隔时间长，或插入次数多，一定会闪烁的。
  防止闪烁的ListView显示方案 收藏
The resolution of ListView Blink

防止闪烁的ListView显示方案

相信做Win Form程序的朋友们一定遇到过在ListView中插入数据时，界面上一直在闪烁，而且速度很慢的情况吧。究其原因，还是在Windows消息机制没有使用好的原因。

本文对于ListView闪烁的原因，进行探究，并对于不同种的情况给出解决方案。

闪烁的原因

ListView闪烁的原因有以下几点或几种情况：
1：在数据多次插入间，存在时间间隔。
2：使用普通的Items.Add方法插入的数据量过大。
3：界面上有多个ListView在进行数据插入。

最根本的原因是因为，每次调用ListView实例进行插入的时候，都需要向系统发送一个窗口消息（相信做C＋＋的朋友应该很清楚），然后窗口接到消息就会刷新对应控件的界面。所以，如果间隔时间长，或插入次数多，一定会闪烁的。

解决方案

源码中实例的解决方案：

ListViewItem lvi;

            ListViewItem[] lvitems1 = new ListViewItem[10000];

            for (int i = 0; i < 10000; i++)
            {
                lvi = new ListViewItem(new string[] { i.ToString(), "22" });
                lvitems1[i] = lvi;
            }

            listViewTest.Items.AddRange(lvitems1);更通用的解决方法：

// create a temp dataTable to store data
            DataTable dt = new DataTable();
            DataRow dr;
            dt.Columns.Add("ID", typeof(String));
            dt.Columns.Add("Name", typeof(String));
            dt.Columns.Add("Class", typeof(String));
            dt.Columns.Add("Lesson", typeof(String));

         foreach(item in dataSource)
         {
                    dr = dt.NewRow();
                    dr[0] = item.ID; // ID 
                    dr[1] = item.Name;  // Name
                    dr[2] = item.Class;  // Class
                    dr[3] = item.Lesson;  // Lesson

                    dt.Rows.Add(dr);

         }

            // loop the temp table , and insert to ListView

            int i = 0;
            while(iint iSize = (dt.Rows.Count-i)>1000?1000:(dt.Rows.Count-i);
                            
                ListViewItem lvi;

                ListViewItem[] lvitems = new ListViewItem[iSize];

                for (int j = 0; j < iSize; j++)
                {
                    lvi = new ListViewItem(new string[] { dt.Rows[i+j][0].ToString(), dt.Rows[i+j][1].ToString(), dt.Rows[i+j][2].ToString(), dt.Rows[i+j][3].ToString() });
                    lvitems[i] = lvi;
                }

                listViewTest.Items.AddRange(lvitems);

                i = i + iSize;
            }

主要思路是，建一个临时的Table，然后，把数据插入到这个临时表中；在处理结束之后，使用Items.AddRange方法把数据分块插入到ListView。

在设计中为了让界面与逻辑分离，我的做法是使用事件，界面只要响应事件来处理界面的显示就行了。而事件在逻辑处理中可能由不同的线程引发，这些事件的响应方法在修改界面中的控件内容时便会引发一个异常。

这时就用到了Control.InvokeRequired 属性 与Invoke方法。

MSDN中说：
获取一个值，该值指示调用方在对控件进行方法调用时是否必须调用 Invoke 方法，因为调用方位于创建控件所在的线程以外的线程中。
如果控件的 Handle 是在与调用线程不同的线程上创建的（说明您必须通过 Invoke 方法对控件进行调用），则为 true；否则为 false。
Windows 窗体中的控件被绑定到特定的线程，不具备线程安全性 。因此，如果从另一个线程调用控件的方法，那么必须使用控件的一个 Invoke 方法来将调用封送到适当的线程。该属性可用于确定是否必须调用 Invoke 方法，当不知道什么线程拥有控件时这很有用。

下面来说下这个的用法（我的一般做法）：
首先定义一个委托，与这个事件处理函数的签名一样委托，当然直接使用该事件的委托也是可以的，如：

private   delegate   void InvokeCallback( string msg); 

然后就是判断这个属性的值来决定是否要调用Invoke函数：

void m_comm_MessageEvent( string msg)
      {
     if (txtMessage.InvokeRequired)
       {
     InvokeCallbackmsgCallback =   new InvokeCallback(m_comm_MessageEvent);
      txtMessage.Invoke(msgCallback, new   object []   { msg } );
    } 
     else 
       {
     txtMessage.Text = msg;
    } 
   } 

说明：这个函数就是事件处理函数，txtMessage是一个文本框。
这样就做到了窗体中控件的线程安全性。

------------------

InvokeRequired 当前线程不是创建控件的线程时为true
比如你可以自己开一个Thread，或使用Timer的事件来访问窗体上的控件的时候，在线程中窗体的这个属性就是True的。

简单的说，如果有两个线程，Thread A和Thread B，并且有一个Control c，是在Thread A里面new的。
那么在Thread A里面运行的任何方法调用c.InvokeRequired都会返回false。
相反，如果在Thread B里面运行的任何方法调用c.InvokeRequired都会返回true。
是否是UI线程与结果无关。（通常Control所在的线程是UI线程，但是可以有例外）

也可以认为，在new Control()的时候，control用一个变量记录下了当前线程，在调用InvokeRequired时，返回当前线程是否不等于new的时候记录下来的那个线程。

--------------------

我理解：如果InvokeRequired==true表示其它线程需要访问控件，那么调用invoke来转给控件owner处理。

ps：C#多线程学习
http://www.cnblogs.com/xugang/archive/2008/04/06/1138856.html

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using System.Threading;

namespace WinThreadNew
{
    public partial class WinThreadNew : Form
    {
        int pro = 0;
        Thread backWork = null;
        public WinThreadNew()
        {
            InitializeComponent();
        }

        private void btnStart_Click(object sender, EventArgs e)
        {
            backWork = new Thread(new ThreadStart(doWork));
            backWork.Start();
        }

        public delegate void DelegateUpdateUIPro();
        private void doWork()
        {
            for (int i = 0; i < 100; i++ )
            {
                pro++;
                UpdateUIPro();
                Thread.Sleep(100);
            }
            
        }

        private void UpdateUIPro()
        {
            if (this.InvokeRequired)
            {
                this.BeginInvoke(new DelegateUpdateUIPro(UpdateUIPro));
            } 
            else
            {
                this.lblPro.Text = pro.ToString() + "%";
            }
        }

        private void Form1_FormClosed(object sender, FormClosedEventArgs e)
        {
            this.backWork.Abort();
            this.backWork.Join();
        }
    }
}

   当 Windows Form 应用程序启动时，会以下列顺序引发主要表单的启动事件：
        System.Windows.Forms.Control.HandleCreated
        System.Windows.Forms.Control.BindingContextChanged
        System.Windows.Forms.Form.Load
        System.Windows.Forms.Control.VisibleChanged
        System.Windows.Forms.Form.Activated
        System.Windows.Forms.Form.Shown

     当应用程序关闭时，会以下列顺序引发主要表单的关闭事件：         
       System.Windows.Forms.Form.Closing
        System.Windows.Forms.Form.FormClosing
        System.Windows.Forms.Form.Closed
        System.Windows.Forms.Form.FormClosed
        System.Windows.Forms.Form.Deactivate

2009-08-12 11:26

其实，两者之间还是有很大的区别的，对于它们的选择甚至反映出对于问题领域本质的理解、对于设计意图的理解是否正确、合理。本文将对它们之间的区别进行一番剖析，试图给开发者提供一个在二者之间进行选择的依据。
下面我们主要从设计理念层面看看abstract class和interface的区别！
abstarct class在C#语言中体现了一种继承关系，要想使得继承关系合理，父类和派生类之间必须存在"is a"关系，即父类和派生类在概念本质上应该是相同的。对于interface 来说则不然，并不要求interface的实现者和interface定义在概念本质上是一致的，仅仅是实现了interface定义的契约而已。为了使论述便于理解，下面将通过一个简单的实例进行说明。

考虑这样一个例子，假设在我们的问题领域中有一个关于Door的抽象概念，该Door具有执行两个动作open和close，此时我们可以通过abstract class或者interface来定义一个表示该抽象概念的类型，定义方式分别如下所示：

使用abstract class方式定义Door：
 
abstract class Door {
 abstract void open();
 abstract void close()；
}
 
使用interface方式定义Door：
 
interface Door {
 void open();
 void close();
} 

其他具体的Door类型可以extends使用abstract class方式定义的Door或者implements使用interface方式定义的Door。看起来好像使用abstract class和interface没有大的区别。

如果现在要求Door还要具有报警的功能。我们该如何设计针对该例子的类结构呢（在本例中，主要是为了展示abstract class和interface反映在设计理念上的区别，其他方面无关的问题都做了简化或者忽略）下面将罗列出可能的解决方案，并从设计理念层面对这些不同的方案进行分析。

解决方案一：

简单的在Door的定义中增加一个alarm方法，如下：

abstract class Door {
 abstract void open();
 abstract void close()；
 abstract void alarm();
}
 
 
或者
 
interface Door {
 void open();
 void close();
 void alarm();
} 

class AlarmDoor :Door {
 void open() { … }
 void close() { … }
 void alarm() { … }
}
 
 
或者
 
class AlarmDoor :Door ｛
 void open() { … }
 void close() { … }
 void alarm() { … }
｝ 

这种方法违反了面向对象设计中的一个核心原则ISP（Interface Segregation Priciple），在Door的定义中把Door概念本身固有的行为方法和另外一个概念"报警器"的行为方法混在了一起。这样引起的一个问题是那些仅仅依赖于Door这个概念的模块会因为"报警器"这个概念的改变（比如：修改alarm方法的参数）而改变，反之依然。
解决方案二：

既然open、close和alarm属于两个不同的概念，根据ISP原则应该把它们分别定义在代表这两个概念的抽象类中。定义方式有：这两个概念都使用abstract class方式定义；两个概念都使用interface方式定义；一个概念使用abstract class方式定义，另一个概念使用interface方式定义。

显然，由于Java语言不支持多重继承，所以两个概念都使用abstract class方式定义是不可行的。后面两种方式都是可行的，但是对于它们的选择却反映出对于问题领域中的概念本质的理解、对于设计意图的反映是否正确、合理。我们一一来分析、说明。

如果两个概念都使用interface方式来定义，那么就反映出两个问题：

1、我们可能没有理解清楚问题领域，AlarmDoor在概念本质上到底是Door还是报警器？

2、如果我们对于问题领域的理解没有问题，比如：我们通过对于问题领域的分析发现AlarmDoor在概念本质上和Door是一致的，那么我们在实现时就没有能够正确的揭示我们的设计意图，因为在这两个概念的定义上（均使用interface方式定义）反映不出上述含义。

如果我们对于问题领域的理解是：AlarmDoor在概念本质上是Door，同时它有具有报警的功能。我们该如何来设计、实现来明确的反映出我们的意思呢？前面已经说过，abstract class在C#语言中表示一种继承关系，而继承关系在本质上是"is a"关系。所以对于Door这个概念，我们应该使用abstarct class方式来定义。另外，AlarmDoor又具有报警功能，说明它又能够完成报警概念中定义的行为，所以报警概念可以通过interface方式定义。如下所示：

abstract class Door { 

abstract void open();
 abstract void close()；
}
interface Alarm {
 void alarm();
}
class AlarmDoor extends Door implements Alarm {
 void open() { … }
 void close() { … }
    void alarm() { … }
} 

这种实现方式基本上能够明确的反映出我们对于问题领域的理解，正确的揭示我们的设计意图。其实abstract class表示的是"is a"关系，interface表示的是"like a"关系，大家在选择时可以作为一个依据，当然这是建立在对问题领域的理解上的，比如：如果我们认为AlarmDoor在概念本质上是报警器，同时又具有Door的功能，那么上述的定义方式就要反过来了。

abstract class和interface是C#语言中的两种定义抽象类的方式，它们之间有很大的相似性。但是对于它们的选择却又往往反映出对于问题领域中的概念本质的理解、对于设计意图的反映是否正确、合理，因为它们表现了概念间的不同的关系（虽然都能够实现需求的功能）。这其实也是语言的一种的惯用法，希望读者朋友能够细细体会。
 
原文地址：http://www.cnblogs.com/yangbin990/archive/2005/09/13/236235.html

参考:Abstract and Sealed Classes and Class Members (C# Programming Guide).
public abstract class A
{
    // Class members here.
}
abstract :必须被继承.

public abstract class A
{
    public abstract void DoWork(int i);
}
abstract class 里也可包含abstract 方法, 但方法就没有{}, 因为abstract 方法不可以有内容. 继承abstract class 的class 内部必须定义那些abstract 方法, 给他真正的含义.

// compile with: /target:library
public class D
{
    public virtual void DoWork(int i)
    {
        // Original implementation.
    }
}

public abstract class E : D
{
    public abstract override void DoWork(int i);
}

public class F : E
{
    public override void DoWork(int i)
    {
        // New implementation.
    }
}

virtual:儿子类看不到的方法, 也就是说不想让儿子看到的方法.

public sealed class D
{
// Class members here.
}
sealed:sealed class 不可以做base class,也就是说不可以被继承.当然也不可以和abstract 同时出现, 因为正好互相抵触.

原文地址：http://www.cnblogs.com/3stones/archive/2007/03/22/684694.html

c#中的interface abstract 与 virtual
2007-02-13 10:42

    

        

            

            
 
            
interface用来声明接口
1.只提供一些方法规约，不提供方法主体.  如:
public interface IPerson
{
    void getName();//不包含方法主体
}
2.方法不能用public abstract等修饰,无字段变量，无构造函数。
3.方法可包含参数。  如  
  public interface IPerson
  {
    void getAge(string s);
  }
            
  一个例子(例1)：
public interface IPerson
{ 
   IPerson();              //错误
   string name;            //错误
   public void getIDcard();//错误
            
   void getName();         //right
   void getAge(string s);  //right
}
            
实现interface的类
1.与继承类的格式一致，如 public class Chinese:IPerson{}
2.必须实现 interface 中的各个方法
            
   例2，继承例1
public class Chinese:IPerson
{ 
   public Chinese(){}                  //添加构造
   public void getName(){}          //实现getName()
   public void getAge(string s){} //实现getAge()
}
            
abstract声明抽象类、抽象方法
1.抽象方法所在类必须为抽象类
2.抽象类不能直接实例化，必须由其派生类实现。
3.抽象方法不包含方法主体，必须由派生类以override方式实现此方法,这点跟interface中的方法类似
            
  如
public abstract class Book
{
  public Book()
  {   
  }
            
  public abstract void getPrice();      //抽象方法，不含主体
  public virtual void getName()   //虚方法，可覆盖
  {
      Console.WriteLine("this is a test:virtual getName()");
  }
  public virtual void getContent()   //虚方法，可覆盖
  {
      Console.WriteLine("this is a test:virtual getContent()");
  }
  public void getDate()                           //一般方法，若在派生类中重写，须使用new关键字
  {
      Console.WriteLine("this is a test: void getDate()");
   }
}
            
public class JavaBook:Book
{
      public override void getPrice()   //实现抽象方法，必须实现
      {
           Console.WriteLine("this is a test:JavaBook override abstract getPrice()");
      }
      public override void getName()   //覆盖原方法，不是必须的
      {
           Console.WriteLine("this is a test:JavaBook override virtual getName()");
      }
}
            
 测试如下：
public class test
{
   public test()
   {
    JavaBook jbook=new JavaBook();
         jbook.getPrice();      //将调用JavaBook中getPrice()
         jbook.getName();       //将调用JavaBook中getName()
         jbook.getContent();    //将调用Book中getContent()
         jbook.getDate();       //将调用Book中getDate()
            
    }
   public static void Main()
   {
            
       test t=new test();
   }
}
            
virtual标记方法为虚方法
1.可在派生类中以override覆盖此方法
2.不覆盖也可由对象调用
3.无此标记的方法(也无其他标记)，重写时需用new隐藏原方法
            
abstract 与virtual : 方法重写时都使用 override 关键字
interface中的方法和abstract方法都要求实现


原文地址：http://www.cnblogs.com/Dlonghow/archive/2008/07/26/1251974.html


            
C# 参考：internal 关键字使用小结
            
     最近在忙于Silverlight 上打印功能的实现，采用Report Definition Language(RDL) （一种 SQL Server 基于报表定义规范）。大体情况是：项目中一种原有的数据格式需要转换成一种通用的数据格式，由它来生成生成各种类型的文档（PDF、BMP等）。
            
     在定义框架的控件类时，真正对internal 访问修饰符有了较深的认识和使用，特总结如下，供参考：
            
     1. internal 关键字是类型和类型成员的访问修饰符。内部成员只有在同一程序集中的文件内才是可访问的。有关程序集的更多信息，请参见组件和程序集。
            
     2. 内部访问通常用于基于组件的开发，因为它使一组组件能够以私有方式进行合作，而不必向应用程序代码的其余部分公开。
            
        例如，用于生成图形用户界面的框架可以提供“控件”类和“窗体”类，这些类通过使用具有内部访问能力的成员进行合作。由于这些成员是内部的，它们不向正在使用框架的代码公开。
            
      在定义具有内部访问能力的成员的程序集外部，引用该成员是错误的
            
       警告  尽管不能用 C# 重写 internal virtual 方法，但可以用某些语言（如使用 Ilasm.exe 的文本 Microsoft 中间语言 (MSIL) 重写它。有关 internal 和其他访问修饰符的比较请参见 可访问性级别。
            


            
            
        
    










 

a) ReferenceEquals
ReferenceEquals是Object的静态方法，用于比较两个引用类型的对象是否是对于同一个对象的引用。对于值类型它总是返回false。（因为Box以后的对象总是不同的，hehe）

b) ==是一个可以重载的二元操作符,可以用于比较两个对象是否相等。
对于内置值类型，==判断的是两个对象的代数值是否相等。它会根据需要自动进行必要的类型转换，并根据两个对象的值是否相等返回true或者false。例如：

Int a = 100;
Double b =100;

If(a == b)
Console.WriteLine(“equal supports compare between different types!”);

上面这段程序将会输出：
equal supports compare between different types!

而对于用户定义的值类型，如果没有重载==操作符，==将是不能够使用的。例如：

Struct Userstruct1;
Userstruct1 a;
Userstruct1 b;

If(a == b)
Console.WriteLine(“can == reach this far?”)

上面的这段代码是不能够通过编译的。可以通过重载使==作用于用户定义的值类型。

对于引用类型，== 默认的行为与ReferenceEquals的行为相同，仅有两个对象指向同一个Reference的时候才返回true。但是.NET Framework中的类很多对==进行了重载，例如String类的==与Equals的行为相同，判断两个字符串的内容是否相等。所以在应用中，对于 系统定义的引用类型建议不要使用==操作符，以免程序出现与预期不同的运行结果。

c) Equals 作为Object内置方法，Equals支持对于任意两个CTSCommon Type System对象的比较。
Equals它有静态方法和可重载的一个版本，下面的程序片断解释了这两个方法的用法，

int a = 5;
int b = 5;

If(Object.Equals(a ,b))
// you can also use if(a.Equals(b))
{
Console.WriteLine(“a is equal to b”);
}

事实上，这两个版本的结果完全相同，如果用户重载了Equals，调用的都是用户重载后的Equals。Equals的静态方法的好处是可以不必考虑用于比较的对象是否为null。

Equals方法对于值类型和引用类型的定义不同，对于值类型，类型相同，并且数值相同(对于struct的每个成员都必须相同)，则Equals返回 true,否则返回false。而对于引用类型，默认的行为与ReferenceEquals的行为相同，仅有两个对象指向同一个Reference的时 候才返回true。可以根据需要对Equals进行重载，例如String类的Equals用于判断两个字符串的内容是否相等。

//StringBuilder 类
//表示可变字符字符串。无法继承此类。

StringBuilder a = new StringBuilder();
a.Append("the test a");
String s1 = a.ToString();
String s2 = "the test a";

if (s2 == s1)
Console.WriteLine("== returns true");

if (Object.Equals(s2, s1))
{
Console.WriteLine("equals returns true");
}

if (Object.ReferenceEquals(s2, s1))
{
Console.WriteLine("ReferenceEquals returns true");
}

这个实例将输出：
== returns true
equals returns true

注：对于String类，直接声明s1 = “the test a”的话，输出结果将包含 "ReferenceEquals returns true"，
因为默认的，String对于声明的相同的字符串在堆上只保留一个Copy，所以s1与s2将会指向相同的Reference
。
http://javasky.bloghome.cn/posts/142567.html

在讨论了运算符，并简要介绍了等于运算符后，就应考虑在处理类和结构的实例时相等意味着什么。理解对象相等比较的机制对编写逻辑表达式非常重要，另外，对实现运算符重载和数据类型转换也非常重要，本章的后面将讨论运算符重载。

    对象相等比较的机制对于引用类型(类的实例)的比较和值类型(基本数据类型，结构或枚举的实例)的比较来说是不同的。下面分别介绍引用类型和值类型的相等比较。

   5.3.1 引用类型的相等比较

    System.Object的一个初看上去令人惊讶的方面是它定义了3个不同的方法，来比较对象的相等性：ReferenceEquals()和Equals()的两个版本。再加上比较运算符==，实际上有4种进行相等比较的方式。这些方法有一些微妙的区别，下面就介绍这些方法。

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

下面的最明了

1. ReferenceEquals()方法

    ReferenceEquals()是一个静态方法，测试两个引用是否指向类的同一个实例，即两个引用是否包含内存中的相同地址。作为静态方法，它不能重写，所以只能使用System.Object的实现代码。如果提供的两个引用指向同一个对象实例，ReferenceEquals()总是返回true，否则就返回false。但是它认为null等于null：

SomeClass x, y;

x = new SomeClass();

y = new SomeClass();

bool B1 = ReferenceEquals(null, null);                //return true

bool B2 = ReferenceEquals(null, x);                //return false

bool B3 = ReferenceEquals(x, y);                  //return false because x and y

                                            //point to different objects

2. 虚拟的Equals()方法

    Equals()虚拟版本的System.Object实现代码也比较引用。但因为这个方法是虚拟的，所以可以在自己的类中重写它，按值来比较对象。特别是如果希望类的实例用作字典中的键，就需要重写这个方法，以比较值。否则，根据重写Object.GetHashCode()的方式，包含对象的字典类要么不工作，要么工作的效率非常低。在重写Equals()方法时要注意，重写的代码不会抛出异常。这是因为如果抛出异常，字典类就会出问题，一些在内部调用这个方法的.NET基类也可能出问题。

3. 静态的Equals()方法

    Equals()的静态版本与其虚拟实例版本的作用相同，其区别是静态版本带有两个参数，并对它们进行相等比较。这个方法可以处理两个对象中有一个是null的情况，因此，如果一个对象可能是null，这个方法就可以抛出异常，提供了额外的保护。静态重载版本首先要检查它传送的引用是否为null。如果它们都是null，就返回true(因为null与null相等)。如果只有一个引用是null，就返回false。如果两个引用都指向某个对象，它就调用Equals()的虚拟实例版本。这表示在重写Equals()的实例版本时，其效果相当于也重写了静态版本。[Page]

4. 比较运算符＝＝

最好将比较运算符看作是严格值比较和严格引用比较之间的中间选项。在大多数情况下，下面的代码：

bool b = (x == y);          //x, y object references

   表示比较引用。但是，如果把一些类看作值，其含义就会比较直观。在这些情况下，最好重写比较运算符，以执行值的比较。后面将讨论运算符的重载，但显然它的一个例子是System.String类，Microsoft重写了这个运算符，比较字符串的内容，而不是它们的引用。

5.3.2 值类型的相等比较

在进行值类型的相等比较时，采用与引用类型相同的规则：ReferenceEquals()用于比较引用，Equals()用于比较值，比较运算符可以看作是一个中间项。但最大的区别是值类型需要装箱，才能把它们转换为引用，才能对它们执行方法。另外，Microsoft已经在System.ValueType类中重载了实例方法Equals()，以便对值类型进行合适的相等测试。如果调用sA.Equals(sB)，其中sA和sB是某个结构的实例，则根据sA和sB是否在其所有的字段中包含相同的值，而返回true或false。另一方面，在默认情况下，不能对自己的结构重载==运算符。在表达式中使用(sA==sB)会导致一个编译错误，除非在代码中为结构提供了==的重载版本。

另外，ReferenceEquals()在应用于值类型时，总是返回false，因为为了调用这个方法，值类型需要装箱到对象中。即使使用下面的代码：

bool b = ReferenceEquals(v, v);          //v is a variable of some value type

也会返回false，因为在转换每个参数时，v都会被单独装箱，这意味着会得到不同的引用。调用ReferenceEquals()来比较值类型实际上没有什么意义。

尽管System.ValueType提供的Equals()默认重载肯定足以应付绝大多数自定义的结构，但仍可以为自己的结构重写它，以提高性能。另外，如果值类型包含作为字段的引用类型，就需要重写Equals()，以便为这些字段提供合适的语义，因为Equals()的默认重写版本仅比较它们的地址。

http://www.zxbc.cn/html/20070809/25909.html

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

http://msdn.microsoft.com/zh-cn/library/bsc2ak47(VS.80).aspx

Object.Equals 方法 (Object)
确定指定的 Object 是否等于当前的 Object。

参数
obj
与当前的 Object 进行比较的 Object。

返回值
如果指定的 Object 等于当前的 Object，则为 true；否则为 false。

 备注
Equals 的默认实现仅支持引用相等，但派生类可重写此方法以支持值相等。

对于引用类型，相等定义为对象相等；即这些引用是否引用同一对象。对于值类型，相等定义为按位相等。ValueType 类支持值类型。

给实现者的说明 此方法可由派生类重写。例如，如果两个对象表示相同的值，则许多基数据类型返回 true；否则返回 false。 此方法仅比较基元和对象。若要比较更复杂的结构（如对象数组），必须重写该方法。 下面的语句对于 Equals 方法的所有实现均必须为真。在列表中，x、y 和 z 表示不为 空引用（在 Visual Basic 中为 Nothing） 的对象引用。

除涉及浮点型的情况外，x.Equals(x) 都返回 true。请参见 IEC 60559:1989, Binary Floating-point Arithmetic for Microprocessor Systems。

x.Equals(y) 返回与 y.Equals(x) 相同的值。

如果 x 和 y 都为 NaN，则 x.Equals(y) 返回 true。

当且仅当 x.Equals(z) 返回 true 时，(x.Equals(y) && y.Equals(z)) 才返回 true。

只要不修改 x 和 y 引用的对象，对 x.Equals(y) 的相继调用将返回相同的值。

x.Equals(空引用（在 Visual Basic 中为 Nothing）) 返回 false。

有关属于 Equals 方法的其他必需行为，请参见 GetHashCode。 Equals 的实现必须不引发异常。 对于某些类型的对象，最好让 Equals 测试值相等性而非引用相等性。如果两个对象具有相同的“值”，那么即使它们不是同一实例，这样的 Equals 实现仍返回 true。类型实施者决定对象的“值”的构成，但这通常是存储在对象的实例变量中的部分或全部数据。例如，String 的值基于字符串的字符；对于两个按同样的顺序包含完全相同的字符的字符串实例，String 类的 Equals 方法返回 true。 实现 IComparable 的类型必须重写 Equals。 重写 Equals 的类型也必须重写 GetHashCode；否则，Hashtable 可能不正常工作。 如果编程语言支持运算符重载，并且您选择了重载给定类型的相等运算符，则该类型必须重写 Equals 方法。这样的 Equals 方法实现必须返回与相等运算符相同的结果。遵照此准则有助于确保使用 Equals 的类库代码（如 ArrayList 和 Hashtable）的行为方式与应用程序代码使用的相等运算符的方式一致。 下面是针对实现值类型的准则：
考虑重写 Equals，以便在 ValueType 上获得比 Equals 的默认实现所提供的性能增强的性能。

如果重写 Equals 并且语言支持运算符重载，则必须重载值类型的相等运算符。

下面是针对实现引用类型的准则：
如果引用类型的语义是基于该类型表示某个（些）值的事实，则考虑对该类型重写 Equals。

即使大多数引用类型重写 Equals，它们也必须不能重载相等运算符。但是，如果实现的引用类型想要具有值语义（如复杂的数字类型），则必须重写相等运算符。

using System;

public class Sample {
    void Method() {
    Object Obj1 = new Object();
    Object Obj2 = new Object();
    Console.WriteLine(Obj1.Equals(Obj2)); //===> false
    Obj2 = Obj1;
    Console.WriteLine(Obj1.Equals(Obj2)); //===> true
    }
}

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

Object.Equals 方法 (Object, Object)

确定指定的 Object 实例是否被视为相等。

参数
objA
要比较的第一个 Object。

objB
要比较的第二个 Object。

返回值
如果 objA 是与 objB 相同的实例，或者如果两者均为空引用，或者如果 objA.Equals(objB) 返回 true，则为 true；否则为 false。

 备注
Equals 的默认实现仅支持引用相等，但派生类可重写此方法以支持值相等。

对于引用类型，相等定义为对象相等；即这些引用是否引用同一对象。对于值类型，相等定义为按位相等。ValueType 类支持值类型。

在调用 objA.Equals(objB) 前，此方法首先检查两个参数是否均为空引用。

 示例
下面的代码示例比较不同的对象。

C#

using System;

public class MyClass {
   public static void Main() {
   string s1 = "Tom";
   string s2 = "Carol";
   Console.WriteLine("Object.Equals(\"{0}\", \"{1}\") => {2}", 
      s1, s2, Object.Equals(s1, s2));

   s1 = "Tom";
   s2 = "Tom";
   Console.WriteLine("Object.Equals(\"{0}\", \"{1}\") => {2}", 
      s1, s2, Object.Equals(s1, s2));

   s1 = null;
   s2 = "Tom";
   Console.WriteLine("Object.Equals(null, \"{1}\") => {2}",
       s1, s2, Object.Equals(s1, s2));

   s1 = "Carol";
   s2 = null;
   Console.WriteLine("Object.Equals(\"{0}\", null) => {2}", 
       s1, s2, Object.Equals(s1, s2));

   s1 = null;
   s2 = null;
   Console.WriteLine("Object.Equals(null, null) => {2}", 
       s1, s2, Object.Equals(s1, s2));
   }
}/**//*

This code produces the following output.

Object.Equals("Tom", "Carol") => False
Object.Equals("Tom", "Tom") => True
Object.Equals(null, "Tom") => False
Object.Equals("Carol", null) => False
Object.Equals(null, null) => True

*/

如果 objA 是与 objB 相同的实例，或者如果二者都为空引用，则为 true；否则为 false。

示例

下面的代码示例使用 ReferenceEquals 确定两个对象是否是相同的实例。

using System;

class MyClass {

   static void Main() {
      object o = null;
      object p = null;
      object q = new Object();

      Console.WriteLine(Object.ReferenceEquals(o, p));
      p = q;
      Console.WriteLine(Object.ReferenceEquals(p, q));
      Console.WriteLine(Object.ReferenceEquals(o, p));
   }
}

/**//*

This code produces the following output.

True
True
False

*/

1.string 和　stringbuilder的区别：

String在任何语言中，都有它的特殊性，在.NET中也是如此。它属于基本数据类型，也是基本数据类型中唯一的引用类型。字符串可以声明为常量，但是它却放在了堆中。

一：不可改变对象

在.NET中String是不可改变对象，一旦创建了一个String对象并为它赋值，它就不可能再改变，也就是你不可能改变一个字符串的值。这句话初听起来似乎有些不可思议，大家也许马上会想到字符串的连接操作，我们不也可以改变字符串吗？看下面这段代码：

 1 using System;
 2
 3 namespace Demo1
 4  {
 5      ///<summary>
 6     /// String连接测试
 7     /// </summary>
 8     public class Test
 9      {
10         public static void Main(string[] args)
11          {
12             string a = "1234";
13             Console.WriteLine(a);
14
15             a += "5678";
16             Console.WriteLine(a);
17             Console.ReadLine();
18         }
19     }
20 }
21
运行的结果：
 1234
 
 12345678
 
看起来我们似乎已经把MyStr的值从“1234”改为了“12345678”。事实是这样的吗？实际上并没有改变。在第5行代码中创建了一个String对象它的值是“1234”，MyStr指向了它在内存中的地址；第七行代码中创建了一个新的String对象它的值是“12345678”，MyStr指向了新的内存地址。这时在堆中其实存在着两个字符串对象，尽管我们只引用了它们中的一个，但是字符串“1234”仍然在内存中驻留。

二：引用类型

前面说过String是引用类型，这就是如果我们创建很多个相同值的字符串对象，它在内存中的指向地址应该是一样的。也就是说，当我们创建了字符串对象a，它的值是“1234”，当我们再创建一个值为“1234”的字符串对象b时它不会再去分配一块内存空间，而是直接指向了a在内存中的地址。这样可以确保内存的有效利用。看下面的代码：

 1 using System;
 2
 3 namespace Demo2
 4  {
 5      ///<summary>
 6     /// String引用类型测试
 7     /// </summary>
 8     public class Test
 9      {
10         public static void Main(string[] args)
11          {
12             string a = "1234";
13
14             Console.WriteLine(a);
15
16             Test.Change(a);
17
18             Console.WriteLine(a);
19             Console.ReadLine();
20         }
21
22         public static void Change(string s)
23          {
24             s = "5678";
25         }
26     }
27 }

运行结果：
 1234
 
 1234

做一个小改动，注意Change(ref string s)
 1 using System;
 2
 3 namespace Demo2
 4  {
 5      /// <summary>
 6     /// String引用类型测试
 7     /// </summary>
 8     public class Test
 9      {
10         public static void Main(string[] args)
11          {
12             string a = "1234";
13
14             Console.WriteLine(a);
15
16             Test.Change(ref a);
17
18             Console.WriteLine(a);
19             Console.ReadLine();
20         }
21
22         public static void Change(ref string s)
23          {
24             s = "5678";
25         }
26     }
27 }
28

运行结果：
 1234
 5678

三：StringBuilder对象
通过上面的分析可以看出，String类型在做字符串的连接操作时，效率是相当低的，并且由于每做一个连接操作，都会在内存中创建一个新的对象，占用了大量的内存空间。这样就引出StringBuilder对象，StringBuilder对象在做字符串连接操作时是在原来的字符串上进行修改，改善了性能。这一点我们平时使用中也许都知道，连接操作频繁的时候，使用StringBuilder对象。但是这两者之间的差别到底有多大呢？来做一个测试：

 1 using System;
 2 using System.Text;
 3
 4 namespace Demo5
 5  {
 6      ///<summary>
 7     /// String和StringBulider比较
 8     /// </summary>
 9     public class Test
10      {
11         public static void Main(string[] args)
12          {
13             string a = "";
14             StringBuilder s = new StringBuilder();
15
16             int times = 10000;
17             int start,end;
18            
19              ///测试String所用的时间
20             start = Environment.TickCount;
21             for(int i=0;i<times;i++)
22              {
23                 a += i.ToString();
24             }
25             end = Environment.TickCount;
26             Console.WriteLine((end-start));
27            
28              ///测试StringBuilder所用的时间
29             start = Environment.TickCount;
30             for(int i=0;i<times;i++)
31              {
32                 s.Append(i.ToString());
33             }
34             end = Environment.TickCount;
35             Console.WriteLine((end-start));
36
37             Console.ReadLine();
38         }
39     }
40 }
41

运行结果：
 884 
 0

通过上面的分析，可以看出用String来做字符串的连接时效率非常低，但并不是所任何情况下都要用StringBuilder，当我们连接很少的字符串时可以用String，但当做大量的或频繁的字符串连接操作时，就一定要用StringBuilder。

早在 C# 2.0 中，便出现了 Partial ，不过那是的 Partial 只能使用在类上，

也就是分部类，对于分部类，实用之处还是比较多的，

因为 Partial Method 是建立在 Partial Class 的基础之上的，

所以在这里先介绍一下 Partial Class 的使用，

然后再一并介绍 Partial Method ，

对于 Partial Class ，其实也就是将一个类拆分成几个分部类，

并且这些分部类可以写在不同的类文件 .cs 中，

比如在一个.cs 中写完这个 Class 的第一部分，

然后再在另外一个 .cs 中完成这个 Class 的第二部分，

再在另外一个 .cs 中完成这个 Class 的第三部分，

………………..

这个就是分部类了。

接下来看个示例便一清二楚了，

由上面的项目视图可以看出，我已经将一个类分成了四个部分，

然后再在 Demo__3 的 Code-Behind 中对这个类进行实例化并且访问，

先来看看各个 Partial Class 中的代码吧（非常简单的）

这个是 Demo__3__Use__PartialMethodOne.cs

public partial class Demo__3__Use__PartialMethod
{
    private string name = "";

    public void MethodOne()
    {
        name += "你来到了 MethodOne 方法<br/>";
    }

    public string GetName()
    {
        MethodOne();
        MethodTwo();
        MethodThree();
        MethodFour();
        return name;
    }
}

这个是 Demo__3__Use__PartialMethodTwo.cs

public partial class Demo__3__Use__PartialMethod
{
    public void MethodTwo()
    {
        name += "你来到了 MethodTwo 方法<br/>";
    }
}

这个是 Demo__3__Use__PartialMethodThree.cs

public partial class Demo__3__Use__PartialMethod
{
    public void MethodThree()
    {
        name += "你来到了 MethodThree 方法<br/>";
    }
}

这个是 Demo__3__Use__PartialMethodFour.cs

public partial class Demo__3__Use__PartialMethod
{
    public void MethodFour()
    {
        name += "你来到了 MethodFour 方法<br/>";
    }
}

然后就只要看一下 Demo__3.aspx 的 Code-Behind 了

using System;

namespace CSharpLanguage
{
    public partial class Demo__3 : System.Web.UI.Page
    {
        protected void Page_Load(object sender, EventArgs e)
        {
            Demo__3__Use__PartialMethod partialMethod =
                        new Demo__3__Use__PartialMethod();
            Response.Write(partialMethod.GetName());
        }
    }
}

以上就是整个 Demo 的所有代码了，

再看一下使用 Partial Class 后的结果吧

完成了 Partial Class 的解释，那么便开始 Partial Method 了，

事实上，Partial Method 是完全依赖于 Partial Class 实现的，

Partial Method 也就是分部方法了，

分部方法也就是把一个完整的方法拆分成两个部分，

即方法的定义和方法的实现，

然后再进一步的就可以将这两个部分放在不同的.cs中了，

比如我有一个方法，

我在这个分部类中完成这个方法定义，

然后我又在另外的一个分部类中完成这个方法的实现，

这个就是分部方法了，

很明显的，分部方法时依赖于分部类的，

因为你必须在这个分部类中完成前面的方法定义，

再在另外的一个分部类中完成后面的方法实现，

所以，可以很明显的看出，没有 Partial Class 就不可能有 Partial Method ，

不过，从上面介绍 Partial Class 的例子中可以看出，

Partial Class 也是比较容易的，所以 Partial Method 也理所当然不会难了，

Demo__4__Use__PartialOne.cs

public partial class Demo__4__Use__Partial
{
    private string name = "";
    partial void UseName();
    public string GetName()
    {
        UseName();
        return name;
    }
}

Demo__4__Use__PartialTwo.cs

public partial class Demo__4__Use__Partial
{
    partial void UseName()
    {
        name += "这里使用了 Partial Method 来操纵 name";
    }
}

Demo__4.aspx 的 Code-Behind 中的代码

using System;

namespace CSharpLanguage
{
    public partial class Demo__4 : System.Web.UI.Page
    {
        protected void Page_Load(object sender, EventArgs e)
        {
            Demo__4__Use__Partial partialMethod =
                     new Demo__4__Use__Partial();
            Response.Write(partialMethod.GetName());
        }
    }
}

在看一下结果

上面虽然是完整的使用了一次 Partial Class 和 Partial Method ，

但是需要注意的是，使用 Partial Method 还是有诸多限制的，

首先是在声明 Partial Method 时，必须使用到关键字 Partial 来声明，

然后就是在使用 Partial Method 时，必须经 Partial Class 才能使用，

然后还有使用 Partial Method 时，其在类中的地位只能是 private ，

即是私有成员，在类外部是无法对 Partial Method 进行访问的，

还有很重要的一点就是 Partial Method 不能够有返回值，也就是只能为 void。

                                                             2010—2—01

在学校那会对listview这个控件就非常头疼，怎么都搞不好，每遇到这种事只能改用datagridview,后来这种事多了，没办法就在网上搜了一点东西结合着自己的理解，做了个测试：

添加listview控件到窗体中然后在load事件中添加代码，这是我的示例：

private void ForthForm_Load(object sender, EventArgs e)
        {
            lvorder.Columns.Add("编号",40);
            lvorder.Columns.Add("号码",80);
            lvorder.Columns.Add("充值金额",80);
            lvorder.Columns.Add("状态",120);
            lvorder.GridLines = true; //显示表格线
            lvorder.View = View.Details;//显示表格细节
            lvorder.HeaderStyle = ColumnHeaderStyle.Clickable;//对表头进行设置
            lvorder.FullRowSelect = true;//是否可以选择行
        }

先为窗体设置listview的列数和表头，并规定每一列的宽度。

下面对数据进行添加，这一类的方法很多，先入为主，我用了listviewitem数组：

ListViewItem[] listViewItem = new ListViewItem[1];
                listViewItem[0] = new ListViewItem(new string[] { ormd, ormn, ormoney + "元", state });
                lvorder.Items.AddRange(listViewItem);

这样一个简单的listview数据绑定就实现了