Buffer.SetByte-Methode
Weist einem Byte an einer bestimmten Position eines angegebenen Arrays einen bestimmten Wert zu.
Namespace: System
Assembly: mscorlib (in mscorlib.dll)
Syntax
'Declaration
Public Shared Sub SetByte ( _
array As Array, _
index As Integer, _
value As Byte _
)
'Usage
Dim array As Array
Dim index As Integer
Dim value As Byte
Buffer.SetByte(array, index, value)
public static void SetByte (
Array array,
int index,
byte value
)
public:
static void SetByte (
Array^ array,
int index,
unsigned char value
)
public static void SetByte (
Array array,
int index,
byte value
)
public static function SetByte (
array : Array,
index : int,
value : byte
)
Parameter
- array
Ein Array.
- index
Eine Position im Array.
- value
Ein zuzuweisender Wert.
Ausnahmen
| Ausnahmetyp | Bedingung |
|---|---|
array ist kein Array von Primitiven. |
|
array ist NULL (Nothing in Visual Basic). |
|
index ist negativ oder größer als die Länge von array. |
Hinweise
array muss ein Array von Primitiven sein.
Beispiel
Im folgenden Codebeispiel werden Bytes an bestimmten Positionen in Arrays mithilfe der SetByte-Methode Werte zugewiesen.
' Example of the Buffer.SetByte method.
Imports System
Imports Microsoft.VisualBasic
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
// 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
*/
// 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.
import 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.get_Length();
String format = String.Format(" {{0:X{0}}}", (Int32)(2 * elemWidth));
// Display the array elements from right to left.
Console.Write("{0,7}:", name);
for (int loopX = arr.get_Length() - 1; loopX >= 0; loopX--) {
Console.Write(format, arr.GetValue(loopX));
}
Console.WriteLine();
} //DisplayArray
public static void main(String[] args)
{
// 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, (ubyte)25);
Buffer.SetByte(shorts, 6, (ubyte)64);
Buffer.SetByte(shorts, 12, (ubyte)121);
Buffer.SetByte(shorts, 17, (ubyte)196);
Buffer.SetByte(longs, 3, (ubyte)25);
Buffer.SetByte(longs, 6, (ubyte)64);
Buffer.SetByte(longs, 12, (ubyte)121);
Buffer.SetByte(longs, 17, (ubyte)196);
// Display the arrays again.
DisplayArray(shorts, "shorts");
DisplayArray(longs, "longs");
} //main
} //SetByteDemo
/*
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
*/
Plattformen
Windows 98, Windows 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile für Pocket PC, Windows Mobile für Smartphone, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition
.NET Framework unterstützt nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen.
Versionsinformationen
.NET Framework
Unterstützt in: 2.0, 1.1, 1.0
.NET Compact Framework
Unterstützt in: 2.0, 1.0