InvalidOperationException InvalidOperationException InvalidOperationException InvalidOperationException Class

Définition

Exception levée en cas d'appel de méthode non valide pour l'état actuel de l'objet.The exception that is thrown when a method call is invalid for the object's current state.

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

Remarques

InvalidOperationException est utilisé lorsque l’échec pour appeler une méthode est dû à des raisons autres que des arguments non valides.InvalidOperationException is used in cases when the failure to invoke a method is caused by reasons other than invalid arguments. En règle générale, elle est levée lorsque l’état d’un objet ne peut pas prendre en charge l’appel de méthode.Typically, it is thrown when the state of an object cannot support the method call. Par exemple, un InvalidOperationException exception est levée par les méthodes telles que :For example, an InvalidOperationException exception is thrown by methods such as:

Important

Étant donné que le InvalidOperationException exception peut être levée dans un large éventail de circonstances, il est important de lire le message d’exception retourné par la Message propriété.Because the InvalidOperationException exception can be thrown in a wide variety of circumstances, it is important to read the exception message returned by the Message property.

Dans cette section :In this section:

Certaines causes courantes des exceptions de InvalidOperationException Some common causes of InvalidOperationException exceptions
La mise à jour d’un thread d’interface utilisateur à partir d’un thread non-interface utilisateurUpdating a UI thread from a non-UI thread
Modification d’une collection lors de l’itération ilChanging a collection while iterating it
Tri d’un tableau ou une collection dont les objets ne peuvent pas être comparées.Sorting an array or collection whose objects cannot be compared
Conversion d’un type Nullable<T> qui a la valeur null en son type sous-jacent Casting a Nullable<T> that is null to its underlying type
Appeler une méthode System.Linq.Enumerable sur une collection videCalling a System.Linq.Enumerable method on an empty collection
L’appel Enumerable.Single ou Enumerable.SingleOrDefault sur une séquence sans un seul élémentCalling Enumerable.Single or Enumerable.SingleOrDefault on a sequence without one element
Accès aux champs de domaine d’applications croisées dynamiquesDynamic cross-application domain field access
Lever une exception InvalidOperationExceptionThrowing an InvalidOperationException exception
Informations diversesMiscellaneous information

Certaines causes courantes des exceptions de InvalidOperationExceptionSome common causes of InvalidOperationException exceptions

Les sections suivantes montrent comment certaines les cas courants dans lesquels dans InvalidOperationException exception est levée dans une application.The following sections show how some common cases in which in InvalidOperationException exception is thrown in an app. Façon dont vous gérez le problème dépend de la situation spécifique.How you handle the issue depends on the specific situation. En règle générale, toutefois, l’exception résulte de l’erreur de développement et le InvalidOperationException exception peut être anticipée et évitée.Most commonly, however, the exception results from developer error, and the InvalidOperationException exception can be anticipated and avoided.

La mise à jour d’un thread d’interface utilisateur à partir d’un thread non-interface utilisateurUpdating a UI thread from a non-UI thread

Souvent, les threads de travail sont utilisés pour exécuter des tâches en arrière-plan qui implique la collecte de données à afficher dans l’interface utilisateur d’une application.Often, worker threads are used to perform some background work that involves gathering data to be displayed in an application's user interface. Toutefois.However. la plupart des infrastructures d’application (l’interface graphique utilisateur) pour le .NET Framework, tels que Windows Forms et Windows Presentation Foundation (WPF), vous permettent d’accéder aux objets de l’interface graphique utilisateur uniquement à partir du thread qui crée et gère l’interface utilisateur (le thread principal ou de l’interface utilisateur).most GUI (graphical user interface) application frameworks for the .NET Framework, such as Windows Forms and Windows Presentation Foundation (WPF), let you access GUI objects only from the thread that creates and manages the UI (the Main or UI thread). Un InvalidOperationException 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.An InvalidOperationException is thrown when you try to access a UI element from a thread other than the UI thread. Le texte du message d’exception est affiché dans le tableau suivant.The text of the exception message is shown in the following table.

