InvalidOperationException Classe
TOC
Recolher sumário
Expandir sumário
Este artigo foi traduzido por máquina. Para visualizar o arquivo em inglês, marque a caixa de seleção Inglês. Você também pode exibir o texto Em inglês em uma janela pop-up, movendo o ponteiro do mouse sobre o texto.
Tradução
Inglês

Classe InvalidOperationException

 

A exceção que é lançada quando um chamada de método é inválida para o estado atual do objeto.

Namespace:   System
Assembly:  mscorlib (em mscorlib.dll)


[SerializableAttribute]
[ComVisibleAttribute(true)]
public class InvalidOperationException : SystemException

NomeDescrição
System_CAPS_pubmethodInvalidOperationException()

Inicializa uma nova instância da classe InvalidOperationException.

System_CAPS_protmethodInvalidOperationException(SerializationInfo, StreamingContext)

Inicializa uma nova instância de InvalidOperationException classe com dados serializados.

System_CAPS_pubmethodInvalidOperationException(String)

Inicializa uma nova instância de InvalidOperationException classe com uma mensagem de erro especificada.

System_CAPS_pubmethodInvalidOperationException(String, Exception)

Inicializa uma nova instância de InvalidOperationException classe com uma mensagem de erro especificada e uma referência à exceção interna que é a causa dessa exceção.

NomeDescrição
System_CAPS_pubpropertyData

Obtém uma coleção de pares chave/valor que fornecem informações adicionais definidas pelo usuário sobre a exceção. (herdado de Exception.)

System_CAPS_pubpropertyHelpLink

Obtém ou define um link para o arquivo de ajuda associado a esta exceção.(herdado de Exception.)

System_CAPS_pubpropertyHResult

Obtém ou define HRESULT, um valor numérico codificado que é atribuído a uma exceção específica.(herdado de Exception.)

System_CAPS_pubpropertyInnerException

Obtém o Exception instância que causou a exceção atual.(herdado de Exception.)

System_CAPS_pubpropertyMessage

Recebe uma mensagem que descreve a exceção atual.(herdado de Exception.)

System_CAPS_pubpropertySource

Obtém ou define o nome do aplicativo ou do objeto que causa o erro. (herdado de Exception.)

System_CAPS_pubpropertyStackTrace

Obtém uma representação de cadeia de caracteres de quadros imediatos na pilha de chamadas.(herdado de Exception.)

System_CAPS_pubpropertyTargetSite

Obtém o método que gera a exceção atual.(herdado de Exception.)

NomeDescrição
System_CAPS_pubmethodEquals(Object)

Verifica se o objeto especificado é igual ao objeto atual. (herdado de Object.)

System_CAPS_protmethodFinalize()

Permite que um objeto tente liberar recursos e executar outras operações de limpeza antes que ele seja recuperado pela coleta de lixo. (herdado de Object.)

System_CAPS_pubmethodGetBaseException()

Quando substituído em uma classe derivada, retorna o Exception que é a causa raiz de um ou mais exceções subsequentes.(herdado de Exception.)

System_CAPS_pubmethodGetHashCode()

Serve como a função de hash padrão.(herdado de Object.)

System_CAPS_pubmethodGetObjectData(SerializationInfo, StreamingContext)

Quando substituído em uma classe derivada, define o SerializationInfo com informações sobre a exceção.(herdado de Exception.)

System_CAPS_pubmethodGetType()

Obtém o tipo em tempo de execução da instância atual. (herdado de Exception.)

System_CAPS_protmethodMemberwiseClone()

Cria uma cópia superficial do atual Object.(herdado de Object.)

System_CAPS_pubmethodToString()

Cria e retorna uma representação da cadeia de caracteres da exceção atual. (herdado de Exception.)

NomeDescrição
System_CAPS_proteventSerializeObjectState

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

