InvalidOperationException Classe

Definizione

Eccezione generata quando una chiamata a un metodo non è valida per lo stato corrente dell'oggetto.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
Ereditarietà
InvalidOperationException
Derivato
Attributi

Commenti

InvalidOperationExceptionviene usato nei casi in cui l'errore di richiamare un metodo è causato da motivi diversi da argomenti non validi.InvalidOperationException is used in cases when the failure to invoke a method is caused by reasons other than invalid arguments. Viene in genere generata quando lo stato di un oggetto non è in grado di supportare la chiamata al metodo.Typically, it is thrown when the state of an object cannot support the method call. Ad esempio, un' InvalidOperationException eccezione viene generata da metodi quali:For example, an InvalidOperationException exception is thrown by methods such as:

  • IEnumerator.MoveNextSe gli oggetti di una raccolta vengono modificati dopo la creazione dell'enumeratore.IEnumerator.MoveNext if objects of a collection are modified after the enumerator is created. Per ulteriori informazioni, vedere modifica di una raccolta durantel'iterazione.For more information, see Changing a collection while iterating it.

  • ResourceSet.GetStringSe il set di risorse viene chiuso prima che venga effettuata la chiamata al metodo.ResourceSet.GetString if the resource set is closed before the method call is made.

  • XContainer.AddSe l'oggetto o gli oggetti da aggiungere generano un documento XML strutturato in modo non corretto.XContainer.Add, if the object or objects to be added would result in an incorrectly structured XML document.

  • Metodo che tenta di modificare l'interfaccia utente da un thread che non è il thread principale o dell'interfaccia utente.A method that attempts to manipulate the UI from a thread that is not the main or UI thread.

Importante

Poiché l' InvalidOperationException eccezione può essere generata in un'ampia gamma di circostanze, è importante leggere il messaggio Message di eccezione restituito dalla proprietà.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.

Contenuto della sezione:In this section:

Alcune cause comuni delle eccezioni InvalidOperationException Some common causes of InvalidOperationException exceptions
Aggiornamento di un thread dell'interfaccia utente da un thread non dell'interfaccia utenteUpdating a UI thread from a non-UI thread
Modifica di una raccolta durante l'iterazioneChanging a collection while iterating it
Ordinamento di una matrice o di una raccolta i cui oggetti non possono essere confrontatiSorting an array or collection whose objects cannot be compared
Cast di una<T> nullable che è null al tipo sottostante Casting a Nullable<T> that is null to its underlying type
Chiamata a un metodo System. Linq. Enumerable su una raccolta vuotaCalling a System.Linq.Enumerable method on an empty collection
Chiamata di Enumerable. Single o Enumerable. SingleOrDefault in una sequenza senza un elementoCalling Enumerable.Single or Enumerable.SingleOrDefault on a sequence without one element
Accesso ai campi dinamici tra applicazioni e dominiDynamic cross-application domain field access
Generazione di un'eccezione InvalidOperationExceptionThrowing an InvalidOperationException exception
Informazioni varieMiscellaneous information

Alcune cause comuni delle eccezioni InvalidOperationExceptionSome common causes of InvalidOperationException exceptions

Le sezioni seguenti illustrano come alcuni casi comuni in cui InvalidOperationException viene generata un'eccezione in un'app.The following sections show how some common cases in which in InvalidOperationException exception is thrown in an app. La modalità di gestione del problema dipende dalla situazione specifica.How you handle the issue depends on the specific situation. In genere, tuttavia, l'eccezione risulta dall'errore dello sviluppatore e l' InvalidOperationException eccezione può essere prevista ed evitata.Most commonly, however, the exception results from developer error, and the InvalidOperationException exception can be anticipated and avoided.

Aggiornamento di un thread dell'interfaccia utente da un thread non dell'interfaccia utenteUpdating a UI thread from a non-UI thread

