В Java ключевое слово throws разрешает методу объявлять, что оно не будет обрабатывать исключение самостоятельно, а скорее бросать это к вызывающему методу.
Есть ли в С# аналогичное ключевое слово/атрибут?
Если нет эквивалента, как вы можете выполнить тот же (или аналогичный) эффект?
В Java вы должны либо обработать исключение, либо пометить метод как тот, который может выдать его с помощью ключевого слова throws.
С# не имеет этого ключевого слова или эквивалентного, как в С#, если вы не обрабатываете исключение, оно будет пузыриться до тех пор, пока не поймается или не поймается, оно закончит программу.
Если вы хотите обработать его, повторите бросок, вы можете сделать следующее:
try
{
// code that throws an exception
}
catch(ArgumentNullException ex)
{
// code that handles the exception
throw;
}
Оп спрашивает о эквиваленте С# Java throws предложение - не ключевое слово throw, Это используется в сигнатурах методов в Java, чтобы указать, что можно исключить проверенное исключение.
В С# нет прямого эквивалента исключенного Java исключения. С# не имеет условия подписи эквивалентного метода.
// Java - need to have throws clause if IOException not handled
public void readFile() throws java.io.IOException {
...not explicitly handling java.io.IOException...
}
переводится на
// C# - no equivalent of throws clause exceptions are unchecked
public void ReadFile()
{
...not explicitly handling System.IO.IOException...
}
Да, это старый поток, однако я часто нахожу старые темы, когда я получаю ответы на поисковые запросы, поэтому я решил добавить что-то полезное, что нашел.
Если вы используете Visual Studio 2012, есть встроенный инструмент, который можно использовать, чтобы обеспечить эквивалент уровня "IDE".
Если вы используете Комментарии к документации XML, как упоминалось выше, вы можете использовать <exception> , чтобы указать тип исключения, созданного методом или классом, а также информацию о том, когда и почему оно выбрано.
Пример:
/// <summary>This method throws an exception.</summary>
/// <param name="myPath">A path to a directory that will be zipped.</param>
/// <exception cref="IOException">This exception is thrown if the archive already exists</exception>
public void FooThrowsAnException (string myPath)
{
// This will throw an IO exception
ZipFile.CreateFromDirectory(myPath);
}
Здесь ответ на аналогичный вопрос, который я просто финансирую bytes.com:
Короткий ответ - нет, исключенных исключений в С# нет. конструктор языка обсуждает это решение в этом интервью:
http://www.artima.com/intv/handcuffs.html
Ближайшим вам может быть использование тегов в вашем XML документации и распространения документов, созданных NDoc, с помощью кода/ассамблей, чтобы другие люди могли видеть, какие исключения вы бросаете (это именно то, что MS делает в документации MSDN). Вы не можете полагаться на компиляторе, чтобы рассказать вам о необработанных исключениях, однако, как вы можете использовать в java.
Пройдя большинство ответов здесь, я хотел бы добавить пару мыслей.
Опираясь на документацию по XML Комментарии и ожидая, что другие полагаются, это плохой выбор. Большинство кодов С#, с которыми я столкнулся, полностью не документируют методы документа, а также комментарии XML Documentation. И тогда возникает большая проблема, которая не проверяет исключения на С#, как вы могли бы документировать все исключения, которые ваш метод выбрасывает, чтобы пользователь вашего API знал, как обращаться с ними все индивидуально? Помните, вы знаете только о тех, которые бросаете себя с ключевым словом throw в своей реализации. API-интерфейсы, которые вы используете внутри реализации метода, также могут генерировать исключения, о которых вы не знаете, потому что они могут быть не документированы, и вы не обрабатываете их в своей реализации, поэтому они взорвутся перед вызывающим вашим метод. Другими словами, эти комментарии к документации XML не заменяют проверенные исключения.
Андреас связал интервью с Андерсом Хейлсбергом в ответах здесь, почему команда разработчиков С# решила исключить исключенные исключения. Окончательный ответ на исходный вопрос скрыт в этом интервью:
Программисты защищают свой код, пишут, наконец, всюду, поэтому они вернутся правильно, если возникает исключение, но на самом деле они не заинтересованы в обработке исключений.
Другими словами, никто не должен интересоваться тем, какое исключение можно ожидать для конкретного API, поскольку вы всегда будете его поймать повсюду. И если вы хотите действительно заботиться о конкретных исключениях, то как обращаться с ними зависит от вас, а не от кого-то, определяющего подпись метода с чем-то вроде ключевого слова Java throw, заставляя особую обработку исключений для пользователя API.
-
Лично я разорван здесь. Я согласен с Андерсом в том, что проверенные исключения не решают проблему без добавления новых, разных проблем. Точно так же, как с комментариями документации XML, я редко вижу код С# со всем, что завершено в блоках try finally. Мне кажется, что это действительно ваш единственный вариант и что-то вроде хорошей практики.
Вы спрашиваете об этом:
Повторное выброс исключения
public void Method()
{
try
{
int x = 0;
int sum = 100/x;
}
catch(DivideByZeroException e)
{
throw;
}
}
или
static void Main()
{
string s = null;
if (s == null)
{
throw new ArgumentNullException();
}
Console.Write("The string s is null"); // not executed
}
На самом деле не проверять исключения на С# можно считать хорошей или плохой.
Я сам считаю это хорошим решением, так как проверенные исключения предоставляют вам следующие проблемы:
Из-за этого в большинстве более крупных приложений вы часто увидите следующий шаблон при проверке Исключения:
try {
// Some Code
} catch(SomeException ex){
throw new RuntimeException(ex);
}
Что по существу означает эмуляцию способа С#/.NET обрабатывает все Исключения.
Существует некоторое мимолетное сходство между .Net CodeContract EnsuresOnThrow<> и дескриптором java throws, поскольку оба могут сигнализировать вызывающий объект как тип исключения, который может быть поднят из функции или метода, хотя есть также значительные различия между 2:
EnsuresOnThrow<> выходит за рамки простого указания того, какие исключения могут быть выбраны, но также предусматривает условия, при которых они гарантированно будут выбрасываться - это может быть довольно обременительный код в вызываемом методе, если условие исключения не является тривиальным для идентификации, Java throws дает указание о том, какие исключения могут быть выбраны (например, IMO фокусируется на .Net внутри метода, который сжимается, чтобы доказать throw, тогда как в Java фокус переходит к вызывающему, чтобы признать возможность исключения)."использовать исключительные постусловия только для тех исключений, которые вызывающий следует ожидать как часть API"
throws для того же исключения на свой интерфейс.Насколько я знаю, все исключения в С# равны java RuntimeException.