c#this的使用方法.doc

this（C# 参考）
this 关键字引用类的当前实例。
以下是 this 的常用用途：
· 限定被相似的名称隐藏的成员，例如：
复制代码
public Employee(string name, string alias)
{
this.name = name;
this.alias = alias;
}
· 将对象作为参数传递到其他方法，例如：
复制代码
CalcTax(this);
· 声明索引器，例如：
复制代码
public int this [int param]
{
get { return array[param]; }
set { array[param] = value; }
}
由于静态成员函数存在于类一级，并且不是对象的一部分，因此没有 this 指针。在静态方法中引用 this 是错误的。
示例
在本例中，this 用于限定 Employee 类成员 name 和 alias，它们都被相似的名称隐藏。this 还用于将对象传递到属于其他类的方法 CalcTax。
复制代码
// keywords_this.cs
// this example
using System;
class Employee
{
private string name;
private string alias;
private decimal salary = 3000.00m;

// Constructor:
public Employee(string name, string alias)
{
// Use this to qualify the fields, name and alias:
this.name = name;
this.alias = alias;
}

// Printing method:
public void printEmployee()
{
Console.WriteLine("Name: {0}\nAlias: {1}", name, alias);
// Passing the object to the CalcTax method by using this:
Console.WriteLine("Taxes: {0:C}", Tax.CalcTax(this));
}

public decimal Salary
{
get { return salary; }
}
}
class Tax
{
public static decimal CalcTax(Employee E)
{
return 0.08m * E.Salary;
}
}

class MainClass
{
static void Main()
{
// Create objects:
Employee E1 = new Employee("John M. Trainer", "jtrainer");

// Display results:
E1.printEmployee();
}
}
输出
Name: John M. Trainer
Alias: jtrainer
Taxes: $240.00
比如你的类中有一个成员变量为a。在你的成员函数中有定义了一个局部变量a。此时就必须使用this关键字来指示类的成员。也就是类的成员变量a写为this.a
其实这个很容易理解的，你写的那些响应函数，说白了都是类方法。
在程序运行后，可能会被很多这个类的实例（对象）来调用。。。那么请问，系统怎么知道调用这个类方法的是谁？是哪个对象？
所以，这时this就发挥它的作用啦。
每当一个对象调用这个类方法的时候，系统就会自动做这个对象的指针赋给this指针。
this指当前类
比如在一个AAA类里有一个aaa的方法
在这个AAA类中调用这个aaa方法就可以用this.aaa
如果是在别的类中就要实例化一个对象来调用这个方法
AAA a=new AAA();
a.aaa;
在静态的方法中不能使用this
如main方法就是一个静态方法
this是保留的指针。指向当前对象。它的好处就是在编译期就可以获得对象的地址。比如一个类中有个成员类。成员类需使用上层类的函数，就可以把this传到成员类中。
this 关键字引用类的当前实例
以下是调用本内中的构造函数，用this
using System;
namespace CallConstructor
{
    public class Car
    {
        int petalCount = 0;
        String s = "null";

        Car(int petals)
        {
            petalCount = petals;
            Console.WriteLine("Constructor w/int arg only,petalCount = " + petalCount);
        }

        Car(String s, int petals)
            : this(petals)   //第一个this的意思是调用Car(int petals)方法的属性petals。
        {
            //第二个this的意思是实例化Car(String s, int petals)方法中的参数s（this.s = s）。
                   this.s = s;
            Console.WriteLine("String & int args");
        }

        Car()
            : this("hi", 47)   //第三个this是调用Car(String s, int petals)方法的两个参数并传参。
        {
            Console.WriteLine("default constructor");
        }

        public static void Main()
        {
            Car x = new Car();
            Console.Read);
        }
    }
}

//结果：
//Constructor w/int arg only,petalCount = 47
//String & int args
//default constructor
永远记得：this出现了，代表它所在的类的对象

