Socket.Send Metodo

Definizione

Spazio dei nomi:

System.Net.Sockets

Assembly:

System.Net.Sockets.dll

Invia dati a un Socket connesso.

Overload

Send(ReadOnlySpan<Byte>, SocketFlags, SocketError)	Invia dati a un oggetto Socket connesso utilizzando l'oggetto SocketFlags specificato.
Send(ReadOnlySpan<Byte>)	Invia dati a un Socket connesso.
Send(Byte[], Int32, Int32, SocketFlags, SocketError)	Invia il numero specificato di byte di dati a un oggetto Socket connesso, a partire dall'offset specificato e usando l'oggetto SocketFlags specificato.
Send(IList<ArraySegment<Byte>>, SocketFlags, SocketError)	Invia l'insieme di buffer dell'elenco a un Socket connesso utilizzando i SocketFlags specificati.
Send(Byte[], Int32, Int32, SocketFlags)	Invia il numero specificato di byte di dati a un oggetto Socket connesso, a partire dall'offset specificato e usando l'oggetto SocketFlags specificato.
Send(Byte[], Int32, SocketFlags)	Invia il numero specificato di byte di dati a un oggetto Socket connesso, utilizzando l'oggetto SocketFlags specificato.
Send(IList<ArraySegment<Byte>>)	Invia l'insieme di buffer dell'elenco a un Socket connesso.
Send(IList<ArraySegment<Byte>>, SocketFlags)	Invia l'insieme di buffer dell'elenco a un Socket connesso utilizzando i SocketFlags specificati.
Send(Byte[], SocketFlags)	Invia dati a un oggetto Socket connesso utilizzando l'oggetto SocketFlags specificato.
Send(ReadOnlySpan<Byte>, SocketFlags)	Invia dati a un oggetto Socket connesso utilizzando l'oggetto SocketFlags specificato.
Send(Byte[])	Invia dati a un Socket connesso.

Send(ReadOnlySpan<Byte>, SocketFlags, SocketError)

Origine:

Socket.cs

Invia dati a un oggetto Socket connesso utilizzando l'oggetto SocketFlags specificato.

public:
 int Send(ReadOnlySpan<System::Byte> buffer, System::Net::Sockets::SocketFlags socketFlags, [Runtime::InteropServices::Out] System::Net::Sockets::SocketError % errorCode);

public int Send (ReadOnlySpan<byte> buffer, System.Net.Sockets.SocketFlags socketFlags, out System.Net.Sockets.SocketError errorCode);

member this.Send : ReadOnlySpan<byte> * System.Net.Sockets.SocketFlags * SocketError -> int

Public Function Send (buffer As ReadOnlySpan(Of Byte), socketFlags As SocketFlags, ByRef errorCode As SocketError) As Integer

Parametri

buffer

ReadOnlySpan<Byte>

Intervallo di byte che contiene i dati da inviare.

socketFlags

SocketFlags

Combinazione bit per bit dei valori di enumerazione che specifica i comportamenti di invio e ricezione.

errorCode

SocketError

Quando termina, questo metodo contiene uno dei valori di enumerazione che definisce i codici errore per il socket.

Restituisce

Int32

Numero di byte inviati a Socket.

Eccezioni

SocketException

Si è verificato un errore durante il tentativo di accesso al socket.

ObjectDisposedException

L'oggetto Socket è stato chiuso.

Commenti

Send Invia in modo sincrono i dati all'host remoto specificato nel Connect metodo o Accept e restituisce il numero di byte inviati correttamente. Send può essere usato sia per i protocolli orientati alla connessione che per i protocolli senza connessione.

Questo overload richiede un buffer contenente i dati da inviare. Il SocketFlags valore predefinito è 0, l'offset del buffer viene impostato su 0 e il numero di byte da inviare per impostazione predefinita alle dimensioni del buffer.

Se si usa un protocollo senza connessione, è necessario chiamare prima di chiamare Connect questo metodo o Send generare un'eccezione SocketException. Se si usa un protocollo orientato alla connessione, è necessario usare Connect per stabilire una connessione host remota o usare Accept per accettare una connessione in ingresso.

Se si usa un protocollo senza connessione e si prevede di inviare dati a diversi host, è consigliabile usare il SendTo metodo . Se non si usa il SendTo metodo , sarà necessario chiamare Connect prima di ogni chiamata a Send. È possibile usare SendTo anche dopo aver stabilito un host remoto predefinito con Connect. È anche possibile modificare l'host remoto predefinito prima di chiamare Send effettuando un'altra chiamata a Connect.

Se si usa un protocollo orientato alla connessione, Send verrà bloccato fino a quando non vengono inviati tutti i byte nel buffer, a meno che non sia stato impostato un timeout tramite Socket.SendTimeout. Se il valore di timeout è stato superato, la Send chiamata genererà un oggetto SocketException. In modalità non di blocco, Send può essere completato correttamente anche se invia meno del numero di byte nel buffer. È responsabilità dell'applicazione tenere traccia del numero di byte inviati e ripetere l'operazione fino a quando l'applicazione non invia i byte nel buffer. Non esiste anche alcuna garanzia che i dati inviati vengano visualizzati immediatamente nella rete. Per aumentare l'efficienza della rete, il sistema sottostante può ritardare la trasmissione fino a quando non viene raccolta una quantità significativa di dati in uscita. Un completamento corretto del Send metodo indica che il sistema sottostante ha avuto spazio per memorizzare nel buffer i dati per un invio di rete.

Nota

Se si riceve un SocketExceptionoggetto , utilizzare la SocketException.ErrorCode proprietà per ottenere il codice di errore specifico. Dopo aver ottenuto questo codice, fare riferimento alla documentazione relativa al codice di errore dell'API Windows Sockets versione 2 per una descrizione dettagliata dell'errore.

Questo membro genera informazioni di traccia quando viene abilitata la funzionalità di traccia di rete nell'applicazione in uso. Per altre informazioni, vedere Traccia di rete in .NET Framework.

Importante

Il completamento corretto di un invio non indica che i dati sono stati recapitati correttamente. Se non è disponibile spazio buffer all'interno del sistema di trasporto per contenere i dati da trasmettere, l'invio bloccherà a meno che il socket non sia stato inserito in modalità non di blocco.

Vedi anche

• Connect(EndPoint)
• SendTo(Byte[], Int32, Int32, SocketFlags, EndPoint)
• SocketFlags
• SetSocketOption(SocketOptionLevel, SocketOptionName, Int32)

Send(ReadOnlySpan<Byte>)

Origine:

Socket.cs

Invia dati a un Socket connesso.

public:
 int Send(ReadOnlySpan<System::Byte> buffer);

public int Send (ReadOnlySpan<byte> buffer);

member this.Send : ReadOnlySpan<byte> -> int

Public Function Send (buffer As ReadOnlySpan(Of Byte)) As Integer

Parametri

buffer

ReadOnlySpan<Byte>

Intervallo di byte che contiene i dati da inviare.

Restituisce

Int32

Numero di byte inviati a Socket.

Eccezioni

SocketException

Si è verificato un errore durante il tentativo di accesso al socket.

ObjectDisposedException

L'oggetto Socket è stato chiuso.

Commenti

Send Invia in modo sincrono i dati all'host remoto specificato nel Connect metodo o Accept e restituisce il numero di byte inviati correttamente. Send può essere usato sia per i protocolli orientati alla connessione che per i protocolli senza connessione.

Questo overload richiede un buffer contenente i dati da inviare. Il SocketFlags valore predefinito è 0, l'offset del buffer viene impostato su 0 e il numero di byte da inviare per impostazione predefinita alle dimensioni del buffer.

