LogLogRecord.cs source code in C# .NET

                        
Code:
                         / 4.0 / 4.0 / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / cdf / src / WCF / Log / System / IO / Log / LogLogRecord.cs / 1305376 / LogLogRecord.cs
                        

                        
                            //------------------------------------------------------------------------------ 
// Copyright (c) Microsoft Corporation.  All rights reserved.
//-----------------------------------------------------------------------------
namespace System.IO.Log
{ 
    using System;
    using System.IO; 
    using System.Runtime.InteropServices; 

    class LogLogRecord : LogRecord 
    {
        RecordStream   stream;
        SequenceNumber sequenceNumber;
        SequenceNumber previous; 
        SequenceNumber user;
 
        unsafe internal LogLogRecord( 
            SequenceNumber sequenceNumber,
            SequenceNumber user, 
            SequenceNumber previous,
            byte *data,
            long length)
        { 
            this.sequenceNumber = sequenceNumber;
            this.previous = previous; 
            this.user = user; 

            if (length < LogLogRecordHeader.Size) 
            {
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(Error.LogCorrupt());
            }
 
            byte[] headerBits = new byte[LogLogRecordHeader.Size];
            Marshal.Copy(new IntPtr(data), 
                         headerBits, 
                         0,
                         LogLogRecordHeader.Size); 

            LogLogRecordHeader header = new LogLogRecordHeader(headerBits);
            if (header.MajorVersion > LogLogRecordHeader.CurrentMajorVersion)
            { 
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(Error.IncompatibleVersion());
            } 
 
            length -= LogLogRecordHeader.Size;
            data += LogLogRecordHeader.Size; 
            if (header.Padding)
            {
                long paddingSize = LogLogRecordHeader.DecodePaddingSize(data, length);
                if ((paddingSize < 0) || (paddingSize > length)) 
                {
                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(Error.LogCorrupt()); 
                } 

                length -= paddingSize; 
                data += paddingSize;
            }

            this.stream = new RecordStream( 
                new UnmanagedMemoryStream(data, length));
        } 
 
        public override Stream Data
        { 
            get
            {
                return this.stream;
            } 
        }
 
        public override SequenceNumber Previous 
        {
            get 
            {
                return this.previous;
            }
        } 

        public override SequenceNumber SequenceNumber 
        { 
            get
            { 
                return this.sequenceNumber;
            }
        }
 
        public override SequenceNumber User
        { 
            get 
            {
                return this.user; 
            }
        }

        public override void Dispose() 
        {
            this.stream.Dispose(); 
        } 

        internal void Detach() 
        {
            this.stream.MakeLocalCopy();
        }
 
        class RecordStream : Stream
        { 
            Stream innerStream; 
            object syncRoot;
 
            internal RecordStream(Stream innerStream)
            {
                this.innerStream = innerStream;
                this.syncRoot = new object(); 
            }
 
            public override bool CanRead  { get { return true; } } 
            public override bool CanSeek  { get { return true; } }
            public override bool CanWrite { get { return false; } } 

            public override long Length
            {
                get 
                {
                    lock(this.syncRoot) 
                    { 
                        CheckDisposed();
                        return this.innerStream.Length; 
                    }
                }
            }
 
            public override long Position
            { 
                get 
                {
                    lock(this.syncRoot) 
                    {
                        CheckDisposed();
                        return this.innerStream.Position;
                    } 
                }
 
                set 
                {
                    lock(this.syncRoot) 
                    {
                        CheckDisposed();
                        this.innerStream.Position = value;
                    } 
                }
            } 
 
            public override void Flush()
            { 
                lock(this.syncRoot)
                {
                    if(this.innerStream != null)
                    { 
                        this.innerStream.Flush();
                    } 
                } 
            }
 
            public override int Read(byte[] buffer, int offset, int count)
            {
                lock(this.syncRoot)
                { 
                    CheckDisposed();
                    return this.innerStream.Read(buffer, offset, count); 
                } 
            }
 
