C# 用这种方法烘干

我需要帮助使这个方法通用。重复大约十次以获取不同web列表控件的列表（用“MyType”替换特定控件中使用的类型）

private静态IList GetList（请求表单）
{
//获取基本列表
IMyTypeRepository myTypeRepository=新建myTypeRepository（新建HybridSessionBuilder（））；
IList myTypes=myTypeRepository.GetAll（）；
//创建结果列表
IList结果=新列表（）；
//迭代活动+已用列表项
foreach（MyType中的MyType MyType）
{
if（myType.Active | | form.SolutionType.Contains（myType.Value））
{
结果.添加（myType）；
}
}
//返回排序结果
OrderBy（o=>o.DisplayOrder）；
返回结果；
}

如果这还不够，请告诉我。我认为这需要我刚刚熟悉的更高级的语言特性。也许我应该让他们都使用同一个存储库

谢谢你的帮助

编辑：

---

谢谢你的帮助。我没有任何同行的支持，所以这个董事会太棒了，我从你们每个人身上学到了一些东西。我希望我能接受所有的答案。

如果所有类型都实现了相同的接口（如果它们没有实现，则创建它们，并确保将此方法所需的所有属性添加到接口），则可以执行以下操作：

private static IList<T> GetList(RequestForm form)
       where T: IMyInterface
    {
        // get base list
        IMyTypeRepository myTypeRepository = new MyTypeRepository(new HybridSessionBuilder());
        IList<T> myTypes = myTypeRepository.GetAll();

        // create results list
        IList<T> result = new List<T>();

        // iterate for active + used list items
        foreach (T myType in myTypes)
        {
            if (myType.Active || form.SolutionType.Contains(myType.Value))
            {
                result.Add(myType);
            }
        }

        // return sorted results

        return result.OrderBy(o => o.DisplayOrder).ToList();
    }

private static IList<MyType> GetList(RequestForm form)
{
    // get base list
    IMyTypeRepository myTypeRepository =
        new MyTypeRepository(new HybridSessionBuilder());

    IList<MyType> myTypes = myTypeRepository.GetAll();

    return myTypes.Where(x => x.Active || form.SolutionType.Contains(x.Value))
                  .OrderBy(x => x.DisplayOrder).ToList();
}

---

当然，假设您的所有存储库都实现了IMyRepository接口。

如果所有类型都实现了相同的接口（如果它们没有实现相同的接口，请确保将此方法所需的所有属性添加到接口中），则可以执行以下操作：

private static IList<T> GetList(RequestForm form)
       where T: IMyInterface
    {
        // get base list
        IMyTypeRepository myTypeRepository = new MyTypeRepository(new HybridSessionBuilder());
        IList<T> myTypes = myTypeRepository.GetAll();

        // create results list
        IList<T> result = new List<T>();

        // iterate for active + used list items
        foreach (T myType in myTypes)
        {
            if (myType.Active || form.SolutionType.Contains(myType.Value))
            {
                result.Add(myType);
            }
        }

        // return sorted results

        return result.OrderBy(o => o.DisplayOrder).ToList();
    }

private static IList<MyType> GetList(RequestForm form)
{
    // get base list
    IMyTypeRepository myTypeRepository =
        new MyTypeRepository(new HybridSessionBuilder());

    IList<MyType> myTypes = myTypeRepository.GetAll();

    return myTypes.Where(x => x.Active || form.SolutionType.Contains(x.Value))
                  .OrderBy(x => x.DisplayOrder).ToList();
}

---

当然，假设您的所有存储库都实现IMyRepository接口。

假设存储库共享一个公共接口，那么存储库的问题应该很容易解决：添加一个静态函数，例如

public static IRepository RepositoryForType(Type t)
{
    if(t == typeof(SomeClass))
       return new SomeClassRepository(new HybridSession());
    else if ...
    else throw new InvalidOperationException("No repository for type " + t.Name);
}

---

这应该要求您对现有代码进行最少的更改，但请记住，将来在项目中添加新存储库时，您必须在此函数中添加对新存储库的类支持（如果您使用单元测试，您将很容易发现您是否忘记了此帮助器）.

假设存储库共享一个公共接口，那么存储库的问题应该很容易解决：添加一个静态函数，例如

public static IRepository RepositoryForType(Type t)
{
    if(t == typeof(SomeClass))
       return new SomeClassRepository(new HybridSession());
    else if ...
    else throw new InvalidOperationException("No repository for type " + t.Name);
}

---

这应该要求您对现有代码进行最少的更改，但请记住，将来在项目中添加新存储库时，您必须在此函数中添加对新存储库的类支持（如果您使用单元测试，您将很容易发现您是否忘记了此帮助器）.

首先，您可以使函数更简洁，如下所示：

private static IList<T> GetList(RequestForm form)
       where T: IMyInterface
    {
        // get base list
        IMyTypeRepository myTypeRepository = new MyTypeRepository(new HybridSessionBuilder());
        IList<T> myTypes = myTypeRepository.GetAll();

        // create results list
        IList<T> result = new List<T>();

        // iterate for active + used list items
        foreach (T myType in myTypes)
        {
            if (myType.Active || form.SolutionType.Contains(myType.Value))
            {
                result.Add(myType);
            }
        }

        // return sorted results

        return result.OrderBy(o => o.DisplayOrder).ToList();
    }

private static IList<MyType> GetList(RequestForm form)
{
    // get base list
    IMyTypeRepository myTypeRepository =
        new MyTypeRepository(new HybridSessionBuilder());

    IList<MyType> myTypes = myTypeRepository.GetAll();

    return myTypes.Where(x => x.Active || form.SolutionType.Contains(x.Value))
                  .OrderBy(x => x.DisplayOrder).ToList();
}

