Example of Interface and Abstract class in real project using C# in ASP.Net

Refer:

1. Implement interface in asp.net with c# live example
2. When to use Abstract Class And Interface In C#

i have already seen your references.but i have no idea how to implement these in my projects which i am making.can you give any examle.which are used in live projects.like any crued operation or any type of method or function which are used by making interface.

Hi iammann,

Here is a small sample that you can understood the concept.

HTML

<div>
    <table border="0" cellpadding="0" cellspacing="0">
        <tr>
            <td>
                <asp:GridView ID="gvEmployees" runat="server" Caption="<b>Interface</b>" />
            </td>
            <td>
                <asp:GridView ID="gvCustomers" runat="server" Caption="<b>Abstract</b>" />
            </td>
        </tr>
    </table>
</div>

For interface create a property class with the name Employees

/// <summary>
/// Employees get set property.
/// </summary>
public class Employees
{
    public string EmployeeId { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
}

Then create interface IEmployee

/// <summary>
/// interface IEmployee.
/// </summary>
public interface IEmployee
{
    /// <summary>
    /// Get list of Employees.
    /// </summary>
    /// <returns>List of Employees</returns>
    List<Employees> PopulateEmployees();
}

Then create class Employee which inherit interface.

/// <summary>
/// Employee Class inherits IEmployee interface.
/// </summary>
public class Employee : IEmployee
{
    /// <summary>
    /// Get list of Employees.
    /// </summary>
    /// <returns>List of Employees</returns>
    public List<Employees> PopulateEmployees()
    {
        string strConnString = ConfigurationManager.ConnectionStrings["constr"].ConnectionString;
        SqlConnection con = new SqlConnection(strConnString);
        string query = "SELECT TOP 10 [EmployeeID],[LastName],[FirstName] FROM [Employees]";
        SqlCommand cmd = new SqlCommand(query);
        SqlDataAdapter sda = new SqlDataAdapter(cmd);
        cmd.Connection = con;
        DataTable dt = new DataTable();
        sda.Fill(dt);
        List<Employees> employees = new List<Employees>();
        foreach (DataRow row in dt.Rows)
        {
            employees.Add(new Employees
            {
                EmployeeId = row["EmployeeId"].ToString(),
                FirstName = row["FirstName"].ToString(),
                LastName = row["LastName"].ToString()
            });
        }
        return employees;
    }
}

For abstract same way create class with the name Customer

/// <summary>
/// Summary description for Customer
/// </summary>
public abstract class Customer
{
    /// <summary>
    /// Gets List of Customers.
    /// </summary>
    /// <returns>List of Customers.</returns>
    abstract public DataTable PopulateCustomers();
}

Create Customers class that override Customer abstract class.

/// <summary>
/// Summary description for Customers
/// </summary>
public class Customers : Customer
{
    /// <summary>
    /// Override PopulateCustomers.
    /// </summary>
    public override DataTable PopulateCustomers()
    {
        string strConnString = ConfigurationManager.ConnectionStrings["constr"].ConnectionString;
        SqlConnection con = new SqlConnection(strConnString);
        string query = "SELECT TOP 10 [CustomerID],[ContactName],[City],[Country] FROM [Customers]";
        SqlCommand cmd = new SqlCommand(query);
        SqlDataAdapter sda = new SqlDataAdapter(cmd);
        cmd.Connection = con;
        DataTable dt = new DataTable();
        sda.Fill(dt);
        return dt;
    }
}

After running the above below is the output.

Dear,

The choice of whether to design your functionality as an interface or an abstract class (a MustInherit class in Visual Basic) can sometimes be a difficult one. An abstract class is a class that cannot be instantiated, but must be inherited from. An abstract class may be fully implemented, but is more usually partially implemented or not implemented at all, thereby encapsulating common functionality for inherited classes.