Se si usa un protocollo senza connessione, è necessario chiamare prima di chiamare Connect questo metodo o Send generare un'eccezione SocketException. Se si usa un protocollo orientato alla connessione, è necessario usare Connect per stabilire una connessione host remota o usare Accept per accettare una connessione in ingresso.

Se si usa un protocollo senza connessione e si prevede di inviare dati a diversi host, è consigliabile usare il SendTo metodo . Se non si usa il SendTo metodo , sarà necessario chiamare Connect prima di ogni chiamata a Send. È possibile usare SendTo anche dopo aver stabilito un host remoto predefinito con Connect. È anche possibile modificare l'host remoto predefinito prima di chiamare Send effettuando un'altra chiamata a Connect.

Se si usa un protocollo orientato alla connessione, Send verrà bloccato fino a quando non vengono inviati tutti i byte nel buffer, a meno che non sia stato impostato un timeout tramite Socket.SendTimeout. Se il valore di timeout è stato superato, la Send chiamata genererà un oggetto SocketException. In modalità non di blocco, Send può essere completato correttamente anche se invia meno del numero di byte nel buffer. È responsabilità dell'applicazione tenere traccia del numero di byte inviati e ripetere l'operazione fino a quando l'applicazione non invia i byte nel buffer. Non esiste anche alcuna garanzia che i dati inviati vengano visualizzati immediatamente nella rete. Per aumentare l'efficienza della rete, il sistema sottostante può ritardare la trasmissione fino a quando non viene raccolta una quantità significativa di dati in uscita. Un completamento corretto del Send metodo indica che il sistema sottostante ha avuto spazio per memorizzare nel buffer i dati per un invio di rete.

Nota

Se si riceve un SocketExceptionoggetto , utilizzare la SocketException.ErrorCode proprietà per ottenere il codice di errore specifico. Dopo aver ottenuto questo codice, fare riferimento alla documentazione relativa al codice di errore dell'API Windows Sockets versione 2 per una descrizione dettagliata dell'errore.

Questo membro genera informazioni di traccia quando viene abilitata la funzionalità di traccia di rete nell'applicazione in uso. Per altre informazioni, vedere Traccia di rete in .NET Framework.

Importante

Il completamento corretto di un invio non indica che i dati sono stati recapitati correttamente. Se non è disponibile spazio buffer all'interno del sistema di trasporto per contenere i dati da trasmettere, l'invio bloccherà a meno che il socket non sia stato inserito in modalità non di blocco.

Vedi anche

• Connect(EndPoint)
• SendTo(Byte[], Int32, Int32, SocketFlags, EndPoint)
• SocketFlags
• SetSocketOption(SocketOptionLevel, SocketOptionName, Int32)

Send(Byte[], Int32, Int32, SocketFlags, SocketError)

Origine:

Socket.cs

Invia il numero specificato di byte di dati a un oggetto Socket connesso, a partire dall'offset specificato e usando l'oggetto SocketFlags specificato.

public:
 int Send(cli::array <System::Byte> ^ buffer, int offset, int size, System::Net::Sockets::SocketFlags socketFlags, [Runtime::InteropServices::Out] System::Net::Sockets::SocketError % errorCode);

public int Send (byte[] buffer, int offset, int size, System.Net.Sockets.SocketFlags socketFlags, out System.Net.Sockets.SocketError errorCode);

member this.Send : byte[] * int * int * System.Net.Sockets.SocketFlags * SocketError -> int

Public Function Send (buffer As Byte(), offset As Integer, size As Integer, socketFlags As SocketFlags, ByRef errorCode As SocketError) As Integer

Parametri

buffer

Byte[]

Matrice di Byte che contiene i dati da inviare.

offset

Int32

Posizione nel buffer di dati da cui iniziare l'invio di dati.

size

Int32

Numero di byte da inviare.

socketFlags

SocketFlags

Combinazione bit per bit dei valori di SocketFlags.

errorCode

SocketError

Oggetto SocketError che memorizza l'errore del socket.

Restituisce

Int32

Numero di byte inviati a Socket.

Eccezioni

ArgumentNullException

buffer è null.

ArgumentOutOfRangeException

offset è minore di 0.

-oppure-

offset è maggiore della lunghezza di buffer.

-oppure-

size è minore di 0.

-oppure-

size è maggiore della lunghezza di buffer meno il valore del parametro offset.

SocketException

socketFlags non è una combinazione valida di valori.

-oppure-

Si verifica un errore del sistema operativo durante l'accesso a Socket.

ObjectDisposedException

L'oggetto Socket è stato chiuso.

Esempio

Nell'esempio di codice seguente vengono specificati il buffer di dati, un offset, una dimensione e SocketFlags per l'invio di dati a un oggetto connesso Socket.

// Displays sending with a connected socket
// using the overload that takes a buffer, offset, message size, and socket flags.
int SendReceiveTest4( Socket^ server )
{
   array<Byte>^ msg = Encoding::UTF8->GetBytes( "This is a test" );
   array<Byte>^ bytes = gcnew array<Byte>(256);
   try
   {
      
      // Blocks until send returns.
      int byteCount = server->Send( msg, 0, msg->Length, SocketFlags::None );
      Console::WriteLine( "Sent {0} bytes.", byteCount.ToString() );
      
      // Get reply from the server.
      byteCount = server->Receive( bytes, 0, server->Available,
         SocketFlags::None );
      if ( byteCount > 0 )
      {
         Console::WriteLine( Encoding::UTF8->GetString( bytes ) );
      }
   }
   catch ( SocketException^ e ) 
   {
      Console::WriteLine(  "{0} Error code: {1}.", e->Message, e->ErrorCode.ToString() );
      return (e->ErrorCode);
   }
   return 0;
}

// Displays sending with a connected socket
// using the overload that takes a buffer, offset, message size, and socket flags.
public static int SendReceiveTest4(Socket server)
{
    byte[] msg = Encoding.UTF8.GetBytes("This is a test");
    byte[] bytes = new byte[256];
    try
    {
        // Blocks until send returns.
        int byteCount = server.Send(msg, 0, msg.Length, SocketFlags.None);
        Console.WriteLine("Sent {0} bytes.", byteCount);

        // Get reply from the server.
        byteCount = server.Receive(bytes, 0, bytes.Length, SocketFlags.None);

        if (byteCount > 0)
            Console.WriteLine(Encoding.UTF8.GetString(bytes, 0, byteCount));
    }
    catch (SocketException e)
    {
        Console.WriteLine("{0} Error code: {1}.", e.Message, e.ErrorCode);
        return (e.ErrorCode);
    }
    return 0;
}

' Displays sending with a connected socket
' using the overload that takes a buffer, offset, message size, and socket flags.
Public Shared Function SendReceiveTest4(ByVal server As Socket) As Integer 
    Dim msg As Byte() = Encoding.UTF8.GetBytes("This is a test")
    Dim bytes(255) As Byte
    Try
        ' Blocks until send returns.
        Dim byteCount As Integer = server.Send(msg, 0, msg.Length, SocketFlags.None)
        Console.WriteLine("Sent {0} bytes.", byteCount)
        
        ' Get reply from the server.
        byteCount = server.Receive(bytes, 0, server.Available, SocketFlags.None)
        
        If byteCount > 0 Then
            Console.WriteLine(Encoding.UTF8.GetString(bytes))
        End If
    Catch e As SocketException
        Console.WriteLine("{0} Error code: {1}.", e.Message, e.ErrorCode)
        Return e.ErrorCode
    End Try
    Return 0

