Generic lists can in fact be serialized and deserialized directly.
There's no problem if some of the elements are of types derived from the type parameter as long as all such types are marked with the Serializable attribute which is not inherited automatically.
Here's a simple example to illustrate these points:
using System;
using System.IO;
using System.Collections.Generic;
using System.Runtime.Serialization.Formatters.Binary;
class Test
{
static void Main()
{
List<Entity> list = new List<Entity>();
Entity e = new Entity();
e.Id = 1;
ChildEntity ce = new ChildEntity();
ce.Id = 2;
ce.Name = "Fred";
list.Add(e);
list.Add(ce);
Serialize(list);
List<Entity> list2 = Deserialize();
Console.WriteLine(list2[0].Id);
ChildEntity ce2 = (ChildEntity)list2[1];
Console.WriteLine(ce2.Id);
Console.WriteLine(ce2.Name);
Console.ReadKey();
}
static void Serialize(List<Entity> list)
{
using (FileStream stream = new FileStream("save.bin", FileMode.Create))
{
BinaryFormatter formatter = new BinaryFormatter();
formatter.Serialize(stream, list);
}
}

static List<Entity> Deserialize()
{
List<Entity> list = null;
using (FileStream stream = new FileStream("save.bin", FileMode.Open))
{
BinaryFormatter formatter = new BinaryFormatter();
list = (List<Entity>)formatter.Deserialize(stream);
}
return list;
}
}
[Serializable]
class Entity
{
public int Id;
}
[Serializable]
class ChildEntity : Entity
{
public string Name;
}

what's the difference between:
[Serializable]
class MyClass
[Serializable()]
class MyClass
class MyClass : ISerializable

There's no difference between the first two - when an attribute constructor doesn't require any arguments, the following () is optional.
The Serializable attribute provides default (de)serialization behaviour which is sufficient for most purposes.
If you need complete control over how a type is serialized or deserialized, then your type should implement the ISerializable interface as well. This interface has one method, GetObjectData, which the serializable type must implement.
Typically, you'd implement ISerializable to control serialization behaviour at runtime (as opposed to compile time).
It's also used by library writers to make serializable types easier to inherit from by consumers of the library. You can do this by making the GetObjectData method virtual so that it can be overridden by derived classes which can thereby extend the serialization behaviour of the base class without the need to reimplement the interface.