Type d'applicationApplication Type MessageMessage
Application WPFWPF app Le thread appelant ne peut pas accéder à cet objet, car un autre thread est propriétaire.The calling thread cannot access this object because a different thread owns it.
Application UWPUWP app L’application a appelé une interface qui était maintenue en ordre pour un thread différent.The application called an interface that was marshalled for a different thread.
Application de Windows FormsWindows Forms app Opération inter-threads non valide : le contrôle 'TextBox1' accédé à partir d’un thread autre que le thread de création.Cross-thread operation not valid: Control 'TextBox1' accessed from a thread other than the thread it was created on.

Infrastructures d’interface utilisateur pour le .NET Framework implémentent un répartiteur modèle qui inclut 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 autres méthodes permettant de planifier l’appel sur le thread d’interface utilisateur :UI frameworks for the .NET Framework implement a dispatcher pattern that includes a method to check whether a call to a member of a UI element is being executed on the UI thread, and other methods to schedule the call on the UI thread:

  • Dans les applications WPF, appelez le Dispatcher.CheckAccess méthode pour déterminer si une méthode est en cours d’exécution sur un thread non-interface utilisateur.In WPF apps, call the Dispatcher.CheckAccess method to determine if a method is running on a non-UI thread. Elle retourne true si la méthode s’exécute sur le thread d’interface utilisateur et false dans le cas contraire.It returns true if the method is running on the UI thread and false otherwise. Appelez une des surcharges de la Dispatcher.Invoke méthode permettant de planifier l’appel sur le thread d’interface utilisateur.Call one of the overloads of the Dispatcher.Invoke method to schedule the call on the UI thread.

  • Dans les applications UWP, appelez le CoreDispatcher.HasThreadAccess méthode pour déterminer si une méthode est en cours d’exécution sur un thread non-interface utilisateur.In UWP apps, call the CoreDispatcher.HasThreadAccess method to determine if a method is running on a non-UI thread. Appelez le CoreDispatcher.RunAsync méthode à exécuter un délégué qui met à jour le thread d’interface utilisateur.Call the CoreDispatcher.RunAsync method to execute a delegate that updates the UI thread. Utilisez la commandeUse the

  • Dans les applications Windows Forms, utilisez le Control.InvokeRequired propriété afin de déterminer si une méthode est en cours d’exécution sur un thread non-interface utilisateur.In Windows Forms apps, use the Control.InvokeRequired property to determine if a method is running on a non-UI thread. Appelez une des surcharges de la Control.Invoke méthode à exécuter un délégué qui met à jour le thread d’interface utilisateur.Call one of the overloads of the Control.Invoke method to execute a delegate that updates the UI thread.

Les exemples suivants illustrent le 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éée.The following examples illustrate the InvalidOperationException exception that is thrown when you attempt to update a UI element from a thread other than the thread that created it. Chaque exemple nécessite que vous créez deux contrôles :Each example requires that you create two controls:

  • Un contrôle de zone de texte nommé textBox1.A text box control named textBox1. Dans une application Windows Forms, vous devez définir ses Multiline propriété true.In a Windows Forms app, you should set its Multiline property to true.

  • Un contrôle bouton nommé threadExampleBtn.A button control named threadExampleBtn. L’exemple fournit un gestionnaire, ThreadsExampleBtn_Click, pour le bouton Click événement.The example provides a handler, ThreadsExampleBtn_Click, for the button's Click event.

Dans chaque cas, le threadExampleBtn_Click Gestionnaire d’événements appelle la DoSomeWork méthode deux fois.In each case, the threadExampleBtn_Click event handler calls the DoSomeWork method twice. Le premier appel s’exécute de façon synchrone et réussit.The first call runs synchronously and succeeds. Mais le deuxième appel, car il s’exécute en mode asynchrone sur un thread de pool, essaie de mettre à jour de l’interface utilisateur à partir d’un thread non-interface utilisateur.But the second call, because it runs asynchronously on a thread pool thread, attempts to update the UI from a non-UI thread. Il en résulte un InvalidOperationException exception.This results in a InvalidOperationException exception.

