blocks|key|1903411|text|顺序是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1903412|对于层次结构中的所有类，|1903413|成员变量均初始化为默认值|unordered-list-item|1903414|1903415|然后从派生最多的类开始：|1903416|为派生最多的type|1903417|Constructor链接执行|1903418|变量初始化器计算出哪个基类构造函数将被调用|1903419|基类被初始化(递归所有这一切：)|1903420|执行此类中链中的构造函数主体(请注意，如果它们与Foo()+:+this(...)+etc|offset|length|style|CODE|1903421|链接，则可以有多个|1903422|1903423|请注意，在Java中，基类是在运行变量初始化器之前初始化的。如果您曾经移植过任何代码，这是一个需要了解的重要区别:)|1903424|如果你感兴趣的话，我有一个page+with+more+details。|1903425|entityMap|0|LINK|mutability|MUTABLE|url|https://jonskeet.uk/csharp/constructors.html^0|0|0|0|0|0|0|0|0|0|O|H|0|0|0|0|D|M|0|0^^$0|@$1|2|3|4|5|6|7|1C|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1D|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|1E|8|@]|9|@]|A|$]]|$1|G|3|-4|5|6|7|1F|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|1G|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|1H|8|@]|9|@]|A|$]]|$1|L|3|M|5|F|7|1I|8|@]|9|@]|A|$]]|$1|N|3|O|5|F|7|1J|8|@]|9|@]|A|$]]|$1|P|3|Q|5|F|7|1K|8|@]|9|@]|A|$]]|$1|R|3|S|5|F|7|1L|8|@$T|1M|U|1N|V|W]]|9|@]|A|$]]|$1|X|3|Y|5|6|7|1O|8|@]|9|@]|A|$]]|$1|Z|3|-4|5|6|7|1P|8|@]|9|@]|A|$]]|$1|10|3|11|5|6|7|1Q|8|@]|9|@]|A|$]]|$1|12|3|13|5|6|7|1R|8|@]|9|@$T|1S|U|1T|1|1U]]|A|$]]|$1|14|3|-4|5|6|7|1V|8|@]|9|@]|A|$]]]|15|$16|$5|17|18|19|A|$1A|1B]]]]

The order is:

<ul>
<li>Member variables are initialized to default values for all classes in the hierarchy</li>
</ul>

Then starting with the most derived class:

<ul>
<li>Variable initializers are executed for the most-derived type</li>
<li>Constructor chaining works out which base class constructor is going to be called</li>
<li>The base class is initialized (recurse all of this :)</li>
<li>The constructor bodies in the chain in this class are executed (note that there can be more than one if they're chained with <code>Foo() : this(...)</code> etc</li>
</ul>

Note that in Java, the base class is initialized before variable initializers are run. If you ever port any code, this is an important difference to know about :)

I have a <a href="https://jonskeet.uk/csharp/constructors.html" rel="noreferrer">page with more details</a> if you're interested.

blocks|key|1901194|text|它将首先调用基构造器。还要记住，如果你不把:base(param1)放在你的构造函数后面，基类的空构造函数就会被调用。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1901195|entityMap^0|L|D|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|K|8|@]|D|@]|E|$]]]|G|$]]

It will call the base constructor first. Also keep in mind that if you don't put the <code>:base(param1)</code> after your constructor, the base's empty constructor will be called.

blocks|key|668818|text|首先调用基类的构造函数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|668819|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 constructor of the baseclass is called first.

blocks|key|600689|text|不确定这是否应该是一个评论/答案，但对于那些通过示例学习的人来说，这个小提琴也说明了顺序：https://dotnetfiddle.net/kETPKP|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|600690|using+System;

//+order+is+approximately
/*
+++1)+most+derived+initializers+first.
+++2)+most+base+constructors+first+(or+top-level+in+constructor-stack+first.)
*/
public+class+Program
{
++++public+static+void+Main()
++++{
++++++++var+d+=+new+D();
++++}
}

