I have 2 classes:
public class Articles
{
private string name;
public Articles(string name)
{
this.name = name;
}
public void Output()
{
Console.WriteLine("The class is: " + this.GetType());
Console.WriteLine("The name is: " + name);
}
}
And
public class Questionnaire
{
private string name;
public Questionnaire(string name)
{
this.name = name;
}
public void Output()
{
Console.WriteLine("The class is: " + this.GetType());
Console.WriteLine("The name is: " + name);
}
}
I want to write a method, that takes an integer (1 meaning Articles
should be returned, 2 meaning Questionnaire
) and a name.
This method must return an instance of one of those two classes:
public [What type??] Choose(int x, string name)
{
if (x == 1)
{
Articles art = new Articles(name);
return art;
}
if (x == 2)
{
Questionnaire ques = new Questionnaire(name);
return ques;
}
}
What return type should I use, so I can call Output()
on the result?
Why not have a base class that has Output
defined. Then return the base.
public abstract class BaseType {
public abstract void Output();
}
Both Articles
and Questionaire
should inherit this BaseType
.
public class Articles : BaseType {
// Output method here
}
public class Questionaire : BaseType {
// Output method here
}
Then you can do:
public static BaseType Choose(int x, string name)
{
if (x == 1)
{
Articles art = new Articles(name);
return art;
}
if (x == 2)
{
Questionnaire ques = new Questionnaire(name);
return ques;
}
}
You could also achieve this via an interface
.
public interface IInterface {
void Output();
}
public class Articles : IInterface {
// Output method here
}
public class Questionaire : IInterface {
// Output method here
}
You would then have to modify the Choose method to return IInterface
rather than BaseType
. Whichever you choose is up to you.
Note: even if you can't change original classes you can still use these approaches before resorting to dynamic
by providing wrapper classes that implement the interface and either inherits original or forwards calls to corresponding method:
public class ArticlesProxy : Articles, IInterface
{
public ArticlesProxy(string name) : base(name){}
}
public class QuestionaireProxy : Questionaire, IInterface {
Questionaire inner;
public QuestionaireProxy(string name) { inner = new Questionaire(name); }
public void Output() { inner.Output();}
}