Modifica di dati con valori elevati (massimi) in ADO.NETModifying Large-Value (max) Data in ADO.NET

I tipi di dati LOB (oggetti di grandi dimensioni) sono quelli che superano la dimensione massima di 8 kilobyte (KB) per le righe.Large object (LOB) data types are those that exceed the maximum row size of 8 kilobytes (KB). In SQL Server viene fornito un identificatore max per i tipi di dati varchar, nvarchar e varbinary per consentire l'archiviazione di valori di dimensioni pari a 2^32 byte.SQL Server provides a max specifier for varchar, nvarchar, and varbinary data types to allow storage of values as large as 2^32 bytes. Nelle colonne di tabelle e nelle variabili Transact-SQL possono essere specificati tipi di dati varchar(max), nvarchar(max) o varbinary(max).Table columns and Transact-SQL variables may specify varchar(max), nvarchar(max), or varbinary(max) data types. In ADO.NET i tipi di dati max possono essere recuperati da un DataReader e possono inoltre essere specificati come parametri di input e di output senza richiedere una gestione speciale.In ADO.NET, the max data types can be fetched by a DataReader, and can also be specified as both input and output parameter values without any special handling. Per tipi di dati varchar di grandi dimensioni, è possibile recuperare e aggiornare i dati in modo incrementale.For large varchar data types, data can be retrieved and updated incrementally.

I tipi di dati max possono essere usati per eseguire confronti, come le variabili Transact-SQL, e per eseguire concatenazioni.The max data types can be used for comparisons, as Transact-SQL variables, and for concatenation. È inoltre usarli nelle clausole DISTINCT, ORDER BY e GROUP BY di un'istruzione SELECT, nonché nelle aggregazioni, nelle unioni e nelle sottoquery.They can also be used in the DISTINCT, ORDER BY, GROUP BY clauses of a SELECT statement as well as in aggregates, joins, and subqueries.

La tabella seguente fornisce i collegamenti alla documentazione online di SQL Server.The following table provides links to the documentation in SQL Server Books Online.

Documentazione online di SQL ServerSQL Server Books Online

  1. Utilizzo di tipi di dati di valori di grandi dimensioniUsing Large-Value Data Types

Restrizioni per i tipi di valori di grandi dimensioniLarge-Value Type Restrictions

Le seguenti restrizioni si applicano ai tipi di dati max e non ai tipi di dati di dimensioni minori:The following restrictions apply to the max data types, which do not exist for smaller data types:

  • Un tipo sql_variant non può contenere un tipo di dati varchar di grandi dimensioni.A sql_variant cannot contain a large varchar data type.

  • Le colonne varchar di grandi dimensioni non possono essere specificate come colonne di chiave primaria in un indice.Large varchar columns cannot be specified as a key column in an index. Sono consentite in una colonna inclusa in un indice non cluster.They are allowed in an included column in a non-clustered index.

  • Le colonne varchar di grandi dimensioni non possono essere usate come colonne chiave di partizionamento.Large varchar columns cannot be used as partitioning key columns.

Uso di tipi di valori di grandi dimensioni in Transact-SQLWorking with Large-Value Types in Transact-SQL

La funzione OPENROWSET di Transact-SQL è un metodo unico per eseguire la connessione e l'accesso ai dati remoti.The Transact-SQL OPENROWSET function is a one-time method of connecting and accessing remote data. Include tutte le informazioni di connessione necessarie per l'accesso remoto ai dati da un'origine dati OLE DB.It includes all of the connection information necessary to access remote data from an OLE DB data source. È possibile fare riferimento a OPENROWSET nella clausola FROM di una query come se fosse un nome di tabella.OPENROWSET can be referenced in the FROM clause of a query as though it were a table name. È inoltre possibile farvi riferimento come tabella di destinazione di un'istruzione INSERT, UPDATE o DELETE, soggetta alle funzionalità del provider OLE DB.It can also be referenced as the target table of an INSERT, UPDATE, or DELETE statement, subject to the capabilities of the OLE DB provider.

