传承在C＃中的问题 - 是压倒内部方法可能吗？ [英] Inheritence in C# question - is overriding internal methods possible?

问题描述

？

是否有可能覆盖一个内部方法的行为

 使用系统; 
 
类TestClass中
 {
公共字符串名称{{返回this.ProtectedMethod（）; }} 
 
保护串ProtectedMethod（）
 {
返回InternalMethod（）; 
} 
 
串InternalMethod（）
 {
回归的TestClass :: InternalMethod（）; 
} 
} 
 
类OverrideClassProgram：TestClass的
 {//尝试重写内部方法？ （不工作）
串InternalMethod（）
 {
返回OverrideClassProgram :: InternalMethod（）; 
} 
 
静态INT主要（字串[] args）
 {
 //的TestClass :: InternalMethod（）
 Console.WriteLine（新识别TestClass（ ）。名称）; 
 //的TestClass :: InternalMethod（）？在我们刚拧？ 
 Console.WriteLine（新OverrideClassProgram（）名称。）; 
回报（INT）Console.ReadKey（）键。 
} 
} 
  

解决方案

我想你已经得到的东西在这里混淆。有一个实际的关键字内部，这是你想要的吗？

 内部字符串InternalMethod（）
 {
返回的TestClass :: InternalMethod（）; 
} 
  

不过，我想你真正需要的是虚的关键字。这可以让你做一个覆盖：
父类

 受保护的虚拟串InternalMethod（）
 {
返回的TestClass :: InternalMethod（）; 
} 
  

子类

 保护覆盖字符串InternalMethod（）
 {
返回TestProgram :: InternalMethod（）; 
} 
  

使用新的关键字是有效的，但它的完全重新实现的方法。即。它打破多态性

编辑：
这里有一个的链接。

Is it possible to override an internal method's behavior?

using System;

class TestClass
{
    public string Name { get { return this.ProtectedMethod(); } }

    protected string ProtectedMethod()
    {
        return InternalMethod();
    }

    string InternalMethod()
    {
        return "TestClass::InternalMethod()";
    }
}

class OverrideClassProgram : TestClass
{   // try to override the internal method ? (doesn't work)        
    string InternalMethod()
    {
        return "OverrideClassProgram::InternalMethod()";
    }

    static int Main(string[] args)
    {
        // TestClass::InternalMethod()
        Console.WriteLine(new TestClass().Name);
        // TestClass::InternalMethod() ?? are we just screwed?
        Console.WriteLine(new OverrideClassProgram().Name); 
        return (int)Console.ReadKey().Key;
    }
}

解决方案

I think you've got something confused here. There is an actual keyword "internal", is this what you want?

internal string InternalMethod()
{
    return "TestClass::InternalMethod()";
}

But I think what you're really looking for is the "virtual" keyword. This allows you to do an override: Parent Class

protected virtual string InternalMethod()
{
    return "TestClass::InternalMethod()";
}

Child Class

protected override string InternalMethod()
{
    return "TestProgram::InternalMethod()";
}

Using the "new" keyword is valid, but it completely reimplements the method. I.e. it breaks polymorphism.

Edit: Here's a link.

这篇关于传承在C＃中的问题 - 是压倒内部方法可能吗？的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！