Applications WPF et UWPWPF and UWP apps

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.The following version of the DoSomeWork method eliminates the exception in a WPF app.

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.The following version of the DoSomeWork method eliminates the exception in a UWP app.

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 FormsWindows Forms apps

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.The following version of the DoSomeWork method eliminates the exception in a Windows Forms app.

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 l’itération ilChanging a collection while iterating it

Le foreach instruction en c# ou For Each instruction en Visual Basic est utilisée pour parcourir les membres d’une collection et pour lire ou modifier ses éléments individuels.The foreach statement in C# or For Each statement in Visual Basic is used to iterate the members of a collection and to read or modify its individual elements. Toutefois, il ne peut pas être utilisé pour ajouter ou supprimer des éléments de la collection.However, it can't be used to add or remove items from the collection. Cela lèverait une InvalidOperationException exception avec un message qui est similaire, «Collection a été modifiée ; opération d’énumération ne peut pas s’exécuter. "Doing this throws an InvalidOperationException exception with a message that is similar to, "Collection was modified; enumeration operation may not execute."

L’exemple suivant itère qu'une collection d’entiers tente d’ajouter le carré de chaque entier à la collection.The following example iterates a collection of integers attempts to add the square of each integer to the collection. L’exemple lève une InvalidOperationException avec le premier appel à la List<T>.Add (méthode).The example throws an InvalidOperationException with the first call to the List<T>.Add method.

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 deux manières, selon votre logique d’application :You can eliminate the exception in one of two ways, depending on your application logic:

  • Si les éléments doivent être ajoutés à la collection lors de l’itération à elle, vous pouvez le parcourir à l’aide des index le for instruction au lieu de foreach ou For Each.If elements must be added to the collection while iterating it, you can iterate it by index using the for statement instead of foreach or For Each. L’exemple suivant utilise la pour instruction à ajouter le carré des nombres dans la collection à la collection.The following example uses the for statement to add the square of numbers in the collection to the 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’itérer la collection à l’aide d’un compteur à l’intérieur de la boucle qui se termine la boucle appropraitely, en effectuant une itération vers l’arrière, à partir de Count - 1 à 0, ou, comme dans l’exemple, en assignant le nombre d’éléments dans le tableau à une variable et l’utiliser pour établir la limite supérieure de la boucle.Note that you must establish the number of iterations before iterating the collection either by using a counter inside the loop that will exit the loop appropraitely, by iterating backward, from Count - 1 to 0, or, as the example does, by assigning the number of elements in the array to a variable and using it to establish the upper bound of the loop. Sinon, si un élément est ajouté à la collection à chaque itération, une boucle sans fin les résultats.Otherwise, if an element is added to the collection on every iteration, an endless loop results.

  • Si elle n’est pas nécessaire d’ajouter des éléments à la collection pendant l’itération il, vous pouvez stocker les éléments à ajouter dans un regroupement temporaire que vous ajoutez lors de l’itération de la collection est terminée.If it is not necessary to add elements to the collection while iterating it, you can store the elements to be added in a temporary collection that you add when iterating the collection has finished. L’exemple suivant utilise cette approche pour ajouter le carré des nombres dans une collection à un regroupement temporaire, puis pour combiner les collections dans un objet tableau unique.The following example uses this approach to add the square of numbers in a collection to a temporary collection, and then to combine the collections into a single array object.

    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 une collection dont les objets ne peuvent pas être comparées.Sorting an array or collection whose objects cannot be compared

