InvalidOperationException Classe

Définition

Exception levée en cas d'appel de méthode non valide pour l'état actuel de l'objet.

public ref class InvalidOperationException : Exception
public ref class InvalidOperationException : SystemException
public class InvalidOperationException : Exception
public class InvalidOperationException : SystemException
[System.Serializable]
public class InvalidOperationException : SystemException
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public class InvalidOperationException : SystemException
type InvalidOperationException = class
    inherit Exception
type InvalidOperationException = class
    inherit SystemException
[<System.Serializable>]
type InvalidOperationException = class
    inherit SystemException
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type InvalidOperationException = class
    inherit SystemException
Public Class InvalidOperationException
Inherits Exception
Public Class InvalidOperationException
Inherits SystemException
Héritage
InvalidOperationException
Héritage
InvalidOperationException
Dérivé
Attributs

Remarques

InvalidOperationException est utilisé dans les cas où l’échec de l’appel d’une méthode est dû à des raisons autres que des arguments non valides. En général, elle est levée lorsque l’état d’un objet ne peut pas prendre en charge l’appel de méthode. Par exemple, une InvalidOperationException exception est levée par des méthodes telles que :

  • IEnumerator.MoveNext Si les objets d’une collection sont modifiés après la création de l’énumérateur. Pour plus d’informations, consultez modification d’une collection lorsde l’itération.

  • ResourceSet.GetString Si le jeu de ressources est fermé avant l’appel de la méthode.

  • XContainer.Add, si l’objet ou les objets à ajouter entraînent un document XML mal structuré.

  • Méthode qui tente de manipuler l’interface utilisateur à partir d’un thread qui n’est pas le thread principal ou le thread d’interface utilisateur.

Important

Étant donné que l' InvalidOperationException exception peut être levée dans une grande variété de circonstances, il est important de lire le message d’exception retourné par la Message propriété.

Dans cette section :

Causes courantes des exceptions InvalidOperationException
Mise à jour d’un thread d’interface utilisateur à partir d’un thread autre qu’un thread d’interface utilisateur
Modification d’une collection lors de son itération
Tri d’un tableau ou d’une collection dont les objets ne peuvent pas être comparés
Cast d’un < T Nullable > ayant la valeur null en son type sous-jacent
Appel d’une méthode System. Linq. Enumerable sur une collection vide
Appel de Enumerable. Single ou Enumerable. SingleOrDefault sur une séquence sans élément
Accès au champ de domaine d’application croisé dynamique
Levée d’une exception InvalidOperationException
Informations diverses

Causes courantes des exceptions InvalidOperationException

Les sections suivantes montrent les cas courants dans lesquels InvalidOperationException une exception est levée dans une application. La façon dont vous gérez le problème dépend de la situation spécifique. La plupart du temps, toutefois, l’exception résulte de l’erreur du développeur et l' InvalidOperationException exception peut être anticipée et évitée.

Mise à jour d’un thread d’interface utilisateur à partir d’un thread autre qu’un thread d’interface utilisateur

Souvent, les threads de travail sont utilisés pour effectuer des tâches en arrière-plan qui impliquent la collecte de données à afficher dans l’interface utilisateur d’une application. Toutefois, la plupart des infrastructures d’application de l’interface graphique utilisateur pour le .NET Framework, telles que Windows Forms et Windows Presentation Foundation (WPF), vous permettent d’accéder aux objets GUI uniquement à partir du thread qui crée et gère l’interface utilisateur (le thread principal ou le thread d’interface utilisateur). Une InvalidOperationException exception est levée lorsque vous essayez d’accéder à un élément d’interface utilisateur à partir d’un thread autre que le thread d’interface utilisateur. Le texte du message d’exception est indiqué dans le tableau suivant.

Type d’application Message
Application WPF Le thread appelant ne peut pas accéder à cet objet parce qu’un autre thread en est propriétaire.
Application UWP L’application a appelé une interface qui a été marshalée pour un thread différent.
Windows Application de formulaires Opération inter-threads non valide : le contrôle’TextBox1 'est accessible à partir d’un thread autre que le thread sur lequel il a été créé.

les infrastructures d’interface utilisateur pour le .NET Framework implémentent un modèle de répartiteur qui comprend une méthode pour vérifier si un appel à un membre d’un élément d’interface utilisateur est en cours d’exécution sur le thread d’interface utilisateur et d’autres méthodes pour planifier l’appel sur le thread d’interface utilisateur :

  • Dans les applications WPF, appelez la Dispatcher.CheckAccess méthode pour déterminer si une méthode s’exécute sur un thread qui n’est pas une interface utilisateur. Elle retourne true si la méthode s’exécute sur le thread d’interface utilisateur et dans le false cas contraire. Appelez l’une des surcharges de la Dispatcher.Invoke méthode pour planifier l’appel sur le thread d’interface utilisateur.

  • Dans les applications UWP, vérifiez la CoreDispatcher.HasThreadAccess propriété pour déterminer si une méthode est en cours d’exécution sur un thread autre qu’un thread d’interface utilisateur. Appelez la CoreDispatcher.RunAsync méthode pour exécuter un délégué qui met à jour le thread d’interface utilisateur.

  • dans Windows Forms applications, utilisez la Control.InvokeRequired propriété pour déterminer si une méthode s’exécute sur un thread non-interface utilisateur. Appelez l’une des surcharges de la Control.Invoke méthode pour exécuter un délégué qui met à jour le thread d’interface utilisateur.