public+class+A
{
++++public+readonly+C+ac+=+new+C("A");

++++public+A()
++++{
++++++++Console.WriteLine("A");
++++}
++++public+A(string+x)+:+this()
++++{
++++++++Console.WriteLine("A+got+"+%2B+x);
++++}
}

public+class+B+:+A
{
++++public+readonly+C+bc+=+new+C("B");

++++public+B():+base()
++++{
++++++++Console.WriteLine("B");
++++}
++++public+B(string+x):+base(x)
++++{
++++++++Console.WriteLine("B+got+"+%2B+x);
++++}
}

public+class+D+:+B
{
++++public+readonly+C+dc+=+new+C("D");

++++public+D():+this("ha")
++++{
++++++++Console.WriteLine("D");
++++}
++++public+D(string+x)+:+base(x)
++++{
++++++++Console.WriteLine("D+got+"+%2B+x);
++++}
}

public+class+C
{
++++public+C(string+caller)
++++{
++++++++Console.WriteLine(caller+%2B+"'s+C.");
++++}
}|code-block|syntax|javascript|600691|结果：|600692|D's+C.
B's+C.
A's+C.
A
A+got+ha
B+got+ha
D+got+ha
D|600693|entityMap|0|LINK|mutability|MUTABLE|url|https://dotnetfiddle.net/kETPKP^0|19|V|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|Z|8|@]|9|@]|C|$]]|$1|K|3|L|5|F|7|10|8|@]|9|@]|C|$G|H]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]]]

Not sure if this should be a comment/answer but for those who learn by example this fiddle illustrates the order as well: <a href="https://dotnetfiddle.net/kETPKP" rel="noreferrer">https://dotnetfiddle.net/kETPKP</a>

<pre><code>using System;

// order is approximately
/*
 1) most derived initializers first.
 2) most base constructors first (or top-level in constructor-stack first.)
*/
public class Program
{
 public static void Main()
 {
 var d = new D();
 }
}

public class A
{
 public readonly C ac = new C("A");

 public A()
 {
 Console.WriteLine("A");
 }
 public A(string x) : this()
 {
 Console.WriteLine("A got " + x);
 }
}

public class B : A
{
 public readonly C bc = new C("B");

 public B(): base()
 {
 Console.WriteLine("B");
 }
 public B(string x): base(x)
 {
 Console.WriteLine("B got " + x);
 }
}

public class D : B
{
 public readonly C dc = new C("D");

 public D(): this("ha")
 {
 Console.WriteLine("D");
 }
 public D(string x) : base(x)
 {
 Console.WriteLine("D got " + x);
 }
}

public class C
{
 public C(string caller)
 {
 Console.WriteLine(caller + "'s C.");
 }
}
</code></pre>

Result:

<pre><code>D's C.
B's C.
A's C.
A
A got ha
B got ha
D got ha
D
</code></pre>

blocks|key|600612|text|编辑:在我回答这个问题的时候，问题已经完全改变了。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|600613|答案是它首先调用base。|600614|以下旧问题的原始答案|600615|你是在问你什么时候做构造函数调用的“基础”部分吗？|600616|如果是这样的话，如果这个类是从另一个具有这个构造函数的类派生出来的，你可以“链接”一个对构造函数基类的调用：|600617|++public+class+CollisionBase
++++{
++++++++public+CollisionBase(Body+body,+GameObject+entity)
++++++++{

++++++++}
++++}

++++public+class+TerrainCollision+:+CollisionBase
++++{
++++++++public+TerrainCollision(Body+body,+GameObject+entity)
++++++++++++:+base(body,+entity)
++++++++{

++++++++}
++++}|code-block|syntax|javascript|600618|在本例中，TerrainCollision派生自CollisionBase。通过以这种方式链接构造函数，它可以确保使用提供的参数在基类上调用指定的构造函数，而不是默认的构造函数(如果基类上有默认构造函数)|offset|length|style|CODE|600619|entityMap^0|0|0|0|0|0|0|5|G|O|D|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|Y|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|Z|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|10|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|11|8|@]|9|@]|A|$M|N]]|$1|O|3|P|5|6|7|12|8|@$Q|13|R|14|S|T]|$Q|15|R|16|S|T]]|9|@]|A|$]]|$1|U|3|-4|5|6|7|17|8|@]|9|@]|A|$]]]|V|$]]

