C#IStream实现IStream

首先，这不是重复的，因为我需要在另一个方向上实现。我需要创建一个从IO.Stream到IStream的IStream实现。但在我开始尝试这样做之前，我想问一下是否有人知道已经存在的实现或关于它的任何文章。我在.net框架中找不到任何东西，google只是给了我从IStream到IO.Stream的实现结果。有人给我小费吗？我真的不知道如何启动，因为第一个成员（Clone->创建一个新的stream对象，该对象引用与原始流相同的字节，但提供了一个指向这些字节的单独的seek指针）给我带来了麻烦。我不知道如何基于IO.Stream实现这一点。

最后，我自己完成了（请随意复制和修改）：

[ComImport]
[接口类型（ComInterfaceType.InterfaceSiunknown）]
[Guid（“0000000 C-0000-0000-C000-0000000000 46”）]
公共接口流
{
[信号]
HResult Read（[Marshallas（UnmanagedType.LPArray，SizeParamIndex=1）][Out]字节[]pv，int cb，IntPtr pcbRead）；
[信号]
HResult Write（[Marshallas（UnmanagedType.LPArray，SizeParamIndex=1）]字节[]pv，int cb，IntPtr PCBRITED）；
[信号]
HResult Seek（长dlibMove、int dwOrigin、IntPtr PLIBNEW位置）；
[信号]
HResult SetSize（长libNewSize）；
HResult CopyTo（IStream pstm、长cb、IntPtr pcbRead、IntPtr PCBREATED）；
[信号]
HResult提交（int grfCommitFlags）；
[信号]
HResult Revert（）；
[信号]
HResult LockRegion（长libOffset、长cb、int-dwLockType）；
[信号]
HResult UnlockRegion（长libOffset、长cb、int-dwLockType）；
[信号]
HResult Stat（out comtypes.STATSTG PSTATSG，int GRFSTATSFLAG）；
[信号]
HResult克隆（出IStream ppstm）；
}
/// 
///看http://msdn.microsoft.com/en-us/library/windows/desktop/ms752876（v=vs.85）.aspx
/// 
公共类ComStream:Stream、IStream
{
私有流(u流),；
公共通信流（流）
：此（流，真）
{
}
内部通信流（流、bool同步）
{
if（流==null）
抛出新的ArgumentNullException（“流”）；
如果（同步）
{
stream=stream.Synchronized（流）；
}
_溪流=溪流；
}
HResult IStream.Clone（输出IStream ppstm）
{
//ComStream newstream=新ComStream（_stream，false）；
//ppstm=新闻流；
ppstm=null；
返回HResult.E_NOTIMPL；
}
HResult IStream.Commit（int grfCommitFlags）
{
返回HResult.E_NOTIMPL；
}
HResult IStream.CopyTo（IStream pstm、长cb、IntPtr pcbRead、IntPtr PCBREATED）
{
返回HResult.E_NOTIMPL；
}
HResult IStream.LockRegion（长libOffset、长cb、int-dwLockType）
{
返回HResult.E_NOTIMPL；
}
HResult IStream.Read（字节[]pv、int cb、IntPtr pcbRead）
{
如果（！CanRead）
抛出新的InvalidOperationException（“流不可读”）；
int read=读取（pv，0，cb）；
如果（pcbRead！=IntPtr.Zero）
Marshal.WriteInt64（pcbRead，read）；
返回HResult.S_OK；
}
HResult IStream.Revert（）
{
返回HResult.E_NOTIMPL；
}
HResult IStream.Seek（长dlibMove、int-dwOrigin、IntPtr plibNewPosition）
{
SeekOrigin origin=（SeekOrigin）dwOrigin；//希望SeekOrigin枚举不会更改
长位置=寻道（dlibMove，原点）；
if（plibNewPosition！=IntPtr.Zero）
封送员写入64（plibNewPosition，pos）；
返回HResult.S_OK；
}
HResult IStream.SetSize（长libNewSize）
{
返回HResult.E_NOTIMPL；
}
HResult IStream.Stat（out comtypes.STATSTG pstatstg，int grfStatFlag）
{
pstatstg=新的comtypes.STATSTG（）；
pstatstg.cbSize=长度；
返回HResult.S_OK；
}
HResult IStream.UnlockRegion（长libOffset、长cb、int-dwLockType）
{
返回HResult.E_NOTIMPL；
}
HResult IStream.Write（字节[]pv、int cb、IntPtr PCBwrite）
{
如果（！CanWrite）
抛出新的InvalidOperationException（“流不可写”）；
写入（pv，0，cb）；
如果（pcbswrited！=null）
封送员书面材料32（书面材料，cb）；
返回HResult.S_OK；
}
公共覆盖布尔可读取
{
获取{return\u stream.CanRead；}
}
公共覆盖布尔搜索
{
获取{return\u stream.CanSeek；}
}
公共覆盖布尔可写
{
获取{return\u stream.CanWrite；}
}
公共覆盖无效刷新（）
{
_stream.Flush（）；
}
公共覆盖长长度
{
获取{return\u stream.Length；}
}
公众优先多头仓位
{
得到
{
返回流位置；
}
设置
{
_流。位置=值；
}
}
公共重写整型读取（字节[]缓冲区、整型偏移量、整型计数）
{
返回_stream.Read（缓冲区、偏移量、计数）；
}
公共覆盖长寻道（长偏移，参见原始坐标系）
{
返回_stream.Seek（偏移，原点）；
}
公共覆盖无效设置长度（长值）
{
_stream.SetLength（值）；
}
公共重写无效写入（字节[]缓冲区、整数偏移量、整数计数）
{
_写入（缓冲区、偏移量、计数）；
}
P
[ComImport]
[InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
[Guid("0000000c-0000-0000-C000-000000000046")]
public interface IStream
{
    [PreserveSig]
    HResult Read([MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 1)] [Out] byte[] pv, int cb, IntPtr pcbRead);

    [PreserveSig]
    HResult Write([MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 1)] byte[] pv, int cb, IntPtr pcbWritten);

    [PreserveSig]
    HResult Seek(long dlibMove, int dwOrigin, IntPtr plibNewPosition);

    [PreserveSig]
    HResult SetSize(long libNewSize);

    HResult CopyTo(IStream pstm, long cb, IntPtr pcbRead, IntPtr pcbWritten);

    [PreserveSig]
    HResult Commit(int grfCommitFlags);

    [PreserveSig]
    HResult Revert();

    [PreserveSig]
    HResult LockRegion(long libOffset, long cb, int dwLockType);

    [PreserveSig]
    HResult UnlockRegion(long libOffset, long cb, int dwLockType);

    [PreserveSig]
    HResult Stat(out comtypes.STATSTG pstatstg, int grfStatFlag);

    [PreserveSig]
    HResult Clone(out IStream ppstm);
}

    /// <summary>
    /// see http://msdn.microsoft.com/en-us/library/windows/desktop/ms752876(v=vs.85).aspx
    /// </summary>
    public class ComStream : Stream, IStream
    {
        private Stream _stream;

        public ComStream(Stream stream)
            : this(stream, true)
        {
        }

        internal ComStream(Stream stream, bool sync)
        {
            if (stream == null)
                throw new ArgumentNullException("stream");

            if (sync)
            {
                stream = Stream.Synchronized(stream);
            }
            _stream = stream;
        }

        HResult IStream.Clone(out IStream ppstm)
        {
            //ComStream newstream = new ComStream(_stream, false);
            //ppstm = newstream;
            ppstm = null;
            return HResult.E_NOTIMPL;
        }

        HResult IStream.Commit(int grfCommitFlags)
        {
            return HResult.E_NOTIMPL;
        }

        HResult IStream.CopyTo(IStream pstm, long cb, IntPtr pcbRead, IntPtr pcbWritten)
        {
            return HResult.E_NOTIMPL;
        }

        HResult IStream.LockRegion(long libOffset, long cb, int dwLockType)
        {
            return HResult.E_NOTIMPL;
        }

        HResult IStream.Read(byte[] pv, int cb, IntPtr pcbRead)
        {
            if (!CanRead)
                throw new InvalidOperationException("Stream not readable");

            int read = Read(pv, 0, cb);
            if (pcbRead != IntPtr.Zero)
                Marshal.WriteInt64(pcbRead, read);
            return HResult.S_OK;
        }

        HResult IStream.Revert()
        {
            return HResult.E_NOTIMPL;
        }

        HResult IStream.Seek(long dlibMove, int dwOrigin, IntPtr plibNewPosition)
        {
            SeekOrigin origin = (SeekOrigin)dwOrigin; //hope that the SeekOrigin enumeration won't change
            long pos = Seek(dlibMove, origin);
            if (plibNewPosition != IntPtr.Zero)
                Marshal.WriteInt64(plibNewPosition, pos);
            return HResult.S_OK;
        }

        HResult IStream.SetSize(long libNewSize)
        {
            return HResult.E_NOTIMPL;
        }

        HResult IStream.Stat(out comtypes.STATSTG pstatstg, int grfStatFlag)
        {
            pstatstg = new comtypes.STATSTG();
            pstatstg.cbSize = Length;
            return HResult.S_OK;
        }

        HResult IStream.UnlockRegion(long libOffset, long cb, int dwLockType)
        {
            return HResult.E_NOTIMPL;
        }

        HResult IStream.Write(byte[] pv, int cb, IntPtr pcbWritten)
        {
            if (!CanWrite)
                throw new InvalidOperationException("Stream is not writeable.");

            Write(pv, 0, cb);
            if (pcbWritten != null)
                Marshal.WriteInt32(pcbWritten, cb);
            return HResult.S_OK;
        }

        public override bool CanRead
        {
            get { return _stream.CanRead; }
        }

        public override bool CanSeek
        {
            get { return _stream.CanSeek; }
        }

        public override bool CanWrite
        {
            get { return _stream.CanWrite; }
        }

        public override void Flush()
        {
            _stream.Flush();
        }

        public override long Length
        {
            get { return _stream.Length; }
        }

        public override long Position
        {
            get
            {
                return _stream.Position;
            }
            set
            {
                _stream.Position = value;
            }
        }

        public override int Read(byte[] buffer, int offset, int count)
        {
            return _stream.Read(buffer, offset, count);
        }

        public override long Seek(long offset, SeekOrigin origin)
        {
            return _stream.Seek(offset, origin);
        }

        public override void SetLength(long value)
        {
            _stream.SetLength(value);
        }

        public override void Write(byte[] buffer, int offset, int count)
        {
            _stream.Write(buffer, offset, count);
        }

        protected override void Dispose(bool disposing)
        {
            if (_stream != null)
            {
                _stream.Dispose();
                _stream = null;
            }
        }
    }