Array.Clear Methode

Definitie

Naamruimte:: System

Assembly's:: netstandard.dll, System.Runtime.dll

Assembly's:: mscorlib.dll, System.Runtime.dll

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Belangrijk

Bepaalde informatie heeft betrekking op een voorlopige productversie die aanzienlijk kan worden gewijzigd voordat deze wordt uitgebracht. Microsoft biedt geen enkele expliciete of impliciete garanties met betrekking tot de informatie die hier wordt verstrekt.

Overloads

Name	Description
Clear(Array)	Hiermee wist u de inhoud van een matrix.
Clear(Array, Int32, Int32)	Hiermee stelt u een bereik van elementen in een matrix in op de standaardwaarde van elk elementtype.

Clear(Array)

Bron:: Array.cs

Bron:: Array.cs

Bron:: Array.CoreCLR.cs

Bron:: Array.CoreCLR.cs

Bron:: Array.CoreCLR.cs

Hiermee wist u de inhoud van een matrix.

public:
 static void Clear(Array ^ array);

public static void Clear(Array array);

static member Clear : Array -> unit

Public Shared Sub Clear (array As Array)

Parameters

array: Array

De matrix die moet worden gewist.

Uitzonderingen

ArgumentNullException

array is null.

Van toepassing op

Clear(Array, Int32, Int32)

Bron:: Array.cs

Bron:: Array.cs

Bron:: Array.CoreCLR.cs

Bron:: Array.CoreCLR.cs

Bron:: Array.CoreCLR.cs

Hiermee stelt u een bereik van elementen in een matrix in op de standaardwaarde van elk elementtype.

public:
 static void Clear(Array ^ array, int index, int length);

public static void Clear(Array array, int index, int length);

static member Clear : Array * int * int -> unit

Public Shared Sub Clear (array As Array, index As Integer, length As Integer)

Parameters

array: Array

De matrix waarvan de elementen moeten worden gewist.

index: Int32

De beginindex van het bereik van elementen dat moet worden gewist.

length: Int32

Het aantal elementen dat moet worden gewist.

Uitzonderingen

ArgumentNullException

array is null.

IndexOutOfRangeException

index is kleiner dan de ondergrens van array.

– of –

length is kleiner dan nul.

– of –

De som van index en length is groter dan de grootte van array.

Voorbeelden

In het volgende voorbeeld wordt de Clear methode gebruikt om gehele getallen in een eendimensionale, tweedimensionale en driedimensionale matrix opnieuw in te stellen.

using System;

class Example
{
    public static void RunIt()
    {
        Console.WriteLine("One dimension (Rank=1):");
        int[] numbers1 = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };

        for (int i = 0; i < 9; i++)
        {
            Console.Write("{0} ", numbers1[i]);
        }
        Console.WriteLine();
        Console.WriteLine();

        Console.WriteLine("Array.Clear(numbers1, 2, 5)");
        Array.Clear(numbers1, 2, 5);

        for (int i = 0; i < 9; i++)
        {
            Console.Write("{0} ", numbers1[i]);
        }
        Console.WriteLine();
        Console.WriteLine();

        Console.WriteLine("Two dimensions (Rank=2):");
        int[,] numbers2 = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };

        for (int i = 0; i < 3; i++)
        {
            for (int j = 0; j < 3; j++)
            {
                Console.Write("{0} ", numbers2[i, j]);
            }
            Console.WriteLine();
        }

        Console.WriteLine();
        Console.WriteLine("Array.Clear(numbers2, 2, 5)");
        Array.Clear(numbers2, 2, 5);

        for (int i = 0; i < 3; i++)
        {
            for (int j = 0; j < 3; j++)
            {
                Console.Write("{0} ", numbers2[i, j]);
            }
            Console.WriteLine();
        }

        Console.WriteLine("\nThree dimensions (Rank=3):");
        int[,,] numbers3 = {{{1, 2}, {3, 4}},
                             {{5, 6}, {7, 8}},
                             {{9, 10}, {11, 12}}};

        for (int i = 0; i < 3; i++)
        {
            for (int j = 0; j < 2; j++)
            {
                for (int k = 0; k < 2; k++)
                {
                    Console.Write("{0} ", numbers3[i, j, k]);
                }
                Console.WriteLine();
            }
            Console.WriteLine();
        }

        Console.WriteLine("Array.Clear(numbers3, 2, 5)");
        Array.Clear(numbers3, 2, 5);

        for (int i = 0; i < 3; i++)
        {
            for (int j = 0; j < 2; j++)
            {
                for (int k = 0; k < 2; k++)
                {
                    Console.Write("{0} ", numbers3[i, j, k]);
                }
                Console.WriteLine();
            }
            Console.WriteLine();
        }
    }
}

