With...End With Statement (Visual Basic)

Executes a series of statements that repeatedly refer to a single object or structure so that the statements can use a simplified syntax when accessing members of the object or structure.

Syntax

With objectExpression
    [ statements ]
End With

Parts

Remarks

By using With...End With, you can perform a series of statements on a specified object without specifying the name of the object multiple times. Within a With statement block, you can specify a member of the object starting with a period, as if the With statement object preceded it.

For example, to change multiple properties on a single object, place the property assignment statements inside the With...End With block, referring to the object only once instead of once for each property assignment.

If your code accesses the same object in multiple statements, you gain the following benefits by using the With statement:

• You don't need to evaluate a complex expression multiple times or assign the result to a temporary variable to refer to its members multiple times.

• You make your code more readable by eliminating repetitive qualifying expressions.

The data type of objectExpression can be any class or structure type or even a Visual Basic elementary type such as Integer. If objectExpression is a structure, the ability to assign to its members depends on whether the structure expression is referenceable. You can assign to members of structures that are directly referenceable (such as variables, array elements, or fields), but you get an error if you try to assign values to members of structures that are returned by value from functions, properties, or operators, or when parentheses are used to cut reference ties (for example, With (structureVariable)). This is the same error you would get if you invoked a method that returned a structure and immediately accessed and assigned a value to a member of the function's result, such as GetAPoint().x = 1. The problem in both cases is that the structure exists only on the call stack, and there is no way a modified structure member in these situations can write to a location such that any other code in the program can observe the change.

The objectExpression is evaluated once, upon entry into the block. You can't reassign the objectExpression from within the With block.

Within a With block, you can access the methods and properties of only the specified object without qualifying them. You can use methods and properties of other objects, but you must qualify them with their object names.

You can place one With...End With statement within another. Nested With...End With statements may be confusing if the objects that are being referred to aren't clear from context. You must provide a fully qualified reference to an object that's in an outer With block when the object is referenced from within an inner With block.

You can't branch into a With statement block from outside the block.

Unless the block contains a loop, the statements run only once. You can nest different kinds of control structures. For more information, see Nested Control Structures.

Example 1

In the following example, each With block executes a series of statements on a single object.

Private Sub AddCustomer()
    Dim theCustomer As New Customer

    With theCustomer
        .Name = "Coho Vineyard"
        .URL = "http://www.cohovineyard.com/"
        .City = "Redmond"
    End With

    With theCustomer.Comments
        .Add("First comment.")
        .Add("Second comment.")
    End With
End Sub

Public Class Customer
    Public Property Name As String
    Public Property City As String
    Public Property URL As String

    Public Property Comments As New List(Of String)
End Class

Example 2

The following example nests With…End With statements. Within the nested With statement, the syntax refers to the inner object.

Dim theWindow As New EntryWindow

With theWindow
    With .InfoLabel
        .Content = "This is a message."
        .Foreground = Brushes.DarkSeaGreen
        .Background = Brushes.LightYellow
    End With

    .Title = "The Form Title"
    .Show()
End With

Example 3

The following example demonstrates how With...End With statements work with structures. You can assign to members of referenceable structures (like array elements), but not to structures returned by value or when parentheses are used.

Private Sub DemonstrateStructureWithStatement()
    ' Create an array of structures - this is referenceable
    Dim points(2) As Point

    ' Valid: Array elements are referenceable, so assignments work
    With points(0)
        .X = 10
        .Y = 20
    End With

    ' Create a single structure variable - this is also referenceable
    Dim singlePoint As Point
    With singlePoint
        .X = 30
        .Y = 40
    End With

    ' Invalid: Using parentheses cuts reference ties
    ' With (points(0))
    '     .X = 50  ' This would cause BC30068 error
    '     .Y = 60
    ' End With

    ' Invalid: Function returns by value, not referenceable
    ' With GetPoint()
    '     .X = 70  ' This would cause BC30068 error
    '     .Y = 80
    ' End With
End Sub

Private Function GetPoint() As Point
    Return New Point With {.X = 1, .Y = 2}
End Function

Private Structure Point
    Public X As Integer
    Public Y As Integer
End Structure

See also

• List<T>
• Nested Control Structures
• Object Initializers: Named and Anonymous Types
• Anonymous Types