TryFoo应该抛出异常吗？(Should TryFoo ever throw an exception?)

 .NET Framework中的一个常见模式是TryXXX模式（我不知道这是他们真正称之为的模式），其中被调用的方法尝试执行某些操作，如果成功则返回True ，如果操作失败则返回False 。 一个很好的例子是通用的Dictionary.TryGetValue方法。 
 
 这些方法的文档说他们不会抛出异常：该失败将在方法返回值中报告。 迄今为止都很好。 
 
 最近我遇到了两种不同的情况，实现TryXXX模式的.NET Framework方法会引发异常。 请参阅System.Random构造函数中的错误？ 和Uri.TryCreate抛出UriFormatException？ 了解详情。 
 
 在这两种情况下， TryXXX方法都会调用其他引发意外异常的方法，并且这些异常会被转义。 我的问题：这是否打破了不抛出异常的暗示合同？ 
 
 换句话说，如果你正在写TryFoo ，你会保证异常无法逃避吗？ 
 
public bool TryFoo(string param, out FooThing foo)
{
    try
    {
        // do whatever
        return true;
    }
    catch
    {
        foo = null;
        return false;
    }
}
 
 这很诱人，因为这样可以保证没有例外可以逃脱，从而履行隐含的合同。 但它是一个错误隐藏者。 
 
 根据我的经验，我的直觉表示这是一个非常糟糕的主意。 但是如果TryFoo允许一些异常逃逸，那么它真正的意思是“我不会抛出任何我知道如何处理的异常”，然后就抛出了合同“我不会抛出异常”的全部想法窗户。 
 
 那么，你有什么看法？ TryFoo应该处理所有的异常，还是只处理所期望的异常？ 你的推理是什么？ 

A common pattern in the .NET Framework is the TryXXX pattern (I don't know if that's what they really call it), in which the called method attempts to do something, returning True if it was successful, or False if the operation failed. A good example is the generic Dictionary.TryGetValue method.
 
Documentation for these methods say that they will not throw exceptions: that failure will be reported in the method return value. All good so far.
 
I recently encountered two different circumstances in which .NET Framework methods that implement the TryXXX pattern threw exceptions. See Bug in System.Random constructor? and Uri.TryCreate throws UriFormatException? for details.
 
In both cases, the TryXXX method called other methods that threw unexpected exceptions, and those exceptions escaped. My question: does this break the implied contract of not throwing exceptions?
 
Put another way, if you were writing TryFoo, would you guarantee that exceptions cannot escape, by writing it like this?
 
public bool TryFoo(string param, out FooThing foo)
{
    try
    {
        // do whatever
        return true;
    }
    catch
    {
        foo = null;
        return false;
    }
}
 
It's tempting, because that guarantees no exceptions will escape, thereby honoring the implied contract. But it's a bug hider.
 
My gut feeling, based on my experience, says that this is a really bad idea. But if TryFoo lets some exceptions escape, then what it's really saying is, "I won't throw any exceptions that I know how to handle," and then the whole idea of the contract "I won't throw exceptions" is thrown out the window.
 
So, what's your opinion? Should TryFoo handle all exceptions, or just those that it's expecting to happen? What's your reasoning?

原文：https://stackoverflow.com/questions/1166880