End Function 'SendReceiveTest4

Commenti

Send invia in modo sincrono i dati all'host remoto specificato nel Connect metodo o Accept e restituisce il numero di byte inviati correttamente. Send può essere usato sia per i protocolli orientati alla connessione che per i protocolli senza connessione.

In questo overload, se si specifica il DontRoute flag come socketflags parametro, i dati inviati non verranno indirizzati.

Se si usa un protocollo senza connessione, è necessario chiamare Connect prima di chiamare questo metodo o Send generare un SocketExceptionoggetto . Se si usa un protocollo orientato alla connessione, è necessario usare Connect per stabilire una connessione host remota o usare Accept per accettare una connessione in ingresso.

Se si usa un protocollo senza connessione e si prevede di inviare dati a diversi host, è consigliabile usare SendTo. Se non si usa SendTo, è necessario chiamare Connect prima di ogni chiamata a Send. È consigliabile usare SendTo anche dopo aver stabilito un host remoto predefinito con Connect. È anche possibile modificare l'host remoto predefinito prima di chiamare Send eseguendo un'altra chiamata a Connect.

È anche necessario assicurarsi che le dimensioni non superino le dimensioni massime del provider di servizi sottostanti. In caso contrario, il datagram non verrà inviato e Send genererà un SocketExceptionoggetto .

Se si usa un protocollo orientato alla connessione, Send verrà bloccato fino all'invio del numero richiesto di byte, a meno che non sia stato impostato un timeout usando Socket.SendTimeout. Se il valore di timeout è stato superato, la Send chiamata genererà un SocketExceptionoggetto . In modalità non sbloccante, Send può essere completato correttamente anche se invia meno del numero di byte richiesto. È responsabilità dell'applicazione tenere traccia del numero di byte inviati e riprovare l'operazione fino a quando l'applicazione invia il numero richiesto di byte. Non vi è anche alcuna garanzia che i dati inviati verranno visualizzati immediatamente nella rete. Per aumentare l'efficienza della rete, il sistema sottostante può ritardare la trasmissione fino a quando non viene raccolta una quantità significativa di dati in uscita. Un completamento riuscito del Send metodo significa che il sistema sottostante ha avuto spazio per bufferre i dati per un invio di rete.

Nota

Se si riceve un SocketExceptionoggetto , utilizzare la proprietà per ottenere il SocketException.ErrorCode codice di errore specifico. Dopo aver ottenuto questo codice, vedere la documentazione del codice di errore dell'API Windows Sockets versione 2 per una descrizione dettagliata dell'errore.

Nota

Il completamento riuscito di un invio non indica che i dati sono stati recapitati correttamente. Se non è disponibile spazio buffer all'interno del sistema di trasporto per contenere i dati da trasmettere, l'invio bloccherà a meno che il socket non sia stato inserito in modalità non di blocco.

Nota

Questo membro genera informazioni di traccia quando viene abilitata la funzionalità di traccia di rete nell'applicazione in uso. Per altre informazioni, vedere Traccia di rete in .NET Framework.

Vedi anche

• Connect(EndPoint)
• SendTo(Byte[], Int32, Int32, SocketFlags, EndPoint)
• SocketFlags
• SetSocketOption(SocketOptionLevel, SocketOptionName, Int32)

Send(IList<ArraySegment<Byte>>, SocketFlags, SocketError)

Origine:

Socket.cs

Invia l'insieme di buffer dell'elenco a un Socket connesso utilizzando i SocketFlags specificati.

public:
 int Send(System::Collections::Generic::IList<ArraySegment<System::Byte>> ^ buffers, System::Net::Sockets::SocketFlags socketFlags, [Runtime::InteropServices::Out] System::Net::Sockets::SocketError % errorCode);

public int Send (System.Collections.Generic.IList<ArraySegment<byte>> buffers, System.Net.Sockets.SocketFlags socketFlags, out System.Net.Sockets.SocketError errorCode);

member this.Send : System.Collections.Generic.IList<ArraySegment<byte>> * System.Net.Sockets.SocketFlags * SocketError -> int

Public Function Send (buffers As IList(Of ArraySegment(Of Byte)), socketFlags As SocketFlags, ByRef errorCode As SocketError) As Integer

Parametri

buffers

IList<ArraySegment<Byte>>

Elenco di oggetti ArraySegment<T> di tipo Byte in cui sono contenuti i dati da inviare.

socketFlags

SocketFlags

Combinazione bit per bit dei valori di SocketFlags.

errorCode

SocketError

Oggetto SocketError che memorizza l'errore del socket.

Restituisce

Int32

Numero di byte inviati a Socket.

Eccezioni

ArgumentNullException

buffers è null.

ArgumentException

buffers è vuoto.

SocketException

Si è verificato un errore durante il tentativo di accesso al socket.

ObjectDisposedException

L'oggetto Socket è stato chiuso.

Commenti

Questo overload richiede almeno un buffer che contiene i dati da inviare. Il SocketFlags valore predefinito è 0. Se si specifica il DontRoute flag come socketFlags parametro, i dati inviati non verranno indirizzati.

Se si usa un protocollo senza connessione, è necessario chiamare Connect prima di chiamare questo metodo oppure Send generare un SocketExceptionoggetto . Se si usa un protocollo orientato alla connessione, è necessario usare Connect per stabilire una connessione host remota o usare Accept per accettare una connessione in ingresso.

Se si usa un protocollo senza connessione e si prevede di inviare dati a diversi host, è consigliabile usare il SendTo metodo . Se non si usa il SendTo metodo, è necessario chiamare Connect prima di ogni chiamata a Send. È possibile usare SendTo anche dopo aver stabilito un host remoto predefinito con Connect. È anche possibile modificare l'host remoto predefinito prima di chiamare Send eseguendo un'altra chiamata a Connect.

Se si usa un protocollo orientato alla connessione, verrà bloccato finché non vengono inviati tutti i byte nel buffer, Send a meno che non sia stato impostato un timeout usando Socket.SendTimeout. Se il valore di timeout è stato superato, la Send chiamata genererà un SocketExceptionoggetto . In modalità non di blocco, Send può essere completato correttamente anche se invia meno del numero di byte nel buffer. È responsabilità dell'applicazione tenere traccia del numero di byte inviati e riprovare l'operazione fino a quando l'applicazione invia i byte nel buffer. Non vi è anche alcuna garanzia che i dati inviati verranno visualizzati immediatamente nella rete. Per aumentare l'efficienza della rete, il sistema sottostante può ritardare la trasmissione fino a quando non viene raccolta una quantità significativa di dati in uscita. Un completamento riuscito del Send metodo significa che il sistema sottostante ha avuto spazio per bufferre i dati per un invio di rete.

Nota

Se si riceve un SocketExceptionoggetto , utilizzare la proprietà per ottenere il SocketException.ErrorCode codice di errore specifico. Dopo aver ottenuto questo codice, vedere la documentazione del codice di errore dell'API Windows Sockets versione 2 per una descrizione dettagliata dell'errore.

Nota

Il completamento riuscito di un invio non indica che i dati sono stati recapitati correttamente. Se non è disponibile spazio buffer all'interno del sistema di trasporto per contenere i dati da trasmettere, l'invio bloccherà a meno che il socket non sia stato inserito in modalità non di blocco.

Nota

Questo membro genera informazioni di traccia quando viene abilitata la funzionalità di traccia di rete nell'applicazione in uso. Per altre informazioni, vedere Traccia di rete in .NET Framework.

