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

https://stackoverflow.com/questions/3465465

27-09-2019
|

Вопрос

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

Есть ли похожий ключевое слово / атрибут в C #?

Если нет эквивалента, как вы можете выполнить тот же (или похожий) эффект?

Решение

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

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

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

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

Другие советы

OP спрашивает о C # эквивалент Java throws пункт - не 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...
}

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

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

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

пример:

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

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

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

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

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

Полагаясь на документацию XML комментариев и ожидаю, что другие полагаются на плохом выборе. Большинство C # код, который я столкнулся, не документирует методы полностью и последовательно с комментариями документации XML. И тогда есть более крупная проблема, не зарегистрированная исключениями в C #, как вы можете документировать все исключения, которые ваш метод выбрасывает для целей пользователя вашего пользователя, чтобы узнать, как обращаться с ними все индивидуально? Помните, вы только знаете о тех, о которых вы бросаете себя ключевым словом броска в вашей реализации. API, которые вы используете внутри вашего метода. Реализация может также бросать исключения, о которых вы не знаете, потому что они могут не документировать, и вы не обращаетесь к ним в вашу реализацию, поэтому они взорвутся в лицо вызывающему метод. Другими словами, эти комментарии XML документации не являются заменой для проверенных исключений.
Андреас связал интервью Андерс Хейлсбергом в ответах здесь, почему команда C # Design решила против проверенных исключений. Окончательный ответ на оригинальный вопрос скрыт в этом интервью:

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

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

Лично я разорвался здесь. Я согласен с Anders, которые проверили исключения исключения, не решают проблему без добавления новых, разных проблем. Как и с комментариями документации XML, я редко вижу C # код со всем завернутым в попытках, наконец, блокирует. Это чувствует для меня, хотя это действительно ваш единственный вариант и что-то, что кажется хорошей практикой.

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

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

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

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

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

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

Вы спрашиваете об этом:

Перебрасывать исключение

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
    }

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

EnsuresOnThrow<> Выходит за пределы только что указание, какие исключения могут быть брошены, но также предусматривает условия, при которых они гарантированно бросаются - это может быть довольно обременительным кодом в под названному методу, если состояние исключения не тривиально, чтобы идентифицировать. Джава throws обеспечивает указание того, какие исключения могут быть брошены (т.е. IMO фокус в .NET находится внутри метода, который доказывает доказать throw, тогда как в Java фокус сдвигается к абонеру, чтобы признать возможность исключения).
.NET CC не делает различие между Проверено против не пробной Исключения, что Java имеет, хотя Ручной раздел CC 2.2.2 упоминается

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

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

Код Контракты Руководство здесь

Лицензировано под: CC-BY-SA с атрибуция

Не связан с StackOverflow