InvalidOperationException é usado em casos quando a falha para chamar um método é causada por razões diferentes de argumentos inválidos. Normalmente, ela é lançada quando o estado de um objeto não oferece suporte para a chamada do método. Por exemplo, um InvalidOperationException exceção é lançada por métodos como:

  • IEnumerator.MoveNext Se os objetos de uma coleção são modificados depois que o enumerador é criado. Para obter mais informações, consulte Alterando uma coleção enquanto ele.

  • ResourceSet.GetString Se o conjunto de recursos for fechado antes da chamada de método é feita.

  • XContainer.Add, se um ou mais objetos a serem adicionados resultaria em um documento XML estruturado incorretamente.

  • Um método que tenta manipular a interface do usuário do thread de interface do usuário ou por um thread que não é o principal.

System_CAPS_importantImportante

Porque o InvalidOperationException exceção pode ser lançada em uma ampla variedade de circunstâncias, é importante ler a mensagem de exceção retornada pelo Message propriedade.

Nesta seção:

Algumas causas comuns de exceções InvalidOperationException
      Atualizando um thread de interface do usuário de um thread sem interface do usuário
      Alterando uma coleção enquanto ele
      Convertendo Nullable < T > Nulo para seu tipo subjacente 
      Chamando um método System.Linq.Enumerable em uma coleção vazia
      Chamar Enumerable ou LastOrDefault em uma seqüência sem um elemento
      Acesso de campo dinâmico entre domínios de aplicativo
Lançar uma exceção InvalidOperationException
Informações diversas

As seções a seguir mostram como algumas ocorrências no qual InvalidOperationException exceção é lançada em um aplicativo. Como tratar o problema depende da situação específica. Normalmente, no entanto, a exceção resulta de erros de desenvolvedor e o InvalidOperationException exceção pode ser prevista e evitada.

Muitas vezes, threads de trabalho são usados para executar um trabalho em segundo plano que envolve a coleta de dados a serem exibidos na interface do usuário do aplicativo. No entanto. a maioria das estruturas de aplicativo de GUI (interface gráfica do usuário) para o .NET Framework, como Windows Forms e Windows Presentation Foundation (WPF), permitem que você acesse objetos de GUI somente do thread que cria e gerencia a interface do usuário (o thread da interface do usuário ou principal). Um InvalidOperationException é lançada quando você tenta acessar um elemento de interface do usuário de um thread diferente do thread da interface do usuário. O texto da mensagem de exceção é mostrado na tabela a seguir.

Tipo de aplicativo

Mensagem

Aplicativo WPF

O thread de chamada não pode acessar este objeto porque possui um thread diferente.

Aplicativo UWP

O aplicativo chamado uma interface que foi tratada por um thread diferente.

Aplicativo do Windows Forms

Operação entre threads inválida: controle 'TextBox1' acessado de um thread diferente do thread que foi criado.

Estruturas de interface do usuário para o .NET Framework implementam um dispatcher padrão que inclui um método para verificar se uma chamada a um membro de um elemento de interface do usuário está sendo executada no thread da interface do usuário e outros métodos para agendar a chamada no thread da interface do usuário:

  • Em aplicativos WPF, chamar o Dispatcher.CheckAccess método para determinar se um método está sendo executado em um segmento sem interface do usuário. Retorna true se o método está sendo executado no thread da interface do usuário e false caso contrário. Chamar uma das sobrecargas do Dispatcher.Invoke método para agendar a chamada no thread da interface do usuário.

  • Em aplicativos UWP, chame o CoreDispatcher.HasThreadAccess método para determinar se um método está sendo executado em um segmento sem interface do usuário. Chamar o CoreDispatcher.RunAsync método para executar um delegado que atualiza o thread da interface do usuário. Use o comando

  • Em aplicativos de formulários do Windows, use o Control.InvokeRequired para determinar se um método está sendo executado em um segmento sem interface do usuário. Chamar uma das sobrecargas do Control.Invoke método para executar um delegado que atualiza o thread da interface do usuário.

Os exemplos a seguir ilustram o InvalidOperationException exceção que é lançada durante a tentativa de atualizar um elemento de interface do usuário de um thread diferente do thread que criou. Cada exemplo requer que você crie dois controles:

  • Um controle de caixa de texto denominado textBox1. Em um aplicativo Windows Forms, você deve definir seu Multiline propriedade true.

  • Um controle de botão chamado threadExampleBtn. O exemplo fornece um manipulador, ThreadsExampleBtn_Click, para o botão Click eventos.