Spesso i thread di lavoro vengono usati per eseguire alcune operazioni in background che coinvolgono la raccolta dei dati da visualizzare nell'interfaccia utente di un'applicazione.Often, worker threads are used to perform some background work that involves gathering data to be displayed in an application's user interface. Tuttavia.However. la maggior parte dei framework applicazione GUI (interfaccia utente grafica) per la .NET Framework, ad esempio Windows Forms e Windows Presentation Foundation (WPF), consente di accedere agli oggetti GUI solo dal thread che crea e gestisce l'interfaccia utente (il thread principale o dell'interfaccia utente).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). Viene InvalidOperationException generata un'eccezione quando si tenta di accedere a un elemento dell'interfaccia utente da un thread diverso dal thread dell'interfaccia utente.An InvalidOperationException is thrown when you try to access a UI element from a thread other than the UI thread. Il testo del messaggio di eccezione è illustrato nella tabella seguente.The text of the exception message is shown in the following table.

Tipo di applicazioneApplication Type MessaggioMessage
App WPFWPF app Il thread chiamante non può accedere a questo oggetto perché è proprietario di un altro thread.The calling thread cannot access this object because a different thread owns it.
App UWPUWP app L'applicazione ha chiamato un'interfaccia di cui è stato effettuato il marshalling per un thread diverso.The application called an interface that was marshaled for a different thread.
App Windows FormsWindows Forms app Operazione cross-thread non valida: È stato eseguito l'accesso al controllo ' TextBox1' da un thread diverso dal thread in cui è stato creato.Cross-thread operation not valid: Control 'TextBox1' accessed from a thread other than the thread it was created on.

I Framework dell'interfaccia utente per la .NET Framework implementano un modello Dispatcher che include un metodo per verificare se una chiamata a un membro di un elemento dell'interfaccia utente viene eseguita sul thread dell'interfaccia utente e altri metodi per pianificare la chiamata sul thread dell'interfaccia utente: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:

  • Nelle app WPF chiamare il Dispatcher.CheckAccess metodo per determinare se un metodo è in esecuzione su un thread non dell'interfaccia utente.In WPF apps, call the Dispatcher.CheckAccess method to determine if a method is running on a non-UI thread. Restituisce true se il metodo è in esecuzione sul thread dell'interfaccia utente false e in caso contrario.It returns true if the method is running on the UI thread and false otherwise. Chiamare uno degli overload del Dispatcher.Invoke metodo per pianificare la chiamata sul thread dell'interfaccia utente.Call one of the overloads of the Dispatcher.Invoke method to schedule the call on the UI thread.

  • Nelle app UWP controllare la CoreDispatcher.HasThreadAccess proprietà per determinare se un metodo è in esecuzione su un thread non dell'interfaccia utente.In UWP apps, check the CoreDispatcher.HasThreadAccess property to determine if a method is running on a non-UI thread. Chiamare il CoreDispatcher.RunAsync metodo per eseguire un delegato che aggiorna il thread dell'interfaccia utente.Call the CoreDispatcher.RunAsync method to execute a delegate that updates the UI thread.

  • Nelle app Windows Forms usare la Control.InvokeRequired proprietà per determinare se un metodo è in esecuzione su un thread non dell'interfaccia utente.In Windows Forms apps, use the Control.InvokeRequired property to determine if a method is running on a non-UI thread. Chiamare uno degli overload del Control.Invoke metodo per eseguire un delegato che aggiorna il thread dell'interfaccia utente.Call one of the overloads of the Control.Invoke method to execute a delegate that updates the UI thread.

Negli esempi seguenti viene illustrata InvalidOperationException l'eccezione generata quando si tenta di aggiornare un elemento dell'interfaccia utente da un thread diverso dal thread che lo ha creato.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. Per ogni esempio è necessario creare due controlli:Each example requires that you create two controls:

  • Controllo casella di testo denominato textBox1.A text box control named textBox1. In un'app Windows Forms è necessario impostare la relativa Multiline proprietà su true.In a Windows Forms app, you should set its Multiline property to true.

  • Controllo Button denominato threadExampleBtn.A button control named threadExampleBtn. Nell'esempio viene fornito un gestore ThreadsExampleBtn_Click,, per l' Click evento del pulsante.The example provides a handler, ThreadsExampleBtn_Click, for the button's Click event.

In ogni caso, il threadExampleBtn_Click gestore eventi chiama il DoSomeWork metodo due volte.In each case, the threadExampleBtn_Click event handler calls the DoSomeWork method twice. La prima chiamata viene eseguita in modo sincrono e ha esito positivo.The first call runs synchronously and succeeds. Tuttavia, la seconda chiamata, poiché viene eseguita in modo asincrono su un thread del pool di thread, tenta di aggiornare l'interfaccia utente da un thread non dell'interfaccia utente.But the second call, because it runs asynchronously on a thread pool thread, attempts to update the UI from a non-UI thread. Viene generata un' InvalidOperationException eccezione.This results in a InvalidOperationException exception.

App WPF e 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 seguente versione del DoSomeWork metodo elimina l'eccezione in un'app 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 versione seguente del DoSomeWork metodo elimina l'eccezione in un'app 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

App di Windows FormWindows 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 versione seguente del DoSomeWork metodo elimina l'eccezione in un'app 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

Modifica di una raccolta durante l'iterazioneChanging a collection while iterating it

L' foreach istruzione nell' C# istruzione For Each o in Visual Basic viene utilizzata per eseguire l'iterazione dei membri di una raccolta e per leggere o modificare i singoli elementi.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. Tuttavia, non può essere utilizzato per aggiungere o rimuovere elementi dalla raccolta.However, it can't be used to add or remove items from the collection. Questa operazione genera un' InvalidOperationException eccezione con un messaggio simile a "laraccolta è stata modificata; l'operazione di enumerazione potrebbe non essere eseguita."Doing this throws an InvalidOperationException exception with a message that is similar to, "Collection was modified; enumeration operation may not execute."

Nell'esempio seguente viene iterata una raccolta di numeri interi che tenta di aggiungere il quadrato di ogni intero alla raccolta.The following example iterates a collection of integers attempts to add the square of each integer to the collection. Nell'esempio viene generata InvalidOperationException un'eccezione con la prima chiamata List<T>.Add al metodo.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()

È possibile eliminare l'eccezione in uno dei due modi seguenti, a seconda della logica dell'applicazione:You can eliminate the exception in one of two ways, depending on your application logic:

  • Se gli elementi devono essere aggiunti alla raccolta durante l'iterazione, è possibile eseguire l'iterazione in for base all'indice foreach usando For Eachl'istruzione invece di o.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. Nell'esempio seguente viene utilizzata l'istruzione for per aggiungere alla raccolta il quadrato dei numeri della raccolta.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
    

    Si noti che è necessario stabilire il numero di iterazioni prima di eseguire l'iterazione della raccolta usando un contatore all'interno del ciclo che chiuderà il ciclo in modo appropriato, Count scorrendo indietro, da-1 a 0 o, come avviene nell'esempio, assegnando il numero di elementi nella matrice a una variabile e che lo usa per stabilire il limite superiore del ciclo.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 appropriately, 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. In caso contrario, se un elemento viene aggiunto alla raccolta in ogni iterazione, viene restituito un ciclo infinito.Otherwise, if an element is added to the collection on every iteration, an endless loop results.

  • Se non è necessario aggiungere elementi alla raccolta durante l'iterazione, è possibile archiviare gli elementi da aggiungere in una raccolta temporanea aggiunta al termine dell'iterazione della raccolta.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. Nell'esempio seguente viene usato questo approccio per aggiungere il quadrato di numeri in una raccolta a una raccolta temporanea e quindi per combinare le raccolte in un singolo oggetto Array.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
    

Ordinamento di una matrice o di una raccolta i cui oggetti non possono essere confrontatiSorting an array or collection whose objects cannot be compared

I metodi di ordinamento generici, ad esempio il Array.Sort(Array) metodo o il List<T>.Sort() metodo, richiedono in genere che almeno uno degli oggetti da IComparable ordinare implementi l' IComparable<T> interfaccia o.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. In caso contrario, la raccolta o la matrice non può essere ordinata e il InvalidOperationException metodo genera un'eccezione.If not, the collection or array cannot be sorted, and the method throws an InvalidOperationException exception. Nell'esempio seguente viene definita Person una classe, vengono Person archiviati due oggetti in List<T> un oggetto generico e viene effettuato un tentativo di ordinarli.The following example defines a Person class, stores two Person objects in a generic List<T> object, and attempts to sort them. Come illustrato nell'output dell'esempio, la chiamata al List<T>.Sort() metodo genera un' InvalidOperationExceptioneccezione.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()

È possibile eliminare l'eccezione in uno dei tre modi seguenti:You can eliminate the exception in any of three ways:

  • Se è possibile essere proprietari del tipo che si sta tentando di ordinare, ovvero se si controlla il codice sorgente, è possibile modificarlo per implementare l' IComparable<T> IComparable interfaccia o.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. A tale scopo, è necessario implementare IComparable<T>.CompareTo il CompareTo metodo o.This requires that you implement either the IComparable<T>.CompareTo or the CompareTo method. L'aggiunta di un'implementazione di interfaccia a un tipo esistente non è una modifica sostanziale.Adding an interface implementation to an existing type is not a breaking change.

    Nell'esempio seguente viene usato questo approccio per fornire IComparable<T> un'implementazione per Person la classe.The following example uses this approach to provide an IComparable<T> implementation for the Person class. È comunque possibile chiamare il metodo di ordinamento generale della raccolta o della matrice e, come illustrato nell'output dell'esempio, la raccolta viene ordinata correttamente.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
    
  • Se non è possibile modificare il codice sorgente per il tipo che si sta tentando di ordinare, è possibile definire una classe di ordinamento per scopi specifici IComparer<T> che implementi l'interfaccia.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. È possibile chiamare un overload del Sort metodo che include un IComparer<T> parametro.You can call an overload of the Sort method that includes an IComparer<T> parameter. Questo approccio è particolarmente utile se si desidera sviluppare una classe di ordinamento specializzata in grado di ordinare gli oggetti in base a più criteri.This approach is especially useful if you want to develop a specialized sorting class that can sort objects based on multiple criteria.

    Nell'esempio seguente viene utilizzato l'approccio sviluppando una PersonComparer classe personalizzata utilizzata per ordinare Person le raccolte.The following example uses the approach by developing a custom PersonComparer class that is used to sort Person collections. Passa quindi un'istanza di questa classe al List<T>.Sort(IComparer<T>) metodo.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
    
  • Se non è possibile modificare il codice sorgente per il tipo che si sta tentando di ordinare, è Comparison<T> possibile creare un delegato per eseguire l'ordinamento.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 firma del delegato èThe delegate signature is

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

    Nell'esempio seguente viene usato l'approccio definendo un PersonComparison metodo che corrisponde alla Comparison<T> firma del delegato.The following example uses the approach by defining a PersonComparison method that matches the Comparison<T> delegate signature. Passa quindi questo delegato al List<T>.Sort(Comparison<T>) metodo.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
    

Cast di un<> Nullable T null al tipo sottostanteCasting a Nullable<T> that is null to its underlying type

Se si tenta di eseguire Nullable<T> il cast di null un valore che corrisponde al tipo InvalidOperationException sottostante, viene generata un'eccezione e viene visualizzato il messaggio di errore "l'oggetto Nullable deve avere un valore.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.

Nell'esempio seguente viene generata InvalidOperationException un'eccezione quando si tenta di eseguire l'iterazione di Nullable(Of Integer) una matrice che include un valore.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()

Per evitare l'eccezione:To prevent the exception:

Nell'esempio seguente viene eseguita l'operazione per InvalidOperationException evitare l'eccezione.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

Chiamata a un metodo System. Linq. Enumerable su una raccolta vuotaCalling a System.Linq.Enumerable method on an empty collection

I Enumerable.Aggregatemetodi Enumerable.Average,, Enumerable.First, ,Enumerable.Max,, e eseguonoEnumerable.SingleOrDefault operazioni su una sequenza e restituiscono un singolo risultato. Enumerable.Single Enumerable.Last Enumerable.MinThe 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. Alcuni overload di questi metodi generano un' InvalidOperationException eccezione quando la sequenza è vuota, mentre altri overload restituiscono. nullSome overloads of these methods throw an InvalidOperationException exception when the sequence is empty, while other overloads return null. Il Enumerable.SingleOrDefault metodo genera inoltre un' InvalidOperationException eccezione quando la sequenza contiene più di un elemento.The Enumerable.SingleOrDefault method also throws an InvalidOperationException exception when the sequence contains more than one element.

Nota

La maggior parte dei metodi che generano un' InvalidOperationException eccezione sono overload.Most of the methods that throw an InvalidOperationException exception are overloads. Assicurarsi di comprendere il comportamento dell'overload scelto.Be sure that you understand the behavior of the overload that you choose.

Nella tabella seguente sono elencati i messaggi di eccezione InvalidOperationException dagli oggetti eccezione generati dalle chiamate ad System.Linq.Enumerable alcuni metodi.The following table lists the exception messages from the InvalidOperationException exception objects thrown by calls to some System.Linq.Enumerable methods.

MetodoMethod MessaggioMessage
Aggregate
Average
Last
Max
Min
La sequenza non contiene elementiSequence contains no elements
First La sequenza non contiene elementi corrispondentiSequence contains no matching element
Single
SingleOrDefault
La sequenza contiene più di un elemento corrispondenteSequence contains more than one matching element

Il modo in cui si elimina o si gestisce l'eccezione dipende dalle ipotesi dell'applicazione e dal metodo particolare chiamato.How you eliminate or handle the exception depends on your application's assumptions and on the particular method you call.

  • Quando si chiama intenzionalmente uno di questi metodi senza verificare la presenza di una sequenza vuota, si presuppone che la sequenza non sia vuota e che una sequenza vuota sia un'occorrenza imprevista.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. In questo caso, è opportuno intercettare o rigenerare l'eccezione.In this case, catching or rethrowing the exception is appropriate .

  • Se il mancato controllo di una sequenza vuota è involontario, è possibile chiamare uno degli Enumerable.Any overload dell'overload per determinare se una sequenza contiene elementi.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.

    Suggerimento

    La chiamata Enumerable.Any<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) al metodo prima della generazione di una sequenza può migliorare le prestazioni se i dati da elaborare possono contenere un numero elevato di elementi o se l'operazione che genera la sequenza è dispendiosa.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.

  • Se è Enumerable.Firststato chiamato un metodo come, Enumerable.Lasto Enumerable.Single, è Enumerable.FirstOrDefaultpossibile sostituire un metodo alternativo, ad esempio, Enumerable.LastOrDefaulto Enumerable.SingleOrDefault, che restituisce un valore predefinito anziché un membro della sequenza.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.

