loop ou um método recursivo não consegue obter os dados

Isso pode ser feito em SQL usando dois CTEs recursivos - um que atravessa a cadeia de reunião pai/anterior e outro que atravessa a cadeia de reunião secundária/continuação. (A reunião original é excluída de ambas as listas.) É então apenas uma questão de executar a UNION ALLe (se desejado) a STRING_AGG()para construir a lista final separada por vírgulas.

Essa lógica pode ser agrupada em uma função definida pelo usuário que pode então ser adicionada ao modelo do Entity Framework e chamada a partir do seu aplicativo.

CREATE FUNCTION GetRelatedMeetings (@MeetingId INT)
RETURNS VARCHAR(MAX)
AS BEGIN
    DECLARE @RelatedMeetings VARCHAR(MAX);
  
    WITH PriorMeetings AS (
        SELECT M.MeetingId
        FROM Meetings M
        WHERE M.ContinuedMeetingId = @MeetingId
        UNION ALL
        SELECT M.MeetingId
        FROM PriorMeetings PM
        JOIN Meetings M
            ON M.ContinuedMeetingId = PM.MeetingId
    ),
    ContinuedMeetings AS (
        SELECT M.ContinuedMeetingId AS MeetingId
        FROM Meetings M
        WHERE M.MeetingId = @MeetingId
        UNION ALL
        SELECT M.ContinuedMeetingId AS MeetingId
        FROM ContinuedMeetings CM
        JOIN Meetings M
            ON M.MeetingId = CM.MeetingId
    ),
    RelatedMeetings AS (
        SELECT PM.MeetingId
        FROM PriorMeetings PM
        UNION ALL
        SELECT CM.MeetingId
        FROM ContinuedMeetings CM
    )
    SELECT @RelatedMeetings =
        STRING_AGG(RM.MeetingId, ',')
            WITHIN GROUP(ORDER BY RM.MeetingId)
    FROM RelatedMeetings RM;

    RETURN @RelatedMeetings
END

A lógica acima pressupõe que a cadeia de reuniões é linear com um relacionamento pai/filho 1 para 1. Se os relacionamentos da reunião puderem ser muitos para muitos, a travessia do gráfico seria muito mais complicada.

Embora lógica semelhante possa ser implementada em C#, não conheço uma maneira de escrever uma instrução LINQ recursiva equivalente que mapeie para uma única execução de consulta SQL. Uma implementação nativa do LINQ provavelmente faria um loop e executaria várias consultas. (Acredito que existam alguns complementos que fornecem suporte limitado a CTE, mas não sei se eles suportam recursão ou seriam adaptados a esta solução. Isso exigiria mais investigação.)

Resultados (com alguns dados de teste extras):

Veja este db<>fiddle para uma demonstração.

Honestamente, ainda não tenho certeza do que você quer fazer. e você acabou de editar sua pergunta copiando e colando algumas palavras-chave da primeira resposta recebida.

Portanto, presumo que a resposta anterior esteja mais ou menos alinhada com o que você está procurando.

Além disso, você var y = (from m in Meetings where m.MeetingId == MeetingId select new{}).FirstOrDefault()pode ser simplificado usando Meetings.FirstOrDefault(m => m.MeetingId == MeetingId).

Para escrever um loop while ou método recursivo em Csharp, você pode tentar o código abaixo:

var meetings = new List<Meeting>
{
    new Meeting {MeetingId = "1", ContinuedMeetingId = "2"},
    new Meeting {MeetingId = "2", ContinuedMeetingId = "3"},
    new Meeting {MeetingId = "3", ContinuedMeetingId = null}
};

var selectedMeetingId = "1";
var nextMeetingIds = new List<string>();
var priorMeetingIds = new List<string>();
var nextMeeting = meetings.FirstOrDefault(m => m.MeetingId == selectedMeetingId);
var priorMeeting = meetings.FirstOrDefault(m => m.ContinuedMeetingId == selectedMeetingId);
while (true)
{
    if (nextMeeting == null && priorMeeting == null)
    {
        break;
    }

    if (nextMeeting != null)
    {
        var nextMeetingId = nextMeeting.ContinuedMeetingId;
        nextMeetingIds.Add(nextMeetingId);
        nextMeeting = meetings.FirstOrDefault(m => m.MeetingId == nextMeetingId);
    }

    if (priorMeeting != null)
    {
        var priorMeetingId = priorMeeting.MeetingId;
        priorMeetingIds.Add(priorMeetingId);
        priorMeeting = meetings.FirstOrDefault(m => m.ContinuedMeetingId == priorMeetingId);
    }
}

Rascunho, resposta da comunidade

A seguir está uma possível implementação LINQ da resposta SQL recursiva CTE anterior que usa o recurso LINQ To DB – Common Table Expression (CTE) .

Este post inicial é um rascunho da tradução do SQL para C# LINQ baseado na documentação, mas não foi testado e pode precisar de correções. Não tenho experiência com isso, então pode precisar de correções ou outras melhorias. Sinta-se à vontade para editar e melhorar esta resposta conforme achar necessário. Se você puder verificar se isso é uma solução funcional, esses comentários poderão ser editados ou removidos conforme apropriado.

using LinqToDB.Configuration;
using LinqToDB.Data;

class RelatedMeetingsCTE
{
    public int MeetingId;
}

...

public string GetRelatedMeetings(int meetingId)
{
    using (var db = ...)
    {
        var priorMeetingsCte = db.GetCte<RelatedMeetingsCTE>(PriorMeetings =>
        {
            return
                (
                    from m in db.Meetings 
                    where m.ContinuedMeetingId == meetingId
                    select new RelatedMeetingsCTE
                    {
                        MeetingId = m.meetingId
                    }
                )
                .Concat
                (
                    from m in db.Meetings
                    from pm in PriorMeetings
                        .InnerJoin(pm => m.ContinuedMeetingId == pm.MeetingId)
                    select new RelatedMeetingsCTE
                    {
                        MeetingId = m.meetingId
                    }
                );
        });

        var continuedMeetingsCte = db.GetCte<RelatedMeetingsCTE>(ContinuedMeetings =>
        {
            return
                (
                    from m in db.Meetings 
                    where m.MeetingId == meetingId
                    select new RelatedMeetingsCTE
                    {
                        MeetingId = m.ContinuedMeetingId
                    }
                )
                .Concat
                (
                    from m in db.Meetings
                    from cm in ContinuedMeetings
                        .InnerJoin(cm => m.MeetingId == cm.ContinuedMeetingId)
                    select new RelatedMeetingsCTE
                    {
                        MeetingId = m.ContinuedMeetingId
                    }
                );
        });

        var relatedMeetingsCte =
            (
                from pm in priorMeetingsCte
                select new RelatedMeetingsCTE
                {
                    MeetingId = pm.MeetingId
                }
            )
            .Concat
            (
                from cm in continuedMeetingsCte
                select new RelatedMeetingsCTE
                {
                    MeetingId = cm.MeetingId
                }
            )
            .AsCte("RelatedMeetings");

        // Or perhaps just...
        //var relatedMeetingsCte =
        //    priorMeetingsCte
        //    .Concat(continuedMeetingsCte)
        //    .AsCte("RelatedMeetings");

        var result = string.Join(",", (
                from rm in relatedMeetingsCte
                orderby rm.MeetingId
                select rm.MeetingId.ToString()
            ));

        return result;
    }    
}