[Edit: in the time it took me to answer, the question had totally changed].

The answer is that it calls the base first.

[Original answer to the old question below]

Are you asking when you would do the "base" bit of the constructor call?

If so, you would "chain" a call to the constructor base if the class is derived from another class which has this constructor:

<pre><code> public class CollisionBase
 {
 public CollisionBase(Body body, GameObject entity)
 {

 }
 }

 public class TerrainCollision : CollisionBase
 {
 public TerrainCollision(Body body, GameObject entity)
 : base(body, entity)
 {

 }
 }
</code></pre>

In this example, <code>TerrainCollision</code> derives from <code>CollisionBase</code>. By chaining the constructors in this way, it ensures the specified constructor is called on the base class with the supplied parameters, rather than the default constructor (if there is one on the base)

blocks|key|2077139|text|巧合的是，这也是面试中被问得最多的问题，在这篇youtube+video+with+demonstration中解释了这一点。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2077140|第一件事就是不要试图记住这个序列。从逻辑上考虑父子关系，子代建立在父代之上。因此，显然应该先创建父实例，然后再创建子实例。|2077141|2077142|，所以首先激发父构造函数，然后激发子构造函数。|blockquote|2077143|2077144|2077145|但是等一下，当涉及到初始化器时，有一个转折，事情是不同的。|2077146|初始化器的|2077147|首先运行子初始化器，然后运行父初始化器。|2077148|2077149|2077150|下面是相同的图表表示。因此，构造函数代码从父级触发到子级，初始化器从子级触发到父级。|2077151|​|2077152|📷|atomic|2077153|2077154|entityMap|0|LINK|mutability|MUTABLE|url|https://www.youtube.com/watch?v=O5VBIx5uslA|1|IMAGE|IMMUTABLE|imageUrl|https://ask.qcloudimg.com/http-save/yehe-900000/c8bc9937ef453f4f9862adba6fedeaa0.jpeg|imageAlt^0|N|W|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|1|1|0|0^^$0|@$1|2|3|4|5|6|7|1F|8|@]|9|@$A|1G|B|1H|1|1I]]|C|$]]|$1|D|3|E|5|6|7|1J|8|@]|9|@]|C|$]]|$1|F|3|-4|5|6|7|1K|8|@]|9|@]|C|$]]|$1|G|3|H|5|I|7|1L|8|@]|9|@]|C|$]]|$1|J|3|-4|5|6|7|1M|8|@]|9|@]|C|$]]|$1|K|3|-4|5|6|7|1N|8|@]|9|@]|C|$]]|$1|L|3|M|5|6|7|1O|8|@]|9|@]|C|$]]|$1|N|3|O|5|6|7|1P|8|@]|9|@]|C|$]]|$1|P|3|Q|5|I|7|1Q|8|@]|9|@]|C|$]]|$1|R|3|-4|5|6|7|1R|8|@]|9|@]|C|$]]|$1|S|3|-4|5|6|7|1S|8|@]|9|@]|C|$]]|$1|T|3|U|5|6|7|1T|8|@]|9|@]|C|$]]|$1|V|3|W|5|6|7|1U|8|@]|9|@]|C|$]]|$1|X|3|Y|5|Z|7|1V|8|@]|9|@$A|1W|B|1X|1|1Y]]|C|$]]|$1|10|3|W|5|6|7|1Z|8|@]|9|@]|C|$]]|$1|11|3|-4|5|6|7|20|8|@]|9|@]|C|$]]]|12|$13|$5|14|15|16|C|$17|18]]|19|$5|1A|15|1B|C|$1C|1D|1E|-4]]]]