Gli esempi forniscono ulteriori dettagli.The examples provide additional detail.

Nell'esempio seguente viene usato Enumerable.Average il metodo per calcolare la media di una sequenza i cui valori sono maggiori di 4.The following example uses the Enumerable.Average method to compute the average of a sequence whose values are greater than 4. Poiché nessun valore della matrice originale supera 4, nessun valore viene incluso nella sequenza e il metodo genera un' InvalidOperationException eccezione.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'eccezione può essere eliminata chiamando il Any metodo per determinare se la sequenza contiene elementi prima di chiamare il metodo che elabora la sequenza, come illustrato nell'esempio seguente.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.

Il Enumerable.First metodo restituisce il primo elemento di una sequenza o il primo elemento di una sequenza che soddisfa una condizione specificata.The Enumerable.First method returns the first item in a sequence or the first element in a sequence that satisfies a specified condition. Se la sequenza è vuota e pertanto non ha un primo elemento, viene generata un' InvalidOperationException eccezione.If the sequence is empty and therefore does not have a first element, it throws an InvalidOperationException exception.

Nell'esempio seguente, il Enumerable.First<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) metodo genera un' InvalidOperationException eccezione perché la matrice dbQueryResults non contiene un elemento maggiore di 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()

È possibile chiamare il Enumerable.FirstOrDefault metodo Enumerable.First anziché per restituire un valore specificato o predefinito.You can call the Enumerable.FirstOrDefault method instead of Enumerable.First to return a specified or default value. Se il metodo non trova un primo elemento nella sequenza, restituisce il valore predefinito per quel tipo di dati.If the method does not find a first element in the sequence, it returns the default value for that data type. Il valore predefinito è null per un tipo di riferimento, zero per un tipo di dati numerico DateTime.MinValue e per DateTime il tipo.The default value is null for a reference type, zero for a numeric data type, and DateTime.MinValue for the DateTime type.

