SocketAsyncEventArgs.SetBuffer Method (Byte[], Int32, Int32) (System.Net.Sockets)

SetBuffer Method (Byte[], Int32, In...

Collapse All

Language Filter

.NET Framework Class Library

SocketAsyncEventArgs..::.SetBuffer Method (array<Byte>[]()[], Int32, Int32)

Updated: November 2007

Sets the data buffer to use with an asynchronous socket method.

Namespace: System.Net.Sockets
Assembly: System (in System.dll)

Syntax

Visual Basic (Declaration)

Public Sub SetBuffer ( _
    buffer As Byte(), _
    offset As Integer, _
    count As Integer _
)

Visual Basic (Usage)

Dim instance As SocketAsyncEventArgs
Dim buffer As Byte()
Dim offset As Integer
Dim count As Integer

instance.SetBuffer(buffer, offset, count)

public void SetBuffer(
    byte[] buffer,
    int offset,
    int count
)

Visual C++

public:
void SetBuffer(
    array<unsigned char>^ buffer, 
    int offset, 
    int count
)

public void SetBuffer(
    byte[] buffer,
    int offset,
    int count
)

JScript

public function SetBuffer(
    buffer : byte[], 
    offset : int, 
    count : int
)

Parameters

buffer: Type: array<System..::.Byte>[]()[]
The data buffer to use with an asynchronous socket method.

offset: Type: System..::.Int32
The offset, in bytes, in the data buffer where the operation starts.

count: Type: System..::.Int32
The maximum amount of data, in bytes, to send or receive in the buffer.

Exceptions

Exception	Condition
ArgumentException	There are ambiguous buffers specified. This exception occurs if the Buffer property is also not null and the BufferList property is also not null.
ArgumentOutOfRangeException	An argument was out of range. This exception occurs if the offset parameter is less than zero or greater than the length of the array in the Buffer property. This exception also occurs if the count parameter is less than zero or greater than the length of the array in the Buffer property minus the offset parameter.

Remarks

The offset and count parameters can't be negative numbers. The combination of the offset and count parameters must be in bounds of the data array in the buffer parameter.

This method sets the Buffer property to the buffer parameter, the Count property to the count parameter, and the Offset property to the offset parameter.

Examples

The following code example creates a single large buffer which can be divided up and assigned to SocketAsyncEventArgs objects for use with each socket I/O operation. This enables buffers to be easily reused and guards against fragmenting heap memory.

// This class creates a single large buffer which can be divided up 
// and assigned to SocketAsyncEventArgs objects for use with each 
// socket I/O operation.  
// This enables bufffers to be easily reused and guards against 
// fragmenting heap memory.
// 
// The operations exposed on the BufferManager class are not thread safe.
class BufferManager
{
    int m_numBytes;                 // the total number of bytes controlled by the buffer pool
    byte[] m_buffer;                // the underlying byte array maintained by the Buffer Manager
    Stack<int> m_freeIndexPool;     // 
    int m_currentIndex;
    int m_bufferSize;

    public BufferManager(int totalBytes, int bufferSize)
    {
        m_numBytes = totalBytes;
        m_currentIndex = 0;
        m_bufferSize = bufferSize;
        m_freeIndexPool = new Stack<int>();
    }

    // Allocates buffer space used by the buffer pool
    public void InitBuffer()
    {
        // create one big large buffer and divide that 
        // out to each SocketAsyncEventArg object
        m_buffer = new byte[m_numBytes];
    }

    // Assigns a buffer from the buffer pool to the 
    // specified SocketAsyncEventArgs object
    //
    // <returns>true if the buffer was successfully set, else false</returns>
    public bool SetBuffer(SocketAsyncEventArgs args)
    {

        if (m_freeIndexPool.Count > 0)
        {
            args.SetBuffer(m_buffer, m_freeIndexPool.Pop(), m_bufferSize);
        }
        else
        {
            if ((m_numBytes - m_bufferSize) < m_currentIndex)
            {
                return false;
            }
            args.SetBuffer(m_buffer, m_currentIndex, m_bufferSize);
            m_currentIndex += m_bufferSize;
        }
        return true;
    }

    // Removes the buffer from a SocketAsyncEventArg object.  
    // This frees the buffer back to the buffer pool
    public void FreeBuffer(SocketAsyncEventArgs args)
    {
        m_freeIndexPool.Push(args.Offset);
        args.SetBuffer(null, 0, 0);
    }

}

Platforms

The .NET Framework and .NET Compact Framework do not support all versions of every platform. For a list of the supported versions, see .NET Framework System Requirements.

Version Information