How can I create two contructors that act differently but recieve the same data type?

Question

public class Parser
{
    Downloader download = new Downloader();
    HtmlDocument Page;

    public Parser(string MovieTitle)
    {
        Page = download.FindMovie(MovieTitle);
    }

    public Parser(string ActorName)
    {
        Page = download.FindActor(ActorName);
    }
}

I want to create a constructor that will allow other developers who use this library to easily create a Parser object with the relevant HtmlDocument already loaded as soon as it's done creating it.

The problem lies in that a constructor cannot exist twice with the same type of parameters. Sure I can tell the logical difference between the two paramters, but the computer can't.

Any suggestions on how to handle this?

Thank you!

Answer 1

Use a couple static methods instead:

public class Parser
{
    Downloader download = new Downloader();
    HtmlDocument Page;

    private Parser() { } // prevent instantiation from the outside

    public static Parser FromMovieTitle(string MovieTitle)
    {
        var newParser = new Parser();
        newParser.Page = newParser.download.FindMovie(MovieTitle);
        return newParser;
    }

    public static Parser FromActorName(string ActorName)
    {
        var newParser = new Parser();
        newParser.Page = newParser.download.FindActor(ActorName);
        return newParser;
    }
}

Answer 2

In this particular case, I would probably use the static methods (I rarely have public constructors myself), but another possibility is to have shim classes, and this technique is also a way you can overload static methods with unique parameter signatures instead of giving them unique (and potentially unwieldy) names:

public class Parser
{
    Downloader download = new Downloader();
    HtmlDocument Page;

    public Parser(MovieTitle MovieTitle)
    {
        Page = download.FindMovie(MovieTitle);
    }

    public Parser(ActorName ActorName)
    {
        Page = download.FindActor(ActorName);
    }
}

Then your usage is new Parser(new MovieTitle(str)) or new Parser(new ActorName(str))

This is a preferable paradigm if you are considering constructing objects from IDs. If you have ints or Guids for your object IDs, there is a possibility of a constructor needing to take two different "types" of Guids. The alternative, of constructing from full objects, is far safer and eliminates a lot of silly mistakes when you pass an int. It just makes sense to not expose internal implementation features as much as possible between objects.