Nota

L'interpretazione del valore restituito dal Enumerable.FirstOrDefault metodo è spesso complicata dal fatto che il valore predefinito del tipo può essere un valore valido nella sequenza.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. In questo caso, è necessario chiamare il Enumerable.Any metodo per determinare se la sequenza contiene membri validi prima di chiamare Enumerable.First il metodo.In this case, you an call the Enumerable.Any method to determine whether the sequence has valid members before calling the Enumerable.First method.

Nell'esempio seguente viene chiamato Enumerable.FirstOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) il metodo per impedire InvalidOperationException l'eccezione generata nell'esempio precedente.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.

Chiamata di Enumerable. Single o Enumerable. SingleOrDefault in una sequenza senza un elementoCalling Enumerable.Single or Enumerable.SingleOrDefault on a sequence without one element

Il Enumerable.Single metodo restituisce l'unico elemento di una sequenza o l'unico elemento di una sequenza che soddisfa una condizione specificata.The Enumerable.Single method returns the only element of a sequence, or the only element of a sequence that meets a specified condition. Se non sono presenti elementi nella sequenza o se è presente più di un elemento, il metodo genera un' InvalidOperationException eccezione.If there are no elements in the sequence, or if there is more than one element , the method throws an InvalidOperationException exception.

È possibile utilizzare il Enumerable.SingleOrDefault metodo per restituire un valore predefinito anziché generare un'eccezione quando la sequenza non contiene elementi.You can use the Enumerable.SingleOrDefault method to return a default value instead of throwing an exception when the sequence contains no elements. Tuttavia, il Enumerable.SingleOrDefault metodo genera comunque un' InvalidOperationException eccezione quando la sequenza contiene più di un elemento.However, the Enumerable.SingleOrDefault method still throws an InvalidOperationException exception when the sequence contains more than one element.