Send(Byte[], Int32, Int32, SocketFlags)

Origine:

Socket.cs

Invia il numero specificato di byte di dati a un oggetto Socket connesso, a partire dall'offset specificato e usando l'oggetto SocketFlags specificato.

public:
 int Send(cli::array <System::Byte> ^ buffer, int offset, int size, System::Net::Sockets::SocketFlags socketFlags);

public int Send (byte[] buffer, int offset, int size, System.Net.Sockets.SocketFlags socketFlags);

member this.Send : byte[] * int * int * System.Net.Sockets.SocketFlags -> int

Public Function Send (buffer As Byte(), offset As Integer, size As Integer, socketFlags As SocketFlags) As Integer

Parametri

buffer

Byte[]

Matrice di Byte che contiene i dati da inviare.

offset

Int32

Posizione nel buffer di dati da cui iniziare l'invio di dati.

size

Int32

Numero di byte da inviare.

socketFlags

SocketFlags

Combinazione bit per bit dei valori di SocketFlags.

Restituisce

Int32

Numero di byte inviati a Socket.

Eccezioni

ArgumentNullException

buffer è null.

ArgumentOutOfRangeException

offset è minore di 0.

-oppure-

offset è maggiore della lunghezza di buffer.

-oppure-

size è minore di 0.

-oppure-

size è maggiore della lunghezza di buffer meno il valore del parametro offset.

SocketException

socketFlags non è una combinazione valida di valori.

-oppure-

Si verifica un errore del sistema operativo durante l'accesso a Socket.

ObjectDisposedException

L'oggetto Socket è stato chiuso.

Esempio

Nell'esempio di codice seguente viene specificato il buffer dati, un offset, una dimensione e SocketFlags per l'invio di dati a un oggetto connesso Socket.

// Displays sending with a connected socket
// using the overload that takes a buffer, offset, message size, and socket flags.
int SendReceiveTest4( Socket^ server )
{
   array<Byte>^ msg = Encoding::UTF8->GetBytes( "This is a test" );
   array<Byte>^ bytes = gcnew array<Byte>(256);
   try
   {
      
      // Blocks until send returns.
      int byteCount = server->Send( msg, 0, msg->Length, SocketFlags::None );
      Console::WriteLine( "Sent {0} bytes.", byteCount.ToString() );
      
      // Get reply from the server.
      byteCount = server->Receive( bytes, 0, server->Available,
         SocketFlags::None );
      if ( byteCount > 0 )
      {
         Console::WriteLine( Encoding::UTF8->GetString( bytes ) );
      }
   }
   catch ( SocketException^ e ) 
   {
      Console::WriteLine(  "{0} Error code: {1}.", e->Message, e->ErrorCode.ToString() );
      return (e->ErrorCode);
   }
   return 0;
}

// Displays sending with a connected socket
// using the overload that takes a buffer, offset, message size, and socket flags.
public static int SendReceiveTest4(Socket server)
{
    byte[] msg = Encoding.UTF8.GetBytes("This is a test");
    byte[] bytes = new byte[256];
    try
    {
        // Blocks until send returns.
        int byteCount = server.Send(msg, 0, msg.Length, SocketFlags.None);
        Console.WriteLine("Sent {0} bytes.", byteCount);

        // Get reply from the server.
        byteCount = server.Receive(bytes, 0, bytes.Length, SocketFlags.None);

        if (byteCount > 0)
            Console.WriteLine(Encoding.UTF8.GetString(bytes, 0, byteCount));
    }
    catch (SocketException e)
    {
        Console.WriteLine("{0} Error code: {1}.", e.Message, e.ErrorCode);
        return (e.ErrorCode);
    }
    return 0;
}

' Displays sending with a connected socket
' using the overload that takes a buffer, offset, message size, and socket flags.
Public Shared Function SendReceiveTest4(ByVal server As Socket) As Integer 
    Dim msg As Byte() = Encoding.UTF8.GetBytes("This is a test")
    Dim bytes(255) As Byte
    Try
        ' Blocks until send returns.
        Dim byteCount As Integer = server.Send(msg, 0, msg.Length, SocketFlags.None)
        Console.WriteLine("Sent {0} bytes.", byteCount)
        
        ' Get reply from the server.
        byteCount = server.Receive(bytes, 0, server.Available, SocketFlags.None)
        
        If byteCount > 0 Then
            Console.WriteLine(Encoding.UTF8.GetString(bytes))
        End If
    Catch e As SocketException
        Console.WriteLine("{0} Error code: {1}.", e.Message, e.ErrorCode)
        Return e.ErrorCode
    End Try
    Return 0

End Function 'SendReceiveTest4

Commenti

Send invia in modo sincrono i dati all'host remoto specificato nel Connect metodo o Accept e restituisce il numero di byte inviati correttamente. Send può essere usato sia per i protocolli orientati alla connessione che per i protocolli senza connessione.

In questo overload, se si specifica il DontRoute flag come socketflags parametro, i dati inviati non verranno indirizzati.

Se si usa un protocollo senza connessione, è necessario chiamare Connect prima di chiamare questo metodo o Send generare un SocketExceptionoggetto . Se si usa un protocollo orientato alla connessione, è necessario usare Connect per stabilire una connessione host remota o usare Accept per accettare una connessione in ingresso.

Se si usa un protocollo senza connessione e si prevede di inviare dati a diversi host, è consigliabile usare SendTo. Se non si usa SendTo, è necessario chiamare Connect prima di ogni chiamata a Send. È consigliabile usare SendTo anche dopo aver stabilito un host remoto predefinito con Connect. È anche possibile modificare l'host remoto predefinito prima di chiamare Send eseguendo un'altra chiamata a Connect.

È anche necessario assicurarsi che le dimensioni non superino le dimensioni massime del provider di servizi sottostanti. In caso contrario, il datagram non verrà inviato e Send genererà un SocketExceptionoggetto .

Se si usa un protocollo orientato alla connessione, Send verrà bloccato fino all'invio del numero richiesto di byte, a meno che non sia stato impostato un timeout usando Socket.SendTimeout. Se il valore di timeout è stato superato, la Send chiamata genererà un SocketExceptionoggetto . In modalità non sbloccante, Send può essere completato correttamente anche se invia meno del numero di byte richiesto. È responsabilità dell'applicazione tenere traccia del numero di byte inviati e riprovare l'operazione fino a quando l'applicazione invia il numero richiesto di byte. Non esiste inoltre alcuna garanzia che i dati inviati vengano visualizzati immediatamente nella rete. Per aumentare l'efficienza della rete, il sistema sottostante può ritardare la trasmissione fino a quando non viene raccolta una quantità significativa di dati in uscita. Un completamento corretto del Send metodo indica che il sistema sottostante ha avuto spazio per memorizzare nel buffer i dati per un invio di rete.

Nota

Se si riceve un SocketExceptionoggetto , utilizzare la SocketException.ErrorCode proprietà per ottenere il codice di errore specifico. Dopo aver ottenuto questo codice, fare riferimento alla documentazione relativa al codice di errore dell'API Windows Sockets versione 2 per una descrizione dettagliata dell'errore.

Nota

Il completamento corretto di un invio non indica che i dati sono stati recapitati correttamente. Se non è disponibile spazio buffer all'interno del sistema di trasporto per contenere i dati da trasmettere, l'invio bloccherà a meno che il socket non sia stato inserito in modalità non di blocco.

Nota

Questo membro genera informazioni di traccia quando viene abilitata la funzionalità di traccia di rete nell'applicazione in uso. Per altre informazioni, vedere Traccia di rete in .NET Framework.