---

首先，您可以将函数变得更简洁，如下所示：

private static IList<T> GetList(RequestForm form)
       where T: IMyInterface
    {
        // get base list
        IMyTypeRepository myTypeRepository = new MyTypeRepository(new HybridSessionBuilder());
        IList<T> myTypes = myTypeRepository.GetAll();

        // create results list
        IList<T> result = new List<T>();

        // iterate for active + used list items
        foreach (T myType in myTypes)
        {
            if (myType.Active || form.SolutionType.Contains(myType.Value))
            {
                result.Add(myType);
            }
        }

        // return sorted results

        return result.OrderBy(o => o.DisplayOrder).ToList();
    }

private static IList<MyType> GetList(RequestForm form)
{
    // get base list
    IMyTypeRepository myTypeRepository =
        new MyTypeRepository(new HybridSessionBuilder());

    IList<MyType> myTypes = myTypeRepository.GetAll();

    return myTypes.Where(x => x.Active || form.SolutionType.Contains(x.Value))
                  .OrderBy(x => x.DisplayOrder).ToList();
}

---

首先，您的所有类型都必须实现一个通用的

接口

，该接口定义属性，如

活动

，

值

另外，据我所知，必须为所有存储库提供一个独立于

MyType

的存储库接口，以便您可以使用这样的通用方法。

GetAll（）

方法应该在

IRepository

中定义

public interface IRepository<T> where T : IMyType
{
    IList<T> GetAll();
}

public class RepositoryFactory
{
    public static IRepository<T> createRepository<T>(ISessionBuilder sb) where T : IMyType
    {
        // create repository
    }
}

public interface IMyType
{
    bool Active { get; }
    string Value { get; }
}

private static IList<T> GetList(RequestForm form) where T : IMyType
{
    // get base list
    IRepository<T> repository = RepositoryFactory.createRepository<T>(new HybridSessionBuilder());
    IList<T> myTypes = repository.GetAll();

    // create results list
    IList<T> result = new List<T>();

    // iterate for active + used list items
    foreach (T myType in myTypes)
    {
        if (myType.Active || form.SolutionType.Contains(myType.Value))
        {
            result.Add(myType);
        }
    }

    // return sorted results
    return result.OrderBy(o => o.DisplayOrder).ToList();
}

公共接口IRepository，其中T:IMyType
{
IList GetAll（）；
}
公共类存储工厂
{
公共静态IRepository createRepository（ISessionBuilder sb），其中T:IMyType
{
//创建存储库
}
}
公共接口IMyType
{
bool活动{get；}
字符串值{get；}
}
私有静态IList GetList（RequestForm表单），其中T:IMyType
{
//获取基本列表
IRepository repository=RepositoryFactory.createRepository（新的HybridSessionBuilder（））；
IList myTypes=repository.GetAll（）；
//创建结果列表
IList结果=新列表（）；
//迭代活动+已用列表项
foreach（myTypes中的T myType）
{
if（myType.Active | | form.SolutionType.Contains（myType.Value））
{
结果.添加（myType）；
}
}
//返回排序结果
返回result.OrderBy（o=>o.DisplayOrder.ToList（）；
}

首先，所有类型都必须实现一个通用的

接口

，该接口定义属性，如

活动

，

值

另外，据我所知，必须为所有存储库提供一个独立于

MyType

的存储库接口，以便您可以使用这样的通用方法。

GetAll（）

方法应该在

IRepository

中定义

public interface IRepository<T> where T : IMyType
{
    IList<T> GetAll();
}

public class RepositoryFactory
{
    public static IRepository<T> createRepository<T>(ISessionBuilder sb) where T : IMyType
    {
        // create repository
    }
}

public interface IMyType
{
    bool Active { get; }
    string Value { get; }
}

private static IList<T> GetList(RequestForm form) where T : IMyType
{
    // get base list
    IRepository<T> repository = RepositoryFactory.createRepository<T>(new HybridSessionBuilder());
    IList<T> myTypes = repository.GetAll();

    // create results list
    IList<T> result = new List<T>();

    // iterate for active + used list items
    foreach (T myType in myTypes)
    {
        if (myType.Active || form.SolutionType.Contains(myType.Value))
        {
            result.Add(myType);
        }
    }

    // return sorted results
    return result.OrderBy(o => o.DisplayOrder).ToList();
}

公共接口IRepository，其中T:IMyType
{
IList GetAll（）；
}
公共类存储工厂
{
公共静态IRepository createRepository（ISessionBuilder sb），其中T:IMyType
{
//创建存储库
}
}
公共接口IMyType
{
bool活动{get；}
字符串值{get；}
}
私有静态IList GetList（RequestForm表单），其中T:IMyType
{
//获取基本列表
IRepository repository=RepositoryFactory.createRepository（新的HybridSessionBuilder（））；
IList myTypes=repository.GetAll（）；
//创建结果列表
IList结果=新列表（）；
//迭代活动+已用列表项
foreach（myTypes中的T myType）
{
if（myType.Active | | form.SolutionType.Contains（myType.Value））
{
结果.添加（myType）；
}
}
//返回排序结果
返回result.OrderBy（o=>o.DisplayOrder.ToList（）；
}

感谢您及时收到订单；在测试中还没有走那么远。所有类型都实现相同的接口，但使用自己的存储库。我必须让他们都使用相同的存储库，是吗？不一定。您可以使用某种工厂，根据T的类型创建存储库。请参阅我的编辑。感谢您通过捕获订单；我没有走那么远