/*  This code example produces the following output:
 *
 * One dimension (Rank=1):
 * 1 2 3 4 5 6 7 8 9
 *
 * Array.Clear(numbers1, 2, 5)
 * 1 2 0 0 0 0 0 8 9
 *
 * Two dimensions (Rank=2):
 * 1 2 3
 * 4 5 6
 * 7 8 9
 *
 * Array.Clear(numbers2, 2, 5)
 * 1 2 0
 * 0 0 0
 * 0 8 9
 *
 * Three dimensions (Rank=3):
 * 1 2
 * 3 4
 * 
 * 5 6
 * 7 8
 * 
 * 9 10
 * 11 12
 * 
 * Array.Clear(numbers3, 2, 5)
 * 1 2
 * 0 0
 * 
 * 0 0
 * 0 8
 * 
 * 9 10
 * 11 12
 */

open System

printfn "One dimension (Rank=1):"
let numbers1 = [| 1..9 |]

for i in numbers1 do
    printf $"{i} "
printfn "\n\nArray.Clear(numbers1, 2, 5)"

Array.Clear(numbers1, 2, 5)

for i in numbers1 do
    printf $"{i} "

printfn "\n\nTwo dimensions (Rank=2):"

let numbers2 = array2D [ [ 1; 2; 3 ]; [ 4; 5; 6 ]; [ 7; 8; 9 ] ]

for i = 0 to 2 do
    for j = 0 to 2 do
        printfn $"{numbers2[i, j]} "
    printfn ""

printfn "\nArray.Clear(numbers2, 2, 5)"
Array.Clear(numbers2, 2, 5)

for i = 0 to 2 do
    for j = 0 to 2 do
        printfn $"{numbers2[i, j]} "
    printfn ""

printfn "Three dimensions (Rank=3):"
let numbers3 = Array3D.zeroCreate 2 2 2
numbers3[0, 0, 0] <- 1
numbers3[0, 0, 1] <- 2
numbers3[0, 1, 0] <- 3
numbers3[0, 1, 1] <- 4
numbers3[1, 0, 0] <- 5
numbers3[1, 1, 0] <- 7
numbers3[1, 0, 1] <- 6
numbers3[1, 1, 1] <- 8
numbers3[2, 0, 0] <- 9
numbers3[2, 1, 0] <- 10
numbers3[2, 0, 1] <- 11
numbers3[2, 1, 1] <- 12

for i = 0 to 2 do
    for j = 0 to 1 do
        for k = 0 to 1 do
            printf $"{numbers3[i, j, k]} "
        printfn ""
    printfn ""

printfn "Array.Clear(numbers3, 2, 5)"
Array.Clear(numbers3, 2, 5)

for i = 0 to 1 do
    for j = 0 to 1 do
        for k = 0 to 1 do
            printf $"{numbers3[i, j, k]} "
        printfn ""
    printfn ""

//  This code example produces the following output:
//
// One dimension (Rank=1):
// 1 2 3 4 5 6 7 8 9
//
// Array.Clear(numbers1, 2, 5)
// 1 2 0 0 0 0 0 8 9
//
// Two dimensions (Rank=2):
// 1 2 3
// 4 5 6
// 7 8 9
//
// Array.Clear(numbers2, 2, 5)
// 1 2 0
// 0 0 0
// 0 8 9
//
// Three dimensions (Rank=3):
// 1 2
// 3 4
//
// 5 6
// 7 8
//
// 9 10
// 11 12
//
// Array.Clear(numbers3, 2, 5)
// 1 2
// 0 0
//
// 0 0
// 0 8
//
// 9 10
// 11 12
//

