Socket.Send Metod

Källa:

Socket.cs

Källa:

Socket.cs

Källa:

Socket.cs

Källa:

Socket.cs

Källa:

Socket.cs

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

Parametrar

Returer

Antalet byte som skickas till Socket.

Undantag

Kommentarer

Send skickar synkront data till fjärrvärden som anges i Connect metoden eller Accept och returnerar antalet byte som har skickats. Send kan användas för både anslutningsorienterade och anslutningslösa protokoll.

Den här överlagringen kräver en buffert som innehåller de data som du vill skicka. Värdet SocketFlags är som standard 0, buffertförskjutningen är som standard 0 och antalet byte som ska skickas som standard till buffertens storlek.

Om du använder ett anslutningslöst protokoll måste du anropa Connect innan du anropar den här metoden, eller Send utlösa ett SocketException. Om du använder ett anslutningsorienterat protokoll måste du antingen använda Connect för att upprätta en fjärrvärdanslutning eller använda Accept för att acceptera en inkommande anslutning.

Om du använder ett anslutningslöst protokoll och planerar att skicka data till flera olika värdar bör du använda SendTo metoden. Om du inte använder SendTo metoden måste du anropa Connect före varje anrop till Send. Du kan använda SendTo även när du har upprättat en standardvärd med Connect. Du kan också ändra standardvärden för fjärrvärden innan du anropar Send genom att göra ett annat anrop till Connect.

Om du använder ett anslutningsorienterat protokoll Send blockeras tills alla byte i bufferten skickas, såvida inte en timeout har angetts med hjälp Socket.SendTimeoutav . Om tidsgränsvärdet överskreds utlöser anropet Send ett SocketException. I icke-blockeringsläge Send kan slutföras även om det skickar mindre än antalet byte i bufferten. Det är programmets ansvar att hålla reda på antalet skickade byte och att försöka utföra åtgärden igen tills programmet skickar byte i bufferten. Det finns heller ingen garanti för att de data som du skickar visas i nätverket omedelbart. För att öka nätverkseffektiviteten kan det underliggande systemet fördröja överföringen tills en betydande mängd utgående data samlas in. Ett lyckat slutförande av Send metoden innebär att det underliggande systemet har haft utrymme för att buffera dina data för en nätverkssändning.

Den här medlemmen matar ut spårningsinformation när du aktiverar nätverksspårning i ditt program. Mer information finns i Network Tracing in .NET Framework.

Se även

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

Källa:

Socket.cs

Källa:

Socket.cs

Källa:

Socket.cs

Källa:

Socket.cs

Källa:

Socket.cs

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

Parametrar

Returer

Antalet byte som skickas till Socket.

Undantag

Kommentarer

Send skickar synkront data till fjärrvärden som anges i Connect metoden eller Accept och returnerar antalet byte som har skickats. Send kan användas för både anslutningsorienterade och anslutningslösa protokoll.

Den här överlagringen kräver en buffert som innehåller de data som du vill skicka. Värdet SocketFlags är som standard 0, buffertförskjutningen är som standard 0 och antalet byte som ska skickas som standard till buffertens storlek.

Om du använder ett anslutningslöst protokoll måste du anropa Connect innan du anropar den här metoden, eller Send utlösa ett SocketException. Om du använder ett anslutningsorienterat protokoll måste du antingen använda Connect för att upprätta en fjärrvärdanslutning eller använda Accept för att acceptera en inkommande anslutning.

Om du använder ett anslutningslöst protokoll och planerar att skicka data till flera olika värdar bör du använda SendTo metoden. Om du inte använder SendTo metoden måste du anropa Connect före varje anrop till Send. Du kan använda SendTo även när du har upprättat en standardvärd med Connect. Du kan också ändra standardvärden för fjärrvärden innan du anropar Send genom att göra ett annat anrop till Connect.