Nella tabella seguente sono elencati i messaggi di eccezione InvalidOperationException dagli oggetti eccezione generati dalle chiamate Enumerable.Single ai metodi Enumerable.SingleOrDefault e.The following table lists the exception messages from the InvalidOperationException exception objects thrown by calls to the Enumerable.Single and Enumerable.SingleOrDefault methods.

MetodoMethod MessaggioMessage
Single La sequenza non contiene elementi corrispondentiSequence contains no matching element
Single
SingleOrDefault
La sequenza contiene più di un elemento corrispondenteSequence contains more than one matching element

Nell'esempio seguente, la chiamata al Enumerable.Single metodo genera un' InvalidOperationException eccezione perché la sequenza non contiene un elemento maggiore di 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()

Nell'esempio seguente viene eseguito un tentativo InvalidOperationException di impedire l'eccezione generata quando una sequenza è vuota chiamando Enumerable.SingleOrDefault invece il metodo.The following example attempts to prevent the InvalidOperationException exception thrown when a sequence is empty by instead calling the Enumerable.SingleOrDefault method. Tuttavia, poiché questa sequenza restituisce più elementi il cui valore è maggiore di 2, viene generata anche InvalidOperationException un'eccezione.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()

La chiamata Enumerable.Single al metodo presuppone che una sequenza o la sequenza che soddisfa i criteri specificati contenga un solo elemento.Calling the Enumerable.Single method assumes that either a sequence or the sequence that meets specified criteria contains only one element. Enumerable.SingleOrDefaultpresuppone una sequenza con zero o un risultato, ma non altro.Enumerable.SingleOrDefault assumes a sequence with zero or one result, but no more. Se si tratta di un presupposto intenzionale da parte dell'utente e queste condizioni non vengono soddisfatte, la rigenerazione InvalidOperationException o il rilevamento dell'oggetto risultante è appropriato.If this assumption is a deliberate one on your part and these conditions are not met, rethrowing or catching the resulting InvalidOperationException is appropriate. In caso contrario, o se si prevede che le condizioni non valide vengano eseguite con una certa frequenza, è Enumerable consigliabile usare un altro FirstOrDefault metodo Where, ad esempio o.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.