Les exemples suivants illustrent l' InvalidOperationException exception qui est levée lorsque vous tentez de mettre à jour un élément d’interface utilisateur à partir d’un thread autre que le thread qui l’a créé. Chaque exemple requiert la création de deux contrôles :

  • Contrôle de zone de texte nommé textBox1 . dans une application Windows Forms, vous devez affecter à sa propriété la valeur Multiline true .

  • Contrôle Button nommé threadExampleBtn . L’exemple fournit un gestionnaire, ThreadsExampleBtn_Click , pour l’événement du bouton Click .

Dans chaque cas, le threadExampleBtn_Click Gestionnaire d’événements appelle la DoSomeWork méthode à deux reprises. Le premier appel s’exécute de façon synchrone et fonctionne. Mais le deuxième appel, parce qu’il s’exécute de façon asynchrone sur un thread de pool de threads, tente de mettre à jour l’interface utilisateur à partir d’un thread qui n’est pas une interface utilisateur. Cela entraîne une InvalidOperationException exception.

Applications WPF et 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;
}
Private Async Sub threadExampleBtn_Click(sender As Object, e As RoutedEventArgs) Handles threadExampleBtn.Click
    textBox1.Text = String.Empty

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

    textBox1.Text += "Simulating work on non-UI thread." + vbCrLf
    Await Task.Factory.StartNew(Sub()
                                    DoSomeWork(1000)
                                End Sub)
    textBox1.Text += "Work completed..." + vbCrLf
End Sub

Private Async Sub DoSomeWork(milliseconds As Integer)
    ' Simulate work.
    Await Task.Delay(milliseconds)

    ' Report completion.
    Dim msg = String.Format("Some work completed in {0} ms.", milliseconds) + vbCrLf
    textBox1.Text += msg
End Sub

La version suivante de la DoSomeWork méthode élimine l’exception dans une application 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; });
}
Private Async Sub DoSomeWork(milliseconds As Integer)
    ' Simulate work.
    Await Task.Delay(milliseconds)

    ' Report completion.
    Dim uiAccess As Boolean = textBox1.Dispatcher.CheckAccess()
    Dim msg As String = String.Format("Some work completed in {0} ms. on {1}UI thread",
                                      milliseconds, If(uiAccess, String.Empty, "non-")) + 
                                      vbCrLf 
    If uiAccess Then
        textBox1.Text += msg
    Else
        textBox1.Dispatcher.Invoke( Sub() textBox1.Text += msg)
    End If
End Sub

La version suivante de la DoSomeWork méthode élimine l’exception dans une application 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; });
}
Private Async Sub DoSomeWork(milliseconds As Integer)
    ' Simulate work.
    Await Task.Delay(milliseconds)

    ' Report completion.
    Dim uiAccess As Boolean = textBox1.Dispatcher.HasThreadAccess
    Dim msg As String = String.Format("Some work completed in {0} ms. on {1}UI thread" + vbCrLf,
                                      milliseconds, If(uiAccess, String.Empty, "non-"))
    If (uiAccess) Then
        textBox1.Text += msg
    Else
        Await textBox1.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, Sub() textBox1.Text += msg)
    End If
End Sub

Applications 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();
}
Dim lines As New List(Of String)()
Private Async Sub threadExampleBtn_Click(sender As Object, e As EventArgs) Handles threadExampleBtn.Click
    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(Sub() DoSomeWork(1000))

    lines.Add("ThreadsExampleBtn_Click completes. ")
    textBox1.Lines = lines.ToArray()
End Sub

Private Async Sub DoSomeWork(milliseconds As Integer)
    ' 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()
End Sub

la version suivante de la DoSomeWork méthode élimine l’exception dans une application 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();
    }
}
Private Async Sub DoSomeWork(milliseconds As Integer)
    ' Simulate work.
    Await Task.Delay(milliseconds)

    ' Report completion.
    Dim uiMarshal As Boolean = textBox1.InvokeRequired
    Dim msg As String = String.Format("Some work completed in {0} ms. on {1}UI thread" + vbCrLf,
                                      milliseconds, If(uiMarshal, String.Empty, "non-"))
    lines.Add(msg)

    If uiMarshal Then
        textBox1.Invoke(New Action(Sub() textBox1.Lines = lines.ToArray()))
    Else
        textBox1.Lines = lines.ToArray()
    End If
End Sub

Modification d’une collection lors de son itération

