La simulation de la Croix Contexte Rejoint--LINQ/C#

Voici la question:

J'ai 2 données de contextes que je voudrais faire une jointure sur. Maintenant, je sais que LINQ n'autorise pas les jointures d'un contexte à un autre, et je sais que 2 solutions possibles serait de créer un seul datacontext ou d'avoir 2 séparés des requêtes (qui est 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();
    }
}

Au moment de l'exécution j'obtiens est

Système.InvalidOperationException: La requête contient des références à des articles définis sur un autre contexte de données

EDIT:

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();
    }
}

OriginalL'auteur David Yancey | 2009-05-22

  1. 12

    Peut-être quelque chose comme cela peut vous aider à démarrer dans la bonne direction. J'ai fait une maquette de la base de données avec les mêmes colonnes en fonction de vos noms de colonne et a obtenu certains 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();
    }
}

    Espérons que cette aide!

    J'ai essayé de retourner IEnumerable<EMPRUNT> auparavant, mais a reçu une erreur de casting, comme prévu. Cependant, je n'avais pas pensé au retour d'une IEnuerable<EMPRUNT> AsQueryable.
    un problème potentiel avec cette approche est que vous ne faites pas un pur rejoindre, donc si vous avez besoin d'ajouter une autre jointure du prêt contexte de votre ne sera pas en mesure de partir de ce que je peux voir.
    Ok travaillé. Nous pouvons supprimer la clause where de la Méthode de jointure et au lieu de faire une sélection à partir de la Méthode il suffit de faire une pure rejoindre. Le truc c'est que la méthode doit retourner un IEnumerable<T>.AsQueryable Cela nous permet de faire de la croix contexte des jointures et jusqu'à présent je ne vois pas de toutes les performances.

    OriginalL'auteur

  2. 3

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

    Nous avons construit nos tables de la base de données manuellement et si c'est sur le même serveur, puis nous préfixer le nom de la table avec:

    <DatabaseName>.<SchemaName>.<YourTableName>

    si elles sont sur un serveur lié, alors vous devez préfixer avec le nom du serveur ainsi:

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

    Cela vous permettra de faire des jointures et toujours retourner un non exécuté IQueryable... qui est ce que nous voulions. Les 2 autres façons d'impliquer les rejoindre en mémoire IEnumerables ce qui signifie que votre pull tous les enregistrements pour chaque avant de faire la jointure (ci-dessus) et de faire un IQueryable rejoindre à l'aide d'une méthode contains qui a des limites...

    Espérons que dans l'avenir le DataContext sera construit assez intelligent pour savoir que si les serveurs sont liés, alors vous pouvez faire des jointures entre les deux différents.

    Alors que c'est une bonne idée mais dans ce cas, ce n'est pas une option. Merci pour la suggestion.

    OriginalL'auteur

  3. 0

    Je préfère créer un contexte de données qui ne contient que les deux tables que vous souhaitez rejoindre. Mais je suppose que vous pourriez maintenir une table temporaire (contenant des données à partir de la première) dans le deuxième contexte, puis se joindre à la table temporaire.

    la création d'une salle de datacontext où juste besoin de deux tables est une possibilité, mais ce n'est pas un cas isolé besoin, c'est juste un seul exemple de la nécessité de cette solution. Je veux éviter de créer un isolé datacontext chaque fois que j'ai besoin de répondre à ce besoin.

    OriginalL'auteur