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

• XmlSerializerAssemblyAttribute.cs
• DummyDataSource.cs
• QueryPageSettingsEventArgs.cs
• SQLUtility.cs
• baseaxisquery.cs
• XmlDataSource.cs
• StreamResourceInfo.cs
• DragEvent.cs
• ProfileInfo.cs
• LinqExpressionNormalizer.cs
• ListViewEditEventArgs.cs
• DataGridViewAutoSizeColumnModeEventArgs.cs
• Guid.cs
• HostingEnvironment.cs
• ExtenderControl.cs
• ButtonStandardAdapter.cs
• TemplateField.cs
• InheritanceRules.cs
• PersonalizationStateInfoCollection.cs
• InheritanceRules.cs
• LinqDataSourceContextData.cs
• CharConverter.cs
• ValueChangedEventManager.cs
• EncryptedData.cs
• ObjectDataSourceMethodEditor.cs
• DesignerCommandSet.cs
• MouseEventArgs.cs
• InheritanceContextHelper.cs
• TableAdapterManagerMethodGenerator.cs
• DesignerActionPropertyItem.cs
• InfoCardHelper.cs
• RoleService.cs
• AnimatedTypeHelpers.cs
• SiteMembershipCondition.cs
• WindowClosedEventArgs.cs
• GZipStream.cs
• SafeLibraryHandle.cs
• UIPermission.cs
• MenuCommandService.cs
• Types.cs
• XmlSchemaAny.cs
• graph.cs
• XmlAtomicValue.cs
• WebPartTransformerAttribute.cs
• RepeatButtonAutomationPeer.cs
• ActivityDesignerResources.cs
• ConsoleTraceListener.cs
• SessionPageStateSection.cs
• WindowsListViewItemStartMenu.cs
• TrustLevelCollection.cs
• DiscardableAttribute.cs
• ObjectListFieldsPage.cs
• ComplexBindingPropertiesAttribute.cs
• CompositeFontParser.cs
• FtpCachePolicyElement.cs
• TypeDescriptionProviderAttribute.cs
• DbConnectionStringCommon.cs
• ValidatorCollection.cs
• Regex.cs
• FileDialogCustomPlace.cs
• DataGridViewRowDividerDoubleClickEventArgs.cs
• DocumentOrderQuery.cs
• ExpandCollapseProviderWrapper.cs
• ConstraintCollection.cs
• RectangleConverter.cs
• WebPartUtil.cs
• formatstringdialog.cs
• ListViewItem.cs
• GridItemPattern.cs
• DesigntimeLicenseContextSerializer.cs
• ITreeGenerator.cs
• AnnotationHighlightLayer.cs
• Action.cs
• Gdiplus.cs
• AuthenticationModuleElement.cs
• UnSafeCharBuffer.cs
• XmlQueryRuntime.cs
• XamlClipboardData.cs
• LicenseManager.cs
• ItemCollection.cs
• HorizontalAlignConverter.cs
• SqlNotificationEventArgs.cs
• GroupByQueryOperator.cs
• UntrustedRecipientException.cs
• CaseKeyBox.ViewModel.cs
• ExpressionEditorAttribute.cs
• SqlRecordBuffer.cs
• DecimalAnimation.cs
• AppDomainManager.cs
• UnsafeNativeMethodsPenimc.cs
• VirtualizedItemProviderWrapper.cs
• AddInIpcChannel.cs
• OrderedDictionary.cs
• BinaryWriter.cs
• BroadcastEventHelper.cs
• datacache.cs
• RuleSetBrowserDialog.cs
• KeySplineConverter.cs
• WinInet.cs
• InvokeMethodActivityDesigner.cs