Em cada caso, o threadExampleBtn_Click chamadas de manipulador de eventos de DoSomeWork método duas vezes. A primeira chamada é executado de forma síncrona e é bem-sucedida. Mas a segunda chamada, porque ele é executado assincronamente em um pool de threads, tente atualizar a interface do usuário de um thread sem interface do usuário. Isso resulta em um InvalidOperationException exceção.

Aplicativos WPF e UWP
private async void threadExampleBtn_Click(object sender, RoutedEventArgs e)
{
    textBox1.Text = String.Empty;

    textBox1.Text = "Simulating work on UI thread.\n";
    DoSomeWork(20);
    textBox1.Text += "Work completed...\n";

    textBox1.Text += "Simulating work on non-UI thread.\n";
    await Task.Run( () => DoSomeWork(1000));
    textBox1.Text += "Work completed...\n";
}

private async void DoSomeWork(int milliseconds)
{
    // Simulate work.
    await Task.Delay(milliseconds);

    // Report completion.
    var msg = String.Format("Some work completed in {0} ms.\n", milliseconds);
    textBox1.Text += msg;
}

A seguinte versão o DoSomeWork método elimina a exceção em um aplicativo WPF.

private async void DoSomeWork(int milliseconds)
{
    // Simulate work.
    await Task.Delay(milliseconds);

    // Report completion.
    bool uiAccess = textBox1.Dispatcher.CheckAccess();
    String msg = String.Format("Some work completed in {0} ms. on {1}UI thread\n",
                               milliseconds, uiAccess ? String.Empty : "non-");
    if (uiAccess)
        textBox1.Text += msg;
    else
        textBox1.Dispatcher.Invoke(() => { textBox1.Text += msg; });
}

A seguinte versão o DoSomeWork método elimina a exceção em um aplicativo UWP.

private async void DoSomeWork(int milliseconds)
{
    // Simulate work.
    await Task.Delay(milliseconds);

    // Report completion.
    bool uiAccess = textBox1.Dispatcher.HasThreadAccess;
    String msg = String.Format("Some work completed in {0} ms. on {1}UI thread\n",
                               milliseconds, uiAccess ? String.Empty : "non-");
    if (uiAccess)
        textBox1.Text += msg;
    else
        await textBox1.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { textBox1.Text += msg; });
}
Aplicativos do Windows Forms
List<String> lines = new List<String>();

private async void threadExampleBtn_Click(object sender, EventArgs e)
{
    textBox1.Text = String.Empty;
    lines.Clear();

    lines.Add("Simulating work on UI thread.");
    textBox1.Lines = lines.ToArray();
    DoSomeWork(20);

    lines.Add("Simulating work on non-UI thread.");
    textBox1.Lines = lines.ToArray();
    await Task.Run(() => DoSomeWork(1000));

    lines.Add("ThreadsExampleBtn_Click completes. ");
    textBox1.Lines = lines.ToArray();
}

private async void DoSomeWork(int milliseconds)
{
    // simulate work
    await Task.Delay(milliseconds);

    // report completion
    lines.Add(String.Format("Some work completed in {0} ms on UI thread.", milliseconds));
    textBox1.Lines = lines.ToArray();
}

A seguinte versão o DoSomeWork método elimina a exceção em um aplicativo Windows Forms.

private async void DoSomeWork(int milliseconds)
{
    // simulate work
    await Task.Delay(milliseconds);

    // Report completion.
    bool uiMarshal = textBox1.InvokeRequired;
    String msg = String.Format("Some work completed in {0} ms. on {1}UI thread\n",
                               milliseconds, uiMarshal ? String.Empty : "non-");
    lines.Add(msg);

    if (uiMarshal) {
        textBox1.Invoke(new Action(() => { textBox1.Lines = lines.ToArray(); }));
    }
    else {
        textBox1.Lines = lines.ToArray();
    }
}

