Is this still considered an implementation of the strategy pattern?

Question

In my project I have different types of entities.
I get the data for these entities in text files from a 3rd party.
I've written a class to read and parse these text files, using the strategy pattern.
The method in this class must return different entity types so I've made the entire class generic - something like this:

public class Parser<T>
{
    public IStrategy<T> strategy { get;set;}

    public IEnumerable<T> LoadFromFile()
    { 
        // implementation details, not interesting
    }
}

But the problem is that now I need a new instance of Parser for every entity I load, so I changed my initial implementation into this:

public class Parser
{
    public IEnumerable<T> LoadFromFile(IStrategy<T> strategy)
    {
        // implementation details, not interesting
    }
}

So, is this still considered as an implementation of the strategy pattern?

If not, is there any way I could return IEnumerable<T> without having to specify what type T actually is anywhere but in the IStrategy<T>?

Answer 1

Sir, you are still using Strategy pattern in less explicit way. However your code after change does not fully reflect that. You'd have to present the IStrategy interface fot completeness.

However the main line of my thought is rather so: patterns are not blueprints, they are rather intellectual scaffold that more it is modified for concrete use the better it is understood and grasped.