Code:
/ WCF / WCF / 3.5.30729.1 / untmp / Orcas / SP / ndp / cdf / src / WCF / TransactionBridge / Microsoft / Transactions / Wsat / StateMachines / Durable.cs / 1 / Durable.cs
//------------------------------------------------------------------------------ // Copyright (c) Microsoft Corporation. All rights reserved. //----------------------------------------------------------------------------- // This file contains the implementation of the various states used by // the durable TwoPhaseCommit participant state machine using System; using System.Diagnostics; using System.ServiceModel.Channels; using Microsoft.Transactions.Bridge; using Microsoft.Transactions.Wsat.InputOutput; using Microsoft.Transactions.Wsat.Messaging; using Microsoft.Transactions.Wsat.Protocol; using Microsoft.Transactions.Wsat.Recovery; using DiagnosticUtility = Microsoft.Transactions.Bridge.DiagnosticUtility; namespace Microsoft.Transactions.Wsat.StateMachines { //============================================================================= // DurableRegistering // // A participant registered for durable 2PC // We asked the TM to create a new subordinate enlistment //============================================================================= class DurableRegistering : InactiveState { public DurableRegistering (ProtocolState state) : base (state) {} public override void OnEvent(TmRegisterResponseEvent e) { ProcessTmRegisterResponse(e); if (e.Status == Status.Success) { e.StateMachine.ChangeState(state.States.DurableActive); } else { e.StateMachine.ChangeState(state.States.DurableInitializationFailed); } } } //============================================================================== // DurableActive // // The TM created a subordinate enlistment and success was sent to the registrant //============================================================================= class DurableActive : ActiveState { public DurableActive (ProtocolState state) : base (state) {} // Unsolicited ReadOnly public override void OnEvent(MsgReadOnlyEvent e) { e.StateMachine.ChangeState(state.States.DurableUnregistered); } // Unsolicited Aborted public override void OnEvent(MsgAbortedEvent e) { state.TransactionManagerSend.Rollback (e.Participant); e.StateMachine.ChangeState(state.States.DurableAborted); } // The WS-AT 1.0 state machines dictate a polite answer for Replay // System.Transactions allows a durable participant to receive a phase zero prepare // instead of a phase one prepare. This implies that it might attempt to recover while // the coordinator is still active, since System.Transactions will register a volatile // for the phase zero prepare. // // We wouldnt want the participant to receive a fault when it should really // receive a polite Rollback message. public override void OnEvent(MsgReplayEvent e) { ProtocolVersionHelper.AssertProtocolVersion10(this.state.ProtocolVersion, typeof(DurableActive), "OnEvent(replay)"); ParticipantEnlistment participant = e.Participant; state.TwoPhaseCommitCoordinator.SendRollback (participant); state.TransactionManagerSend.Rollback (participant); e.StateMachine.ChangeState(state.States.DurableAborted); } public override void OnEvent(TmPrepareEvent e) { ParticipantEnlistment participant = e.Participant; participant.SetCallback(e.Callback, e.CallbackState); state.TwoPhaseCommitCoordinator.SendPrepare (participant); e.StateMachine.ChangeState(state.States.DurablePreparing); } public override void OnEvent(TmRollbackEvent e) { ParticipantEnlistment participant = e.Participant; state.TwoPhaseCommitCoordinator.SendRollback (participant); participant.SetCallback(e.Callback, e.CallbackState); state.TransactionManagerSend.Aborted(participant); e.StateMachine.ChangeState(state.States.DurableAborted); } } //============================================================================== // DurableUnregistered // // The participant sent an unsolicited readonly and "unregistered" from the transaction // This is an active state because we can still abort //============================================================================== class DurableUnregistered : ActiveState { public DurableUnregistered (ProtocolState state) : base (state) {} // Tolerate duplicate messages public override void OnEvent(MsgReadOnlyEvent e) { return; } // Deliver the ReadOnly we're been saving up public override void OnEvent(TmPrepareEvent e) { ParticipantEnlistment participant = e.Participant; participant.SetCallback(e.Callback, e.CallbackState); state.TransactionManagerSend.ReadOnly (participant); e.StateMachine.ChangeState(state.States.DurableInDoubt); } public override void OnEvent(TmRollbackEvent e) { ParticipantEnlistment participant = e.Participant; participant.SetCallback(e.Callback, e.CallbackState); state.TransactionManagerSend.Aborted(participant); e.StateMachine.ChangeState(state.States.DurableAborted); } } //============================================================================= // DurablePreparing // // The TM told us to prepare. We told the participant to prepare //============================================================================== class DurablePreparing : ActiveState { public DurablePreparing (ProtocolState state) : base (state) {} public override void Enter (StateMachine stateMachine) { base.Enter (stateMachine); // Set send Prepare time for performance counter ((ParticipantEnlistment)stateMachine.Enlistment).LastMessageTime = State.QueryStartTime(); // Start up a Prepare timer stateMachine.StartTimer (TimerProfile.Preparing); } public override void Leave (StateMachine stateMachine) { base.Leave (stateMachine); ParticipantEnlistment participant = (ParticipantEnlistment) stateMachine.Enlistment; long elapsed = State.QueryStopTime() - participant.LastMessageTime; state.Perf.AverageParticipantPrepareResponseTimeBase.Increment(); state.Perf.AverageParticipantPrepareResponseTime.IncrementBy(elapsed); // Cancel the Prepare timer participant.Retries = 0; stateMachine.CancelTimer(); } public override void OnEvent(MsgReadOnlyEvent e) { state.TransactionManagerSend.ReadOnly (e.Participant); e.StateMachine.ChangeState(state.States.DurableInDoubt); } public override void OnEvent(MsgPreparedEvent e) { ParticipantEnlistment participant = e.Participant; Exception failed = null; try { byte[] recovery = state.LogEntrySerialization.Serialize(participant); participant.Enlistment.SetRecoveryData (recovery); state.TransactionManagerSend.Prepared (participant); e.StateMachine.ChangeState(state.States.DurablePrepared); } catch (SerializationException exception) { DiagnosticUtility.ExceptionUtility.TraceHandledException(exception, TraceEventType.Error); failed = exception; } if (failed != null) { if (DebugTrace.Error) DebugTrace.Trace(TraceLevel.Verbose, "Failed to serialize log entry for participant: {0}", failed); ParticipantRecoveryLogEntryCreationFailureRecord.TraceAndLog( participant.EnlistmentId, participant.Enlistment.RemoteTransactionId, failed.Message, failed ); // We react to serialization failures by aborting the transaction state.TwoPhaseCommitCoordinator.SendRollback (participant); state.TransactionManagerSend.Aborted(participant); e.StateMachine.ChangeState(state.States.DurableAborted); } } public override void OnEvent(MsgAbortedEvent e) { state.TransactionManagerSend.Aborted(e.Participant); e.StateMachine.ChangeState(state.States.DurableAborted); } // We might also receive a Replay in this state, but we're going to call that a failure // // We abort the transaction if this occurs. We never received a Prepared message // from this participant, and we don't really know what could have happened to it. // There are cases where the participant might write a Prepared log record, then // try to send Prepared, fail, decide to abort and fail. An RM would generally write // an abort log record before performing undo steps, but a TM can optimize the log write // by neglecting to write an abort record and simply forgetting its local state. If the TM // were to fail after, say, having sent rollbacks to half of its participants, it would wake // up in an indoubt state with respect to that transaction. // // In these cases, the participant relies on us to keep it straight. // // The sad thing is that there are legitimate cases where this pattern could occur. If the // participant's Prepared response were lost and then the participant failed, we would // see this message in this state. Unfortunately, we can't tell the difference between // a legitimate replay and the case described above. public override void OnEvent(MsgReplayEvent e) { ProtocolVersionHelper.AssertProtocolVersion10(this.state.ProtocolVersion, typeof(DurablePreparing), "OnEvent(replay)"); ParticipantEnlistment participant = e.Participant; if (DurableParticipantReplayWhilePreparingRecord.ShouldTrace) { DurableParticipantReplayWhilePreparingRecord.Trace ( participant.EnlistmentId, participant.Enlistment.RemoteTransactionId ); } state.TwoPhaseCommitCoordinator.SendRollback (participant); state.TransactionManagerSend.Aborted(participant); e.StateMachine.ChangeState(state.States.DurableAborted); } // Async rollback from the TM... Could be a timeout, could be another participant aborting public override void OnEvent(TmRollbackEvent e) { ParticipantEnlistment participant = e.Participant; state.TwoPhaseCommitCoordinator.SendRollback (participant); participant.SetCallback(e.Callback, e.CallbackState); state.TransactionManagerSend.Aborted(participant); e.StateMachine.ChangeState(state.States.DurableAborted); } public override void OnEvent(TimerParticipantEvent e) { ParticipantEnlistment participant = e.Participant; participant.Retries ++; if (PrepareMessageRetryRecord.ShouldTrace) { PrepareMessageRetryRecord.Trace ( participant.EnlistmentId, participant.Enlistment.RemoteTransactionId, participant.Retries ); } state.Perf.PrepareRetryCountPerInterval.Increment(); // Send another prepare message state.TwoPhaseCommitCoordinator.SendPrepare (participant); } } //============================================================================= // DurablePrepared // // The participant said prepared. We told the TM prepared //============================================================================= class DurablePrepared : DecidedState { public DurablePrepared (ProtocolState state) : base (state) {} // Tolerate duplicate messages public override void OnEvent(MsgPreparedEvent e) { return; } // We will deliver outcome when we're ready public override void OnEvent(MsgReplayEvent e) { ProtocolVersionHelper.AssertProtocolVersion10(this.state.ProtocolVersion, typeof(DurablePrepared), "OnEvent(replay)"); return; } public override void OnEvent(TmCommitEvent e) { ParticipantEnlistment participant = e.Participant; state.TwoPhaseCommitCoordinator.SendCommit (participant); participant.SetCallback(e.Callback, e.CallbackState); e.StateMachine.ChangeState(state.States.DurableCommitting); } public override void OnEvent(TmRollbackEvent e) { ParticipantEnlistment participant = e.Participant; state.TwoPhaseCommitCoordinator.SendRollback (participant); participant.SetCallback(e.Callback, e.CallbackState); state.TransactionManagerSend.Aborted(participant); e.StateMachine.ChangeState(state.States.DurableAborted); } public override void OnEvent(TimerParticipantEvent e) { return; } } //============================================================================= // DurableCommitting // // The participant has been instructed to commit //============================================================================== class DurableCommitting : DecidedState { public DurableCommitting (ProtocolState state) : base (state) {} public override void Enter (StateMachine stateMachine) { base.Enter (stateMachine); // Set send Commit time for performance counter ((ParticipantEnlistment) stateMachine.Enlistment).LastMessageTime = State.QueryStartTime(); // Start up a Commit timer stateMachine.StartTimer (TimerProfile.Committing); } public override void Leave (StateMachine stateMachine) { base.Leave (stateMachine); long elapsed = State.QueryStopTime() - ((ParticipantEnlistment)stateMachine.Enlistment).LastMessageTime; state.Perf.AverageParticipantCommitResponseTimeBase.Increment(); state.Perf.AverageParticipantCommitResponseTime.IncrementBy(elapsed); // Cancel the Commit timer stateMachine.CancelTimer(); } // Tolerate duplicate messages public override void OnEvent(MsgPreparedEvent e) { state.TwoPhaseCommitCoordinator.SendCommit (e.Participant); } public override void OnEvent(MsgReplayEvent e) { ProtocolVersionHelper.AssertProtocolVersion10(this.state.ProtocolVersion, typeof(DurableCommitting), "OnEvent(replay)"); state.TwoPhaseCommitCoordinator.SendCommit (e.Participant); } public override void OnEvent(MsgCommittedEvent e) { state.TransactionManagerSend.Committed (e.Participant); e.StateMachine.ChangeState(state.States.DurableCommitted); } public override void OnEvent(TmParticipantForgetEvent e) { ParticipantEnlistment participant = e.Participant; participant.SetCallback(e.Callback, e.CallbackState); state.TransactionManagerSend.ForgetResponse(participant, Status.Success); e.StateMachine.ChangeState(state.States.DurableInDoubt); } public override void OnEvent(TimerParticipantEvent e) { // This reminder be from a preparing timer, in which case we'll ignore it if (e.Profile == TimerProfile.Committing) { ParticipantEnlistment participant = e.Participant; participant.Retries ++; if (CommitMessageRetryRecord.ShouldTrace) { CommitMessageRetryRecord.Trace ( participant.EnlistmentId, participant.Enlistment.RemoteTransactionId, participant.Retries ); } state.Perf.CommitRetryCountPerInterval.Increment(); // Resend the commit state.TwoPhaseCommitCoordinator.SendCommit (participant); } } } //============================================================================= // DurableRecovering // // During recovery, we received a rejoin message from the TM //============================================================================== class DurableRecovering : InactiveState { public DurableRecovering (ProtocolState state) : base (state) {} public override void OnEvent(TmRejoinEvent e) { if (!state.Recovering) { // Being here outside of recovery is impossible. // This only safe thing to do is crash so that // we don't corrupt any transaction state. DiagnosticUtility.FailFast("Rejoin events should only be delivered during recovery"); } ParticipantEnlistment participant = e.Participant; participant.SetCallback(e.Callback, e.CallbackState); state.TransactionManagerSend.Rejoined (participant); e.StateMachine.ChangeState(state.States.DurableRejoined); } } //============================================================================== // DurableRejoined // // We finished rejoining and await outcome // We might receive network messages too //============================================================================= class DurableRejoined : DecidedState { public DurableRejoined (ProtocolState state) : base (state) {} // We will deliver outcome when we're ready public override void OnEvent(MsgPreparedEvent e) { return; } // We will deliver outcome when we're ready public override void OnEvent(MsgReplayEvent e) { ProtocolVersionHelper.AssertProtocolVersion10(this.state.ProtocolVersion, typeof(DurableRejoined), "OnEvent(replay)"); return; } public override void OnEvent(MsgCommittedEvent e) { return; } public override void OnEvent(MsgAbortedEvent e) { return; } public override void OnEvent(TmCommitEvent e) { // If we're still recovering, put the event in the recovery queue if (state.Recovering && state.TryEnqueueRecoveryOutcome (e)) { e.StateMachine.ChangeState(state.States.DurableRecoveryAwaitingCommit); } else { e.Participant.SetCallback(e.Callback, e.CallbackState); e.StateMachine.ChangeState(state.States.DurableRecoveryReceivedCommit); } } public override void OnEvent(TmRollbackEvent e) { // If we're still recovering, put the event in the recovery queue if (state.Recovering && state.TryEnqueueRecoveryOutcome (e)) { e.StateMachine.ChangeState(state.States.DurableRecoveryAwaitingRollback); } else { e.Participant.SetCallback(e.Callback, e.CallbackState); e.StateMachine.ChangeState(state.States.DurableRecoveryReceivedRollback); } } } //============================================================================== // DurableRecoveryAwaitingCommit // // We enqueued a commit outcome from the TM in the recovery queue //============================================================================= class DurableRecoveryAwaitingCommit : DecidedState { public DurableRecoveryAwaitingCommit (ProtocolState state) : base (state) {} // We will deliver outcome when we're ready public override void OnEvent(MsgPreparedEvent e) { return; } // We will deliver outcome when we're ready public override void OnEvent(MsgReplayEvent e) { ProtocolVersionHelper.AssertProtocolVersion10(this.state.ProtocolVersion, typeof(DurableRecoveryAwaitingCommit), "OnEvent(replay)"); return; } public override void OnEvent(MsgCommittedEvent e) { // We must have sent a commit to the participant in a previous life e.StateMachine.ChangeState(state.States.DurableCommitted); } // This is a repost sent when recovery ended public override void OnEvent(TmCommitEvent e) { if (state.Recovering) { // Being here inside of recovery is impossible. // This only safe thing to do is crash so that // we don't corrupt any transaction state. DiagnosticUtility.FailFast("Rejoin events should only be re-delivered after recovery"); } e.Participant.SetCallback(e.Callback, e.CallbackState); e.StateMachine.ChangeState(state.States.DurableRecoveryReceivedCommit); } public override void OnEvent(TmParticipantForgetEvent e) { ParticipantEnlistment participant = e.Participant; participant.SetCallback(e.Callback, e.CallbackState); state.TransactionManagerSend.ForgetResponse(participant, Status.Success); e.StateMachine.ChangeState(state.States.DurableInDoubt); } } //============================================================================= // DurableRecoveryReceivedCommit // // We recovered a participant enlistment, and the TM told us to commit //============================================================================= class DurableRecoveryReceivedCommit : DecidedState { public DurableRecoveryReceivedCommit(ProtocolState state) : base(state) {} public override void Enter(StateMachine stateMachine) { ParticipantEnlistment participant = (ParticipantEnlistment) stateMachine.Enlistment; // Ensure our proxy has a proper 'from' participant.CreateCoordinatorService(); // Send our participant a commit state.TwoPhaseCommitCoordinator.SendCommit(participant); // We'll ack the TM later, when the participant responds stateMachine.ChangeState(state.States.DurableCommitting); } } //============================================================================== // DurableRecoveryAwaitingRollback // // We enqueued a rollback outcome from the TM in the recovery queue //============================================================================= class DurableRecoveryAwaitingRollback : DecidedState { public DurableRecoveryAwaitingRollback (ProtocolState state) : base (state) {} // We will deliver outcome when we're ready public override void OnEvent(MsgPreparedEvent e) { return; } // We'll deliver outcome when we receive our TmRollbackEvent repost public override void OnEvent(MsgReplayEvent e) { ProtocolVersionHelper.AssertProtocolVersion10(this.state.ProtocolVersion, typeof(DurableRecoveryAwaitingRollback), "OnEvent(replay)"); return; } // We must have sent a rollback to the participant in a previous life public override void OnEvent(MsgAbortedEvent e) { e.StateMachine.ChangeState(state.States.DurableAborted); } // This is a repost sent when recovery ended public override void OnEvent(TmRollbackEvent e) { e.Participant.SetCallback(e.Callback, e.CallbackState); e.StateMachine.ChangeState(state.States.DurableRecoveryReceivedRollback); } } //============================================================================== // DurableRecoveryReceivedRollback // // We recovered a participant enlistment, and the TM told us to rollback //============================================================================== class DurableRecoveryReceivedRollback : DecidedState { public DurableRecoveryReceivedRollback(ProtocolState state) : base(state) {} public override void Enter(StateMachine stateMachine) { ParticipantEnlistment participant = (ParticipantEnlistment) stateMachine.Enlistment; // Ensure our proxy has a proper 'from' participant.CreateCoordinatorService(); // Send our participant a rollback state.TwoPhaseCommitCoordinator.SendRollback (participant); // Ack the TM state.TransactionManagerSend.Aborted(participant); stateMachine.ChangeState(state.States.DurableAborted); } } //============================================================================= // DurableFailedRecovery // // We failed to create a proxy during recovery, so we sit idle and wait // On restart, perhaps we will have better luck with policy negotiation //============================================================================== class DurableFailedRecovery : DecidedState { public DurableFailedRecovery (ProtocolState state) : base (state) {} public override void OnEvent(TmRejoinEvent e) { ParticipantEnlistment participant = e.Participant; participant.SetCallback(e.Callback, e.CallbackState); state.TransactionManagerSend.Rejoined(participant); } public override void OnEvent(TmCommitEvent e) { return; } public override void OnEvent(TmRollbackEvent e) { ParticipantEnlistment participant = e.Participant; participant.SetCallback(e.Callback, e.CallbackState); state.TransactionManagerSend.Aborted(participant); e.StateMachine.ChangeState(state.States.DurableAborted); } public override void OnEvent(TmParticipantForgetEvent e) { ParticipantEnlistment participant = e.Participant; participant.SetCallback(e.Callback, e.CallbackState); state.TransactionManagerSend.ForgetResponse(participant, Status.Success); e.StateMachine.ChangeState(state.States.DurableInDoubt); } } //============================================================================= // DurableCommitted // // We think we're done, and the transaction committed //============================================================================= class DurableCommitted : TerminalState { public DurableCommitted (ProtocolState state) : base (state) {} public override void Enter (StateMachine stateMachine) { base.Enter (stateMachine); if (ParticipantStateMachineFinishedRecord.ShouldTrace) { ParticipantStateMachineFinishedRecord.Trace( stateMachine.Enlistment.EnlistmentId, stateMachine.Enlistment.Enlistment.RemoteTransactionId, TransactionOutcome.Committed ); } } // We already received a committed message public override void OnEvent(MsgPreparedEvent e) { return; } public override void OnEvent(MsgCommittedEvent e) { return; } // We already received a committed message public override void OnEvent(MsgReplayEvent e) { ProtocolVersionHelper.AssertProtocolVersion10(this.state.ProtocolVersion, typeof(DurableCommitted), "OnEvent(replay)"); return; } // This is a repost from the recovery queue public override void OnEvent(TmCommitEvent e) { ParticipantEnlistment participant = e.Participant; participant.SetCallback(e.Callback, e.CallbackState); state.TransactionManagerSend.Committed (participant); } public override void OnEvent(TmParticipantForgetEvent e) { ParticipantEnlistment participant = e.Participant; participant.SetCallback(e.Callback, e.CallbackState); state.TransactionManagerSend.ForgetResponse(participant, Status.Success); } public override void OnEvent(TimerParticipantEvent e) { return; } } //============================================================================= // DurableAborted // // We think we're done, and the transaction aborted //============================================================================== class DurableAborted : TerminalState { public DurableAborted(ProtocolState state) : base (state) {} public override void Enter (StateMachine stateMachine) { base.Enter (stateMachine); if (ParticipantStateMachineFinishedRecord.ShouldTrace) { ParticipantStateMachineFinishedRecord.Trace( stateMachine.Enlistment.EnlistmentId, stateMachine.Enlistment.Enlistment.RemoteTransactionId, TransactionOutcome.Aborted ); } } public override void OnEvent(MsgReadOnlyEvent e) { return; } public override void OnEvent(MsgPreparedEvent e) { state.TwoPhaseCommitCoordinator.SendRollback(e.ReplyTo); } public override void OnEvent(MsgAbortedEvent e) { return; } public override void OnEvent(MsgReplayEvent e) { ProtocolVersionHelper.AssertProtocolVersion10(this.state.ProtocolVersion, typeof(DurableAborted), "OnEvent(replay)"); state.TwoPhaseCommitCoordinator.SendRollback(e.ReplyTo); } public override void OnEvent(TmPrepareEvent e) { ParticipantEnlistment participant = e.Participant; participant.SetCallback(e.Callback, e.CallbackState); state.TransactionManagerSend.Aborted(participant); } public override void OnEvent(TmRollbackEvent e) { ParticipantEnlistment participant = e.Participant; participant.SetCallback(e.Callback, e.CallbackState); state.TransactionManagerSend.Aborted(participant); } public override void OnEvent(TmRollbackResponseEvent e) { if (e.Status != Status.Aborted) { // The only valid status is Aborted. If this is not true, we // shouldn't be in this state method. DiagnosticUtility.FailFast("Transaction manager should respond Aborted to Rollback"); } return; } public override void OnEvent(TmParticipantForgetEvent e) { ParticipantEnlistment participant = e.Participant; participant.SetCallback(e.Callback, e.CallbackState); state.TransactionManagerSend.ForgetResponse(participant, Status.Success); } public override void OnEvent(TimerParticipantEvent e) { return; } } //============================================================================= // DurableInDoubt // // We think we're done, and the transaction is indoubt //============================================================================== class DurableInDoubt : TerminalState { public DurableInDoubt (ProtocolState state) : base (state) {} public override void Enter (StateMachine stateMachine) { base.Enter (stateMachine); if (ParticipantStateMachineFinishedRecord.ShouldTrace) { ParticipantStateMachineFinishedRecord.Trace( stateMachine.Enlistment.EnlistmentId, stateMachine.Enlistment.Enlistment.RemoteTransactionId, TransactionOutcome.InDoubt ); } } public override void OnEvent(MsgReadOnlyEvent e) { return; } public override void OnEvent(MsgAbortedEvent e) { return; } public override void OnEvent(MsgCommittedEvent e) { return; } public override void OnEvent(TmRollbackEvent e) { ParticipantEnlistment participant = e.Participant; participant.SetCallback(e.Callback, e.CallbackState); state.TransactionManagerSend.Aborted(participant); } public override void OnEvent(TimerParticipantEvent e) { return; } } //============================================================================== // DurableInitializationFailed // // We think we're done because we couldn't create a subordinate enlistment //============================================================================= class DurableInitializationFailed : TerminalState { public DurableInitializationFailed(ProtocolState state) : base(state) { } } } // 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
- SqlNodeAnnotation.cs
- HashMembershipCondition.cs
- DescriptionAttribute.cs
- BlobPersonalizationState.cs
- SyndicationContent.cs
- RTLAwareMessageBox.cs
- MdiWindowListItemConverter.cs
- InkPresenterAutomationPeer.cs
- Converter.cs
- Exceptions.cs
- isolationinterop.cs
- TrueReadOnlyCollection.cs
- DataContractSerializer.cs
- TogglePatternIdentifiers.cs
- SizeIndependentAnimationStorage.cs
- XslUrlEditor.cs
- CroppedBitmap.cs
- ToolTipService.cs
- QilInvoke.cs
- BindingsSection.cs
- ReadOnlyNameValueCollection.cs
- CompareInfo.cs
- StylusButtonEventArgs.cs
- WizardPanel.cs
- GenericEnumerator.cs
- TranslateTransform3D.cs
- FontNamesConverter.cs
- DuplexSecurityProtocolFactory.cs
- KeyFrames.cs
- PassportPrincipal.cs
- DynamicPropertyHolder.cs
- DataBoundControlHelper.cs
- _SingleItemRequestCache.cs
- URIFormatException.cs
- ProcessRequestArgs.cs
- StreamReader.cs
- WindowsGraphics2.cs
- X509Certificate.cs
- UniqueConstraint.cs
- WorkflowInstanceContextProvider.cs
- SmtpAuthenticationManager.cs
- WindowsGraphicsCacheManager.cs
- Vertex.cs
- SoapMessage.cs
- TemplateControl.cs
- Calendar.cs
- StrokeCollection2.cs
- UriTemplateClientFormatter.cs
- QilLiteral.cs
- RegexCharClass.cs
- TabControlAutomationPeer.cs
- ClassDataContract.cs
- SerializationSectionGroup.cs
- ProcessThreadCollection.cs
- DoubleAnimationUsingPath.cs
- ExtendedProperty.cs
- TableItemProviderWrapper.cs
- DESCryptoServiceProvider.cs
- PipelineComponent.cs
- Package.cs
- MetadataItem.cs
- ProjectionRewriter.cs
- ViewGenerator.cs
- Int32CAMarshaler.cs
- JsonEnumDataContract.cs
- XmlNodeWriter.cs
- AdRotatorDesigner.cs
- CssTextWriter.cs
- SessionEndedEventArgs.cs
- HttpModuleActionCollection.cs
- DoubleLinkListEnumerator.cs
- Transform3DGroup.cs
- QilGenerator.cs
- MergablePropertyAttribute.cs
- SettingsProperty.cs
- OracleDataReader.cs
- _SpnDictionary.cs
- ObjectListTitleAttribute.cs
- sqlcontext.cs
- ListBoxAutomationPeer.cs
- SessionEndingEventArgs.cs
- CircleHotSpot.cs
- ExpressionNode.cs
- NetSectionGroup.cs
- AvTraceDetails.cs
- HttpWebRequest.cs
- MailAddressCollection.cs
- ZoomPercentageConverter.cs
- DbProviderFactoriesConfigurationHandler.cs
- BitConverter.cs
- FieldTemplateUserControl.cs
- ThousandthOfEmRealPoints.cs
- GlyphRun.cs
- CodeTypeReference.cs
- EventWaitHandle.cs
- PropertyDescriptorGridEntry.cs
- ArgumentValue.cs
- embossbitmapeffect.cs
- DetailsViewUpdateEventArgs.cs
- SqlNamer.cs