C# 如何将两个方法转换为一个泛型？

如何从两个方法

ConvertToDictionary

中生成一个可以处理两个集合的泛型方法

编辑： 我重写了代码，因此可以按原样运行

DgDictHosp

与

DgDictOper

在属性类型

Data

IOrderedEnumerable

vs

IOrderedEnumerable

其中，类和操作是由实体框架生成的类

using System;
using System.Collections.Generic;
using System.Linq;
    public class DictItem
    {
        public long Id { get; set; }
        public List<string> List { get; set; }
    }
    public class Hospitalization
    {
        public int ID { get; set; }
        public long IDHospitalization { get; set; }
        public int IDDiagnosis { get; set; }
    }
    public class Operation
    {
        public int ID { get; set; }
        public long IDOperation { get; set; }
        public int IDDiagnosis { get; set; }
    }
    public class DgDictOper
    {
        public long Key { get; set; }
        public IOrderedEnumerable<Operation> Data { get; set; }
        public List<string> List { get; set; }
    }
    public class DgDictHosp
    {
        public long Key { get; set; }
        public IOrderedEnumerable<Hospitalization> Data { get; set; }
        public List<string> List { get; set; }
    }
    public class Program
    {
        public static string ToLiteral(int dgid)
        {
            return "dictionary phrase for " + dgid;
        }
        public static Dictionary<long, DictItem> ConvertToDictionary(List<DgDictHosp> list_g)
        {
            var res_dict = list_g.Select(q => new DictItem
            {
                Id = q.Key,
                List = q.Data.Select(t => ToLiteral(t.IDDiagnosis)).ToList()
            }).ToDictionary(k => k.Id);
            return res_dict;
        }
        public static Dictionary<long, DictItem> ConvertToDictionary(List<DgDictOper> list_g)
        {
            var res_dict = list_g.Select(q => new DictItem
            {
                Id = q.Key,
                List = q.Data.Select(t => ToLiteral(t.IDDiagnosis)).ToList()
            }).ToDictionary(k => k.Id);
            return res_dict;
        }
        public static List<Hospitalization> InitHospList()
        {
            List<Hospitalization> list = new List<Hospitalization>();
            list.Add(new Hospitalization() { ID = 1, IDHospitalization = 11, IDDiagnosis = 10 });
            list.Add(new Hospitalization() { ID = 2, IDHospitalization = 11, IDDiagnosis = 20 });
            return list;            
        }
        public static List<Operation> InitOperList()
        {
            List<Operation> list = new List<Operation>();
            list.Add(new Operation() { ID = 1, IDOperation = 22, IDDiagnosis = 30 });
            list.Add(new Operation() { ID = 2, IDOperation = 22, IDDiagnosis = 40 });
            return list;
        }
        public static Dictionary<long, DictItem> GetHospDict(List<Hospitalization> list)
        {
            var res_g =
                (from dg in list
                 group dg by dg.IDHospitalization
                 into dg_group
                 select new DgDictHosp
                 {
                     Key = dg_group.Key,
                     Data = dg_group.OrderBy(g => g.ID)
                 }).ToList();
            var res = ConvertToDictionary(res_g);
            return res;
        }
        public static Dictionary<long, DictItem> GetOperDict(List<Operation> list)
        {
            var res_g =
                (from dg in list
                 group dg by dg.IDOperation
                 into dg_group
                 select new DgDictOper
                 {
                     Key = dg_group.Key,
                     Data = dg_group.OrderBy(g => g.ID)
                 }).ToList();
            var res = ConvertToDictionary(res_g);
            return res;
        }
        public void Main()
        {                        
            foreach (var x in GetHospDict(InitHospList())) 
            {
                Console.WriteLine("Hosp ID: " + x.Key);
                foreach (var y in x.Value.List)
                {
                    Console.WriteLine("Diagosis: " + y);  ;
                }
            }
            foreach (var x in GetOperDict(InitOperList()))
            {
                Console.WriteLine("Operation ID: " + x.Key);
                foreach (var y in x.Value.List)
                {
                    Console.WriteLine("Diagosis: " + y); ;
                }
            }
        }
    }

使用系统；
使用System.Collections.Generic；
使用System.Linq；
公共课堂用语
{
公共长Id{get；set；}
公共列表{get；set；}
}
公立医院
{
公共int ID{get；set；}
公共长IDL{get；set；}
公共int IDDiagnosis{get；set；}
}
公营课运作
{
公共int ID{get；set；}
公共长i操作{get；set；}
公共int IDDiagnosis{get；set；}
}
公共类DgDictOper
{
公共长密钥{get；set；}
公共IOrderedEnumerable数据{get；set；}
公共列表{get；set；}
}
公共级DGP
{
公共长密钥{get；set；}
公共IOrderedEnumerable数据{get；set；}
公共列表{get；set；}
}
公共课程
{
公共静态字符串ToLiteral（int dgid）
{
返回“+dgid”的“字典短语”；
}
公共静态字典转换为字典（列表）
{
变量res_dict=列表选择（q=>新词汇
{
Id=q.键，
List=q.Data.Select（t=>ToLiteral（t.IDDiagnosis））.ToList（）
}).ToDictionary（k=>k.Id）；
返回resu dict；
}
公共静态字典转换为字典（列表）
{
变量res_dict=列表选择（q=>新词汇
{
Id=q.键，
List=q.Data.Select（t=>ToLiteral（t.IDDiagnosis））.ToList（）
}).ToDictionary（k=>k.Id）；
返回resu dict；
}
公共静态列表InitHospList（）
{
列表=新列表（）；
添加（新住院（）{ID=1，ID住院=11，ID诊断=10}）；
添加（新住院（）{ID=2，idindustriation=11，IDDiagnosis=20}）；
退货清单；
}
公共静态列表InitOperList（）
{
列表=新列表（）；
Add（新操作（）{ID=1，IDOperation=22，IDDiagnosis=30}）；
Add（新操作（）{ID=2，IDOperation=22，IDDiagnosis=40}）；
退货清单；
}
公共静态词典GetHospDict（列表）
{
var Resug=
（来自名单中的dg）
按dg分组
进入dg_集团
选择新DGP
{
Key=dg_group.Key，
Data=dg_group.OrderBy（g=>g.ID）
}).ToList（）；
var res=转换到字典（res_g）；
返回res；
}
公共静态字典getOpedict（列表）
{
var Resug=
（来自名单中的dg）
按dg.I操作分组dg
进入dg_集团
选择新DgDictOper
{
Key=dg_group.Key，
Data=dg_group.OrderBy（g=>g.ID）
}).ToList（）；
var res=转换到字典（res_g）；
返回res；
}
公共图书馆
{                        
foreach（GetHospDict（inithosplit（））中的变量x）
{
控制台写入线（“软管ID:+x.Key”）；
foreach（x.Value.List中的变量y）
{
控制台写入线（“诊断：+y”）；
}
}
foreach（GetOperDict（InitOperList（））中的变量x）
{
Console.WriteLine（“操作ID:+x.Key”）；
foreach（x.Value.List中的变量y）
{
控制台写入线（“诊断：+y”）；
}
}
}
}