Accesso ai campi dinamici tra applicazioni e dominiDynamic cross-application domain field access

L' OpCodes.Ldflda istruzione Microsoft Intermediate Language (MSIL) InvalidOperationException genera un'eccezione se l'oggetto contenente il campo il cui indirizzo si sta tentando di recuperare non si trova all'interno del dominio dell'applicazione in cui è in esecuzione il codice.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. È possibile accedere all'indirizzo di un campo solo dal dominio dell'applicazione in cui risiede.The address of a field can only be accessed from the application domain in which it resides.

Generazione di un'eccezione InvalidOperationExceptionThrowing an InvalidOperationException exception

È consigliabile generare un' InvalidOperationException eccezione solo quando lo stato dell'oggetto per qualche motivo non supporta una particolare chiamata al metodo.You should throw an InvalidOperationException exception only when the state of your object for some reason does not support a particular method call. Ovvero la chiamata al metodo è valida in alcune circostanze o contesti, ma non è valida in altri.That is, the method call is valid in some circumstances or contexts, but is invalid in others.

Se l'errore di chiamata al metodo è dovuto a argomenti non validi ArgumentException , è necessario che venga generata una ArgumentNullException delle ArgumentOutOfRangeExceptionclassi derivate o.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.

Informazioni varieMiscellaneous information