            public override long Seek(long offset, SeekOrigin origin)
            {
                lock(this.syncRoot)
                { 
                    CheckDisposed();
                    return this.innerStream.Seek(offset, origin); 
                } 
            }
 
            public override void SetLength(long value)
            {
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(Error.NotSupported());
            } 

            public override void Write(byte[] buffer, int offset, int count) 
            { 
                if (this.innerStream == null)
                { 
                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(Error.ObjectDisposed());
                }
                else
                { 
                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(Error.NotSupported());
                } 
            } 

            public override void WriteByte(byte value) 
            {
                if (this.innerStream == null)
                {
                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(Error.ObjectDisposed()); 
                }
                else 
                { 
                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(Error.NotSupported());
                } 
            }

            internal void MakeLocalCopy()
            { 
                lock(this.syncRoot)
                { 
                    if (this.innerStream != null) 
                    {
                        long originalPosition = this.innerStream.Position; 
                        try
                        {
                            try
                            { 
                                byte[] newData = new byte[this.innerStream.Length];
                                this.innerStream.Position = 0; 
                                this.innerStream.Read(newData, 0, newData.Length); 

                                Stream oldStream = this.innerStream; 
                                this.innerStream = new MemoryStream(newData);
                                oldStream.Close();
                            }
                            finally 
                            {
                                this.innerStream.Position = originalPosition; 
                            } 
                        }
                        catch 
                        {
                            // This outer catch block is needed to prevent an exception filter
                            // from running while we're in an inconsistent state before
                            // restoring the inner stream's original position. 
                            // See http://msdn2.microsoft.com/en-US/library/8cd7yaws.aspx
                            throw; 
                        } 
                    }
                } 
            }

            protected override void Dispose(bool disposing)
            { 
                try
                { 
                    if (disposing) 
                    {
                        lock (this.syncRoot) 
                        {
                            if (this.innerStream != null)
                            {
                                this.innerStream.Close(); 
                                this.innerStream = null;
                            } 
                        } 
                    }
                } 
                finally
                {
                    base.Dispose(disposing);
                } 
            }
 
            void CheckDisposed() 
            {
                if (this.innerStream == null) 
                {
                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(Error.ObjectDisposed());
                }
            } 
        }
    } 
} 

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
//------------------------------------------------------------------------------ 
// Copyright (c) Microsoft Corporation.  All rights reserved.
//-----------------------------------------------------------------------------
namespace System.IO.Log
{ 
    using System;
    using System.IO; 
    using System.Runtime.InteropServices; 

    class LogLogRecord : LogRecord 
    {
        RecordStream   stream;
        SequenceNumber sequenceNumber;
        SequenceNumber previous; 
        SequenceNumber user;
 
        unsafe internal LogLogRecord( 
            SequenceNumber sequenceNumber,
            SequenceNumber user, 
            SequenceNumber previous,
            byte *data,
            long length)
        { 
            this.sequenceNumber = sequenceNumber;
            this.previous = previous; 
            this.user = user; 

            if (length < LogLogRecordHeader.Size) 
            {
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(Error.LogCorrupt());
            }
 
            byte[] headerBits = new byte[LogLogRecordHeader.Size];
            Marshal.Copy(new IntPtr(data), 
                         headerBits, 
                         0,
                         LogLogRecordHeader.Size); 

            LogLogRecordHeader header = new LogLogRecordHeader(headerBits);
            if (header.MajorVersion > LogLogRecordHeader.CurrentMajorVersion)
            { 
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(Error.IncompatibleVersion());
            } 
 
            length -= LogLogRecordHeader.Size;
            data += LogLogRecordHeader.Size; 
            if (header.Padding)
            {
                long paddingSize = LogLogRecordHeader.DecodePaddingSize(data, length);
                if ((paddingSize < 0) || (paddingSize > length)) 
                {
                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(Error.LogCorrupt()); 
                } 

                length -= paddingSize; 
                data += paddingSize;
            }

            this.stream = new RecordStream( 
                new UnmanagedMemoryStream(data, length));
        } 
 