l' foreach instruction en C# ou l' For Each instruction Visual Basic permet d’itérer les membres d’une collection et de lire ou modifier ses éléments individuels. Toutefois, il ne peut pas être utilisé pour ajouter ou supprimer des éléments dans la collection. Cela lève une InvalidOperationException exception avec un message semblable à «la **collection a été modifiée ; l’opération d’énumération ne peut pas s’exécuter.**»

L’exemple suivant itère une collection d’entiers qui tente d’ajouter le carré de chaque entier à la collection. L’exemple lève une exception InvalidOperationException avec le premier appel à la List<T>.Add méthode.

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()
Imports System.Collections.Generic

Module Example
   Public Sub Main()
      Dim numbers As New List(Of Integer)( { 1, 2, 3, 4, 5 } )
      For Each number In numbers
         Dim square As Integer = CInt(Math.Pow(number, 2))
         Console.WriteLine("{0}^{1}", number, square)
         Console.WriteLine("Adding {0} to the collection..." + vbCrLf, 
                           square)
         numbers.Add(square)
      Next
   End Sub
End Module
' 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()

Vous pouvez éliminer l’exception de l’une des deux façons suivantes, en fonction de votre logique d’application :

  • Si les éléments doivent être ajoutés à la collection lors de l’itération, vous pouvez les itérer par index à l’aide for de l’instruction au lieu de foreach ou For Each . L’exemple suivant utilise l’instruction for pour ajouter le carré des nombres de la collection à la collection.

    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
    
    Imports System.Collections.Generic
    
    Module Example
       Public Sub Main()
          Dim numbers As New List(Of Integer)( { 1, 2, 3, 4, 5 } )
          Dim upperBound = numbers.Count - 1
    
          For ctr As Integer = 0 To upperBound
             Dim square As Integer = CInt(Math.Pow(numbers(ctr), 2))
             Console.WriteLine("{0}^{1}", numbers(ctr), square)
             Console.WriteLine("Adding {0} to the collection..." + vbCrLf, 
                               square)
             numbers.Add(square)
          Next
       
          Console.WriteLine("Elements now in the collection: ")
          For Each number In numbers
             Console.Write("{0}    ", number)
          Next   
       End Sub
    End Module
    ' 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
    

    Notez que vous devez établir le nombre d’itérations avant d’effectuer l’itération de la collection en utilisant un compteur à l’intérieur de la boucle qui quittera la boucle de manière appropriée, en effectuant une itération vers l’arrière, de Count -1 à 0, ou, comme l’illustre l’exemple, en assignant le nombre d’éléments du tableau à une variable et en l’utilisant pour établir la Sinon, si un élément est ajouté à la collection à chaque itération, une boucle sans fin est générée.

  • S’il n’est pas nécessaire d’ajouter des éléments à la collection lors de l’itération, vous pouvez stocker les éléments à ajouter dans une collection temporaire que vous ajoutez lorsque l’itération de la collection est terminée. L’exemple suivant utilise cette approche pour ajouter le carré des nombres d’une collection à une collection temporaire, puis pour combiner les collections en un objet de tableau unique.

    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
    
    Imports System.Collections.Generic
    
    Module Example
       Public Sub Main()
          Dim numbers As New List(Of Integer)( { 1, 2, 3, 4, 5 } )
          Dim temp As New List(Of Integer)()
          
          ' Square each number and store it in a temporary collection.
          For Each number In numbers
             Dim square As Integer = CInt(Math.Pow(number, 2))
             temp.Add(square)
          Next
        
          ' Combine the numbers into a single array.
          Dim combined(numbers.Count + temp.Count - 1) As Integer 
          Array.Copy(numbers.ToArray(), 0, combined, 0, numbers.Count)
          Array.Copy(temp.ToArray(), 0, combined, numbers.Count, temp.Count)
          
          ' Iterate the array.
          For Each value In combined
             Console.Write("{0}    ", value)
          Next
       End Sub
    End Module
    ' The example displays the following output:
    '       1    2    3    4    5    1    4    9    16    25
    

Tri d’un tableau ou d’une collection dont les objets ne peuvent pas être comparés

Les méthodes de tri à usage général, telles que la Array.Sort(Array) méthode ou la List<T>.Sort() méthode, requièrent généralement qu’au moins l’un des objets à trier implémente l' IComparable<T> IComparable interface ou. Si ce n’est pas le cas, la collection ou le tableau ne peut pas être trié, et la méthode lève une InvalidOperationException exception. L’exemple suivant définit une Person classe, stocke deux Person objets dans un List<T> objet générique et tente de les trier. Comme le montre la sortie de l’exemple, l’appel à la List<T>.Sort() méthode lève une InvalidOperationException .

using System;
using System.Collections.Generic;

public class Person
{
   public Person(String fName, String lName)
   {
      FirstName = fName;
      LastName = lName;
   }

   public String FirstName { get; set; }
   public String LastName { get; set; }
}