c#中 this保留字的用法
2007年03月21日 星期三 21:31
this 关键字将引用类的当前实例。静态成员函数没有 this 指针。this 关键字可用于从构造函数、实例方法和实例访问器中访问成员。
以下是 this 的常用用途：
限定被相似的名称隐藏的成员，例如：
public Employee(string name, string alias)
{
    this.name = name;
    this.alias = alias;
}
将对象作为参数传递到其他方法，例如：
CalcTax(this);
声明索引器，例如：
public int this [int param]
{
       get
       {
          return array[param];
       }
       set
       {
          array[param] = value;
       }
    }
在静态方法、静态属性访问器或字段声明的变量初始值设定项中引用 this 是错误的。
示例
在本例中，this 用于限定 Employee 类成员 name 和 alias，它们都被相似的名称隐藏。this 还用于将对象传递到属于其他类的方法 CalcTax。
// keywords_this.cs
// this example
using System;
public class Employee
{
    public string name;
    public string alias;
    public decimal salary = 3000.00m;
    // Constructor:
    public Employee(string name, string alias)
    {
       // Use this to qualify the fields, name and alias:
       this.name = name;
       this.alias = alias;
    }
    // Printing method:
    public void printEmployee()
    {
       Console.WriteLine("Name: {0}\nAlias: {1}", name, alias);
       // Passing the object to the CalcTax method by using this:
       Console.WriteLine("Taxes: {0:C}", Tax.CalcTax(this));
    }
}
public class Tax
{
    public static decimal CalcTax(Employee E)
    {
       return (0.08m*(E.salary));
    }
}
public class MainClass
{
    public static void Main()
    {
       // Create objects:
       Employee E1 = new Employee ("John M. Trainer", "jtrainer");
       // Display results:
       E1.printEmployee();
    }
}
输出
Name: John M. Trainer
Alias: jtrainer
Taxes: $240.00
this关键字--精通c#编程
2008-05-22 10:04
this关键字引用被访问成员所在的当前实例。静态成员函数没有this指针。this关键字可以用来从构造函数，实例方法和实例化访问器中访问成员。
不能在静态方法。静态属性访问器或者域声明的变量初始化程序中使用this关键字，这将会产生错误。
1.在类的构造函数中出现的this作为一个值类型表示对正在构造的对象本身的引用。
2.在类的方法中出现this作为一个值类型表示对调用该方法的对象的引用。
3.在结构的构造函数中出现的this作为一个变量类型表示对正在构造的结构的引用。
4.在结构的方法中出现的this作为一个变量类型表示对调用该方法的结构。
============================================
使用this访问被相似名字隐藏的成员
using System;
class E
{
public int id;
public string name;
public E(string name,int id)
{
   this.name=name;
   this.id=id;//限定被相似的名称隐藏的成员
}
public void P()
{
   Print.pe(this); //作为参数传递到其他方法中去
}
class Print
{
   public static void pe(E x)
   {
    Console.WriteLine("name:{0}\t id:{1}",x.name,x.id);
   }
}
}
class Test
{
public static void Main()
{
   Console.WriteLine("请输入姓名：");
   string name=Console.ReadLine();
   Console.WriteLine("请输入id号");
   string s=Console.ReadLine();
   int id=int.Parse(s);
   E e=new E(name,id);
   e.P();
}
}
================================
利用this在 索引中的引用访问类
using System;
class Ic
{
private int []arr=new int[10];
public int this[int index]
{
   get
   {
    if(index<0 || index>=10)
    {
     Console.WriteLine("下标越界！");
     return 0;
    }
    else
     return arr[index];
   }
   set
   {
    if(!(index>=10 || index<0))
     arr[index] = value;
   }
}
}
class T
{
static void Main()
{
   Ic mic=new Ic();
   Console.WriteLine("输入要赋值元素的下标：");
   string s=Console.ReadLine();
   int index=int.Parse(s);

   Console.WriteLine("请输入值：");
   string str=Console.ReadLine();
   int n=int.Parse(str);

   mic[index]=n;
   Console.WriteLine("current value:mic[index]={0}",mic[index]);
}
}
==================================================================================
=====================================
this关键字用在类的方法声明内部，表示“当前调用此方法的那个对象”的引用。
为什么这么用呢？首先看下面的例子：
public class TestThis {
public static void main(String[] args) {
   Dog dog=new Dog();
   dog.bark(2);
}
}
class Dog{
String name="";
public Dog() {
}
public void bark(int n){
   System.out.println("叫"+n+"声");
}
}
在面向对象的编程中，经常要做的事情，就是“发送消息给对象”，要就是指的是“方法的调用”过程。
在上面的代码中指的就是：dog.bark(2);这句代码。而为了“发送消息”给对象这个过程，编译器“暗地里”，在这个方法的调用过程中干了一件事，就是“私底下”将dog这个引用作为参数，传递到了bark方法的内部。（当然，这个过程是编译器“偷偷”完成的，而不需要我们去明码表示出来，如果我们想自己明码完成这个过程，那一定会出错的，呵呵……）。
知道了上面的过程，那么，当你在定义一个类的方法时，如果想在这个方法内部获取“被偷偷”传进来的这个当前对象的引用呢？因为根本没有明码的标志符可用，所以，在Java中就有这个专门的关键字：this，用在方法定义的内部，表示当前正在调用此方法的那个对象的引用。
所以，这个时候，如果写出下面的代码：就能从本质上理解类的各个方法之间是如何相互调用的了。
public class TestThis {
public static void main(String[] args) {
   Dog dog=new Dog();
   dog.bark(2);
}
}
class Dog{
String name="";
public Dog() {
}
public void bark(int n){
   this.bark();//这里直接使用bark();即可，不应该画蛇添足使用this
   System.out.println("叫"+n+"声");
}
public void bark(){
   System.out.println("狗要叫啦！");
}
}
但是应该注意到，在上面的bark(int n)这个方法的定义中，使用了this.bark();，这里使用this是没有必要的，因为，编译器能够自动帮助我们添加这个this。但是，有的人却习惯这么使用，我现在刚刚学习Java,也是一直在这么使用，前段时间用swing写了点东西，里面也是这么用的。后来，朋友看我写的那些代码，呵呵，很乱很乱，因为我把this用在了没有必要使用的地方，所以，看我的代码的人就会觉得很乱。所以要养成良好的coding习惯啊。
当然，关于这种说法也有例外，比如说，为一个类的属性，定义getter和setter时，往往setter的参数的标志符和相应的属性相同，这个时候就需要在setter的内部使用this加以区分了。这也算是this关键字用在方法定义内部中的一种用法吧，当然，只是可能有的人在写代码时，没有这种习惯，比如说我就是。而，一些主流的java IDE却有这种习惯，呵呵。
class Dog{
Stringname="";
public Dog() {
}
public void setName(String name){
  this.name=name;
}

}
在类的方法定义中使用this的时候，就是当必需明确指出当前对象的引用时，才使用。例如，我们在定义的方法中需要返回当前对象的引用时。
public class TestThis {
public static void main(String[] args) {
   Dog dog=new Dog();
   dog.bark(2);
}
}
class Dog{
String name="";
public Dog() {
}
public Dog bark(int n){
   bark();
   System.out.println("叫"+n+"声");
   return this;
}
public void bark(){
   System.out.println("狗要叫啦！");
}
}
或者,在方法定义中调用了其他的方法，而调用这个其它的方法时，需要将当前对象的引用传递给这个其它的方法作为参数，这个时候应该使用this。
总结：通过理解上面的内容，就不难理解，为什么在静态方法(static)内部，不能使用this关键字的原因了。
因为，在调用静态方法的时，不会将当前对象的引用传递进来（大多数情况，使用静态方法时，根本不会存在当前对象吧，呵呵）。
这样就不难得出使用静态方法时，几个需要注意的地方：
1：静态方法中只能调用其他的静态方法。
2：静态方法中只能访问静态属性。
3：静态方法中不能使用this关键字。（实际上也是上面的1和2）。
当然，上面的1、2两点是相对的，只是帮助我们理解，如果你在静态方法中，创建了一个类的对象，这个时候当然可以通过这个对象的引用访问这个对象的静态数据了。
最后得出一点：就是在调用静态方法时，一定要用类名去调用，而不建议使用对象的引用去调用（虽然，在语法上这样是允许的），避免引起混淆。
C# 参考之访问关键字：base、this
base