InvalidOperationExceptionUSA HRESULT COR_E_INVALIDOPERATION, che ha il valore 0x80131509.InvalidOperationException uses the HRESULT COR_E_INVALIDOPERATION, which has the value 0x80131509.

Per un elenco di valori di proprietà iniziali per un'istanza di InvalidOperationException, vedere il InvalidOperationException costruttori.For a list of initial property values for an instance of InvalidOperationException, see the InvalidOperationException constructors.

Costruttori

InvalidOperationException()

Inizializza una nuova istanza della classe InvalidOperationException.Initializes a new instance of the InvalidOperationException class.

InvalidOperationException(SerializationInfo, StreamingContext)

Inizializza una nuova istanza della classe InvalidOperationException con dati serializzati.Initializes a new instance of the InvalidOperationException class with serialized data.

InvalidOperationException(String)

Inizializza una nuova istanza della classe InvalidOperationException con un messaggio di errore specificato.Initializes a new instance of the InvalidOperationException class with a specified error message.

InvalidOperationException(String, Exception)

Inizializza una nuova istanza della classe InvalidOperationException con un messaggio di errore specificato e un riferimento all'eccezione interna che è la causa dell'eccezione corrente.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.

Proprietà

Data

Ottiene una raccolta di coppie chiave-valore che fornisce informazioni aggiuntive definite dall'utente relative all'eccezione.Gets a collection of key/value pairs that provide additional user-defined information about the exception.

(Ereditato da Exception)
HelpLink

Ottiene o imposta un collegamento al file della Guida associato all'eccezione.Gets or sets a link to the help file associated with this exception.

(Ereditato da Exception)
HResult

Ottiene o imposta HRESULT, un valore numerico codificato che viene assegnato a un'eccezione specifica.Gets or sets HRESULT, a coded numerical value that is assigned to a specific exception.

(Ereditato da Exception)
InnerException

Ottiene l'istanza di Exception che ha causato l'eccezione corrente.Gets the Exception instance that caused the current exception.

(Ereditato da Exception)
Message

Ottiene un messaggio che descrive l'eccezione corrente.Gets a message that describes the current exception.

(Ereditato da Exception)
Source

Ottiene o imposta il nome dell'oggetto o dell'applicazione che ha generato l'errore.Gets or sets the name of the application or the object that causes the error.

(Ereditato da Exception)
StackTrace

Ottiene una rappresentazione di stringa dei frame immediati nello stack di chiamate.Gets a string representation of the immediate frames on the call stack.

(Ereditato da Exception)
TargetSite

Ottiene il metodo che genera l'eccezione corrente.Gets the method that throws the current exception.

(Ereditato da Exception)

Metodi

Equals(Object)

Determina se l'oggetto specificato è uguale all'oggetto corrente.Determines whether the specified object is equal to the current object.

(Ereditato da Object)
GetBaseException()

Se utilizzato come metodo di override in una classe derivata, restituisce l'Exception che è la causa radice di una o più eccezioni successive.When overridden in a derived class, returns the Exception that is the root cause of one or more subsequent exceptions.

(Ereditato da Exception)
GetHashCode()

Funge da funzione hash predefinita.Serves as the default hash function.

(Ereditato da Object)
GetObjectData(SerializationInfo, StreamingContext)

Quando l'override viene eseguito in una classe derivata, imposta il controllo SerializationInfo per la colonna.When overridden in a derived class, sets the SerializationInfo with information about the exception.

(Ereditato da Exception)
GetType()

Ottiene il tipo di runtime dell'istanza corrente.Gets the runtime type of the current instance.

(Ereditato da Exception)
MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.Creates a shallow copy of the current Object.

(Ereditato da Object)
ToString()

Crea e restituisce una rappresentazione di stringa dell'eccezione corrente.Creates and returns a string representation of the current exception.

(Ereditato da Exception)

Eventi

SerializeObjectState

Si verifica quando un'eccezione viene serializzata per creare un oggetto di stato eccezione contenente i dati serializzati relativi all'eccezione.Occurs when an exception is serialized to create an exception state object that contains serialized data about the exception.

(Ereditato da Exception)

Si applica a

Vedi anche