Как использовать ключевое слово Java в стиле Java в C #?

В Java ключевое слово throws позволяет объявить, что оно не будет обрабатывать исключение самостоятельно, а скорее передаст его вызывающему методу.

Есть ли аналогичное ключевое слово / атрибут в C #?

Если нет эквивалента, как вы можете достичь того же (или аналогичного) эффекта?

    В Java вы должны либо обработать исключение, либо пометить метод как способ, который может бросить его с помощью ключевого слова throws .

    C # не имеет этого ключевого слова или эквивалентного, как в C #, если вы не обрабатываете исключение, оно будет пузыриться до тех пор, пока оно не поймается или если оно не поймано, оно закончит программу.

    Если вы хотите справиться с этим, повторите бросок, вы можете сделать следующее:

     try { // code that throws an exception } catch(ArgumentNullException ex) { // code that handles the exception throw; } 

    Оператор задает вопрос о эквиваленте C # Java- предложения throw ключевом слове throw . Это используется в сигнатурах методов в Java, чтобы указать, что можно исключить проверенное исключение.

    В C # нет прямого эквивалента исключенного Java исключения. У C # нет условия эквивалентной формулы.

     // 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... } 

    Да, это старый stream, однако я часто нахожу старые темы, когда я получаю ответы от Google, поэтому я решил добавить что-то полезное, что нашел.

    Если вы используете Visual Studio 2012, есть встроенный инструмент, который можно использовать, чтобы обеспечить эквивалент уровня «ID».

    Если вы используете комментарии XML Documentation , как указано выше, вы можете использовать тег <исключение>, чтобы указать тип исключения, созданного методом или classом, а также информацию о том, когда и почему оно выбрано.

    пример:

      /// This method throws an exception. /// A path to a directory that will be zipped. /// This exception is thrown if the archive already exists public void FooThrowsAnException (string myPath) { // This will throw an IO exception ZipFile.CreateFromDirectory(myPath); } 

    Вот ответ на аналогичный вопрос, который я просто финансирую на bytes.com :

    Короткий ответ – нет, исключенных исключений в C # нет. Дизайнер языка обсуждает это решение в этом интервью:

    http://www.artima.com/intv/handcuffs.html

    Ближайшим вам может быть использование тегов в вашей документации XML и распространение NDoc-сгенерированных документов с помощью вашего кода / ассемблеров, чтобы другие люди могли видеть, какие исключения вы выбрасываете (что именно то, что MS делает в документации MSDN). Вы не можете полагаться на компилятор, чтобы рассказать вам о необработанных исключениях, однако, как вы можете использовать в java.

    На самом деле не проверять исключения на C # можно считать хорошей или плохой.

    Я сам считаю это хорошим решением, так как проверенные исключения предоставляют вам следующие проблемы:

    1. Технические исключения утечки на уровень бизнес / домен, потому что вы не можете правильно их обрабатывать на низком уровне.
    2. Они относятся к сигнатуре метода, которая не всегда хорошо сочетается с дизайном API.

    Из-за этого в большинстве больших приложений вы часто увидите следующий шаблон при проверке Исключения:

     try { // Some Code } catch(SomeException ex){ throw new RuntimeException(ex); } 

    Что по существу означает эмуляцию способа C # /. NET обрабатывает все Исключения.

    Существует некоторое мимолетное сходство между .Net CodeContract EnsuresOnThrow<> и дескриптором java throws , поскольку оба могут сигнализировать вызывающему абоненту как тип исключения, которое может быть вызвано функцией или методом, хотя есть также значительные различия между 2:

    • EnsuresOnThrow<> выходит за frameworks простого указания того, какие исключения могут быть выбраны, но также предусматривает условия, при которых они гарантированно будут выбрасываться – это может быть довольно обременительный код в вызываемом методе, если условие исключения не является тривиальным для идентификации. Шаблоны Java показывают, какие исключения могут быть выбраны (например, IMO фокусируется на .Net внутри метода, который сжимается, чтобы доказать throw , тогда как в Java фокус переходит к вызывающему, чтобы признать возможность исключения).
    • .Net CC не делает различия между проверенными и исключенными исключениями, которые имеет Java, хотя в разделе 2.2.2 руководства CC упоминается

    «использовать исключительные постусловия только для тех исключений, которые вызывающий должен ожидать как часть API»,

    • В .Net вызывающий может определить, делать или не делать ничего с исключением (например, путем отключения контрактов). В Java вызывающий должен что-то сделать , даже если он добавляет throws для одного и того же исключения на свой интерфейс.

    Справочник по контрактам

    Пройдя большинство ответов здесь, я хотел бы добавить пару мыслей.

    1. Опираясь на документацию по XML Комментарии и ожидая, что другие полагаются, это плохой выбор. Большинство кодов C #, с которыми я столкнулся, полностью не документируют методы документа, а также комментарии XML Documentation. И тогда есть большая проблема, которая не проверяет исключения на C #, как вы могли бы документировать все исключения, которые ваш метод выбрасывает, чтобы пользователь вашего API знал, как обрабатывать их все индивидуально? Помните, вы знаете только о тех, которые бросаете себя с ключевым словом throw в своей реализации. API-интерфейсы, которые вы используете внутри реализации метода, также могут генерировать исключения, о которых вы не знаете, потому что они могут быть не документированы, и вы не обрабатываете их в своей реализации, поэтому они взорвутся перед вызывающим вашим метод. Другими словами, эти комментарии к документации XML не заменяют проверенные исключения.

    2. Андреас связал интервью с Андерсом Хейлсбергом в ответах здесь о том, почему команда разработчиков C # решила не проверять исключения. Окончательный ответ на исходный вопрос скрыт в этом интервью:

    Программисты защищают свой код, написав try, наконец, повсюду, поэтому они вернутся правильно, если произойдет исключение, но на самом деле они не заинтересованы в обработке исключений.

    Другими словами, никто не должен интересоваться тем, какое исключение можно ожидать для конкретного API, поскольку вы всегда будете его поймать повсюду. И если вы хотите действительно заботиться о конкретных исключениях, то как обращаться с ними зависит от вас, а не от кого-то, определяющего подпись метода с чем-то вроде ключевого слова Java throws, заставляя особую обработку исключений для пользователя API.

    Лично я разорван здесь. Я согласен с Андерсом в том, что проверенные исключения не решают проблему без добавления новых, разных проблем. Точно так же, как с комментариями документации XML, я редко вижу код C # со всем, что завершено в блоках 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 } 
    Давайте будем гением компьютера.