À usage général tri des méthodes, telles que la Array.Sort(Array) (méthode) ou le List<T>.Sort() (méthode), nécessitent généralement qu’au moins un des objets à trier implémenter le IComparable<T> ou le IComparable interface.General-purpose sorting methods, such as the Array.Sort(Array) method or the List<T>.Sort() method, usually require that at least one of the objects to be sorted implement the IComparable<T> or the IComparable interface. Si non, la collection ou un tableau ne peuvent pas être trié, et la méthode lève un InvalidOperationException exception.If not, the collection or array cannot be sorted, and the method throws an InvalidOperationException exception. L’exemple suivant définit un Person classe stocke deux Person objets dans un modèle générique List<T> objet et tente de les trier.The following example defines a Person class, stores two Person objects in a generic List<T> object, and attempts to sort them. Comme la sortie de l’exemple, l’appel à la List<T>.Sort() méthode lève un InvalidOperationException.As the output from the example shows, the call to the List<T>.Sort() method throws an 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 dans une des trois manières :You can eliminate the exception in any of three ways:

  • Si vous pouvez être propriétaire du type que vous essayez de trier (autrement dit, si vous contrôler son code source), vous pouvez le modifier pour implémenter le IComparable<T> ou IComparable interface.If you can own the type that you are trying to sort (that is, if you control its source code), you can modify it to implement the IComparable<T> or the IComparable interface. Cela nécessite que vous implémentez soit le IComparable<T>.CompareTo ou le CompareTo (méthode).This requires that you implement either the IComparable<T>.CompareTo or the CompareTo method. Ajout d’une implémentation d’interface à un type existant n’est pas une modification avec rupture.Adding an interface implementation to an existing type is not a breaking change.

    L’exemple suivant utilise cette approche pour fournir un IComparable<T> implémentation pour la Person classe.The following example uses this approach to provide an IComparable<T> implementation for the Person class. Vous pouvez toujours appeler la méthode de tri générales du tableau ou de la collection et, comme le montre la sortie de l’exemple, la collection trie avec succès.You can still call the collection or array's general sorting method and, as the output from the example shows, the collection sorts successfully.

    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}", LastName, 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}", LastName, 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 voulez trier, vous pouvez définir une classe de tri à usage spécial qui implémente le IComparer<T> interface.If you cannot modify the source code for the type you are trying to sort, you can define a special-purpose sorting class that implements the IComparer<T> interface. Vous pouvez appeler une surcharge de la Sort méthode inclut un IComparer<T> paramètre.You can call an overload of the Sort method that includes an IComparer<T> parameter. Cette approche est particulièrement utile si vous souhaitez développer une classe spécialisée trie peut trier les objets selon plusieurs critères.This approach is especially useful if you want to develop a specialized sorting class that can sort objects based on multiple criteria.

    L’exemple suivant utilise l’approche en développant un personnalisé PersonComparer classe qui sert à trier Person collections.The following example uses the approach by developing a custom PersonComparer class that is used to sort Person collections. Il passe ensuite une instance de cette classe pour le List<T>.Sort(IComparer<T>) (méthode).It then passes an instance of this class to the List<T>.Sort(IComparer<T>) method.

    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 voulez trier, vous pouvez créer un Comparison<T> délégué pour effectuer le tri.If you cannot modify the source code for the type you are trying to sort, you can create a Comparison<T> delegate to perform the sorting. La signature du délégué estThe delegate signature is

    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 un PersonComparison méthode qui correspond à la Comparison<T> signature du délégué.The following example uses the approach by defining a PersonComparison method that matches the Comparison<T> delegate signature. Il passe ensuite ce délégué à la List<T>.Sort(Comparison<T>) (méthode).It then passes this delegate to the List<T>.Sort(Comparison<T>) method.

    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 type Nullable<T > qui a la valeur null en son type sous-jacentCasting a Nullable<T> that is null to its underlying type

Tentative de cast un Nullable<T> valeur qui est null à son type sous-jacent lève une InvalidOperationException exception et affiche le message d’erreur «objet Nullable doit avoir une valeur.Attempting to cast a Nullable<T> value that is null to its underlying type throws an InvalidOperationException exception and displays the error message, "Nullable object must have a value.

L’exemple suivant lève une InvalidOperationException exception lorsqu’il tente d’effectuer une itération d’un tableau qui inclut un Nullable(Of Integer) valeur.The following example throws an InvalidOperationException exception when it attempts to iterate an array that includes a Nullable(Of Integer) value.

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 empêcher l’exception :To prevent the exception:

