我最近在使用一个DateTime对象,并写了这样的东西:
DateTime dt = DateTime.Now;
dt.AddDays(1);
return dt; // still today's date! WTF?
intellisense文档AddDays()说它增加了一天的日期,它没有 - 它实际上返回添加了一天的日期,所以你必须写如下:
DateTime dt = DateTime.Now;
dt = dt.AddDays(1);
return dt; // tomorrow's date
这个曾经多次咬过我,所以我认为编制最糟糕的C#陷阱会很有用.
可能重复:
重写方法的C#可选参数
这是以下代码的输出:
Peter: -1
Peter: 0
Fred: 1
Fred: 1
你能解释我为什么彼得的号召p.TellYourAge(),并p.DoSomething()是不相同？
这里是自己尝试的代码(VS2010和FW 4):
static void Main(string[] args)
{
Peter p = new Peter();
p.TellYourAge(); // expected -1, result: -1
p.DoSomething(); // expected -1, result: 0
Fred f = new Fred();
f.TellYourAge(1); // expected 1, result: 1
f.DoSomething(); // expected 1, result: 1
Console.ReadKey();
}
}
public abstract class Person
{
public abstract void TellYourAge(int age); // abstract method without default value
}
public class Peter …在下面的代码中,对Method2的调用接收Value参数为False,即使基类根本没有声明参数的默认值,派生类声明True为默认值.
可以认为(在这里的类似示例中已经完成:在重写方法上使用C#可选参数)编译器首先使用基类的方法声明(这是正确的,因为可以通过对Method1调用前缀来更改此行为this.),但是在这种情况下,基数根本不会声明默认值.
对此有合理的解释吗？
using System;
class Base
{
public virtual bool Method1(bool Value) { return true; }
public virtual bool Method2(bool Value) { return true; }
}
class Derived : Base
{
public override bool Method1(bool Value = true)
{
return Value;
}
public override bool Method2(bool Value = true)
{
return Method1();
}
}
class Program
{
static void Main(string[] args)
{
Derived a = new Derived();
Console.WriteLine("Call to Method1, expected: True, got: …如果你向Eric Lippert 转发大约13分钟的视频,他描述了对C#编译器所做的更改,该更改使得以下代码无效(显然在此代码编译之前包括.NET 2).
int y;
int x = 10;
if (x * 0 == 0)
y = 123;
Console.Write(y);
现在我明白了上面代码的任何执行实际上都是为了评估
int y;
int x = 10;
y = 123;
Console.Write(y);
但是我不明白为什么将下面的代码编译成"可编辑"被认为是"可取的"？IE:允许这样的推论运行的风险是什么？
复制真的很简单,输出很奇怪;
预期输出为"bbb bbb"实际输出为"aaa bbb"
有没有人得到任何MSDN解释这种行为？我找不到任何东西.
((a)new b()).test();
new b().test();
public class a
{
public virtual void test(string bob = "aaa ")
{
throw new NotImplementedException();
}
}
public class b : a
{
public override void test(string bob = "bbb ")
{
HttpContext.Current.Response.Write(bob);
}
}
我的一位同事发现了这个奇怪的案例.我在这里发布一个简单的例子:
using System;
namespace Test
{
public class F
{
public void f(double d) { Console.WriteLine("public void F.f(double d)"); }
public virtual void f(long l, int q = 0) { Console.WriteLine("public virtual void F.f(long l, int q = 0)"); }
}
public class FDerived : F
{
public override void f(long l, int q) { Console.WriteLine("public override FDerived.f(long l, int q)"); }
public void g() { f(2L); }
}
public class G : FDerived
{
public void h1() { F …为什么输出B5，有人可以解释吗？
class A
{
public virtual void M(int x=5)
Console.Write("A"+x);
}
class B:A
{
public override void M(int x=6)
Console.Write("B"+x);
}
class Program
{
static void Main(string[] args)
{
A a = new B();
a.M();
}
}
//Output is : B5
我希望输出为B6，但实际输出为B5。
在给定的示例中(对于代码样式而言,它是为了一个紧凑的自包含repro的兴趣),被调用的方法始终是B中的虚方法,它具有附加的整数参数,而我希望该方法在C将是一个叫做的人.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace MethodChoosing
{
class Program
{
static void Main(string[] args)
{
C c = new C();
c.M();
Console.ReadKey();
}
}
public class A
{
public virtual void M(bool? a = null)
{
Console.WriteLine("base base");
}
}
public class B : A
{
public override void M(bool? a = null)
{
Console.WriteLine("base override");
}
public virtual void M(bool? a = null, int? b = null)
{
Console.Write("base new");
}
} …我读过其他帖子和埃里克·利珀特（Eric Lippert）关于该主题的帖子，但还没有在任何地方看到这种确切的情况得到解决。 重写方法上的 C# 可选参数 可选 参数和继承
我正在尝试实现以下情况：
public class BaseClass
{//ignore rest of class for now
public void DoThings(String str)
{
//dostuff
}
}
public class DerivedClass: BaseClass
{//ignore rest of class for now
new public void DoThings(String str, Int32 someint = 1)
{
//dostuff but including someint, calls base:DoThings in here
}
}
当我这样做时，编译器会在主题行中向我发出警告，表明我不需要使用 new 关键字，因为该方法不会隐藏继承的方法。但是，我没有看到从对象实例调用基本方法的方法，因此它对我来说看起来是隐藏的。
我希望它实际上被隐藏。如果不隐藏，其他用户有可能有一天直接调用基方法并破坏该类（这涉及线程安全）。
我的问题是，新方法实际上隐藏了继承的方法（编译器是错误的？）还是编译器正确，我需要做其他事情来隐藏原始方法？或者根本不可能达到预期的结果？