Передающий пустой указатель к [закрытому] методу

В Java путь, принимая пустой указатель прибывает из программной ошибки (т.е. никогда не должен выходить за пределы фазы тестирования), затем уезжайте, система бросают его, или если существуют побочные эффекты, достигающие той точки, проверьте на пустой указатель вначале и бросьте или IllegalArgumentException или NullPointerException.

, Если пустой указатель мог бы прибыть из фактического исключение al случай, но Вы не хотите использовать контролируемую исключительную ситуацию для этого, тогда Вы определенно хотите пойти путем IllegalArgumentException в начале метода.

Лучшим способом обработать это действительно было бы использование исключений. В конечном счете, утверждение собираются закончить тем, что дали подобный опыт конечному пользователю, но не обеспечили пути к разработчику, называющему Ваш код для обработки ситуации прежде, чем показать исключение конечному пользователю. Ultimatley, Вы хотите удостовериться, чтобы Вы протестировали на недопустимые исходные данные как можно раньше (особенно в общедоступном коде направления) и обеспечили соответствующие исключения, которые может поймать код вызова.

Thwrowing C# ArgumentException или Java IllegalArgumentException прямо в начале метода смотрит на меня как на самое свободное из решений.

нужно всегда быть осторожным с Исключениями на этапе выполнения - исключения, которые не объявляются на сигнатуре метода. Так как компилятор не осуществляет Вас для ловли их, действительно легко забыть о них. Удостоверьтесь, что у Вас есть некоторая "выгода вся" обработка исключений для предотвращения программного обеспечения для остановки резко. Это - самая важная часть Вашего пользовательского опыта.

Немного вне темы, но одна функция findbugs, что я думаю, очень полезен, должен быть в состоянии аннотировать параметры методов для описания, какие параметры не должны быть переданы нулевое значение.

Используя статический анализ Вашего кода, findbugs может тогда указать на местоположения, где метод называют с потенциально нулевым значением.

Это имеет два преимущества:

1. аннотация описывает Ваше намерение для того, как метод нужно назвать, помогая документации
2. , FindBugs может указать потенциальным трудным вызывающим сторонам метода, позволив Вам разыскать потенциальные ошибки.

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

Я соглашаюсь или не соглашаюсь с сообщение wvdschel , оно зависит от того, что он конкретно говорит.

В этом случае, уверенный, этот метод откажет на null, таким образом, явная проверка здесь будет, вероятно, не нужна.

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

Я обычно предпочитаю не делать также, так как это просто замедляет вещи. NullPointerExceptions брошены позже так или иначе, который быстро приведет пользователя к обнаружению, что они передают пустой указатель методу. Я раньше проверял, но 40% моего кода закончили тем, что были проверяющим кодом, в которой точке я решил, что это просто не стоило хороших сообщений утверждения.

@Chris Karcher I сказал бы абсолютно корректный. Единственной вещью, которую я сказал бы, является проверка параметрические усилители отдельно, и имейте исключение, сообщает параметрический усилитель, который был пустым также, поскольку это делает отслеживание, куда пустой указатель прибывает из намного более легкого.

@wvdschel, ничего себе! Если запись кода является слишком большим усилием для Вас, необходимо изучить что-то как PostSharp (или Java, эквивалентный, если Вы доступны), который может выполнить последующую обработку блоки и вставить проверки параметрического усилителя на Вас.

С тех пор вне темы, кажется, стал темой, Scala проявляет интересный подход к этому. Все типы, как предполагается, являются не пустыми, если Вы, explicity обертывают его в Option, чтобы указать, что это могло бы быть пустым. Так:

//  allocate null
var name : Option[String]
name = None

//  allocate a value
name = Any["Hello"]

//  print the value if we can
name match {
  Any[x] => print x
  _ => print "Nothing at all"
}

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

я нашел JetBrains' @Nullable и @NotNull подход аннотаций для контакта с этим самое оригинальное, до сих пор. Это - конкретный IDE, к сожалению, но действительно уберите и мощный, IMO.

http://www.jetbrains.com/idea/documentation/howto.html

Наличие этого (или что-то подобное), поскольку стандарт Java был бы действительно хорош.

Spec# выглядит очень интересным!

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

/**
 * Checks to see if an object is null, and if so 
 * generates an IllegalArgumentException with a fitting message.
 * 
 * @param o The object to check against null.
 * @param name The name of the object, used to format the exception message
 *
 * @throws IllegalArgumentException if o is null.
 */
public static void checkNull(Object o, String name) 
    throws IllegalArgumentException {
   if (null == o)
      throw new IllegalArgumentException(name + " must not be null");
}

public static void checkNull(Object o) throws IllegalArgumentException {
   checkNull(o, "object");
} 

// untested:
public static void checkNull(Object... os) throws IllegalArgumentException {
   for(Object o in os) checkNull(o);  
}

Тогда проверка превращается:

public void someFun(String val1, String val2) throws IllegalArgumentException {
   ExceptionUtilities.checkNull(val1, "val1");
   ExceptionUtilities.checkNull(val2, "val2");

   /** alternatively:
   ExceptionUtilities.checkNull(val1, val2);
   **/

   /** ... **/
} 

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

Я предпочитаю использование утверждений.

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

Это действительно не входит, как Вы осуществили бы это ограничение?

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

if (p1 == null || p2 == null) {
    throw new IllegalArgumentException("Invalid argument for xProjection");
}

Также не непосредственного использования, но связанный с упоминанием о Spec#... Существует предложение добавить "пустые безопасные типы" к будущей версии Java: "Улучшенная обработка пустого указателя - Пустые безопасные типы" .

В соответствии с предложением, Ваш метод стал бы

public class MetricsCalculator {
    public double xProjection(#Point p1, #Point p2) {
        return (p2.x - p1.x) * 1.5;
    }
}

, где #Point тип не - null ссылки на объекты типа Point.

Общее правило состоит в том, если Ваш метод не ожидает null аргументы тогда, необходимо бросить Система. ArgumentNullException. Бросок надлежащего Exception не только защищает Вас от повреждения ресурса и других плохих вещей, но служит руководством для пользователей Вашего времени экономящего кода, проведенного, отлаживая Ваш код.

Также читает статью о Безопасное программирование

Хотя это строго не связано, Вы могли бы хотеть смотреть к Spec#.

я думаю, что это находится все еще в разработке (Microsoft), но некоторые CTP доступны, и это выглядит многообещающим. В основном это позволяет Вам делать это:

  public static int Divide(int x, int y)
    requires y != 0 otherwise ArgumentException; 
  {
  }

или

  public static int Subtract(int x, int y)
    requires x > y;
    ensures result > y;
  {
    return x - y;
  } 

Это также предоставляет другому функции как типы Notnull. Это - сборка сверху Платформы.NET 2.0, и это полностью совместимо. syntaxt, как можно видеть, является C#.