public class Example
{
   public static void Main()
   {
      var people = new List<Person>();

      people.Add(new Person("John", "Doe"));
      people.Add(new Person("Jane", "Doe"));
      people.Sort();
      foreach (var person in people)
         Console.WriteLine("{0} {1}", person.FirstName, person.LastName);
   }
}
// The example displays the following output:
//    Unhandled Exception: System.InvalidOperationException: Failed to compare two elements in the array. --->
//       System.ArgumentException: At least one object must implement IComparable.
//       at System.Collections.Comparer.Compare(Object a, Object b)
//       at System.Collections.Generic.ArraySortHelper`1.SwapIfGreater(T[] keys, IComparer`1 comparer, Int32 a, Int32 b)
//       at System.Collections.Generic.ArraySortHelper`1.DepthLimitedQuickSort(T[] keys, Int32 left, Int32 right, IComparer`1 comparer, Int32 depthLimit)
//       at System.Collections.Generic.ArraySortHelper`1.Sort(T[] keys, Int32 index, Int32 length, IComparer`1 comparer)
//       --- End of inner exception stack trace ---
//       at System.Collections.Generic.ArraySortHelper`1.Sort(T[] keys, Int32 index, Int32 length, IComparer`1 comparer)
//       at System.Array.Sort[T](T[] array, Int32 index, Int32 length, IComparer`1 comparer)
//       at System.Collections.Generic.List`1.Sort(Int32 index, Int32 count, IComparer`1 comparer)
//       at Example.Main()
Imports System.Collections.Generic

Public Class Person
   Public Sub New(fName As String, lName As String)
      FirstName = fName
      LastName = lName
   End Sub
   
   Public Property FirstName As String
   Public Property LastName As String
End Class

Module Example
   Public Sub Main()
      Dim people As New List(Of Person)()
      
      people.Add(New Person("John", "Doe"))
      people.Add(New Person("Jane", "Doe"))
      people.Sort()
      For Each person In people
         Console.WriteLine("{0} {1}", person.FirstName, person.LastName)
      Next
   End Sub
End Module
' The example displays the following output:
'    Unhandled Exception: System.InvalidOperationException: Failed to compare two elements in the array. ---> 
'       System.ArgumentException: At least one object must implement IComparable.
'       at System.Collections.Comparer.Compare(Object a, Object b)
'       at System.Collections.Generic.ArraySortHelper`1.SwapIfGreater(T[] keys, IComparer`1 comparer, Int32 a, Int32 b)
'       at System.Collections.Generic.ArraySortHelper`1.DepthLimitedQuickSort(T[] keys, Int32 left, Int32 right, IComparer`1 comparer, Int32 depthLimit)
'       at System.Collections.Generic.ArraySortHelper`1.Sort(T[] keys, Int32 index, Int32 length, IComparer`1 comparer)
'       --- End of inner exception stack trace ---
'       at System.Collections.Generic.ArraySortHelper`1.Sort(T[] keys, Int32 index, Int32 length, IComparer`1 comparer)
'       at System.Array.Sort[T](T[] array, Int32 index, Int32 length, IComparer`1 comparer)
'       at System.Collections.Generic.List`1.Sort(Int32 index, Int32 count, IComparer`1 comparer)
'       at Example.Main()

