OOP Question

[Guest]

Hi

I feel real silly asking this, I have been posed with a simple design question which goes as follows (I am from a procedural background and not oop which may help explain my stupidity)

I have a class called Person and a class called Developer. Developer Inherits from Person. When I call the GetDeveloper method in the devloper should this return the Developer specific information only or should this also bring back the Person information. By defintion a Developer is a person. I would like to keep the Person data access code encapsulted and there fore does calling the Developer data mean that I would need to make two calls to the database - one that would get the devloper data and a secondary one which would get the person information. I have thought about achieving this with a lazy load style design whereby the class would work so that GetDEveloper returned only the developer specific information and a call to any 'person' related property would retrieve the Person information - preferably I want to acheive this as a single function call. This is a fairly simple example but I feel like I am losing my head.

How would you guys go about doing this

Please help.

 

[Cowboy \(Gregory A. Beamer\) [MVP]]

As long as you inherit properly, and do not hide methods (by setting one up
of with the same name as one in the base class), you will also see the
methods of the base class, like so:

//TODO: Add constructors
public class Person
{
private string _name;

public string Name
{
set
{
_name = value;
}
}
}

public class Developer : Person
{
private string _devLanguage;

public string DevLanguage
{
set
{
_devLanguage= value;
}
}
}

//Initialization and use code
Developer MyDev = new Developer();
MyDev.Name = "Lala"; //From person
MyDev.DevLanguage = "C#"; //From Developer

--
Gregory A. Beamer
MVP; MCP: +I, SE, SD, DBA

************************************************
Think Outside the Box!
************************************************

Hi,

I feel real silly asking this, I have been posed with a simple design

question which goes as follows (I am from a procedural background and not
oop which may help explain my stupidity):

I have a class called Person and a class called Developer. Developer

Inherits from Person. When I call the GetDeveloper method in the devloper
should this return the Developer specific information only or should this
also bring back the Person information. By defintion a Developer is a
person. I would like to keep the Person data access code encapsulted and
there fore does calling the Developer data mean that I would need to make
two calls to the database - one that would get the devloper data and a
secondary one which would get the person information. I have thought about
achieving this with a lazy load style design whereby the class would work so
that GetDEveloper returned only the developer specific information and a
call to any 'person' related property would retrieve the Person
information - preferably I want to acheive this as a single function call.
This is a fairly simple example but I feel like I am losing my head.

 

[Jonathan Yong]

Instead of having a GetDeveloper() method in the Developer class, I will
have a virtual GetData() define in the Person class and override it in
the Developer class. Like this :

public class Person
{
public virtual void GetData()
{ // get person info from database.
}
}


public class Person : Developer
{
public override void GetData()
{
// call base class method to get person info.
base.GetData();

// get developer specific info from database.
}
}

Of course, you still need to make 2 DB call with these approach. If you
want to reduce the DB call to just 1, then you have to load everything
from the Developer class which I think defeat the encapsulation of using OO.

 

[Jay B. Harlow [MVP - Outlook]]

Akeel,
Check out Martin Fowler's book "Patterns of Enterprise Application
Architecture" he offers & discusses a number of patterns for mapping
database to objects.

http://www.martinfowler.com/books.html#eaa

Hope this helps
Jay

Thanks for both responses.

We battled with this yesterday and came to the conclusion that you did

Jonathon: The Person class should handle all aspects of person data, if a
developer class needs person data it should not need to know how a person is
stored in the DB or what makes up a person.

This seems cool and inline with the rules of OOP, however, what are your

thoughts around how well this would fit in to the real world. What I am
thinking is in the real world I may need to compromise OOP in order to
achieve performance but by doing this I introduce a higher level of
maintanenece...oh no..I am back to Performance vs Maintanence debate. Is
that right?

I must admit I was very passive towards OOP but am starting to really embrace the concepts.

Jonathon in your code sample you set the GetData function within the

developer class to return void, what would you suggest is the best way to
return this data - would it be properties, a dataset, XML? I would tend to
move towards properties and perhaps cater for other return types by
overloading. Any thoughts?