This is where it gets a little more interesting, because DefaultValue is, apparently DBNull.Value (according to the documentation for RawValue) if there is no default. Which is no good if the parameter is of type object and IsOptional==true!

做完多一点挖，我希望，可靠的方式来解决，这是物理读 ParameterInfo.Attributes 成员，分别读取bitflags 第一以检查 ParameterAttributes.Optional 和然后的检查 ParameterAttributes.Default 。只有当的两个的是present，然后读 ParameterInfo.DefaultValue 将是正确的。

Having done a bit more digging, I'm hopeful that the reliable way to solve this is to physically read the ParameterInfo.Attributes member, reading the bitflags individually first to check for ParameterAttributes.Optional and then check for ParameterAttributes.Default. Only if both are present, then reading ParameterInfo.DefaultValue will be correct.

我要开始编码和写作解决这个测试，但我要问，希望有一个人有更多的IL的知识，可以证实我的怀疑，希望确认这将是正确的任何基础IL语言（从而避免需要小样库负荷在不同的语言！）。

I'm going to start coding and writing tests around this, but I'm asking in the hope that there's someone with more IL knowledge that can confirm my suspicions and hopefully confirm that this'll be correct for any IL-based language (thus avoiding the need to mock up loads of libraries in different languages!).

推荐答案

简短的回答我的问题是没有 - 只是因为 IsOptional 是真实的，并不意味着默认值实际上将包含真正的默认。我推测在问题文本进一步下跌是正确的（和.NET文档也有点解释这一点，在一个迂回的方式）。在本质上，如果存在缺省值，那么调用者应该使用它，否则呼叫者应提供它自己的默认。该参数的属性被用来计算出，如果存在缺省值。

The short answer to my question is no - just because IsOptional is true doesn't mean that DefaultValue will actually contain the real default. My suppositions further down in the question text were correct (and the .Net documentation does kinda explain this, in a round-about way). In essence, if a default exists, then the caller should use it, otherwise the caller should provide it's own default. The parameter's Attributes are used to figure out if a default exists.

这是我做了什么。

假设下面的方法存在：

/* wrapper around a generic FastDefault<T>() that returns default(T) */
public object FastDefault(Type t) { /*elided*/ }

和再给予一个特定的参数和提供的参数值的字典（从配置）：

And then given a particular parameter and Dictionary of supplied argument values (from configuration):

public object GetParameterValue(ParameterInfo p, IDictionary<string, object> args)
{
  /* null checks on p and args elided - args can be empty though */
  object argValue = null;
  if(args.TryGetValue(p.Name, out argValue))
    return argValue;
  else if(p.IsOptional)
  {
    //now check to see if a default is supplied in the IL with the method
    if((p.Attributes & ParameterAttributes.HasDefault) == 
        ParameterAttributes.HasDefault)
      return p.DefaultValue;  //use the supplied default
    else
      return FastDefault(p.ParameterType); //use the FastDefault method
  }
  else  //parameter requires an argument - throw an exception
    throw new InvalidOperationException("Parameter requires an argument");
}

然后，我测试的构造函数和方法这样写这样的逻辑：

I've then tested this logic on constructors and methods written like this:

public class Test
{
  public readonly string Message;
  public Test(string message = "hello") { Message = message; }
}

IE浏览器，其中默认除了参数是可选的提供（该程序正确地落入其手伸向分支 ParameterInfo.DefaultValue ）。

随后，在回答了我的问题的另一部分，我意识到，在C＃4中我们可以使用OptionalAttribute产生一个可选参数的没有默认值的：

Then, in answer to another part of my question, I realised that in C# 4 we can use the OptionalAttribute to produce an optional parameter with no default:

public class Test2
{
  public readonly string Message;
  public Test2([OptionalAttribute]string message) { Message = message; }
}

此外，程序正确落入其执行 FastDefault 法的分支。

（在这种情况下，C＃中也将使用该类型的默认作为此参数的参数）的

我觉得，涵盖了一切 - 它的一切工作很好，我试过（我有乐趣试图让重载感觉正确的，因为我的IOC系统始终使用命名参数相当于 - 但C＃4规格的帮助有）。

I think that covers it all - it's working nicely on everything I've tried (I have had fun trying to get overload resolution feeling correct as my IOC system always uses the equivalent of named arguments - but the C# 4 spec helped there).