Om du använder ett anslutningsorienterat protokoll Send blockeras tills alla byte i bufferten skickas, såvida inte en timeout har angetts med hjälp Socket.SendTimeoutav . Om tidsgränsvärdet överskreds utlöser anropet Send ett SocketException. I icke-blockeringsläge Send kan slutföras även om det skickar mindre än antalet byte i bufferten. Det är programmets ansvar att hålla reda på antalet skickade byte och att försöka utföra åtgärden igen tills programmet skickar byte i bufferten. Det finns heller ingen garanti för att de data som du skickar visas i nätverket omedelbart. För att öka nätverkseffektiviteten kan det underliggande systemet fördröja överföringen tills en betydande mängd utgående data samlas in. Ett lyckat slutförande av Send metoden innebär att det underliggande systemet har haft utrymme för att buffera dina data för en nätverkssändning.

Den här medlemmen matar ut spårningsinformation när du aktiverar nätverksspårning i ditt program. Mer information finns i Network Tracing in .NET Framework.

Se även

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

Källa:

Socket.cs

Källa:

Socket.cs

Källa:

Socket.cs

Källa:

Socket.cs

Källa:

Socket.cs

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

Parametrar

Returer

Antalet byte som skickas till Socket.

Undantag

Exempel

I följande kodexempel anges databufferten, en förskjutning, en storlek och SocketFlags för att skicka data till en ansluten Socket.

// 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

Kommentarer

Send skickar synkront data till fjärrvärden som anges i Connect metoden eller Accept och returnerar antalet byte som har skickats. Send kan användas för både anslutningsorienterade och anslutningslösa protokoll.

I den här överlagringen DontRoute dirigeras inte de data som du skickar om du anger flaggan som socketflags parameter.

Om du använder ett anslutningslöst protokoll måste du anropa Connect innan du anropar den här metoden eller Send genererar en SocketException. Om du använder ett anslutningsorienterat protokoll måste du antingen använda Connect för att upprätta en fjärrvärdanslutning eller använda Accept för att acceptera en inkommande anslutning.

Om du använder ett anslutningslöst protokoll och planerar att skicka data till flera olika värdar bör du använda SendTo. Om du inte använder SendTomåste du anropa Connect före varje anrop till Send. Det är okej att använda SendTo även när du har upprättat en standardvärd med Connect. Du kan också ändra standardvärden innan du anropar Send genom att göra ett annat anrop till Connect.

Du måste också vara säker på att storleken inte överskrider den maximala paketstorleken för den underliggande tjänstleverantören. Om det gör det skickas inte datagrammet och Send genererar en SocketException.

Om du använder ett anslutningsorienterat protokoll Send blockeras tills det begärda antalet byte skickas, såvida inte en timeout har angetts med hjälp Socket.SendTimeoutav . Om tidsgränsvärdet överskreds utlöser anropet Send ett SocketException. I icke-blockeringsläge Send kan slutföras även om det skickar mindre än det antal byte som du begär. Det är programmets ansvar att hålla reda på antalet skickade byte och att försöka utföra åtgärden igen tills programmet skickar det begärda antalet byte. Det finns inte heller någon garanti för att de data du skickar kommer att visas i nätverket omedelbart. För att öka nätverkseffektiviteten kan det underliggande systemet fördröja överföringen tills en betydande mängd utgående data samlas in. Ett lyckat slutförande av Send metoden innebär att det underliggande systemet har haft utrymme för att buffera dina data för en nätverkssändning.

Se även

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

Källa:

Socket.cs

Källa:

Socket.cs

Källa:

Socket.cs

Källa:

Socket.cs

Källa:

Socket.cs

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

Parametrar

Returer

Antalet byte som skickas till Socket.

Undantag

Kommentarer

Den här överlagringen kräver minst en buffert som innehåller de data som du vill skicka. Värdet SocketFlags är som standard 0. Om du anger DontRoute flaggan som socketFlags parameter dirigeras inte de data som du skickar.

