<p>I know that IList is the interface and List is the concrete type but I still don't know when to use each one. What I'm doing now is if I don't need the Sort or FindAll methods I use the interface. Am I right? Is there a better way to decide when to use the interface or the concrete type?</p>

I don't think there are hard and fast rules for this type of thing, but I usually go by the guideline of using the lightest possible way until absolutely necessary.
For example, let's say you have a
```
Person
```
class and a
```
Group
```
class. A
```
Group
```
instance has many people, so a List here would make sense. When I declare the list object in
```
Group
```
I will use an
```
IList<Person>
```
and instantiate it as a
```
List
```
.
```
```
public class Group {
  private IList<Person> people;

  public Group() {
    this.people = new List<Person>();
  }
}
```
```
And, if you don't even need everything in
```
IList
```
you can always use
```
IEnumerable
```
too. With modern compilers and processors, I don't think there is really any speed difference, so this is more just a matter of style.