La funzione OPENROWSET include il provider di set di righe BULK, che consente di leggere i dati direttamente da un file senza caricare i dati in una tabella di destinazione.The OPENROWSET function includes the BULK rowset provider, which allows you to read data directly from a file without loading the data into a target table. Questo consente l'uso di OPENROWSET in una semplice istruzione INSERT SELECT.This enables you to use OPENROWSET in a simple INSERT SELECT statement.

Il OPENROWSET``BULK gli argomenti dell'opzione forniscono un controllo notevole sul punto in cui iniziare e terminare la lettura dei dati, come gestire gli errori e sull'interpretazione dei dati.The OPENROWSET``BULK option arguments provide significant control over where to begin and end reading data, how to deal with errors, and how data is interpreted. È ad esempio possibile specificare che il file di dati venga letto come una singola riga o come un set di righe di una singola colonna di tipo varbinary, varchar o nvarchar.For example, you can specify that the data file be read as a single-row, single-column rowset of type varbinary, varchar, or nvarchar. Per la sintassi e le opzioni complete, vedere la documentazione online di SQL Server.For the complete syntax and options, see SQL Server Books Online.

Nell'esempio seguente viene inserita una foto nella tabella ProductPhoto del database di esempio AdventureWorks.The following example inserts a photo into the ProductPhoto table in the AdventureWorks sample database. Quando si utilizza il BULK``OPENROWSET provider, è necessario fornire l'elenco di colonne anche denominato se non si inseriscono valori in ogni colonna.When using the BULK``OPENROWSET provider, you must supply the named list of columns even if you aren't inserting values into every column. In questo caso, la chiave primaria è definita come colonna Identity e può essere omessa dall'elenco di colonne.The primary key in this case is defined as an identity column, and may be omitted from the column list. Notare che è necessario fornire anche un nome di correlazione alla fine dell'istruzione OPENROWSET, che in questo caso è ThumbnailPhoto.Note that you must also supply a correlation name at the end of the OPENROWSET statement, which in this case is ThumbnailPhoto. Tale nome è correlato alla colonna della tabella ProductPhoto in cui viene caricato il file.This correlates with the column in the ProductPhoto table into which the file is being loaded.

INSERT Production.ProductPhoto (  
    ThumbnailPhoto,   
    ThumbnailPhotoFilePath,   
    LargePhoto,   
    LargePhotoFilePath)  
SELECT ThumbnailPhoto.*, null, null, N'tricycle_pink.gif'  
FROM OPENROWSET   
    (BULK 'c:\images\tricycle.jpg', SINGLE_BLOB) ThumbnailPhoto  

Aggiornamento di dati tramite UPDATE .WRITEUpdating Data Using UPDATE .WRITE

L'istruzione Transact-SQL UPDATE include una nuova sintassi WRITE per modificare il contenuto delle colonne varchar(max), nvarchar(max) o varbinary(max).The Transact-SQL UPDATE statement has new WRITE syntax for modifying the contents of varchar(max), nvarchar(max), or varbinary(max) columns. In tal modo è possibile eseguire aggiornamenti parziali dei dati.This allows you to perform partial updates of the data. La sintassi UPDATE .WRITE viene illustrata di seguito in formato abbreviato:The UPDATE .WRITE syntax is shown here in abbreviated form:

AGGIORNAMENTOUPDATE

{ <oggetto > }{ <object> }

SETSET

