Making a class/function that works like 'class(type)' in a class library

Question

0.00/5 (No votes)

See more:

OK, this may be hard to explain so forgive me if you don't understand any of it. I am porting some of my functions that were previously in classes in my main application into a class library so I can use them in any projects. I have literally just started this so the code might not be very complete but I have this so far:

C#

namespace WeatherLink
{
    public class DataDownloader
    {
        public class MetOffice
        {
            public DataType DataType;
            public bool CacheData;
            public string CacheLocation;
            public string ApiKey;

            public string GetData()
            {
                string resource = "";

                if (DataType.Type == "VisibleObservation")
                {
                    string sourcePath = string.Format(Path.Combine(@"C:\Users\Henry\AppData\Local\WeatherLink\temp\runtime_cache\visibleObservation"));

                    if (!File.Exists(sourcePath))
                    {
                        string sourceImage = string.Format("http://datapoint.metoffice.gov.uk/public/data/layer/wxobs/SATELLITE_Visible_N_Section/png?TIME={0}Z&key={1}");
                        System.Drawing.Bitmap image = new Bitmap(Image.FromStream(System.Net.HttpWebRequest.Create(sourceImage).GetResponse().GetResponseStream()));
                        Bitmap bitmap = new Bitmap(640, 852);
                        using (Graphics graphics = Graphics.FromImage(bitmap))
                        {
                            graphics.DrawImage(image, new Point[] { new Point(0, 0), new Point(650, 0), new Point(0, 852) });
                            bitmap.Save(sourcePath);
                            resource = sourcePath;
                        }
                    }
                    else { resource = sourcePath; }
                    return resource;
                }

                return resource;
            }
        }

        public class EuMetSat
        {

        }
    }

    public class DataType
    {
        public string Type { get; set; }
    }
}

...and I call it like this:

C#

DataDownloader.MetOffice MetOffice = new DataDownloader.MetOffice();
DataDownloader.EuMetSat EuMetSat = new DataDownloader.EuMetSat();

I want to know how I can change my code in the library so that I can call a DataDownloader like this:

C#

DataDownloader dd = new DataDownloader(MetOffice);
DataDownloader dd = new DataDownloader(EuMetSat);

...So instead of calling it using all the levels of the namespace I want to call the DataDownloader and specify its type (either MetOffice or EuMetSat). How do I do this? Would I have to use methods instead of classes for the 2 types? Like when you initiate most variables, as an example an XmlDocument has brackets after it (new XmlDocument()) where you could specify something for it. How would I do this in my code (new DataDownloader(MetOffice))? I hope you understand what I am trying to do. Thank You

Posted 15-Nov-13 8:31am

Henry Hunt

Add a Solution

4 solutions

Add a Solution

Add your solution here

Treat my content as plain text, not as HTML

Preview 0

…

Existing Members

Sign in to your account

...or Join us

Download, Vote, Comment, Publish.

Your Email
Password
Forgot your password?

Your Email
This email is in use. Do you need your password?
Optional Password

I have read and agree to the Terms of Service and Privacy Policy
Please subscribe me to the CodeProject newsletters

When answering a question please:

Read the question carefully.
Understand that English isn't everyone's first language so be lenient of bad spelling and grammar.
If a question is poorly phrased then either ask for clarification, ignore it, or edit the question and fix the problem. Insults are not welcome.
Don't tell someone to read the manual. Chances are they have and don't get it. Provide an answer or move on to the next question.

Let's work to help developers, not make them feel stupid.

This content, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

BillWoodruff · Answer 1 · 2013-11-15T09:49:00

I started to write my response before there were other solutions posted here, but I see that what I did is different from the other responses: I maintain your nested Classes, and do not use an Abstract Class.

Hopefully, in the range of implementations here, you'll find useful ideas to adapt to your own work.

Consider this:

C#

using System;

namespace WeatherLink
{
    public class DataDownLoader
    {
        public DataDownLoader()
        {
            // initialize data structures, fields, properties
            // common to both MetOffice and EuMetSat
        }

        // declare data structures, fields, properties
        // common to both MetOffice and EuMetSat
        // these can be public or private
        private string ClassName;

