ArgumentOutOfRangeException Classe

Riferimento

Definizione

Spazio dei nomi:: System

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Origine:: ArgumentOutOfRangeException.cs

Origine:: ArgumentOutOfRangeException.cs

Origine:: ArgumentOutOfRangeException.cs

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.

Eccezione generata quando il valore di un argomento non è compreso nell'intervallo consentito di valori, come definito dal metodo richiamato.

public ref class ArgumentOutOfRangeException : ArgumentException

public class ArgumentOutOfRangeException : ArgumentException

[System.Serializable]
public class ArgumentOutOfRangeException : ArgumentException

[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public class ArgumentOutOfRangeException : ArgumentException

type ArgumentOutOfRangeException = class
    inherit ArgumentException

type ArgumentOutOfRangeException = class
    inherit ArgumentException
    interface ISerializable

[<System.Serializable>]
type ArgumentOutOfRangeException = class
    inherit ArgumentException
    interface ISerializable

[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type ArgumentOutOfRangeException = class
    inherit ArgumentException
    interface ISerializable

Public Class ArgumentOutOfRangeException
Inherits ArgumentException

Ereditarietà: Object

Exception

ArgumentException
ArgumentOutOfRangeException

Ereditarietà: Object

Exception

SystemException

ArgumentException
ArgumentOutOfRangeException

Attributi: SerializableAttribute ComVisibleAttribute

Implementazioni: ISerializable

Esempio

Nell'esempio seguente viene definita una classe che contiene informazioni su un guest invitato. Se il guest è minore di 21, viene generata un'eccezione ArgumentOutOfRangeException .

using System;
using static System.Console;

public class Program
{
    public static void Main(string[] args)
    {
        try
        {
            var guest1 = new Guest("Ben", "Miller", 17);
            WriteLine(guest1.GuestInfo);
        }
        catch (ArgumentOutOfRangeException argumentOutOfRangeException)
        {
            WriteLine($"Error: {argumentOutOfRangeException.Message}");
        }
    }
}

class Guest
{
    private const int minimumRequiredAge = 21;

    private string firstName;
    private string lastName;
    private int age;

    public Guest(string firstName, string lastName, int age)
    {
        if (age < minimumRequiredAge)
            throw new ArgumentOutOfRangeException(nameof(age), $"All guests must be {minimumRequiredAge}-years-old or older.");

        this.firstName = firstName;
        this.lastName = lastName;
        this.age = age;
    }

    public string GuestInfo => $"{firstName} {lastName}, {age}";
}

open System

type Guest(fName: string, lName: string, age: int) =
    let minimumRequiredAge = 21

    do if age < minimumRequiredAge then 
        raise (ArgumentOutOfRangeException(nameof age, $"All guests must be {minimumRequiredAge}-years-old or older."))

    member _.FirstName = fName
    member _.LastName = lName
    member _.GuestInfo() = $"{fName} {lName}, {age}"

try
    let guest1 = Guest("Ben", "Miller", 17);
    printfn $"{guest1.GuestInfo()}"
with
| :? ArgumentOutOfRangeException as e ->
    printfn $"Error: {e.Message}"

Module Module1
   Public Sub Main()
       Try
           Dim guest1 As Guest = New Guest("Ben", "Miller", 17)
           Console.WriteLine(guest1.GuestInfo)
       Catch outOfRange As ArgumentOutOfRangeException
           Console.WriteLine("Error: {0}", outOfRange.Message)
       End Try
   End Sub
End Module

Class Guest
    Private FirstName As String
    Private LastName As String
    Private Age As Integer

    Public Sub New(ByVal fName As String, ByVal lName As String, ByVal age As Integer)
        MyBase.New()
        FirstName = fName
        LastName = lName
        If (age < 21) Then
            Throw New ArgumentOutOfRangeException("age", "All guests must be 21-years-old or older.")
        Else
            age = age
        End If
    End Sub

    Public Function GuestInfo() As String
        Dim gInfo As String = (FirstName + (" " _
                    + (Me.LastName + (", " + Me.Age.ToString))))
        Return gInfo
    End Function
End Class

Commenti

Viene ArgumentOutOfRangeException generata un'eccezione quando viene richiamato un metodo e almeno uno degli argomenti passati al metodo non null è e contiene un valore non valido che non è un membro del set di valori previsto per l'argomento. La ParamName proprietà identifica l'argomento non valido e la ActualValue proprietà, se è presente un valore, identifica il valore non valido.

In genere, si verifica un ArgumentOutOfRangeException errore dello sviluppatore. Anziché gestire l'eccezione in un try/catch blocco, è necessario eliminare la causa dell'eccezione o, se l'argomento viene restituito da una chiamata al metodo o dall'input dell'utente prima di essere passato al metodo che genera l'eccezione, è necessario convalidare gli argomenti prima di passarli al metodo .

ArgumentOutOfRangeException viene usato ampiamente da:

Classi negli spazi dei System.Collections nomi e System.IO .
Classe Array.
Metodi di manipolazione delle stringhe nella String classe .

Le condizioni in cui viene generata un'eccezione ArgumentOutOfRangeException includono quanto segue:

Si sta recuperando il membro di una raccolta in base al numero di indice e il numero di indice non è valido.

Questa è la causa più comune di un'eccezione ArgumentOutOfRangeException . In genere, il numero di indice non è valido per uno dei quattro motivi seguenti:

La raccolta non ha membri e il codice presuppone che lo faccia. Nell'esempio seguente viene eseguito un tentativo di recuperare il primo elemento di una raccolta senza elementi:

using System;
using System.Collections.Generic;

public class Example4
{
   public static void Main()
   {
      var list = new List<string>();
      Console.WriteLine("Number of items: {0}", list.Count);
      try {
         Console.WriteLine("The first item: '{0}'", list[0]);
      }
      catch (ArgumentOutOfRangeException e) {
         Console.WriteLine(e.Message);
      }
   }
}
// The example displays the following output:
//   Number of items: 0
//   Index was out of range. Must be non-negative and less than the size of the collection.
//   Parameter name: index

open System


let list = ResizeArray<string>()
printfn $"Number of items: {list.Count}"
try
    printfn $"The first item: '{list[0]}'"
with 
| :? ArgumentOutOfRangeException as e ->
    printfn $"{e.Message}"

// The example displays the following output:
//   Number of items: 0
//   Index was out of range. Must be non-negative and less than the size of the collection. (Parameter 'index')

Imports System.Collections.Generic

Module Example
   Public Sub Main()
      Dim list As New List(Of String)
      Console.WriteLine("Number of items: {0}", list.Count)
      Try
         Console.WriteLine("The first item: '{0}'", list(0))
      Catch e As ArgumentOutOfRangeException
         Console.WriteLine(e.Message)
      End Try
   End Sub
End Module
' The example displays the following output:
'   Number of items: 0
'   Index was out of range. Must be non-negative and less than the size of the collection.
'   Parameter name: index

Per evitare l'eccezione, verificare se la proprietà della Count raccolta è maggiore di zero prima di tentare di recuperare tutti i membri, come nel frammento di codice seguente.

if (list.Count > 0)
   Console.WriteLine("The first item: '{0}'", list[0]);

if list.Count > 0 then
    printfn $"The first item: '{list[0]}'"

If list.Count > 0 Then
   Console.WriteLine("The first item: '{0}'", list(0))
End If

In alcuni casi, l'eccezione può verificarsi perché si sta tentando di aggiungere un membro a una raccolta usando un indice che non esiste, anziché chiamando il metodo , ad esempio Add, esistente a questo scopo. Nell'esempio seguente viene tentato di aggiungere un elemento a una raccolta utilizzando un indice inesistente anziché chiamare il List<T>.Add metodo .

using System;
using System.Collections.Generic;

public class Example13
{
   public static void Main()
   {
      var numbers = new List<int>();
      numbers.AddRange( new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 20 } );

      var squares = new List<int>();
      for (int ctr = 0; ctr < numbers.Count; ctr++)
         squares[ctr] = (int) Math.Pow(numbers[ctr], 2);
   }
}
// The example displays the following output:
//    Unhandled Exception: System.ArgumentOutOfRangeException: Index was out of range. Must be non-negative and less than the size of the collection.
//    Parameter name: index
//       at System.ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument argument, ExceptionResource resource)
//       at Example.Main()

let numbers = ResizeArray<int>()
numbers.AddRange [ 0; 1; 2; 3; 4; 5; 6; 7; 8; 9; 20 ]

let squares = ResizeArray<int>()
for  ctr = 0 to numbers.Count - 1 do
    squares[ctr] <- int (float numbers[ctr] ** 2)

// The example displays the following output:
//    Unhandled Exception: System.ArgumentOutOfRangeException: Index was out of range. Must be non-negative and less than the size of the collection. (Parameter 'index')
//       at System.ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument argument, ExceptionResource resource)
//       at <StartupCode$argumentoutofrangeexception>.$NoElements.main@()

Imports System.Collections.Generic

Module Example
   Public Sub Main()
      Dim numbers As New List(Of Integer)
      numbers.AddRange( { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 20 } )
      
      Dim squares As New List(Of Integer)
      For ctr As Integer = 0 To numbers.Count - 1
         squares(ctr) = CInt(numbers(ctr) ^ 2) 
      Next
   End Sub
End Module
' The example displays the following output:
'    Unhandled Exception: System.ArgumentOutOfRangeException: Index was out of range. Must be non-negative and less than the size of the collection.
'    Parameter name: index
'       at System.ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument argument, ExceptionResource resource)
'       at Example.Main()

Il frammento di codice seguente corregge questo errore:

var squares = new List<int>();
for (int ctr = 0; ctr < numbers.Count; ctr++)
   squares.Add((int) Math.Pow(numbers[ctr], 2));

let squares = ResizeArray<int>()
for ctr = 0 to numbers.Count - 1 do
    squares.Add(int (float numbers[ctr] ** 2))

Dim squares As New List(Of Integer)
For ctr As Integer = 0 To numbers.Count - 1
   squares.Add(CInt(numbers(ctr) ^ 2)) 
Next

Si sta tentando di recuperare un elemento il cui indice è negativo. Ciò si verifica in genere perché è stata eseguita una ricerca in una raccolta per l'indice di un particolare elemento e si presuppone erroneamente che la ricerca abbia esito positivo. Nell'esempio seguente la chiamata al List<T>.FindIndex(Predicate<T>) metodo non riesce a trovare una stringa uguale a "Z" e quindi restituisce -1. Tuttavia, si tratta di un valore di indice non valido.

using System;
using System.Collections.Generic;

public class Example
{
   public static void Main()
   {
      var list = new List<string>();
      list.AddRange( new String[] { "A", "B", "C" } );
      // Get the index of the element whose value is "Z".
      int index = list.FindIndex((new StringSearcher("Z")).FindEquals);
      try {
         Console.WriteLine("Index {0} contains '{1}'", index, list[index]);
      }
      catch (ArgumentOutOfRangeException e) {
         Console.WriteLine(e.Message);
      }
   }
}

internal class StringSearcher
{
   string value;

   public StringSearcher(string value)
   {
      this.value = value;
   }

   public bool FindEquals(string s)
   {
      return s.Equals(value, StringComparison.InvariantCulture);
   }
}
// The example displays the following output:
//   Index was out of range. Must be non-negative and less than the size of the collection.
//   Parameter name: index

open System

module StringSearcher =
    let findEquals (s: string) value =
        s.Equals(value, StringComparison.InvariantCulture)

let list = ResizeArray<string>()
list.AddRange [ "A"; "B"; "C" ]
// Get the index of the element whose value is "Z".
let index = list.FindIndex(StringSearcher.findEquals "Z")
try 
    printfn $"Index {index} contains '{list[index]}'"
with 
| :? ArgumentOutOfRangeException as e ->
    printfn $"{e.Message}" 

// The example displays the following output:
//   Index was out of range. Must be non-negative and less than the size of the collection. (Parameter 'index')

Imports System.Collections.Generic

Module Example
   Public Sub Main()
      Dim list As New List(Of String) 
      list.AddRange( { "A", "B", "C" } )
      ' Get the index of the element whose value is "Z".
      Dim index As Integer = list.FindIndex(AddressOf (New StringSearcher("Z")).FindEquals)
      Try
         Console.WriteLine("Index {0} contains '{1}'", index, list(index)) 
      Catch e As ArgumentOutOfRangeException
         Console.WriteLine(e.Message)
      End Try
   End Sub
End Module

Friend Class StringSearcher
   Dim value As String
   
   Public Sub New(value As String)
      Me.value = value
   End Sub
   
   Public Function FindEquals(s As String) As Boolean
      Return s.Equals(value, StringComparison.InvariantCulture) 
   End Function
End Class
' The example displays the following output:
'   Index was out of range. Must be non-negative and less than the size of the collection.
'   Parameter name: index

Per evitare l'eccezione, verificare che la ricerca abbia esito positivo assicurandosi che l'indice restituito sia maggiore o uguale a zero prima di tentare di recuperare l'elemento dalla raccolta, come avviene nel frammento di codice seguente.

// Get the index of the element whose value is "Z".
int index = list.FindIndex((new StringSearcher("Z")).FindEquals);
if (index >= 0)
   Console.WriteLine("'Z' is found at index {0}", list[index]);

// Get the index of the element whose value is "Z".
let index = list.FindIndex(StringSearcher.findEquals "Z")
if index >= 0 then
    printfn $"'Z' is found at index {list[index]}"

' Get the index of the element whose value is "Z".
Dim index As Integer = list.FindIndex(AddressOf (New StringSearcher("Z")).FindEquals)
If index >= 0 Then
   Console.WriteLine("Index {0} contains '{1}'", index, list(index)) 
End If

Si sta tentando di recuperare un elemento il cui indice è uguale al valore della proprietà della Count raccolta, come illustrato nell'esempio seguente.

using System;
using System.Collections.Generic;

public class Example8
{
   public static void Main()
   {
      var list = new List<string>();
      list.AddRange( new String[] { "A", "B", "C" } );
      try {
         // Display the elements in the list by index.
         for (int ctr = 0; ctr <= list.Count; ctr++)
            Console.WriteLine("Index {0}: {1}", ctr, list[ctr]);
      }
      catch (ArgumentOutOfRangeException e) {
         Console.WriteLine(e.Message);
      }
   }
}
// The example displays the following output:
//   Index 0: A
//   Index 1: B
//   Index 2: C
//   Index was out of range. Must be non-negative and less than the size of the collection.
//   Parameter name: index

open System

let list = ResizeArray<string>()
list.AddRange [ "A"; "B"; "C" ] 
try
    // Display the elements in the list by index.
    for i = 0 to list.Count do
        printfn $"Index {i}: {list[i]}"
with 
| :? ArgumentOutOfRangeException as e ->
    printfn $"{e.Message}" 
      
// The example displays the following output:
//   Index 0: A
//   Index 1: B
//   Index 2: C
//   Index was out of range. Must be non-negative and less than the size of the collection. (Parameter 'index')

Imports System.Collections.Generic

Module Example
   Public Sub Main()
      Dim list As New List(Of String) 
      list.AddRange( { "A", "B", "C" } )
      Try
         ' Display the elements in the list by index.
         For ctr As Integer = 0 To list.Count
            Console.WriteLine("Index {0}: {1}", ctr, list(ctr)) 
         Next   
      Catch e As ArgumentOutOfRangeException
         Console.WriteLine(e.Message)
      End Try
   End Sub
End Module
' The example displays the following output:
'   Index 0: A
'   Index 1: B
'   Index 2: C
'   Index was out of range. Must be non-negative and less than the size of the collection.
'   Parameter name: index

Poiché le raccolte in .NET usano l'indicizzazione in base zero, il primo elemento della raccolta è in corrispondenza dell'indice 0 e l'ultimo elemento è in corrispondenza dell'indice Count - 1. È possibile eliminare l'errore assicurandosi di accedere all'ultimo elemento in corrispondenza dell'indice Count - 1, come avviene nel codice seguente.

// Display the elements in the list by index.
for (int ctr = 0; ctr < list.Count; ctr++)
   Console.WriteLine("Index {0}: {1}", ctr, list[ctr]);

// Display the elements in the list by index.
for i = 0 to list.Count - 1 do
    printfn $"Index {i}: {list[i]}"

' Display the elements in the list by index.
For ctr As Integer = 0 To list.Count - 1 
   Console.WriteLine("Index {0}: {1}", ctr, list(ctr)) 
Next

Si sta tentando di eseguire un'operazione di stringa chiamando un metodo di manipolazione delle stringhe e l'indice iniziale non esiste nella stringa.

Overload di metodi come String.Compare, , String.CompareOrdinal, String.IndexOf String.Insert IndexOfAny, String.LastIndexOf, String.LastIndexOfAny, Remove, o String.Substring che consentono di specificare l'indice iniziale dell'operazione richiede che l'indice sia una posizione valida all'interno della stringa. Gli indici validi sono compreso tra 0 e String.Length 1.

Esistono quattro cause comuni di questa ArgumentOutOfRangeException eccezione:

Si sta usando una stringa vuota o String.Empty. Poiché la relativa String.Length proprietà restituisce 0, qualsiasi tentativo di modificarlo in base all'indice genera un'eccezione ArgumentOutOfRangeException . Nell'esempio seguente viene definito un GetFirstCharacter metodo che restituisce il primo carattere di una stringa. Se la stringa è vuota, poiché la stringa finale passata al metodo è , il metodo genera un'eccezione ArgumentOutOfRangeException .

using System;

public class Example1
{
    public static void Main()
    {
        String[] words = { "the", "today", "tomorrow", " ", "" };
        foreach (var word in words)
            Console.WriteLine("First character of '{0}': '{1}'",
                              word, GetFirstCharacter(word));
    }

    private static char GetFirstCharacter(string s)
    {
        return s[0];
    }
}
// The example displays the following output:
//    First character of //the//: //t//
//    First character of //today//: //t//
//    First character of //tomorrow//: //t//
//    First character of // //: // //
//
//    Unhandled Exception: System.IndexOutOfRangeException: Index was outside the bounds of the array.
//       at Example.Main()

open System

let getFirstCharacter (s: string) = s[0]

let words = [ "the"; "today"; "tomorrow"; " "; "" ]
for word in words do
    printfn $"First character of '{word}': '{getFirstCharacter word}'"

// The example displays the following output:
//    First character of 'the': 't'
//    First character of 'today': 't'
//    First character of 'tomorrow': 't'
//    First character of ' ': ' '
//
//    Unhandled Exception: System.IndexOutOfRangeException: Index was outside the bounds of the array.
//       at <StartupCode$argumentoutofrangeexception>.$EmptyString1.main@()

Module Example
   Public Sub Main()
       Dim words() As String = { "the", "today", "tomorrow", " ", "" }
       For Each word In words
          Console.WriteLine("First character of '{0}': '{1}'", 
                            word, GetFirstCharacter(word))
       Next                     
   End Sub
   
   Private Function GetFirstCharacter(s As String) As Char
      Return s(0)
   End Function
End Module
' The example displays the following output:
'    First character of 'the': 't'
'    First character of 'today': 't'
'    First character of 'tomorrow': 't'
'    First character of ' ': ' '
'    
'    Unhandled Exception: System.IndexOutOfRangeException: Index was outside the bounds of the array.
'       at Example.Main()

È possibile eliminare l'eccezione String.Length verificando se la stringa è maggiore di zero o chiamando il IsNullOrEmpty metodo per assicurarsi che la stringa non null sia o vuota. Il frammento di codice seguente esegue quest'ultima operazione. In questo caso, se la stringa è null o vuota, il GetFirstCharacter metodo restituisce U+0000.

static char GetFirstCharacter(string s)
{
    if (string.IsNullOrEmpty(s))
        return '\u0000';
    else
        return s[0];
}

let getFirstCharacter (s: string) =
   if String.IsNullOrEmpty s then
      '\u0000'
   else
      s[0]

Function GetFirstCharacter(s As String) As Char
   If String.IsNullOrEmpty(s) Then 
      Return ChrW(0)
   Else   
      Return s(0)
   End If   
End Function

Si sta modificando una stringa in base alla posizione di una sottostringa all'interno di tale stringa e non è stato possibile determinare se la sottostringa è stata effettivamente trovata.

Nell'esempio seguente viene estratta la seconda parola di una frase a due parole. Genera un'eccezione ArgumentOutOfRangeException se la frase è costituita da una sola parola e pertanto non contiene un carattere di spazio incorporato. Ciò si verifica perché la chiamata al String.IndexOf(String) metodo restituisce -1 per indicare che la ricerca non è riuscita e questo valore non valido viene quindi passato al String.Substring(Int32) metodo .

using System;

public class Example17
{
   public static void Main()
   {
      String[] phrases = { "ocean blue", "concerned citizen",
                           "runOnPhrase" };
      foreach (var phrase in phrases)
         Console.WriteLine("Second word is {0}", GetSecondWord(phrase));
   }

   static string GetSecondWord(string s)
   {
      int pos = s.IndexOf(" ");
      return s.Substring(pos).Trim();
   }
}
// The example displays the following output:
//    Second word is blue
//    Second word is citizen
//
//    Unhandled Exception: System.ArgumentOutOfRangeException: StartIndex cannot be less than zero.
//    Parameter name: startIndex
//       at System.String.Substring(Int32 startIndex, Int32 length)
//       at Example17.GetSecondWord(String s)
//       at Example17.Main()

let getSecondWord (s: string) =
    let pos = s.IndexOf " "
    s.Substring(pos).Trim()

let phrases = [ "ocean blue"; "concerned citizen"; "runOnPhrase" ]
for phrase in phrases do
    printfn $"Second word is {getSecondWord phrase}"

// The example displays the following output:
//    Second word is blue
//    Second word is citizen
//
//    Unhandled Exception: System.ArgumentOutOfRangeException: StartIndex cannot be less than zero. (Parameter 'startIndex')
//       at System.String.Substring(Int32 startIndex, Int32 length)
//       at System.String.Substring(Int32 startIndex)
//       at NoFind1.getSecondWord(String s)
//       at <StartupCode$argumentoutofrangeexception>.$NoFind1.main@()

Module Example
   Public Sub Main()
      Dim phrases() As String = { "ocean blue", "concerned citizen", 
                                  "runOnPhrase" }
      For Each phrase In phrases
         Console.WriteLine("Second word is {0}", GetSecondWord(phrase))
      Next                            
  End Sub
  
  Function GetSecondWord(s As String) As String
     Dim pos As Integer = s.IndexOf(" ")
     Return s.Substring(pos).Trim()
  End Function
End Module
' The example displays the following output:
'       Second word is blue
'       Second word is citizen
'       
'       Unhandled Exception: System.ArgumentOutOfRangeException: StartIndex cannot be less than zero.
'       Parameter name: startIndex
'          at System.String.Substring(Int32 startIndex, Int32 length)
'          at Example.GetSecondWord(String s)
'          at Example.Main()

Per eliminare l'eccezione, convalidare il valore restituito dal metodo di ricerca di stringhe prima di chiamare il metodo di manipolazione delle stringhe.

using System;

public class Example18
{
   public static void Main()
   {
      String[] phrases = { "ocean blue", "concerned citizen",
                           "runOnPhrase" };
      foreach (var phrase in phrases) {
         string word = GetSecondWord(phrase);
         if (! string.IsNullOrEmpty(word))
            Console.WriteLine("Second word is {0}", word);
      }
   }

   static string GetSecondWord(string s)
   {
      int pos = s.IndexOf(" ");
      if (pos >= 0)
         return s.Substring(pos).Trim();
      else
         return string.Empty;
   }
}
// The example displays the following output:
//       Second word is blue
//       Second word is citizen

open System

let getSecondWord (s: string) =
    let pos = s.IndexOf " "
    if pos >= 0 then
        s.Substring(pos).Trim()
    else 
        String.Empty

let phrases = [ "ocean blue"; "concerned citizen"; "runOnPhrase" ]
for phrase in phrases do
    let word = getSecondWord phrase
    if not (String.IsNullOrEmpty word) then
        printfn $"Second word is {word}"

// The example displays the following output:
//       Second word is blue
//       Second word is citizen

Module Example
   Public Sub Main()
      Dim phrases() As String = { "ocean blue", "concerned citizen", 
                                  "runOnPhrase" }
      For Each phrase In phrases
         Dim word As String = GetSecondWord(phrase)
         If Not String.IsNullOrEmpty(word) Then _
            Console.WriteLine("Second word is {0}", word)
      Next                            
   End Sub
  
   Function GetSecondWord(s As String) As String
      Dim pos As Integer = s.IndexOf(" ")
      If pos >= 0
          Return s.Substring(pos).Trim()
      Else
         Return String.Empty
      End If
  End Function
End Module
' The example displays the following output:
'       Second word is blue
'       Second word is citizen

Si è tentato di estrarre una sottostringa esterna all'intervallo della stringa corrente.

I metodi che estraggono tutte le sottostringhe richiedono di specificare la posizione iniziale della sottostringa e, per le sottostringhe che non continuano alla fine della stringa, il numero di caratteri nella sottostringa. Si noti che questo non è l'indice dell'ultimo carattere nella sottostringa.

In ArgumentOutOfRangeException questo caso viene generata un'eccezione perché il numero di caratteri nella sottostringa è stato calcolato in modo non corretto. Se si usa un metodo di ricerca come String.IndexOf per identificare le posizioni iniziale e finale di una sottostringa:

Se il carattere nella posizione finale restituita da String.IndexOf deve essere incluso nella sottostringa, la posizione finale della sottostringa viene assegnata dalla formula
```
endIndex - startIndex + 1
```

Se il carattere nella posizione finale restituita da String.IndexOf deve essere escluso dalla sottostringa, la posizione finale della sottostringa viene assegnata dalla formula

endIndex - startIndex

Nell'esempio seguente viene definito un FindWords metodo che usa il String.IndexOfAny(Char[], Int32) metodo per identificare caratteri di spazio e segni di punteggiatura in una stringa e restituisce una matrice contenente le parole trovate nella stringa.

using System;
using System.Collections.Generic;

public class Example19
{
   public static void Main()
   {
      string sentence = "This is a simple, short sentence.";
      Console.WriteLine("Words in '{0}':", sentence);
      foreach (var word in FindWords(sentence))
         Console.WriteLine("   '{0}'", word);
   }

   static String[] FindWords(string s)
   {
      int start = 0, end = 0;
      Char[] delimiters = { ' ', '.', ',', ';', ':', '(', ')' };
      var words = new List<string>();

      while (end >= 0) {
         end = s.IndexOfAny(delimiters, start);
         if (end >= 0) {
            if (end - start > 0)
               words.Add(s.Substring(start, end - start));

            start = end + 1;
         }
         else {
            if (start < s.Length - 1)
               words.Add(s.Substring(start));
         }
      }
      return words.ToArray();
   }
}
// The example displays the following output:
//       Words in 'This is a simple, short sentence.':
//          'This'
//          'is'
//          'a'
//          'simple'
//          'short'
//          'sentence'


let findWords (s: string) =
    let mutable start, end' = 0, 0
    let delimiters = [| ' '; '.'; ','; ';'; ':'; '('; ')' |]
    let words = ResizeArray<string>()
    while end' >= 0 do
        end' <- s.IndexOfAny(delimiters, start)
        if end' >= 0 then
            if end' - start > 0 then
                words.Add(s.Substring(start, end' - start))
            start <- end' + 1
        elif start < s.Length - 1 then
            words.Add(s.Substring start)
    words.ToArray()

let sentence = "This is a simple, short sentence."
printfn $"Words in '{sentence}':"
for word in findWords sentence do
    printfn $"   '{word}'"

// The example displays the following output:
//       Words in 'This is a simple, short sentence.':
//          'This'
//          'is'
//          'a'
//          'simple'
//          'short'
//          'sentence'

Imports System.Collections.Generic

Module Example
   Public Sub Main()
      Dim sentence As String = "This is a simple, short sentence."
      Console.WriteLine("Words in '{0}':", sentence)
      For Each word In FindWords(sentence)
         Console.WriteLine("   '{0}'", word)
      Next
   End Sub
   
   Function FindWords(s As String) As String()
      Dim start, ending As Integer
      Dim delimiters() As Char = { " "c, "."c, ","c, ";"c, ":"c,
                                   "("c, ")"c }
      Dim words As New List(Of String)()

      Do While ending >= 0
         ending = s.IndexOfAny(delimiters, start)
         If ending >= 0
            If ending - start > 0 Then
               words.Add(s.Substring(start, ending - start)) 
            End If
            start = ending + 1
         Else
            If start < s.Length - 1 Then
               words.Add(s.Substring(start))
            End If      
         End If
      Loop    
      Return words.ToArray()                         
   End Function
End Module
' The example displays the following output:
'       Words in 'This is a simple, short sentence.':
'          'This'
'          'is'
'          'a'
'          'simple'
'          'short'
'          'sentence'

È stato passato un numero negativo a un metodo con un argomento che richiede solo numeri positivi e zero oppure è stato passato un numero negativo o zero a un metodo con un argomento che richiede solo numeri positivi.

Ad esempio, il Array.CreateInstance(Type, Int32, Int32, Int32) metodo richiede di specificare il numero di elementi in ogni dimensione di una matrice bidimensionale. I valori validi per ogni dimensione possono variare da 0 a Int32.MaxValue. Tuttavia, poiché l'argomento dimensione nell'esempio seguente ha un valore negativo, il metodo genera un'eccezione ArgumentOutOfRangeException .

using System;

public class Example01
{
    public static void Main()
    {
        int dimension1 = 10;
        int dimension2 = -1;
        try
        {
            Array arr = Array.CreateInstance(typeof(string),
                                             dimension1, dimension2);
        }
        catch (ArgumentOutOfRangeException e)
        {
            if (e.ActualValue != null)
                Console.WriteLine("{0} is an invalid value for {1}: ", e.ActualValue, e.ParamName);
            Console.WriteLine(e.Message);
        }
    }
}
// The example displays the following output:
//     Non-negative number required.
//     Parameter name: length2

open System

let dimension1 = 10
let dimension2 = -1
try
    let arr = Array.CreateInstance(typeof<string>, dimension1, dimension2)
    printfn "%A" arr
with 
| :? ArgumentOutOfRangeException as e ->
    if not (isNull e.ActualValue) then
        printfn $"{e.ActualValue} is an invalid value for {e.ParamName}: "
    printfn $"{e.Message}"

// The example displays the following output:
//     Non-negative number required. (Parameter 'length2')

Module Example
   Public Sub Main()
      Dim dimension1 As Integer = 10
      Dim dimension2 As Integer = -1
      Try
         Dim arr AS Array = Array.CreateInstance(GetType(String), 
                                                 dimension1, dimension2)
      Catch e As ArgumentOutOfRangeException
         If e.ActualValue IsNot Nothing Then
            Console.WriteLine("{0} is an invalid value for {1}: ", 
                              e.ActualValue, e.ParamName)
         End If                     
         Console.WriteLine(e.Message)
      End Try
   End Sub
End Module
' The example displays the following output:
'     Non-negative number required.
'     Parameter name: length2

Per correggere l'errore, verificare che il valore dell'argomento non valido sia non negativo. È possibile eseguire questa operazione specificando un valore valido, poiché il frammento di codice seguente esegue.

int dimension1 = 10;
int dimension2 = 10;
Array arr = Array.CreateInstance(typeof(string),
                                 dimension1, dimension2);

let dimension1 = 10
let dimension2 = 10
let arr = Array.CreateInstance(typeof<string>, dimension1, dimension2)
printfn "%A" arr

Dim dimension1 As Integer = 10
Dim dimension2 As Integer = 10
Dim arr As Array = Array.CreateInstance(GetType(String), 
                                        dimension1, dimension2)

È anche possibile convalidare l'input e, se non è valido, eseguire alcune azioni. Il frammento di codice seguente visualizza un messaggio di errore anziché chiamare il metodo.

if (dimension1 < 0 || dimension2 < 0)
{
    Console.WriteLine("Unable to create the array.");
    Console.WriteLine("Specify non-negative values for the two dimensions.");
}
else
{
    arr = Array.CreateInstance(typeof(string),
                               dimension1, dimension2);
}

if dimension1 < 0 || dimension2 < 0 then
    printfn "Unable to create the array."
    printfn "Specify non-negative values for the two dimensions."
else
    let arr = Array.CreateInstance(typeof<string>, dimension1, dimension2)
    printfn "%A" arr

If dimension1 < 0 OrElse dimension2 < 0 Then
   Console.WriteLine("Unable to create the array.")
   Console.WriteLine("Specify non-negative values for the two dimensions.")
Else
   arr = Array.CreateInstance(GetType(String), 
                              dimension1, dimension2)   
End If

Una condizione di razza esiste in un'app che è multithreading o ha attività che eseguono in modo asincrono e che aggiorna una matrice o una raccolta.

Nell'esempio seguente viene usato un oggetto per popolare una List<T> raccolta di Continent oggetti. Genera un valore ArgumentOutOfRangeException se l'esempio tenta di visualizzare i sette elementi della raccolta prima che l'insieme sia completamente popolato.

using System;
using System.Collections.Generic;
using System.Threading;

public class Continent
{
   public string? Name { get; set; }
   public int Population { get; set; }
   public Decimal Area { get; set; }
}

public class Example11
{
   static List<Continent> continents = new List<Continent>();
   static string? s_msg;

   public static void Main()
   {
      String[] names = { "Africa", "Antarctica", "Asia",
                         "Australia", "Europe", "North America",
                         "South America" };
      // Populate the list.
      foreach (var name in names) {
         var th = new Thread(PopulateContinents);
         th.Start(name);
      }
      Console.WriteLine(s_msg);
      Console.WriteLine();

      // Display the list.
      for (int ctr = 0; ctr < names.Length; ctr++) {
         var continent = continents[ctr];
         Console.WriteLine("{0}: Area: {1}, Population {2}",
                           continent.Name, continent.Population,
                           continent.Area);
      }
   }

   private static void PopulateContinents(Object? obj)
   {
      string? name = obj?.ToString();
      s_msg += string.Format("Adding '{0}' to the list.\n", name);
      var continent = new Continent();
      continent.Name = name;
      // Sleep to simulate retrieving remaining data.
      Thread.Sleep(50);
      continents.Add(continent);
   }
}
// The example displays output like the following:
//    Adding //Africa// to the list.
//    Adding //Antarctica// to the list.
//    Adding //Asia// to the list.
//    Adding //Australia// to the list.
//    Adding //Europe// to the list.
//    Adding //North America// to the list.
//    Adding //South America// to the list.
//
//
//
//    Unhandled Exception: System.ArgumentOutOfRangeException: Index was out of range. Must be non-negative and less than the size of the collection.
//    Parameter name: index
//       at System.ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument argument, ExceptionResource resource)
//       at Example.Main()

open System.Threading

type Continent =
    { Name: string
      Population: int
      Area: decimal }

let continents = ResizeArray<Continent>()
let mutable msg = ""

let names = 
    [ "Africa"; "Antarctica"; "Asia"
      "Australia"; "Europe"; "North America"
      "South America" ]

let populateContinents obj = 
    let name = string obj
    msg <- msg + $"Adding '{name}' to the list.\n"
    // Sleep to simulate retrieving data.
    Thread.Sleep 50
    let continent = 
        { Name = name
          Population = 0
          Area = 0M }
    continents.Add continent
      
// Populate the list.
for name in names do
    let th = Thread(ParameterizedThreadStart populateContinents)
    th.Start name
      
printfn $"{msg}\n"

// Display the list.
for i = 0 to names.Length - 1 do
    let continent = continents[i]
    printfn $"{continent.Name}: Area: {continent.Population}, Population {continent.Area}"

// The example displays output like the following:
//    Unhandled Exception: System.ArgumentOutOfRangeException: Index was out of range. Must be non-negative and less than the size of the collection. (Parameter 'index')
//       at System.Collections.Generic.List`1.get_Item(Int32 index)
//       at <StartupCode$argumentoutofrangeexception>.$Race1.main@()

Imports System.Collections.Generic
Imports System.Threading

Public Class Continent
   Public Property Name As String
   Public Property Population As Integer
   Public Property Area As Decimal  
End Class

Module Example
   Dim continents As New List(Of Continent)
   Dim msg As String 
      
   Public Sub Main()
      Dim names() As String = { "Africa", "Antarctica", "Asia", 
                                     "Australia", "Europe", "North America",
                                     "South America" }
      ' Populate the list.
      For Each name In names
         Dim th As New Thread(AddressOf PopulateContinents)
         th.Start(name)
      Next              
      Console.WriteLine(msg)
      Console.WriteLine()

      ' Display the list.
      For ctr As Integer = 0 To names.Length - 1
         Dim continent = continents(ctr)
         Console.WriteLine("{0}: Area: {1}, Population {2}", 
                           continent.Name, continent.Population,
                           continent.Area)
      Next
   End Sub
   
   Private Sub PopulateContinents(obj As Object)
      Dim name As String = obj.ToString()
      msg += String.Format("Adding '{0}' to the list.{1}", name, vbCrLf)
      Dim continent As New Continent()
      continent.Name = name
      ' Sleep to simulate retrieving remaining data.
      Thread.Sleep(50)
      continents.Add(continent)
   End Sub
End Module
' The example displays output like the following:
'    Adding 'Africa' to the list.
'    Adding 'Antarctica' to the list.
'    Adding 'Asia' to the list.
'    Adding 'Australia' to the list.
'    Adding 'Europe' to the list.
'    Adding 'North America' to the list.
'    Adding 'South America' to the list.
'    
'    
'    
'    Unhandled Exception: System.ArgumentOutOfRangeException: Index was out of range. Must be non-negative and less than the size of the collection.
'    Parameter name: index
'       at System.ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument argument, ExceptionResource resource)
'       at Example.Main()

In questo caso, due risorse vengono accessibili da più thread:

Raccolta continents. Il List<T>.Add metodo viene chiamato da più thread. Inoltre, il thread principale o primario presuppone che la raccolta sia completamente popolata con sette elementi quando esegue l'iterazione dei membri.
Stringa msg concatenata da più thread.

Per correggere l'errore, assicurarsi che lo stato condiviso sia accessibile in modo thread-safe, come indicato di seguito.

se l'app usa una matrice o un oggetto raccolta, prendere in considerazione l'uso di una classe di raccolta thread-safe, ad esempio i tipi nello System.Collections.Concurrent spazio dei nomi o nella System.Collections.Immutable versione out-of-band.
Assicurarsi che lo stato condiviso (ovvero le risorse a cui è possibile accedere da più thread) sia accessibile in modo thread sicuro, in modo che un solo thread alla volta abbia accesso esclusivo alle risorse. Un numero elevato di classi, ad esempio CountdownEvent, Interlocked, Monitore , Mutexsono disponibili per sincronizzare l'accesso alle risorse. Per altre informazioni, vedere Threading. Inoltre, il supporto del linguaggio è disponibile tramite l'istruzione lock in C# e il costrutto SyncLock in Visual Basic.

Nell'esempio seguente vengono risolti gli ArgumentOutOfRangeException altri problemi dell'esempio precedente. Sostituisce l'oggetto con un oggetto per garantire che l'accesso List<T> all'insieme sia thread-safe, usa un ConcurrentBag<T> oggetto per assicurarsi che il thread dell'applicazione continui solo dopo l'esecuzione di altri thread e usi un CountdownEvent blocco per garantire che solo un thread possa accedere alla msg variabile alla volta.

using System;
using System.Collections.Concurrent;
using System.Threading;

public class ContinentD
{
   public string? Name { get; set; }
   public int Population { get; set; }
   public Decimal Area { get; set; }
}

public class Example12
{
   static ConcurrentBag<ContinentD> ContinentDs = new ConcurrentBag<ContinentD>();
   static CountdownEvent? gate;
   static string msg = string.Empty;

   public static void Main()
   {
      String[] names = { "Africa", "Antarctica", "Asia",
                         "Australia", "Europe", "North America",
                         "South America" };
      gate = new CountdownEvent(names.Length);

      // Populate the list.
      foreach (var name in names) {
         var th = new Thread(PopulateContinentDs);
         th.Start(name);
      }

      // Display the list.
      gate.Wait();
      Console.WriteLine(msg);
      Console.WriteLine();

      var arr = ContinentDs.ToArray();
      for (int ctr = 0; ctr < names.Length; ctr++) {
         var ContinentD = arr[ctr];
         Console.WriteLine("{0}: Area: {1}, Population {2}",
                           ContinentD.Name, ContinentD.Population,
                           ContinentD.Area);
      }
   }

   private static void PopulateContinentDs(Object? obj)
   {
      string? name = obj?.ToString();
      lock(msg) {
         msg += string.Format("Adding '{0}' to the list.\n", name);
      }
      var ContinentD = new ContinentD();
      ContinentD.Name = name;
      // Sleep to simulate retrieving remaining data.
      Thread.Sleep(25);
      ContinentDs.Add(ContinentD);
      gate?.Signal();
   }
}
// The example displays output like the following:
//       Adding 'Africa' to the list.
//       Adding 'Antarctica' to the list.
//       Adding 'Asia' to the list.
//       Adding 'Australia' to the list.
//       Adding 'Europe' to the list.
//       Adding 'North America' to the list.
//       Adding 'South America' to the list.
//
//
//       Africa: Area: 0, Population 0
//       Antarctica: Area: 0, Population 0
//       Asia: Area: 0, Population 0
//       Australia: Area: 0, Population 0
//       Europe: Area: 0, Population 0
//       North America: Area: 0, Population 0
//       South America: Area: 0, Population 0

open System.Collections.Concurrent
open System.Threading

type Continent =
    { Name: string
      Population: int
      Area: decimal }

let continents = ConcurrentBag<Continent>();
let mutable msg = ""

let names = 
    [ "Africa"; "Antarctica"; "Asia"
      "Australia"; "Europe"; "North America"
      "South America" ]

let gate = new CountdownEvent(names.Length)

let populateContinents obj = 
    let name = string obj
    lock msg (fun () -> 
        msg <- msg + $"Adding '{name}' to the list.\n" )

    // Sleep to simulate retrieving remaining data.
    let continent = 
        { Name = name
          Population = 0
          Area = 0M }
    Thread.Sleep 25
    continents.Add continent
    gate.Signal() |> ignore

// Populate the list.
for name in names do
    let th = Thread(ParameterizedThreadStart populateContinents)
    th.Start name

// Display the list.
gate.Wait();
printfn $"{msg}\n"

let arr = continents.ToArray();
for i = 0 to names.Length - 1 do
    let continent = arr[i]
    printfn $"{continent.Name}: Area: {continent.Population}, Population {continent.Area}"

// The example displays output like the following:
//       Adding 'Africa' to the list.
//       Adding 'Antarctica' to the list.
//       Adding 'Asia' to the list.
//       Adding 'Australia' to the list.
//       Adding 'Europe' to the list.
//       Adding 'North America' to the list.
//       Adding 'South America' to the list.
//
//
//       Africa: Area: 0, Population 0
//       Antarctica: Area: 0, Population 0
//       Asia: Area: 0, Population 0
//       Australia: Area: 0, Population 0
//       Europe: Area: 0, Population 0
//       North America: Area: 0, Population 0
//       South America: Area: 0, Population 0

Imports System.Collections.Concurrent
Imports System.Threading

Public Class Continent
   Public Property Name As String
   Public Property Population As Integer
   Public Property Area As Decimal  
End Class

Module Example
   Dim continents As New ConcurrentBag(Of Continent)
   Dim gate As CountdownEvent
   Dim msg As String = String.Empty
      
   Public Sub Main()
      Dim names() As String = { "Africa", "Antarctica", "Asia", 
                                "Australia", "Europe", "North America",
                                "South America" }
      gate = new CountdownEvent(names.Length)
      
      ' Populate the list.
      For Each name In names
         Dim th As New Thread(AddressOf PopulateContinents)
         th.Start(name)
      Next              

      ' Display the list.
      gate.Wait()
      Console.WriteLine(msg)
      Console.WriteLine()

      For ctr As Integer = 0 To names.Length - 1
         Dim continent = continents(ctr)
         Console.WriteLine("{0}: Area: {1}, Population {2}", 
                           continent.Name, continent.Population,
                           continent.Area)
      Next
   End Sub
   
   Private Sub PopulateContinents(obj As Object)
      Dim name As String = obj.ToString()
      SyncLock msg 
         msg += String.Format("Adding '{0}' to the list.{1}", name, vbCrLf)
      End SyncLock
      Dim continent As New Continent()
      continent.Name = name
      ' Sleep to simulate retrieving remaining data.
      Thread.Sleep(25)
      continents.Add(continent)
      gate.Signal()
   End Sub
End Module
' The example displays output like the following:
'    Adding 'Africa' to the list.
'    Adding 'Antarctica' to the list.
'    Adding 'Asia' to the list.
'    Adding 'Australia' to the list.
'    Adding 'Europe' to the list.
'    Adding 'North America' to the list.
'    Adding 'South America' to the list.
'    
'    
'    Africa: Area: 0, Population 0
'    Antarctica: Area: 0, Population 0
'    Asia: Area: 0, Population 0
'    Australia: Area: 0, Population 0
'    Europe: Area: 0, Population 0
'    North America: Area: 0, Population 0
'    South America: Area: 0, Population 0

ArgumentOutOfRangeException usa il COR_E_ARGUMENTOUTOFRANGE HRESULT, che ha il valore 0x80131502.

Per un elenco di valori di proprietà iniziali per un'istanza di ArgumentOutOfRangeException, vedere il ArgumentOutOfRangeException costruttori.

Costruttori

ArgumentOutOfRangeException()	Inizializza una nuova istanza della classe ArgumentOutOfRangeException.
ArgumentOutOfRangeException(SerializationInfo, StreamingContext)	Obsoleti. Inizializza una nuova istanza della classe ArgumentOutOfRangeException con dati serializzati.
ArgumentOutOfRangeException(String)	Inizializza una nuova istanza della classe ArgumentOutOfRangeException con il nome del parametro che causa l'eccezione.
ArgumentOutOfRangeException(String, Exception)	Inizializza una nuova istanza della classe ArgumentOutOfRangeException con un messaggio di errore e l'eccezione che ha causato l'eccezione corrente.
ArgumentOutOfRangeException(String, Object, String)	Inizializza una nuova istanza della classe ArgumentOutOfRangeException con il nome del parametro, il valore dell'argomento e un messaggio di errore specificato.
ArgumentOutOfRangeException(String, String)	Inizializza una nuova istanza della classe ArgumentOutOfRangeException con il nome del parametro che causa l'eccezione e un messaggio di errore specificato.

Proprietà

ActualValue	Ottiene il valore dell'argomento che causa l'eccezione.
Data	Ottiene una raccolta di coppie chiave/valore che forniscono informazioni definite dall'utente aggiuntive sull'eccezione. (Ereditato da Exception)
HelpLink	Ottiene o imposta un collegamento al file della Guida associato all'eccezione. (Ereditato da Exception)
HResult	Ottiene o imposta HRESULT, un valore numerico codificato che viene assegnato a un'eccezione specifica. (Ereditato da Exception)
InnerException	Ottiene l'istanza di Exception che ha causato l'eccezione corrente. (Ereditato da Exception)
Message	Ottiene il messaggio di errore e la rappresentazione in forma di stringa del valore dell'argomento non valido, oppure solo del messaggio di errore se il valore dell'argomento è null.
ParamName	Ottiene il nome del parametro che ha causato questa eccezione. (Ereditato da ArgumentException)
Source	Ottiene o imposta il nome dell'oggetto o dell'applicazione che ha generato l'errore. (Ereditato da Exception)
StackTrace	Ottiene una rappresentazione di stringa dei frame immediati nello stack di chiamate. (Ereditato da Exception)
TargetSite	Ottiene il metodo che genera l'eccezione corrente. (Ereditato da Exception)

Metodi

Equals(Object)	Determina se l'oggetto specificato è uguale all'oggetto corrente. (Ereditato da Object)
GetBaseException()	Quando ne viene eseguito l'override in una classe derivata, restituisce l'Exception che è la causa radice di una o più eccezioni successive. (Ereditato da Exception)
GetHashCode()	Funge da funzione hash predefinita. (Ereditato da Object)
GetObjectData(SerializationInfo, StreamingContext)	Obsoleti. Imposta l'oggetto SerializationInfo con il valore dell'argomento non valido e le informazioni aggiuntive sull'eccezione.
GetObjectData(SerializationInfo, StreamingContext)	Obsoleti. Imposta l'oggetto SerializationInfo con il nome del parametro e informazioni aggiuntive sull'eccezione. (Ereditato da ArgumentException)
GetType()	Ottiene il tipo di runtime dell'istanza corrente. (Ereditato da Exception)
MemberwiseClone()	Crea una copia superficiale dell'oggetto Object corrente. (Ereditato da Object)
ThrowIfEqual<T>(T, T, String)	Genera un'eccezione ArgumentOutOfRangeException se `value` è uguale a `other`.
ThrowIfGreaterThan<T>(T, T, String)	Genera un'eccezione ArgumentOutOfRangeException se `value` è maggiore di `other`.
ThrowIfGreaterThanOrEqual<T>(T, T, String)	Genera un'eccezione ArgumentOutOfRangeException se `value` è maggiore o uguale a `other`.
ThrowIfLessThan<T>(T, T, String)	Genera un'eccezione ArgumentOutOfRangeException se `value` è minore di `other`.
ThrowIfLessThanOrEqual<T>(T, T, String)	Genera un'eccezione ArgumentOutOfRangeException se `value` è minore o uguale a `other`.
ThrowIfNegative<T>(T, String)	Genera un'eccezione ArgumentOutOfRangeException se `value` è negativa.
ThrowIfNegativeOrZero<T>(T, String)	Genera un'eccezione ArgumentOutOfRangeException se `value` è negativa o zero.
ThrowIfNotEqual<T>(T, T, String)	Genera un'eccezione ArgumentOutOfRangeException se `value` non è uguale a `other`.
ThrowIfZero<T>(T, String)	Genera un'eccezione ArgumentOutOfRangeException se `value` è zero.
ToString()	Crea e restituisce una rappresentazione di stringa dell'eccezione corrente. (Ereditato da Exception)

Eventi

SerializeObjectState

Obsoleti.

Si verifica quando un'eccezione viene serializzata per creare un oggetto di stato eccezione contenente i dati serializzati relativi all'eccezione.

(Ereditato da Exception)

Si applica a

Vedi anche

Exception

Condividi tramite