相关疑难解决方法(0)

有没有办法覆盖非虚方法？或者给出类似结果的东西(除了创建一个新的方法来调用所需的方法)？

我想从Microsoft.Xna.Framework.Graphics.GraphicsDevice单元测试中覆盖一个方法.

我正在看这篇博文,并有以下问题:

• 为什么我们需要new关键字,只是指定隐藏基类方法.我的意思是,为什么我们需要它？如果我们不使用override关键字,是不是我们隐藏了基类方法？
• 为什么隐藏C#中的默认值而不是覆盖？为什么设计师会这样实现它？

开发一个通用的接口我希望在一个接口中声明一个构造函数,但它说那里禁止构造函数.我试图声明一个静态工厂方法,但它说不允许使用静态方法,并建议使用'new'关键字.但我几乎不知道在C#中使用界面时,'new'关键字究竟意味着什么.你呢？

更新:

我没有发布任何示例代码,因为我不想混合2个问题 - 如何在界面中指定构造函数/工厂以及'new'关键字在接口中的含义.II甚至只被强制指定第一部分因为StackOverflow不接受纯粹形式的第二个问题,说它不符合质量标准.

但是,正如你所要求的那样,我将对我试图实现的目标进行抽样:

Interface IMyInterface <T, U, V>
{
    IMyInterface (T, U, U);
    // OR
    static IMyInterface GetNewIMyInterface (T, U, U);
}

我只是希望每个派生类都实现这样的构造函数.

何时使用新的虚拟关键词来装饰方法？感情是什么？就像定义一个接口一样,并添加一个类来继承接口.但是使用新的虚拟来实现接口方法.

 interface IPrinter
{
    void Print();
}

 public class PrinterOne : IPrinter
{
    public void Print() 
    {
        Console.WriteLine("PrinterOne.");
    }
}

public class PrinterTwo : PrinterOne
{
    public new virtual void Print()
    {
        Console.WriteLine("PrinterTwo.");
    }
}

public class PrinterThree : PrinterTwo
{
    public override void Print()
    {
        Console.WriteLine("PrinterThree.");
    }
}

public class PrinterFour : PrinterThree
{
    public override void Print()
    {
        Console.WriteLine("PrinterFour.");
    }
}

 static void Main(string[] args)
    {
        IPrinter iprinter = new PrinterFour();
        iprinter.Print();//the output is PrinterOne? why???
        Console.ReadLine();
    }

我偶然在方法签名中遇到了这个新的关键字,我发现这篇文章中给出的一些例子不准确(例如第二篇)

如果你不说"覆盖",我认为"新"已经存在.唯一的区别是,如果你不写"覆盖"(对于虚方法)或"新",你会得到一条绿线(warrning？).你仍然可以选择不写"新",它仍然可以工作.我说得对,或者我错过了重要的事情吗？

在这个链接中,他们有这个代码:

public class Base
{
   public virtual void Method(){}
}

public class Derived : Base
{
   public new void Method(){}
}

然后像这样调用:

Base b = new Derived();
b.Method();

我的实际代码是这样的:

public class Base
{
   public void Method()
   {
        // bla bla bla
   }
}

public class Derived : Base
{
   public new void Method()
   {
        base.Method();
   }
}

是否有必要打电话base.Method();？
或者只是将派生类中的方法留空？

可能重复:
C# - 方法签名中的新关键字

假设我有3个班:GrandDad,爸爸,儿子.儿子继承自祖父,继承自祖父.

每个类都实现了foo.

// GrandDad class: 
public virtual void foo()

// Dad class: 
new public virtual void foo()

// Son class: 
public override void foo()

我不明白为什么爸爸会使用新关键字的原因.据我所知,使用新隐藏方法.你为什么想做这个？

我阅读了新的MSDN解释,但讨论只是机械的,而不是架构的.

谢谢

我有两节课

