blocks|key|1739504|text|将首先调用基构造器。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1739505|试试看：|1739506|public+class+MyBase
{
++public+MyBase()
++{
++++Console.WriteLine("MyBase");
++}
}

public+class+MyDerived+:+MyBase
{
++public+MyDerived():base()
++{
++++Console.WriteLine("MyDerived");
++}
}|code-block|syntax|javascript|1739507|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

The base constructor will be called first.

try it:

<pre><code>public class MyBase
{
 public MyBase()
 {
 Console.WriteLine("MyBase");
 }
}

public class MyDerived : MyBase
{
 public MyDerived():base()
 {
 Console.WriteLine("MyDerived");
 }
}
</code></pre>

blocks|key|1740051|text|不要试图记住它，试着向自己解释发生了什么。假设您有一个名为Animal的基类和一个名为Dog的派生类。派生类向基类添加了一些功能。因此，当执行派生类的构造函数时，基类实例必须可用(以便可以向其添加新功能)。这就是为什么构造函数是从基础执行到派生的，而析构函数是以相反的方式执行的-首先是派生的析构函数，然后是基础析构函数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1740052|(这是简化的，但它应该可以帮助您在将来回答这个问题，而不需要实际记住它。)|1740053|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

Don't try to remember it, try to explain to yourself what has to happen. Imagine that you have base class named Animal and a derived class named Dog. The derived class adds some functionality to the base class. Therefore when the constructor of the derived class is executed the base class instance must be available (so that you can add new functionality to it). That's why the constructors are executed from the base to derived but destructors are executed in the opposite way - first the derived destructors and then base destructors. 

(This is simplified but it should help you to answer this question in the future without the need to actually memorizing this.)

blocks|key|1739636|text|实际上，派生类构造函数是首先执行的，但C#编译器会插入对基类构造函数的调用，作为派生构造函数的第一个语句。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1739637|所以:派生的是首先执行的，但它“看起来”像是基先执行的。|1739638|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

Actually, the derived class constructor is executed first, but the C# compiler inserts a call to the base class constructor as first statement of the derived constructor.

So: the derived is executed first, but it "looks like" the base was executed first.

blocks|key|1739869|text|正如其他人所说，基构造器首先被调用。然而，构造函数并不是真正发生的第一件事。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1739870|假设你有这样的类：|1739871|class+A+{}

class+B+:+A+{}

class+C+:+B+{}|code-block|syntax|javascript|1739872|首先，字段初始化器将按照派生最多的类到派生最少的类的顺序进行调用。首先是C的字段初始值设定项，然后是B，然后是A。|offset|length|style|CODE|1739873|然后将以相反的顺序调用构造函数:首先是A的构造函数，然后是B，然后是C。|1739874|entityMap^0|0|0|0|10|1|1E|1|1J|1|0|J|1|T|1|Y|1|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|V|8|@$K|W|L|X|M|N]|$K|Y|L|Z|M|N]|$K|10|L|11|M|N]]|9|@]|A|$]]|$1|O|3|P|5|6|7|12|8|@$K|13|L|14|M|N]|$K|15|L|16|M|N]|$K|17|L|18|M|N]]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|19|8|@]|9|@]|A|$]]]|R|$]]

As others have said, the base constructor gets called first. However, constructors are not really the first thing that happens.

Let's say you have classes like this:

<pre><code>class A {}

class B : A {}

class C : B {}
</code></pre>

First, field initializers will be called in order of most-derived to least-derived classes. So first field initializers of <code>C</code>, then <code>B</code>, then <code>A</code>.

The constructors will then be called in the opposite order: First <code>A</code>'s constructor, then <code>B</code>, then <code>C</code>.

blocks|key|1740117|text|Eric+Lippert在对象初始化的相关问题上发表了一篇有趣的文章，解释了构造函数和字段初始化器排序的原因：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1740118|Why+Do+Initializers+Run+In+The+Opposite+Order+As+Constructors?+Part+One|offset|length|1740119|Why+Do+Initializers+Run+In+The+Opposite+Order+As+Constructors?+Part+Two|1740120|entityMap|0|LINK|mutability|MUTABLE|url|http://blogs.msdn.com/ericlippert/archive/2008/02/15/why-do-initializers-run-in-the-opposite-order-as-constructors-part-one.aspx|1|http://blogs.msdn.com/ericlippert/archive/2008/02/18/why-do-initializers-run-in-the-opposite-order-as-constructors-part-two.aspx^0|0|0|1Z|0|0|0|1Z|1|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|S|8|@]|9|@$D|T|E|U|1|V]]|A|$]]|$1|F|3|G|5|6|7|W|8|@]|9|@$D|X|E|Y|1|Z]]|A|$]]|$1|H|3|-4|5|6|7|10|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|O]]|P|$5|K|L|M|A|$N|Q]]]]

Eric Lippert had an interesting post on the related issue of object initialization, which explains the reason for the ordering of constructors and field initializers:

<a href="http://blogs.msdn.com/ericlippert/archive/2008/02/15/why-do-initializers-run-in-the-opposite-order-as-constructors-part-one.aspx" rel="nofollow noreferrer">Why Do Initializers Run In The Opposite Order As Constructors? Part One</a>
 
<a href="http://blogs.msdn.com/ericlippert/archive/2008/02/18/why-do-initializers-run-in-the-opposite-order-as-constructors-part-two.aspx" rel="nofollow noreferrer">Why Do Initializers Run In The Opposite Order As Constructors? Part Two</a>

blocks|key|1739517|text|http://www.devhood.com/tutorials/tutorial_details.aspx?tutorial_id=777|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1739518|基构造器首先被调用。|1739519|entityMap|0|LINK|mutability|MUTABLE|url^0|0|1Y|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@$A|N|B|O|1|P]]|C|$]]|$1|D|3|E|5|6|7|Q|8|@]|9|@]|C|$]]|$1|F|3|-4|5|6|7|R|8|@]|9|@]|C|$]]]|G|$H|$5|I|J|K|C|$L|4]]]]

<a href="http://www.devhood.com/tutorials/tutorial_details.aspx?tutorial_id=777" rel="nofollow noreferrer">http://www.devhood.com/tutorials/tutorial_details.aspx?tutorial_id=777</a>

Base Constructor gets called first.

blocks|key|1524544|text|将调用异常构造函数，然后调用您的子类构造函数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1524545|简单的面向对象原则|1524546|看看这里，http://www.dotnet-news.com/lien.aspx?ID=35151|offset|length|1524547|entityMap|0|LINK|mutability|MUTABLE|url|http://www.dotnet-news.com/lien.aspx?ID=35151^0|0|0|5|19|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@$F|S|G|T|1|U]]|A|$]]|$1|H|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|O]]]]

The Exception Constructor will be called, then your Child class constructor will be called.

Simple OO principle

Have a look here
<a href="http://www.dotnet-news.com/lien.aspx?ID=35151" rel="nofollow noreferrer">http://www.dotnet-news.com/lien.aspx?ID=35151</a>

blocks|key|1739726|text|基构造器将首先被调用，否则，在你的“其他东西”必须使用基构造器初始化的成员变量的情况下，你会得到编译时错误，因为你的类成员还没有被初始化。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1739727|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

The base constructor will be called first, otherwise, in cases where your "other stuff" must make use of member variables initialized by your base constructor, you'll get compile time errors because your class members will not have been initialized yet.

blocks|key|1739809|text|碱基(？)在子构造函数中完成任何工作之前调用。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1739810|这是正确的，即使您省略了:+base+()+(在这种情况下，将调用0参数的基本构造函数)。|1739811|它的工作原理类似于java，|1739812|public+Child()
{
+++super();+//+this+line+is+always+the+first+line+in+a+child+constructor+even+if+you+don't+put+it+there!+***
}|code-block|syntax|javascript|1739813|*例外:我可以放入super(1,2,3)。但是如果我不显式地调用super，就会调用super()。|1739814|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|Q|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|R|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

base(?) is called before any work is done in the child constructor.

This is true, even if you leave off the :base() (in which case, the 0-parameter base constructor is called.)

It works similar to java,

<pre><code>public Child()
{
 super(); // this line is always the first line in a child constructor even if you don't put it there! ***
}
</code></pre>

*** Exception: I could put in super(1,2,3) instead. But if I don't put a call to super in explicitly, super() is called.

blocks|key|1524914|text|构造函数调用是自下而上调用(激发)的，并自上而下执行。因此，如果C类继承自B类，而B类继承自A类，那么当您创建C类的实例时，C的构造函数被调用，而C的构造函数又调用B的指导器，后者又调用A的构造函数。现在A的构造函数被执行，B的构造函数被执行，C的构造函数也被执行。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1524915|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Constructor calls are called (fired) from the bottom up, and executed from the top down. Thus, if you had Class C which inherits from Class B which inherits from Class A, when you create an instance of class C the constructor for C is called, which in turn calls the instructor for B, which again in turn calls the constructor for A. Now the constructor for A is executed, then the constructor for B is executed, then the constructor for C is executed.

Which gets called first - the base constructor or "other stuff here"?

<pre><code>public class MyExceptionClass : Exception
{
 public MyExceptionClass(string message, string extrainfo) : base(message)
 {
 //other stuff here
 }
}
</code></pre>

Base constructor in C# - Which gets called first?

编译器

哪个最先被调用--基构造器还是“这里的其他东西”？public class MyExceptionClass : Exception{    public MyExceptionClass(string message, string extrainfo) : base(message)    {        //other stuff here    }}

问C#中的基构造器-哪个最先被调用？
EN

回答 10

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问C#中的基构造器-哪个最先被调用？EN

回答 10

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问C#中的基构造器-哪个最先被调用？
EN