List<MyClass> x = someList.Select(f => (MyClass)f).ToList();

You can't cast List<OneType> to List<OtherType> as it is actually the instances of the list you want to cast, as well as the List itself.

there is an extension method which will allow you to do this (MSDN reference):

IEnumerable<Object> myNewEnumerable = myEnumerable.Cast<Object>();

This method will attempt to cast each instance of the list of one type to the other type and add them to a new enumerable. it will throw an exception if any instance can't be cast.

As far as the system is concerned the two types for your lists are just different types, so it is like saying:

A objectOfTypeA;
B objectOfTypeB = (B) objectofTypeA;

To be able to do the cast there would have to be an implicit or explicit conversion between the types available, which there isn't (unless you provided one, which you might be able to do).

you expect it to work because List<object> will always be able to hold any type in another list, but when you think about it in those terms you can see why it doesn't.

I'm sure there is a more technically competent answer, but that is the gist of it I think.

you might be interested in reading Eric Lippert's series on Covariance and Contravariance as this may be helpful to you.

This question may also be useful

I'm presuming that you mean that the lists are of types which inherit from each other or can otherwise be cast from one type to another - in that case, try this:

Tools.MyMethod(MyListOfQuoteHeaders.Cast<OtherType>());

Thanks for the many responses.

I'll explain what I wanted to do and what I've come up with as a solution.

I needed a method that I could call by passing in a List of objects of any type and then output that list to XML. Also passed to the method would be a string which would be a system file structure path location which points to the location the XML file would be saved to. As I have an ever growing number of classes and types, I wanted to avoid writing multiple methods to cater for each type of class. I'm not sure if I've even gone about this the right way, but it's a lightweight solution to my problem and works. If there are any issues with it, or if anyone has any comments please feel free...

So... my method now looks like this...

    public static Enums.Status WriteListToXML<T>(string outputPath, List<T> inboundList)
    {
        try
        {
            XmlSerializer xmlSerializer = new XmlSerializer(inboundList.GetType());
            using (StreamWriter streamWriter = System.IO.File.CreateText(outputPath))
            {
                xmlSerializer.Serialize(streamWriter, inboundList);
            }
            return Enums.Status.Success;
        }
        catch (Exception ex)
        {
            return Enums.Status.Failure;
        }
    }

... and my calling line reads...

WriteListToXML<QuoteHeader>(@"C:\XMLDocuments\output\QuoteHeaders.xml", quoteHeadersList);

Like I said, it may not be the tidiest solution, but it works well in my scenario.

The problem is that at Compile time, the compiler emits 2 separate classes, 1 that represents List<MyClass> and one that represents List<Object>. They are essentially 2 separate types. That's how Generic types work, in .Net at least.

Assuming this is .Net, you could do

MyListOfQuoteHeaders.Cast<Object>()

which basically does

var objects = new List<Object>();

foreach(var item in MyListOfQuoteHeaders)
{
   objects.Add((object)item);
}

return objects;