基本上，您的数据结构在“通用”参数上有所不同。因此，您需要一个泛型接口来适应这一点，或者您可以使用泛型类并完全摆脱

DgDictHosp

和

DgDictOper

，因为泛型类可以解释所有属性：

public class DgDictBaseClass<T> where T : HospOpBase
{
    public long Key { get; set; }
    public IOrderedEnumerable<T> Data { get; set; }
    public List<string> List { get; set; }
}

使用backback中的这些工具，您现在可以开始使映射方法通用化，以适应这两种类型的集合。作为一个参数，您现在将传递一个

列表

，然后返回

字典

：

编辑：

实际上，有一种方法可以将最后2种映射方法组合成1种。这里棘手的部分是分组变量，这实际上是两种方法的唯一区别。可以将此方法作为方法参数提供。类型为

Func

或

Func

。（这基本上意味着它是一种将

操作

作为输入参数并返回

长

，在您的示例中是属性：

dg.IDOperation

）的方法。因此，由于这两个类现在有一个公共基类，我们可以将方法设置为泛型，即类型为：

Func

的分组函数参数，并将泛型参数限制为仅类型为

HospOpBase

。现在函数将如下所示：

public static Dictionary<long, DictItem> GetOperDictNew<T>(List<T> list, Func<T, long> groupingFilter)  where T : HospOpBase
{
    var res_g =
        (from dg in list
         group dg by groupingFilter(dg) // <= use here the grouping filter
         into dg_group
         select new DgDictBaseClass<T>
         {
             Key = dg_group.Key,
             Data = dg_group.OrderBy(g => g.ID)
         }).ToList();
    var res = ConvertToDictionary(res_g);
    return res;
}

您将获得相同的输出：

医院编号：11
诊断：10的字典短语
诊断：20的字典短语
操作ID:22
诊断：30的字典短语
诊断：40的字典短语

请分享一个。你不能（不思考），除非

public static Dictionary<long, DictItem> ConvertToDictionary<T>(List<DgDictBaseClass<T>> list_g) where T : HospOpBase
{
    var res_dict = list_g.Select(q => new DictItem
    {
        Id = q.Key,
        List = q.Data.Select(t => ToLiteral(t.IDDiagnosis)).ToList()

    }).ToDictionary(k => k.Id);
    return res_dict;
}

public static Dictionary<long, DictItem> GetHospDict(List<Hospitalization> list)
{
    var res_g =
        (from dg in list
         group dg by dg.IDHospitalization
         into dg_group
         select new DgDictBaseClass<Hospitalization> // <= change here
         {
             Key = dg_group.Key,
             Data = dg_group.OrderBy(g => g.ID)
         }).ToList();
    var res = ConvertToDictionary(res_g);
    return res;
}

public static Dictionary<long, DictItem> GetOperDict(List<Operation> list)
{
    var res_g =
        (from dg in list
         group dg by dg.IDOperation
         into dg_group
         select new DgDictBaseClass<Operation> // <= change here
         {
             Key = dg_group.Key,
             Data = dg_group.OrderBy(g => g.ID)
         }).ToList();
    var res = ConvertToDictionary(res_g);
    return res;
}

public static Dictionary<long, DictItem> GetOperDictNew<T>(List<T> list, Func<T, long> groupingFilter)  where T : HospOpBase
{
    var res_g =
        (from dg in list
         group dg by groupingFilter(dg) // <= use here the grouping filter
         into dg_group
         select new DgDictBaseClass<T>
         {
             Key = dg_group.Key,
             Data = dg_group.OrderBy(g => g.ID)
         }).ToList();
    var res = ConvertToDictionary(res_g);
    return res;
}

foreach (var x in GetOperDictNew(InitHospList(), x => x.IDHospitalization))
{
    Console.WriteLine("Hosp ID: " + x.Key);
    foreach (var y in x.Value.List)
    {
        Console.WriteLine("Diagosis: " + y); ;
    }
}
foreach (var x in GetOperDictNew(InitOperList(), x => x.IDOperation))
{
    Console.WriteLine("Operation ID: " + x.Key);
    foreach (var y in x.Value.List)
    {
        Console.WriteLine("Diagosis: " + y); ;
    }
}