Vedi anche

• Connect(EndPoint)
• SendTo(Byte[], Int32, Int32, SocketFlags, EndPoint)
• SocketFlags
• SetSocketOption(SocketOptionLevel, SocketOptionName, Int32)

Send(Byte[], Int32, SocketFlags)

Origine:

Socket.cs

Invia il numero specificato di byte di dati a un oggetto Socket connesso, utilizzando l'oggetto SocketFlags specificato.

public:
 int Send(cli::array <System::Byte> ^ buffer, int size, System::Net::Sockets::SocketFlags socketFlags);

public int Send (byte[] buffer, int size, System.Net.Sockets.SocketFlags socketFlags);

member this.Send : byte[] * int * System.Net.Sockets.SocketFlags -> int

Public Function Send (buffer As Byte(), size As Integer, socketFlags As SocketFlags) As Integer

Parametri

buffer

Byte[]

Matrice di Byte che contiene i dati da inviare.

size

Int32

Numero di byte da inviare.

socketFlags

SocketFlags

Combinazione bit per bit dei valori di SocketFlags.

Restituisce

Int32

Numero di byte inviati a Socket.

Eccezioni

ArgumentNullException

buffer è null.

ArgumentOutOfRangeException

size è inferiore a 0 o supera la dimensione del buffer.

SocketException

socketFlags non è una combinazione valida di valori.

-oppure-

Si è verificato un errore del sistema operativo durante l'accesso al socket.

ObjectDisposedException

L'oggetto Socket è stato chiuso.

Esempio

L'esempio di codice seguente invia i dati trovati nel buffer e specifica None per SocketFlags.

// Displays sending with a connected socket
// using the overload that takes a buffer, message size, and socket flags.
int SendReceiveTest3( Socket^ server )
{
   array<Byte>^ msg = Encoding::UTF8->GetBytes( "This is a test" );
   array<Byte>^ bytes = gcnew array<Byte>(256);
   try
   {
      // Blocks until send returns.
      int i = server->Send( msg, msg->Length, SocketFlags::None );
      Console::WriteLine( "Sent {0} bytes.", i.ToString() );
      
      // Get reply from the server.
      int byteCount = server->Receive( bytes, server->Available,
         SocketFlags::None );
      if ( byteCount > 0 )
      {
         Console::WriteLine( Encoding::UTF8->GetString( bytes ) );
      }
   }
   catch ( SocketException^ e ) 
   {
      Console::WriteLine( "{0} Error code: {1}.", e->Message, e->ErrorCode.ToString() );
      return (e->ErrorCode);
   }
   return 0;
}

// Displays sending with a connected socket
// using the overload that takes a buffer, message size, and socket flags.
public static int SendReceiveTest3(Socket server)
{
    byte[] msg = Encoding.UTF8.GetBytes("This is a test");
    byte[] bytes = new byte[256];
    try
    {
        // Blocks until send returns.
        int i = server.Send(msg, msg.Length, SocketFlags.None);
        Console.WriteLine("Sent {0} bytes.", i);

        // Get reply from the server.
        int byteCount = server.Receive(bytes, bytes.Length, SocketFlags.None);
        if (byteCount > 0)
            Console.WriteLine(Encoding.UTF8.GetString(bytes, 0, byteCount));
    }
    catch (SocketException e)
    {
        Console.WriteLine("{0} Error code: {1}.", e.Message, e.ErrorCode);
        return (e.ErrorCode);
    }
    return 0;
}

' Displays sending with a connected socket
' using the overload that takes a buffer, message size, and socket flags.
Public Shared Function SendReceiveTest3(ByVal server As Socket) As Integer 
    Dim msg As Byte() = Encoding.UTF8.GetBytes("This is a test")
    Dim bytes(255) As Byte
    Try
        ' Blocks until send returns.
        Dim i As Integer = server.Send(msg, msg.Length, SocketFlags.None)
        Console.WriteLine("Sent {0} bytes.", i)
        
        ' Get reply from the server.
        Dim byteCount As Integer = server.Receive(bytes, server.Available, SocketFlags.None)
        If byteCount > 0 Then
            Console.WriteLine(Encoding.UTF8.GetString(bytes))
        End If
    Catch e As SocketException
        Console.WriteLine("{0} Error code: {1}.", e.Message, e.ErrorCode)
        Return e.ErrorCode
    End Try
    Return 0

End Function 'SendReceiveTest3

Commenti

Send Invia in modo sincrono i dati all'host remoto stabilito nel Connect metodo o Accept e restituisce il numero di byte inviati correttamente. Send può essere usato sia per i protocolli orientati alla connessione che per i protocolli senza connessione.

Questo overload richiede un buffer contenente i dati da inviare, il numero di byte da inviare e una combinazione bit per bit di qualsiasi SocketFlags. Se si specifica il DontRoute flag come socketflags parametro, i dati inviati non verranno instradati.

Se si usa un protocollo senza connessione, è necessario chiamare prima di chiamare Connect questo metodo o Send generare un'eccezione SocketException. Se si usa un protocollo orientato alla connessione, è necessario usare Connect per stabilire una connessione host remota o usare Accept per accettare una connessione in ingresso.

Se si usa un protocollo senza connessione e si prevede di inviare dati a diversi host, è consigliabile usare il SendTo metodo . Se si esegue il tuse del SendTo metodo, sarà necessario chiamare il Connect metodo prima di ogni chiamata al Send metodo . È possibile usare SendTo anche dopo aver stabilito un host remoto predefinito con Connect. È anche possibile modificare l'host remoto predefinito prima di chiamare Send effettuando un'altra chiamata a Connect.

Con un protocollo orientato alla connessione, Send verrà bloccato fino a quando non viene inviato il numero di byte richiesto, a meno che non sia stato impostato un timeout tramite Socket.SendTimeout. Se il valore di timeout è stato superato, la Send chiamata genererà un oggetto SocketException. In modalità non di blocco, Send può essere completato correttamente anche se invia meno del numero di byte richiesti. È responsabilità dell'applicazione tenere traccia del numero di byte inviati e ripetere l'operazione fino a quando l'applicazione non invia il numero di byte richiesto. Non esiste inoltre alcuna garanzia che i dati inviati vengano visualizzati immediatamente nella rete. Per aumentare l'efficienza della rete, il sistema sottostante può ritardare la trasmissione fino a quando non viene raccolta una quantità significativa di dati in uscita. Un completamento corretto del Send metodo indica che il sistema sottostante ha avuto spazio per memorizzare nel buffer i dati per un invio di rete.

Nota

È necessario assicurarsi che le dimensioni non superino le dimensioni massime del pacchetto del provider di servizi sottostante. In caso affermativo, il datagramma non verrà inviato e Send genererà un'eccezione SocketException. Se si riceve un SocketExceptionoggetto , utilizzare la SocketException.ErrorCode proprietà per ottenere il codice di errore specifico. Dopo aver ottenuto questo codice, fare riferimento alla documentazione relativa al codice di errore dell'API Windows Sockets versione 2 per una descrizione dettagliata dell'errore.

Questo membro genera informazioni di traccia quando viene abilitata la funzionalità di traccia di rete nell'applicazione in uso. Per altre informazioni, vedere Traccia di rete in .NET Framework.

Importante

Il completamento corretto di un invio non indica che i dati sono stati recapitati correttamente. Se non è disponibile spazio buffer all'interno del sistema di trasporto per contenere i dati da trasmettere, l'invio bloccherà a meno che il socket non sia stato inserito in modalità non di blocco.

