Generic Strategy pattern

Question

I'm trying to implement strategy pattern with generic types. I try to create object and the end invoke it but I have no idea how should look like signature of it. My problem is in ObjectProcessor class(Do method).

//my code
abstract class Credential {}
class SNMP : Credential { }
class HTTP : Credential { }

//dll
abstract class CredentialDLL { }
class SNMPDLL : CredentialDLL { }
class HTTPDLL : CredentialDLL { }

interface IMapper<T, Y>
{
    T Map(Y input);
    Y Map(T input);
}

class SNMPMapper : IMapper<SNMP, SNMPDLL>
{
    public SNMPDLL Map(SNMP input) { throw new NotImplementedException(); }
    public SNMP Map(SNMPDLL input) { throw new NotImplementedException(); }
}

class HTPPMapper : IMapper<HTTP, HTTPDLL>
{
    public HTTPDLL Map(HTTP input) { throw new NotImplementedException(); }
    public HTTP Map(HTTPDLL input) { throw new NotImplementedException(); }
}

class ObjectProcessor
{
    CredentialDLL Do(Credential input)
    {
        IMapper <?,?> mapper; // ??

        if (input is SNMP)
        {
            mapper = new SNMPMapper();
        }
        else
        {
            mapper = new HTPPMapper();
        }

        return mapper.Map(input);
    }
}

Answer 1

The simple answer is, you can't declare the mapper outside of the if statement because each of those two types returns a different mapper (one is IMapper<SNMP, SNMPDLL> and the other is IMapper<HTTP, HTTPDLL>). There are several options to solving this, but without knowing the rest of your code it is hard to say what would be the best option. The simplest change that I can think of would be to edit your Do method like this:

CredentialDLL Do(Credential input)
{
    if (input is SNMP)
    {
        return new SNMPMapper().Map(input);
    }
    else
    {
        return new HTPPMapper().Map(input);
    }
}

A second possiblity would be to add a Map method to your abstract class and then implement it in each derived class. Then you could simplify the Do method further and remove the need to check for a type (which seems to defeat the purpose of having a generic or a base class anyway).

abstract class Credential
{
    public abstract CredentialDLL Map();
}
class SNMP : Credential
{
    public override CredentialDLL Map()
    {
        return new SNMPMapper().Map(this);
    }
}

class HTTP : Credential
{
    public override CredentialDLL Map()
    {
        return new HTTPMapper().Map(this);
    }
}

// Simplified do method, it is now a one liner
CredentialDLL Do(Credential input)
{
    return input.Map();
}