Generic classes with Inheritance

I am having the below method that returns an instance of a Generic Class. This is a simple factory class. I have a Generic class called FileReader<T> which reads pipe-delimited txt file of Chase,Products, customers, suppliers etc and populate the data into respective BusinessObjects. I am trying to achieve is a Generic file reader. All these business objects derive from BusinessBase class.

public override FileReaderGeneric<BusinessBase> CreateFileReader(ImportJobConfig jobConfig)
        {
            return new FileReaderGeneric<Chase>(jobConfig);
        }

The BusinessBase is not a generic class. The BusinessBase only has validation functions. However, the above code is giving me an error
Cannot implicitly convert type <BusinessLayer.Chase> to <BusinessLayer.BusinessBase>

Edited based on the comments
Looks like my understanding on Generics is not correct

With C# generics, you cannot cast an instance of a generic class to another. For instance, given

class A {
}
class B : A {
}
class Foo<T> where T:A {
}
Foo<A> fooA = new Foo<A>();
Foo<B> fooB = new Foo<B>();

Even though A is the supertype of B, you cannot then say

fooA = (Foo<A>)fooB;

Even though A is the supertype of B. The language does not allow it: the types Foo<A> and Foo<B> are completely unrelated: only their generic parameters are related.

This code:

using System;
class A
{
}
class B : A
{
}
class Foo<T>
	where T : A
{
}
public class Program
{
	public static void Main()
	{
		Foo<A> fooA = new Foo<A>();
		Foo<B> fooB = new Foo<B>();
		Foo<A> xxxx = (Foo<A>)fooB;
	}
}

will give you a compilation error Compilation error (line 22, col 17): Cannot convert type 'Foo<B>' to 'Foo<A>'

on the assignment statement

Foo<A> xxxx = (Foo<A>)fooB;

Updating this to offer possible solutions

Since it sounds like the BusinessBase instance that you are instantiating are not exposed to the consumers of the instantiated instances of FileReaderGeneric<T>, there are a couple of things you can do.

Assuming that your generic class looks something like this:

class FileReaderGeneric<T> where T:BusinessBase
{
  ...
}

you can . . .

Use Dependency Injection

class FileReader
{
  private BusinessBase bb
  private FileReader( BusinessBase bb, ImportJobConfig jobConfig )
  {
    this.bb = bb;
  }
  public static FileReader CreateFileReader( BusinessBase bb , ImportJobConfig jobConfig )
  {
    return new FileReader( bb , jobConfig );
  }
}

Use An Abstract Base Class

public abstract class AbstractFileReader
{
  . . .
}
class FileReader<T> : AbstractFileReader where T:BusinessBase
{
  private FileReader( ImportJobConfig jobConfig )
  {
  }
  public static AbstractFileReader CreateFileReader( ImportJobConfig jobConfig )
  {
    return new FileReader<Chase>( jobConfig );
  }
}

You likely want to use a generic method here. With type constraints, you can limit callers to using a type derived from BusinessBase. Something like this

public override FileReaderGeneric<TBusinessBase> CreateFileReader(ImportJobConfig jobConfig) where TBusinessBase: BusinessBase
{
    return new FileReaderGeneric<TBusinessBase>(jobConfig);
}

You will need to change the containing class appropriately because this overriding method no longer has the same signature it did before.

If you create an interface to describe a file reader, and use that interface with a covariant generic type, you can cast the types:

public class ImportJobConfig { }
public class BusinessBase { }
public class Chase : BusinessBase { }
public interface IFileReader<in T> { }
public class FileReaderGeneric<T> : IFileReader<T> {
    public FileReaderGeneric(ImportJobConfig jc) { }
}
public override IFileReader<BusinessBase> CreateFileReader(ImportJobConfig jobConfig) {
    return (IFileReader<BusinessBase>)(new FileReaderGeneric<Chase>(jobConfig));
}