Looking for a suitable design pattern...

[mmx_nexus]

Hi,

I'm looking for a specific design pattern or a solution which can solve my problem..

I have a base class with 3 derived classes.Let us say A,B,C are derived classes and Base is the base class.

For all the 3 derived classes i need to fetch data from a server,where A and B are operating upon the same set of data...while C is operating on a different set of data.

In the base class Base i have made the data retrievel method as virtual,so that intrested dervied classes can implement their own retrievel and operations upon their set of data.

Problem is since A and B operate upon the same set of data...i need to retrieve data only once for both the subclasses...and the datastructure which stores the data should be shared between the instances of A & B,wherin C is free to retrieve and operate independently.

Any pointers on how exactly should i implement it or which design pattern should i use???

Time being let us assume that all instances are singleton.

Thanks in advance,
Mmx

[Mutant_Fruit]

Make 'D' inherit from 'Base' and implement the store/retrieve method, then make 'A' and 'B' inherit from that.

'C' can inherit dirctly from 'Base'.

[mmx_nexus]

Well..that is where exactly the problem is...

Find the code & comments below..

class Program
    {
        static void Main(string[] args)
        {
            Base derived1 = new Derived1();
            derived1.GetData();

            Base derived2 = new Derived2();

            //I cant do this...as the retrievel is a costly operation 
            //and the string dataretrieved should be shared between
            //derived2 and derived1 instances...
           // derived2.GetData();

            Base derived3 = new Derived3();
            derived3.GetData();

            Console.Read();
        }
    }

    public class Base
    {
        public string dataRetrieved = string.Empty;

        public virtual void GetData()
        {
            dataRetrieved = "Base get data called";
            Console.WriteLine(dataRetrieved);
        }      
    }


    public class Derived3:Base
    {
        public override void GetData()
        {
            dataRetrieved = "Derived3 getdata called";
            Console.WriteLine(dataRetrieved);
        }
      
    }


    public class Intermediate : Base
    {     
        public override void GetData()
        {
            dataRetrieved = "Intermediate getdata called";
            Console.WriteLine(dataRetrieved);
        }     
    }


    public class Derived1 : Intermediate
    {
        public override string ToString()
        {
            return "Derived1";
        }
    }


    public class Derived2 : Intermediate
    {
        public override string ToString()
        {
            return "Derived2";
        }
    }

As evident from the code,i can't call getdata for derived2 instance,since it's a lengthy op and the data is same for both derived1 and derived2...once derived1.getdata is called the string value should be shared by both derived1 instance and derived2 instance.I know i can pass the value to the constructor of derived2...is there any better solution other than that..I read some where about Indirection...how to apply it over here???

[nelo]

    public class Intermediate : Base
    {
        private static string data = string.Empty;

        protected string Data
        {
            get { return data; }
        }
        public override void GetData()
        {
            if (data == string.Empty)
            {
               // do the expensive data retrieval here
               // this means it will only happen once
            }
            dataRetrieved = "Intermediate getdata called";
            Console.WriteLine(dataRetrieved);
        }     
    }


    public class Derived1 : Intermediate
    {
        public override string ToString()
        {
            return "Derived1";
        }
    }


    public class Derived2 : Intermediate
    {
        public override string ToString()
        {
            return "Derived2";
        }
    }

Essentially you modify the Intermediate class to only get and maintain one copy of the data. The classes derived from Intermediate would only get the data once. At other times the call would be redundant.

[Mutant_Fruit]

Or split data retrieval and data processing into separate classes.