VB.NET 'С' Оператором - охватывает или избегает?

На практике нет никаких действительно востребованных точек против него. Я не поклонник, но это - персональное предпочтение, нет никаких эмпирических данных, чтобы предположить, что эти With конструкция плоха.

В.NET, это компилирует в точно тот же код как полное определение имени объекта, таким образом, нет никакой потери производительности для этого сахара. Я установил это путем компиляции, затем демонтировав, следующая.NET VB 2,0 класса:

Imports System.Text

Public Class Class1
    Public Sub Foo()
        Dim sb As New StringBuilder
        With sb
            .Append("foo")
            .Append("bar")
            .Append("zap")
        End With

        Dim sb2 As New StringBuilder
        sb2.Append("foo")
        sb2.Append("bar")
        sb2.Append("zap")
    End Sub
End Class

дизассемблирование следующим образом - отмечают что вызовы к sb2 Append взгляд метода, идентичный With призывы оператора sb:

.method public instance void  Foo() cil managed
{
  // Code size       91 (0x5b)
  .maxstack  2
  .locals init ([0] class [mscorlib]System.Text.StringBuilder sb,
           [1] class [mscorlib]System.Text.StringBuilder sb2,
           [2] class [mscorlib]System.Text.StringBuilder VB$t_ref$L0)
  IL_0000:  nop
  IL_0001:  newobj     instance void [mscorlib]System.Text.StringBuilder::.ctor()
  IL_0006:  stloc.0
  IL_0007:  ldloc.0
  IL_0008:  stloc.2
  IL_0009:  ldloc.2
  IL_000a:  ldstr      "foo"
  IL_000f:  callvirt   instance class [mscorlib]System.Text.StringBuilder [mscorlib]System.Text.StringBuilder::Append(string)
  IL_0014:  pop
  IL_0015:  ldloc.2
  IL_0016:  ldstr      "bar"
  IL_001b:  callvirt   instance class [mscorlib]System.Text.StringBuilder [mscorlib]System.Text.StringBuilder::Append(string)
  IL_0020:  pop
  IL_0021:  ldloc.2
  IL_0022:  ldstr      "zap"
  IL_0027:  callvirt   instance class [mscorlib]System.Text.StringBuilder [mscorlib]System.Text.StringBuilder::Append(string)
  IL_002c:  pop
  IL_002d:  ldnull
  IL_002e:  stloc.2
  IL_002f:  newobj     instance void [mscorlib]System.Text.StringBuilder::.ctor()
  IL_0034:  stloc.1
  IL_0035:  ldloc.1
  IL_0036:  ldstr      "foo"
  IL_003b:  callvirt   instance class [mscorlib]System.Text.StringBuilder [mscorlib]System.Text.StringBuilder::Append(string)
  IL_0040:  pop
  IL_0041:  ldloc.1
  IL_0042:  ldstr      "bar"
  IL_0047:  callvirt   instance class [mscorlib]System.Text.StringBuilder [mscorlib]System.Text.StringBuilder::Append(string)
  IL_004c:  pop
  IL_004d:  ldloc.1
  IL_004e:  ldstr      "zap"
  IL_0053:  callvirt   instance class [mscorlib]System.Text.StringBuilder [mscorlib]System.Text.StringBuilder::Append(string)
  IL_0058:  pop
  IL_0059:  nop
  IL_005a:  ret
} // end of method Class1::Foo

Поэтому, если Вы любите его и находите его более читаемым, идут для него; нет никакого неопровержимого довода не к.

(Между прочим, Tom, я интересуюсь знанием, что произошло с отладчиком - я не могу вспомнить никогда наблюдение никакого необычного поведения в отладчике на основе With оператор, таким образом, мне любопытно знать, какое поведение Вы действительно видели.)

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

C# 3.0 имеет эту функцию только объектной инициализации:

var x = new Whatever { PropertyA=true, PropertyB="Inactive" };

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

Одно примечание о Вашем примере - Вам действительно нужен "Я" вообще? Почему не просто запишите:

PropertyA = True
PropertyB = "Inactive"

? Конечно, "Меня" подразумевается в этом случае...

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

UserHandler.GetUser.First.User.FirstName="Stefan"
UserHandler.GetUser.First.User.LastName="Karlsson"
UserHandler.GetUser.First.User.Age="39"
UserHandler.GetUser.First.User.Sex="Male"
UserHandler.GetUser.First.User.Occupation="Programmer"
UserHandler.GetUser.First.User.UserID="0"

тогда Вы, вероятно, нарушаете Закон

Я не использую VB.NET (я раньше использовал простой VB), но...

действительно ли ведущая точка обязательна? Если так, тогда я не вижу проблемы. В JavaScript результат использования with состоит в том, что свойство объекта смотрит все равно как простая переменная, и , что очень опасно, поскольку Вы не видите, получаете ли Вы доступ к свойству, или переменная, и таким образом, with является чем-то для предотвращения.

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

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

The 'with' is basically the 'cascade' from Smalltalk. It is a pattern in Kent Beck's Smalltalk Best Practice Patterns book.

A summary of the pattern: use it when it makes sense to group the messages sent to the object. Don't use it if it just happens to be some messages sent to the same object.