L’exemple suivant effectue les deux pour éviter le InvalidOperationException exception.The following example does both to avoid the 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

Appeler une méthode System.Linq.Enumerable sur une collection videCalling a System.Linq.Enumerable method on an empty collection

Le Enumerable.Aggregate, Enumerable.Average, Enumerable.First, Enumerable.Last, Enumerable.Max, Enumerable.Min, Enumerable.Single, et Enumerable.SingleOrDefault méthodes effectuer des opérations sur une séquence et retourner un résultat unique.The Enumerable.Aggregate, Enumerable.Average, Enumerable.First, Enumerable.Last, Enumerable.Max, Enumerable.Min, Enumerable.Single, and Enumerable.SingleOrDefault methods perform operations on a sequence and return a single result. Certaines surcharges de ces méthodes lèvent une InvalidOperationException exception lorsque la séquence est vide, alors que les autres surcharges retournent null.Some overloads of these methods throw an InvalidOperationException exception when the sequence is empty, while other overloads return null. Le Enumerable.SingleOrDefault méthode lève également une InvalidOperationException exception lorsque la séquence contient plusieurs éléments.The Enumerable.SingleOrDefault method also throws an InvalidOperationException exception when the sequence contains more than one element.

Note

La plupart des méthodes qui lèvent une InvalidOperationException exception sont des surcharges.Most of the methods that throw an InvalidOperationException exception are overloads. N’oubliez pas que vous comprenez le comportement de la surcharge que vous choisissez.Be sure that you understand the behavior of the overload that you choose.

Le tableau suivant répertorie les messages d’exception à partir de la InvalidOperationException objets d’exception levées par les appels à certaines System.Linq.Enumerable méthodes.The following table lists the exception messages from the InvalidOperationException exception objects thrown by calls to some System.Linq.Enumerable methods.

MéthodeMethod MessageMessage
Aggregate
Average
Last
Max
Min
Séquence ne contient aucun élémentSequence contains no elements
First Séquence ne contient aucun élément correspondantSequence contains no matching element
Single
SingleOrDefault
Séquence contient plusieurs éléments correspondantsSequence contains more than one matching element

Comment supprimer ou gérer l’exception dépend les hypothèses de votre application et de la méthode particulière, que vous appelez.How you eliminate or handle the exception depends on your application's assumptions and on the particular method you call.

  • Lorsque vous appelez délibérément une de ces méthodes sans vérifier pour 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.When you deliberately call one of these methods without checking for an empty sequence, you are assuming that the sequence is not empty, and that an empty sequence is an unexpected occurrence. Dans ce cas, l’interception ou de nouveau l’exception est approprié.In this case, catching or rethrowing the exception is appropriate .

  • Si votre manquement à vérifier pour une séquence vide a été par inadvertance, vous pouvez appeler une des surcharges de la Enumerable.Any surcharge pour déterminer si une séquence contient des éléments.If your failure to check for an empty sequence was inadvertent, you can call one of the overloads of the Enumerable.Any overload to determine whether a sequence contains any elements.

    Conseil

    Appelant le Enumerable.Any<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) avant de générer une séquence peut améliorer les performances si les données de traitement peuvent contenir un grand nombre d’éléments ou si l’opération qui génère la séquence est coûteuse.Calling the Enumerable.Any<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) method before generating a sequence can improve performance if the data to be processed might contain a large number of elements or if operation that generates the sequence is expensive.

  • Si vous avez appelé une méthode comme Enumerable.First, Enumerable.Last, ou Enumerable.Single, vous pouvez remplacer par une autre méthode, tel que Enumerable.FirstOrDefault, Enumerable.LastOrDefault, ou Enumerable.SingleOrDefault, qui retourne une valeur par défaut au lieu d’un membre de la séquence.If you've called a method such as Enumerable.First, Enumerable.Last, or Enumerable.Single, you can substitute an alternate method, such as Enumerable.FirstOrDefault, Enumerable.LastOrDefault, or Enumerable.SingleOrDefault, that returns a default value instead of a member of the sequence.