Vedi anche

• Connect(EndPoint)
• SendTo(Byte[], Int32, Int32, SocketFlags, EndPoint)
• SocketFlags
• SetSocketOption(SocketOptionLevel, SocketOptionName, Int32)

Send(IList<ArraySegment<Byte>>)

Origine:

Socket.cs

Invia l'insieme di buffer dell'elenco a un Socket connesso.

public:
 int Send(System::Collections::Generic::IList<ArraySegment<System::Byte>> ^ buffers);

public int Send (System.Collections.Generic.IList<ArraySegment<byte>> buffers);

member this.Send : System.Collections.Generic.IList<ArraySegment<byte>> -> int

Public Function Send (buffers As IList(Of ArraySegment(Of Byte))) As Integer

Parametri

buffers

IList<ArraySegment<Byte>>

Elenco di oggetti ArraySegment<T> di tipo Byte in cui sono contenuti i dati da inviare.

Restituisce

Int32

Numero di byte inviati a Socket.

Eccezioni

ArgumentNullException

buffers è null.

ArgumentException

buffers è vuoto.

SocketException

Si è verificato un errore durante il tentativo di accesso al socket. Vedere la sezione Osservazioni riportata di seguito.

ObjectDisposedException

L'oggetto Socket è stato chiuso.

Commenti

Send può essere usato sia per i protocolli orientati alla connessione che per i protocolli senza connessione.

Questo overload richiede almeno un buffer contenente i dati da inviare.

Se si usa un protocollo senza connessione, è necessario chiamare prima di chiamare Connect questo metodo o Send generare un'eccezione SocketException. Se si usa un protocollo orientato alla connessione, è necessario usare Connect per stabilire una connessione host remota o usare Accept per accettare una connessione in ingresso.

Se si usa un protocollo senza connessione e si prevede di inviare dati a più host diversi, è consigliabile usare il SendTo metodo . Se non si usa il SendTo metodo , sarà necessario chiamare Connect prima di ogni chiamata a Send. È possibile usare SendTo anche dopo aver stabilito un host remoto predefinito con Connect. È anche possibile modificare l'host remoto predefinito prima di chiamare Send effettuando un'altra chiamata a Connect.

Se si usa un protocollo orientato alla connessione, Send verrà bloccato fino a quando non vengono inviati tutti i byte nel buffer, a meno che non sia stato impostato un timeout tramite Socket.SendTimeout. Se il valore di timeout è stato superato, la Send chiamata genererà un oggetto SocketException. In modalità non di blocco, Send può essere completato correttamente anche se invia meno del numero di byte nel buffer. È responsabilità dell'applicazione tenere traccia del numero di byte inviati e ripetere l'operazione fino a quando l'applicazione non invia i byte nel buffer. Non esiste inoltre alcuna garanzia che i dati inviati vengano visualizzati immediatamente nella rete. Per aumentare l'efficienza della rete, il sistema sottostante può ritardare la trasmissione fino a quando non viene raccolta una quantità significativa di dati in uscita. Un completamento corretto del Send metodo indica che il sistema sottostante ha avuto spazio per memorizzare nel buffer i dati per un invio di rete.

Nota

Se si riceve un SocketExceptionoggetto , utilizzare la SocketException.ErrorCode proprietà per ottenere il codice di errore specifico. Dopo aver ottenuto questo codice, fare riferimento alla documentazione relativa al codice di errore dell'API Windows Sockets versione 2 per una descrizione dettagliata dell'errore.

Nota

Il completamento corretto di un invio non indica che i dati sono stati recapitati correttamente. Se non è disponibile spazio buffer all'interno del sistema di trasporto per contenere i dati da trasmettere, l'invio bloccherà a meno che il socket non sia stato inserito in modalità non di blocco.

Nota

Questo membro genera informazioni di traccia quando viene abilitata la funzionalità di traccia di rete nell'applicazione in uso. Per altre informazioni, vedere Traccia di rete in .NET Framework.

Send(IList<ArraySegment<Byte>>, SocketFlags)

Origine:

Socket.cs

Invia l'insieme di buffer dell'elenco a un Socket connesso utilizzando i SocketFlags specificati.

public:
 int Send(System::Collections::Generic::IList<ArraySegment<System::Byte>> ^ buffers, System::Net::Sockets::SocketFlags socketFlags);

public int Send (System.Collections.Generic.IList<ArraySegment<byte>> buffers, System.Net.Sockets.SocketFlags socketFlags);

member this.Send : System.Collections.Generic.IList<ArraySegment<byte>> * System.Net.Sockets.SocketFlags -> int

Public Function Send (buffers As IList(Of ArraySegment(Of Byte)), socketFlags As SocketFlags) As Integer

Parametri

buffers

IList<ArraySegment<Byte>>

Elenco di oggetti ArraySegment<T> di tipo Byte in cui sono contenuti i dati da inviare.

socketFlags

SocketFlags

Combinazione bit per bit dei valori di SocketFlags.

Restituisce

Int32

Numero di byte inviati a Socket.

Eccezioni

ArgumentNullException

buffers è null.

ArgumentException

buffers è vuoto.

SocketException

Si è verificato un errore durante il tentativo di accesso al socket.

ObjectDisposedException

L'oggetto Socket è stato chiuso.

Commenti

Questo overload richiede almeno un buffer contenente i dati da inviare. Il SocketFlags valore predefinito è 0. Se si specifica il DontRoute flag come socketFlags parametro, i dati inviati non verranno instradati.

Se si usa un protocollo senza connessione, è necessario chiamare prima di chiamare Connect questo metodo o Send generare un'eccezione SocketException. Se si usa un protocollo orientato alla connessione, è necessario usare Connect per stabilire una connessione host remota o usare Accept per accettare una connessione in ingresso.

Se si usa un protocollo senza connessione e si prevede di inviare dati a più host diversi, è consigliabile usare il SendTo metodo . Se non si usa il SendTo metodo , sarà necessario chiamare Connect prima di ogni chiamata a Send. È possibile usare SendTo anche dopo aver stabilito un host remoto predefinito con Connect. È anche possibile modificare l'host remoto predefinito prima di chiamare Send effettuando un'altra chiamata a Connect.

Se si usa un protocollo orientato alla connessione, verrà bloccato finché non vengono inviati tutti i byte nel buffer, Send a meno che non sia stato impostato un timeout usando Socket.SendTimeout. Se il valore di timeout è stato superato, la Send chiamata genererà un SocketExceptionoggetto . In modalità non di blocco, Send può essere completato correttamente anche se invia meno del numero di byte nel buffer. È responsabilità dell'applicazione tenere traccia del numero di byte inviati e riprovare l'operazione fino a quando l'applicazione invia i byte nel buffer. Non vi è anche alcuna garanzia che i dati inviati verranno visualizzati immediatamente nella rete. Per aumentare l'efficienza della rete, il sistema sottostante può ritardare la trasmissione fino a quando non viene raccolta una quantità significativa di dati in uscita. Un completamento riuscito del Send metodo significa che il sistema sottostante ha avuto spazio per bufferre i dati per un invio di rete.

Nota

Se si riceve un SocketExceptionoggetto , utilizzare la proprietà per ottenere il SocketException.ErrorCode codice di errore specifico. Dopo aver ottenuto questo codice, vedere la documentazione del codice di errore dell'API Windows Sockets versione 2 per una descrizione dettagliata dell'errore.

Nota

