Welcome to the “Important Interface in C#” article series. In this series we will be talking about various useful interfaces of the .NET class library. In our previous articles we have talked about the IEnumerable, ICollection and IComparable interfaces, you can read them from here.
Important Interface in .NET: Work with Ienumerable Interface
Important Interface in .NET: Work with ICollection Interface
Important Interface in .NET: Work with IComparable Interface
In this article we will learn the IList interface in the .NET class library. If you are an experienced .NET developer then you might know how a List collection helps in our day-to-day programming life.
The IList interface represents a non-generic collection that can accessed by an index.
The IList interface has one generic and another non-generic version as in the following:
- IList: without argument
- IList<T>: argument of type T
The IList interface is located in the .NET class library as in the following:
- Namespace: System.Collection
- Assembly : mscorlib.dll
IList<T> is located in the .NET class library as in the following:
- Namespace: System.Collection.Generic
- Assembly : mscorlib.dll
Defination of the IList interface
Here is the implementation of the IList interface. We are seeing that the IList interface implements the ICollection and IEnumerable interfaces so that we can use the methods and properties of the ICollection and IEnumerable interfaces from the IList interface.
public interface IList : ICollection, IEnumerable
public interface IList : ICollection, IEnumerable
{
bool IsFixedSize { get; }
bool IsReadOnly { get; }
Object this[int index] { get; set; }
int Add(Object value);
void Clear();
bool Contains(Object value);
int IndexOf(Object value);
void Insert(int index, Object value);
void Remove(Object value);
void RemoveAt(int index);
}
IList has three properties and seven methods that we can use to manipulate a collection that is derived from the IList interface.
Definition of IList<T> interface
Here is a generic version of the IList interface.
public interface IList<T> : ICollection<T>, IEnumerable<T>, IEnumerable
public interface IList<T> : ICollection<T>, IEnumerable<T>, IEnumerable
{
T this[int index] { get; set; }
int IndexOf(T item);
void Insert(int index, T item);
void RemoveAt(int index);
}
It contains one property and three methods.
Ok, now it’s time to implement an example of an IList and an IList<T>.
Since List<T> implements an IList interface, we can initialize an IList with the object of List<T>. Here is a sample implementation.
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace SelfHostingWebAPI
{
class Program
{
static void Main(string[] args)
{
//Implement IList into List with premetive data type
//as parameter
IList li1 = new List<int>();
li1.Add(10);
IList li2 = new List<string>();
li2.Add("sourav");
IList li3 = new List<double>();
li3.Add(10.10);
Console.WriteLine(li1[0]);
Console.WriteLine(li2[0]);
Console.WriteLine(li3[0]);
Console.ReadLine();
}
}
}
We are passing various arguments instead of T in the List and initiating an IList object. This is the output of the example above.
![]()
In the example above we have passed a predefined data type as the argument/parameter of List<T> and in this example we will pass a user-defined data type or object of our own class as the argument. Have a look at the following example.
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace SelfHostingWebAPI
{
class Person
{
public string name { get; set; }
public string surname { get; set; }
}
class Program
{
static void Main(string[] args)
{
//Implement IList into List with User defined data type
//as parameter
Person p1 = new Person();
p1.name = "Sourav";
p1.surname = "Kayal";
IList list = new List<Person>();
list.Add(p1);
Console.WriteLine(((Person)list[0]).name + " " + ((Person)list[0]).surname);
Console.ReadLine();
}
}
}
![]()
Let’s implement a few examples using IList<T> In this example we will pass our own object instead of T. Have a look at the following example.
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace SelfHostingWebAPI
{
public class Person
{
public Int16 ID { get; set; }
public string name { get; set; }
public string surname { get; set; }
}
class Program
{
static void Main(string[] args)
{
List<Person> person = new List<Person>();
person.Add(new Person { ID = 1, name = "sourav", surname = "kayal" });
person.Add(new Person { ID = 2, name = "Ram", surname = "Kumar" });
person.Add(new Person { ID = 3, name = "shyam", surname = "Kumar" });
foreach (Person p in person)
{
Console.WriteLine(p.ID + " " + p.name + " " + p.surname);
}
Console.ReadLine();
}
}
}
Here is the output of the example above:
![]()
ConclusionIn this example we learned the concept of the IList and IList<T> interfaces that developers use every now and then in application development. In a future article we will look at a few more interfaces in the .NET class library.