Vous pouvez éliminer l’exception de l’une des trois façons suivantes :

  • Si vous pouvez posséder le type que vous essayez de trier (autrement dit, si vous contrôlez son code source), vous pouvez le modifier pour implémenter l' IComparable<T> interface ou IComparable . Pour cela, vous devez implémenter la IComparable<T>.CompareTo CompareTo méthode ou. L’ajout d’une implémentation d’interface à un type existant n’est pas une modification avec rupture.

    L’exemple suivant utilise cette approche pour fournir une IComparable<T> implémentation de la Person classe. Vous pouvez toujours appeler la méthode de tri générale de la collection ou du tableau et, comme le montre la sortie de l’exemple, la collection est correctement triée.

    using System;
    using System.Collections.Generic;
    
    public class Person : IComparable<Person>
    {
       public Person(String fName, String lName)
       {
          FirstName = fName;
          LastName = lName;
       }
    
       public String FirstName { get; set; }
       public String LastName { get; set; }
    
       public int CompareTo(Person other)
       {
          return String.Format("{0} {1}", LastName, FirstName).
                 CompareTo(String.Format("{0} {1}", other.LastName, other.FirstName));
       }
    }
    
    public class Example
    {
       public static void Main()
       {
          var people = new List<Person>();
    
          people.Add(new Person("John", "Doe"));
          people.Add(new Person("Jane", "Doe"));
          people.Sort();
          foreach (var person in people)
             Console.WriteLine("{0} {1}", person.FirstName, person.LastName);
       }
    }
    // The example displays the following output:
    //       Jane Doe
    //       John Doe
    
    Imports System.Collections.Generic
    
    Public Class Person : Implements IComparable(Of Person)
       Public Sub New(fName As String, lName As String)
          FirstName = fName
          LastName = lName
       End Sub
       
       Public Property FirstName As String
       Public Property LastName As String
       
       Public Function CompareTo(other As Person) As Integer _
              Implements IComparable(Of Person).CompareTo
          Return String.Format("{0} {1}", LastName, FirstName).
                CompareTo(String.Format("{0} {1}", other.LastName, other.FirstName))    
       End Function
    End Class
    
    Module Example
       Public Sub Main()
          Dim people As New List(Of Person)()
          
          people.Add(New Person("John", "Doe"))
          people.Add(New Person("Jane", "Doe"))
          people.Sort()
          For Each person In people
             Console.WriteLine("{0} {1}", person.FirstName, person.LastName)
          Next
       End Sub
    End Module
    ' The example displays the following output:
    '       Jane Doe
    '       John Doe
    
  • Si vous ne pouvez pas modifier le code source pour le type que vous essayez de trier, vous pouvez définir une classe de tri à usage spécifique qui implémente l' IComparer<T> interface. Vous pouvez appeler une surcharge de la Sort méthode qui comprend un IComparer<T> paramètre. Cette approche est particulièrement utile si vous souhaitez développer une classe de tri spécialisée qui peut trier des objets en fonction de plusieurs critères.

    L’exemple suivant utilise l’approche en développant une PersonComparer classe personnalisée qui est utilisée pour trier les Person Collections. Il passe ensuite une instance de cette classe à la List<T>.Sort(IComparer<T>) méthode.

    using System;
    using System.Collections.Generic;
    
    public class Person
    {
       public Person(String fName, String lName)
       {
          FirstName = fName;
          LastName = lName;
       }
    
       public String FirstName { get; set; }
       public String LastName { get; set; }
    }
    
    public class PersonComparer : IComparer<Person>
    {
       public int Compare(Person x, Person y)
       {
          return String.Format("{0} {1}", x.LastName, x.FirstName).
                 CompareTo(String.Format("{0} {1}", y.LastName, y.FirstName));
       }
    }
    
    public class Example
    {
       public static void Main()
       {
          var people = new List<Person>();
    
          people.Add(new Person("John", "Doe"));
          people.Add(new Person("Jane", "Doe"));
          people.Sort(new PersonComparer());
          foreach (var person in people)
             Console.WriteLine("{0} {1}", person.FirstName, person.LastName);
       }
    }
    // The example displays the following output:
    //       Jane Doe
    //       John Doe
    
    Imports System.Collections.Generic
    
    Public Class Person
       Public Sub New(fName As String, lName As String)
          FirstName = fName
          LastName = lName
       End Sub
       
       Public Property FirstName As String
       Public Property LastName As String
    End Class
    
    Public Class PersonComparer : Implements IComparer(Of Person)
       Public Function Compare(x As Person, y As Person) As Integer _
              Implements IComparer(Of Person).Compare
          Return String.Format("{0} {1}", x.LastName, x.FirstName).
                 CompareTo(String.Format("{0} {1}", y.LastName, y.FirstName))    
       End Function       
    End Class
    
    Module Example
       Public Sub Main()
          Dim people As New List(Of Person)()
          
          people.Add(New Person("John", "Doe"))
          people.Add(New Person("Jane", "Doe"))
          people.Sort(New PersonComparer())
          For Each person In people
             Console.WriteLine("{0} {1}", person.FirstName, person.LastName)
          Next
       End Sub
    End Module
    ' The example displays the following output:
    '       Jane Doe
    '       John Doe
    
  • Si vous ne pouvez pas modifier le code source pour le type que vous essayez de trier, vous pouvez créer un Comparison<T> délégué pour effectuer le tri. La signature du délégué est

    Function Comparison(Of T)(x As T, y As T) As Integer  
    
    int Comparison<T>(T x, T y)  
    

    L’exemple suivant utilise l’approche en définissant une PersonComparison méthode qui correspond à la Comparison<T> signature du délégué. Il passe ensuite ce délégué à la List<T>.Sort(Comparison<T>) méthode.

    using System;
    using System.Collections.Generic;
    
    public class Person
    {
       public Person(String fName, String lName)
       {
          FirstName = fName;
          LastName = lName;
       }
    
       public String FirstName { get; set; }
       public String LastName { get; set; }
    }
    
    public class Example
    {
       public static void Main()
       {
          var people = new List<Person>();
    
          people.Add(new Person("John", "Doe"));
          people.Add(new Person("Jane", "Doe"));
          people.Sort(PersonComparison);
          foreach (var person in people)
             Console.WriteLine("{0} {1}", person.FirstName, person.LastName);
       }
    
       public static int PersonComparison(Person x, Person y)
       {
          return String.Format("{0} {1}", x.LastName, x.FirstName).
                 CompareTo(String.Format("{0} {1}", y.LastName, y.FirstName));
       }
    }
    // The example displays the following output:
    //       Jane Doe
    //       John Doe
    
    Imports System.Collections.Generic
    
    Public Class Person
       Public Sub New(fName As String, lName As String)
          FirstName = fName
          LastName = lName
       End Sub
       
       Public Property FirstName As String
       Public Property LastName As String
    End Class
    
    Module Example
       Public Sub Main()
          Dim people As New List(Of Person)()
          
          people.Add(New Person("John", "Doe"))
          people.Add(New Person("Jane", "Doe"))
          people.Sort(AddressOf PersonComparison)
          For Each person In people
             Console.WriteLine("{0} {1}", person.FirstName, person.LastName)
          Next
       End Sub
       
       Public Function PersonComparison(x As Person, y As Person) As Integer
          Return String.Format("{0} {1}", x.LastName, x.FirstName).
                 CompareTo(String.Format("{0} {1}", y.LastName, y.FirstName))    
       End Function
    End Module
    ' The example displays the following output:
    '       Jane Doe
    '       John Doe
    

