Combining multiple unknown queries using Union

It looks like you just need records that match any of the criteria, so "criteria 1 or criteria 2 or ...".

So, what you could do is to generate single condition from each criteria object and then join all of them with OR operator. Then use such predicate in Where, which would just produce single query with WHERE clause.

While such generation of predicate could be implemented, there is good nuget package for doing this: LinqKit.

Example usage

Using below model classes:

public class Criteria
{
    public string Name { get; set; }
    public string Email { get; set; }
}

public class User
{
    [Key]
    public int Id { get; set; }
    public string Name { get; set; }
    public string Email { get; set; }
}

I have written such code generating said predicate:

var criteria = new Criteria[]
{
    new Criteria()
    {
        Name = "CriteriaName1",
        Email = "CriteriaEmail1",
    },
    new Criteria()
    {
        Name = "CriteriaName2",
        Email = "CriteriaEmail2",
    }
};

var predicate = PredicateBuilder.New<User>();

predicate = criteria.Aggregate(
    predicate,
    (predicate, criteria) => predicate
        .Or(x => x.Name == criteria.Name && x.Email == criteria.Email));

using var context = new MyContext();

Console.WriteLine(context.Users.Where(predicate).ToQueryString());

Then I could see single query with all criteria combined with OR:

DECLARE @__criteria_Name_0 nvarchar(4000) = N'CriteriaName1';
DECLARE @__criteria_Email_1 nvarchar(4000) = N'CriteriaEmail1';
DECLARE @__criteria_Name_2 nvarchar(4000) = N'CriteriaName2';
DECLARE @__criteria_Email_3 nvarchar(4000) = N'CriteriaEmail2';

SELECT [u].[Id], [u].[Email], [u].[Name]
FROM [Users] AS [u]
WHERE ([u].[Name] = @__criteria_Name_0 AND [u].[Email] = @__criteria_Email_1) OR ([u].[Name] = @__criteria_Name_2 AND [u].[Email] = @__criteria_Email_3)

Your primary issue is this line

lastQuery.Concat(selectQuery);

It should say:

combinedQuery = lastQuery.Concat(selectQuery);

Although you could simplify the loop:

IQueryable<Valuation> combinedQuery = null;

foreach (var valuationCriteria in valuationCriteriaList)
{
    var selectQuery = DbContext.Valuations
            .Where(w => w.ActivityDate == valuationCriteria.ActivityDate &&
                w.ValuationSourceId == valuationCriteria.ValuationSourceId &&
                w.ActivityTypeId == valuationCriteria.ActivityTypeId &&
                w.CurrencyId == valuationCriteria.CurrencyId &&
                w.OrganizationHierarchyId == valuationCriteria.OrganizationHierarchyId &&
                w.StatusCode == "A");
    combinedQuery = combinedQuery is null
        ? selectQuery
        : combinedQuery.Concat(selectQuery);
}

But you would be better off using a Table Valued Parameter, rather than loads of UNION ALL queries.

First, create a Table Type

CREATE TYPE dbo.ValuationCriteria (
    ActivityDate date NOT NULL,
    ValuationSourceId int NOT NULL,
    ActivityTypeId int NOT NULL,
    CurrencyId char(3) NOT NULL,
    OrganizationHierarchyId int NOT NULL,
    -- what is the PRIMARY KEY ??
);

You need an entity class for this

class ValuationCriteria
{
    public DateTime ActivityDate { get; set; }
    public int ValuationSourceId { get; set; }
    public int ActivityTypeId { get; set; }
    public string CurrencyId { get; set; }
    public int OrganizationHierarchyId { get; set; }
}

modelBuilder.Entity<ValuationCriteria>().HasNoKey();

Then you create a DataTable with the values, and pass it in as a SqlParameter. You can then compose over that in a join.

public List<Valuation> GetValuations(List<GetValuationCriteria> valuationCriteriaList)
{
    var table = new DataTable { Columns = {
        { "ActivityDate", typeof(DateTime) },
        { "ValuationSourceId", typeof(int) },
        { "ActivityTypeId", typeof(int) },
        { "CurrencyId ", typeof(string) },
        { "OrganizationHierarchyId", typeof(int) },
    } };
    foreach (var criteria in valuationCriteriaList)
        table.Add(criteria.ActivityDate, criteria.ValuationSourceId, criteria.ActivityTypeId, criteria.CurrencyId, criteria.OrganizationHierarchyId);

    var param = new SqlParameter("@tvp", SqlDbType.Structured) { TypeName = "dbo.ValuationCriteria", Value = table };
    var tvp = DbContext.FromSql<ValuationCriteria>($"SELECT * FROM {param}");
    // must do this in a separate step or it won't compose
    var query = DbContext.Valuations
        .Where(w => tvp.Any(t =>
            w.ActivityDate == t.ActivityDate &&
            w.ValuationSourceId == t.ValuationSourceId &&
            w.ActivityTypeId == t.ActivityTypeId &&
            w.CurrencyId == t.CurrencyId &&
            w.OrganizationHierarchyId == t.OrganizationHierarchyId)
          && w.StatusCode == "A");
    return query.ToList();
}