base 关键字用于从派生类中访问基类的成员：

调用基类上已被其他方法重写的方法。
指定创建派生类实例时应调用的基类构造函数。
基类访问只能在构造函数、实例方法或实例属性访问器中进行。

示例：

在派生类中调用基类方法。
// base 关键字
// 访问基类成员
using System;

public class BaseClass
{
protected string _className = "BaseClass";

public virtual void PrintName()
{
Console.WriteLine("Class Name: {0}", _className);
}
}

class DerivedClass : BaseClass
{
public string _className = "DerivedClass";

public override void PrintName()
{
Console.Write("The BaseClass Name is {0}");
//调用基类方法
base.PrintName();
Console.WriteLine("This DerivedClass is {0}", _className);
}
}

class TestApp
{
public static void Main()
{
DerivedClass dc = new DerivedClass();
dc.PrintName();
}
}

/**//*
控制台输出:
The BaseClass Name is BaseClass
This DerivedClass is DerivedClass
*/
在派生类中调用基类构造函数。
// keywords_base2.cs
using System;
public class BaseClass
{
int num;

public BaseClass()
{
Console.WriteLine("in BaseClass()");
}

public BaseClass(int i)
{
num = i;
Console.WriteLine("in BaseClass(int {0})", num);
}
}

public class DerivedClass : BaseClass
{
// 该构造器调用 BaseClass.BaseClass()
public DerivedClass() : base()
{
}

// 该构造器调用 BaseClass.BaseClass(int i)
public DerivedClass(int i) : base(i)
{
}

static void Main()
{
DerivedClass dc = new DerivedClass();
DerivedClass dc1 = new DerivedClass(1);
}
}

