Enumerable.AsEnumerable<TSource> Method

Type Parameters

• TSource
  The type of the elements of source.

Parameters

• source
  Type: System.Collections.Generic.IEnumerable<TSource>
  The sequence to type as IEnumerable<T>.

Return Value

Type: System.Collections.Generic.IEnumerable<TSource>
The input sequence typed as IEnumerable<T>.

   Dim output As New System.Text.StringBuilder

   ' A custom class.
   Class Clump(Of T)
      Inherits List(Of T)

      ' Constructor.
      Public Sub New(ByVal collection As System.Collections.Generic.IEnumerable(Of T))
         MyBase.New(collection)
      End Sub

      ' Custom implementation of Where().
      Function Where(ByVal predicate As Func(Of T, Boolean)) As IEnumerable(Of T)
         output.AppendLine("In Clump's implementation of Where().")
         Return Enumerable.Where(Me, predicate)
      End Function
   End Class

   Sub AsEnumerableEx1()
      ' Create a new Clump(Of T) object.
      Dim fruitClump As New Clump(Of String)(New String() _
                                             {"apple", "passionfruit", "banana", _
                                              "mango", "orange", "blueberry", _
                                              "grape", "strawberry"})

      ' First call to Where():
      ' Call Clump's Where() method with a predicate.
      Dim query1 As IEnumerable(Of String) = _
          fruitClump.Where(Function(fruit) fruit.Contains("o"))
      output.AppendLine("query1 has been created." & vbCrLf)

      ' Second call to Where():
      ' First call AsEnumerable() to hide Clump's Where() method and thereby
      ' force System.Linq.Enumerable's Where() method to be called.
      Dim query2 As IEnumerable(Of String) = _
          fruitClump.AsEnumerable().Where(Function(fruit) fruit.Contains("o"))
      output.AppendLine("query2 has been created.")

      ' Display the output.
      outputBlock.Text += output.ToString() + vbCrLf
   End Sub

   ' This code produces the following output:
   '
   ' In Clump's implementation of Where().
   ' query1 has been created.
   '
   ' query2 has been created.

   // Custom class.
   class Clump<T> : List<T>
   {
      // Custom implementation of Where().
      public IEnumerable<T> Where(Func<T, bool> predicate)
      {
         outputBlock.Text += "In Clump's implementation of Where()." + "\n";
         return Enumerable.Where(this, predicate);
      }
   }

   static void AsEnumerableEx1()
   {
      // Create a new Clump<T> object.
      Clump<string> fruitClump =
          new Clump<string> { "apple", "passionfruit", "banana", 
                 "mango", "orange", "blueberry", "grape", "strawberry" };

      // First call to Where():
      // Call Clump's Where() method with a predicate.
      IEnumerable<string> query1 =
          fruitClump.Where(fruit => fruit.Contains("o"));

      outputBlock.Text += "query1 has been created.\n" + "\n";

      // Second call to Where():
      // First call AsEnumerable() to hide Clump's Where() method and thereby
      // force System.Linq.Enumerable's Where() method to be called.
      IEnumerable<string> query2 =
          fruitClump.AsEnumerable().Where(fruit => fruit.Contains("o"));

      // Display the output.
      outputBlock.Text += "query2 has been created." + "\n";
   }

   // This code produces the following output:
   //
   // In Clump's implementation of Where().
   // query1 has been created.
   //
   // query2 has been created.