¿Cómo se traduce la instrucción "Using" de C#a VB?

.net vb.net

Question

Por ejemplo:

BitmapImage bitmap = new BitmapImage();

byte[] buffer = GetHugeByteArray(); // from some external source
using (MemoryStream stream = new MemoryStream(buffer, false))
{
    bitmap.BeginInit();
    bitmap.CacheOption = BitmapCacheOption.OnLoad;
    bitmap.StreamSource = stream;
    bitmap.EndInit();
    bitmap.Freeze();
}

¿Me puede decir algo más sobre el using ?

Editar:

Como se discutió en los comentarios de la publicación de JaredPar, esta pregunta está más relacionada con una implementación de Using en VS2003. Se señaló que el Using no se introdujo hasta .NET 2.0 (VS2005). JaredPar publicó una solución equivalente.

Answer 1

El punto clave es que la clase "utilizada" debe implementar la interfaz IDisposable.

Answer 2

El uso tiene prácticamente la misma sintaxis en VB que C #, suponiendo que esté utilizando .NET 2.0 o posterior (lo que implica el compilador VB.NET v8 o posterior). Básicamente, simplemente quite los frenos y agregue un "Fin de usar"

Dim bitmap as New BitmapImage()
Dim buffer As Byte() = GetHugeByteArrayFromExternalSource()
Using stream As New MemoryStream(buffer, false)
    bitmap.BeginInit()
    bitmap.CacheOption = BitmapCacheOption.OnLoad
    bitmap.StreamSource = stream
    bitmap.EndInit()
    bitmap.Freeze()
End Using

Puede obtener la documentación completa aquí

• http://msdn.microsoft.com/en-us/library/htd05whh(VS.80).aspx

EDITAR

Si usa VS2003 o una versión anterior, necesitará el siguiente código. La sentencia using no se introdujo hasta VS 2005, .NET 2.0 ( reference ). Gracias Chris !. Lo siguiente es equivalente a la declaración de uso.

Dim bitmap as New BitmapImage()
Dim buffer As Byte() = GetHugeByteArrayFromExternalSource()
Dim stream As New MemoryStream(buffer, false)
Try
    bitmap.BeginInit()
    bitmap.CacheOption = BitmapCacheOption.OnLoad
    bitmap.StreamSource = stream
    bitmap.EndInit()
    bitmap.Freeze()
Finally
    DirectCast(stream, IDisposable).Dispose()
End Try

Answer 3

Es importante señalar que el uso se compila en realidad en varias líneas de código, similar al bloqueo, etc.

De la especificación de lenguaje C # .... Una declaración de uso de la forma

using (ResourceType resource = expression) statement

corresponde a una de las dos posibles expansiones. Cuando ResourceType es un tipo de valor, la expansión es

{
    ResourceType resource = expression;
    try {
        statement;
    }
    finally {
        ((IDisposable)resource).Dispose();
    }
}

De lo contrario, cuando ResourceType es un tipo de referencia, la expansión es

{
    ResourceType resource = expression;
    try {
        statement;
    }
    finally {
        if (resource != null) ((IDisposable)resource).Dispose();
    }
}

(fragmento de especificación de idioma final)

Básicamente, en tiempo de compilación se convierte en ese código. No hay un método llamado usar, etc. Traté de encontrar cosas similares en la especificación del lenguaje vb.net pero no pude encontrar nada, presumiblemente hace exactamente lo mismo.

Answer 4

Eso sería algo como esto:

Dim bitmap As New BitmapImage()
Dim buffer As Byte() = GetHugeByteArray()
Using stream As New MemoryStream(buffer, False)
    bitmap.BeginInit()
    bitmap.CacheOption = BitmapCacheOption.OnLoad
    bitmap.StreamSource = stream
    bitmap.EndInit()
    bitmap.Freeze()
End Using

Answer 5

Parece que using (C #) y Using (VB) tienen una diferencia extremadamente importante. Y al menos para mí ahora, puede vencer el propósito del Using .

Imports System.IO
Class Program

    Private Shared sw As StreamWriter

    Private Shared Sub DoSmth()
        sw.WriteLine("foo")
    End Sub

    Shared Sub Main(ByVal args As String())
        Using sw = New StreamWriter("C:/Temp/data.txt")
            DoSmth()
        End Using
    End Sub
End Class

Obtendrá NullReferenceException como en VB Using redefine la variable de clase de miembro mientras que en C # no!

Por supuesto, tal vez me falta algo ...