Coincidentally , this is also a most asked interview question as well and its explained in this <a href="https://www.youtube.com/watch?v=O5VBIx5uslA" rel="nofollow noreferrer">youtube video with demonstration</a>.
First thing do not try to memorize the sequence.
Think logically in parent child relationship , child builds on the top of the parent . So obviously first Parent instance should be created and then child.
<blockquote>
So first the parent constructor fires and then child constructor.
</blockquote>
But hang on there is a twist when it comes to initializers things are different.
<blockquote>
For initializers first child initializers run and then parent initializers.
</blockquote>
Below is the diagrammatic representation of the same. So constructor code fires Parent to Child and Initializers fire from Child to Parent.
<a href="https://i.stack.imgur.com/GVjyR.jpg" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/GVjyR.jpg" alt="C# constructor execution" /></a>

blocks|key|600433|text|你的问题有点不清楚，但我猜你是想问下面的问题|type|unstyled|depth|inlineStyleRanges|entityRanges|data|600434|600435|何时调用我的XNA对象的基构造器与使用不正确的默认构造器|blockquote|600436|600437|600438|这个问题的答案在很大程度上取决于您的场景和底层对象。你能澄清一下以下几点吗？|600439|TerrainCollision的基本对象类型是什么?What+is+|offset|length|style|CODE|600440|unordered-list-item|600441|是什么类型|600442|600443|不过，我的最佳答案是，如果您的参数与基类的构造函数的参数一致，那么几乎可以肯定的是，您应该调用它。|600444|entityMap^0|0|0|0|0|0|0|0|G|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|10|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|11|8|@]|9|@]|A|$]]|$1|G|3|-4|5|6|7|12|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|13|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|14|8|@$L|15|M|16|N|O]]|9|@]|A|$]]|$1|P|3|-4|5|Q|7|17|8|@]|9|@]|A|$]]|$1|R|3|S|5|Q|7|18|8|@]|9|@]|A|$]]|$1|T|3|-4|5|6|7|19|8|@]|9|@]|A|$]]|$1|U|3|V|5|6|7|1A|8|@]|9|@]|A|$]]|$1|W|3|-4|5|6|7|1B|8|@]|9|@]|A|$]]]|X|$]]

Your question is a bit unclear but I'm assuming you meant to ask the following

<blockquote>
 When to I call the base constructor for my XNA object vs. using the impilict default constructor 
</blockquote>

The answer to this is highly dependent on both your scenario and the underlying object. Could you clarify a bit wit the following

<ul>
<li>What is the scenario</li>
<li>What is the type of the base object of <code>TerrainCollision</code>?</li>
</ul>

My best answer though is that in the case where you have parameters that line up with the parameters of the base class`s constructor, you should almost certainly be calling it.

blocks|key|2077004|text|构造函数机制要好得多，因为它让应用程序使用构造函数链接，如果您要扩展应用程序，它可以通过继承实现最小程度的代码更改。Jon+Skeets+Article|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2077005|entityMap|0|LINK|mutability|MUTABLE|url|http://jonskeet.uk/csharp/constructors.html^0|1M|I|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

Constructor mechanism is much better as it leaves the application to use constructor chaining and if you were to extend the application it enables through inheritance the ability to make minimal code changes.
<a href="http://jonskeet.uk/csharp/constructors.html" rel="nofollow">Jon Skeets Article</a>

In C#, when you do

<pre><code>Class(Type param1, Type param2) : base(param1) 
</code></pre>

is the constructor of the class executed first, and then the superclass constructor is called or does it call the base constructor first?

C# constructor execution order

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云AI代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

功能1上新10个字符

功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符。

功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符。

功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符

功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符

功能4上新

文章&问答评论现已支持表情

全新交互，全新视觉，新增快捷键、悬浮工具栏、高亮块等功能并同时优化现有功能，全面提升创作效率和体验

社区富文本编辑器全新改版！诚邀体验～ 

精选全网热门MCP server，让你的AI更好用 🚀

💥开发者 MCP广场重磅上线！

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

在C#中，当你这样做Class(Type param1, Type param2) : base(param1) 是先执行类的构造函数，然后调用超类构造函数，还是先调用基构造函数？

问C#构造函数的执行顺序
EN

回答 8

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问C#构造函数的执行顺序EN

回答 8

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问C#构造函数的执行顺序
EN