grazie Alessio, non c'è dubbio che io debba studiare ancora molto dato che è il primo progetto che provo a fare con Linq To Entities ed Entity Framework quindi andrò a guardare i link che mi hai passato.

Per la cronaca, ho applicato i tuoi suggerimenti anche perchè ho capito la filosofia del cambiamento che mi hai chiesto di fare ed ora funziona correttamente anche ho dovuto comunque sostituire ToList() nelle due query con AsEnumerable() altrimenti la Union non la faceva dato che le due query in realtà proiettano i dati su una stessa DTO ma non ti avevo detto che pescano i dati da due entità diverse.

Poi ho notato che non ti avevo risposto sul passaggio di una dropdownlist come parametro... in realtà per ora l'ho fatto per "fretta" nel senso che poi lo cambierò passando solo la lista di elementi variabili da cui è composta

Se proprio vuoi aiutarmi ti mostro la versione completa "funzionante" ma sicuramente migliorabile...
Ecco le considerazioni:
query, quer1 e query2 sono di fatto insiemi disgiunti quindi se non ho capito male potrei usare anche Concat invece di Union per unirli nella query3 finale
query pesca da un entità contenente barche sicuramente non presenti in query1
query2 "dovrebbe" pescare dall'entità che contiene TUTTE le barche togliendo quelle presenti in query e query1. Per fare questo uso le due liste IList0 e 1 per ricavare l'id delle barche delle prime due query e toglierli nella query2 anche se sono certo esistano metodi migliori solo che non li trovo...
Infine AsEnumerable alla fine delle 3 query ho dovuto metterlo altrimenti la Union mi da errore (ho letto che da errore perchè anche se le query creano tutte lo stesso DTO pescano dati da entità diverse.


public IQueryable<BarcaplanningDTO> GetBarchePlanningDTO(ListItemCollection ddl, int mese, int anno, string tipofiltro)
{
List<int> IdList0 = null;
List<int> IdList1 = null;
List<Filter> filtro = new List<Filter>();
Func<BarcaplanningDTO, bool> deleg = null;

if (ddl.Count > 0)
{
foreach (ListItem t in ddl)
{
filtro.Add(new Filter { PropertyName = t.Text, Operation = (tipofiltro == "") ? Op.Equals : Op.Contains, Value = t.Value });
}
deleg = FiltroExpressionBuilder.GetExpression<BarcaplanningDTO>(filtro).Compile();
}

var query = _db.ListEventiBarche
.Where(r => r.Evento.Event_date.Month == mese || r.Evento.Event_end_date.Month == mese)
.GroupBy(r => r.Barca.BarcaID)
.Select(r => new BarcaplanningDTO
{
BarcaID = r.Key,
EventoExtraID = r.Select(x => 0).ToList(),
Titolo = r.Select(x => x.Evento.Title).ToList(),
Modello = r.Select(x => x.Barca.Modello).FirstOrDefault(),
Nome = r.Select(x => x.Barca.Nome).FirstOrDefault(),
Regione = r.Select(x => x.Barca.Regione).FirstOrDefault(),
Letti = r.Select(x => x.Barca.Letti).FirstOrDefault(),
Imbarco = r.Select(x => x.Imbarco.Nome).ToList(),
Occupata = r.Select(x => 3).ToList(),
Ordine = 3,
Dateint = r.Select(x => new Intervallodate { EventoID = x.EventoID, Event_date = x.Evento.Event_date, Event_end_date = x.Evento.Event_end_date }).ToList()
}).AsEnumerable();


var query1 = _db.ListEventiExtraBarche
.Where(r => r.Event_date.Month == mese || r.Event_end_date.Month == mese)
.GroupBy(r => r.Barca.BarcaID)
.Select(r => new BarcaplanningDTO
{
BarcaID = r.Key,
EventoExtraID = r.Select(x => x.EventoExtraID).ToList(),
Titolo = r.Select(x => x.Title).ToList(),
Modello = r.Select(x => x.Barca.Modello).FirstOrDefault(),
Nome = r.Select(x => x.Barca.Nome).FirstOrDefault(),
Regione = r.Select(x => x.Barca.Regione).FirstOrDefault(),
Letti = r.Select(x => x.Barca.Letti).FirstOrDefault(),
Imbarco = r.Select(x => "").ToList(),
Occupata = r.Select(x => x.Occupata).ToList(),
Ordine = 2,
Dateint = r.Select(x => new Intervallodate { EventoID = x.EventoExtraID, Event_date = x.Event_date, Event_end_date = x.Event_end_date }).ToList()
}).AsEnumerable();

IdList0 = query.Select(r => r.BarcaID).ToList();
IdList1 = query1.Select(t => t.BarcaID).ToList();
foreach (int li in IdList1)
IdList0.Add(li);


var query2 = _db.ListBarche.Where(p => !IdList0.Any(p2 => p2 == p.BarcaID))
.Select(r => new BarcaplanningDTO
{
BarcaID = r.BarcaID,
Modello = r.Modello,
Nome = r.Nome,
Letti = r.Letti,
Regione = r.Regione,
Imbarco = new List<string> { "" }.ToList(),
Ordine = 0,
Occupata = new List<int> { 0 }.ToList(),
}).AsEnumerable();

var query3 = query.Union(query1).Union(query2).AsQueryable();

if (filtro.Count > 0)
return query3.Where<BarcaplanningDTO>(deleg).AsQueryable();
else
return query3;
}


public class BarcaplanningDTO
{

[DefaultValue(0)]
public List<int> EventoExtraID { get; set; }
public int BarcaID { get; set; }
public List<Intervallodate> Dateint { get; set; }
public List<string> Titolo { get; set; }
public string Modello { get; set; }
public string Nome { get; set; }
public int Letti { get; set; }
public string Regione { get; set; }
[DefaultValue("")]
public List<string> Imbarco { get; set; }
public string Imbarcostring
{
get { return string.Join(",", Imbarco); }
set { Imbarcostring = value; }
}
[DefaultValue(0)]
public List<int> Occupata { get; set; }
public int Ordine { get; set; }
}

grazie lo stesso Alessio
confermo che i link che mi hai passato li ho letti ma non ancora "applicati" anche perchè prima vanno compresi bene, così come ho notato la quantità di query che vengono in realtà eseguite usando LinqPad4 come applicazione di test perche mi mostra subito come vengono trasformate le query in SQL
Io provengo da anni di utilizzo di ObjectDataSource e istruzioni SQL dirette al DB o all'uso di Stored Procedure così, provando ad "aggiornarmi" sulle novità informatiche, mi è parso all'inizio molto "comodo" l'utilizzo di Entity Framework e Linq To Entities perchè semplificano le righe di codice da scrivere ma ammetto che mi sono imputato sul voler usare queste strutture sempre e comunque cercando di ottimizzarle (quando capirò bene come si usano).

Dalle parole che scrivi e dalle query che vengono poi eseguite in questo particolare caso del GetBarchePlanningDTO mi sa che mi conviene davvero accettare di fare una query diretta al DB per evitare di "farmi male" magari quando i dati saranno più numerosi.