Conversion d’un Nullable <T> qui a la valeur null en son type sous-jacent

Toute tentative d’effectuer un cast d’une Nullable<T> valeur null en son type sous-jacent lève une InvalidOperationException exception et affiche le message d’erreur «l'objet Nullable doit avoir une valeur.

L’exemple suivant lève une InvalidOperationException exception lorsqu’il tente d’itérer un tableau qui comprend une Nullable(Of Integer) valeur.

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()
Imports System.Linq

Module Example
   Public Sub Main()
      Dim queryResult = New Integer?() { 1, 2, Nothing, 4 }
      Dim map = queryResult.Select(Function(nullableInt) CInt(nullableInt))
      
      ' Display list.
      For Each num In map
         Console.Write("{0} ", num)
      Next
      Console.WriteLine()   
   End Sub
End Module
' The example displays thIe 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()

Pour éviter l’exception :

L’exemple suivant effectue les deux pour éviter l' InvalidOperationException exception.

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
Imports System.Linq

Module Example
   Public Sub Main()
      Dim queryResult = New Integer?() { 1, 2, Nothing, 4 }
      Dim numbers = queryResult.Select(Function(nullableInt) _ 
                                          CInt(nullableInt.GetValueOrDefault()))
      ' Display list.
      For Each number In numbers
         Console.Write("{0} ", number)
      Next
      Console.WriteLine()
      
      ' Use -1 to indicate a missing values.
      numbers = queryResult.Select(Function(nullableInt) _   
                                      CInt(If(nullableInt.HasValue, nullableInt, -1)))
      ' Display list.
      For Each number In numbers
         Console.Write("{0} ", number)
      Next
      Console.WriteLine()
                                      
   End Sub
End Module
' The example displays the following output:
'       1 2 0 4
'       1 2 -1 4

Appel d’une méthode System. Linq. Enumerable sur une collection vide

Les Enumerable.Aggregate Enumerable.Average méthodes,, Enumerable.First ,,,, Enumerable.Last Enumerable.Max Enumerable.Min Enumerable.Single et Enumerable.SingleOrDefault effectuent des opérations sur une séquence et retournent un résultat unique. Certaines surcharges de ces méthodes lèvent une InvalidOperationException exception lorsque la séquence est vide, tandis que d’autres surcharges retournent null . La Enumerable.SingleOrDefault méthode lève également une InvalidOperationException exception lorsque la séquence contient plusieurs éléments.

Notes

La plupart des méthodes qui lèvent une InvalidOperationException exception sont des surcharges. Veillez à bien comprendre le comportement de la surcharge que vous choisissez.

Le tableau suivant répertorie les messages d’exception des InvalidOperationException objets exception levées par les appels à certaines System.Linq.Enumerable méthodes.

Méthode Message
Aggregate
Average
Last
Max
Min
La séquence ne contient aucun élément
First La séquence ne contient aucun élément correspondant
Single
SingleOrDefault
La séquence contient plusieurs éléments correspondants

La façon dont vous éliminez ou gérez l’exception dépend des hypothèses de votre application et de la méthode particulière que vous appelez.

  • Lorsque vous appelez délibérément l’une de ces méthodes sans vérifier la présence d’une séquence vide, vous supposez que la séquence n’est pas vide et qu’une séquence vide est un événement inattendu. Dans ce cas, le fait d’intercepter ou de lever à nouveau l’exception est approprié.

  • Si vous ne parvenez pas à rechercher une séquence vide, vous pouvez appeler l’une des surcharges de la Enumerable.Any surcharge pour déterminer si une séquence contient des éléments.

    Conseil

    L’appel de la Enumerable.Any<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) méthode avant la génération d’une séquence peut améliorer les performances si les données à traiter peuvent contenir un grand nombre d’éléments ou si l’opération qui génère la séquence est coûteuse.

  • Si vous avez appelé une méthode telle que Enumerable.First , Enumerable.Last ou Enumerable.Single , vous pouvez substituer une autre méthode, telle que Enumerable.FirstOrDefault , Enumerable.LastOrDefault ou Enumerable.SingleOrDefault , qui retourne une valeur par défaut au lieu d’un membre de la séquence.

Les exemples fournissent des détails supplémentaires.

L’exemple suivant utilise la Enumerable.Average méthode pour calculer la moyenne d’une séquence dont les valeurs sont supérieures à 4. Dans la mesure où aucune valeur du tableau d’origine ne dépasse 4, aucune valeur n’est incluse dans la séquence, et la méthode lève une InvalidOperationException exception.

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()
Imports System.Linq

