CODEWITHSUNDEEP
c#oopabstract
Veverke
Veverke

Reputation: 11378

Object oriented design issues - abstract, derived/implementing types - a use case scenario

I have no practical experience with OO design, thus I am hesitant as to the solution I adopted for the following problem:

I have to process network text files that come from N different sources, in different formats - with the processing consisting in the classical reading, computations, and insertion into database.

The solution I devised was to create a class that defines all functionalities/behaviors that are core/file-format-independent, and create derived classes from the latter where each contain the appropriate format-reading logic, according to the file-type the given class handles.

All files are read via File.ReadAllLines(), what differs is mapping fields from the file into the main object's variables. So I did this by defining an event in the base class, that is called after File.ReadAllLines(), and all derived classes attach their mapping logic to the inherited event.

But I understand this solution is not correct design-wise. First of all, there is no meaning in instantiating the base class, so it should be abstract. The reason I did not make it abstract is that the construction code for all the derived objects is the same, so I defined it as the base constructor. Should I declare an "Initialize" method in the abstract class and simply call it in every derived class's constructor? (looks weird...) Perhaps interfaces? I don't see how using an interface would give me any benefits here, besides it will not solve this "constructor" problem...

What is the correct solution?

Code demonstration of my scenario:

public delegate void myDelegate(object parameter);

class Base
{
   #region Attributes
   ...
   #endregion

   public Base(object p)
   {
     //initialization code
     ...
   }

   #region Methods
   protected void m1() { }
   protected void m2() { }
   ...
   #endregion

   public event myDelegate myEvent;
}

class Child1
{
    public Child1(object o) : base(o)
    {
      this.myEvent += new myDelegate(ChildMethod);
    }

    public void ChildMethod(object o)
    {
      ...
    }
}

Upvotes: 0

Views: 109

Answers (1)

jason
jason

Reputation: 241701

First of all, there is no meaning in instantiating the base class, so it should be abstract. The reason I did not make it abstract is that the construction code for all the derived objects is the same, so I defined it as the base constructor.

You still can make the base class abstract yet have common constructor logic in the base class constructor. I see in your code you've already figured out how to call the base class constructor; that's all you need to do.

abstract class Base {
    public Base(object o) { }
    public abstract void M();
}

class Derived : Base { 
   public Derived(object o) : base(o) { }
   public override void M() { } 
}

Upvotes: 2

Related Questions