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

• versioninfo.cs
• TaiwanLunisolarCalendar.cs
• TemplateEditingService.cs
• TreeViewItemAutomationPeer.cs
• VisualStyleElement.cs
• HandleExceptionArgs.cs
• UserMapPath.cs
• MemberHolder.cs
• ImageListImage.cs
• ButtonStandardAdapter.cs
• MessageLoggingFilterTraceRecord.cs
• TaiwanCalendar.cs
• SmtpException.cs
• DesignerDataSourceView.cs
• MessagingActivityHelper.cs
• ZipIOLocalFileHeader.cs
• ListBoxItemAutomationPeer.cs
• MsmqPoisonMessageException.cs
• ClientWindowsAuthenticationMembershipProvider.cs
• PixelFormats.cs
• ExpressionLink.cs
• AsymmetricKeyExchangeFormatter.cs
• TrustManager.cs
• MaskedTextProvider.cs
• ResXResourceWriter.cs
• ParserOptions.cs
• WindowsHyperlink.cs
• AccessControlList.cs
• Container.cs
• ContextMenuAutomationPeer.cs
• EntityContainerEmitter.cs
• LayoutEvent.cs
• TextTreeFixupNode.cs
• RemotingSurrogateSelector.cs
• SystemWebCachingSectionGroup.cs
• Shape.cs
• InvalidateEvent.cs
• LeafCellTreeNode.cs
• PenThreadPool.cs
• RichTextBox.cs
• FixedLineResult.cs
• TagNameToTypeMapper.cs
• NestedContainer.cs
• LogicalExpressionTypeConverter.cs
• MaskDesignerDialog.cs
• UpWmlPageAdapter.cs
• ExpressionConverter.cs
• XPathArrayIterator.cs
• CodeVariableDeclarationStatement.cs
• ClientTargetCollection.cs
• TreeChangeInfo.cs
• Cursor.cs
• ProcessThread.cs
• LambdaSerializationException.cs
• ErrorProvider.cs
• XmlILIndex.cs
• XmlTextReaderImpl.cs
• Dispatcher.cs
• ILGenerator.cs
• AppDomainManager.cs
• XmlAttribute.cs
• UdpAnnouncementEndpoint.cs
• HttpCachePolicy.cs
• TrackingDataItemValue.cs
• TextEvent.cs
• Process.cs
• BamlReader.cs
• ISO2022Encoding.cs
• ThreadExceptionDialog.cs
• SystemMulticastIPAddressInformation.cs
• DocumentReferenceCollection.cs
• WarningException.cs
• PropertyMap.cs
• CharacterShapingProperties.cs
• DeferredReference.cs
• SafeProcessHandle.cs
• DisposableCollectionWrapper.cs
• QueryLifecycle.cs
• RightsManagementPermission.cs
• WCFModelStrings.Designer.cs
• SiteMapPath.cs
• DragDrop.cs
• AuthenticationModuleElementCollection.cs
• FixedDocumentPaginator.cs
• SchemaManager.cs
• WindowsRegion.cs
• DisplayClaim.cs
• SqlNode.cs
• UIntPtr.cs
• VisualBasicValue.cs
• TypeBuilder.cs
• StorageAssociationTypeMapping.cs
• UserControl.cs
• DataGridViewSelectedRowCollection.cs
• Currency.cs
• XmlSchemaInfo.cs
• BindingGroup.cs
• SafeRightsManagementPubHandle.cs
• XsdValidatingReader.cs
• Hyperlink.cs