C# IStream.Stat方法代码示例

        private static int GetStreamSize(IStream stream)
        {
            const int STATFLAG_NONAME = 1;

            STATSTG stats;
            stream.Stat(out stats, STATFLAG_NONAME);
            long result = stats.cbSize;
            if (result < 0 || result > int.MaxValue)
            {
                throw new BadImageFormatException();
            }

            return (int)result;
        }

		private static NativeMethods.Stgm GetAccessMode(IStream stream)
		{
			Debug.Assert(stream != null, "Expected stream.");

			try
			{
				// If IStream is created via CreateStreamOnHGlobal, stream.Stat() does not return the proper read/write state of the stream.
				// We bypass this by checking if it is created that way, and just return ReadWrite mode.
				IntPtr hStream;
				if (0 == NativeMethods.GetHGlobalFromStream(stream, out hStream) && hStream != IntPtr.Zero)
					return NativeMethods.Stgm.ReadWrite;

				// Get statistics from IStream.
				ComTypes.STATSTG stat;
				stream.Stat(out stat, (int)NativeMethods.STATFLAG.NoName);
				return (NativeMethods.Stgm)stat.grfMode;
			}
			catch (InvalidComObjectException ex)
			{
				throw new IOException(Resources.UnmanagedStream.IOException_StreamNotInitialized, ex);
			}
		}

 static bool PptStreamContainsEncryptedLabel(IStream pptStream)
 {
     var ptrReadBytes = Marshal.AllocHGlobal(sizeof(ulong));
     try
     {
         int CHUNK_SIZE = 512;
         var lastChunk = new byte[CHUNK_SIZE];
         System.Runtime.InteropServices.ComTypes.STATSTG stat;
         pptStream.Stat(out stat, STATFLAG_DEFAULT);
         if (stat.cbSize > CHUNK_SIZE)
         {
             pptStream.Seek(stat.cbSize - CHUNK_SIZE, STREAM_SEEK_START, IntPtr.Zero);
         }
         pptStream.Read(lastChunk, CHUNK_SIZE, ptrReadBytes);
         var contentAsText = Encoding.ASCII.GetString(lastChunk);
         return contentAsText.Contains(ENCODED_LABEL_AS_TEXT);
     }
     finally
     {
         Marshal.FreeHGlobal(ptrReadBytes);
     }
 }

        private static byte[] GetBufferFromIStream(IStream comStream)
        {
            LARGE_INTEGER zeroPos;
            zeroPos.QuadPart = 0;
            ULARGE_INTEGER[] streamPosition = new ULARGE_INTEGER[1];
            comStream.Seek(zeroPos, (uint)STREAM_SEEK.STREAM_SEEK_CUR, streamPosition);
            comStream.Seek(zeroPos, (uint)STREAM_SEEK.STREAM_SEEK_SET, null);

            Microsoft.VisualStudio.OLE.Interop.STATSTG[] stat = new Microsoft.VisualStudio.OLE.Interop.STATSTG[1];
            comStream.Stat(stat, (uint)STATFLAG.STATFLAG_NONAME);

            int bufferLength = (int)stat[0].cbSize.QuadPart;
            byte[] buffer = new byte[bufferLength];
            uint bytesRead = 0;
            comStream.Read(buffer, (uint)buffer.Length, out bytesRead);

            // return the stream to its previous location
            LARGE_INTEGER newPos;
            newPos.QuadPart = (long)streamPosition[0].QuadPart;
            comStream.Seek(newPos, (uint)STREAM_SEEK.STREAM_SEEK_SET, null);

            return buffer;
        }

 public WICReadOnlyStreamWrapper(IStream stream)
 {
     this.stream = stream;
     stream.Stat(out stat, 1);
 }

        protected virtual void ParserProperties(IStorage storage, IStream propertyHeaderStream, ref int readCount)
        {
            STATSTG stat;
            propertyHeaderStream.Stat(out stat, 1);
            int count = (int)stat.cbSize;

            while (readCount < count)
            {
                var tag = propertyHeaderStream.ReadInt32(ref readCount);
                var flag = propertyHeaderStream.ReadInt32(ref readCount);
                var value = propertyHeaderStream.ReadInt64(ref readCount);
                IPropValueForParser property = SpecialPropertyUtil.Instance.CreateNewPropValue(tag, value);

                property.Parse(Storage);
                Properties.AddProperty(property);
            }
        }