        // create methods and functions
        // common to both MetOffice and EuMetSat
        // these can be public or private
        public void WriteToConsole()
        {
            if (this is MetOffice)
            {
                Console.WriteLine("This is a MetOffice instance");
            }
            else if (this is EuMetSat)
            {
                Console.WriteLine("This is a EuMetSat instance");
            }
            else
            {
                throw new ArgumentException("Error in argument to WriteToConsole");
            }
        }

        public class MetOffice : DataDownLoader
        {
            public MetOffice()
            {
                ClassName = "MetOffice";
            }
        }

        public class EuMetSat : DataDownLoader
        {
            public EuMetSat()
            {
                ClassName = "EuMetSat";
            }
        }
    }
}

In this case, the outer Class is simply serving as a binder for the inner Classes, providing common functionality.

Here you would create new instances of the inner Classes, each of which inherits from the outer Class, like this:

WeatherLink.DataDownLoader newMetOffice = new WeatherLink.DataDownLoader.MetOffice();

WeatherLink.DataDownLoader newEuMetSat = new WeatherLink.DataDownLoader.EuMetSat();

In OOP terms we can say that each instance of MetOffice, and EuMetSat, is-a instance of 'DataDownLoader.

Each instance of MetOffice, or EuMetSat, can call the public method 'WriteToConsole provided by the DataDownLoader Class: in that method the keyword 'this is used to get the Type of the current "flavor" of DataDownLoader:

C#

newMetOffice.WriteToConsole();
newEuMetSat.WriteToConsole();

If I may suggest, I think it's very important to try and get a basic grounding in OOP concepts in .NET from the beginning, and understanding inheritance, and use of abstract and virtual Classes, and Interfaces, are very important. A good book, or two, and study, and posing design problems to yourself, will equip to handle many scenarios in the future (end of sermon).

Finally, there are many ways you could implement the functionality you have specified here (if I understood it !); I don't claim the way I presented here is the "ultimate."

OriginalGriff · Answer 2 · 2013-11-15T09:08:00

AFAIK, you can't - because new always returns an instance of the class you create, and you can't change that: so it will always return a DataDownloader class instance.
But it would be simple (ish) to add a Create method to DataDownloader that takes a Type and creates it:

C#

public static T Create<T>() where T : new()
    {
    return new T();
    }

But frankly, I wouldn't go there.

Myself, I would create DataDownLoader as an abstract base class, and derive MetOffice and EuMetSat from it, since your containing class seems to exists simply to "bracket" the two classes within it.

Ron Beyer · Answer 3 · 2013-11-15T09:11:00

Solution 2

Well the first thing to do is not nest your classes if there is no need to, so here is a stripped down example:

C#

interface IWeatherDataSource
{
    //Define common interface to your data source here
}

class DataDownloader
{
    DataDownloader(IWeatherDataSource dataSource)
    {
        //Do whatever with your source here
    }
}

class MetOffice : IWeatherDataSource
{
    //Implement IWeatherDataSource
}

class EuMetSat : IWeatherDataSource
{
    //Implement IWeatherDataSource
}

Then elsewhere in your program, you can write:

C#

DataDownloader metSource = new DataDownloader(new MetOffice());
DataDownloader euSource = new DataDownloader(new EuMetSat());

Posted 15-Nov-13 9:11am

Ron Beyer

Comments

PIEBALDconsult 15-Nov-13 15:40pm

Or generic: new DataDownloader<EuMetSat>()

Henry Hunt 15-Nov-13 15:43pm

THAT'S IT!! That's what I want, like a list<>

PIEBALDconsult 15-Nov-13 15:53pm

I trust you've written generic classes before?

Ron Beyer 15-Nov-13 15:58pm

Even with generics he's still going to have to implement a common interface, and use generic constraints, like:

class DataDownloader<T> where T : IWeatherDataSource, new()
{
T internalSource;

DataDownloader()
{
internalSource = new T();
}
}

PIEBALDconsult 15-Nov-13 16:09pm

Yes.

PIEBALDconsult · Answer 4 · 2013-11-15T09:30:00

Solution 3

# define DataDownloader(x) DataDownloader.x()

var d = new DataDownloader(MetOffice);

But seriously, I think your example is flawed, you likely need an abstract class and/or an Interface. You may also want to go generic.

Posted 15-Nov-13 9:30am

PIEBALDconsult