How to check if IEnumerable is a List?

Given an IEnumerable, how can I check if its type is List?

Given an IEnume开发者_JS百科rable, I want to perform List methods, but if it's a List already I will simply cast it rather that using .ToList()

---

Use the is operator to test the type of the variable.

if(myIEnumerable is IList)
{
   // it is a List (may still need casting in order to use List specific methods)
}

---

List list = (yourEnumerable as List) ?? yourEnumerable.ToList();

---

var myList = myIEnumerable as List ?? myIEnumerable.ToList();

or

var myList = (myIEnumerable as List<Type>) ?? myIEnumerable.ToList();

---

You can use is or as operators.

---

Couple of ways:

List<int> list = myColl as List<int>;
if (list != null) // ...

or

if (myColl is List<int>) // ...

or

if (myColl.GetType() == typeof(List<int>) // ...

---

I've often wished for a bigger selection of collection-related interfaces, especially ICountableEnumerable and IReadableByIndex. The former could have been added in the design of .Net without adding extra code by implementors; the former would probably have required the addition of a GetByIndex method to avoid conflicts with the read/write indexer present in a full IList, but would IMHO still have been a worthwhile addition since it could be contravariant.

As it is, it's possible that an object may be a generic IList but not very well usable for your purposes because it may be an IList of a type which is derived from the type you're expecting. For example, if your routine were expecting an IEnumerable(Of Car) but were passed an IList(Of HondaCivic), it would be nice if you could use its read-by-index function. If IList(Of T) inherited from IReadableByIndex(Of T), as described above, an IList(Of HondaCivic) could be cast to an IReadableByIndex(Of Car). Unfortunately, such a cast isn't possible with a read-write interface.

Still, using a generic routine to process the list may make it possible to avoid an unnecessary conversion even in such case. The following short VB class illustrates:

Class GenericTest
    Class myThing
        Public Value As String
        Sub New(ByVal X As String)
            Value = X
        End Sub
    End Class
    Class myDerived
        Inherits myThing
        Sub New(ByVal x As String)
            MyBase.New(x)
        End Sub
    End Class
    Shared Sub ReversePrint(Of T As myThing)(ByVal theList As IEnumerable(Of T))
        Dim castAsList As IList(Of T) = TryCast(theList, IList(Of T))
        If castAsList Is Nothing Then
            castAsList = theList.ToList
            Debug.Print("Converting to list")
        Else
            Debug.Print("List was good")
        End If
        For i As Integer = castAsList.Count - 1 To 0 Step -1
            Debug.Print(castAsList(i).Value.ToString)
        Next
    End Sub
    Shared Sub Test()
        Dim myList As New List(Of myDerived)
        For i As Integer = 1 To 5
            myList.Add(New myDerived("Item " & i.ToString))
        Next
        ReversePrint(myList)
        ReversePrint(Of myThing)(myList)
    End Sub
End Class

The ReversePrint function casts or converts an IEnumerable to an IList and outputs it in reverse order. Note that the routine is really "expecting" an IEnumerable(Of myThing), but accepts its parameter as an IEnumerable(Of T). Thus, if the compiler knows that it implements IEnumerable(Of myDerived), it can offer up MyDerived as a type parameter. When doing so, the object can be cast to an IList(of MyDerived). If one prevents the generic parameter from conforming to the original object, the object will be passed to the routine just fine, but the try-typecast won't work and thus it will be necessary to convert the item to an IList conforming to the passed-in type parameter.

PS--One of my wish-list items for .Net 5.0 would be the ability for an interface to specify a default implementation of a method for use in case a class which is supposed to implement a method doesn't provide one. This could allow Microsoft to have IList inherit from a contravariant IReadableByIndex interface (and possibly covariant IWritableByIndex and IAppendable interfaces) without breaking existing code.