How do I implement extension helper methods as an abstract class with variable parameters?

Question

To cut down on reused code throughout my repository which gets values from another library, I wanted to create extension methods for "parsing"(for lack of a better word) one class to another. How do I implement abstract methods with different parameters.

I can't find anything that answers my question, and I'm not sure it can even be done.

Instead of having something like this in multiple places.

var list = _library.GetList();
var model = list.Select(o => new ClassA()
{
   ID = o.ID, 
   Name = o.Name
}).ToList<ClassA>();

I want extension methods so I can call something like

var list = _library.GetList();
var model = ExtensionClass.ParseMany(list);

But, I want to base this off an abstract class so it can be reused by mutliple different classes, so I have

public abstract class Parser<U, T> where T : class where U : class 
{
   public abstract T ParseOne(U parser);
   public abstract IEnumerable<T> ParseMany(IEnumerable<U> parser); 
}

public class ParseA<ClassA, ClassADTO> 
{
   public override ClassA ParseOne(ClassADTO parser){ // }
}

But it doesn't seem that my parameter that is passed in is the actual object, it says it's a KeyValuePair and now I'm lost.

I expect to able to return a new instance based on my parameter, basically what I already do in my code multiple times.

Answer 1

I guess you can have a generic parser using Func. I just wrote a sample and hope it helps you.

public class ClassA
{
    public int SomeNumber { get; set; }

    public string SomeString { get; set; }
}

public class ClassB
{
    public int OtherNumber { get; set; }

    public string OtherString { get; set; }
}

public static class ExecuteParsingFunction
{
    public static TDestiny Parse<TOrigin, TDestiny>(TOrigin origin,
                                Func<TOrigin, TDestiny> parserFunction)
    {
        return parserFunction(origin);
    }
}

public static class ParsingFunctions
{
    public static ClassB ParseAToB(ClassA a)
    {
        return new ClassB { OtherNumber = a.SomeNumber, OtherString = a.SomeString };
    }

    public static IEnumerable<ClassB> ParseManyAToB(IEnumerable<ClassA> aCollection)
    {
        foreach(var a in aCollection)
            yield return ParseAToB(a);
    }
}

public void Sample()
{
    var a = new ClassA { SomeNumber = 1, SomeString = "Test" };
    var manyAs = new List<ClassA> { a };

    var b = ExecuteParsingFunction.Parse(a, ParserFunctions.ParseAToB);
    var manyBs = ExecuteParsingFunction.Parse(manyAs, ParserFunctions.ParseManyAToB);
}