Regarding a coding style in OOPS & C#

Question

i go through a code sample where i have seen a different way to create a instance.

so code here

public interface IEmployee
{
    System.Int32? EmployeeID { get; set; }
    System.String FirstName { get; set; }
    System.String LastName { get; set; }
    System.DateTime DateOfBirth { get; set; }
    System.Int32? DepartmentID { get; set; }
    System.String FullName();
    System.Single Salary();
}

public class Employee : IEmployee
{
    #region Properties

    public System.Int32? EmployeeID { get; set; }
    public System.String FirstName { get; set; }
    public System.String LastName { get; set; }
    public System.DateTime DateOfBirth { get; set; }
    public System.Int32? DepartmentID { get; set; }

    #endregion

    public Employee(
        System.Int32? employeeid
        , System.String firstname
        , System.String lastname
        , System.DateTime bDay
        , System.Int32? departmentID
    )
    {
        this.EmployeeID = employeeid;
        this.FirstName = firstname;
        this.LastName = lastname;
        this.DateOfBirth = bDay;
        this.DepartmentID = departmentID;
    }

    public Employee() { }

    public System.String FullName()
    {
        System.String s = FirstName + " " + LastName;
        return s;
    }

    public System.Single Salary()
    {
        System.Single i = 10000.12f;
        return i;
    }
}

    private List<IEmployee> myList =  new List<IEmployee> { new Employee(1, "John", "Smith", new DateTime(1990, 4, 1), 1), 
            new Employee(2, "Gustavo", "Achong", new DateTime(1980, 8, 1), 1), 
            new Employee(3, "Maxwell", "Becker", new DateTime(1966, 12, 24), 2), 
            new Employee(4, "Catherine", "Johnston", new DateTime(1977, 4, 12), 2), 
            new Employee(5, "Payton", "Castellucio", new DateTime(1959, 4, 21), 3), 
            new Employee(6, "Pamela", "Lee", new DateTime(1978, 9, 16), 4) };

so i just want to know why code should create instance of list with IEmployee why not Employee.

here we can code like

private List<Employee> myList =  new List<Employee> { new Employee(1, "John", "Smith", new DateTime(1990, 4, 1), 1), 
        new Employee(2, "Gustavo", "Achong", new DateTime(1980, 8, 1), 1), 
        new Employee(3, "Maxwell", "Becker", new DateTime(1966, 12, 24), 2), 
        new Employee(4, "Catherine", "Johnston", new DateTime(1977, 4, 12), 2), 
        new Employee(5, "Payton", "Castellucio", new DateTime(1959, 4, 21), 3), 
        new Employee(6, "Pamela", "Lee", new DateTime(1978, 9, 16), 4) };

it also works....they why should one use IEmployee. why coder is using IEmployee instead of Employee so there must be some specific objective. so i just need to know the objective for using IEmployee. i am looking for good explanation. please guide me. thanks.

I would say - that is cargo cult programming or some bizarre technical issues programmer was facing. Might be unjustified fear of inheritance too. — Arnis Lapsa, Jul 14 '11 at 08:01

score 8 · Answer 1 · answered Jul 14 '11 at 06:42

8

Using a List<IEmployee> allows the code to remain flexible if you ever want to have multiple implementations of IEmployee. For example, you may want to have Employee : IEmployee and Manager : IEmployee, and using List<IEmployee> allows the list to contain both

answered Jul 14 '11 at 06:42

Jim Deville

10,632
1
37
47

thanks but i would be happy if someone explain with small sample code to understand it better. – Mou Jul 14 '11 at 07:21

score 1 · Accepted Answer · edited May 23 '17 at 12:11

You said you want some code. I'll show you some (slightly different for sake of answer).

Suppose you have

public interface IPlanet {
    string Name {get;}
}

And then specialize that interface many times:

public class Mars    : IPlanet { public string Name { get { return "Mars";   } } }
public class Venus   : IPlanet { public string Name { get { return "Venus";  } } }
public class Jupiter : IPlanet { public string Name { get { return "Jupiter";} } }
public class Earth   : IPlanet { public string Name { get { return "Earth";  } } }

Then you can do:

List<IPlanet> solarsystem = new List<IPlanet> {
    new Mars(),
    new Venus(),
    new Jupiter(),
    new Earth(),
};

And because they share the same interface, you can do:

foreach (var planet in solarsystem) {
    Console.WriteWrite (planet.Name);
}

So, in some sense, interfaces help you to manage heterogeneous objects in a homogeneous way. This is also one (of many) sort of generic, re-usable programming (don't look at the wikipedia site, which equates generic programming with templates and generics).

Note that a List implements the IList-interface, so you can generalise even more:

IList<IPlanet> solarsystem = new List<IPlanet> {
    new Mars(),
    new Venus(),
    new Jupiter(),
    new Earth(),
};

For whether you should or not, see List<T> or IList<T> .

Regarding a coding style in OOPS & C#

2 Answers2