Les exemples fournissent des détails supplémentaires.The examples provide additional detail.

L’exemple suivant utilise la Enumerable.Average méthode pour calculer la moyenne d’une séquence dont les valeurs sont supérieures à 4.The following example uses the Enumerable.Average method to compute the average of a sequence whose values are greater than 4. Dans la mesure où aucune valeur à partir du tableau d’origine ne dépasse 4, aucune valeur n’est inclus dans la séquence, et la méthode lève un InvalidOperationException exception.Since no values from the original array exceed 4, no values are included in the sequence, and the method throws an 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 le 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.The exception can be eliminated by calling the Any method to determine whether the sequence contains any elements before calling the method that processes the sequence, as the following example shows.

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.

Le Enumerable.First méthode retourne le premier élément dans une séquence ou le premier élément dans une séquence qui satisfait à une condition spécifiée.The Enumerable.First method returns the first item in a sequence or the first element in a sequence that satisfies a specified condition. Si la séquence est vide et n’a donc pas un premier élément, elle lève une InvalidOperationException exception.If the sequence is empty and therefore does not have a first element, it throws an InvalidOperationException exception.

Dans l’exemple suivant, le Enumerable.First<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) méthode lève un InvalidOperationException exception, car le tableau de dbQueryResults ne contient aucun élément supérieur à 4.In the following example, the Enumerable.First<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) method throws an InvalidOperationException exception because the dbQueryResults array doesn't contain an element greater than 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 au lieu de Enumerable.First pour retourner un spécifié ou la valeur par défaut.You can call the Enumerable.FirstOrDefault method instead of Enumerable.First to return a specified or default value. Si la méthode ne trouve pas un premier élément dans la séquence, elle retourne la valeur par défaut pour ce type de données.If the method does not find a first element in the sequence, it returns the default value for that data type. 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 la DateTime type.The default value is null for a reference type, zero for a numeric data type, and DateTime.MinValue for the DateTime type.

Note

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.Interpreting the value returned by the Enumerable.FirstOrDefault method is often complicated by the fact that the default value of the type can be a valid value in the sequence. Dans ce cas, vous un appel de la Enumerable.Any méthode pour déterminer si la séquence a des membres valides avant d’appeler le Enumerable.First (méthode).In this case, you an call the Enumerable.Any method to determine whether the sequence has valid members before calling the Enumerable.First method.

L’exemple suivant appelle la Enumerable.FirstOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) méthode pour empêcher le InvalidOperationException exception levée dans l’exemple précédent.The following example calls the Enumerable.FirstOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) method to prevent the InvalidOperationException exception thrown in the previous example.

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.

L’appel Enumerable.Single ou Enumerable.SingleOrDefault sur une séquence sans un seul élémentCalling Enumerable.Single or Enumerable.SingleOrDefault on a sequence without one element

Le 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.The Enumerable.Single method returns the only element of a sequence, or the only element of a sequence that meets a specified condition. Si aucun élément dans la séquence, ou s’il existe plusieurs éléments, la méthode lève un InvalidOperationException exception.If there are no elements in the sequence, or if there is more than one element , the method throws an 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.You can use the Enumerable.SingleOrDefault method to return a default value instead of throwing an exception when the sequence contains no elements. Toutefois, le Enumerable.SingleOrDefault méthode lève toujours une InvalidOperationException exception lorsque la séquence contient plusieurs éléments.However, the Enumerable.SingleOrDefault method still throws an InvalidOperationException exception when the sequence contains more than one element.

Le tableau suivant répertorie les messages d’exception à partir de la InvalidOperationException objets d’exception levées par les appels à la Enumerable.Single et Enumerable.SingleOrDefault méthodes.The following table lists the exception messages from the InvalidOperationException exception objects thrown by calls to the Enumerable.Single and Enumerable.SingleOrDefault methods.

MéthodeMethod MessageMessage
Single Séquence ne contient aucun élément correspondantSequence contains no matching element
Single
SingleOrDefault
Séquence contient plusieurs éléments correspondantsSequence contains more than one matching element

