C# 使用覆盖初始化对象

是否可以用一些等价物来初始化对象，以替代新运算符

假设我有一个对象，我想将它转换为某个派生类型。 让我们称它们为objBase和objDerived

因此，假设这个objDerived类型有一个在objBase方法上使用new修饰符的方法，但是我想在cast objBase对象上使用这个新方法。 有没有一种说法可以等同于：

objBase myObjB = new objBase();
myObjB = *override* objDervied();

也许这样做没有意义，或者我缺少了一些非常简单的选择？我很确定一些人为的例子可以显示一些时间，当它可能是有用的，虽然。。。

---

实际上，我不需要这样做，但我只是想知道，自从我在methods中了解了新的修饰符关键字后的最后几天。在这种情况下，没有必要重写。始终可以将派生对象引用直接指定给基类变量：

objBase myObjB = new objDervied();

objBase myObjB = new objDerived();

请注意，创建实例，然后立即重新分配也不是一种好做法：

// Don't instantiate an object in the first line here, 
// since you're going to assign it in the next line
objBase myObjB;  //= new objBase();
myObjB = new objDervied();

至于：

因此，假设这个objDerived类型有一个在objBase方法上使用new修饰符的方法，但是我想在cast objBase对象上使用这个新方法

只能调用

new

方法，该方法通过赋值或回溯到派生类来隐藏基类方法：

objBase myObjB = new objDerived();
((objDerived)myObjB).Method(); // Will call objDerived.Method

如果

myObjB

没有实际引用

objDerived

实例，则此操作在运行时将失败

这里的另一个选项是使用

dynamic

。对变量使用

dynamic

将导致发生动态分派，这将使变量有效地表现为始终是“最派生”类型，并调用新方法。这实际上很有用，因为您可以在C#中有效地执行，即使它通常是静态类型的。这是一个完整的工作示例：

void Main()
{
    Base b = new Derived();  
    dynamic d = b;
    Console.WriteLine(d.Output());//This prints "Derived"
}

public class Base {
public string Output() {
        return "Base";
}
}

public class Derived:  Base {
    public new string Output() {
        return "Derived";
}
}

---

在这种情况下，不需要重写。始终可以将派生对象引用直接指定给基类变量：

objBase myObjB = new objDerived();

请注意，创建实例，然后立即重新分配也不是一种好做法：

// Don't instantiate an object in the first line here, 
// since you're going to assign it in the next line
objBase myObjB;  //= new objBase();
myObjB = new objDervied();

至于：

因此，假设这个objDerived类型有一个在objBase方法上使用new修饰符的方法，但是我想在cast objBase对象上使用这个新方法

只能调用

new

方法，该方法通过赋值或回溯到派生类来隐藏基类方法：

objBase myObjB = new objDerived();
((objDerived)myObjB).Method(); // Will call objDerived.Method

如果

myObjB

没有实际引用

objDerived

实例，则此操作在运行时将失败

这里的另一个选项是使用

dynamic

。对变量使用

dynamic

将导致发生动态分派，这将使变量有效地表现为始终是“最派生”类型，并调用新方法。这实际上很有用，因为您可以在C#中有效地执行，即使它通常是静态类型的。这是一个完整的工作示例：

void Main()
{
    Base b = new Derived();  
    dynamic d = b;
    Console.WriteLine(d.Output());//This prints "Derived"
}

public class Base {
public string Output() {
        return "Base";
}
}

public class Derived:  Base {
    public new string Output() {
        return "Derived";
}
}

不可能

不能在运行时覆盖成员

这将更多地是一种动态语言的特性，而不是像C#这样的静态类型和编译语言。例如，您可以在JavaScript中执行此操作，因为您可以在运行时重用标识符：

var someJsObject = { myMethod: function() { } };
someJsObject.myMethod = function() { alert("hey, I did it!"); };

顺便说一句，我觉得这不是一个好的做法，因为一件事是有一个动态语言（鸭子打字），另一件事是“嘿，我是一只鸭子，我过去常说嘎嘎，但现在我是一只吠叫的鸭子！”。这很可悲

