如何将解决方案资源作为 FileStream 对象传递（到拦截的 File.Open 命令）？

Question

我扩展了一个访问硬盘上文件的旧库。我的单元测试项目中有嵌入资源等文件。

我已经移植了库的部分内容以接受流，这允许我使用 GetManifestResourceStream 将嵌入的资源传递到旧库。这工作得很好，但有点麻烦。维护这些库的人不喜欢这种“混乱”或必须发布新版本。

JustMock 和 TypeMock 允许我拦截 File.Open 命令，并且我希望向库传递 FileStream 对象，但如何从嵌入式清单资源构造 FileStream 对象？ 我当然可以创建一个物理文件，但我不希望在运行测试时触及文件系统。

Answer 1

我根据你在这里提到的要求做了一个样品。我在内存流中使用它，但也可以使用嵌入式资源来完成。

           byte[] actual = new byte[255];

        // writing locally, can be done from resource manifest as well.

        using (StreamWriter writer = new StreamWriter(new MemoryStream(actual)))
        {
            writer.WriteLine("Hello world");
            writer.Flush();
        }

        // arrange the file system.

        FileStream fs = (FileStream)FormatterServices
            .GetSafeUninitializedObject(typeof(FileStream));

        // mocking the specific call and setting up expectations.
        Mock.Arrange(() => fs.Write(Arg.IsAny<byte[]>(), Arg.AnyInt, Arg.AnyInt))
            .DoInstead((byte[] content, int offset, int len) =>
        {
            actual.CopyTo(content, offset);
        });

        // return custom filestream for File.Open.
        Mock.Arrange(() => File.Open(Arg.AnyString, Arg.IsAny<FileMode>()))
             .Returns(fs);


        // act
        var fileStream =  File.Open("hello.txt", FileMode.Open);
        byte[] fakeContent = new byte[actual.Length];

        // original task
        fileStream.Write(fakeContent, 0, actual.Length);

        // assert
        Assert.Equal(fakeContent.Length, actual.Length);

        for (var i = 0; i < fakeContent.Length; i++)
        {
            Assert.Equal(fakeContent[i], actual[i]);
        }

由于我正在调用 mscorlib 成员，并且 FileStream.Write 是一个实例调用/不包含在默认设置文件、日期时间、文件信息中。我还在 TestInitailization 期间添加了以下行。

           Mock.Partial<FileStream>()
              .For<byte[], int, int>((x, content, offset, len) => 
            x.Write(content, offset, len));

[我为 Telerik 工作的免责声明]

希望有帮助，

Mehfuz

Answer 2

您可以阅读以下文章“从程序集中读取嵌入式文件”和"C#: Use Embedded Resource" 演示了如何实现这个目标。

Answer 3

您可以创建一个从 FileStream 派生的新类，可能称为 FauxFileStream 或其他名称，并重写其中所有必要的与 Stream 相关的方法改为不同的流。然后，您可以轻松实例化一个新的 FauxFileStream(myManifestResourceStream) 并将其传递给库。

该类看起来像这样：

class FauxFileStream : FileStream
{
    private Stream _underlying;

    public FauxFileStream(Stream underlying)
    {
        _underlying = underlying;
    }

    public override bool CanRead { get { return _underlying.CanRead; } }
    public override bool CanSeek { get { return _underlying.CanSeek; } }
    public override bool CanTimeout { get { return _underlying.CanTimeout; } }
    public override bool CanWrite { get { return _underlying.CanWrite; } }
    public override long Length { get { return _underlying.Length; } }
    public override long Position { get { return _underlying.Position; } set { _underlying.Position = value; } }
    public override int ReadTimeout { get { return _underlying.ReadTimeout; } set { _underlying.ReadTimeout = value; } }
    public override int WriteTimeout { get { return _underlying.WriteTimeout; } set { _underlying.WriteTimeout = value; } }
    public override void Close() { _underlying.Close(); }
    public override void Flush() { _underlying.Flush(); }
    public override int Read(byte[] buffer, int offset, int count) { return _underlying.Read(buffer, offset, count); }
    public override int ReadByte() { return _underlying.ReadByte(); }
    public override long Seek(long offset, SeekOrigin origin) { return _underlying.Seek(offset, origin); }
    public override void SetLength(long value) { _underlying.SetLength(value); }
    public override void Write(byte[] buffer, int offset, int count) { _underlying.Write(buffer, offset, count); }
    public override void WriteByte(byte value) { _underlying.WriteByte(value); }
}

但是，目前它无法编译，因为您需要使用一些合理的参数调用 FileStream 的基本构造函数。我能想到的最好的方法是传递一些打开某些文件进行读取的东西（这将是无害的，因为该文件实际上不会被读取，因为所有方法都被覆盖）。您可以为此目的创建一个 0 字节文件，并且如果将 FileShare.Read 作为共享参数传递，则可以安全地打开同一文件以同时读取。