Dans l’exemple suivant, l’appel à la Enumerable.Single méthode lève un InvalidOperationException exception parce que la séquence ne contient aucun élément supérieur à 4.In the following example, the call to the Enumerable.Single method throws an InvalidOperationException exception because the sequence doesn't have an element greater than 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 la InvalidOperationException exception levée lorsqu’une séquence est vide en appelant à la place le Enumerable.SingleOrDefault (méthode).The following example attempts to prevent the InvalidOperationException exception thrown when a sequence is empty by instead calling the Enumerable.SingleOrDefault method. 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.However, because this sequence returns multiple elements whose value is greater than 2, it also throws an 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()

Appel de la Enumerable.Single méthode part du principe qu’une séquence ou la séquence qui répond aux critères spécifiés ne contient qu’un seul élément.Calling the Enumerable.Single method assumes that either a sequence or the sequence that meets specified criteria contains only one element. Enumerable.SingleOrDefault suppose une séquence avec zéro ou un résultat, mais pas plus.Enumerable.SingleOrDefault assumes a sequence with zero or one result, but no more. Si cette hypothèse est délibérée de votre part et que ces conditions ne sont pas remplies, nouvelle levée ou l’interception résultant InvalidOperationException est appropriée.If this assumption is a deliberate one on your part and these conditions are not met, rethrowing or catching the resulting InvalidOperationException is appropriate. Dans le cas contraire, ou si vous prévoyez que les conditions non valides seront produit à une certaine fréquence, vous devez envisager d’utiliser un autre Enumerable (méthode), tel que FirstOrDefault ou Where.Otherwise, or if you expect that invalid conditions will occur with some frequency, you should consider using some other Enumerable method, such as FirstOrDefault or Where.

Accès aux champs de domaine d’applications croisées dynamiquesDynamic cross-application domain field access

Le OpCodes.Ldflda Microsoft intermediate language (MSIL) instruction lève une InvalidOperationException exception si l’objet qui contient le champ dont vous essayez de récupérer l’adresse n’est pas dans le domaine d’application dans lequel votre code s’exécute.The OpCodes.Ldflda Microsoft intermediate language (MSIL) instruction throws an InvalidOperationException exception if the object containing the field whose address you are trying to retrieve is not within the application domain in which your code is executing. L’adresse d’un champ est uniquement accessible à partir du domaine d’application dans lequel il réside.The address of a field can only be accessed from the application domain in which it resides.

Lever une exception InvalidOperationExceptionThrowing an InvalidOperationException exception

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.You should throw an InvalidOperationException exception only when the state of your object for some reason does not support a particular method call. Autrement dit, l’appel de méthode n’est valide que dans certaines circonstances ou des contextes, mais n’est pas valide dans d’autres.That is, the method call is valid in some circumstances or contexts, but is invalid in others.

Si l’échec d’appel de méthode est en raison d’arguments non valides, puis ArgumentException ou l’une de ses classes dérivées, ArgumentNullException ou ArgumentOutOfRangeException, doit être levée à la place.If the method invocation failure is due to invalid arguments, then ArgumentException or one of its derived classes, ArgumentNullException or ArgumentOutOfRangeException, should be thrown instead.

Informations diversesMiscellaneous information

InvalidOperationException utilise le HRESULT COR_E_INVALIDOPERATION dont la valeur est 0 x 80131509.InvalidOperationException uses the HRESULT COR_E_INVALIDOPERATION, which has the value 0x80131509.

Pour obtenir la liste des valeurs initiales des propriétés d’une instance de InvalidOperationException, consultez le InvalidOperationException constructeurs.For a list of initial property values for an instance of InvalidOperationException, see the InvalidOperationException constructors.

Constructeurs

InvalidOperationException() InvalidOperationException() InvalidOperationException() InvalidOperationException()

Initialise une nouvelle instance de la classe InvalidOperationException.Initializes a new instance of the InvalidOperationException class.