Om du använder ett anslutningslöst protokoll måste du anropa Connect innan du anropar den här metoden eller Send utlösa ett SocketException. Om du använder ett anslutningsorienterat protokoll måste du antingen använda Connect för att upprätta en fjärrvärdanslutning eller använda Accept för att acceptera en inkommande anslutning.

Om du använder ett anslutningslöst protokoll och planerar att skicka data till flera olika värdar bör du använda SendTo metoden. Om du inte använder SendTo metoden måste du anropa Connect före varje anrop till Send. Du kan använda SendTo även när du har upprättat en standardvärd med Connect. Du kan också ändra standardvärden innan du anropar Send genom att göra ett annat anrop till Connect.

Om du använder ett anslutningsorienterat protokoll Send blockeras tills alla byte i bufferten skickas, såvida inte en timeout har angetts med hjälp Socket.SendTimeoutav . Om tidsgränsvärdet överskreds utlöser anropet Send ett SocketException. I icke-blockerande läge Send kan slutföras även om det skickar mindre än antalet byte i bufferten. Det är programmets ansvar att hålla reda på antalet skickade byte och att försöka utföra åtgärden igen tills programmet skickar byte i bufferten. Det finns inte heller någon garanti för att de data du skickar kommer att visas i nätverket omedelbart. För att öka nätverkseffektiviteten kan det underliggande systemet fördröja överföringen tills en betydande mängd utgående data samlas in. Ett lyckat slutförande av Send metoden innebär att det underliggande systemet har haft utrymme för att buffera dina data för en nätverkssändning.

Källa:

Socket.cs

Källa:

Socket.cs

Källa:

Socket.cs

Källa:

Socket.cs

Källa:

Socket.cs

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

Parametrar

Returer

Antalet byte som skickas till Socket.

Undantag

Exempel

I följande kodexempel anges databufferten, en förskjutning, en storlek och SocketFlags för att skicka data till en ansluten Socket.

// 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

Kommentarer

Send skickar synkront data till fjärrvärden som anges i Connect metoden eller Accept och returnerar antalet byte som har skickats. Send kan användas för både anslutningsorienterade och anslutningslösa protokoll.

I den här överlagringen DontRoute dirigeras inte de data som du skickar om du anger flaggan som socketflags parameter.

Om du använder ett anslutningslöst protokoll måste du anropa Connect innan du anropar den här metoden eller Send genererar en SocketException. Om du använder ett anslutningsorienterat protokoll måste du antingen använda Connect för att upprätta en fjärrvärdanslutning eller använda Accept för att acceptera en inkommande anslutning.

Om du använder ett anslutningslöst protokoll och planerar att skicka data till flera olika värdar bör du använda SendTo. Om du inte använder SendTomåste du anropa Connect före varje anrop till Send. Det är okej att använda SendTo även när du har upprättat en standardvärd med Connect. Du kan också ändra standardvärden innan du anropar Send genom att göra ett annat anrop till Connect.

Du måste också vara säker på att storleken inte överskrider den maximala paketstorleken för den underliggande tjänstleverantören. Om det gör det skickas inte datagrammet och Send genererar en SocketException.

Om du använder ett anslutningsorienterat protokoll Send blockeras tills det begärda antalet byte skickas, såvida inte en timeout har angetts med hjälp Socket.SendTimeoutav . Om tidsgränsvärdet överskreds utlöser anropet Send ett SocketException. I icke-blockeringsläge Send kan slutföras även om det skickar mindre än det antal byte som du begär. Det är programmets ansvar att hålla reda på antalet skickade byte och att försöka utföra åtgärden igen tills programmet skickar det begärda antalet byte. Det finns inte heller någon garanti för att de data du skickar kommer att visas i nätverket omedelbart. För att öka nätverkseffektiviteten kan det underliggande systemet fördröja överföringen tills en betydande mängd utgående data samlas in. Ett lyckat slutförande av Send metoden innebär att det underliggande systemet har haft utrymme för att buffera dina data för en nätverkssändning.

