designing application using polymorphism

Question

I have created a polymorphic system, but I don't know whether this is the correct way of doing it. Am I abusing Polymorphism here? Here is the code:

class WriteObj
{
 public string Obj1 { get; set; }
 public string Obj2 { get; set; }
 public string Obj3 { get; set; }
}

The above code is a data object that I am passing around in the methods, since I would be using a List of these objects.

abstract class BaseWriter
{
 public abstract void Write(List<WriteObj> writeObjList);
}
class ConsoleWriter : BaseWriter
{
 public override void Write(List<WriteObj> writeObjList)
 {
 for (int i = 0; i < writeObjList.Count; i++)
 {
 Console.Writeline("I am in Console Writer, parameter: " + writeObjList[i].Obj1);
 }
 }
}
class FileWriter : BaseWriter
{
 public override void Write(List<WriteObj> writeObjList)
 {
 for (int i = 0; i < writeObjList.Count; i++)
 {
 Console.Writeline("I write in file, parameter: " + writeObjList[i].Obj1);
 }
 }
}
class DatabaseWriter : BaseWriter
{
 public override void Write(List<WriteObj> writeObjList)
 {
 for (int i = 0; i < writeObjList.Count; i++)
 {
 Console.Writeline("I write in database, parameter: " + writeObjList[i].Obj2);
 }
 }
}

In my main method I call them like:

 static void main()
 {
 List<WriteObj> col = new List<WriteObj>();
 col.AddRange(new WriteObj[2] { new WriteObj { Obj1 = "this is obj1 iteration 1", Obj2 = "This is obj2 iteration 1" }, 
 new WriteObj { Obj1 = "this is obj1 iteration 2", Obj2 = "This is obj2 iteration 2" } });
 //some factory will generate these concrete types, 
 //but the sake of simplicity I am instantiating it like that.
 BaseWriter a = new ConsoleWriter();
 a.Write(col);
 BaseWriter b = new FileWriter();
 b.Write(col);
 BaseWriter c = new DatabaseWriter();
 c.Write(col);
 }

Is it Ok to pass List of WriteObj in the Write method of the respective concrete implementations?

---

Update : I have used abstract class because it will be having some methods in it. I haven't mentioned it here for the sake of simplicity.

• dreza: Seems ok. I might consider making the Writer method take a more generic parameter, perhaps ICollection or even a ReadOnlyCollection to enforce an abstraction that the method is there to write the data and not alter it?

Answer 1

Yes, I don't see a problem with that.

If you don't have any implementation at all in the base class, consider making it an interface instead:

interface IWriter {
 void Write(List<WriteObj> writeObjList);
}
class ConsoleWriter : IWriter {
 public void Write(List<WriteObj> writeObjList) {
 foreach (WriteObj obj in writeObjList) {
 Console.Writeline("I am in Console Writer, parameter: " + obj.Obj1);
 }
 }
}
etc.

Answer 2

Yes, you could take that way. I would recomend to make BaseWriter an interface IWriter too. But I have an other suggestion.

interface IWriter
{
 void Write(List<WriteObject> writeObjectList);
}
public class ConsoleWriter : IWriter
{
 public void Write(List<WriteObject> writeObjectList)
 {
 // your implementation
 }
}
public class Writer // bad name but I dont have a better now
{
 private IWriter _writer; // or make it public and delete the constructor
 public Writer(IWriter writer)
 {
 _writer = writer;
 }
 public void Write(List<WriteObject> writeObjectList)
 {
 _writer.Write(writeObjectList);
 }
}

In this case, you do not use polymorphism. So your design is more flexible. You could change the way of writing your objects while runtime. Give it a try ;-)