Il completamento riuscito di un invio non indica che i dati sono stati recapitati correttamente. Se non è disponibile spazio buffer all'interno del sistema di trasporto per contenere i dati da trasmettere, l'invio bloccherà a meno che il socket non sia stato inserito in modalità non di blocco.

Nota

Questo membro genera informazioni di traccia quando viene abilitata la funzionalità di traccia di rete nell'applicazione in uso. Per altre informazioni, vedere Traccia di rete in .NET Framework.

Send(Byte[], SocketFlags)

Origine:

Socket.cs

Invia dati a un oggetto Socket connesso utilizzando l'oggetto SocketFlags specificato.

public:
 int Send(cli::array <System::Byte> ^ buffer, System::Net::Sockets::SocketFlags socketFlags);

public int Send (byte[] buffer, System.Net.Sockets.SocketFlags socketFlags);

member this.Send : byte[] * System.Net.Sockets.SocketFlags -> int

Public Function Send (buffer As Byte(), socketFlags As SocketFlags) As Integer

Parametri

buffer

Byte[]

Matrice di Byte che contiene i dati da inviare.

socketFlags

SocketFlags

Combinazione bit per bit dei valori di SocketFlags.

Restituisce

Int32

Numero di byte inviati a Socket.

Eccezioni

ArgumentNullException

buffer è null.

SocketException

Si è verificato un errore durante il tentativo di accesso al socket.

ObjectDisposedException

L'oggetto Socket è stato chiuso.

Esempio

Nell'esempio di codice seguente viene illustrato l'invio di dati in un oggetto connesso Socket.

// Displays sending with a connected socket
// using the overload that takes a buffer and socket flags.
int SendReceiveTest2( Socket^ server )
{
   array<Byte>^ msg = Encoding::UTF8->GetBytes( "This is a test" );
   array<Byte>^ bytes = gcnew array<Byte>(256);
   try
   {
      // Blocks until send returns.
      int byteCount = server->Send( msg, SocketFlags::None );
      Console::WriteLine( "Sent {0} bytes.", byteCount.ToString() );
      
      // Get reply from the server.
      byteCount = server->Receive( bytes, SocketFlags::None );
      if ( byteCount > 0 )
      {
         Console::WriteLine( Encoding::UTF8->GetString( bytes ) );
      }
   }
   catch ( SocketException^ e ) 
   {
      Console::WriteLine( "{0} Error code: {1}.", e->Message, e->ErrorCode.ToString() );
      return (e->ErrorCode);
   }
   return 0;
}

// Displays sending with a connected socket
// using the overload that takes a buffer and socket flags.
public static int SendReceiveTest2(Socket server)
{
    byte[] msg = Encoding.UTF8.GetBytes("This is a test");
    byte[] bytes = new byte[256];
    try
    {
        // Blocks until send returns.
        int byteCount = server.Send(msg, SocketFlags.None);
        Console.WriteLine("Sent {0} bytes.", byteCount);

        // Get reply from the server.
        byteCount = server.Receive(bytes, SocketFlags.None);
        if (byteCount > 0)
            Console.WriteLine(Encoding.UTF8.GetString(bytes));
    }
    catch (SocketException e)
    {
        Console.WriteLine("{0} Error code: {1}.", e.Message, e.ErrorCode);
        return (e.ErrorCode);
    }
    return 0;
}

' Displays sending with a connected socket
' using the overload that takes a buffer and socket flags.
Public Shared Function SendReceiveTest2(ByVal server As Socket) As Integer 
    Dim msg As Byte() = Encoding.UTF8.GetBytes("This is a test")
    Dim bytes(255) As Byte
    Try
        ' Blocks until send returns.
        Dim byteCount As Integer = server.Send(msg, SocketFlags.None)
        Console.WriteLine("Sent {0} bytes.", byteCount)
        
        ' Get reply from the server.
        byteCount = server.Receive(bytes, SocketFlags.None)
        If byteCount > 0 Then
            Console.WriteLine(Encoding.UTF8.GetString(bytes))
        End If
    Catch e As SocketException
        Console.WriteLine("{0} Error code: {1}.", e.Message, e.ErrorCode)
        Return e.ErrorCode
    End Try
    Return 0

End Function 'SendReceiveTest2

Commenti

Send invia in modo sincrono i dati all'host remoto stabilito nel Connect metodo o Accept e restituisce il numero di byte inviati correttamente. Il Send metodo può essere usato per protocolli sia orientati alla connessione che senza connessione.

Questo overload richiede un buffer che contiene i dati che si desidera inviare e una combinazione bit per bit di SocketFlags. L'offset del buffer viene impostato su 0 e il numero di byte da inviare per impostazione predefinita alle dimensioni del buffer. Se si specifica il flag come valore del DontRoutesocketflags parametro, i dati inviati non verranno indirizzati.

Se si usa un protocollo senza connessione, è necessario chiamare Connect prima di chiamare questo metodo oppure Send generare un SocketExceptionoggetto . Se si usa un protocollo orientato alla connessione, è necessario usare Connect per stabilire una connessione host remota o usare Accept per accettare una connessione in ingresso.

Se si usa un protocollo senza connessione e si prevede di inviare dati a diversi host, è consigliabile usare il SendTo metodo . Se non si usa il metodo, è necessario chiamare il SendToConnect metodo prima di ogni chiamata a Send. È possibile usare SendTo anche dopo aver stabilito un host remoto predefinito con Connect. È anche possibile modificare l'host remoto predefinito prima di chiamare Send eseguendo un'altra chiamata a Connect.

Se si usa un protocollo orientato alla connessione, verrà bloccato finché non vengono inviati tutti i byte nel buffer, Send a meno che non sia stato impostato un timeout usando Socket.SendTimeout. Se il valore di timeout è stato superato, la Send chiamata genererà un SocketExceptionoggetto . In modalità non sbloccante, Send può essere completato correttamente anche se invia meno del numero di byte nel buffer. È responsabilità dell'applicazione tenere traccia del numero di byte inviati e riprovare l'operazione fino a quando l'applicazione invia il numero richiesto di byte. Non vi è anche alcuna garanzia che i dati inviati verranno visualizzati immediatamente nella rete. Per aumentare l'efficienza della rete, il sistema sottostante può ritardare la trasmissione fino a quando non viene raccolta una quantità significativa di dati in uscita. Un completamento riuscito del Send metodo significa che il sistema sottostante ha avuto spazio per bufferre i dati per un invio di rete.

Nota

È necessario assicurarsi che le dimensioni del buffer non superino le dimensioni massime del provider di servizi sottostanti. In caso contrario, il datagram non verrà inviato e Send genererà un SocketExceptionoggetto . Se si riceve un SocketExceptionoggetto , utilizzare la proprietà per ottenere il SocketException.ErrorCode codice di errore specifico. Dopo aver ottenuto questo codice, vedere la documentazione del codice di errore dell'API Windows Sockets versione 2 per una descrizione dettagliata dell'errore.

Nota

Il completamento riuscito di un invio non indica che i dati sono stati recapitati correttamente. Se non è disponibile spazio buffer all'interno del sistema di trasporto per contenere i dati da trasmettere, l'invio bloccherà a meno che il socket non sia stato inserito in modalità non di blocco.

Nota

Questo membro genera informazioni di traccia quando viene abilitata la funzionalità di traccia di rete nell'applicazione in uso. Per altre informazioni, vedere Traccia di rete in .NET Framework.

Vedi anche

• Connect(EndPoint)
• SendTo(Byte[], Int32, Int32, SocketFlags, EndPoint)
• SocketFlags
• SetSocketOption(SocketOptionLevel, SocketOptionName, Int32)