Module Example
    Sub RunIt()
        Console.WriteLine(vbLf & "One dimension (Rank=1):")
        Dim numbers1() As Integer = {1, 2, 3, 4, 5, 6, 7, 8, 9}

        For i As Integer = 0 To 8
            Console.Write("{0} ", numbers1(i))
        Next
        Console.WriteLine()

        Console.WriteLine(vbLf & "Array.Clear(numbers1, 2, 5)")
        Array.Clear(numbers1, 2, 5)

        For i As Integer = 0 To 8
            Console.Write("{0} ", numbers1(i))
        Next
        Console.WriteLine()


        Console.WriteLine(vbLf & "Two dimensions (Rank=2):")
        Dim numbers2(,) As Integer = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}

        For i As Integer = 0 To 2
            For j As Integer = 0 To 2
                Console.Write("{0} ", numbers2(i, j))
            Next
            Console.WriteLine()
        Next

        Console.WriteLine(vbLf & "Array.Clear(numbers2, 2, 5)")
        Array.Clear(numbers2, 2, 5)

        For i As Integer = 0 To 2
            For j As Integer = 0 To 2
                Console.Write("{0} ", numbers2(i, j))
            Next
            Console.WriteLine()
        Next

        Console.WriteLine(vbLf & "Three dimensions (Rank=3):")
        Dim numbers3(,,) As Integer = {{{1, 2}, {3, 4}},
                                       {{5, 6}, {7, 8}},
                                       {{9, 10}, {11, 12}}}

        For i As Integer = 0 To 2
            For j As Integer = 0 To 1
                For k As Integer = 0 To 1
                    Console.Write("{0} ", numbers3(i, j, k))
                Next
                Console.WriteLine()
            Next
            Console.WriteLine()
        Next

        Console.WriteLine("Array.Clear(numbers3, 2, 5)")
        Array.Clear(numbers3, 2, 5)

        For i As Integer = 0 To 2
            For j As Integer = 0 To 1
                For k As Integer = 0 To 1
                    Console.Write("{0} ", numbers3(i, j, k))
                Next
                Console.WriteLine()
            Next
            Console.WriteLine()
        Next
    End Sub
End Module

' The example displays the following output:
'       One dimension (Rank=1):
'       1 2 3 4 5 6 7 8 9
'
'       Array.Clear(numbers1, 2, 5)
'       1 2 0 0 0 0 0 8 9
'
'       Two dimensions (Rank=2):
'       1 2 3
'       4 5 6
'       7 8 9
'
'       Array.Clear(numbers2, 2, 5)
'       1 2 0
'       0 0 0
'       0 8 9
'
'       Three dimensions (Rank=3):
'       1 2
'       3 4
'       
'       5 6
'       7 8
'       
'       9 10
'       11 12
'       
'       Array.Clear(numbers3, 2, 5)
'       1 2
'       0 0
'       
'       0 0
'       0 8
'       
'       9 10
'       11 12

In het volgende voorbeeld wordt een TimeZoneTime structuur gedefinieerd die een TimeZoneInfo veld en een DateTimeOffset veld bevat. Vervolgens wordt de Clear methode aangeroepen om één element in een matrix met twee elementen met TimeZoneTime waarden te wissen. Met de methode wordt de waarde van het gewiste element ingesteld op de standaardwaarde van een TimeZoneInfo object, dat wil nullwel , en de standaardwaarde van een DateTimeOffset object, namelijk DateTimeOffset.MinValue.

using System;

public struct TimeZoneTime
{
    public TimeZoneTime(DateTimeOffset dateTime, TimeZoneInfo timeZone)
    {
        DateTime = dateTime;
        TimeZone = timeZone;
    }

    public DateTimeOffset DateTime { get; }

    public TimeZoneInfo TimeZone { get; }
}

public class Example1
{
    public static void RunIt()
    {
        // Declare an array with two elements.
        TimeZoneTime[] timeZoneTimes = {
            new(DateTime.Now, TimeZoneInfo.Local),
            new(DateTime.Now, TimeZoneInfo.Utc)
        };
        foreach (var timeZoneTime in timeZoneTimes)
            Console.WriteLine("{0}: {1:G}",
                              timeZoneTime.TimeZone == null ? "<null>" : timeZoneTime.TimeZone.ToString(),
                              timeZoneTime.DateTime);
        Console.WriteLine();

        Array.Clear(timeZoneTimes, 1, 1);
        foreach (var timeZoneTime in timeZoneTimes)
            Console.WriteLine("{0}: {1:G}",
                              timeZoneTime.TimeZone == null ? "<null>" : timeZoneTime.TimeZone.ToString(),
                              timeZoneTime.DateTime);
    }
}