O foreach instrução em c# ou For Each instrução no Visual Basic é usada para iterar os membros de uma coleção e para ler ou modificar os elementos individuais. No entanto, ele não pode ser usado para adicionar ou remover itens da coleção. Isso lança um InvalidOperationException exceção com uma mensagem semelhante a "coleção foi modificada; operação de enumeração não pode ser executada."

O exemplo a seguir itera que uma coleção de inteiros tenta adicionar o quadrado de cada inteiro à coleção. O exemplo gera um InvalidOperationException com a primeira chamada para o List<T>.Add método.

using System;
using System.Collections.Generic;

public class Example
{
   public static void Main()
   {
      var numbers = new List<int>() { 1, 2, 3, 4, 5 };
      foreach (var number in numbers) {
         int square = (int) Math.Pow(number, 2);
         Console.WriteLine("{0}^{1}", number, square);
         Console.WriteLine("Adding {0} to the collection...\n", square);
         numbers.Add(square);
      }
   }
}
// The example displays the following output:
//    1^1
//    Adding 1 to the collection...
//    
//    
//    Unhandled Exception: System.InvalidOperationException: Collection was modified; 
//       enumeration operation may not execute.
//       at System.ThrowHelper.ThrowInvalidOperationException(ExceptionResource resource)
//       at System.Collections.Generic.List`1.Enumerator.MoveNextRare()
//       at Example.Main()

Você pode eliminar a exceção em uma das duas maneiras, dependendo da lógica do seu aplicativo:

  • Se elementos devem ser adicionados à coleção iterá-lo, você pode iterá-lo usando o índice de for instrução em vez de foreach ou For Each. O exemplo a seguir usa a instrução adicionar a raiz dos números na coleção para a coleção.

    using System;
    using System.Collections.Generic;
    
    public class Example
    {
       public static void Main()
       {
          var numbers = new List<int>() { 1, 2, 3, 4, 5 };
    
          int upperBound = numbers.Count - 1;
          for (int ctr = 0; ctr <= upperBound; ctr++) {
             int square = (int) Math.Pow(numbers[ctr], 2);
             Console.WriteLine("{0}^{1}", numbers[ctr], square);
             Console.WriteLine("Adding {0} to the collection...\n", square);
             numbers.Add(square);
          }
    
          Console.WriteLine("Elements now in the collection: ");
          foreach (var number in numbers)
             Console.Write("{0}    ", number);
       }
    }
    // The example displays the following output:
    //    1^1
    //    Adding 1 to the collection...
    //    
    //    2^4
    //    Adding 4 to the collection...
    //    
    //    3^9
    //    Adding 9 to the collection...
    //    
    //    4^16
    //    Adding 16 to the collection...
    //    
    //    5^25
    //    Adding 25 to the collection...
    //    
    //    Elements now in the collection:
    //    1    2    3    4    5    1    4    9    16    25
    

    Observe que você deve estabelecer o número de iterações antes da iteração da coleção usando um contador de loop que será encerrado appropraitely loop, fazendo a iteração para trás, de Count - 1 para 0, ou, como o exemplo faz, atribuindo o número de elementos na matriz em uma variável e usá-lo para estabelecer o limite superior do loop. Caso contrário, se um elemento é adicionado à coleção em cada iteração, ocorrerá um loop infinito.

  • Se não for necessário para adicionar elementos à coleção iterá-lo, você pode armazenar os elementos a serem adicionados em uma coleção temporária que você adicionar ao iterar a coleção terminou. O exemplo a seguir usa essa abordagem para adicionar o quadrado de números em uma coleção para um conjunto temporário e, em seguida, combinar as coleções em um único objeto de matriz.

    using System;
    using System.Collections.Generic;
    
    public class Example
    {
       public static void Main()
       {
          var numbers = new List<int>() { 1, 2, 3, 4, 5 };
          var temp = new List<int>();
    
          // Square each number and store it in a temporary collection.
          foreach (var number in numbers) {
             int square = (int) Math.Pow(number, 2);
             temp.Add(square);
          }
    
          // Combine the numbers into a single array.
          int[] combined = new int[numbers.Count + temp.Count];
          Array.Copy(numbers.ToArray(), 0, combined, 0, numbers.Count);
          Array.Copy(temp.ToArray(), 0, combined, numbers.Count, temp.Count);
    
          // Iterate the array.
          foreach (var value in combined)
             Console.Write("{0}    ", value);
       }
    }
    // The example displays the following output:
    //       1    2    3    4    5    1    4    9    16    25
    

