Simulation de jointures de contexte croisé - LINQ / C #

c# datacontext entity-framework linq

Question

Voici le problème:

J'ai deux contextes de données sur lesquels j'aimerais faire une jointure. Maintenant, je sais que LINQ n'autorise pas les jointures d'un contexte à l'autre et je sais que deux solutions possibles consisteraient à créer un seul contexte de données ou à avoir deux requêtes distinctes (ce que je fais pour l'instant). Cependant, ce que je voudrais faire est de "simuler" une jointure.

Voici ce que j'ai essayé.

using (var _baseDataContext = Instance)
{
    var query = from a in _baseDataContext.Account.ACCOUNTs
                where a.STR_ACCOUNT_NUMBER.ToString() == accountID
                join app in _baseDataContext.Account.APPLICATIONs on a.GUID_ACCOUNT_ID equals
                            app.GUID_ACCOUNT
                join l in GetLoans() on app.GUID_APPLICATION equals l.GUID_APPLICATION
                select l.GUID_LOAN;

    return query.Count() > 0 ? query.First() : Guid.Empty;
}

private static IQueryable<LOAN> GetLoans()
{
    using (var _baseDataContext = Instance)
    {
        return (from l in _baseDataContext.Loan.LOANs
                select l).AsQueryable();
    }
}

Dans le temps, je reçois est

System.InvalidOperationException: la requête contient des références à des éléments définis dans un contexte de données différent

MODIFIER:

Solution de travail:

using (var _baseDataContext = Instance)
{
    var query = from a in _baseDataContext.Account.ACCOUNTs
                where a.STR_ACCOUNT_NUMBER.ToString() == accountID
                join app in _baseDataContext.Account.APPLICATIONs on a.GUID_ACCOUNT_ID equals
                           app.GUID_ACCOUNT
                join l in GetLoans() on app.GUID_APPLICATION equals l.GUID_APPLICATION 
                select l.GUID_LOAN;

     return (query.Count() > 0) ? query.First() : Guid.Empty;
}

private static IEnumerable<LOAN> GetLoans()
{
    using (var _baseDataContext = Instance)
    {
        return (from l in _baseDataContext.Loan.LOANs
                select l).AsQueryable();
    }
}

Réponse acceptée

Peut-être que quelque chose comme cela peut vous aider à démarrer dans la bonne direction. J'ai créé une base de données fictive avec des colonnes similaires en fonction de vos noms de colonnes et obtenu des résultats.

    class Program
{
    static AccountContextDataContext aContext = new AccountContextDataContext(@"Data Source=;Initial Catalog=;Integrated Security=True");
    static LoanContextDataContext lContext = new LoanContextDataContext(@"Data Source=;Initial Catalog=;Integrated Security=True");

    static void Main()
    {

        var query = from a in aContext.ACCOUNTs
                    join app in aContext.APPLICATIONs on a.GUID_ACCOUNT_ID equals app.GUID_ACCOUNT
                    where app.GUID_APPLICATION.ToString() == "24551D72-D4C2-428B-84BA-5837A25D8CF6"
                    select GetLoans(app.GUID_APPLICATION);

        IEnumerable<LOAN> loan = query.First();
        foreach (LOAN enumerable in loan)
        {
            Console.WriteLine(enumerable.GUID_LOAN);
        }

        Console.ReadLine();
    }

    private static IEnumerable<LOAN> GetLoans(Guid applicationGuid)
    {
        return (from l in lContext.LOANs where l.GUID_APPLICATION == applicationGuid select l).AsQueryable();
    }
}

J'espère que cela t'aides!


Réponse populaire

C'est le "contournement" que nous avons trouvé ...

Nous avons construit nos tables à partir de l'autre base de données manuellement et si elle se trouve sur le même serveur, nous avons préfixé le nom de la table avec:

<DatabaseName>.<SchemaName>.<YourTableName>

s'ils se trouvent sur un serveur lié, vous devez également le préfixer avec le nom du serveur:

<ServerName>.<DatabaseName>.<SchemaName>.<YourTableName>

Cela vous permettra de faire des jointures tout en retournant un IQueryable non exécuté ... ce que nous voulions. Les 2 autres façons d’impliquer des jointures en mémoire IEnumerables, c’est-à-dire extraire tous les enregistrements pour chaque jointure avant de faire la jointure (ci-dessus) et de faire une jointure IQueryable à l’aide d’une méthode contient qui a ses limites

Espérons qu'à l'avenir, le DataContext sera suffisamment intelligent pour savoir que si les serveurs sont liés, vous pouvez effectuer des jointures entre deux serveurs différents.



Related

Sous licence: CC-BY-SA with attribution
Non affilié à Stack Overflow
Sous licence: CC-BY-SA with attribution
Non affilié à Stack Overflow