C# 在继承上下文中使用base_C#_Inheritance

C# 在继承上下文中使用base

c# inheritance

C# 在继承上下文中使用base,c#,inheritance,C#,Inheritance,有人能解释一下为什么这里的结果是：DVD未知DVD:DVD using System; class Program { class M { internal string n; internal M() { } internal M(string N) { Console.Write(N + " "); n = N; } } cla

有人能解释一下为什么这里的结果是：DVD未知DVD:DVD

using System;

class Program
{
    class M
    {
        internal string n;

        internal M() { }
        internal M(string N)
        {
            Console.Write(N + " ");
            n = N;
        }
    }

    class D : M
    {
        internal D(string N) : base(N) { n = "DVD:" + N; }
    }

    static void Main(string[] args)
    {
        M d1 = new D("DVD");

        M m1 = new M("Unknown");

        Console.WriteLine(" " + d1.n);

    }
}

我理解代码的大部分内容，除了这一行：

internal D(string N) : base(N) { n = "DVD:" + N; }

internal D(string N) : base(N)
{
    n = "DVD:" + N;
}

我知道基类从父类调用了一些东西，但在这种情况下，我就是不明白/

首先，Console.WriteLine（“+d1.n”）；将给您DVD:DVD，因为base意味着使用父类的构造函数。所以，当你把你的参数发送到你的D类时，它把你的代码发送到你的M类，它正在执行它，在你的屏幕上给你“DVD”，然后它改变了n的值。之后，您将直接向M类发送“未知”值，该值与D类不再相关，它将在屏幕上显示“未知”。最后，您请求的D类n值已经是“DVD”。所以结果是DVD未知DVD:DVD。我希望这对您有意义。

让我们把这一行分开：

internal D(string N) : base(N) { n = "DVD:" + N; }

internal D(string N) : base(N)
{
    n = "DVD:" + N;
}

您最需要澄清的部分是

base（N）

。是对

M（字符串N）

构造函数的调用。这在运行此构造函数（

n=“DVD…

）的主体之前发生

我认为，如果您稍微修改打印的内容，代码会更清晰：

class M
{
    internal string n;

    internal M() { }
    internal M(string N)
    {
        Console.WriteLine("in base " + N);
        n = N;
    }
}

class D : M
{
    internal D(string N) : base(N) { n = "DVD:" + N; }
}

static void Main(string[] args)
{
    M d1 = new D("DVD");

    M m1 = new M("Unknown");

    Console.WriteLine("d1.n is " + d1.n);
}

输出

in base DVD
in base Unknown
d1.n is DVD:DVD

同样的事情也发生在

DVD未知DVD:DVD

的输出中，只在一行上：首先，

的构造函数调用

的构造函数，该构造函数写入

DVD

（这发生在

DVD:

添加到它之前）。然后，直接调用

的构造函数，它写入

未知的。然后，您写入d1
的n
，这是DVD:DVD
，让我们分开这一行：
internal D(string N) : base(N) { n = "DVD:" + N; }

internal D(string N) : base(N)
{
    n = "DVD:" + N;
}

您最可能需要澄清的部分是base（N）
。是对M（string N）
构造函数的调用。这发生在该构造函数的主体（N=“DVD…
）运行之前
我认为，如果您稍微修改打印的内容，代码会更清晰：
class M
{
    internal string n;

    internal M() { }
    internal M(string N)
    {
        Console.WriteLine("in base " + N);
        n = N;
    }
}

class D : M
{
    internal D(string N) : base(N) { n = "DVD:" + N; }
}

static void Main(string[] args)
{
    M d1 = new D("DVD");

    M m1 = new M("Unknown");

    Console.WriteLine("d1.n is " + d1.n);
}

输出
in base DVD
in base Unknown
d1.n is DVD:DVD

同样的事情也发生在DVD未知DVD:DVD
的输出中，只在一行上：首先，D
的构造函数调用M
的构造函数，该构造函数写入DVD
（这发生在DVD:
添加到它之前）。然后，直接调用M
的构造函数，该构造函数写入Unknown
。然后，您编写d1
的n
，这是DVD:DVD
让我们分开这一行：
internal D(string N) : base(N) { n = "DVD:" + N; }

internal D(string N) : base(N)
{
    n = "DVD:" + N;
}

您最需要澄清的部分是base（N）
。是对M（字符串N）
构造函数的调用。这在运行此构造函数（n=“DVD…
）的主体之前发生
我认为，如果您稍微修改打印的内容，代码会更清晰：
class M
{
    internal string n;

    internal M() { }
    internal M(string N)
    {
        Console.WriteLine("in base " + N);
        n = N;
    }
}

class D : M
{
    internal D(string N) : base(N) { n = "DVD:" + N; }
}

static void Main(string[] args)
{
    M d1 = new D("DVD");

    M m1 = new M("Unknown");

    Console.WriteLine("d1.n is " + d1.n);
}

输出
in base DVD
in base Unknown
d1.n is DVD:DVD

同样的事情也发生在DVD未知DVD:DVD
的输出中，只在一行上：首先，D
的构造函数调用M
的构造函数，该构造函数写入DVD
（这发生在DVD:
添加到它之前）。然后，直接调用M
的构造函数，它写入未知的。然后，您写入d1
的n
，这是DVD:DVD
，让我们分开这一行：
internal D(string N) : base(N) { n = "DVD:" + N; }

internal D(string N) : base(N)
{
    n = "DVD:" + N;
}

您最可能需要澄清的部分是base（N）
。是对M（string N）
构造函数的调用。这发生在该构造函数的主体（N=“DVD…
）运行之前
我认为，如果您稍微修改打印的内容，代码会更清晰：
class M
{
    internal string n;

    internal M() { }
    internal M(string N)
    {
        Console.WriteLine("in base " + N);
        n = N;
    }
}

class D : M
{
    internal D(string N) : base(N) { n = "DVD:" + N; }
}

static void Main(string[] args)
{
    M d1 = new D("DVD");

    M m1 = new M("Unknown");

    Console.WriteLine("d1.n is " + d1.n);
}

输出
in base DVD
in base Unknown
d1.n is DVD:DVD

同样的事情也发生在DVD未知DVD:DVD
的输出中，只在一行上：首先，D
的构造函数调用M
的构造函数，该构造函数写入DVD
（这发生在DVD:
添加到它之前）。然后，直接调用M
的构造函数，该构造函数写入Unknown
。然后，编写d1
的n
，即DVD:DVD
，它从bas调用构造函数