C#

public interface I1
{
    void A();
    void B();
}
public interface I2
{
    void A();
    void B();
    void C();
    void D();
}
public class ClassA : I1, I2
{
    public void A()
    { }
    public void B()
    { }
    public void C()
    { }
    public void D()
    { }
}

public class ClassA2 : I1, I2
{
    void I1.A()
    { }
    void I2.A()
    { }
    void I1.B()
    { }
    void I2.B()
    { }
    public void C()
    { }
    public void D()
    { }
}

public class ClassA2 : I1, I2
{
    public void A()
    {
        (this as I1).A();
    }
    public void B()
    {
        (this as I1).B();
    }
    void I1.A()
    { }
    void I2.A()
    { }
    void I1.B()
    { }
    void I2.B()
    { }
    public void C()
    { }
    public void D()
    { }
}

public interface I1
{
    void A();
    void B();
}
public abstract class A2 : I1
{
    public virtual void C()
    {
        //nothing in default implementation
    }
    public virtual void D()
    {
        //nothing in default implementation
    }

    #region I1 Members

    public abstract void A();
    public abstract void B();

    #endregion
}

// case 1
// fuction A and B will be there always
// not implementing C and D
public class ClassA : A2
{
    public override void A()
    {

    }

    public override void B()
    {

    }
}

// case 2
// fuction A and B will be there always
// ALSO implementing C and D
public class ClassA2 : A2
{
    public override void A()
    {

    }

    public override void B()
    {

    }

    public override void C()
    {

    }

    public override void D()
    {

    }
}

TheGermoz wrote:

class A can implements I1 or I2 depending on how it is constructed

interface I1 {
 void A();
 void B();
}

interface I2 : I1 {
 void C();
 void D();
}

class A : I1 {
 // Implementations of the I1 functionality, and the I1 type constructor
 public virtual void A() {}
 public virtual void B() {}
}

class A2 : A, I2 {
 // Implementations of the I2 functionality, and the I2 type constructor
 public void C() {}
 public void D() {}

 // You can also override implementations from A
 public override void A() {
  base.A();
  // other stuff
 }
}

Rahul Rajat Singh wrote:

Also we can make class A as abstract to make sure no one is able to create it directly as its only purpose is to facilitate default implementation for optional functions.

KKW_acd wrote:

righthand side of the line

public struct Item
{
    private string name;
    private int index;

    public Item(string name, int index)
    {
        this.name = name;
        this.index = index;
    }

    // only getters as a struct should not normally be changed once created.
    public string Name { get { return name; } }
    public int Index { get { return index; } }
}

public class DataList
{
    private Item[] items = new Item[128];

    public Item[] Items { get { return items; } }
}

// usage
DataList[] dataLists = new DataList[128];

int listIndex = 0;
int itemIndex = 0;

string itemText = "Random text";
string indexText = "1";

dataLists[listIndex] = new DataList();

dataLists[listIndex].Items[itemIndex] = new Item(itemText, int.Parse(indexText));

KKW_acd wrote:

I wish I was as young

KKW_acd wrote:

old bit-twiddler from the DOS and Microprocessor days

KKW_acd wrote:

I even remember watching man's first step on the moon on an Admiral B&W tv! - Live!

typedef struct {
 string FieldName;
 int FieldIndex;
} ItmAray;

typedef struct {
 ItmAray[128] ItemArray;
} DtLst;

DtLst[128] DataList;

class Field {
 string Name;
 int Index;
}

class DataListItem {
 List<Field> Fields;
}

List<DataListItem> DataList;