A tentativa de converter um Nullable<T> valor que é null para seu tipo subjacente lança um InvalidOperationException exceção e exibe a mensagem de erro "objeto nulo deve ter um valor.

O exemplo a seguir gera um InvalidOperationException exceção quando tentar repetir uma matriz que inclui um Nullable(Of Integer) valor.

using System;
using System.Linq;

public class Example
{
   public static void Main()
   {
      var queryResult = new int?[] { 1, 2, null, 4 };
      var map = queryResult.Select(nullableInt => (int)nullableInt);

      // Display list.
      foreach (var num in map)
         Console.Write("{0} ", num);
      Console.WriteLine();   
   }
}
// The example displays the following output:
//    1 2
//    Unhandled Exception: System.InvalidOperationException: Nullable object must have a value.
//       at System.ThrowHelper.ThrowInvalidOperationException(ExceptionResource resource)
//       at Example.<Main>b__0(Nullable`1 nullableInt)
//       at System.Linq.Enumerable.WhereSelectArrayIterator`2.MoveNext()
//       at Example.Main()

Para evitar a exceção:

O exemplo a seguir faz isso para evitar o InvalidOperationException exceção.

using System;
using System.Linq;

public class Example
{
   public static void Main()
   {
      var queryResult = new int?[] { 1, 2, null, 4 };
      var numbers = queryResult.Select(nullableInt => (int)nullableInt.GetValueOrDefault());

      // Display list using Nullable<int>.HasValue.
      foreach (var number in numbers)
         Console.Write("{0} ", number);
      Console.WriteLine();   

      numbers = queryResult.Select(nullableInt => (int) (nullableInt.HasValue ? nullableInt : -1));
      // Display list using Nullable<int>.GetValueOrDefault.
      foreach (var number in numbers)
         Console.Write("{0} ", number);
      Console.WriteLine();   
   }
}
// The example displays the following output:
//       1 2 0 4
//       1 2 -1 4

O Enumerable.Aggregate<TSource>, Enumerable.Average, Enumerable.First<TSource>, Enumerable.Last<TSource>, Enumerable.Max, Enumerable.Min, Enumerable.Single<TSource>, e Enumerable.SingleOrDefault<TSource> métodos executam operações em uma sequência e retornar um único resultado. Algumas sobrecargas desses métodos lançar um InvalidOperationException uma exceção quando a sequência está vazia, enquanto outras sobrecargas retornam null. O Enumerable.SingleOrDefault<TSource> também o método lança um InvalidOperationException uma exceção quando a sequência contém mais de um elemento.

System_CAPS_noteObservação

A maioria dos métodos que lançam uma InvalidOperationException exceção são sobrecargas. Certifique-se de que você compreender o comportamento da sobrecarga que você escolher.

A tabela a seguir lista as mensagens de exceção do InvalidOperationException objetos de exceção lançados por chamadas para alguns System.Linq.Enumerable métodos.

Método

Mensagem

Aggregate
Average
 Last
 Max
Min 

Sequência não contém elementos

First

Sequência não contém elementos correspondentes

Single
SingleOrDefault

A seqüência contém mais de um elemento de correspondência

Como eliminar ou tratar a exceção depende suposições do seu aplicativo e o método particular chamado.

Os exemplos fornecem detalhes adicionais.

O exemplo a seguir usa o Enumerable.Average método para calcular a média de uma sequência cujos valores são maiores que 4. Como nenhum valor da matriz original excede 4, valores não é incluído na seqüência e o método lança um InvalidOperationException exceção.

using System;
using System.Linq;