        public override Stream Data
        { 
            get
            {
                return this.stream;
            } 
        }
 
        public override SequenceNumber Previous 
        {
            get 
            {
                return this.previous;
            }
        } 

        public override SequenceNumber SequenceNumber 
        { 
            get
            { 
                return this.sequenceNumber;
            }
        }
 
        public override SequenceNumber User
        { 
            get 
            {
                return this.user; 
            }
        }

        public override void Dispose() 
        {
            this.stream.Dispose(); 
        } 

        internal void Detach() 
        {
            this.stream.MakeLocalCopy();
        }
 
        class RecordStream : Stream
        { 
            Stream innerStream; 
            object syncRoot;
 
            internal RecordStream(Stream innerStream)
            {
                this.innerStream = innerStream;
                this.syncRoot = new object(); 
            }
 
            public override bool CanRead  { get { return true; } } 
            public override bool CanSeek  { get { return true; } }
            public override bool CanWrite { get { return false; } } 

            public override long Length
            {
                get 
                {
                    lock(this.syncRoot) 
                    { 
                        CheckDisposed();
                        return this.innerStream.Length; 
                    }
                }
            }
 
            public override long Position
            { 
                get 
                {
                    lock(this.syncRoot) 
                    {
                        CheckDisposed();
                        return this.innerStream.Position;
                    } 
                }
 
                set 
                {
                    lock(this.syncRoot) 
                    {
                        CheckDisposed();
                        this.innerStream.Position = value;
                    } 
                }
            } 
 
            public override void Flush()
            { 
                lock(this.syncRoot)
                {
                    if(this.innerStream != null)
                    { 
                        this.innerStream.Flush();
                    } 
                } 
            }
 
            public override int Read(byte[] buffer, int offset, int count)
            {
                lock(this.syncRoot)
                { 
                    CheckDisposed();
                    return this.innerStream.Read(buffer, offset, count); 
                } 
            }
 
            public override long Seek(long offset, SeekOrigin origin)
            {
                lock(this.syncRoot)
                { 
                    CheckDisposed();
                    return this.innerStream.Seek(offset, origin); 
                } 
            }
 
            public override void SetLength(long value)
            {
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(Error.NotSupported());
            } 

            public override void Write(byte[] buffer, int offset, int count) 
            { 
                if (this.innerStream == null)
                { 
                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(Error.ObjectDisposed());
                }
                else
                { 
                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(Error.NotSupported());
                } 
            } 

            public override void WriteByte(byte value) 
            {
                if (this.innerStream == null)
                {
                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(Error.ObjectDisposed()); 
                }
                else 
                { 
                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(Error.NotSupported());
                } 
            }

            internal void MakeLocalCopy()
            { 
                lock(this.syncRoot)
                { 
                    if (this.innerStream != null) 
                    {
                        long originalPosition = this.innerStream.Position; 
                        try
                        {
                            try
                            { 
                                byte[] newData = new byte[this.innerStream.Length];
                                this.innerStream.Position = 0; 
                                this.innerStream.Read(newData, 0, newData.Length); 

                                Stream oldStream = this.innerStream; 
                                this.innerStream = new MemoryStream(newData);
                                oldStream.Close();
                            }
                            finally 
                            {
                                this.innerStream.Position = originalPosition; 
                            } 
                        }
                        catch 
                        {
                            // This outer catch block is needed to prevent an exception filter
                            // from running while we're in an inconsistent state before
                            // restoring the inner stream's original position. 
                            // See http://msdn2.microsoft.com/en-US/library/8cd7yaws.aspx
                            throw; 
                        } 
                    }
                } 
            }

