ArgumentOutOfRangeException Classe

Definição

Namespace:

System

Assembly:

System.Runtime.dll

Origem:

ArgumentOutOfRangeException.cs

A exceção que é gerada quando o valor de um argumento está fora do intervalo permitido de valores conforme definido pelo método invocado.

C#

public class ArgumentOutOfRangeException : ArgumentException

Herança

Object

Exception

SystemException

ArgumentException

ArgumentOutOfRangeException

Exemplos

O exemplo a seguir define uma classe para conter informações sobre um convidado convidado. Se o convidado tiver menos de 21 anos, uma exceção ArgumentOutOfRangeException será lançada.

C#

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}";
}

Comentários

Uma ArgumentOutOfRangeException exceção é gerada quando um método é invocado e pelo menos um dos argumentos passados para o método não null é e contém um valor inválido que não é um membro do conjunto de valores esperados para o argumento. A ParamName propriedade identifica o argumento inválido e a ActualValue propriedade, se um valor estiver presente, identifica o valor inválido.

Normalmente, um ArgumentOutOfRangeException resultado do erro do desenvolvedor. Em vez de lidar com a exceção em um try/catch bloco, você deve eliminar a causa da exceção ou, se o argumento for retornado por uma chamada de método ou entrada pelo usuário antes de ser passado para o método que gera a exceção, você deve validar os argumentos antes de passá-los para o método .

ArgumentOutOfRangeException é usado extensivamente por:

• Classes nos System.Collections namespaces e System.IO .

• A classe Array.

• Métodos de manipulação de cadeia de caracteres na String classe .

As condições nas quais uma exceção ArgumentOutOfRangeException é gerada incluem o seguinte:

• Você está recuperando o membro de uma coleção pelo número de índice e o número de índice é inválido.

  Essa é a causa mais comum de uma exceção ArgumentOutOfRangeException . Normalmente, o número do índice é inválido por um dos quatro motivos:

  1. A coleção não tem membros e seu código pressupõe que sim. O exemplo a seguir tenta recuperar o primeiro elemento de uma coleção que não tem elementos:

     C#

     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
     

     Para evitar a exceção, marcar se a propriedade da Count coleção é maior que zero antes de tentar recuperar membros, como o fragmento de código a seguir faz.

     C#

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

  2. Em alguns casos, a exceção pode ocorrer porque você está tentando adicionar um membro a uma coleção usando um índice que não existe, em vez de chamar o método , como Add, que existe para essa finalidade. O exemplo a seguir tenta adicionar um elemento a uma coleção usando um índice inexistente em vez de chamar o List<T>.Add método .

     C#

     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()
     

     O fragmento de código a seguir corrige este erro:

     C#

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

  3. Você está tentando recuperar um item cujo índice é negativo. Isso geralmente ocorre porque você pesquisou o índice de um elemento específico em uma coleção e presumiu erroneamente que a pesquisa foi bem-sucedida. No exemplo a seguir, a chamada para o List<T>.FindIndex(Predicate<T>) método falha ao localizar uma cadeia de caracteres igual a "Z" e, portanto, retorna -1. No entanto, esse é um valor de índice inválido.

     C#

     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
     

     Para evitar a exceção, marcar que a pesquisa foi bem-sucedida, certificando-se de que o índice retornado é maior ou igual a zero antes de tentar recuperar o item da coleção, como o fragmento de código a seguir faz.

     C#

     // 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]);
     

  4. Você está tentando recuperar um elemento cujo índice é igual ao valor da propriedade da Count coleção, como ilustra o exemplo a seguir.

     C#

     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
     

     Como as coleções no .NET usam indexação baseada em zero, o primeiro elemento da coleção está no índice 0 e o último elemento está no índice Count - 1. Você pode eliminar o erro garantindo que você acesse o último elemento no índice Count - 1, como o código a seguir faz.

     C#

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