public class Example
{
   public static void Main()
   {
      int[] data = { 1, 2, 3, 4 };
      var average = data.Where(num => num > 4).Average();
      Console.Write("The average of numbers greater than 4 is {0}",
                    average);
   }
}
// The example displays the following output:
//    Unhandled Exception: System.InvalidOperationException: Sequence contains no elements
//       at System.Linq.Enumerable.Average(IEnumerable`1 source)
//       at Example.Main()

A exceção pode ser eliminada chamando o Any<TSource> método para determinar se a sequência contém elementos antes de chamar o método que processa a seqüência, como mostra o exemplo a seguir.

using System;
using System.Linq;

public class Example
{
   public static void Main()
   {
       int[] dbQueryResults = { 1, 2, 3, 4 };
       var moreThan4 = dbQueryResults.Where(num => num > 4);

       if(moreThan4.Any())
           Console.WriteLine("Average value of numbers greater than 4: {0}:", 
                             moreThan4.Average());
       else
           // handle empty collection 
           Console.WriteLine("The dataset has no values greater than 4.");
   }
}
// The example displays the following output:
//       The dataset has no values greater than 4.

O Enumerable.First<TSource> método retorna o primeiro item em uma seqüência ou o primeiro elemento em uma sequência que satisfazem uma condição especificada. Se a sequência está vazia e, portanto, não tem um elemento primeiro, ele lança um InvalidOperationException exceção.

No exemplo a seguir, o Enumerable.First<TSource>(IEnumerable<TSource>, Func<TSource, Boolean>) método lança um InvalidOperationException exceção porque a matriz de dbQueryResults não contém um elemento maior que 4.

using System;
using System.Linq;

public class Example
{
   public static void Main()
   {
      int[] dbQueryResults = { 1, 2, 3, 4 };

      var firstNum = dbQueryResults.First(n => n > 4);

      Console.WriteLine("The first value greater than 4 is {0}", 
                        firstNum);
   }
}
// The example displays the following output:
//    Unhandled Exception: System.InvalidOperationException: 
//       Sequence contains no matching element
//       at System.Linq.Enumerable.First[TSource](IEnumerable`1 source, Func`2 predicate)
//       at Example.Main()

Você pode chamar o Enumerable.FirstOrDefault<TSource> método em vez de Enumerable.First<TSource> para retornar um especificado ou o valor padrão. Se o método não encontrar um elemento primeiro na sequência, ele retorna o valor padrão para esse tipo de dados. O valor padrão é null para um tipo de referência, zero para um tipo de dados numéricos, e DateTime.MinValue para o DateTime tipo.

System_CAPS_noteObservação

Interpretando o valor retornado pelo Enumerable.FirstOrDefault<TSource> método geralmente é complicado pelo fato de que o valor padrão do tipo pode ser um valor válido na sequência. Nesse caso, é uma chamada a Enumerable.Any<TSource>método para determinar se a seqüência tem membros válidos antes de chamar o Enumerable.First<TSource> método.

A exemplo a seguir chama o Enumerable.FirstOrDefault<TSource>(IEnumerable<TSource>, Func<TSource, Boolean>) método para impedir que o InvalidOperationException exceção lançada no exemplo anterior.

using System;
using System.Linq;

public class Example
{
   public static void Main()
   {
      int[] dbQueryResults = { 1, 2, 3, 4 };

      var firstNum = dbQueryResults.FirstOrDefault(n => n > 4);

      if (firstNum == 0)
         Console.WriteLine("No value is greater than 4.");
      else   
         Console.WriteLine("The first value greater than 4 is {0}", 
                           firstNum);
   }
}
// The example displays the following output:
//       No value is greater than 4.

O Enumerable.Single<TSource> método retorna o único elemento de uma seqüência ou o único elemento de uma sequência que atende a uma condição especificada. Se não há nenhum elemento na sequência, ou se houver mais de um elemento, o método gerará uma InvalidOperationException exceção.

Você pode usar o Enumerable.SingleOrDefault<TSource> método retorne um valor padrão em vez de gerar uma exceção quando a sequência não contém elementos. No entanto, o Enumerable.SingleOrDefault<TSource> método ainda lança um InvalidOperationException uma exceção quando a sequência contém mais de um elemento.