InvalidOperationException(SerializationInfo, StreamingContext) InvalidOperationException(SerializationInfo, StreamingContext) InvalidOperationException(SerializationInfo, StreamingContext) InvalidOperationException(SerializationInfo, StreamingContext)

Initialise une nouvelle instance de la classe InvalidOperationException avec des données sérialisées.Initializes a new instance of the InvalidOperationException class with serialized data.

InvalidOperationException(String) InvalidOperationException(String) InvalidOperationException(String) InvalidOperationException(String)

Initialise une nouvelle instance de la classe InvalidOperationException avec un message d'erreur spécifié.Initializes a new instance of the InvalidOperationException class with a specified error message.

InvalidOperationException(String, Exception) InvalidOperationException(String, Exception) InvalidOperationException(String, Exception) 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.Initializes a new instance of the InvalidOperationException class with a specified error message and a reference to the inner exception that is the cause of this exception.

Propriétés

Data Data Data Data

Obtient une collection de paires clé/valeur qui fournissent des informations supplémentaires définies par l’utilisateur sur l’exception.Gets a collection of key/value pairs that provide additional user-defined information about the exception.

(Inherited from Exception)
HelpLink HelpLink HelpLink HelpLink

Obtient ou définit un lien vers le fichier d'aide associé à cette exception.Gets or sets a link to the help file associated with this exception.

(Inherited from Exception)
HResult HResult HResult HResult

Obtient ou définit HRESULT, valeur numérique codée qui est assignée à une exception spécifique.Gets or sets HRESULT, a coded numerical value that is assigned to a specific exception.

(Inherited from Exception)
InnerException InnerException InnerException InnerException

Obtient l'instance Exception qui a provoqué l'exception actuelle.Gets the Exception instance that caused the current exception.

(Inherited from Exception)
Message Message Message Message

Obtient un message qui décrit l'exception actuelle.Gets a message that describes the current exception.

(Inherited from Exception)
Source Source Source Source

Obtient ou définit le nom de l'application ou de l'objet qui est à l'origine de l'erreur.Gets or sets the name of the application or the object that causes the error.

(Inherited from Exception)
StackTrace StackTrace StackTrace StackTrace

Obtient une représentation sous forme de chaîne des frames immédiats sur la pile des appels.Gets a string representation of the immediate frames on the call stack.

(Inherited from Exception)
TargetSite TargetSite TargetSite TargetSite

Obtient la méthode qui lève l'exception actuelle.Gets the method that throws the current exception.

(Inherited from Exception)

Méthodes

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Détermine si l'objet spécifié est identique à l'objet actuel.Determines whether the specified object is equal to the current object.

(Inherited from Object)
GetBaseException() GetBaseException() GetBaseException() 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.When overridden in a derived class, returns the Exception that is the root cause of one or more subsequent exceptions.

(Inherited from Exception)
GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Fait office de fonction de hachage par défaut.Serves as the default hash function.

(Inherited from Object)
GetObjectData(SerializationInfo, StreamingContext) GetObjectData(SerializationInfo, StreamingContext) GetObjectData(SerializationInfo, StreamingContext) GetObjectData(SerializationInfo, StreamingContext)

En cas de substitution dans une classe dérivée, définit SerializationInfo avec des informations sur l'exception.When overridden in a derived class, sets the SerializationInfo with information about the exception.

(Inherited from Exception)
GetType() GetType() GetType() GetType()

Obtient le type au moment de l'exécution de l'instance actuelle.Gets the runtime type of the current instance.

(Inherited from Exception)
MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Crée une copie superficielle du Object actuel.Creates a shallow copy of the current Object.

(Inherited from Object)
ToString() ToString() ToString() ToString()

Crée et retourne une chaîne représentant l'exception actuelle.Creates and returns a string representation of the current exception.

(Inherited from Exception)

Événements

SerializeObjectState SerializeObjectState SerializeObjectState SerializeObjectState

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.Occurs when an exception is serialized to create an exception state object that contains serialized data about the exception.

(Inherited from Exception)

S’applique à

Voir aussi