使现代化 嗯。。。事实上，您可以使用C#和一个

ExpandoObject

来做类似的事情：

dynamic expando = new ExpandoObject();
expando.MyMethod = new Func<bool>(() => true);

dynamic expando2 = new ExpandoObject();
expando.MyMethod = new Func<string>(() => "What? I've changed!");

expando.MyMethod = expando2.MyMethod;
            
// This will set "What? I've changed!"
string result = expando.MyMethod();

dynamic expando=new ExpandoObject（）；
expando.MyMethod=newfunc（（）=>true）；
dynamic expando2=新的ExpandoObject（）；
expando.MyMethod=newfunc（（）=>“什么？我变了！”）；
expando.MyMethod=expando2.MyMethod；
//这将设置“什么？我变了！”
字符串结果=expando.MyMethod（）；

但这仍然是一种不好的做法。

不可能

不能在运行时覆盖成员

这将更多地是一种动态语言的特性，而不是像C#这样的静态类型和编译语言。例如，您可以在JavaScript中执行此操作，因为您可以在运行时重用标识符：

var someJsObject = { myMethod: function() { } };
someJsObject.myMethod = function() { alert("hey, I did it!"); };

顺便说一句，我觉得这不是一个好的做法，因为一件事是有一个动态语言（鸭子打字），另一件事是“嘿，我是一只鸭子，我过去常说嘎嘎，但现在我是一只吠叫的鸭子！”。这很可悲

使现代化 嗯。。。事实上，您可以使用C#和一个

ExpandoObject

来做类似的事情：

dynamic expando = new ExpandoObject();
expando.MyMethod = new Func<bool>(() => true);

dynamic expando2 = new ExpandoObject();
expando.MyMethod = new Func<string>(() => "What? I've changed!");

expando.MyMethod = expando2.MyMethod;
            
// This will set "What? I've changed!"
string result = expando.MyMethod();

dynamic expando=new ExpandoObject（）；
expando.MyMethod=newfunc（（）=>true）；
dynamic expando2=新的ExpandoObject（）；
expando.MyMethod=newfunc（（）=>“什么？我变了！”）；
expando.MyMethod=expando2.MyMethod；
//这将设置“什么？我变了！”
字符串结果=expando.MyMethod（）；

但这仍然是一种不好的做法

所以假设这个objDerived类型有一个使用新修饰符的方法 在objBase方法上，但我想在cast中使用新方法 对象库对象

我想你要求的是这样的：

public class Base {
   public string Write() {
        return "Base";
   }
}

public class Derived:  Base {

    public new string Write() { //HIDES BASE CLASS METHOD
        return "Derived";
   }
}


void Main()
{
    Base b = new Derived();  
    b.Write();//THIS WILL RETURN "BASE"

    Derived d = new Derived();  
    d.Write();//THIS WILL RETURN "DERIVED"
}

您不能这样做，因为派生类成员上的

new

只覆盖具体的对象类型

要以您希望的方式工作，因此只使用基类型，您需要使用基本的OOP概念，如

继承

和

虚拟/抽象

方法

所以假设这个objDerived类型有一个使用新修饰符的方法 在objBase方法上，但我想在cast中使用新方法 对象库对象

我想你要求的是这样的：

public class Base {
   public string Write() {
        return "Base";
   }
}

public class Derived:  Base {

    public new string Write() { //HIDES BASE CLASS METHOD
        return "Derived";
   }
}


void Main()
{
    Base b = new Derived();  
    b.Write();//THIS WILL RETURN "BASE"

    Derived d = new Derived();  
    d.Write();//THIS WILL RETURN "DERIVED"
}

您不能这样做，因为派生类成员上的

new

只覆盖具体的对象类型

要以您希望的方式工作，因此只使用基类型，您需要使用基本的OOP概念，如

继承

和

虚拟/抽象

方法。

同时可以分配的新实例