Se även

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

Källa:

Socket.cs

Källa:

Socket.cs

Källa:

Socket.cs

Källa:

Socket.cs

Källa:

Socket.cs

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

Parametrar

Returer

Antalet byte som skickas till Socket.

Undantag

Exempel

Följande kodexempel skickar data som finns i bufferten och anger None för SocketFlags.

// 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

Kommentarer

Send skickar synkront data till fjärrvärden som upprättats i Connect metoden eller Accept och returnerar antalet byte som har skickats. Send kan användas för både anslutningsorienterade och anslutningslösa protokoll.

Den här överlagringen kräver en buffert som innehåller de data som du vill skicka, antalet byte som du vill skicka och en bitvis kombination av alla SocketFlags. Om du anger DontRoute flaggan som socketflags parameter dirigeras inte de data som du skickar.

Om du använder ett anslutningslöst protokoll måste du anropa Connect innan du anropar den här metoden, eller Send utlösa ett SocketException. Om du använder ett anslutningsorienterat protokoll måste du antingen använda Connect för att upprätta en fjärrvärdanslutning eller använda Accept för att acceptera en inkommande anslutning.

Om du använder ett anslutningslöst protokoll och planerar att skicka data till flera olika värdar bör du använda SendTo metoden. Om du inte använder SendTo metoden måste du anropa Connect metoden före varje anrop till Send metoden. Du kan använda SendTo även när du har upprättat en standardvärd med Connect. Du kan också ändra standardvärden för fjärrvärden innan du anropar Send genom att göra ett annat anrop till Connect.

Med ett anslutningsorienterat protokoll Send blockeras tills det begärda antalet byte skickas, såvida inte en timeout har angetts med hjälp Socket.SendTimeoutav . Om tidsgränsvärdet överskreds utlöser anropet Send ett SocketException. I icke-blockeringsläge Send kan slutföras även om det skickar mindre än det antal byte som du begär. Det är programmets ansvar att hålla reda på antalet skickade byte och att försöka utföra åtgärden igen tills programmet skickar det begärda antalet byte. Det finns inte heller någon garanti för att de data du skickar kommer att visas i nätverket omedelbart. För att öka nätverkseffektiviteten kan det underliggande systemet fördröja överföringen tills en betydande mängd utgående data samlas in. Ett lyckat slutförande av Send metoden innebär att det underliggande systemet har haft utrymme för att buffera dina data för en nätverkssändning.

Den här medlemmen matar ut spårningsinformation när du aktiverar nätverksspårning i ditt program. Mer information finns i Network Tracing in .NET Framework.

Se även

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

Källa:

Socket.cs

Källa:

Socket.cs

Källa:

Socket.cs

Källa:

Socket.cs

Källa:

Socket.cs

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

Parametrar

Returer

Antalet byte som skickas till Socket.

Undantag

Kommentarer

Send kan användas för både anslutningsorienterade och anslutningslösa protokoll.

Den här överlagringen kräver minst en buffert som innehåller de data som du vill skicka.

Om du använder ett anslutningslöst protokoll måste du anropa Connect innan du anropar den här metoden eller Send utlösa ett SocketException. Om du använder ett anslutningsorienterat protokoll måste du antingen använda Connect för att upprätta en fjärrvärdanslutning eller använda Accept för att acceptera en inkommande anslutning.

Om du använder ett anslutningslöst protokoll och planerar att skicka data till flera olika värdar bör du använda SendTo metoden. Om du inte använder SendTo metoden måste du anropa Connect före varje anrop till Send. Du kan använda SendTo även när du har upprättat en standardvärd med Connect. Du kan också ändra standardvärden innan du anropar Send genom att göra ett annat anrop till Connect.

