Question: Pretty self explanatory question, glad for any answer. For me it doesn't make sense. I don't care about losing information. I just want to concatenate all my lists that inherit IRenderable somehow into a single list and then call IRenderable methods on it.
I have a feeling that this is some basic rule of programming I forgot...

edit: 
This is the code:

```
interface IRenderable
{
    void Render();
}
interface IScreen : IRenderable
{
}
public List<IScreen> Screens = new List<IScreen>();
List<IRenderable> renderList = new List<IRenderable>();
renderList = ((List<IRenderable>)Screens; // error: cannot convert type IScreen to IRenderable

```

edit2: btw, I have .net 4.0 installed, but the reference still stays System.dll Version 2.0.5.0

Answer: 
You don't give a lot of details. But let's assume you have:

```
IRenderable {}

IScreen : IRenderable {}

private List<IRenderable> ConcatLists(IEnumerable<IRenderable> first, IEnumerable<IRenderable> second) { ... }

```

Now, you will not be able to call the ConcatLists method directly with an IEnumerable<IScreen>, in C# versions prior to C#4. The reason for this is called co- and contravariance. In Framework 4, IEnumerable<T> is declared covariant, which means that it can be implicitly converted to a IEnumerable where T is of a lesser type (IRenderable in your case).

If you want to call such a method in C#3, you can use an extension method to help you.

This might be:

```
ConcatLists(first.Cast<IRenderable>(), second);

```

If "first" is declared to be of type IRenderable.
`List<T0>` is not castable to `List<T1>`. You should do casting for every element of list. The Cast extension for IEnumarable is do this:

```
List<IScreen> Screens = new List<IScreen>();
List<IRenderable> renderList = Screens.Cast<IRenderable>().ToList();

```