Combiner le résultat de différentes procédures stockées dans une seule liste en c #

Vous ne pouvez pas Concatrer des listes de deux types de sources différents. Voir la signature des fonctions:

public interface IInterface {}
public class AgentTermDTO : IInterface {}
public class AgentHospCashPlanDTO : IInterface {}

Pour ce faire, projetez chaque liste dans un type qui partage le même type de base ou interface. Quelque chose de la structure:

public static System.Collections.Generic.IEnumerable<TSource> Concat<TSource> 
    (this System.Collections.Generic.IEnumerable<TSource> first, 
     System.Collections.Generic.IEnumerable<TSource> second);

ou une solution rapide et sale (n'allez pas pour celle-ci) consiste à convertir chacun en une collection d ' object code > s: list1.Cast

Si vous aviez écrit la définition complète de term et hosp au lieu de var, vous auriez écrit quelque chose comme:

IEnumerable<IMyInterface> myTerms = terms.Select(term => new AgentTerm
    {
         TermResult = term,
    })
    .Cast<IMyInterface>();
IEnumerable<IMyInterface> myHosps = hosps.Select(hosp => new MyHosp
    {
        Hosp = hosp,
    })
    .Cast<IMyInterface>();

var result = myTerms.Concat(myHosps);

Apparemment, ils ne sont pas du même type. Vous ne pouvez concaténer que des séquences de type similaire. Hélas vous avez oublié de nous écrire vos cours. Si un terme et un hosp sont liés, par exemple s'ils ont la même super classe, vous pouvez les convertir en super classe avant de contaténer:

class AgentTerm : IMyInterface
{
     public AgentTerm_Result TermResult {get; set;}

     public int Id => this.TermResult.TermResultId;
     public string Name => this.TermResult.TermResultName;

Cela fonctionne également s'ils implémentez la même interface.

S'il n'y a rien de commun entre eux, vous devriez peut-être reconsidérer l'idée de concaténer ces deux listes. Après tout, à quoi sert la collection de Vaches mélangée à une collection de NewYorkCityBuildings?

Quoi qu'il en soit, si vous pensez vraiment qu'il y a quelque chose de commun , il existe plusieurs solutions pour concaténer les séquences. Bien sûr, vous ne pouvez utiliser que les propriétés qu'ils ont en commun.

Pensez à créer une interface contenant les propriétés auxquelles vous souhaitez accéder:

interface IMyInterface
{
     // Properties that are both in AgentTerm_Result and in AgentHospCashPlan
     int Id {get;}
     string Name {get;}
}

class AgentTerm_Result : IMyInterface {...}
class AgentHospCashPlan : IMyInterface{...}

var result = terms.Cast<IMyInterface>()
     .Concat(hosps.Cast<IMyInterface>();

Si il n'y a pas de propriétés communes, pensez à créer une classe wrapper qui convertit les propriétés en propriétés appropriées:

var result = terms.Cast<CommonSuperClass>()
    .Concat(hosps.Cast<CommonSuperClass>();

}

et similaire pour Hosp p >

List<AgentTerm_Result> terms = ...
List<AgentHospCashPlan_Result> hosps = ...

Si vous souhaitez renvoyer deux listes contenant deux types différents, la meilleure option est de renvoyer un type personnalisé ou même simplement de renvoyer un tuple.

Pour renvoyer un type personnalisé, définissez simplement une classe contenant les valeurs de retour :

var (term, hop) = GetResults();

Vous pouvez maintenant le faire facilement:

public (List<AgentTerm_Result>, List<AgentHospCashPlan_Result>) GetResults()
{
    var Agentcode = "";

    var term = dc.AgentTerm(Agentcode).ToList();
    var hosp = dc.AgentHospCashPlan(Agentcode).ToList();

    return (term, hosp);
}   

Utiliser un tuple est un peu plus facile que vous ne le faites pas besoin de définir quelque chose de nouveau:

public Results GetResults()
{
    var term = dc.AgentTerm(Agentcode).ToList();
    var hosp = dc.AgentHospCashPlan(Agentcode).ToList();

    return new Results { AgentTerms = term, AgentHospCashPlan = hosp };
}

Pour obtenir les résultats du tuple, appelez-le simplement comme ceci:

public class Results
{
    public List<AgentTerm_Result> AgentTerms;
    public List<AgentHospCashPlan_Result> AgentHospCashPlan;
}

Ensuite vous pouvez utiliser les résultats comme deux variables distinctes.