> I'm using what I think is a Strategy Pattern to perform the same
> process, but implemented in two different ways. I therefore plan to
> have an Interface with a single method, and two concrete classes that
> inherit from the interface, each having a different implementation of
> that method.
>

If this is strategy pattern will be more clear if you can quote your
actual scenario. Merely having to implement same interface may not qualify
your implementation to be using strategy pattern.

Also what do you mean by inheriting from the interface?

>
> The problem is, while both these implementations are logically
> performing the same function, both need different parameters to perform
> the task. This means my interface will need both versions of the
> method, which means in turn both classes will need both too. I'm pretty
> sure that's not right!
>
>

Yeah, I guess that too. That something is wrongly designed.

> I'm thinking one possibility might be to have a separate class to hold
> the parameters, and pass an instance of that into each method. Is that
> a good or bad approach?
>

May be right depending on your context. But more obvious reply would be
that most possibly its wrong approach.

>
> Alternatively, am I approaching this in completely the wrong way - is
> there another pattern I should be using?
>
>

If you can explain your senario more clearly may be we can propose or may
discuss new approach.

regards,
Shashank