Module Example
   Public Sub Main()
      Dim data() As Integer = { 1, 2, 3, 4 }
      Dim average = data.Where(Function(num) num > 4).Average()
      Console.Write("The average of numbers greater than 4 is {0}",
                    average)
   End Sub
End Module
' 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()

L’exception peut être éliminée en appelant la Any méthode pour déterminer si la séquence contient des éléments avant d’appeler la méthode qui traite la séquence, comme le montre l’exemple suivant.

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.
Imports System.Linq

Module Example
   Public Sub Main()
       Dim dbQueryResults() As Integer = { 1, 2, 3, 4 }
       Dim moreThan4 = dbQueryResults.Where(Function(num) num > 4)
   
       If moreThan4.Any() Then
           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.")
       End If    
   End Sub
End Module
' The example displays the following output:
'       The dataset has no values greater than 4.

La Enumerable.First méthode retourne le premier élément d’une séquence ou le premier élément d’une séquence qui satisfait à une condition spécifiée. Si la séquence est vide et n’a donc pas de premier élément, elle lève une InvalidOperationException exception.

Dans l’exemple suivant, la Enumerable.First<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) méthode lève une InvalidOperationException exception, car le tableau dbQueryResults ne contient pas d’élément supérieur à 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()
Imports System.Linq

Module Example
   Public Sub Main()
      Dim dbQueryResults() As Integer = { 1, 2, 3, 4 }

      Dim firstNum = dbQueryResults.First(Function(n) n > 4)

      Console.WriteLine("The first value greater than 4 is {0}", 
                        firstNum)
   End Sub
End Module
' 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()

Vous pouvez appeler la Enumerable.FirstOrDefault méthode à la place de Enumerable.First pour retourner une valeur spécifiée ou par défaut. Si la méthode ne trouve pas de premier élément dans la séquence, elle retourne la valeur par défaut de ce type de données. La valeur par défaut est null pour un type référence, zéro pour un type de données numérique et DateTime.MinValue pour le DateTime type.

Notes

L’interprétation de la valeur retournée par la Enumerable.FirstOrDefault méthode est souvent compliquée par le fait que la valeur par défaut du type peut être une valeur valide dans la séquence. Dans ce cas, vous appelez la Enumerable.Any méthode pour déterminer si la séquence a des membres valides avant d’appeler la Enumerable.First méthode.

L’exemple suivant appelle la Enumerable.FirstOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) méthode pour empêcher l' InvalidOperationException exception levée dans l’exemple précédent.

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.
Imports System.Linq

Module Example
   Public Sub Main()
      Dim dbQueryResults() As Integer = { 1, 2, 3, 4 }

      Dim firstNum = dbQueryResults.FirstOrDefault(Function(n) n > 4)

      If firstNum = 0 Then
         Console.WriteLIne("No value is greater than 4.")
      Else   
         Console.WriteLine("The first value greater than 4 is {0}", 
                           firstNum)
      End If                     
   End Sub
End Module
' The example displays the following output:
'       No value is greater than 4.

Appel de Enumerable. Single ou Enumerable. SingleOrDefault sur une séquence sans élément

La Enumerable.Single méthode retourne le seul élément d’une séquence ou le seul élément d’une séquence qui répond à une condition spécifiée. S’il n’y a aucun élément dans la séquence, ou s’il y a plusieurs éléments, la méthode lève une InvalidOperationException exception.

Vous pouvez utiliser la Enumerable.SingleOrDefault méthode pour retourner une valeur par défaut au lieu de lever une exception lorsque la séquence ne contient aucun élément. Toutefois, la Enumerable.SingleOrDefault méthode lève toujours une InvalidOperationException exception lorsque la séquence contient plusieurs éléments.

Le tableau suivant répertorie les messages d’exception des InvalidOperationException objets exception levées par les appels aux Enumerable.Single Enumerable.SingleOrDefault méthodes et.

Méthode Message
Single La séquence ne contient aucun élément correspondant
Single
SingleOrDefault
La séquence contient plusieurs éléments correspondants

Dans l’exemple suivant, l’appel à la Enumerable.Single méthode lève une InvalidOperationException exception, car la séquence n’a pas d’élément supérieur à 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()
Imports System.Linq

Module Example
   Public Sub Main()
       Dim dbQueryResults() As Integer = { 1, 2, 3, 4 }
   
       Dim singleObject = dbQueryResults.Single(Function(value) value > 4)
   
       ' Display results.
       Console.WriteLine("{0} is the only value greater than 4", 
                         singleObject)
   End Sub
End Module
' 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()

L’exemple suivant tente d’empêcher l' InvalidOperationException exception levée lorsqu’une séquence est vide au lieu d’appeler la Enumerable.SingleOrDefault méthode. Toutefois, étant donné que cette séquence retourne plusieurs éléments dont la valeur est supérieure à 2, elle lève également une InvalidOperationException exception.

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()
Imports System.Linq

