Function Comparison(Of T)(x As T, y As T) As Integer  
int Comparison<T>(T x, T y)  
以下示例通过定义  PersonComparison 与委托签名匹配  Comparison<T> 的方法来使用此方法。  然后，它将此委托传递给 List<T>.Sort(Comparison<T>) 方法。
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
open System
open System.Collections.Generic
type Person(firstName, lastName) =
    member val FirstName = firstName with get, set
    member val LastName = lastName with get, set
let personComparison (x: Person) (y: Person) =
    $"{x.LastName} {x.FirstName}".CompareTo $"{y.LastName} {y.FirstName}"
let people = ResizeArray()
people.Add(Person("John", "Doe"))
people.Add(Person("Jane", "Doe"))
people.Sort personComparison
for person in people do
    printfn $"{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
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)
   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
将可为 Null 的可为 Null<T> 强制转换为其基础类型
尝试强制转换 Nullable<T> 其基础类型的值 null 会 InvalidOperationException 引发异常并显示错误消息“可为 Null 的对象必须具有值。
以下示例尝试循环访问包含Nullable(Of Integer)值的数组时引发InvalidOperationException异常。
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()
open System
open System.Linq
let queryResult = [| Nullable 1; Nullable 2; Nullable(); Nullable 4 |]
let map = queryResult.Select(fun nullableInt -> nullableInt.Value)
// Display list.
for num in map do
    printf $"{num} "
printfn ""
// 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 <StartupCode$fs>.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)
      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()
若要防止异常：
Nullable<T>.HasValue使用属性仅选择那些不是null元素的元素。
调用其中 Nullable<T>.GetValueOrDefault 一个重载来提供值的默认值 null 。
以下示例同时执行这两项操作以避免  InvalidOperationException 异常。
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
open System
open System.Linq
let queryResult = [| Nullable 1; Nullable 2; Nullable(); Nullable 4 |]
let numbers = queryResult.Select(fun nullableInt -> nullableInt.GetValueOrDefault())
// Display list using Nullable<int>.HasValue.
for number in numbers do
    printf $"{number} "
printfn ""
let numbers2 = queryResult.Select(fun nullableInt -> if nullableInt.HasValue then nullableInt.Value else -1)
// Display list using Nullable<int>.GetValueOrDefault.
for number in numbers2 do
    printf $"{number} "
printfn ""
// 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)
      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)
      Console.WriteLine()
   End Sub
End Module
' The example displays the following output:
'       1 2 0 4
'       1 2 -1 4
对空集合调用 System.Linq.Enumerable 方法
Enumerable.Aggregate、Enumerable.Average、Enumerable.First、Enumerable.Last、Enumerable.Max、Enumerable.MinEnumerable.Single和Enumerable.SingleOrDefault方法对序列执行操作并返回单个结果。   当序列为空时，这些方法的某些重载会引发 InvalidOperationException 异常，而其他重载则返回 null。 当序列包含多个元素时，该方法 Enumerable.SingleOrDefault 也会引发 InvalidOperationException 异常。
引发 InvalidOperationException 异常的大多数方法是重载。 请确保了解所选重载的行为。
下表列出了调用某些System.Linq.Enumerable方法引发的异常对象中的异常消息InvalidOperationException。
Message
如何消除或处理异常取决于应用程序的假设和调用的特定方法。
当你故意调用其中一种方法而不检查空序列时，假设序列不为空，并且空序列是意外发生的。 在这种情况下，捕获或重新引发异常是适当的。

如果未能检查空序列无意中，可以调用重载的 Enumerable.Any 重载之一以确定序列是否包含任何元素。

Enumerable.Any<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)如果要处理的数据可能包含大量元素，或者生成序列的操作成本高昂，则生成序列之前调用该方法可以提高性能。
如果已调用方法（例如，或）可以替换返回默认值而不是序列成员的备用方法（例如Enumerable.FirstOrDefaultEnumerable.LastOrDefault，或Enumerable.SingleOrDefault）。Enumerable.SingleEnumerable.LastEnumerable.First

这些示例提供了更多详细信息。
以下示例使用 Enumerable.Average 该方法计算其值大于 4 的序列的平均值。 由于原始数组的值不超过 4，序列中不包含任何值，并且该方法将引发异常 InvalidOperationException 。
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()
open System
open System.Linq
let data = [| 1; 2; 3; 4 |]
let average = 
   data.Where(fun num -> num > 4).Average();
printfn $"The average of numbers greater than 4 is {average}"
// The example displays the following output:
//    Unhandled Exception: System.InvalidOperationException: Sequence contains no elements
//       at System.Linq.Enumerable.Average(IEnumerable`1 source)
//       at <StartupCode$fs>.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()
通过调用 Any 方法来确定序列是否包含任何元素，然后调用处理序列的方法之前，可以消除异常，如以下示例所示。
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());
           // 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.
open System
open System.Linq
let dbQueryResults = [| 1; 2; 3; 4 |]
let moreThan4 = 
    dbQueryResults.Where(fun num -> num > 4)
