Array.Clear Metodo

Definizione

Spazio dei nomi:: System

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

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

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Importante

Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.

Overload

Nome	Descrizione
Clear(Array)	Cancella il contenuto di una matrice.
Clear(Array, Int32, Int32)	Imposta un intervallo di elementi in una matrice sul valore predefinito di ogni tipo di elemento.

Clear(Array)

Origine:: Array.cs

Origine:: Array.cs

Origine:: Array.CoreCLR.cs

Origine:: Array.CoreCLR.cs

Origine:: Array.CoreCLR.cs

Cancella il contenuto di una matrice.

public:
 static void Clear(Array ^ array);

public static void Clear(Array array);

static member Clear : Array -> unit

Public Shared Sub Clear (array As Array)

Parametri

array: Array

Matrice da cancellare.

Eccezioni

ArgumentNullException

array è null.

Si applica a

Clear(Array, Int32, Int32)

Origine:: Array.cs

Origine:: Array.cs

Origine:: Array.CoreCLR.cs

Origine:: Array.CoreCLR.cs

Origine:: Array.CoreCLR.cs

Imposta un intervallo di elementi in una matrice sul valore predefinito di ogni tipo di elemento.

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)

Parametri

array: Array

Matrice i cui elementi devono essere cancellati.

index: Int32

Indice iniziale dell'intervallo di elementi da cancellare.

length: Int32

Numero di elementi da cancellare.

Eccezioni

ArgumentNullException

array è null.

IndexOutOfRangeException

index è minore del limite inferiore di array.

oppure

length è minore di zero.

oppure

La somma di index e length è maggiore della dimensione di array.

Esempio

Nell'esempio seguente viene utilizzato il Clear metodo per reimpostare i valori integer in una matrice unidimensionale, bidimensionale e tridimensionale.

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

Nell'esempio seguente viene definita una TimeZoneTime struttura che include un TimeZoneInfo campo e un DateTimeOffset campo. Chiama quindi il Clear metodo per cancellare un elemento in una matrice a due elementi di TimeZoneTime valori. Il metodo imposta il valore dell'elemento cancellato sul valore predefinito di un TimeZoneInfo oggetto , ovvero nulle il valore predefinito di un DateTimeOffset oggetto , ovvero 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

Commenti

Questo metodo reimposta ogni elemento di una matrice sul valore predefinito del tipo di elemento. Imposta gli elementi dei tipi di riferimento (inclusi String gli elementi) su nulle imposta gli elementi dei tipi valore sui valori predefiniti illustrati nella tabella seguente.

TIPO	Value
Boolean	`false`
Tutti i tipi numerici integrali e a virgola mobile	0 (zero)
DateTime	DateTime.MinValue
Altri tipi di valore	Valore predefinito dei campi del tipo

Intervallo di elementi cancellati a capo da riga a riga in una matrice multidimensionale.

Questo metodo cancella solo i valori degli elementi; non elimina gli elementi stessi. Una matrice ha una dimensione fissa; pertanto, gli elementi non possono essere aggiunti o rimossi.

Questo metodo è un'operazione $O(n)$, dove $n$ è length.

Si applica a

Commenti e suggerimenti

Questa pagina è stata utile?