Question

I want to make an interface in C# that defines a method that always returns an object of the implementing class, thus:

public interface IParser {
    IParser Parse(string s);
}

public class Parser : IParser {
    public Parser Parse(string s) {
        return new Parser(s);
    }
}

Can I force an implementing class to return an object of its own type? If possible, then how? Or is generics the answer here?

NB: The code is just an illustration, not something that s supposed to run.

Answer 1

Generics is the answer here.

public interface IParser<T> where T:IParser<T> {
    T Parse(string s);
}

public class Parser : IParser<Parser> {
    public Parser Parse(string s) {
        return new Parser(s);
    }
}

Answer 2

Not in the interface declaration, no. The best you could manage is with generics:

public interface IParser<T>
    where T: IParser<T>
{
    T Parse(string s);
}

public class Parser
 : IParser<Parser>
{
    public Parser Parse(string s)
    {
       return new Parser(s);
    }
}

This doesn t force the implementation to return it s own type, but at least it allows it to do so. This is why the IClonable interface returns an object from its Clone method, rather than a specific type.

----Edit----

Something to remember on this question: let s say that my code, for which you don t have any knowledge of the implementation, returns an IParser, and your code calls the Parse method. What object do you expect to be returned, not knowing the concrete type of returned IParser reference? I think you re trying to use interfaces for something they re not meant to do...

Answer 3

Yes, and this is known as the factory pattern, only that usually this is complemented with the use of a private constructor and making the instance returning method static, for example:

public class Parser : IParser {

    private Parser(string s) {
        //Do something with s, probably store it in a field
    }

    public static IParser GetNewParser(string s) {
        return new Parser(s);
    }
}

Answer 4

You can do this with Generics, but I would probably stick with returning an instance of the interface. Note that since the class implements the interface, returning an instance of it is ok -- it will be an instance of that type and of the interface as well.

public class Parser : I Parser
{
   public IParser Parser( string s )
   {
       return Parser(s);
   }
}

友情链接