/**//*
控制台输出:
in BaseClass()
in BaseClass(1)
*/

注意点:
从静态方法中使用 base 关键字是错误的。
base 主要用于面向对象开发的对态这方面，在示例2中有体现。
this
this 关键字引用类的当前实例。

以下是 this 的常用用途：

限定被相似的名称隐藏的成员
将对象作为参数传递到其他方法
声明索引器
示例：

综合示例。
// this 关键字
// keywords_this.cs
using System;
class Employee
{
private string _name;
private int _age;
private string[] _arr = new string[5];

public Employee(string name, int age)
{
// 使用this限定字段，name与age
this._name = name;
this._age = age;
}

public string Name
{
get { return this._name; }
}

public int Age
{
get { return this._age; }
}

// 打印雇员资料
public void PrintEmployee()
{
// 将Employee对象作为参数传递到DoPrint方法
Print.DoPrint(this);
}

// 声明索引器
public string this[int param]
{
get { return _arr[param]; }
set { _arr[param] = value; }
}

}
class Print
{
public static void DoPrint(Employee e)
{
Console.WriteLine("Name: {0}\nAge: {1}", e.Name, e.Age);
}
}

class TestApp
{
static void Main()
{
Employee E = new Employee("Hunts", 21);
E[0] = "Scott";
E[1] = "Leigh";
E[4] = "Kiwis";
E.PrintEmployee();

for(int i=0; i<5; i++)
{
Console.WriteLine("Friends Name: {0}", E[i]);
}

Console.ReadLine();
}
}

/**//*
控制台输出：
Name: Hunts
Age: 21
Friends Name: Scott
Friends Name: Leigh
Friends Name:
Friends Name:
Friends Name: Kiwis
*/

注意点:
由于静态成员函数存在于类一级，并且不是对象的一部分，因此没有 this 指针。在静态方法中引用 this 是错误的。
索引器允许类或结构的实例按照与数组相同的方式进行索引。索引器类似于属性，不同之处在于它们的访问器采用参数。