Code:
/ WCF / WCF / 3.5.30729.1 / untmp / Orcas / SP / ndp / cdf / src / WCF / ServiceModel / System / ServiceModel / Channels / MsmqQueue.cs / 1 / MsmqQueue.cs
//------------------------------------------------------------ // Copyright (c) Microsoft Corporation. All rights reserved. //----------------------------------------------------------- namespace System.ServiceModel.Channels { using System.Globalization; using System.IO; using System.Text; using System.Net.Security; using System.Transactions; using System.Threading; using System.IdentityModel.Claims; using System.IdentityModel.Policy; using System.ServiceModel.Security.Tokens; using System.ServiceModel; using System.ServiceModel.Diagnostics; using System.ServiceModel.Security; using System.Runtime.Serialization; using System.Xml; using System.Runtime.InteropServices; enum MsmqTransactionMode { None, // do not use a transaction Single, // create a single message transaction CurrentOrSingle, // use Transaction.Current if set, Single otherwise CurrentOrNone, // use Transaction.Current if set, None otherwise CurrentOrThrow, // use Transaction.Current if set, throw otherwise } class MsmqQueue : IDisposable { MsmqQueueHandle handle; string formatName; int accessMode; bool isBoundToCompletionPort; bool isAsyncEnabled; public MsmqQueue(string formatName, int accessMode) { this.formatName = formatName; this.accessMode = accessMode; } object ThisLock { get { return this; } } public string FormatName { get { return this.formatName; } } public override string ToString() { return this.formatName; } public void Dispose() { lock (this.ThisLock) { CloseQueue(); } } internal void EnsureOpen() { GetHandle(); } MsmqQueueHandle GetHandleForAsync(out bool useCompletionPort) { lock (this.ThisLock) { if (this.handle == null) { this.handle = OpenQueue(); } if (!this.isAsyncEnabled) { if (IsCompletionPortSupported(this.handle)) { ThreadPool.BindHandle(this.handle); this.isBoundToCompletionPort = true; } this.isAsyncEnabled = true; } useCompletionPort = this.isBoundToCompletionPort; return this.handle; } } MsmqQueueHandle GetHandle() { lock (this.ThisLock) { if (this.handle == null) { this.handle = OpenQueue(); } return this.handle; } } static bool IsCompletionPortSupported(MsmqQueueHandle handle) { // if it's a kernel handle, then it supports completion ports int flags; #pragma warning suppress 56523 return UnsafeNativeMethods.GetHandleInformation(handle, out flags) != 0; } internal MsmqQueueHandle OpenQueue() { MsmqQueueHandle handle; int error = UnsafeNativeMethods.MQOpenQueue(this.formatName, this.accessMode, UnsafeNativeMethods.MQ_DENY_NONE, out handle); if (error != 0) { Utility.CloseInvalidOutSafeHandle(handle); throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MsmqException(SR.GetString(SR.MsmqOpenError, MsmqError.GetErrorString(error)), error)); } MsmqDiagnostics.QueueOpened(this.formatName); return handle; } void CloseQueue() { if (this.handle != null) { CloseQueue(this.handle); this.handle = null; this.isBoundToCompletionPort = false; this.isAsyncEnabled = false; MsmqDiagnostics.QueueClosed(this.formatName); } } void CloseQueue(MsmqQueueHandle handle) { handle.Dispose(); } void HandleIsStale(MsmqQueueHandle handle) { lock (this.ThisLock) { if (this.handle == handle) { CloseQueue(); } } } public static void GetMsmqInformation(ref Version version, ref bool activeDirectoryEnabled) { PrivateComputerProperties properties = new PrivateComputerProperties(); using (properties) { IntPtr nativePropertiesPointer = properties.Pin(); try { int error = UnsafeNativeMethods.MQGetPrivateComputerInformation(null, nativePropertiesPointer); if (error != 0) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MsmqException(SR.GetString( SR.MsmqGetPrivateComputerInformationError, MsmqError.GetErrorString(error)), error)); } int packedVersion = properties.Version.Value; version = new Version( packedVersion >> 24, (packedVersion & 0x00FF0000) >> 16, packedVersion & 0xFFFF); activeDirectoryEnabled = properties.ActiveDirectory.Value; } finally { properties.Unpin(); } } } public static bool IsReadable(string formatName, out MsmqException ex) { return SupportsAccessMode(formatName, UnsafeNativeMethods.MQ_RECEIVE_ACCESS, out ex); } public static bool IsWriteable(string formatName) { MsmqException ex; return SupportsAccessMode(formatName, UnsafeNativeMethods.MQ_SEND_ACCESS, out ex); } public static bool IsMoveable(string formatName) { MsmqException ex; return SupportsAccessMode(formatName, UnsafeNativeMethods.MQ_MOVE_ACCESS, out ex); } static bool SupportsAccessMode(string formatName, int accessType, out MsmqException msmqException) { msmqException = null; try { using (MsmqQueue msmqQueue = new MsmqQueue(formatName, accessType)) { msmqQueue.GetHandle(); } } catch (Exception ex) { msmqException = ex as MsmqException; if (null != msmqException) { return false; } throw; } return true; } public static bool TryGetIsTransactional(string formatName, out bool isTransactional) { using (QueueTransactionProperties properties = new QueueTransactionProperties()) { IntPtr nativePropertiesPointer = properties.Pin(); try { if (UnsafeNativeMethods.MQGetQueueProperties(formatName, nativePropertiesPointer) == 0) { isTransactional = properties.Transaction.Value != UnsafeNativeMethods.MQ_TRANSACTIONAL_NONE; return true; } else { isTransactional = false; MsmqDiagnostics.QueueTransactionalStatusUnknown(formatName); return false; } } finally { properties.Unpin(); } } } static bool IsErrorDueToStaleHandle(int error) { switch (error) { case UnsafeNativeMethods.MQ_ERROR_STALE_HANDLE: case UnsafeNativeMethods.MQ_ERROR_INVALID_HANDLE: case UnsafeNativeMethods.MQ_ERROR_INVALID_PARAMETER: case UnsafeNativeMethods.MQ_ERROR_QUEUE_DELETED: return true; default: return false; } } static bool IsReceiveErrorDueToInsufficientBuffer(int error) { switch (error) { case UnsafeNativeMethods.MQ_ERROR_BUFFER_OVERFLOW: case UnsafeNativeMethods.MQ_INFORMATION_FORMATNAME_BUFFER_TOO_SMALL: case UnsafeNativeMethods.MQ_ERROR_FORMATNAME_BUFFER_TOO_SMALL: case UnsafeNativeMethods.MQ_ERROR_SENDERID_BUFFER_TOO_SMALL: case UnsafeNativeMethods.MQ_ERROR_SECURITY_DESCRIPTOR_TOO_SMALL: case UnsafeNativeMethods.MQ_ERROR_USER_BUFFER_TOO_SMALL: case UnsafeNativeMethods.MQ_ERROR_SENDER_CERT_BUFFER_TOO_SMALL: case UnsafeNativeMethods.MQ_ERROR_RESULT_BUFFER_TOO_SMALL: case UnsafeNativeMethods.MQ_ERROR_LABEL_BUFFER_TOO_SMALL: case UnsafeNativeMethods.MQ_ERROR_SYMM_KEY_BUFFER_TOO_SMALL: case UnsafeNativeMethods.MQ_ERROR_SIGNATURE_BUFFER_TOO_SMALL: case UnsafeNativeMethods.MQ_ERROR_PROV_NAME_BUFFER_TOO_SMALL: return true; default: return false; } } public void MarkMessageRejected(long lookupId) { MsmqQueueHandle handle = GetHandle(); int error = 0; try { error = UnsafeNativeMethods.MQMarkMessageRejected(handle, lookupId); } catch (ObjectDisposedException ex) { MsmqDiagnostics.ExpectedException(ex); } if (error != 0) { if (IsErrorDueToStaleHandle(error)) { HandleIsStale(handle); } throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MsmqException(SR.GetString(SR.MsmqSendError, MsmqError.GetErrorString(error)), error)); } } int TryMoveMessageDtcTransacted(long lookupId, MsmqQueueHandle sourceQueueHandle, MsmqQueueHandle destinationQueueHandle, MsmqTransactionMode transactionMode) { IDtcTransaction dtcTransaction = GetNativeTransaction(transactionMode); if (dtcTransaction != null) { try { return UnsafeNativeMethods.MQMoveMessage(sourceQueueHandle, destinationQueueHandle, lookupId, dtcTransaction); } finally { Marshal.ReleaseComObject(dtcTransaction); } } else { return UnsafeNativeMethods.MQMoveMessage(sourceQueueHandle, destinationQueueHandle, lookupId, (IntPtr)GetTransactionConstant(transactionMode)); } } public MoveReceiveResult TryMoveMessage(long lookupId, MsmqQueue destinationQueue, MsmqTransactionMode transactionMode) { MsmqQueueHandle sourceQueueHandle = GetHandle(); MsmqQueueHandle destinationQueueHandle = destinationQueue.GetHandle(); int error; try { if (RequiresDtcTransaction(transactionMode)) { error = TryMoveMessageDtcTransacted(lookupId, sourceQueueHandle, destinationQueueHandle, transactionMode); } else { error = UnsafeNativeMethods.MQMoveMessage(sourceQueueHandle, destinationQueueHandle, lookupId, (IntPtr)GetTransactionConstant(transactionMode)); } } catch (ObjectDisposedException ex) { MsmqDiagnostics.ExpectedException(ex); return MoveReceiveResult.Succeeded; } if (error != 0) { if (error == UnsafeNativeMethods.MQ_ERROR_MESSAGE_NOT_FOUND) return MoveReceiveResult.MessageNotFound; else if (error == UnsafeNativeMethods.MQ_ERROR_MESSAGE_LOCKED_UNDER_TRANSACTION) return MoveReceiveResult.MessageLockedUnderTransaction; else if (IsErrorDueToStaleHandle(error)) { HandleIsStale(sourceQueueHandle); destinationQueue.HandleIsStale(destinationQueueHandle); } throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MsmqException(SR.GetString(SR.MsmqSendError, MsmqError.GetErrorString(error)), error)); } return MoveReceiveResult.Succeeded; } public ReceiveResult TryReceive(NativeMsmqMessage message, TimeSpan timeout, MsmqTransactionMode transactionMode) { return TryReceive(message, timeout, transactionMode, UnsafeNativeMethods.MQ_ACTION_RECEIVE); } ReceiveResult TryReceive(NativeMsmqMessage message, TimeSpan timeout, MsmqTransactionMode transactionMode, int action) { TimeoutHelper timeoutHelper = new TimeoutHelper(timeout); MsmqQueueHandle handle = GetHandle(); while (true) { int error = ReceiveCore(handle, message, timeoutHelper.RemainingTime(), transactionMode, action); if (0 == error) return ReceiveResult.MessageReceived; if (IsReceiveErrorDueToInsufficientBuffer(error)) { message.GrowBuffers(); continue; } else if (error == UnsafeNativeMethods.MQ_ERROR_IO_TIMEOUT) { return ReceiveResult.Timeout; } else if (error == UnsafeNativeMethods.MQ_ERROR_OPERATION_CANCELLED) { return ReceiveResult.OperationCancelled; } else if (error == UnsafeNativeMethods.MQ_ERROR_INVALID_HANDLE) { // should happen only if racing with Close return ReceiveResult.OperationCancelled; } else if (IsErrorDueToStaleHandle(error)) { HandleIsStale(handle); } throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MsmqException(SR.GetString(SR.MsmqReceiveError, MsmqError.GetErrorString(error)), error)); } } public MoveReceiveResult TryReceiveByLookupId(long lookupId, NativeMsmqMessage message, MsmqTransactionMode transactionMode) { MsmqQueueHandle handle = GetHandle(); int error = 0; try { error = ReceiveByLookupIdCore(handle, lookupId, message, transactionMode, UnsafeNativeMethods.MQ_LOOKUP_RECEIVE_CURRENT); } catch (ObjectDisposedException ex) { // race with Close MsmqDiagnostics.ExpectedException(ex); return MoveReceiveResult.Succeeded; } if (0 != error) { if (UnsafeNativeMethods.MQ_ERROR_MESSAGE_NOT_FOUND == error) return MoveReceiveResult.MessageNotFound; else if (UnsafeNativeMethods.MQ_ERROR_MESSAGE_LOCKED_UNDER_TRANSACTION == error) return MoveReceiveResult.MessageLockedUnderTransaction; else if (IsErrorDueToStaleHandle(error)) HandleIsStale(handle); throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MsmqException(SR.GetString(SR.MsmqReceiveError, MsmqError.GetErrorString(error)), error)); } return MoveReceiveResult.Succeeded; } unsafe int ReceiveByLookupIdCoreDtcTransacted(MsmqQueueHandle handle, long lookupId, NativeMsmqMessage message, MsmqTransactionMode transactionMode, int action) { IDtcTransaction dtcTransaction = GetNativeTransaction(transactionMode); IntPtr nativePropertiesPointer = message.Pin(); try { if (dtcTransaction != null) { try { return UnsafeNativeMethods.MQReceiveMessageByLookupId(handle, lookupId, action, nativePropertiesPointer, null, IntPtr.Zero, dtcTransaction); } finally { Marshal.ReleaseComObject(dtcTransaction); } } else { return UnsafeNativeMethods.MQReceiveMessageByLookupId(handle, lookupId, action, nativePropertiesPointer, null, IntPtr.Zero, (IntPtr)GetTransactionConstant(transactionMode)); } } finally { message.Unpin(); } } unsafe int ReceiveByLookupIdCore(MsmqQueueHandle handle, long lookupId, NativeMsmqMessage message, MsmqTransactionMode transactionMode, int action) { if (RequiresDtcTransaction(transactionMode)) { return ReceiveByLookupIdCoreDtcTransacted(handle, lookupId, message, transactionMode, action); } else { IntPtr nativePropertiesPointer = message.Pin(); try { return UnsafeNativeMethods.MQReceiveMessageByLookupId(handle, lookupId, action, nativePropertiesPointer, null, IntPtr.Zero, (IntPtr)GetTransactionConstant(transactionMode)); } finally { message.Unpin(); } } } unsafe int ReceiveCoreDtcTransacted(MsmqQueueHandle handle, NativeMsmqMessage message, TimeSpan timeout, MsmqTransactionMode transactionMode, int action) { IDtcTransaction dtcTransaction = GetNativeTransaction(transactionMode); int timeoutInMilliseconds = TimeoutHelper.ToMilliseconds(timeout); IntPtr nativePropertiesPointer = message.Pin(); try { if (dtcTransaction != null) { try { return UnsafeNativeMethods.MQReceiveMessage(handle.DangerousGetHandle(), timeoutInMilliseconds, action, nativePropertiesPointer, null, IntPtr.Zero, IntPtr.Zero, dtcTransaction); } finally { Marshal.ReleaseComObject(dtcTransaction); } } else { return UnsafeNativeMethods.MQReceiveMessage(handle.DangerousGetHandle(), timeoutInMilliseconds, action, nativePropertiesPointer, null, IntPtr.Zero, IntPtr.Zero, (IntPtr)GetTransactionConstant(transactionMode)); } } finally { message.Unpin(); } } unsafe int ReceiveCore(MsmqQueueHandle handle, NativeMsmqMessage message, TimeSpan timeout, MsmqTransactionMode transactionMode, int action) { if (RequiresDtcTransaction(transactionMode)) { return ReceiveCoreDtcTransacted(handle, message, timeout, transactionMode, action); } else { int timeoutInMilliseconds = TimeoutHelper.ToMilliseconds(timeout); IntPtr nativePropertiesPointer = message.Pin(); try { return UnsafeNativeMethods.MQReceiveMessage(handle.DangerousGetHandle(), timeoutInMilliseconds, action, nativePropertiesPointer, null, IntPtr.Zero, IntPtr.Zero, (IntPtr)GetTransactionConstant(transactionMode)); } finally { message.Unpin(); } } } IDtcTransaction GetNativeTransaction(MsmqTransactionMode transactionMode) { Transaction transaction = Transaction.Current; if (transaction != null) { return TransactionInterop.GetDtcTransaction(transaction); } if (transactionMode == MsmqTransactionMode.CurrentOrThrow) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.MsmqTransactionRequired))); } return null; } public ReceiveResult TryPeek(NativeMsmqMessage message, TimeSpan timeout) { return TryReceive(message, timeout, MsmqTransactionMode.None, UnsafeNativeMethods.MQ_ACTION_PEEK_CURRENT); } bool RequiresDtcTransaction(MsmqTransactionMode transactionMode) { switch (transactionMode) { case MsmqTransactionMode.None: case MsmqTransactionMode.Single: return false; case MsmqTransactionMode.CurrentOrSingle: case MsmqTransactionMode.CurrentOrNone: case MsmqTransactionMode.CurrentOrThrow: return true; default: throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("transactionMode")); } } int GetTransactionConstant(MsmqTransactionMode transactionMode) { switch (transactionMode) { case MsmqTransactionMode.CurrentOrNone: case MsmqTransactionMode.None: return UnsafeNativeMethods.MQ_NO_TRANSACTION; case MsmqTransactionMode.Single: case MsmqTransactionMode.CurrentOrSingle: return UnsafeNativeMethods.MQ_SINGLE_MESSAGE; default: throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("transactionMode")); } } int SendDtcTransacted(NativeMsmqMessage message, MsmqTransactionMode transactionMode) { IDtcTransaction dtcTransaction = GetNativeTransaction(transactionMode); MsmqQueueHandle handle = GetHandle(); IntPtr nativePropertiesPointer = message.Pin(); try { if (dtcTransaction != null) { try { return UnsafeNativeMethods.MQSendMessage(handle, nativePropertiesPointer, dtcTransaction); } finally { Marshal.ReleaseComObject(dtcTransaction); } } else { return UnsafeNativeMethods.MQSendMessage(handle, nativePropertiesPointer, (IntPtr)GetTransactionConstant(transactionMode)); } } finally { message.Unpin(); } } public void Send(NativeMsmqMessage message, MsmqTransactionMode transactionMode) { int error = 0; if (RequiresDtcTransaction(transactionMode)) { error = SendDtcTransacted(message, transactionMode); } else { MsmqQueueHandle handle = GetHandle(); IntPtr nativePropertiesPointer = message.Pin(); try { error = UnsafeNativeMethods.MQSendMessage(handle, nativePropertiesPointer, (IntPtr)GetTransactionConstant(transactionMode)); } finally { message.Unpin(); } } if (error != 0) { if (IsErrorDueToStaleHandle(error)) { HandleIsStale(handle); } throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MsmqException(SR.GetString(SR.MsmqSendError, MsmqError.GetErrorString(error)), error)); } } unsafe int ReceiveCoreAsync(MsmqQueueHandle handle, IntPtr nativePropertiesPointer, TimeSpan timeout, int action, NativeOverlapped* nativeOverlapped, UnsafeNativeMethods.MQReceiveCallback receiveCallback) { int timeoutInMilliseconds = TimeoutHelper.ToMilliseconds(timeout); return UnsafeNativeMethods.MQReceiveMessage(handle, timeoutInMilliseconds, action, nativePropertiesPointer, nativeOverlapped, receiveCallback, IntPtr.Zero, (IntPtr)UnsafeNativeMethods.MQ_NO_TRANSACTION); } public IAsyncResult BeginTryReceive(NativeMsmqMessage message, TimeSpan timeout, AsyncCallback callback, object state) { return new TryReceiveAsyncResult(this, message, timeout, UnsafeNativeMethods.MQ_ACTION_RECEIVE, callback, state); } public ReceiveResult EndTryReceive(IAsyncResult result) { return TypedAsyncResult.End(result); } public IAsyncResult BeginPeek(NativeMsmqMessage message, TimeSpan timeout, AsyncCallback callback, object state) { return new TryReceiveAsyncResult(this, message, timeout, UnsafeNativeMethods.MQ_ACTION_PEEK_CURRENT, callback, state); } public ReceiveResult EndPeek(IAsyncResult result) { return TypedAsyncResult .End(result); } class TryReceiveAsyncResult : TypedAsyncResult { MsmqQueue msmqQueue; int action; TimeoutHelper timeoutHelper; NativeMsmqMessage message; unsafe NativeOverlapped* nativeOverlapped = null; MsmqQueueHandle handle; unsafe static IOCompletionCallback onPortedCompletion = DiagnosticUtility.Utility.ThunkCallback(new IOCompletionCallback(OnPortedCompletion)); unsafe static UnsafeNativeMethods.MQReceiveCallback onNonPortedCompletion; public TryReceiveAsyncResult(MsmqQueue msmqQueue, NativeMsmqMessage message, TimeSpan timeout, int action, AsyncCallback callback, object state) : base(callback, state) { this.msmqQueue = msmqQueue; this.message = message; this.action = action; this.timeoutHelper = new TimeoutHelper(timeout); StartReceive(true); } unsafe ~TryReceiveAsyncResult() { if (null != this.nativeOverlapped && ! Environment.HasShutdownStarted && ! AppDomain.CurrentDomain.IsFinalizingForUnload()) { Overlapped.Free(this.nativeOverlapped); } } unsafe void StartReceive(bool synchronously) { bool useCompletionPort; try { this.handle = this.msmqQueue.GetHandleForAsync(out useCompletionPort); } catch (MsmqException ex) { OnCompletion(ex.ErrorCode, synchronously); return; } if (null != nativeOverlapped) { DiagnosticUtility.DebugAssert("Race in StartReceive"); } IntPtr nativePropertiesPointer = this.message.Pin(); nativeOverlapped = new Overlapped(0, 0, IntPtr.Zero, this).UnsafePack(onPortedCompletion, this.message.GetBuffersForAsync()); int error; try { if (useCompletionPort) { error = msmqQueue.ReceiveCoreAsync(this.handle, nativePropertiesPointer, this.timeoutHelper.RemainingTime(), this.action, nativeOverlapped, null); } else { if (onNonPortedCompletion == null) { onNonPortedCompletion = new UnsafeNativeMethods.MQReceiveCallback(OnNonPortedCompletion); } error = msmqQueue.ReceiveCoreAsync(this.handle, nativePropertiesPointer, this.timeoutHelper.RemainingTime(), this.action, nativeOverlapped, onNonPortedCompletion); } } catch (ObjectDisposedException ex) { // if Close races with the async Receive, it is possible that SafeHandle will throw ObjectDisposedException // the behavior should be same as if operation was just cancelled (the channel will return no message) MsmqDiagnostics.ExpectedException(ex); error = UnsafeNativeMethods.MQ_ERROR_OPERATION_CANCELLED; } if (error != 0) { if (error != UnsafeNativeMethods.MQ_INFORMATION_OPERATION_PENDING) { Overlapped.Free(nativeOverlapped); nativeOverlapped = null; GC.SuppressFinalize(this); OnCompletion(error, synchronously); } } } unsafe static void OnNonPortedCompletion(int error, IntPtr handle, int timeout, int action, IntPtr props, NativeOverlapped* nativeOverlapped, IntPtr cursor) { ThreadPool.UnsafeQueueNativeOverlapped(nativeOverlapped); } unsafe static void OnPortedCompletion(uint error, uint numBytes, NativeOverlapped* nativeOverlapped) { Overlapped overlapped = Overlapped.Unpack(nativeOverlapped); TryReceiveAsyncResult result = (TryReceiveAsyncResult)overlapped.AsyncResult; if (error != 0) { error = (uint)UnsafeNativeMethods.MQGetOverlappedResult(nativeOverlapped); } Overlapped.Free(nativeOverlapped); result.nativeOverlapped = null; #pragma warning suppress 56508 // Suppression justified. Presharp warning concerns different scenario. GC.SuppressFinalize(result); result.OnCompletion((int)error, false); } void OnCompletion(int error, bool completedSynchronously) { Exception completionException = null; ReceiveResult result = ReceiveResult.MessageReceived; try { if (error != 0) { if (error == UnsafeNativeMethods.MQ_ERROR_IO_TIMEOUT) { result = ReceiveResult.Timeout; } else if (error == UnsafeNativeMethods.MQ_ERROR_OPERATION_CANCELLED) { result = ReceiveResult.OperationCancelled; } else { if (IsReceiveErrorDueToInsufficientBuffer(error)) { this.message.Unpin(); message.GrowBuffers(); StartReceive(completedSynchronously); return; } else if (IsErrorDueToStaleHandle(error)) { this.msmqQueue.HandleIsStale(this.handle); } throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MsmqException(SR.GetString(SR.MsmqReceiveError, MsmqError.GetErrorString(error)), error)); } } } catch (Exception e) { if (e is NullReferenceException || e is SEHException) throw; completionException = e; } this.message.Unpin(); if (null == completionException) Complete(result, completedSynchronously); else Complete(completedSynchronously, completionException); } } class QueueTransactionProperties : NativeMsmqMessage { ByteProperty transaction; public QueueTransactionProperties() : base(1) { this.transaction = new ByteProperty(this, UnsafeNativeMethods.PROPID_Q_TRANSACTION); } public ByteProperty Transaction { get { return this.transaction; } } } class PrivateComputerProperties : NativeMsmqMessage { IntProperty version; BooleanProperty activeDirectory; public PrivateComputerProperties() : base(2) { this.version = new IntProperty(this, UnsafeNativeMethods.PROPID_PC_VERSION); this.activeDirectory = new BooleanProperty(this, UnsafeNativeMethods.PROPID_PC_DS_ENABLED); } public IntProperty Version { get { return this.version; } } public BooleanProperty ActiveDirectory { get { return this.activeDirectory; } } } public enum MoveReceiveResult { Unknown, Succeeded, MessageNotFound, MessageLockedUnderTransaction } internal enum ReceiveResult { Unknown, MessageReceived, Timeout, OperationCancelled } } static class MsmqFormatName { const string systemMessagingLabelPrefix = "LABEL:"; const string systemMessagingFormatNamePrefix = "FORMATNAME:"; public static string ToSystemMessagingQueueName(string formatName) { return systemMessagingFormatNamePrefix + formatName; } public static string FromQueuePath(string queuePath) { int len = 256; StringBuilder buffer = new StringBuilder(len); int error = UnsafeNativeMethods.MQPathNameToFormatName(queuePath, buffer, ref len); if (UnsafeNativeMethods.MQ_ERROR_FORMATNAME_BUFFER_TOO_SMALL == error) { buffer = new StringBuilder(len); error = UnsafeNativeMethods.MQPathNameToFormatName(queuePath, buffer, ref len); } if (0 != error) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError( new MsmqException(SR.GetString(SR.MsmqPathLookupError, queuePath, MsmqError.GetErrorString(error)), error)); } return buffer.ToString(); } } } // File provided for Reference Use Only by Microsoft Corporation (c) 2007. // Copyright (c) Microsoft Corporation. All rights reserved.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- OutputCacheProfileCollection.cs
- TabItem.cs
- MonthCalendar.cs
- TemplatedWizardStep.cs
- UserControl.cs
- RowSpanVector.cs
- DataTrigger.cs
- PowerModeChangedEventArgs.cs
- InstancePersistenceCommand.cs
- TransformedBitmap.cs
- ContainerFilterService.cs
- PageOutputColor.cs
- EntityDataSourceWrapperCollection.cs
- XmlUTF8TextWriter.cs
- DoubleAnimation.cs
- SweepDirectionValidation.cs
- DocumentAutomationPeer.cs
- TransactionFilter.cs
- XPathSelfQuery.cs
- DefaultMemberAttribute.cs
- StorageEntitySetMapping.cs
- CrossContextChannel.cs
- Coordinator.cs
- HttpInputStream.cs
- PropertyValue.cs
- ListenerConstants.cs
- DbCommandTree.cs
- StackBuilderSink.cs
- EtwTrace.cs
- ThicknessAnimation.cs
- GridViewRowCollection.cs
- SimpleParser.cs
- ConfigXmlElement.cs
- PlaceHolder.cs
- Page.cs
- AutoScrollHelper.cs
- _Events.cs
- ConfigXmlElement.cs
- CellParaClient.cs
- WithStatement.cs
- ShaderEffect.cs
- BulletDecorator.cs
- Brush.cs
- EdmRelationshipRoleAttribute.cs
- IPeerNeighbor.cs
- WebBaseEventKeyComparer.cs
- ClientSponsor.cs
- WebPartUserCapability.cs
- MemberInitExpression.cs
- RectangleF.cs
- coordinatorscratchpad.cs
- ConnectionStringsSection.cs
- SourceFileInfo.cs
- VideoDrawing.cs
- DataGridPagerStyle.cs
- DataColumnMappingCollection.cs
- ReadOnlyDataSource.cs
- LowerCaseStringConverter.cs
- BitmapEffectDrawingContextState.cs
- TextTabProperties.cs
- InfoCardSymmetricCrypto.cs
- XmlIncludeAttribute.cs
- CodeChecksumPragma.cs
- Section.cs
- HwndSourceKeyboardInputSite.cs
- DesignSurface.cs
- SqlGenericUtil.cs
- PageRequestManager.cs
- SelectionChangedEventArgs.cs
- MetadataUtilsSmi.cs
- panel.cs
- ServiceOperationParameter.cs
- NotSupportedException.cs
- LineInfo.cs
- MailMessageEventArgs.cs
- OleDbConnectionPoolGroupProviderInfo.cs
- ParameterToken.cs
- CachedCompositeFamily.cs
- PictureBox.cs
- XmlTextReaderImplHelpers.cs
- RuleSettingsCollection.cs
- FrameworkPropertyMetadata.cs
- UrlAuthFailedErrorFormatter.cs
- ObjectPersistData.cs
- PerfCounterSection.cs
- ManifestResourceInfo.cs
- SignerInfo.cs
- SourceItem.cs
- RTLAwareMessageBox.cs
- ReferenceSchema.cs
- MemberCollection.cs
- VirtualDirectoryMapping.cs
- PrinterSettings.cs
- validation.cs
- MonthChangedEventArgs.cs
- TableRow.cs
- RuntimeHelpers.cs
- StructuredType.cs
- CharEntityEncoderFallback.cs
- ToolStripRenderer.cs