C# 文件系统或程序集嵌入资源中文件的多态搜索

我正在学习在C#中使用多态性，但无法理解这一点。我正在尝试编写一个类，该类允许我从存储库中获取文件的筛选列表

存储库可以是文件系统文件夹，也可以是任意已加载程序集中的嵌入资源（但它不是当前正在执行的程序集）

有什么建议吗？

使用系统；
using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;

namespace Reposes
{
    class ReposeFile
    {
        string m_name;

        public string Name
        {
            get { return m_name; }
        }

        public ReposeFile(string name)
        {
            m_name = name;
        }
    }

    interface IRepose
    {
        void RetriveFiles();
        ReposeFile[] Files { get; }
    }

    class FileSystemRepose : IRepose
    {
        string m_path = null;
        List<ReposeFile> m_files = new List<ReposeFile>();

        public FileSystemRepose(string path)
        {
            m_path = path;
        }

        #region IRepose Members

        public void RetriveFiles()
        {
            string[] files = Directory.GetFiles(m_path);
            foreach (string file in files)
            {
                m_files.Add(new ReposeFile(file));
            }
        }

        public ReposeFile[] Files
        {
            get { return m_files.ToArray(); }
        }

        #endregion
    }

    class AssemblyRepose : IRepose
    {
        string m_assembly = null;
        List<ReposeFile> m_files = new List<ReposeFile>();

        public AssemblyRepose(string assembly)
        {
            m_assembly = assembly;
        }

        #region IRepose Members

        public void RetriveFiles()
        {
            m_files.Add(new ReposeFile("Stuff"));
        }

        public ReposeFile[] Files
        {
            get { return m_files.ToArray(); }
        }

        #endregion
    }

    class Consumer
    {
        static void Main()
        {
            List<IRepose> reps = new List<IRepose>();
            reps.Add(new FileSystemRepose("c:\\")); // would normally be @"c:\" but stackoverflow's syntax highlighter barfed :)
            reps.Add(new AssemblyRepose("rep.dll"));

            foreach (IRepose rep in reps)
            {
                rep.RetriveFiles();

                foreach (ReposeFile file in rep.Files)
                {
                    Console.WriteLine(file.Name);
                }
            }

            Console.ReadKey();
        }
    }
}

使用系统集合；
使用System.Collections.Generic；
使用System.IO；
命名空间休息
{
类ReposeFile
{
字符串m_name；
公共字符串名
{
获取{return m_name；}
}
公共ReposeFile（字符串名称）
{
m_name=名称；
}
}
界面不适
{
无效检索文件（）；
ReposeFile[]文件{get；}
}
类filesystemrespose:IRepose
{
字符串m_path=null；
列出m_文件=新建列表（）；
公共文件系统休息（字符串路径）
{
m_path=路径；
}
#地区委员
公共无效检索文件（）
{
string[]files=Directory.GetFiles（m_路径）；
foreach（文件中的字符串文件）
{
添加（新的ReposeFile（文件））；
}
}
公共ReposeFile[]文件
{
获取{return m_files.ToArray（）；}
}
#端区
}
类AssemblyRespose:iResose
{
字符串m_assembly=null；
列出m_文件=新建列表（）；
公共程序集休息（字符串程序集）
{
m_assembly=assembly；
}
#地区委员
公共无效检索文件（）
{
添加（新的ReposeFile（“Stuff”）；
}
公共ReposeFile[]文件
{
获取{return m_files.ToArray（）；}
}
#端区
}
阶级消费者
{
静态void Main（）
{
列表代表=新列表（）；
reps.Add（newfilesystemrespose（“c:\\”）；//通常为@“c:\”，但stackoverflow的语法高亮显示为：
reps.Add（新的AssemblyRespose（“rep.dll”）；
foreach（IRepose rep in reps）
{
rep.retrievefiles（）；
foreach（rep.Files中的ReposeFile文件）
{
Console.WriteLine（file.Name）；
}
}
Console.ReadKey（）；
}
}
}

---

这是一个粗略的示例，但应该为您指出正确的方向：）

您可以这样定义一对接口：

public interface IReadableFile
{
    Stream OpenRead();
}

public interface IRepository
{
    IEnumerable<IReadableFile> Search(string pattern);
}

公共接口IReadableFile
{
流OpenRead（）；
}
公共接口假定
{
IEnumerable搜索（字符串模式）；
}

并且有两种不同的实现方式：

public class FolderFile : IReadableFile
{
    readonly private string _name;

    public FolderFile(string name)
    {
        _name = name;
    }

    #region IFile Members

    public Stream OpenRead()
    {
        return File.OpenRead(_name);
    }

    #endregion
}

public class FolderRepository : IRepository
{
    readonly private string _directory;

    public FolderRepository(string directory)
    {
        _directory = directory;
    }

    #region IRepository Members

    public IEnumerable<IReadableFile> Search(string pattern)
    {
        return Array.ConvertAll(Directory.GetFiles(_directory, pattern), name => new FolderFile(name));
    }

    #endregion
}

public class AssemblyFile : IReadableFile
{
    readonly private Assembly _assembly;
    readonly private string _name;

    public AssemblyFile(Assembly assembly, string name)
    {
        _assembly = assembly;
        _name = name;
    }

    #region IReadableFile Members

    public Stream OpenRead()
    {
        return _assembly.GetManifestResourceStream(_name);
    }

    #endregion
}

public class AssemblyRepository : IRepository
{
    readonly private Assembly _assembly;

    public AssemblyRepository(Assembly assembly)
    {
        _assembly = assembly;
    }

    #region IRepository Members

    public IEnumerable<IReadableFile> Search(string pattern)
    {
        return _assembly.GetManifestResourceNames().Where(name => name.Contains(pattern)).Select(name => new AssemblyFile(_assembly, name)).ToArray();
    }

    #endregion
}

公共类文件夹文件：IReadableFile
{
只读私有字符串\u名称；
公共文件夹文件（字符串名称）
{
_名称=名称；
}
#地区法定成员
公共流OpenRead（）
{
返回File.OpenRead（_name）；
}
#端区
}
公共类FolderRepository:IRepository
{
只读私有字符串_目录；
公共文件夹存储库（字符串目录）
{
_目录=目录；
}
#地区成员
公共IEnumerable搜索（字符串模式）
{
返回Array.ConvertAll（Directory.GetFiles（_Directory，pattern），name=>newfolderfile（name））；
}
#端区
}
公共类AssemblyFile:IReadableFile
{
只读专用程序集\u程序集；
只读私有字符串\u名称；
公共程序集文件（程序集，字符串名称）
{
_组装=组装；
_名称=名称；
}
#区域IReadableFile成员
公共流OpenRead（）
{
返回_assembly.GetManifestResourceStream（_名称）；
}
#端区
}
公共类AssemblyRepository:IRepository
{
只读专用程序集\u程序集；
公共程序集存储库（程序集）
{
_组装=组装；
}
#地区成员
公共IEnumerable搜索（字符串模式）
{
返回_assembly.GetManifestResourceNames（）.Where（name=>name.Contains（pattern））.Select（name=>newassemblyfile（_assembly，name））.ToArray（）；
}
#端区
}

---

然后，您可以只根据这些接口而不是它们的实现来编写算法。

Nelson，我理解您的代码。但它没有解决困难的部分：如何从传递字符串到拥有一个可以调用方法的汇编对象？如果程序集已经加载，如何避免在每次调用时加载该程序集？