// The example displays the following output:
//       (UTC-08:00) Pacific Time (US & Canada): 1/20/2014 12:11:00 PM
//       UTC: 1/20/2014 12:11:00 PM
//
//       (UTC-08:00) Pacific Time (US & Canada): 1/20/2014 12:11:00 PM
//       <null>: 1/1/0001 12:00:00 AM

open System

[<Struct>]
type TimeZoneTime =
    { DateTime: DateTimeOffset
      TimeZone: TimeZoneInfo }

// Declare an array with two elements.
let timeZoneTimes = 
    [| { DateTime = DateTimeOffset.Now; TimeZone = TimeZoneInfo.Local }
       { DateTime = DateTimeOffset.Now; TimeZone = TimeZoneInfo.Local } |]

for timeZoneTime in timeZoneTimes do
    let tz = if isNull timeZoneTime.TimeZone then "<null>" else string timeZoneTime.TimeZone
    printfn $"{tz}: {timeZoneTime.DateTime:G}"
printfn ""

Array.Clear(timeZoneTimes, 1, 1)
for timeZoneTime in timeZoneTimes do
    let tz = if isNull timeZoneTime.TimeZone then "<null>" else string timeZoneTime.TimeZone
    printfn $"{tz}: {timeZoneTime.DateTime:G}"

// The example displays the following output:
//       (UTC-08:00) Pacific Time (US & Canada): 1/20/2014 12:11:00 PM
//       UTC: 1/20/2014 12:11:00 PM
//
//       (UTC-08:00) Pacific Time (US & Canada): 1/20/2014 12:11:00 PM
//       <null>: 1/1/0001 12:00:00 AM

Public Structure TimeZoneTime
    Private dt As DateTimeOffset
    Private tz As TimeZoneInfo

    Public Sub New(dateTime As DateTimeOffset, timeZone As TimeZoneInfo)
        dt = dateTime
        tz = timeZone
    End Sub

    Public ReadOnly Property DateTime As DateTimeOffset
        Get
            Return dt
        End Get
    End Property

    Public ReadOnly Property TimeZone As TimeZoneInfo
        Get
            Return tz
        End Get
    End Property
End Structure

Module Example1
    Public Sub RunIt()
        ' Declare an array with two elements.
        Dim timeZoneTimes() As TimeZoneTime = {New TimeZoneTime(Date.Now, TimeZoneInfo.Local),
                                              New TimeZoneTime(Date.Now, TimeZoneInfo.Utc)}
        For Each timeZoneTime In timeZoneTimes
            Console.WriteLine("{0}: {1:G}",
                           If(timeZoneTime.TimeZone Is Nothing, "<null>", timeZoneTime.TimeZone),
                           timeZoneTime.DateTime)
        Next
        Console.WriteLine()

        Array.Clear(timeZoneTimes, 1, 1)
        For Each timeZoneTime In timeZoneTimes
            Console.WriteLine("{0}: {1:G}",
                           If(timeZoneTime.TimeZone Is Nothing, "<null>", timeZoneTime.TimeZone),
                           timeZoneTime.DateTime)
        Next
    End Sub
End Module
' The example displays output like the following:
'       (UTC-08:00) Pacific Time (US & Canada): 1/20/2014 12:11:00 PM
'       UTC: 1/20/2014 12:11:00 PM
'       
'       (UTC-08:00) Pacific Time (US & Canada): 1/20/2014 12:11:00 PM
'       <null>: 1/1/0001 12:00:00 AM

Opmerkingen

Met deze methode wordt elk element in een matrix opnieuw ingesteld op de standaardwaarde van het elementtype. Hiermee worden elementen van verwijzingstypen (inclusief String elementen) nullingesteld op en worden elementen van waardetypen ingesteld op de standaardwaarden die worden weergegeven in de volgende tabel.

Typ	Waarde
Boolean	`false`
Alle integrale en numerieke typen drijvende komma	0 (nul)
DateTime	DateTime.MinValue
Andere waardetypen	Standaardwaarde van de velden van het type

Het bereik van gewiste elementen loopt van rij naar rij in een multidimensionale matrix.

Met deze methode worden alleen de waarden van de elementen gewist; de elementen zelf worden niet verwijderd. Een matrix heeft een vaste grootte; daarom kunnen elementen niet worden toegevoegd of verwijderd.

Deze methode is een $O(n)$ bewerking, waarbij $n$ is length.

Van toepassing op

Feedback

Is deze pagina nuttig?