A tabela a seguir lista as mensagens de exceção do InvalidOperationException objetos de exceção lançados por chamadas para o Enumerable.Single<TSource> e Enumerable.SingleOrDefault<TSource> métodos.

Método

Mensagem

Single 

Sequência não contém elementos correspondentes

Single
SingleOrDefault

A seqüência contém mais de um elemento de correspondência

No exemplo a seguir, a chamada para o Enumerable.Single<TSource> método lança um InvalidOperationException exceção como a sequência não tem um elemento maior que 4.

using System;
using System.Linq;

public class Example
{
   public static void Main()
   {
       int[] dbQueryResults = { 1, 2, 3, 4 };

       var singleObject = dbQueryResults.Single(value => value > 4);

       // Display results.
       Console.WriteLine("{0} is the only value greater than 4", singleObject);
   }
}
// The example displays the following output:
//    Unhandled Exception: System.InvalidOperationException: 
//       Sequence contains no matching element
//       at System.Linq.Enumerable.Single[TSource](IEnumerable`1 source, Func`2 predicate)
//       at Example.Main()

O exemplo a seguir tenta evitar que o InvalidOperationException exceção lançada quando uma sequência é vazia em vez disso, chamando o Enumerable.SingleOrDefault<TSource> método. No entanto, como essa seqüência retorna vários elementos cujo valor é maior que 2, ele também gera um InvalidOperationException exceção.

using System;
using System.Linq;

public class Example
{
   public static void Main()
   {
       int[] dbQueryResults = { 1, 2, 3, 4 };

       var singleObject = dbQueryResults.SingleOrDefault(value => value > 2);

       if (singleObject != 0)
           Console.WriteLine("{0} is the only value greater than 2", 
                             singleObject);
       else
           // Handle an empty collection.
           Console.WriteLine("No value is greater than 2");
   }
}
// The example displays the following output:
//    Unhandled Exception: System.InvalidOperationException: 
//       Sequence contains more than one matching element
//       at System.Linq.Enumerable.SingleOrDefault[TSource](IEnumerable`1 source, Func`2 predicate)
//       at Example.Main()

Chamar o Enumerable.Single<TSource> método pressupõe que uma sequência ou a sequência que atenda aos critérios especificados contém somente um elemento. Enumerable.SingleOrDefault<TSource> pressupõe uma sequência com zero ou um resultado, mas não mais. Se essa suposição é deliberada de sua parte, e essas condições não forem atendidas, relançamento ou captura resultante InvalidOperationException apropriado. Caso contrário, ou se você espera que condições inválidas ocorram com alguma frequência, você deve considerar usar algum outro Enumerable método, como FirstOrDefault<TSource> ou Where<TSource>.

O OpCodes.Ldflda Microsoft instrução intermediate language (MSIL) gera um InvalidOperationException exceção se o objeto que contém o campo cujo endereço que você está tentando recuperar não está dentro do domínio de aplicativo no qual o código está em execução. O endereço de um campo só pode ser acessado do domínio de aplicativo no qual ele reside.

Você deve lançar uma InvalidOperationException exceção apenas quando o estado de seu objeto por alguma razão não dá suporte a uma chamada de método específico. Ou seja, a chamada do método é válida em algumas circunstâncias ou contextos, mas não é válida em outros.

Se a falha da chamada de método é devido a argumentos inválidos, então ArgumentException ou uma de suas classes derivadas, ArgumentNullException ou ArgumentOutOfRangeException, deverá ser gerado.

InvalidOperationException usa o HRESULT COR_E_INVALIDOPERATION, que tem o valor 0x80131509.

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

Universal Windows Platform
Disponível desde 8
.NET Framework
Disponível desde 1.1
Portable Class Library
Com suporte em: portable .NET platforms
Silverlight
Disponível desde 2.0
Windows Phone Silverlight
Disponível desde 7.0
Windows Phone
Disponível desde 8.1

Qualquer estático público (Compartilhado no Visual Basic) membros desde tipo são thread safe. Não há garantia de que qualquer membro de instância seja thread-safe.

Retornar ao topo
Mostrar:
© 2016 Microsoft