Question

我在WCF中开发并在我的客户端代码中创建文件流，并将文件传输到服务（通过在消息中将其作为流发送）。服务到达后，他通过和平阅读它并将其写在新文件上;服务将文件从客户端下载到他，就是所有。

我覆盖了文件流中的方法，读取，所以我可以知道在服务器下载的时候，客户端有多少被处理。

public class FileStreamEx : FileStream
    {
        public long _ReadUntilNow { get; private set; }
        public FileStreamEx(string path, FileMode mode, FileAccess access, FileShare share)
            : base(path, mode, access, share)
        {
            this._ReadUntilNow = 0;
        }
        public override int Read(byte[] array, int offset, int count)
        {
            int ReturnV = base.Read(array, offset, count);
            _ReadUntilNow += ReturnV;
            return ReturnV;
        }
    }

我的目标是从客户端了解每秒服务所带来的数量。这可以通过简单地从客户端看到_ReadUntilNow值来实现，因为服务只使用对FileStreamEx对象的引用。

我的问题是服务甚至开始读取我给他的流，_ReadUntilNow值=文件的大小。只有这样才能实现这一目标，就是调用我的重写方法，Read，因为我这样做。

我的问题是谁给我打电话，为什么以及我该怎样做才能阻止它？

我的客户：

public static void CallService()
        {
            ServiceReference1.IJob Service1 = new ServiceReference1.JobClient(new InstanceContext(new CCBImplement()));
            DLL.FileStreamEx TheStream TheStream = new DLL.FileStreamEx(@"C:\Uploadfiles\Chat.rar", FileMode.Open, FileAccess.Read, FileShare.None);
            ServiceReference1.RemoteFile RemoteFile1=new ServiceReference1.RemoteFile("Chat.rar", TheStream.Length, @"C:\Uploadfiles\Chat.rar", TheStream);
            Service1.UselessMethod1(RemoteFile1);
            new Thread(new ThreadStart(Check_Only_ReadUntilNow_Every_Second)).Start();
        }

服务代码：

public void UselessMethod1(RemoteFile RemoteFile)
        {
            Stream MyStream = RemoteFile.FileByteStream;
            using (FileStream fs = new FileStream(@"C:\Upload\"+RemoteFile.FileName, FileMode.Create))
            {
                int bufferSize = 1 ; // 1 MB buffer
                byte[] buffer = new byte[bufferSize];
                int totalBytes = 0;
                int bytes = 0;
                while ((bytes = MyStream.Read(buffer, 0, bufferSize)) > 0)
                {
                    fs.Write(buffer, 0, bytes);
                    fs.Flush();
                    totalBytes += bytes;
                }
            }
        }

RemoteFile类：

[MessageContract]
    public class RemoteFile : IDisposable
    {
        [MessageHeader]
        public string FileName;

        [MessageHeader]
        public string Path;

        [MessageHeader]
        public long Length;

        [MessageBodyMember]
        public Stream FileByteStream;
        public RemoteFile() { }
        public RemoteFile(string FileName, string Path, long Length, Stream FileByteStream)
        {
            this.Path = Path;
            this.FileName = FileName;
            this.Length = Length;
            this.FileByteStream = FileByteStream;
        }
        public void Dispose()
        {
            if (FileByteStream != null)
            {
                FileByteStream.Close();
                FileByteStream = null;
            }
        }
    }

Answer 1

我认为他的问题是：在A侧，有一个服务主机，其方法是在流模式下读取文件。在B侧，有一个客户端使用此服务发送文件。

他扩展了FileStream calss以添加一个变量，该变量保存从文件中读取的字节数。

他在A方调用服务，但在它到达方法之前 - 额外变量保存整个文件的大小......这意味着整个文件被读取。

问题是为什么。

无法理解为什么FileStream将文件加载到内存中

1 个答案: