InvalidOperationException Classe

Definizione

Eccezione generata quando una chiamata a un metodo non è valida per lo stato corrente dell'oggetto.

public ref class InvalidOperationException : Exception
public ref class InvalidOperationException : SystemException
public class InvalidOperationException : Exception
public class InvalidOperationException : SystemException
[System.Serializable]
public class InvalidOperationException : SystemException
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public class InvalidOperationException : SystemException
type InvalidOperationException = class
    inherit Exception
type InvalidOperationException = class
    inherit SystemException
[<System.Serializable>]
type InvalidOperationException = class
    inherit SystemException
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type InvalidOperationException = class
    inherit SystemException
Public Class InvalidOperationException
Inherits Exception
Public Class InvalidOperationException
Inherits SystemException
Ereditarietà
InvalidOperationException
Ereditarietà
InvalidOperationException
Derivato
Attributi

Commenti

InvalidOperationException viene usato nei casi in cui l'errore di richiamare un metodo è causato da motivi diversi da argomenti non validi. In genere, viene generata quando lo stato di un oggetto non supporta la chiamata al metodo . Ad esempio, InvalidOperationException un'eccezione viene generata da metodi come:

  • IEnumerator.MoveNext se gli oggetti di una raccolta vengono modificati dopo la creazione dell'enumeratore. Per altre informazioni, vedere Modifica di una raccolta durante l'iterazione.

  • ResourceSet.GetString se il set di risorse viene chiuso prima della chiamata al metodo.

  • XContainer.Add, se l'oggetto o gli oggetti da aggiungere comporterebbe un documento XML strutturato in modo non corretto.

  • Metodo che tenta di modificare l'interfaccia utente da un thread che non è il thread principale o dell'interfaccia utente.

Importante

Poiché l'eccezione può essere generata in un'ampia gamma di circostanze, è importante leggere il messaggio di eccezione InvalidOperationException restituito dalla Message proprietà .

Contenuto della sezione:

Alcune cause comuni delle eccezioni InvalidOperationException
Aggiornamento di un thread dell'interfaccia utente da un thread non dell'interfaccia utente
Modifica di una raccolta durante l'iterazione
Ordinamento di una matrice o di una raccolta i cui oggetti non possono essere confrontati
Cast di un < oggetto T > nullable nel tipo sottostante
Chiamata di un metodo System.Linq.Enumerable su una raccolta vuota
Chiamata di Enumerable.Single o Enumerable.SingleOrDefault in una sequenza senza un elemento
Accesso dinamico al campo di dominio tra applicazioni
Generazione di un'eccezione InvalidOperationException
Informazioni varie

Alcune cause comuni delle eccezioni InvalidOperationException

Le sezioni seguenti illustrano come vengono generati alcuni casi comuni in cui in InvalidOperationException un'app viene generata un'eccezione. La modalità di gestione del problema dipende dalla situazione specifica. In genere, tuttavia, l'eccezione risulta dall'errore dello sviluppatore e InvalidOperationException l'eccezione può essere anticipata ed evitata.

Aggiornamento di un thread dell'interfaccia utente da un thread non dell'interfaccia utente

Spesso, i thread di lavoro vengono usati per eseguire alcune operazioni in background che comportano la raccolta di dati da visualizzare nell'interfaccia utente di un'applicazione. Tuttavia, La maggior parte dei framework di applicazione gui (interfaccia utente grafica) per il .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 (thread principale o dell'interfaccia utente). 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. Il testo del messaggio di eccezione è illustrato nella tabella seguente.

Tipo di applicazione Messaggio
App WPF Il thread chiamante non può accedere a questo oggetto perché è proprietario di un thread diverso.
App UWP L'applicazione ha chiamato un'interfaccia di cui è stato effettuato il marshalling per un thread diverso.
Windows App Forms Operazione tra thread non valida: controllo 'TextBox1' a cui si accede da un thread diverso dal thread in cui è stato creato.

I framework dell'interfaccia utente per il .NET Framework implementano un modello dispatcher che include un metodo per controllare se una chiamata a un membro di un elemento dell'interfaccia utente viene eseguita nel thread dell'interfaccia utente e altri metodi per pianificare la chiamata nel thread dell'interfaccia utente:

  • Nelle app WPF chiamare il metodo Dispatcher.CheckAccess per determinare se un metodo è in esecuzione in un thread non dell'interfaccia utente. Restituisce se true il metodo è in esecuzione nel thread dell'interfaccia utente e in caso false contrario. Chiamare uno degli overload del metodo per Dispatcher.Invoke pianificare la chiamata nel thread dell'interfaccia utente.

  • Nelle app UWP controllare la CoreDispatcher.HasThreadAccess proprietà per determinare se un metodo è in esecuzione in un thread non dell'interfaccia utente. Chiamare il metodo CoreDispatcher.RunAsync per eseguire un delegato che aggiorna il thread dell'interfaccia utente.

  • Nelle Windows Forms usare la proprietà per determinare se un Control.InvokeRequired metodo è in esecuzione in un thread non dell'interfaccia utente. Chiamare uno degli overload del metodo per eseguire un delegato Control.Invoke che aggiorna il thread dell'interfaccia utente.

Gli esempi seguenti illustrano l'eccezione generata quando si tenta di aggiornare un elemento dell'interfaccia utente da un thread diverso InvalidOperationException dal thread che lo ha creato. Per ogni esempio è necessario creare due controlli:

  • Controllo casella di testo denominato textBox1 . In un'app Windows Forms, è necessario impostarne Multiline la proprietà su true .

  • Controllo pulsante denominato threadExampleBtn . Nell'esempio viene fornito un gestore, ThreadsExampleBtn_Click , per l'evento del Click pulsante.

In ogni caso, il threadExampleBtn_Click gestore eventi chiama il metodo due DoSomeWork volte. La prima chiamata viene eseguita in modo sincrono e ha esito positivo. Ma 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. Verrà generata InvalidOperationException un'eccezione.

App WPF e UWP

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

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

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

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

    // Report completion.
    var msg = String.Format("Some work completed in {0} ms.\n", milliseconds);
    textBox1.Text += msg;
}
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 versione seguente del metodo DoSomeWork elimina l'eccezione in un'app WPF.

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

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

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

La versione seguente del metodo DoSomeWork elimina l'eccezione in un'app UWP.

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

    // Report completion.
    bool uiAccess = textBox1.Dispatcher.HasThreadAccess;
    String msg = String.Format("Some work completed in {0} ms. on {1}UI thread\n",
                               milliseconds, uiAccess ? String.Empty : "non-");
    if (uiAccess)
        textBox1.Text += msg;
    else
        await textBox1.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { textBox1.Text += msg; });
}
Private Async Sub DoSomeWork(milliseconds As Integer)
    ' Simulate work.
    Await Task.Delay(milliseconds)

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

App di Windows Form

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 metodo DoSomeWork elimina l'eccezione in un'app Windows Forms.

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

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

    if (uiMarshal) {
        textBox1.Invoke(new Action(() => { textBox1.Lines = lines.ToArray(); }));
    }
    else {
        textBox1.Lines = lines.ToArray();
    }
}
Private Async Sub DoSomeWork(milliseconds As Integer)
    ' Simulate work.
    Await Task.Delay(milliseconds)

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

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

Modifica di una raccolta durante l'iterazione

L'istruzione in C# o in Visual Basic viene usata per scorrere i membri di una raccolta e foreach per leggere o modificare i singoli For Each elementi. Tuttavia, non può essere usato per aggiungere o rimuovere elementi dalla raccolta. In questo modo viene generata InvalidOperationException un'eccezione con un messaggio simile a " La raccolta è stata modificata. L'operazione di enumerazione potrebbe non essere eseguita.

Nell'esempio seguente viene eseguito un'iterazione di una raccolta di numeri interi che tenta di aggiungere il quadrato di ogni numero intero alla raccolta. Nell'esempio viene generata InvalidOperationException un'eccezione con la prima chiamata al List<T>.Add metodo .

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:

  • Se è necessario aggiungere elementi alla raccolta durante l'iterazione, è possibile eseguire l'iterazione in base all'indice usando for l'istruzione anziché foreach o For Each . Nell'esempio seguente viene utilizzata l'istruzione for per aggiungere il quadrato di numeri nella raccolta alla raccolta .

    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 esce dal ciclo in modo appropriato, scorrendo all'indietro, da Count - 1 a 0 oppure, come nell'esempio, assegnando il numero di elementi della matrice a una variabile e usandolo per stabilire il limite superiore del ciclo. In caso contrario, se un elemento viene aggiunto alla raccolta a ogni iterazione, viene restituito un ciclo infinito.

  • 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. Nell'esempio seguente viene utilizzato questo approccio per aggiungere il quadrato dei numeri di una raccolta a una raccolta temporanea e quindi per combinare le raccolte in un singolo oggetto matrice.

    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 confrontati

I metodi di ordinamento per utilizzo generico, ad esempio il metodo o , richiedono in genere che almeno uno degli oggetti da ordinare Array.Sort(Array) List<T>.Sort() implementi IComparable<T> l'interfaccia o IComparable . In caso contrario, la raccolta o la matrice non può essere ordinata e il metodo genera InvalidOperationException un'eccezione. Nell'esempio seguente viene definita Person una classe , vengono archiviati due oggetti in un oggetto generico e viene effettuato un tentativo di Person List<T> ordinarli. Come illustrato nell'output dell'esempio, la chiamata al List<T>.Sort() metodo genera un'eccezione 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:

  • Se è possibile essere proprietari del tipo che si sta tentando di ordinare, ovvero se si controlla il codice sorgente, è possibile modificarlo per implementare IComparable<T> l'interfaccia o IComparable . A questo scopo è necessario implementare IComparable<T>.CompareTo il metodo o CompareTo . L'aggiunta di un'implementazione dell'interfaccia a un tipo esistente non è una modifica di rilievo.

    Nell'esempio seguente viene utilizzato questo approccio per fornire IComparable<T> un'implementazione per la Person classe . È 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.

    using System;
    using System.Collections.Generic;
    
    public class Person : IComparable<Person>
    {
       public Person(String fName, String lName)
       {
          FirstName = fName;
          LastName = lName;
       }
    
       public String FirstName { get; set; }
       public String LastName { get; set; }
    
       public int CompareTo(Person other)
       {
          return String.Format("{0} {1}", LastName, FirstName).
                 CompareTo(String.Format("{0} {1}", other.LastName, other.FirstName));
       }
    }
    
    public class Example
    {
       public static void Main()
       {
          var people = new List<Person>();
    
          people.Add(new Person("John", "Doe"));
          people.Add(new Person("Jane", "Doe"));
          people.Sort();
          foreach (var person in people)
             Console.WriteLine("{0} {1}", person.FirstName, person.LastName);
       }
    }
    // The example displays the following output:
    //       Jane Doe
    //       John Doe
    
    Imports System.Collections.Generic
    
    Public Class Person : Implements IComparable(Of Person)
       Public Sub New(fName As String, lName As String)
          FirstName = fName
          LastName = lName
       End Sub
       
       Public Property FirstName As String
       Public Property LastName As String
       
       Public Function CompareTo(other As Person) As Integer _
              Implements IComparable(Of Person).CompareTo
          Return String.Format("{0} {1}", LastName, FirstName).
                CompareTo(String.Format("{0} {1}", other.LastName, other.FirstName))    
       End Function
    End Class
    
    Module Example
       Public Sub Main()
          Dim people As New List(Of Person)()
          
          people.Add(New Person("John", "Doe"))
          people.Add(New Person("Jane", "Doe"))
          people.Sort()
          For Each person In people
             Console.WriteLine("{0} {1}", person.FirstName, person.LastName)
          Next
       End Sub
    End Module
    ' The example displays the following output:
    '       Jane Doe
    '       John Doe
    
  • Se non è possibile modificare il codice sorgente per il tipo che si sta tentando di ordinare, è possibile definire una classe di ordinamento speciale che implementa IComparer<T> l'interfaccia . È possibile chiamare un overload del Sort metodo che include un parametro IComparer<T> . Questo approccio è particolarmente utile se si vuole sviluppare una classe di ordinamento specializzata in grado di ordinare gli oggetti in base a più criteri.

    L'esempio seguente usa l'approccio sviluppando una classe PersonComparer personalizzata usata per ordinare le Person raccolte. Passa quindi un'istanza di questa classe al List<T>.Sort(IComparer<T>) metodo .

    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, è possibile creare un delegato Comparison<T> per eseguire l'ordinamento. La firma del delegato è

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

    Nell'esempio seguente viene utilizzato l'approccio definendo un PersonComparison metodo che corrisponde alla firma del Comparison<T> delegato. Passa quindi questo delegato al List<T>.Sort(Comparison<T>) metodo .

    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 oggetto Nullable <T> null al tipo sottostante

Il tentativo di eseguire il cast di un valore nel tipo sottostante genera un'eccezione e visualizza il messaggio di errore " L'oggetto Nullable<T> null InvalidOperationException nullable deve avere un valore.

L'esempio seguente genera un'eccezione quando tenta di scorrere una InvalidOperationException matrice che include un valore Nullable(Of Integer) .

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:

L'esempio seguente esegue entrambe le operazioni per evitare InvalidOperationException l'eccezione.

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 di un metodo System.Linq.Enumerable su una raccolta vuota

I metodi , , , , , , eseguono Enumerable.Aggregate operazioni su una sequenza e Enumerable.Average Enumerable.First Enumerable.Last Enumerable.Max Enumerable.Min Enumerable.Single Enumerable.SingleOrDefault restituiscono un singolo risultato. Alcuni overload di questi metodi generano InvalidOperationException un'eccezione quando la sequenza è vuota, mentre altri overload restituiscono null . Il Enumerable.SingleOrDefault metodo genera anche un'eccezione quando la sequenza contiene più di un InvalidOperationException elemento.

Nota

La maggior parte dei metodi che generano InvalidOperationException un'eccezione sono overload. Assicurarsi di aver compreso il comportamento dell'overload scelto.

Nella tabella seguente sono elencati i messaggi di eccezione provenienti InvalidOperationException dagli oggetti eccezione generati dalle chiamate ad alcuni System.Linq.Enumerable metodi.

Metodo Messaggio
Aggregate
Average
Last
Max
Min
La sequenza non contiene elementi
First La sequenza non contiene elementi corrispondenti
Single
SingleOrDefault
La sequenza contiene più di un elemento corrispondente

La modalità di eliminazione o gestione dell'eccezione dipende dai presupposti dell'applicazione e dal metodo specifico chiamato.

  • Quando si chiama intenzionalmente uno di questi metodi senza cercare una sequenza vuota, si presuppone che la sequenza non sia vuota e che una sequenza vuota sia un'occorrenza imprevista. In questo caso, l'intercettazione o la rigenerazione dell'eccezione è appropriata.

  • Se non è stato possibile verificare la presenza di una sequenza vuota inavvertitamente, è possibile chiamare uno degli overload dell'overload per determinare se una sequenza contiene Enumerable.Any elementi.

    Suggerimento

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

  • Se è stato chiamato un metodo come , o , è possibile sostituire un metodo alternativo, ad esempio , o , che restituisce un valore predefinito anziché un membro Enumerable.First Enumerable.Last della Enumerable.Single Enumerable.FirstOrDefault Enumerable.LastOrDefault Enumerable.SingleOrDefault sequenza.

Gli esempi forniscono dettagli aggiuntivi.

Nell'esempio seguente viene Enumerable.Average utilizzato il metodo per calcolare la media di una sequenza i cui valori sono maggiori di 4. Poiché nessun valore della matrice originale supera 4, nella sequenza non viene incluso alcun valore e il metodo genera InvalidOperationException un'eccezione.

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 metodo per determinare se la sequenza contiene elementi prima di chiamare il metodo che elabora la sequenza, come illustrato Any nell'esempio seguente.

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 metodo restituisce il primo elemento di una sequenza o il primo elemento di una sequenza che soddisfa Enumerable.First una condizione specificata. Se la sequenza è vuota e pertanto non dispone di un primo elemento, viene generata InvalidOperationException un'eccezione.

Nell'esempio seguente il metodo genera un'eccezione perché la matrice dbQueryResults non contiene Enumerable.First<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) un elemento maggiore di InvalidOperationException 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 anziché per restituire un valore specificato o Enumerable.First predefinito. Se il metodo non trova un primo elemento nella sequenza, restituisce il valore predefinito per quel tipo di dati. Il valore predefinito è null per un tipo riferimento, zero per un tipo di dati numerico e DateTime.MinValue per il tipo DateTime .

Nota

L'interpretazione del valore restituito dal metodo è spesso complicata dal fatto che il valore predefinito del tipo può essere un Enumerable.FirstOrDefault valore valido nella sequenza. In questo caso, si chiama il Enumerable.Any metodo per determinare se la sequenza dispone di membri validi prima di chiamare il Enumerable.First metodo .

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

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 elemento

Il Enumerable.Single metodo restituisce l'unico elemento di una sequenza o l'unico elemento di una sequenza che soddisfa una condizione specificata. Se non sono presenti elementi nella sequenza o se è presente più di un elemento , il metodo genera InvalidOperationException un'eccezione.

È possibile usare il Enumerable.SingleOrDefault metodo per restituire un valore predefinito anziché generare un'eccezione quando la sequenza non contiene elementi. Tuttavia, il Enumerable.SingleOrDefault metodo genera comunque InvalidOperationException un'eccezione quando la sequenza contiene più di un elemento.

Nella tabella seguente sono elencati i messaggi di eccezione provenienti dagli oggetti InvalidOperationException eccezione generati dalle chiamate ai metodi e Enumerable.Single Enumerable.SingleOrDefault .

Metodo Messaggio
Single La sequenza non contiene elementi corrispondenti
Single
SingleOrDefault
La sequenza contiene più di un elemento corrispondente