• Você está tentando executar uma operação de cadeia de caracteres chamando um método de manipulação de cadeia de caracteres e o índice inicial não existe na cadeia de caracteres.

  Sobrecargas de métodos como String.Compare, , String.CompareOrdinal, String.IndexOf, String.InsertIndexOfAny, String.LastIndexOf, String.LastIndexOfAny, , Removeou String.Substring que permitem especificar o índice inicial da operação exigem que o índice seja uma posição válida dentro da cadeia de caracteres. Os índices válidos variam de 0 a String.Length 1.

  Há quatro causas comuns dessa exceção ArgumentOutOfRangeException:

  1. Você está trabalhando com uma cadeia de caracteres vazia, ou String.Empty. Como sua propriedade String.Length retorna 0, qualquer tentativa de manipulá-la pelo índice lança uma exceção ArgumentOutOfRangeException. O exemplo a seguir define um método GetFirstCharacter que retorna o primeiro caractere de uma cadeia de caracteres. Se a cadeia de caracteres estiver vazia, como a cadeia de caracteres final passada para o método está, o método gerará uma exceção ArgumentOutOfRangeException.

     C#

     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()
     

     Você pode eliminar a exceção testando se a cadeia de caracteres String.Length é maior que zero ou chamando o método IsNullOrEmpty para garantir que a cadeia de caracteres não é null nem está vazia. O fragmento de código a seguir faz o último. Nesse caso, se a cadeia de caracteres é null ou está vazia, o método GetFirstCharacter retorna U+0000.

     C#

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

  2. Você está manipulando uma cadeia de caracteres com base na posição de uma subcadeia de caracteres dentro dessa cadeia de caracteres e não conseguiu determinar se a subcadeia de caracteres foi realmente encontrada.

     O exemplo a seguir extrai a segunda palavra de uma frase de duas palavras. Ele gerará uma exceção ArgumentOutOfRangeException se a frase consistir em apenas uma palavra e, portanto, não contiver um caractere de espaço inserido. Isso ocorre porque a chamada para o String.IndexOf(String) método retorna -1 para indicar que a pesquisa falhou e esse valor inválido é então passado para o String.Substring(Int32) método .

     C#

     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()
     

     Para eliminar a exceção, valide o valor retornado pelo método de pesquisa de cadeia de caracteres antes de chamar o método de manipulação de cadeia de caracteres.

     C#

     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
     

  3. Você tentou extrair uma subcadeia de caracteres que está fora do intervalo da cadeia de caracteres atual.

     Os métodos que extraem subcadeias de caracteres exigem que você especifique a posição inicial da subcadeia de caracteres e, para subcadeias de caracteres que não continuam até o final da cadeia de caracteres, o número de caracteres na subcadeia de caracteres. Observe que esse não é o índice do último caractere na subcadeia de caracteres.

     Normalmente ArgumentOutOfRangeException , uma exceção é gerada nesse caso porque você calculou incorretamente o número de caracteres na subcadeia de caracteres. Se você estiver usando um método de pesquisa como String.IndexOf para identificar as posições inicial e final de uma subcadeia de caracteres:

     • Se o caractere na posição final retornada por String.IndexOf for incluído na subcadeia de caracteres, a posição final da subcadeia de caracteres será fornecida pela fórmula

       endIndex - startIndex + 1
       

     • Se o caractere na posição final retornada por String.IndexOf for excluído da subcadeia de caracteres, a posição final da subcadeia de caracteres será fornecida pela fórmula

       endIndex - startIndex
       

       O exemplo a seguir define um FindWords método que usa o String.IndexOfAny(Char[], Int32) método para identificar caracteres de espaço e marcas de pontuação em uma cadeia de caracteres e retorna uma matriz que contém as palavras encontradas na cadeia de caracteres.

       C#

       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'
       

• Você passou um número negativo para um método com um argumento que requer apenas números positivos e zero ou passou um número negativo ou zero para um método com um argumento que requer apenas números positivos.

  Por exemplo, o Array.CreateInstance(Type, Int32, Int32, Int32) método requer que você especifique o número de elementos em cada dimensão de uma matriz bidimensional; os valores válidos para cada dimensão podem variar de 0 a Int32.MaxValue. Mas como o argumento de dimensão no exemplo a seguir tem um valor negativo, o método gera uma exceção ArgumentOutOfRangeException .

  C#

  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
  

  Para corrigir o erro, verifique se o valor do argumento inválido não é negativo. Você pode fazer isso fornecendo um valor válido, como o fragmento de código a seguir faz.

  C#

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

  Você também pode validar a entrada e, se ela for inválida, executar alguma ação. O fragmento de código a seguir exibe uma mensagem de erro em vez de chamar o método .

  C#

  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);
  }
  

• Existe uma condição de corrida em um aplicativo multithread ou que tem tarefas que são executadas de forma assíncrona e que atualiza uma matriz ou coleção.

  O exemplo a seguir usa um List<T> objeto para preencher uma coleção de Continent objetos. Ele gerará um ArgumentOutOfRangeException se o exemplo tentar exibir os sete itens na coleção antes que a coleção seja totalmente preenchida.

  C#

  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()
  

  Nesse caso, dois recursos são acessados de vários threads:

  • A coleção continents. Seu List<T>.Add método é chamado de vários threads. Além disso, o thread main ou primário pressupõe que a coleção seja totalmente preenchida com sete elementos quando itera seus membros.

  • A msg cadeia de caracteres, que é concatenada de vários threads.

  Para corrigir o erro, verifique se o estado compartilhado é acessado de maneira thread-safe, da seguinte maneira.

  • se o aplicativo usar uma matriz ou objeto de coleção, considere usar uma classe de coleção thread-safe, como os tipos no System.Collections.Concurrent namespace ou a System.Collections.Immutable versão fora de banda.

  • Verifique se o estado compartilhado (ou seja, recursos que podem ser acessados por vários threads) é acessado de forma thread-safe, de modo que apenas um thread por vez tenha acesso exclusivo aos recursos. Um grande número de classes, como CountdownEvent, Interlocked, Monitore Mutex, estão disponíveis para sincronizar o acesso aos recursos. Para obter mais informações, consulte Threading. Além disso, o suporte ao idioma está disponível por meio da instrução lock em C# e do constructo SyncLock no Visual Basic.

  O exemplo a seguir aborda o ArgumentOutOfRangeException e os outros problemas do exemplo anterior. Ele substitui o List<T> objeto por um ConcurrentBag<T> objeto para garantir que o acesso à coleção seja thread-safe, usa um CountdownEvent objeto para garantir que o thread do aplicativo continue somente após a execução de outros threads e use um bloqueio para garantir que apenas um thread possa acessar a msg variável por vez.

  C#

  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
  