class  A
{
     public virtual void Metod1()
     {
         Console.WriteLine("A.Method1");
     }
}

class B : A
{
    public new void  Metod1()
    {
        Console.WriteLine("B.Method1");
    }
}

然后我编写一些声明这些类的实例的代码,并调用它们的方法

     static void Main(string[] args)
    {
        A a = new B();
        a.Metod1();
        B b = new B();
        b.Metod1();
        Console.ReadKey();
    }

我给出了以下结果:

A.Method1
B.Method1

但是当我从B类的签名方法1中删除关键字new并运行Main方法时,我得到了相同的结果.问题:方法签名中的新关键字是否只是为了更好的可读性？

编辑:是否存在我们离不开新关键字的情况？

我有这个代码:

using System;

namespace Test
{
    class Program
    {
        static void Main(string[] args)
        {
            Foo foo = new Foo();
            Bar bar = new Bar();
            Baz baz = new Baz();
            Foo fooBar = new Bar();
            Foo fooBaz = new Baz();
            Bar barBaz = new Baz();

            foo.Test();
            bar.Test();
            baz.Test();
            fooBar.Test();
            fooBaz.Test();
            barBaz.Test();

            Console.ReadLine();
        }
    }

    internal class Foo
    {
        public virtual void Test()
        {
            Console.WriteLine("Foo");
        }
    }

    internal class Bar : Foo
    {
        public new virtual void Test()
        {
            Console.WriteLine("Bar");
        }
    } …

我已经阅读了方法签名中的new关键字,并且已经在这篇文章中看到过以下示例,但我仍然不明白为什么要在方法签名中编写new关键字.如果我们省略它,它仍然会做同样的事情.它会编译.会有一个警告,但它会编译.

那么,写new 方法签名只是为了可读性？

public class A
{
   public virtual void One() { /* ... */ }
   public void Two() { /* ... */ }
}

public class B : A
{
   public override void One() { /* ... */ }
   public new void Two() { /* ... */ }
}

B b = new B();
A a = b as A;

a.One(); // Calls implementation in B …

全部 -

已阅读有关新关键字的各种文章以及何时应该使用它:

MSDN - http://msdn.microsoft.com/en-us/library/6fawty39(v=vs.80).aspx

StackOverflow - 在与基类成员具有相同名称的派生类成员中使用new关键字的好处

这是我为实践这个概念而编写的示例代码

    static void Main(string[] args)
    {
        Animal a2 = new Dog();
        a2.Talk();
        a2.Sing();
        a2.Greet();
        a2.Dance();
        Console.ReadLine();
    }

class Animal
{
    public Animal()
    {
        Console.WriteLine("Animal constructor");
    }

    public void Talk()
    {
        Console.WriteLine("Animal is Talking");
    }

    public virtual void Sing()
    {
        Console.WriteLine("Animal is Singing");
    }

    public void Greet()
    {
        Console.WriteLine("Animal is Greeting");
    }

    public virtual void Dance()
    {
        Console.WriteLine("Animal is Dancing");
    }
}

//Derived Class Dog from Animal
class Dog : Animal
{ …

我有这个代码

class parent 
{
  public void sleep()
   {
     // Some Logic
   }
}

class Child : Parent
{
  public void sleep()
  {
    // some logic
  }
}

class Implement
{
  Child ch = new Child();
  ch.sleep();
}

但是现在我想通过使用已经创建的子类的实例来访问父类的sleep()方法.

class A {
    public virtual void M() { Console.Write("A"); }
}

class B: A {
    public override void M() { Console.Write("B"); }
}

class C: B {
    new public virtual void M() { Console.Write("C"); }
}

class D: C {
    public override void M() { Console.Write("D"); }
    static void Main() {
        D d = new D(); 
        C c = d; 
        B b = c; 
        A a = b;
        d.M(); c.M(); b.M(); a.M();
    }
}

我是这个概念的新手,所以详细的答案将不胜感激.