{ column_name = {. SCRIVERE ( espressione , @Offset , @Length )}{ column_name = { .WRITE ( expression , @Offset , @Length ) }

Il metodo WRITE specifica che una sezione del valore del column_name verrà modificato.The WRITE method specifies that a section of the value of the column_name will be modified. L'espressione è il valore che verrà copiato il column_name, @Offset è il punto di inizio in cui verrà scritta l'espressione e il @Length argomento è la lunghezza della sezione nella colonna.The expression is the value that will be copied to the column_name, the @Offset is the beginning point at which the expression will be written, and the @Length argument is the length of the section in the column.

SeIf ThenThen
L'espressione è impostata su NULL.The expression is set to NULL @Length viene ignorato e il valore in column_name viene troncato in corrispondenza @Offset.@Length is ignored and the value in column_name is truncated at the specified @Offset.
Il valore di @Offset è NULL.@Offset is NULL L'operazione di aggiornamento aggiunge l'espressione alla fine dell'oggetto esistente column_name valore e @Length viene ignorato.The update operation appends the expression at the end of the existing column_name value and @Length is ignored.
Il valore di @Offset è maggiore della lunghezza del valore di column_name.@Offset is greater than the length of the column_name value SQL Server restituisce un errore.SQL Server returns an error.
Il valore di @Length è NULL.@Length is NULL L'operazione di aggiornamento rimuove tutti i dati a partire da @Offset alla fine del valore di column_name.The update operation removes all data from @Offset to the end of the column_name value.

Nota

Il valore di @Offset o di @Length non può essere un numero negativo.Neither @Offset nor @Length can be a negative number.

EsempioExample

In questo esempio di Transact-SQL viene aggiornato un valore parziale di DocumentSummary, una colonna nvarchar(max) della tabella Document nel database AdventureWorks.This Transact-SQL example updates a partial value in DocumentSummary, an nvarchar(max) column in the Document table in the AdventureWorks database. La parola "components" viene sostituita con la parola "features" specificando la parola di sostituzione, la posizione iniziale (offset) della parola da sostituire nei dati esistenti e il numero di caratteri da sostituire (lunghezza).The word 'components' is replaced by the word 'features' by specifying the replacement word, the beginning location (offset) of the word to be replaced in the existing data, and the number of characters to be replaced (length). Per confrontare i risultati, nell'esempio sono incluse le istruzioni SELECT precedenti e successive all'istruzione UPDATE.The example includes SELECT statements before and after the UPDATE statement to compare results.

USE AdventureWorks;  
GO  
--View the existing value.  
SELECT DocumentSummary  
FROM Production.Document  
WHERE DocumentID = 3;  
GO  
-- The first sentence of the results will be:  
-- Reflectors are vital safety components of your bicycle.  

--Modify a single word in the DocumentSummary column  
UPDATE Production.Document  
SET DocumentSummary .WRITE (N'features',28,10)  
WHERE DocumentID = 3 ;  
GO   
--View the modified value.  
SELECT DocumentSummary  
FROM Production.Document  
WHERE DocumentID = 3;  
GO  
-- The first sentence of the results will be:  
-- Reflectors are vital safety features of your bicycle.  

Uso di tipi di valori di grandi dimensioni in ADO.NETWorking with Large-Value Types in ADO.NET

È possibile utilizzare con i tipi di valori di grandi dimensioni in ADO.NET, che specifica i tipi di valori di grandi dimensioni come SqlParameter gli oggetti in un SqlDataReader per restituire un risultato o set, utilizzando un SqlDataAdapter per riempire un DataSet / DataTable.You can work with large value types in ADO.NET by specifying large value types as SqlParameter objects in a SqlDataReader to return a result set, or by using a SqlDataAdapter to fill a DataSet/DataTable. Non vi è differenza tra il modo di usare un tipo di valore di grandi dimensioni e il relativo tipo di dati del valore di dimensioni minori.There is no difference between the way you work with a large value type and its related, smaller value data type.

Uso di GetSqlBytes per il recupero di datiUsing GetSqlBytes to Retrieve Data

È possibile usare il metodo GetSqlBytes del tipo SqlDataReader per recuperare il contenuto di una colonna varbinary(max).The GetSqlBytes method of the SqlDataReader can be used to retrieve the contents of a varbinary(max) column. Il seguente frammento di codice presuppone un oggetto SqlCommand denominato cmd che consente di selezionare dati varbinary(max) da una tabella e un oggetto SqlDataReader denominato reader che consente di recuperare i dati come tipo SqlBytes.The following code fragment assumes a SqlCommand object named cmd that selects varbinary(max) data from a table and a SqlDataReader object named reader that retrieves the data as SqlBytes.

reader = cmd.ExecuteReader(CommandBehavior.CloseConnection)  
While reader.Read()  
    Dim bytes As SqlBytes = reader.GetSqlBytes(0)  
End While  
reader = cmd.ExecuteReader(CommandBehavior.CloseConnection);  
while (reader.Read())  
    {  
        SqlBytes bytes = reader.GetSqlBytes(0);  
    }  

Uso di GetSqlChars per il recupero di datiUsing GetSqlChars to Retrieve Data

È possibile usare il metodo GetSqlChars del tipo SqlDataReader per recuperare il contenuto di una colonna varchar(max) o nvarchar(max).The GetSqlChars method of the SqlDataReader can be used to retrieve the contents of a varchar(max) or nvarchar(max) column. Il seguente frammento di codice presuppone un oggetto SqlCommand denominato cmd che consente di selezionare dati nvarchar(max) da una tabella e un oggetto SqlDataReader denominato reader che consente di recuperare i dati.The following code fragment assumes a SqlCommand object named cmd that selects nvarchar(max) data from a table and a SqlDataReader object named reader that retrieves the data.

reader = cmd.ExecuteReader(CommandBehavior.CloseConnection)  
While reader.Read()  
    Dim buffer As SqlChars = reader.GetSqlChars(0)  
End While  
reader = cmd.ExecuteReader(CommandBehavior.CloseConnection);  
while (reader.Read())  
{  
    SqlChars buffer = reader.GetSqlChars(0);  
}  

Uso di GetSqlBinary per il recupero di datiUsing GetSqlBinary to Retrieve Data

È possibile usare il metodo GetSqlBinary di un tipo SqlDataReader per recuperare il contenuto di una colonna varbinary(max).The GetSqlBinary method of a SqlDataReader can be used to retrieve the contents of a varbinary(max) column. Il seguente frammento di codice presuppone un oggetto SqlCommand denominato cmd che consente di selezionare dati varbinary(max) da una tabella e un oggetto SqlDataReader denominato reader che consente di recuperare i dati come flusso SqlBinary.The following code fragment assumes a SqlCommand object named cmd that selects varbinary(max) data from a table and a SqlDataReader object named reader that retrieves the data as a SqlBinary stream.

reader = cmd.ExecuteReader(CommandBehavior.CloseConnection)  
While reader.Read()  
    Dim binaryStream As SqlBinary = reader.GetSqlBinary(0)  
End While  
reader = cmd.ExecuteReader(CommandBehavior.CloseConnection);  
while (reader.Read())  
    {  
        SqlBinary binaryStream = reader.GetSqlBinary(0);  
    }  

Uso di GetBytes per il recupero di datiUsing GetBytes to Retrieve Data

Il metodo GetBytes di un tipo SqlDataReader consente di leggere un flusso di byte dall'offset della colonna specificata nella matrice di byte a partire dall'offset della matrice specificata.The GetBytes method of a SqlDataReader reads a stream of bytes from the specified column offset into a byte array starting at the specified array offset. Il seguente frammento di codice presuppone un oggetto SqlDataReader denominato reader che consente di recuperare byte in una matrice di byte.The following code fragment assumes a SqlDataReader object named reader that retrieves bytes into a byte array. Notare che, a differenza di GetSqlBytes, con GetBytes è necessario specificare una dimensione per il buffer della matrice.Note that, unlike GetSqlBytes, GetBytes requires a size for the array buffer.

While reader.Read()  
    Dim buffer(4000) As Byte  
    Dim byteCount As Integer = _  
    CInt(reader.GetBytes(1, 0, buffer, 0, 4000))  
End While  
while (reader.Read())  
{  
    byte[] buffer = new byte[4000];  
    long byteCount = reader.GetBytes(1, 0, buffer, 0, 4000);  
}  

Uso di GetValue per il recupero di datiUsing GetValue to Retrieve Data

Il metodo GetValue di un tipo SqlDataReader consente di leggere il valore dall'offset della colonna specificata in una matrice.The GetValue method of a SqlDataReader reads the value from the specified column offset into an array. Il seguente frammento di codice presuppone un oggetto SqlDataReader denominato reader che consente di recuperare dati binari dall'offset della prima colonna e dati di tipo stringa dall'offset della seconda colonna.The following code fragment assumes a SqlDataReader object named reader that retrieves binary data from the first column offset, and then string data from the second column offset.

While reader.Read()  
    ' Read the data from varbinary(max) column  
    Dim binaryData() As Byte = CByte(reader.GetValue(0))  

    ' Read the data from varchar(max) or nvarchar(max) column  
    Dim stringData() As String = Cstr((reader.GetValue(1))  
End While  
while (reader.Read())  
{  
    // Read the data from varbinary(max) column  
    byte[] binaryData = (byte[])reader.GetValue(0);  

    // Read the data from varchar(max) or nvarchar(max) column  
    String stringData = (String)reader.GetValue(1);  
}  

Conversione da tipi di valore di grandi dimensioni a tipi CLRConverting from Large Value Types to CLR Types

È possibile convertire il contenuto di una colonna varchar(max) o nvarchar(max) usando uno dei metodi disponibili per la conversione di stringhe, ad esempio ToString.You can convert the contents of a varchar(max) or nvarchar(max) column using any of the string conversion methods, such as ToString. Il seguente frammento di codice presuppone un oggetto SqlDataReader denominato reader che consente di recuperare i dati.The following code fragment assumes a SqlDataReader object named reader that retrieves the data.

While reader.Read()  
    Dim str as String = reader(0).ToString()  
    Console.WriteLine(str)  
End While  
while (reader.Read())  
{  
     string str = reader[0].ToString();  
     Console.WriteLine(str);  
}  

EsempioExample

Il codice seguente consente di recuperare il nome e l'oggetto LargePhoto dalla tabella ProductPhoto del database AdventureWorks e di salvarlo in un file.The following code retrieves the name and the LargePhoto object from the ProductPhoto table in the AdventureWorks database and saves it to a file. È necessario compilare l'assembly con un riferimento allo spazio dei nomi System.Drawing.The assembly needs to be compiled with a reference to the System.Drawing namespace. Il metodo GetSqlBytes del tipo SqlDataReader restituisce un oggetto SqlBytes che espone una proprietà Stream.The GetSqlBytes method of the SqlDataReader returns a SqlBytes object that exposes a Stream property. Il codice utilizza per creare un nuovo Bitmap dell'oggetto che verrà quindi salvato nel formato ImageFormat.The code uses this to create a new Bitmap object, and then saves it in the Gif ImageFormat.

static private void TestGetSqlBytes(int documentID, string filePath)
{
    // Assumes GetConnectionString returns a valid connection string.
    using (SqlConnection connection =
               new SqlConnection(GetConnectionString()))
    {
        SqlCommand command = connection.CreateCommand();
        SqlDataReader reader = null;
        try
        {
            // Setup the command
            command.CommandText =
                "SELECT LargePhotoFileName, LargePhoto "
                + "FROM Production.ProductPhoto "
                + "WHERE ProductPhotoID=@ProductPhotoID";
            command.CommandType = CommandType.Text;

            // Declare the parameter
            SqlParameter paramID =
                new SqlParameter("@ProductPhotoID", SqlDbType.Int);
            paramID.Value = documentID;
            command.Parameters.Add(paramID);
            connection.Open();

            string photoName = null;

            reader = command.ExecuteReader(CommandBehavior.CloseConnection);

            if (reader.HasRows)
            {
                while (reader.Read())
                {
                    // Get the name of the file.
                    photoName = reader.GetString(0);

                    // Ensure that the column isn't null
                    if (reader.IsDBNull(1))
                    {
                        Console.WriteLine("{0} is unavailable.", photoName);
                    }
                    else
                    {
                        SqlBytes bytes = reader.GetSqlBytes(1);
                        using (Bitmap productImage = new Bitmap(bytes.Stream))
                        {
                            String fileName = filePath + photoName;

                            // Save in gif format.
                            productImage.Save(fileName, ImageFormat.Gif);
                            Console.WriteLine("Successfully created {0}.", fileName);
                        }
                    }
                }
            }
            else
            {
                Console.WriteLine("No records returned.");
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex.Message);
        }
        finally
        {
            if (reader != null)
                reader.Dispose();
        }
    }
}
Private Sub GetPhoto( _
  ByVal documentID As Integer, ByVal filePath As String)
    ' Assumes GetConnectionString returns a valid connection string.
    Using connection As New SqlConnection(GetConnectionString())
        Dim command As SqlCommand = connection.CreateCommand()
        Dim reader As SqlDataReader
        Try
            ' Setup the command
            command.CommandText = _
              "SELECT LargePhotoFileName, LargePhoto FROM" _
                & " Production.ProductPhoto" _
                & " WHERE ProductPhotoID=@ProductPhotoID"
            command.CommandType = CommandType.Text

            ' Declare the parameter
            Dim paramID As SqlParameter = _
                New SqlParameter("@ProductPhotoID", SqlDbType.Int)
            paramID.Value = documentID
            command.Parameters.Add(paramID)
            connection.Open()

            Dim photoName As String

            reader = _
             command.ExecuteReader(CommandBehavior.CloseConnection)

            If reader.HasRows Then
                While reader.Read()
                    ' Get the name of the file
                    photoName = reader.GetString(0)

                    ' Ensure that the column isn't null
                    If (reader.IsDBNull(1)) Then
                        Console.WriteLine("{0} is unavailable.", photoName)
                    Else
                        Dim bytes As SqlBytes = reader.GetSqlBytes(1)
                        Using productImage As Bitmap = _
                          New Bitmap(bytes.Stream)
                            Dim fileName As String = filePath & photoName

                            ' Save in gif format.
                            productImage.Save( _
                              fileName, ImageFormat.Gif)
                            Console.WriteLine("Successfully created {0}.", fileName)
                        End Using
                    End If
                End While
            Else
                Console.WriteLine("No records returned.")
            End If
        Catch ex As Exception
            Console.WriteLine("Exception: {0}", ex.Message)
        End Try
    End Using
End Sub

Uso dei parametri di tipo di valore di grandi dimensioniUsing Large Value Type Parameters

I tipi di valore di grandi dimensioni possono essere usati negli oggetti SqlParameter nello stesso modo in cui si usano tipi di valore di dimensioni minori in oggetti SqlParameter.Large value types can be used in SqlParameter objects the same way you use smaller value types in SqlParameter objects. È possibile recuperare tipi di valori di grandi dimensioni come SqlParameter valori, come illustrato nell'esempio seguente.You can retrieve large value types as SqlParameter values, as shown in the following example. Il codice presuppone l'esistenza della seguente stored procedure GetDocumentSummary nel database di esempio AdventureWorks.The code assumes that the following GetDocumentSummary stored procedure exists in the AdventureWorks sample database. La stored procedure accetta un parametro di input denominato @DocumentID e restituisce il contenuto della colonna DocumentSummary il @DocumentSummary parametro di output.The stored procedure takes an input parameter named @DocumentID and returns the contents of the DocumentSummary column in the @DocumentSummary output parameter.

CREATE PROCEDURE GetDocumentSummary   
(  
    @DocumentID int,  
    @DocumentSummary nvarchar(MAX) OUTPUT  
)  
AS  
SET NOCOUNT ON  
SELECT  @DocumentSummary=Convert(nvarchar(MAX), DocumentSummary)  
FROM    Production.Document  
WHERE   DocumentID=@DocumentID  

EsempioExample

Il codice di ADO.NET crea oggetti SqlConnection e SqlCommand per eseguire la stored procedure GetDocumentSummary e recuperare le informazioni di riepilogo del documento archiviate come tipo di valore di grandi dimensioni.The ADO.NET code creates SqlConnection and SqlCommand objects to execute the GetDocumentSummary stored procedure and retrieve the document summary, which is stored as a large value type. Il codice passa un valore il @DocumentID parametro di input e consente di visualizzare i risultati passati nuovamente il @DocumentSummary parametro nella finestra della Console di output.The code passes a value for the @DocumentID input parameter, and displays the results passed back in the @DocumentSummary output parameter in the Console window.

static private string GetDocumentSummary(int documentID)
{
    //Assumes GetConnectionString returns a valid connection string.
    using (SqlConnection connection =
               new SqlConnection(GetConnectionString()))
    {
        connection.Open();
        SqlCommand command = connection.CreateCommand();
        try
        {
            // Setup the command to execute the stored procedure.
            command.CommandText = "GetDocumentSummary";
            command.CommandType = CommandType.StoredProcedure;

            // Set up the input parameter for the DocumentID.
            SqlParameter paramID =
                new SqlParameter("@DocumentID", SqlDbType.Int);
            paramID.Value = documentID;
            command.Parameters.Add(paramID);

            // Set up the output parameter to retrieve the summary.
            SqlParameter paramSummary =
                new SqlParameter("@DocumentSummary",
                SqlDbType.NVarChar, -1);
            paramSummary.Direction = ParameterDirection.Output;
            command.Parameters.Add(paramSummary);

            // Execute the stored procedure.
            command.ExecuteNonQuery();
            Console.WriteLine((String)(paramSummary.Value));
            return (String)(paramSummary.Value);
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex.Message);
            return null;
        }
    }
}
Private Function GetDocumentSummary( _
  ByVal documentID As Integer) As String

    ' Assumes GetConnectionString returns a valid connection string.
    Using connection As New SqlConnection(GetConnectionString())
        connection.Open()
        Dim command As SqlCommand = connection.CreateCommand()

        ' Setup the command to execute the stored procedure.
        command.CommandText = "GetDocumentSummary"
        command.CommandType = CommandType.StoredProcedure

        ' Set up the input parameter for the DocumentID.
        Dim paramID As SqlParameter = _
            New SqlParameter("@DocumentID", SqlDbType.Int)
        paramID.Value = documentID
        command.Parameters.Add(paramID)

        ' Set up the output parameter to retrieve the summary.
        Dim paramSummary As SqlParameter = _
            New SqlParameter("@DocumentSummary", _
               SqlDbType.NVarChar, -1)
        paramSummary.Direction = ParameterDirection.Output
        command.Parameters.Add(paramSummary)

        ' Execute the stored procedure.
        command.ExecuteNonQuery()
        Console.WriteLine(paramSummary.Value)
        Return paramSummary.Value.ToString
    End Using
End Function

Vedere ancheSee Also

Dati binari e con valori elevati SQL ServerSQL Server Binary and Large-Value Data
Mapping dei tipi di dati SQL ServerSQL Server Data Type Mappings
Operazioni sui dati SQL Server in ADO.NETSQL Server Data Operations in ADO.NET
Provider gestiti ADO.NET e Centro per sviluppatori di set di datiADO.NET Managed Providers and DataSet Developer Center