接口/抽象类IEnumerable <T> T是特定的方法

Question

I have a C# abstract class that I am using as a kind of interface

public abstract class ExcelParser
{
    protected FileInfo fileInfo { get; set; }

    protected bool FileIsValidExcelFile()...
    protected virtual string GetCellValue(int row, int column)...
    protected virtual int GetColumnLocation(string columnHeader)...

    public abstract IEnumerable<T> Parse();
}

My issue is with the abstract IEnumerable of T method, Parse().

My problem is that I want the method to return an IEnumerable of a specific Type, but I don't care what that Type is at the abstract level. I only want the inheriting class to be specific about the IEnumerable returned.

Ignoring the fact that this doesn't compile, the other issue I'm running into is the execution in the presentation layer.

        private string BuildSql(string fileName, bool minifySqlText, bool productCodeXref)
    {
        string result = string.Empty;
        ISqlBuilder sqlBuilder;
        ExcelParser excelParser;

        try
        {
            if (productCodeXref)
            {
                excelParser = new ProductCodeXrefExcelParser(fileName);
                var productCodeXrefs = excelParser.Parse();
                sqlBuilder = new ProductCodeXrefSqlBuilder(productCodeXrefs)
            }
            else
            {
                excelParser = new VendorExcelParser(fileName);
                var vendors = excelParser.Parse();
                sqlBuilder = new VendorSqlBuilder(vendors);
            }

            result = sqlBuilder.GetSql();
        }
        catch(Exception ex)
        {
            MessageBox.Show(ex.Message, "USER ERROR",
                MessageBoxButtons.OK, MessageBoxIcon.Error, MessageBoxDefaultButton.Button1);
        }
        return result;
    }

This is a rough implementation in the presentation layer at the moment, but I don't know if this is going to work. The reason I bring this up is because I had another implementation of ExcelParser that did compile, but that required me to be specific about what ExcelParser is eg..

ExcelParser<Vendor>

... which completely defeats the purpose of doing it this way.

I know this because I attempted a similar solution to the following link, but then my class/interface required that I specify the type. => How do i return IEnumerable<T> from a method

Is there any way to 1) Have a method in an abstract class or interface return an IEnumerable of T, but not care what that type is when it's being implemented, and 2) Insure that the interfaces/abstract classes don't care what type will be returned by the Parse method?

Answer 1

Is there any way to

1) Have a method in an abstract class or interface return an IEnumerable<T> , but not care what that type is when it's being implemented

2) Insure that the interfaces/abstract classes don't care what type will be returned by the Parse method?

Yes - make the abstract class generic:

public abstract class ExcelParser<T>

The concrete class would then look like:

public class VendorExcelParser : ExcelParser<Vendor>

and would contain the logic that would create Vendor instances from the Excel data - utilizing the base abstract methods as much as possible.

Answer 2

You have to specify the type in some way for the type of T to be realized: it has to be either able to be implicitly determined (eg. by usage: Foo.Get<T>(T input), Foo.Get("") , or statically determined eg. Foo.Get<vendor>()

If your presentation layer cannot know the type, then I'm at a loss as to how you intend to use a generic class to do so. .Parse() needs to return a type in some manner. Possibly you can use an interface to accomplish the intended function here: if the objects returned will stick to a schema of sorts, then you don't have to care what the type is, just that it conforms to the interface.

Depending on your usage, IEnumerable<object> may be appropriate?