Send(ReadOnlySpan<Byte>, SocketFlags)

Origine:

Socket.cs

Invia dati a un oggetto Socket connesso utilizzando l'oggetto SocketFlags specificato.

public:
 int Send(ReadOnlySpan<System::Byte> buffer, System::Net::Sockets::SocketFlags socketFlags);

public int Send (ReadOnlySpan<byte> buffer, System.Net.Sockets.SocketFlags socketFlags);

member this.Send : ReadOnlySpan<byte> * System.Net.Sockets.SocketFlags -> int

Public Function Send (buffer As ReadOnlySpan(Of Byte), socketFlags As SocketFlags) As Integer

Parametri

buffer

ReadOnlySpan<Byte>

Intervallo di byte che contiene i dati da inviare.

socketFlags

SocketFlags

Combinazione bit per bit dei valori di enumerazione che specifica i comportamenti di invio e ricezione.

Restituisce

Int32

Numero di byte inviati a Socket.

Eccezioni

SocketException

Si è verificato un errore durante il tentativo di accesso al socket.

ObjectDisposedException

L'oggetto Socket è stato chiuso.

Vedi anche

• Connect(EndPoint)
• SendTo(Byte[], Int32, Int32, SocketFlags, EndPoint)
• SocketFlags
• SetSocketOption(SocketOptionLevel, SocketOptionName, Int32)

Send(Byte[])

Origine:

Socket.cs

Invia dati a un Socket connesso.

public:
 int Send(cli::array <System::Byte> ^ buffer);

public int Send (byte[] buffer);

member this.Send : byte[] -> int

Public Function Send (buffer As Byte()) As Integer

Parametri

buffer

Byte[]

Matrice di Byte che contiene i dati da inviare.

Restituisce

Int32

Numero di byte inviati a Socket.

Eccezioni

ArgumentNullException

buffer è null.

SocketException

Si è verificato un errore durante il tentativo di accesso al socket.

ObjectDisposedException

L'oggetto Socket è stato chiuso.

Esempio

Nell'esempio di codice seguente viene illustrato l'invio di dati in un oggetto connesso Socket.

// Displays sending with a connected socket
// using the overload that takes a buffer.
int SendReceiveTest1( Socket^ server )
{
   array<Byte>^ msg = Encoding::UTF8->GetBytes( "This is a test" );
   array<Byte>^ bytes = gcnew array<Byte>(256);
   try
   {
      // Blocks until send returns.
      int byteCount = server->Send( msg );
      Console::WriteLine( "Sent {0} bytes.", byteCount.ToString() );
      
      // Get reply from the server.
      byteCount = server->Receive( bytes );
      if ( byteCount > 0 )
      {
         Console::WriteLine( Encoding::UTF8->GetString( bytes ) );
      }
   }
   catch ( SocketException^ e ) 
   {
      Console::WriteLine( "{0} Error code: {1}.", e->Message, e->ErrorCode.ToString() );
      return ( e->ErrorCode );
   }
   return 0;
}

// Displays sending with a connected socket
// using the overload that takes a buffer.
public static int SendReceiveTest1(Socket server)
{
    byte[] msg = Encoding.UTF8.GetBytes("This is a test");
    byte[] bytes = new byte[256];
    try
    {
        // Blocks until send returns.
        int i = server.Send(msg);
        Console.WriteLine("Sent {0} bytes.", i);

        // Get reply from the server.
        i = server.Receive(bytes);
        Console.WriteLine(Encoding.UTF8.GetString(bytes));
    }
    catch (SocketException e)
    {
        Console.WriteLine("{0} Error code: {1}.", e.Message, e.ErrorCode);
        return (e.ErrorCode);
    }
    return 0;
}

' Displays sending with a connected socket
' using the overload that takes a buffer.
Public Shared Function SendReceiveTest1(ByVal server As Socket) As Integer 
    Dim msg As Byte() = Encoding.UTF8.GetBytes("This is a test")
    Dim bytes(255) As Byte
    Try
        ' Blocks until send returns.
        Dim i As Integer = server.Send(msg)
        Console.WriteLine("Sent {0} bytes.", i)
        
        ' Get reply from the server.
        i = server.Receive(bytes)
        Console.WriteLine(Encoding.UTF8.GetString(bytes))
    Catch e As SocketException
        Console.WriteLine("{0} Error code: {1}.", e.Message, e.ErrorCode)
        Return e.ErrorCode
    End Try
    Return 0

End Function 'SendReceiveTest1

Commenti

Send invia in modo sincrono i dati all'host remoto specificato nel Connect metodo o Accept e restituisce il numero di byte inviati correttamente. Send può essere usato sia per i protocolli orientati alla connessione che per i protocolli senza connessione.

Questo overload richiede un buffer che contiene i dati da inviare. Il SocketFlags valore predefinito è 0, l'offset del buffer viene predefinito su 0 e il numero di byte da inviare per impostazione predefinita alle dimensioni del buffer.

Se si usa un protocollo senza connessione, è necessario chiamare Connect prima di chiamare questo metodo oppure Send generare un SocketExceptionoggetto . Se si usa un protocollo orientato alla connessione, è necessario usare Connect per stabilire una connessione host remota o usare Accept per accettare una connessione in ingresso.

Se si usa un protocollo senza connessione e si prevede di inviare dati a diversi host, è consigliabile usare il SendTo metodo . Se non si usa il SendTo metodo, è necessario chiamare Connect prima di ogni chiamata a Send. È possibile usare SendTo anche dopo aver stabilito un host remoto predefinito con Connect. È anche possibile modificare l'host remoto predefinito prima di chiamare Send eseguendo un'altra chiamata a Connect.

Se si usa un protocollo orientato alla connessione, verrà bloccato finché non vengono inviati tutti i byte nel buffer, Send a meno che non sia stato impostato un timeout usando Socket.SendTimeout. Se il valore di timeout è stato superato, la Send chiamata genererà un SocketExceptionoggetto . In modalità non sbloccante, Send può essere completato correttamente anche se invia meno del numero di byte nel buffer. È responsabilità dell'applicazione tenere traccia del numero di byte inviati e riprovare l'operazione fino a quando l'applicazione invia i byte nel buffer. Non vi è anche alcuna garanzia che i dati inviati verranno visualizzati immediatamente nella rete. Per aumentare l'efficienza della rete, il sistema sottostante può ritardare la trasmissione fino a quando non viene raccolta una quantità significativa di dati in uscita. Un completamento riuscito del Send metodo significa che il sistema sottostante ha avuto spazio per bufferre i dati per un invio di rete.

Nota

Se si riceve un SocketExceptionoggetto , utilizzare la proprietà per ottenere il SocketException.ErrorCode codice di errore specifico. Dopo aver ottenuto questo codice, vedere la documentazione del codice di errore dell'API Windows Sockets versione 2 per una descrizione dettagliata dell'errore.

Nota

Il completamento riuscito di un invio non indica che i dati sono stati recapitati correttamente. Se non è disponibile spazio buffer all'interno del sistema di trasporto per contenere i dati da trasmettere, l'invio bloccherà a meno che il socket non sia stato inserito in modalità non di blocco.

Nota

Questo membro genera informazioni di traccia quando viene abilitata la funzionalità di traccia di rete nell'applicazione in uso. Per altre informazioni, vedere Traccia di rete in .NET Framework.

Vedi anche

• Connect(EndPoint)
• SendTo(Byte[], Int32, Int32, SocketFlags, EndPoint)
• SocketFlags
• SetSocketOption(SocketOptionLevel, SocketOptionName, Int32)