相关疑难解决方法(0)

所以例如你有一个类似的类型:

public class EffectOptions
{
    public EffectOptions ( params object [ ] options ) {}

    public EffectOptions ( IEnumerable<object> options ) {}

    public EffectOptions ( string name ) {}

    public EffectOptions ( object owner ) {}

    public EffectOptions ( int count ) {}

    public EffectOptions ( Point point ) {}

}

这里我只使用构造函数给出示例,但如果它们是类型本身的非构造方法,结果将是相同的,对吧？

所以当你这样做时:

EffectOptions options = new EffectOptions (null);

会调用哪个构造函数,为什么？

我可以自己测试一下,但我想了解重载分辨率系统是如何工作的(不确定它是否被称为).

乔恩的脑筋急转弯

这里是剧透......

我正在看#1 的答案,我必须承认我从来不知道重载决议是这种情况.但为什么会这样呢.在我的小脑袋里Derived.Foo(int)似乎是合乎逻辑的道路.

这个设计决定背后的逻辑是什么？

奖金时间!

此行为是C#规范,CLR实现还是编译器的结果？

任何人都可以这么好,并解释为什么这个代码显示Derived.DoWork(double).我可以为这种行为提出一些解释,但我希望有人为我澄清这一点.

using System;

public class Base
{
    public virtual void DoWork(int param) {
        Console.WriteLine("Base.DoWork");
    }
}

public class Derived : Base
{
    public override void DoWork(int param) {
        Console.WriteLine("Derived.DoWork(int)");
    }

    public void DoWork(double param) {
        Console.WriteLine("Derived.DoWork(double)");
    }

    public static void Main() {
        int val = 5;
        Derived d = new Derived();
        d.DoWork(val);
    }
}

在以下代码中:

public abstract class MyClass
{
public abstract bool MyMethod(
        Database database,
        AssetDetails asset,
        ref string errorMessage);
}

public sealed class MySubClass : MyClass
{
    public override bool MyMethod(
        Database database,
        AssetDetails asset,
        ref string errorMessage)
    {
        return MyMethod(database, asset, ref errorMessage);
    }

    public bool MyMethod(
        Database database,
        AssetBase asset,
        ref string errorMessage)
    {
    // work is done here
}
}

其中AssetDetails是AssetBase的子类.

为什么第一个MyMethod在传递AssetDetails时会在运行时调用第二个,而不是陷入递归的无限循环？

class Base
{
    public virtual void MethodA(int x)
    {
        Console.WriteLine ("In Base Class");
    }
}

class Derived : Base
{
    public override void MethodA(int x)
    {
        Console.WriteLine ("In derived INT)");
    }

    public void MethodA(object o)
    {
        Console.WriteLine ("In derived OBJECT");
    }
}

class Test
{
    static void Main()
    {
        Derived d = new Derived();
        int k = 20;
        d.MethodA(k);
    }
}

我得到的输出是" In derived OBJECT ".这种奇怪行为的原因是什么？经过一番研究,我发现原因是忽略了基类中声明的签名.他们为什么被忽视？

在文章Anders Hejsberg的采访中,"我们在C#中进行重载解析的方式与其他语言不同"有人可以用C#和Java提供一些例子吗？

我想使用继承来根据层次结构中的位置以不同的方式处理对象

(类似于这个C#问题)

假设您构建Shape对象的层次结构,如:

class Shape {} ;
class Sphere : public Shape {} ;
class Triangle : public Shape {} ; ...

然后为Ray类配备如下方法:

class Ray
{
    Intersection intersects( const Sphere * s ) ;
    Intersection intersects( const Triangle * t ) ;
};

您存储各种类型的各种Shape*的数组并调用

vector<Shape*> shapes ; ...
//foreach shape..
Intersection int = ray.intersects( shapes[ i ] )

但是你得到了编译错误

错误C2664:'交点Ray :: intersects(const Sphere*)const':无法将参数1从'Shape*const'转换为'const Sphere*'

你做错了什么？

唯一的方法就是用另一种方式来做

class Shape
{
    virtual Intersection intersects( const Ray* ray )=0 …