Возможно ошибочный пустой оператор

if (checkBox5.Checked = true) ;
Double value5 = Convert.ToDouble(checkBox4.Checked);
value5 = +1;
Double result5 = value5;
label2.Text = Convert.ToString(result5);

0

if (checkBox5.Checked = true) ;
Double value5 = Convert.ToDouble(checkBox4.Checked);
value5 = +1;
Double result5 = value5;
label2.Text = Convert.ToString(result5);

0

На C # я могу написать что-то вроде:

using (new MyDisposableClass().MethodA());

Точка с запятой вызывает отображение предупреждения компилятора, в котором указывается возможный ошибочный пустой оператор. Я не запускал приведенный выше код, но разве метод не будет вызван?

Какое применение имеет этот тип соглашения о кодировании? Я видел здесь еще одну ветку об этом, но я спрашиваю, есть ли какие-то различия сейчас / поэтому разные ответы.

Благодарность

Этот код в основном переводится как

MyDisposableClass tmp = new MyDisposableClass().MethodA();
try
{
}
finally
{
    if( tmp != null )
        tmp.Dispose();
}

По сути, вы избавляетесь от результата вызова MethodA, а не от MyDisposableClass, что является вероятным намерением.

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

using( var tmp = new MyDisposableClass() );
{
    tmp.MethodA();
}

Синтаксический анализатор оценивает два совершенно отдельных блока и воспринимается компилятором так, как если бы вы набрали это:

using( var tmp = new MyDispoableClass() )
{

}


{
    tmp.MethodA();
}

Оборванный ; легко пропустить на глаз, поэтому предупреждение компилятора просто указывает на то, что вы, вероятно, хотели сделать что-то еще. Бывают случаи, когда желательно более короткое краткое изложение, и я думаю, что лучший способ указать, что это сделано намеренно, — это использовать {} вместо ;.

using( new MyDisposableClass().MethodA() ){}

Обратите внимание, что это удаляет результат вызова MethodA, а не экземпляр MyDisposableClass. На самом деле ваш код должен быть написан как

using( var tmp = new MyDisposableClass() ){ tmp.MethodA(); }

Оператор using может использоваться в качестве открытия для предложения, в конце которого удаляется экземпляр объекта. Другими словами:

using (var foo = new bar())
{
  SomeStatments();
} 
//foo is disposed

Или

using (var foo = new bar())
  SomeStatments();
//foo is disposed

Ваша точка с запятой не заканчивает оператор using. Фактически он заканчивается пустым предложением, следующим за оператором using. Часто это не соответствует истинным намерениям программистов. Таким образом, компилятор выдает предупреждение «возможно ошибочный пустой оператор».

Обновление . Предполагая, что код, который вы указали в вопросе, является фактическим кодом, вам, вероятно, следует превратить MethodA в метод static, поскольку вы, очевидно, не применяете ограничение или не полагаетесь на любых учениках.

Зачем стараться быть умным?

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

//By the name of the example, I can assume that MyDisposableClass 
//implements IDisposable
using (MyDisposableClass something = new MyDisposableClass())
{
   //Assuming the example code compiles, then the return value of MethodA
   //implemented IDisposable, too.
   using(something.MethodA())
   {

   };
}

И если вам нужно избавиться от чего-то после всего лишь одного вызова, почему бы не заставить MethodA очистить то, что когда-либо нужно было очистить?

Думаю, было бы понятнее написать вот что:

using (var myDisposable = new MyDisposableClass())
{
   myDisposable.MethodA();
}

Таким образом, результат MethodA фактически будет рассматриваться как реализация IDisposable.

Может, поможет этот образец:

public static class Helper {
    public static void Using<T>( Action<T> action ) where T : IDisposable, new() {
        var obj = new T();
        action( obj );
    }
}

// ...
Helper.Using<MyDisposableClass>( cls => cls.MethodA() );
Helper.Using<OtherClass>( cls => {
    for( int i = 0; i < 5; i++ ) { cls.DoRandom(); }
} );

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

Даже заменив «;» с пустым блоком (что устраняет предупреждение компилятора) может привести к головной боли при чтении позже — и помните, что код читается чаще, чем он пишется.

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

Я использовал его в случае, когда меня просто интересовал побочный эффект исключения, генерируемого методом:

try {
    using (var _ = File.Open(logPath, FileMode.Open, FileAccess.Read)) { }
} catch (Exception ex) { ... }

File.Open возвращает FileStream, который необходимо закрыть или удалить. Но мне это не очень понравилось. В итоге я назвал переменную и поставил в блок явное закрытие. Я чувствовал, что позже будет легче понять.

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

Кроме того, я не уверен, о какой запятой вы имеете в виду. Вы имеете в виду точку с запятой в конце строки?

Этот метод по существу вызовет MethodA () и никогда не будет его использовать. «Использование» использует все, что указано в круглых скобках, только в этом конкретном блоке using. Затем это выходит за рамки. Так:

using (new MyDisposableClass().MethodA())
{
    //Code that uses MethodA()
}

… не должен выдавать эту ошибку, но MethodA () по-прежнему будет недоступен за пределами блока using.

Разъяснение:

Вы по-прежнему можете вызвать new MyDisposableClass().MethodA() где-нибудь в программе, но конкретный вызов, сделанный в коде using (new MyDisposableClass().MethodA()), выйдет за пределы области видимости и станет недоступным.