Module Example
   Public Sub Main()
       Dim dbQueryResults() As Integer = { 1, 2, 3, 4 }
   
       Dim singleObject = dbQueryResults.SingleOrDefault(Function(value) value > 2)
   
       If singleObject <> 0 Then
           Console.WriteLine("{0} is the only value greater than 2", 
                             singleObject)
       Else
           ' Handle an empty collection.
           Console.WriteLine("No value is greater than 2")
       End If    
   End Sub
End Module
' 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()

L’appel de la Enumerable.Single méthode suppose qu’une séquence ou la séquence qui répond aux critères spécifiés contient un seul élément. Enumerable.SingleOrDefault suppose une séquence avec zéro ou un résultat, mais pas plus. Si cette hypothèse est une personne délibérée de votre part et que ces conditions ne sont pas remplies, la nouvelle levée ou l’interception du résultat InvalidOperationException est appropriée. Dans le cas contraire, ou si vous pensez que des conditions non valides se produiront avec une certaine fréquence, vous devez envisager d’utiliser une autre Enumerable méthode, telle que FirstOrDefault ou Where .

Accès au champ de domaine d’application croisé dynamique

L' OpCodes.Ldflda instruction MSIL (Microsoft Intermediate Language) lève une InvalidOperationException exception si l’objet contenant le champ dont vous essayez d’extraire l’adresse n’est pas dans le domaine d’application dans lequel votre code s’exécute. L’adresse d’un champ est accessible uniquement à partir du domaine d’application dans lequel il réside.

Levée d’une exception InvalidOperationException

Vous devez lever une InvalidOperationException exception uniquement lorsque l’état de votre objet pour une raison quelconque ne prend pas en charge un appel de méthode particulier. Autrement dit, l’appel de méthode est valide dans certaines circonstances ou certains contextes, mais n’est pas valide dans d’autres.

Si l’échec de l’appel de la méthode est dû à des arguments non valides, ou à l' ArgumentException une de ses classes dérivées, ArgumentNullException ou ArgumentOutOfRangeException doit être levée à la place.

Informations diverses

InvalidOperationException utilise le COR_E_INVALIDOPERATION HRESULT, qui a la valeur 0x80131509.

Pour obtenir la liste des valeurs initiales des propriétés d’une instance de InvalidOperationException, consultez le InvalidOperationException constructeurs.

Constructeurs

InvalidOperationException()

Initialise une nouvelle instance de la classe InvalidOperationException.

InvalidOperationException(SerializationInfo, StreamingContext)

Initialise une nouvelle instance de la classe InvalidOperationException avec des données sérialisées.

InvalidOperationException(String)

Initialise une nouvelle instance de la classe InvalidOperationException avec un message d'erreur spécifié.

InvalidOperationException(String, Exception)

Initialise une nouvelle instance de la classe InvalidOperationException avec un message d'erreur spécifié et une référence à l'exception interne ayant provoqué cette exception.

Propriétés

Data

Obtient une collection de paires clé/valeur qui fournissent des informations définies par l'utilisateur supplémentaires sur l'exception.

(Hérité de Exception)
HelpLink

Obtient ou définit un lien vers le fichier d'aide associé à cette exception.

(Hérité de Exception)
HResult

Obtient ou définit HRESULT, valeur numérique codée qui est assignée à une exception spécifique.

(Hérité de Exception)
InnerException

Obtient l'instance Exception qui a provoqué l'exception actuelle.

(Hérité de Exception)
Message

Obtient un message qui décrit l'exception active.

(Hérité de Exception)
Source

Obtient ou définit le nom de l'application ou de l'objet qui est à l'origine de l'erreur.

(Hérité de Exception)
StackTrace

Obtient une représentation sous forme de chaîne des frames immédiats sur la pile des appels.

(Hérité de Exception)
TargetSite

Obtient la méthode qui lève l'exception actuelle.

(Hérité de Exception)

Méthodes

Equals(Object)

Détermine si l'objet spécifié est égal à l'objet actuel.

(Hérité de Object)
GetBaseException()

En cas de substitution dans une classe dérivée, retourne la Exception qui est à l'origine d'une ou de plusieurs exceptions ultérieures.

(Hérité de Exception)
GetHashCode()

Fait office de fonction de hachage par défaut.

(Hérité de Object)
GetObjectData(SerializationInfo, StreamingContext)

En cas de substitution dans une classe dérivée, définit SerializationInfo avec des informations sur l'exception.

(Hérité de Exception)
GetType()

Obtient le type au moment de l'exécution de l'instance actuelle.

(Hérité de Exception)
MemberwiseClone()

Crée une copie superficielle du Object actuel.

(Hérité de Object)
ToString()

Crée et retourne une chaîne représentant l'exception actuelle.

(Hérité de Exception)

Événements

SerializeObjectState
Obsolète.

Se produit quand une exception est sérialisée pour créer un objet d'état d'exception qui contient des données sérialisées concernant l'exception.

(Hérité de Exception)

S’applique à

Voir aussi