Om du använder ett anslutningsorienterat protokoll Send blockeras tills alla byte i bufferten skickas, såvida inte en timeout har angetts med hjälp Socket.SendTimeoutav . Om tidsgränsvärdet överskreds utlöser anropet Send ett SocketException. I icke-blockeringsläge Send kan slutföras även om det skickar mindre än antalet byte i bufferten. Det är programmets ansvar att hålla reda på antalet skickade byte och att försöka utföra åtgärden igen tills programmet skickar byte i bufferten. Det finns inte heller någon garanti för att de data du skickar kommer att visas i nätverket omedelbart. För att öka nätverkseffektiviteten kan det underliggande systemet fördröja överföringen tills en betydande mängd utgående data samlas in. Ett lyckat slutförande av Send metoden innebär att det underliggande systemet har haft utrymme för att buffera dina data för en nätverkssändning.

Källa:

Socket.cs

Källa:

Socket.cs

Källa:

Socket.cs

Källa:

Socket.cs

Källa:

Socket.cs

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

Parametrar

Returer

Antalet byte som skickas till Socket.

Undantag

Kommentarer

Den här överlagringen kräver minst en buffert som innehåller de data som du vill skicka. Värdet SocketFlags är som standard 0. Om du anger DontRoute flaggan som socketFlags parameter dirigeras inte de data som du skickar.

Om du använder ett anslutningslöst protokoll måste du anropa Connect innan du anropar den här metoden eller Send utlösa ett SocketException. Om du använder ett anslutningsorienterat protokoll måste du antingen använda Connect för att upprätta en fjärrvärdanslutning eller använda Accept för att acceptera en inkommande anslutning.

Om du använder ett anslutningslöst protokoll och planerar att skicka data till flera olika värdar bör du använda SendTo metoden. Om du inte använder SendTo metoden måste du anropa Connect före varje anrop till Send. Du kan använda SendTo även när du har upprättat en standardvärd med Connect. Du kan också ändra standardvärden innan du anropar Send genom att göra ett annat anrop till Connect.

Om du använder ett anslutningsorienterat protokoll Send blockeras tills alla byte i bufferten skickas, såvida inte en timeout har angetts med hjälp Socket.SendTimeoutav . Om tidsgränsvärdet överskreds utlöser anropet Send ett SocketException. I icke-blockerande läge Send kan slutföras även om det skickar mindre än antalet byte i bufferten. Det är programmets ansvar att hålla reda på antalet skickade byte och att försöka utföra åtgärden igen tills programmet skickar byte i bufferten. Det finns inte heller någon garanti för att de data du skickar kommer att visas i nätverket omedelbart. För att öka nätverkseffektiviteten kan det underliggande systemet fördröja överföringen tills en betydande mängd utgående data samlas in. Ett lyckat slutförande av Send metoden innebär att det underliggande systemet har haft utrymme för att buffera dina data för en nätverkssändning.

Källa:

Socket.cs

Källa:

Socket.cs

Källa:

Socket.cs

Källa:

Socket.cs

Källa:

Socket.cs

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

Parametrar

Returer

Antalet byte som skickas till Socket.

Undantag

Exempel

I följande kodexempel visas hur du skickar data på en ansluten Socket.

// 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

Kommentarer

Send skickar synkront data till fjärrvärden som upprättats i Connect metoden eller Accept och returnerar antalet byte som har skickats. Metoden Send kan användas för både anslutningsorienterade och anslutningslösa protokoll.

Den här överlagringen kräver en buffert som innehåller de data som du vill skicka och en bitvis kombination av SocketFlags. Buffertförskjutningen är som standard 0 och antalet byte som ska skickas som standard till buffertens storlek. Om du anger DontRoute flaggan som socketflags parametervärde dirigeras inte de data som du skickar.

Om du använder ett anslutningslöst protokoll måste du anropa Connect innan du anropar den här metoden eller Send utlösa ett SocketException. Om du använder ett anslutningsorienterat protokoll måste du antingen använda Connect för att upprätta en fjärrvärdanslutning eller använda Accept för att acceptera en inkommande anslutning.