if moreThan4.Any() then
    printfn $"Average value of numbers greater than 4: {moreThan4.Average()}:"
    // handle empty collection
    printfn "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())
           ' 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.
该方法 Enumerable.First 返回序列中的第一项或满足指定条件的序列中的第一个元素。 如果序列为空，因此没有第一个元素，则会引发 InvalidOperationException 异常。
在下面的示例中，该方法 Enumerable.First<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) 会引发异常 InvalidOperationException ，因为 dbQueryResults 数组不包含大于 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()
open System
open System.Linq
let dbQueryResults = [| 1; 2; 3; 4 |]
let firstNum = dbQueryResults.First(fun n -> n > 4)
printfn $"The first value greater than 4 is {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 <StartupCode$fs>.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()
可以调用 Enumerable.FirstOrDefault 该方法， Enumerable.First 而不是返回指定的或默认值。 如果该方法在序列中找不到第一个元素，则返回该数据类型的默认值。  默认值为 null 引用类型，数值数据类型为零，类型 DateTime.MinValue 为 DateTime 零。
解释方法返回 Enumerable.FirstOrDefault 的值通常很复杂，因为类型默认值可以是序列中的有效值。 在这种情况下，调用 Enumerable.Any 方法以确定序列在调用 Enumerable.First 该方法之前是否具有有效成员。
以下示例调用该方法  Enumerable.FirstOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) 以防止 InvalidOperationException 上一示例中引发的异常。
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.");
         Console.WriteLine("The first value greater than 4 is {0}",
                           firstNum);
// The example displays the following output:
//       No value is greater than 4.
open System
open System.Linq
let dbQueryResults = [| 1; 2; 3; 4 |]
let firstNum = dbQueryResults.FirstOrDefault(fun n -> n > 4)
if firstNum = 0 then
    printfn "No value is greater than 4."
    printfn $"The first value greater than 4 is {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.")
         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.
在没有一个元素的序列上调用 Enumerable.Single 或 Enumerable.SingleOrDefault
该方法 Enumerable.Single 返回序列的唯一元素，或满足指定条件的序列的唯一元素。    如果序列中没有元素，或者如果有多个元素，该方法将引发异常 InvalidOperationException 。
可以使用 Enumerable.SingleOrDefault 该方法返回默认值，而不是在序列不包含任何元素时引发异常。 但是，当序列包含多个元素时，该方法 Enumerable.SingleOrDefault 仍会引发 InvalidOperationException 异常。
下表列出了调用Enumerable.Single和Enumerable.SingleOrDefault方法引发的异常对象中的异常消息InvalidOperationException。
Message
在下面的示例中，对方法的 Enumerable.Single 调用将引发异常 InvalidOperationException ，因为序列没有大于 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()
open System
open System.Linq
let dbQueryResults = [| 1; 2; 3; 4 |]
let singleObject = dbQueryResults.Single(fun value -> value > 4)
// Display results.
printfn $"{singleObject} is the only value greater than 4"
// 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 <StartupCode$fs>.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()
以下示例尝试通过调用方法来防止 InvalidOperationException 序列为空时引发的 Enumerable.SingleOrDefault 异常。 但是，由于此序列返回的值大于 2 的多个元素，因此也会引发异常 InvalidOperationException 。
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);
           // 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()
open System
open System.Linq
let dbQueryResults = [| 1; 2; 3; 4 |]
let singleObject = dbQueryResults.SingleOrDefault(fun value -> value > 2)
if singleObject <> 0 then
    printfn $"{singleObject} is the only value greater than 2"
    // Handle an empty collection.
    printfn "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 <StartupCode$fs>.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)
           ' 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()
Enumerable.Single调用该方法假定序列或满足指定条件的序列仅包含一个元素。  Enumerable.SingleOrDefault 假定序列包含零个或一个结果，但不再包含。 如果此假设是你部分的故意假设，并且不符合这些条件，则重新引发或捕获结果 InvalidOperationException 是适当的。 否则，或者如果预期某些频率会出现无效条件，应考虑使用其他 Enumerable 方法，例如 FirstOrDefault 或 Where。
动态跨应用程序域字段访问
OpCodes.Ldflda Microsoft 中间语言 (MSIL) 指令在包含您尝试检索其地址的字段的对象不在执行代码的应用程序域中时引发InvalidOperationException异常。 只能从它所在的应用程序域中访问字段的地址。
引发 InvalidOperationException 异常
仅当对象的状态出于某种原因不支持特定方法调用时，才应引发 InvalidOperationException 异常。 也就是说，方法调用在某些情况下或上下文中有效，但在其他情况下无效。
如果方法调用失败是由于参数无效，则 ArgumentException 应改为引发其派生类 ArgumentNullException ArgumentOutOfRangeException之一或其中一个。
InvalidOperationException 使用具有值0x80131509的 HRESULT COR_E_INVALIDOPERATION。
有关实例的初始属性值的列表InvalidOperationException，请参阅InvalidOperationException构造函数。