Nell'esempio seguente la chiamata al metodo genera un'eccezione perché la sequenza non ha un elemento Enumerable.Single InvalidOperationException maggiore di 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 si tenta di impedire InvalidOperationException l'eccezione generata quando una sequenza è vuota chiamando invece il Enumerable.SingleOrDefault metodo . Tuttavia, poiché questa sequenza restituisce più elementi il cui valore è maggiore di 2, genera anche InvalidOperationException un'eccezione.

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 al metodo presuppone che una sequenza o la sequenza che soddisfa i criteri specificati Enumerable.Single contenga un solo elemento. Enumerable.SingleOrDefault presuppone una sequenza con zero o un risultato, ma non più. Se questo presupposto è intenzionale da parte dell'utente e queste condizioni non vengono soddisfatte, è appropriato rigenerare o intercettare InvalidOperationException il risultato. In caso contrario, o se si prevede che si verifichino condizioni non valide con una certa frequenza, è consigliabile usare un altro Enumerable metodo, ad esempio FirstOrDefault o Where .

Accesso dinamico ai campi di dominio tra applicazioni

L'istruzione MSIL (Microsoft Intermediate Language) genera un'eccezione se l'oggetto contenente il campo il cui indirizzo si sta tentando di recuperare non si trova all'interno del dominio applicazione in cui è in esecuzione OpCodes.Ldflda InvalidOperationException il codice. L'indirizzo di un campo è accessibile solo dal dominio dell'applicazione in cui si trova.

Generazione di un'eccezione InvalidOperationException

È consigliabile generare InvalidOperationException un'eccezione solo quando lo stato dell'oggetto per qualche motivo non supporta una particolare chiamata al metodo. Ciò significa che la chiamata al metodo è valida in alcune circostanze o contesti, ma non è valida in altri.

Se l'errore di chiamata al metodo è dovuto a argomenti non validi, è necessario generare invece o una delle relative classi ArgumentException ArgumentNullException ArgumentOutOfRangeException derivate, o .

Informazioni varie

InvalidOperationException usa il valore HRESULT COR_E_INVALIDOPERATION, che ha il valore 0x80131509.

Per un elenco di valori di proprietà iniziali per un'istanza di InvalidOperationException, vedere il InvalidOperationException costruttori.

Costruttori

InvalidOperationException()

Inizializza una nuova istanza della classe InvalidOperationException.

InvalidOperationException(SerializationInfo, StreamingContext)

Inizializza una nuova istanza della classe InvalidOperationException con dati serializzati.

InvalidOperationException(String)

Inizializza una nuova istanza della classe InvalidOperationException con un messaggio di errore specificato.

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.

Proprietà

Data

Ottiene una raccolta di coppie chiave/valore che forniscono informazioni definite dall'utente aggiuntive sull'eccezione.

(Ereditato da Exception)
HelpLink

Ottiene o imposta un collegamento al file della Guida associato all'eccezione.

(Ereditato da Exception)
HResult

Ottiene o imposta HRESULT, un valore numerico codificato che viene assegnato a un'eccezione specifica.

(Ereditato da Exception)
InnerException

Ottiene l'istanza di Exception che ha causato l'eccezione corrente.

(Ereditato da Exception)
Message

Ottiene un messaggio che descrive l'eccezione corrente.

(Ereditato da Exception)
Source

Ottiene o imposta il nome dell'oggetto o dell'applicazione che ha generato l'errore.

(Ereditato da Exception)
StackTrace

Ottiene una rappresentazione di stringa dei frame immediati nello stack di chiamate.

(Ereditato da Exception)
TargetSite

Ottiene il metodo che genera l'eccezione corrente.

(Ereditato da Exception)

Metodi

Equals(Object)

Determina se l'oggetto specificato è uguale all'oggetto corrente.

(Ereditato da Object)
GetBaseException()

Quando ne viene eseguito l'override in una classe derivata, restituisce l'Exception che è la causa radice di una o più eccezioni successive.

(Ereditato da Exception)
GetHashCode()

Funge da funzione hash predefinita.

(Ereditato da Object)
GetObjectData(SerializationInfo, StreamingContext)

Quando ne viene eseguito l'override in una classe derivata, imposta il controllo SerializationInfo con le informazioni sull'eccezione.

(Ereditato da Exception)
GetType()

Ottiene il tipo di runtime dell'istanza corrente.

(Ereditato da Exception)
MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.

(Ereditato da Object)
ToString()

Crea e restituisce una rappresentazione di stringa dell'eccezione corrente.

(Ereditato da Exception)

Eventi

SerializeObjectState
Obsoleta.

Si verifica quando un'eccezione viene serializzata per creare un oggetto di stato eccezione contenente i dati serializzati relativi all'eccezione.

(Ereditato da Exception)

Si applica a

Vedi anche