методы, которые возвращают разные типы возврата

Вы можете использовать метод Set<T> для DbContext для общего доступа к наборам. Если вы поместите все соответствующие свойства вашей фильтрации в базу, вы можете затем ограничить общий параметр этим базовым типом и по-прежнему фильтровать все свои свойства.

Таким образом, ваши классы будут выглядеть примерно так на основе ваших исходных запросов:

public class Entity
{
    public string SpaceFunction { get; set; }
    public string Category { get; set; }
}

public class LightingEquipment : Entity
{
    public LightingSource LightingSource { get; set; }
}

public class LightingSource
{
    public string Name { get; set; }
}

И ваш метод хотел бы этого, используя селектор источника:

public IQueryable<T> Fields<T>(string spaceFunction, string category, string source, Func<T, string> sourceSelector) where T : Entity
{
    return _dbContext.Set<T>().Where(s => s.SpaceFunction == spaceFunction
                              && s.Category == category &&
                              sourceSelector(s) == source);
}

И вы бы назвали этот метод следующим образом:

public void Consumer()
{
    var queryable = Fields<LightingEquipment>("spaceFunction", "category", "source", x => x.LightingSource.Name);
}

Документы для Set<T>()

Я думаю, вы обнаружите, что ваш текущий дизайн самый чистый. Ваш код не является полностью «универсальным», поскольку они берутся из разных таблиц и имеют разные предложения where (например, s.EnvironmentSource.Name == source против s.LightingSource.Name == source).

Вы можете комбинировать некоторые функциональные возможности, например, обобщая доступ к таблице по типу и комбинируя s.Category == category часть фильтра, но вы собираетесь иметь сочетание рефлексии (или операторов switch) и дженериков, которые могут быть более уродливыми, чем то, что у вас есть сейчас.

Если вам нужен только один метод, возможно, вам сойдет с рук использование универсальных шаблонов, как упомянул @ColinM при проверке типа, чтобы решить, какой блок кода выполнять.
Не проверял. это, и это может быть неправильный подход. Это немного зависит от того, где вы его используете.

public T Fields<T>(string spaceFunction, string category, string source)
{
    Type tt = typeof(T);
    if(tt == typeof(IQueryable<LibraryEnvironment>))
        return _dbContext.LibraryEnvironment.Where(s => s.SpaceFunction == spaceFunction
                                                        && s.Category == category &&
                                                          s.EnvironmentSource.Name == source);
    if (tt == typeof(IQueryable<LibraryEquipment>))
        return _dbContext.LibraryEquipment.Where(s => s.SpaceFunction == spaceFunction
                                                      && s.Category == category &&
                                                        s.EquipmentSource.Name == source);
    if (tt == typeof(IQueryable<LibraryLighting>))
        return _dbContext.LibraryLighting.Where(s => s.SpaceFunction == spaceFunction
                                                      && s.Category == category &&
                                                      s.LightingSource.Name == source);
    return default;
}

Затем вы можете вызвать метод, указав тип возвращаемого значения:

Fields<IQueryable<LibraryEnvironment>>("a", "b", "c");
Fields<IQueryable<LibraryEquipment>>("a", "b", "c");
Fields<IQueryable<LibraryLighting>>("a", "b", "c");