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

• TextTreeTextElementNode.cs
• ScalarOps.cs
• Literal.cs
• ContextStaticAttribute.cs
• PropertyConverter.cs
• DeviceContexts.cs
• GreenMethods.cs
• DomNameTable.cs
• PerfService.cs
• ToolStripDropDownClosedEventArgs.cs
• DataGridItem.cs
• Classification.cs
• Quaternion.cs
• PersistenceProviderBehavior.cs
• MultipartContentParser.cs
• SqlError.cs
• XamlWrappingReader.cs
• ParameterBuilder.cs
• RoleManagerSection.cs
• PublisherIdentityPermission.cs
• ListSourceHelper.cs
• WebEvents.cs
• ParameterBuilder.cs
• TabPanel.cs
• MenuItemBinding.cs
• Fonts.cs
• XmlSerializer.cs
• ReverseQueryOperator.cs
• X509Extension.cs
• XmlSerializer.cs
• ConstructorBuilder.cs
• WriterOutput.cs
• LinkArea.cs
• GeneralTransform3DTo2DTo3D.cs
• control.ime.cs
• ServiceModelSectionGroup.cs
• MultitargetingHelpers.cs
• BrowserCapabilitiesFactory.cs
• TransactionContextManager.cs
• HttpServerUtilityWrapper.cs
• SchemaNotation.cs
• DbTransaction.cs
• TraceEventCache.cs
• XamlReaderHelper.cs
• ExceptionValidationRule.cs
• __Filters.cs
• URLMembershipCondition.cs
• DataSourceXmlSubItemAttribute.cs
• HashAlgorithm.cs
• TTSEngineTypes.cs
• SoapCodeExporter.cs
• Button.cs
• ByeOperationCD1AsyncResult.cs
• Visitors.cs
• PackageRelationshipSelector.cs
• DataObjectMethodAttribute.cs
• DbTypeMap.cs
• PatternMatcher.cs
• Privilege.cs
• ReadOnlyNameValueCollection.cs
• XslCompiledTransform.cs
• QueryableDataSourceEditData.cs
• AuthenticationService.cs
• DocumentEventArgs.cs
• TypeForwardedFromAttribute.cs
• ClientSettingsProvider.cs
• NetworkInterface.cs
• KeyBinding.cs
• NullableLongAverageAggregationOperator.cs
• DataGridView.cs
• CroppedBitmap.cs
• SqlConnection.cs
• HwndSourceParameters.cs
• RenderDataDrawingContext.cs
• DebugTrace.cs
• ToolStripSplitStackLayout.cs
• ProtocolsConfigurationHandler.cs
• StateBag.cs
• Rectangle.cs
• ForeignKeyConstraint.cs
• NavigateUrlConverter.cs
• SourceElementsCollection.cs
• ApplicationServiceManager.cs
• BamlTreeNode.cs
• DoubleAnimation.cs
• UpdatePanelTriggerCollection.cs
• WindowsImpersonationContext.cs
• SerialStream.cs
• GAC.cs
• ResXFileRef.cs
• PanelStyle.cs
• EdmError.cs
• PointHitTestParameters.cs
• SortQuery.cs
• WeakReferenceKey.cs
• DBParameter.cs
• DataGridViewHeaderCell.cs
• StatusStrip.cs
• DecimalConverter.cs
• DataSourceHelper.cs