Om du använder ett anslutningslöst protokoll och planerar att skicka data till flera olika värdar bör du använda SendTo metoden. Om du inte använder SendTo metoden måste du anropa Connect metoden före varje anrop till Send. Du kan använda SendTo även när du har upprättat en standardvärd med Connect. Du kan också ändra standardvärden innan du anropar Send genom att göra ett annat anrop till Connect.

Om du använder ett anslutningsorienterat protokoll Send blockeras tills alla byte i bufferten skickas, såvida inte en timeout har angetts med hjälp Socket.SendTimeoutav . Om tidsgränsvärdet överskreds utlöser anropet Send ett SocketException. I icke-blockeringsläge Send kan slutföras även om det skickar mindre än antalet byte i bufferten. Det är programmets ansvar att hålla reda på antalet skickade byte och att försöka utföra åtgärden igen tills programmet skickar det begärda antalet byte. Det finns inte heller någon garanti för att de data du skickar kommer att visas i nätverket omedelbart. För att öka nätverkseffektiviteten kan det underliggande systemet fördröja överföringen tills en betydande mängd utgående data samlas in. Ett lyckat slutförande av Send metoden innebär att det underliggande systemet har haft utrymme för att buffera dina data för en nätverkssändning.

Se även

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

Källa:

Socket.cs

Källa:

Socket.cs

Källa:

Socket.cs

Källa:

Socket.cs

Källa:

Socket.cs

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

Parametrar

Returer

Antalet byte som skickas till Socket.

Undantag

Se även

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

Källa:

Socket.cs

Källa:

Socket.cs

Källa:

Socket.cs

Källa:

Socket.cs

Källa:

Socket.cs

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

Parametrar

Returer

Antalet byte som skickas till Socket.

Undantag

Exempel

I följande kodexempel visas hur du skickar data på en ansluten Socket.

// 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

Kommentarer

Send skickar synkront data till fjärrvärden som anges i Connect metoden eller Accept och returnerar antalet byte som har skickats. Send kan användas för både anslutningsorienterade och anslutningslösa protokoll.

Den här överlagringen kräver en buffert som innehåller de data som du vill skicka. Värdet SocketFlags är som standard 0, buffertförskjutningen är som standard 0 och antalet byte som ska skickas som standard till buffertens storlek.

Om du använder ett anslutningslöst protokoll måste du anropa Connect innan du anropar den här metoden eller Send utlösa ett SocketException. Om du använder ett anslutningsorienterat protokoll måste du antingen använda Connect för att upprätta en fjärrvärdanslutning eller använda Accept för att acceptera en inkommande anslutning.

Om du använder ett anslutningslöst protokoll och planerar att skicka data till flera olika värdar bör du använda SendTo metoden. Om du inte använder SendTo metoden måste du anropa Connect före varje anrop till Send. Du kan använda SendTo även när du har upprättat en standardvärd med Connect. Du kan också ändra standardvärden innan du anropar Send genom att göra ett annat anrop till Connect.

Om du använder ett anslutningsorienterat protokoll Send blockeras tills alla byte i bufferten skickas, såvida inte en timeout har angetts med hjälp Socket.SendTimeoutav . Om tidsgränsvärdet överskreds utlöser anropet Send ett SocketException. I icke-blockeringsläge Send kan slutföras även om det skickar mindre än antalet byte i bufferten. Det är programmets ansvar att hålla reda på antalet skickade byte och att försöka utföra åtgärden igen tills programmet skickar byte i bufferten. Det finns inte heller någon garanti för att de data du skickar kommer att visas i nätverket omedelbart. För att öka nätverkseffektiviteten kan det underliggande systemet fördröja överföringen tills en betydande mängd utgående data samlas in. Ett lyckat slutförande av Send metoden innebär att det underliggande systemet har haft utrymme för att buffera dina data för en nätverkssändning.

Se även

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