Question

class Person
{
    string name;

    public Person(string name)
    {
        this.name = name;
    }

    public void method()
    {
        Person gupta = new Person("James"); // Current Object
        Console.WriteLine(this.name);
        Person gupta1 = new Person("Peter");  // Current Object
        Console.WriteLine(this.name);
        Person gupta2 = new Person("Frank");  // Current Object
        Console.WriteLine(this.name);
    }

    static void Main(string[] args)
    {
        Person p = new Person("Jim");
        p.method();
        Console.ReadLine();
    }
}

此代码生成结果

Jim
Jim
Jim

但是如果认为这应该是

James
Peter
Frank

有人可以解释一下吗？

Answer 1

this指的是当前实例。在Main方法中，您创建Person类的实例，并将Jim传递给构造函数，然后将其存储在name字段中。接下来，您将调用该方法。在此方法中，您要创建Person类的多个实例：gupta，gupta1和gupta2。您需要在每个实例上调用name字段：

public void method()
{
    Person gupta = new Person("James");
    Console.WriteLine(gupta.name);
    Person gupta1 = new Person("Peter");
    Console.WriteLine(gupta1.name);
    Person gupta2 = new Person("Frank");
    Console.WriteLine(gupta2.name);
}

Answer 2

您正在使用this。它指的是您当前所在的对象实例。更改以下代码，您将得到您期望的结果。

        Person gupta = new Person("James");
        Console.WriteLine(gupta.name);
        Person gupta1 = new Person("Peter");
        Console.WriteLine(gupta1.name);
        Person gupta2 = new Person("Frank");
        Console.WriteLine(gupta2.name);

Answer 3

“当前对象”是一种非正式的说话方式。只要你不对它的含义感到困惑就可以了。

不要将它视为一种“按时间顺序”的衡量标准 - “当前对象”不是您最后实例化的对象。相反，它是您调用方法当前执行的类的实例。

在撰写“this。（...）”时，你不知道它将是哪个实例。您现在将代码调用。

Person somePerson = new Person("Lucy");
somePerson.method();

在对method的调用中，“this”将是Lucy - 因为方法method正在该特定的Person实例上调用。您在Person内创建的小method根本不会影响这一点。

进一步澄清：

Person somePerson = new Person("Lucy");
somePerson.method(); // inside method, "this" is Lucy.

Person somePerson = new Person("Anne");
somePerson.method(); // inside method, "this" is Anne.

Person somePerson = new Person("Sarah");
somePerson.method(); // inside method, "this" is Sarah.

Person somePerson = new Person("Emily");
somePerson.method(); // inside method, "this" is Emily.

Answer 4

@Nadeem

通过调用main方法启动程序，这将创建一个名为“Jim”的新Person，变量p指向它。

Person p = new Person("Jim");

然后致电

p.method();

因此从p内部调用method（）。方法'method（）'生成3个新的Person对象，名称为“James”，“Peter”和“Frank”，但“当前范围”仍为p。您正在 p。

中运行'method（）'

所以如果你问'你的名字是什么？'，p会说'吉姆'。

当我在学习的时候，我有时会觉得这样更容易想到 - 如果我有三个孩子然后你问我每个孩子出生后我的名字是什么，我的名字仍然是5arx。你不是问我的孩子他们的名字是什么，你问我。

您可以修改代码以使事情更清晰（也许！）：

//Using declarations ommitted for brevity.

public class Person{
   public Guid ID;
   public string Name;

   public Person (string _name){
      this.Name = _name;
      ID = System.Guid.NewGuid();//creates a unique identifier
   }

   public void testMethod(){
      Console.WriteLine("This code is running inside a Person object: " + this.Identify());
      Person g1, g2, g3;

      g1 = new Person("Nadeem");
      g2 = new Person("Anish");
      g3 = new Person("Frank");

      this.Identify();// this tells you which class the code is running in - ie. what 'this' means in this context.

      //These are the additional objects you created by running testmethod from inside "Jim", the first person you created.

      g1.Identify();
      g2.Identify();
      g3.Identify();

      //If you want to get really funky, you can call testMethod() on g1, g2 and g3 too.
      //the ID field should help you see what's going on internally.

   }


   public void Identify(){
      Console.WriteLine("Person: ID=" + this.ID + "Name = " + this.Name);//Use string.format in production code!
   }

   public static void main (string[] args){
      Person p = new Person ("Jim");

      p.testMethod();
   }

}

希望这有帮助，

5arx

Answer 5

致电时

Person p = new Person("Jim"); 
p.method();

方法（）正在'p'对象上执行...这是你的'当前'对象。也许这是一个糟糕的选择。

'当前'引用'调用该方法的对象'并不意味着'最后使用过的对象'

Answer 6

如果您将代码重写为：

，也许

public void method()
{
    Console.WriteLine(this.name);
}

static void Main(string[] args)
{
    Person p = new Person("James"); // Current Object
    p.method();
    Person p2 = new Person("Peter");  // Current Object
    p2.method();
    Person p3 = new Person("Frank");  // Current Object
    p3.method();
    Console.ReadLine();
}

你会更好地理解“这个”是如何运作的。

Answer 7

当您使用this.name时，您正在寻址对象本身而不是您创建的新对象。（注意你曾三次使用this.name并获得三个“吉姆”）。

因此，如果您要打印刚创建的人的姓名，请使用gupta.name作为第一个和gupta1.name等。

其他选项是保留List<Person>并使用foreach在列表中运行并打印名称。

请注意，有许多Person可以在同一个应用中共存。并且person对象可以包含其他person个对象。当你在一个person的函数内（这里是jim中的一个函数）时，this.name将只引用他（对jim），而不引用Jim内的其他person实例！

 class Person
{
     public string Name
     {
          get;
         protected set;
     }
    List<Person> Relatives
     {
        get;
        set;
     }

    public Person(string name)
    {
        this.Name = name;
        Relatives = new List<Person>();
    }

    public void AddRelative(Person Relative)
    {
        Relatives.Add(Relative);
    }

    public void PrintRelatives()
    {
        foreach (Person Relative in Relatives)
        {
            Console.WriteLine(Relative.Name);
        }
    }

    static void Main(string[] args)
    {
        Person jim = new Person("Jim");
        jim.AddRelative(new Person("James"));
        jim.AddRelative(new Person("Peter"));
        jim.AddRelative(new Person("Frank"));
        jim.PrintRelatives();
        Console.ReadLine();
    }
}

这指的是当前的对象。但无法理解以下行为

7 个答案: