Buffer.SetByte(Array, Int32, Byte) Method

Reference

Definition

Namespace:: System

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Source:: Buffer.cs

Source:: Buffer.cs

Source:: Buffer.cs

Important

Some information relates to prerelease product that may be substantially modified before it’s released. Microsoft makes no warranties, express or implied, with respect to the information provided here.

Assigns a specified value to a byte at a particular location in a specified array.

public:
 static void SetByte(Array ^ array, int index, System::Byte value);

public static void SetByte (Array array, int index, byte value);

static member SetByte : Array * int * byte -> unit

Public Shared Sub SetByte (array As Array, index As Integer, value As Byte)

Parameters

array: Array

An array.

index: Int32

A location in the array.

value: Byte

A value to assign.

Exceptions

ArgumentException

array is not a primitive.

ArgumentNullException

array is null.

ArgumentOutOfRangeException

index is negative or greater than the length of array.

OverflowException

array is larger than 2 gigabytes (GB).

Examples

The following code example assigns values to bytes at particular locations within arrays using the SetByte method.

// Example of the Buffer::SetByte method.
using namespace System;

// Display the array contents in hexadecimal.
void DisplayArray( Array^ arr, String^ name )
{
   
   // Get the array element width; format the formatting string.
   int elemWidth = Buffer::ByteLength( arr ) / arr->Length;
   String^ format = String::Format( " {{0:X{0}}}", 2 * elemWidth );
   
   // Display the array elements from right to left.
   Console::Write( "{0,7}:", name );
   for ( int loopX = arr->Length - 1; loopX >= 0; loopX-- )
      Console::Write( format, arr->GetValue( loopX ) );
   Console::WriteLine();
}

int main()
{
   
   // These are the arrays to be modified with SetByte.
   array<Int16>^shorts = gcnew array<Int16>(10);
   array<Int64>^longs = gcnew array<Int64>(3);
   Console::WriteLine( "This example of the "
   "Buffer::SetByte( Array*, int, unsigned char ) \n"
   "method generates the following output.\n"
   "Note: The arrays are displayed from right to left.\n" );
   Console::WriteLine( "  Initial values of arrays:\n" );
   
   // Display the initial values of the arrays.
   DisplayArray( shorts, "shorts" );
   DisplayArray( longs, "longs" );
   
   // Copy two regions of source array to destination array,
   // and two overlapped copies from source to source.
   Console::WriteLine( "\n  Array values after setting byte 3 = 25, \n"
   "  byte 6 = 64, byte 12 = 121, and byte 17 = 196:\n" );
   Buffer::SetByte( shorts, 3, 25 );
   Buffer::SetByte( shorts, 6, 64 );
   Buffer::SetByte( shorts, 12, 121 );
   Buffer::SetByte( shorts, 17, 196 );
   Buffer::SetByte( longs, 3, 25 );
   Buffer::SetByte( longs, 6, 64 );
   Buffer::SetByte( longs, 12, 121 );
   Buffer::SetByte( longs, 17, 196 );
   
   // Display the arrays again.
   DisplayArray( shorts, "shorts" );
   DisplayArray( longs, "longs" );
}

/*
This example of the Buffer::SetByte( Array*, int, unsigned char )
method generates the following output.
Note: The arrays are displayed from right to left.

  Initial values of arrays:

 shorts: 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000
  longs: 0000000000000000 0000000000000000 0000000000000000

  Array values after setting byte 3 = 25,
  byte 6 = 64, byte 12 = 121, and byte 17 = 196:

 shorts: 0000 C400 0000 0079 0000 0000 0040 0000 1900 0000
  longs: 000000000000C400 0000007900000000 0040000019000000
*/

// Example of the Buffer.SetByte method.
using System;

class SetByteDemo
{
    // Display the array contents in hexadecimal.
    public static void DisplayArray( Array arr, string name )
    {
        // Get the array element width; format the formatting string.
        int elemWidth = Buffer.ByteLength( arr ) / arr.Length;
        string format = String.Format( " {{0:X{0}}}", 2 * elemWidth );

        // Display the array elements from right to left.
        Console.Write( "{0,7}:", name );
        for( int loopX = arr.Length - 1; loopX >= 0; loopX-- )
            Console.Write( format, arr.GetValue( loopX ) );
        Console.WriteLine( );
    }

    public static void Main( )
    {
        // These are the arrays to be modified with SetByte.
        short[ ] shorts = new short[ 10 ];
        long[ ]  longs  = new long[ 3 ];

        Console.WriteLine( "This example of the " +
            "Buffer.SetByte( Array, int, byte ) \n" +
            "method generates the following output.\n" +
            "Note: The arrays are displayed from right to left.\n" );
        Console.WriteLine( "  Initial values of arrays:\n" );

        // Display the initial values of the arrays.
        DisplayArray( shorts, "shorts" );
        DisplayArray( longs, "longs" );

        // Copy two regions of source array to destination array,
        // and two overlapped copies from source to source.
        Console.WriteLine( "\n" +
            "  Array values after setting byte 3 = 25, \n" +
            "  byte 6 = 64, byte 12 = 121, and byte 17 = 196:\n" );

        Buffer.SetByte( shorts, 3, 25 );
        Buffer.SetByte( shorts, 6, 64 );
        Buffer.SetByte( shorts, 12, 121 );
        Buffer.SetByte( shorts, 17, 196 );
        Buffer.SetByte( longs, 3, 25 );
        Buffer.SetByte( longs, 6, 64 );
        Buffer.SetByte( longs, 12, 121 );
        Buffer.SetByte( longs, 17, 196 );

        // Display the arrays again.
        DisplayArray( shorts, "shorts" );
        DisplayArray( longs, "longs" );
    }
}

/*
This example of the Buffer.SetByte( Array, int, byte )
method generates the following output.
Note: The arrays are displayed from right to left.

  Initial values of arrays:

 shorts: 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000
  longs: 0000000000000000 0000000000000000 0000000000000000

  Array values after setting byte 3 = 25,
  byte 6 = 64, byte 12 = 121, and byte 17 = 196:

 shorts: 0000 C400 0000 0079 0000 0000 0040 0000 1900 0000
  longs: 000000000000C400 0000007900000000 0040000019000000
*/

open System

// Display the array contents in hexadecimal.
let inline displayArray (arr: ^a []) name =
    // Get the array element width; format the formatting string.
    let elemWidth = Buffer.ByteLength arr / arr.Length

    // Display the array elements from right to left.
    printf $"{name,5}:"
    for i = arr.Length - 1 downto 0 do
        printf " %0*X" (2 * elemWidth) arr[i]
    printfn ""

// These are the arrays to be modified with SetByte.
let shorts = Array.zeroCreate<int16> 10
let longs = Array.zeroCreate<int64> 3

printfn "This example of the Buffer.SetByte(Array, int, byte) \nmethod generates the following output.\nNote: The arrays are displayed from right to left.\n"
printfn "  Initial values of arrays:\n"

// Display the initial values of the arrays.
displayArray shorts "shorts"
displayArray longs "longs"

// Copy two regions of source array to destination array,
// and two overlapped copies from source to source.
printfn "\n  Array values after setting byte 3 = 25, \n  byte 6 = 64, byte 12 = 121, and byte 17 = 196:\n"

Buffer.SetByte(shorts, 3, 25uy)
Buffer.SetByte(shorts, 6, 64uy)
Buffer.SetByte(shorts, 12, 121uy)
Buffer.SetByte(shorts, 17, 196uy)
Buffer.SetByte(longs, 3, 25uy)
Buffer.SetByte(longs, 6, 64uy)
Buffer.SetByte(longs, 12, 121uy) 
Buffer.SetByte(longs, 17, 196uy)

// Display the arrays again.
displayArray shorts "shorts"
displayArray longs "longs"


// This example of the Buffer.SetByte( Array, int, byte )
// method generates the following output.
// Note: The arrays are displayed from right to left.
//
//   Initial values of arrays:
//
//  shorts: 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000
//   longs: 0000000000000000 0000000000000000 0000000000000000
//
//   Array values after setting byte 3 = 25,
//   byte 6 = 64, byte 12 = 121, and byte 17 = 196:
//
//  shorts: 0000 C400 0000 0079 0000 0000 0040 0000 1900 0000
//   longs: 000000000000C400 0000007900000000 0040000019000000

' Example of the Buffer.SetByte method.
Module SetByteDemo

    ' Display the array contents in hexadecimal.
    Sub DisplayArray( arr As Array, name As String )

        ' Get the array element width; format the formatting string.
        Dim loopX     As Integer
        Dim elemWidth As Integer = _
            Buffer.ByteLength( arr ) / arr.Length
        Dim format    As String = _
            String.Format( " {{0:X{0}}}", 2 * elemWidth )

        ' Display the array elements from right to left.
        Console.Write( "{0,7}:", name )
        For loopX = arr.Length - 1 to 0 Step -1
            Console.Write( format, arr( loopX ) )
        Next loopX
        Console.WriteLine( )
    End Sub

    Sub Main( )

        ' These are the arrays to be modified with SetByte.
        ' This allocates 10 elements for shorts and 3 elements
        ' for longs in Visual Basic.
        Dim shorts( 9 ) As Short
        Dim longs( 2 )  As Long  

        Console.WriteLine( "This example of the " & _
            "Buffer.SetByte( Array, Integer, Byte ) " & vbCrLf & _
            "method generates the following output." & vbCrLf & _
            "Note: The arrays are displayed from right to left." & _
            vbCrLf )
        Console.WriteLine( "  Initial values of arrays:" & vbCrLf )

        ' Display the initial values of the arrays.
        DisplayArray( shorts, "shorts" )
        DisplayArray( longs, "longs" )

        ' Copy two regions of source array to destination array,
        ' and two overlapped copies from source to source.
        Console.WriteLine( vbCrLf & _
            "  Array values after setting byte 3 = 25, " & vbCrLf & _
            "  byte 6 = 64, byte 12 = 121, and byte 17 = 196:" & vbCrLf )

        Buffer.SetByte( shorts, 3, 25 )
        Buffer.SetByte( shorts, 6, 64 )
        Buffer.SetByte( shorts, 12, 121 )
        Buffer.SetByte( shorts, 17, 196 )
        Buffer.SetByte( longs, 3, 25 )
        Buffer.SetByte( longs, 6, 64 )
        Buffer.SetByte( longs, 12, 121 )
        Buffer.SetByte( longs, 17, 196 )

        ' Display the arrays again.
        DisplayArray( shorts, "shorts" )
        DisplayArray( longs, "longs" )
    End Sub 
End Module 

' This example of the Buffer.SetByte( Array, Integer, Byte )
' method generates the following output.
' Note: The arrays are displayed from right to left.
' 
'   Initial values of arrays:
' 
'  shorts: 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000
'   longs: 0000000000000000 0000000000000000 0000000000000000
' 
'   Array values after setting byte 3 = 25,
'   byte 6 = 64, byte 12 = 121, and byte 17 = 196:
' 
'  shorts: 0000 C400 0000 0079 0000 0000 0040 0000 1900 0000
'   longs: 000000000000C400 0000007900000000 0040000019000000

Remarks

array must be an array of primitives.

Applies to

Dijeli putem