ArgumentOutOfRangeException usa a COR_E_ARGUMENTOUTOFRANGE HRESULT, que tem o valor 0x80131502.

Para obter uma lista de valores de propriedade inicial para uma instância do ArgumentOutOfRangeException, consulte o ArgumentOutOfRangeException construtores.

Construtores

ArgumentOutOfRangeException()	Inicializa uma nova instância da classe ArgumentOutOfRangeException.
ArgumentOutOfRangeException(SerializationInfo, StreamingContext)	Obsoleto. Inicializa uma nova instância da classe ArgumentOutOfRangeException com dados serializados.
ArgumentOutOfRangeException(String)	Inicializa uma nova instância da classe ArgumentOutOfRangeException com o nome do parâmetro que causa essa exceção.
ArgumentOutOfRangeException(String, Exception)	Inicializa uma nova instância da classe ArgumentOutOfRangeException com uma mensagem de erro especificada e a exceção interna que é a causa desta exceção.
ArgumentOutOfRangeException(String, Object, String)	Inicializa uma nova instância da classe ArgumentOutOfRangeException com o nome do parâmetro, o valor do argumento e uma mensagem de erro especificada.
ArgumentOutOfRangeException(String, String)	Inicializa uma nova instância da classe ArgumentOutOfRangeException com o nome do parâmetro que causa essa exceção e uma mensagem de erro especificada.

Propriedades

ActualValue	Obtém o valor do argumento que causa essa exceção.
Data	Obtém uma coleção de pares de chave/valor que fornecem informações definidas pelo usuário adicionais sobre a exceção. (Herdado de Exception)
HelpLink	Obtém ou define um link para o arquivo de ajuda associado a essa exceção. (Herdado de Exception)
HResult	Obtém ou define HRESULT, um valor numérico codificado que é atribuído a uma exceção específica. (Herdado de Exception)
InnerException	Obtém a instância Exception que causou a exceção atual. (Herdado de Exception)
Message	Obtém a mensagem de erro e a representação de cadeia de caracteres do valor de argumento inválido ou apenas a mensagem de erro se o valor do argumento for nulo.
ParamName	Obtém o nome do parâmetro que causa essa exceção. (Herdado de ArgumentException)
Source	Obtém ou define o nome do aplicativo ou objeto que causa o erro. (Herdado de Exception)
StackTrace	Obtém uma representação de cadeia de caracteres de quadros imediatos na pilha de chamadas. (Herdado de Exception)
TargetSite	Obtém o método que gerou a exceção atual. (Herdado de Exception)

Métodos

Equals(Object)	Determina se o objeto especificado é igual ao objeto atual. (Herdado de Object)
GetBaseException()	Quando substituído em uma classe derivada, retorna a Exception que é a causa raiz de uma ou mais exceções subsequentes. (Herdado de Exception)
GetHashCode()	Serve como a função de hash padrão. (Herdado de Object)
GetObjectData(SerializationInfo, StreamingContext)	Obsoleto. Define o objeto SerializationInfo com o valor de argumento inválido e informações adicionais de exceção.
GetType()	Obtém o tipo de runtime da instância atual. (Herdado de Exception)
MemberwiseClone()	Cria uma cópia superficial do Object atual. (Herdado de Object)
ThrowIfEqual<T>(T, T, String)	Lança um ArgumentOutOfRangeException se value é igual a other.
ThrowIfGreaterThan<T>(T, T, String)	Lança um ArgumentOutOfRangeException se value for maior que other.
ThrowIfGreaterThanOrEqual<T>(T, T, String)	Lança um ArgumentOutOfRangeException se value for maior ou igual a other.
ThrowIfLessThan<T>(T, T, String)	Lança um ArgumentOutOfRangeException se value for menor que other.
ThrowIfLessThanOrEqual<T>(T, T, String)	Lança um ArgumentOutOfRangeException se value for menor ou igual a other.
ThrowIfNegative<T>(T, String)	Lança um ArgumentOutOfRangeException se value é negativo.
ThrowIfNegativeOrZero<T>(T, String)	Lança um ArgumentOutOfRangeException se value for negativo ou zero.
ThrowIfNotEqual<T>(T, T, String)	Lança um ArgumentOutOfRangeException se value não for igual a other.
ThrowIfZero<T>(T, String)	Lança um ArgumentOutOfRangeException se value for zero.
ToString()	Cria e retorna uma representação de cadeia de caracteres da exceção atual. (Herdado de Exception)

Eventos

SerializeObjectState

Obsoleto. Ocorre quando uma exceção é serializada para criar um objeto de estado de exceção que contém dados serializados sobre a exceção. (Herdado de Exception)

Aplica-se a

Confira também

• Exception