            protected override void Dispose(bool disposing)
            { 
                try
                { 
                    if (disposing) 
                    {
                        lock (this.syncRoot) 
                        {
                            if (this.innerStream != null)
                            {
                                this.innerStream.Close(); 
                                this.innerStream = null;
                            } 
                        } 
                    }
                } 
                finally
                {
                    base.Dispose(disposing);
                } 
            }
 
            void CheckDisposed() 
            {
                if (this.innerStream == null) 
                {
                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(Error.ObjectDisposed());
                }
            } 
        }
    } 
} 

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
                        

                        

                        
                        

Link Menu

This book is available now!
Buy at Amazon US or
Buy at Amazon UK

• PropertyChange.cs
• ChannelServices.cs
• IISMapPath.cs
• ByteStream.cs
• TextEditorDragDrop.cs
• DataGridViewSortCompareEventArgs.cs
• LineInfo.cs
• SqlRetyper.cs
• DataError.cs
• SelectionUIHandler.cs
• CodeRemoveEventStatement.cs
• FormCollection.cs
• StorageScalarPropertyMapping.cs
• XmlDownloadManager.cs
• TextEvent.cs
• selecteditemcollection.cs
• SessionEndedEventArgs.cs
• HexParser.cs
• DaylightTime.cs
• TypeConverterHelper.cs
• MeshGeometry3D.cs
• RevocationPoint.cs
• HtmlWindowCollection.cs
• WebException.cs
• DataMemberAttribute.cs
• ValueTypeFixupInfo.cs
• TreePrinter.cs
• QueryContinueDragEventArgs.cs
• SqlCachedBuffer.cs
• PKCS1MaskGenerationMethod.cs
• HttpProfileGroupBase.cs
• KnownTypeHelper.cs
• HttpListenerResponse.cs
• PackageDigitalSignature.cs
• XmlSchemaFacet.cs
• RoleManagerEventArgs.cs
• ApplicationInfo.cs
• LocationSectionRecord.cs
• QueryableDataSourceHelper.cs
• Point4D.cs
• DesignerCommandSet.cs
• ModelTypeConverter.cs
• TypeSource.cs
• MediaContextNotificationWindow.cs
• SynchronizationContext.cs
• SocketPermission.cs
• ToolBar.cs
• COM2ExtendedTypeConverter.cs
• TypeExtensions.cs
• SqlServer2KCompatibilityAnnotation.cs
• XmlElement.cs
• MimeMultiPart.cs
• TheQuery.cs
• ModuleElement.cs
• Vertex.cs
• ExceptionUtil.cs
• InternalSafeNativeMethods.cs
• DataRowCollection.cs
• GeneralTransform.cs
• HwndSourceParameters.cs
• Messages.cs
• DbConnectionPoolCounters.cs
• ComMethodElement.cs
• ZipIOLocalFileHeader.cs
• ContentDisposition.cs
• StreamMarshaler.cs
• SiteMapNodeItem.cs
• ServiceHttpModule.cs
• RowToParametersTransformer.cs
• ObjectConverter.cs
• OpCodes.cs
• StrongNamePublicKeyBlob.cs
• TextSelectionProcessor.cs
• SessionEndingEventArgs.cs
• EventData.cs
• HttpStaticObjectsCollectionBase.cs
• CustomSignedXml.cs
• ModuleBuilderData.cs
• FileSecurity.cs
• newitemfactory.cs
• SqlClientWrapperSmiStream.cs
• Fonts.cs
• SignalGate.cs
• ButtonChrome.cs
• NativeActivityAbortContext.cs
• DropDownList.cs
• CodeAccessPermission.cs
• TcpClientSocketManager.cs
• SqlCachedBuffer.cs
• QilPatternFactory.cs
• FileLoadException.cs
• SqlDelegatedTransaction.cs
• Point3DIndependentAnimationStorage.cs
• RegexWorker.cs
• HttpCookiesSection.cs
• ObjectDataSourceMethodEventArgs.cs
• IdentityElement.cs
• HotSpot.cs
• CodeCompiler.cs
• SystemPens.cs