Code:
/ 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / cdf / src / NetFx40 / System.ServiceModel.Activities / System / ServiceModel / Activities / WorkflowOperationContext.cs / 1407647 / WorkflowOperationContext.cs
//------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//-----------------------------------------------------------
namespace System.ServiceModel.Activities
{
using System.Activities;
using System.Collections.Generic;
using System.Diagnostics;
using System.Runtime;
using System.Runtime.Diagnostics;
using System.Security;
using System.ServiceModel.Activation;
using System.ServiceModel.Activities.Description;
using System.ServiceModel.Activities.Dispatcher;
using System.ServiceModel.Channels;
using System.ServiceModel.Diagnostics;
using System.ServiceModel.Dispatcher;
using System.Transactions;
using TD2 = System.ServiceModel.Diagnostics.Application.TD;
// This AsyncResult completion is very tricky. It can complete in two path.
// FastPath: When workflow executes synchronously(SendFault/SendReply called before ResumeBookmark completes) we complete the AsyncResult at HandleEndResumeBookmark;
// Async Path: If workflow goes async (SendFault/SendReply called after ResumeBookmark completes) we complete the AsyncResult at SendFault/SendReply.
class WorkflowOperationContext : AsyncResult
{
static readonly ReadOnlyDictionary emptyDictionary = new ReadOnlyDictionary(new Dictionary(), false);
static readonly object[] emptyObjectArray = new object[0];
static AsyncCompletion handleEndResumeBookmark = new AsyncCompletion(HandleEndResumeBookmark);
static AsyncCompletion handleEndWaitForPendingOperations = new AsyncCompletion(HandleEndWaitForPendingOperations);
static AsyncCompletion handleEndProcessReceiveContext;
static Action onCompleting = new Action(Finally);
object[] inputs;
string operationName;
object[] outputs;
object operationReturnValue;
object thisLock;
WorkflowServiceInstance workflowInstance;
Bookmark bookmark;
object bookmarkValue;
BookmarkScope bookmarkScope;
IInvokeReceivedNotification notification;
IAsyncResult pendingAsyncResult;
TimeoutHelper timeoutHelper;
Exception pendingException;
ReceiveContext receiveContext;
// perf counter data
bool performanceCountersEnabled;
long beginTime;
// tracing data
bool propagateActivity;
Guid ambientActivityId;
Guid e2eActivityId;
long beginOperation;
//Tracking for decrement of ASP.NET busy count
bool hasDecrementedBusyCount;
WorkflowOperationContext(object[] inputs, OperationContext operationContext, string operationName,
bool performanceCountersEnabled, bool propagateActivity, Transaction currentTransaction,
WorkflowServiceInstance workflowInstance, IInvokeReceivedNotification notification, WorkflowOperationBehavior behavior,
TimeSpan timeout, AsyncCallback callback, object state)
: base(callback, state)
{
this.inputs = inputs;
this.operationName = operationName;
this.OperationContext = operationContext;
this.CurrentTransaction = currentTransaction;
this.performanceCountersEnabled = performanceCountersEnabled;
this.propagateActivity = propagateActivity;
this.timeoutHelper = new TimeoutHelper(timeout);
this.workflowInstance = workflowInstance;
this.thisLock = new object();
this.notification = notification;
this.OnCompleting = onCompleting;
// Resolve bookmark
Fx.Assert(behavior != null, "behavior must not be null!");
this.bookmark = behavior.OnResolveBookmark(this, out this.bookmarkScope, out this.bookmarkValue);
Fx.Assert(this.bookmark != null, "bookmark must not be null!");
bool completeSelf = false;
try
{
// set activity ID on the executing thread (Bug 113386)
if (TraceUtility.MessageFlowTracingOnly)
{
this.e2eActivityId = TraceUtility.GetReceivedActivityId(this.OperationContext);
DiagnosticTrace.ActivityId = this.e2eActivityId;
}
// Take ownership of the ReceiveContext when buffering is enabled by removing the property
if (this.workflowInstance.BufferedReceiveManager != null)
{
if (!ReceiveContext.TryGet(this.OperationContext.IncomingMessageProperties, out this.receiveContext))
{
Fx.Assert("ReceiveContext expected when BufferedReceives are enabled");
}
this.OperationContext.IncomingMessageProperties.Remove(ReceiveContext.Name);
}
completeSelf = ProcessRequest();
}
catch (Exception e)
{
if (Fx.IsFatal(e))
{
throw;
}
// Failing synchronously is one case where AsyncResult won't handle calling OnCompleting
OnCompleting(this, e);
throw;
}
if (completeSelf)
{
base.Complete(true);
}
}
public object[] Inputs
{
get
{
return this.inputs;
}
}
public OperationContext OperationContext
{
get;
private set;
}
public Transaction CurrentTransaction
{
get;
private set;
}
public object BookmarkValue
{
get
{
return this.bookmarkValue;
}
}
public bool HasResponse
{
get
{
lock (this.thisLock)
{
return this.CurrentState == State.Completed || this.CurrentState == State.ResultReceived;
}
}
}
//Completion state of this AsyncResult guarded by propertyLock
State CurrentState
{
get;
set;
}
public Guid E2EActivityId
{
get
{
return this.e2eActivityId;
}
}
public static IAsyncResult BeginProcessRequest(WorkflowServiceInstance workflowInstance, OperationContext operationContext, string operationName,
object[] inputs, bool performanceCountersEnabled, bool propagateActivity, Transaction currentTransaction, IInvokeReceivedNotification notification,
WorkflowOperationBehavior behavior, TimeSpan timeout, AsyncCallback callback, object state)
{
Fx.Assert(inputs != null, "Null inputs");
return new WorkflowOperationContext(inputs, operationContext, operationName, performanceCountersEnabled,
propagateActivity, currentTransaction, workflowInstance, notification, behavior, timeout, callback, state);
}
public static object EndProcessRequest(IAsyncResult result, out object[] outputs)
{
WorkflowOperationContext thisPtr = AsyncResult.End(result);
outputs = thisPtr.outputs;
return thisPtr.operationReturnValue;
}
public void SendFault(Exception exception)
{
Fx.Assert(exception != null, "Null Exception");
this.pendingException = exception;
bool completeNow;
lock (this.thisLock)
{
Fx.Assert(this.CurrentState != State.Completed && this.CurrentState != State.ResultReceived, "Cannot receive this call after completion/result");
completeNow = ProcessReply();
}
if (completeNow)
{
this.Complete(false, exception);
}
}
public void SendReply(Message returnValue)
{
bool completeNow;
lock (this.thisLock)
{
Fx.Assert(this.CurrentState != State.Completed && this.CurrentState != State.ResultReceived, "Cannot receive this call after completion/result");
this.outputs = WorkflowOperationContext.emptyObjectArray; // everything is in the Message return value for workflow
this.operationReturnValue = returnValue;
completeNow = ProcessReply();
}
if (completeNow)
{
base.Complete(false);
}
}
public void SendReply(object returnValue, object[] outputs)
{
bool completeNow;
lock (this.thisLock)
{
Fx.Assert(this.CurrentState != State.Completed && this.CurrentState != State.ResultReceived, "Cannot receive this call after completion/result");
this.outputs = outputs ?? WorkflowOperationContext.emptyObjectArray;
this.operationReturnValue = returnValue;
completeNow = ProcessReply();
}
if (completeNow)
{
base.Complete(false);
}
}
//No-op for two-ways.
public void SetOperationCompleted()
{
bool completeNow;
lock (this.thisLock)
{
completeNow = ProcessReply();
}
if (completeNow)
{
base.Complete(false);
}
}
bool ProcessReply()
{
bool completed = false;
this.workflowInstance.ReleaseContext(this);
this.RemovePendingOperation();
if (this.CurrentState == State.BookmarkResumption) //We are still in Bookmark Resume
{
this.CurrentState = State.ResultReceived; //HandleEndResumeBookmark will take care of Completing AsyncResult.
}
else if (this.CurrentState == State.WaitForResult) //We already finished the bookmarkOperation; Now have to signal the AsynResult.
{
this.CurrentState = State.Completed;
completed = true;
}
// we are not really completed until the ReceiveContext finishes its work
if (completed)
{
if (this.pendingException == null)
{
completed = ProcessReceiveContext();
}
else
{
// if there's a pendingException, we let the RC abandon async so there's no need
// to affect the completed status
BufferedReceiveManager.AbandonReceiveContext(this.receiveContext);
}
}
return completed;
}
void ProcessInitializationTraces()
{
//Let asp.net know that it needs to wait
IncrementBusyCount();
try
{
if (TraceUtility.MessageFlowTracingOnly)
{
//ensure that Activity ID is set
DiagnosticTrace.ActivityId = this.E2EActivityId;
this.propagateActivity = false;
}
if (TraceUtility.ActivityTracing || (!TraceUtility.MessageFlowTracing && this.propagateActivity))
{
this.e2eActivityId = TraceUtility.GetReceivedActivityId(this.OperationContext);
if ((this.E2EActivityId != Guid.Empty) && (this.E2EActivityId != Trace.CorrelationManager.ActivityId))
{
this.propagateActivity = true;
this.OperationContext.IncomingMessageProperties[MessagingActivityHelper.E2EActivityId] = this.E2EActivityId;
this.ambientActivityId = Trace.CorrelationManager.ActivityId;
FxTrace.Trace.SetAndTraceTransfer(this.E2EActivityId, true);
if (TD.StartSignpostEventIsEnabled())
{
TD.StartSignpostEvent(new DictionaryTraceRecord(new Dictionary(2) {
{ MessagingActivityHelper.ActivityName, MessagingActivityHelper.ActivityNameWorkflowOperationInvoke },
{ MessagingActivityHelper.ActivityType, MessagingActivityHelper.ActivityTypeExecuteUserCode }
}));
}
}
else
{
this.propagateActivity = false;
}
}
}
catch (Exception ex)
{
if(Fx.IsFatal(ex))
{
throw;
}
FxTrace.Exception.AsInformation(ex);
}
}
void DecrementBusyCount()
{
lock (this.thisLock)
{
if (!this.hasDecrementedBusyCount)
{
AspNetEnvironment.Current.DecrementBusyCount();
if (AspNetEnvironment.Current.TraceDecrementBusyCountIsEnabled())
{
AspNetEnvironment.Current.TraceDecrementBusyCount(SR.BusyCountTraceFormatString(this.workflowInstance.Id));
}
this.hasDecrementedBusyCount = true;
}
}
}
void IncrementBusyCount()
{
AspNetEnvironment.Current.IncrementBusyCount();
if (AspNetEnvironment.Current.TraceIncrementBusyCountIsEnabled())
{
AspNetEnvironment.Current.TraceIncrementBusyCount(SR.BusyCountTraceFormatString(this.workflowInstance.Id));
}
}
void EmitTransferFromInstanceId()
{
if (TraceUtility.MessageFlowTracing)
{
//set the WF instance ID as the Activity ID
if (DiagnosticTrace.ActivityId != this.workflowInstance.Id)
{
DiagnosticTrace.ActivityId = this.workflowInstance.Id;
}
FxTrace.Trace.SetAndTraceTransfer(this.E2EActivityId, true);
}
}
void ProcessFinalizationTraces()
{
try
{
if (this.propagateActivity)
{
Guid oldId = Trace.CorrelationManager.ActivityId;
if (TD.StopSignpostEventIsEnabled())
{
TD.StopSignpostEvent(new DictionaryTraceRecord(new Dictionary(2) {
{ MessagingActivityHelper.ActivityName, MessagingActivityHelper.ActivityNameWorkflowOperationInvoke },
{ MessagingActivityHelper.ActivityType, MessagingActivityHelper.ActivityTypeExecuteUserCode }
}));
}
FxTrace.Trace.SetAndTraceTransfer(this.ambientActivityId, true);
this.ambientActivityId = Guid.Empty;
}
}
catch (Exception ex)
{
if (Fx.IsFatal(ex))
{
throw;
}
FxTrace.Exception.AsInformation(ex);
}
DecrementBusyCount();
}
//Perf counter helpers.
void TrackMethodCalled()
{
if (this.performanceCountersEnabled)
{
using (new OperationContextScopeHelper(this.OperationContext))
{
PerformanceCounters.MethodCalled(this.operationName);
}
try
{
if (System.Runtime.Interop.UnsafeNativeMethods.QueryPerformanceCounter(out this.beginTime) == 0)
{
this.beginTime = -1;
}
}
catch (SecurityException securityException)
{
throw FxTrace.Exception.AsError(new SecurityException(SR.PartialTrustPerformanceCounterNotEnabled, securityException));
}
}
if (TD2.OperationCompletedIsEnabled() ||
TD2.OperationFaultedIsEnabled() ||
TD2.OperationFailedIsEnabled())
{
this.beginOperation = DateTime.UtcNow.Ticks;
}
if (TD2.OperationInvokedIsEnabled())
{
using (new OperationContextScopeHelper(this.OperationContext))
{
TD2.OperationInvoked(this.operationName, TraceUtility.GetCallerInfo(this.OperationContext));
}
}
}
void TrackMethodFaulted()
{
if (this.performanceCountersEnabled)
{
long duration = this.GetDuration();
using (new OperationContextScopeHelper(this.OperationContext))
{
PerformanceCounters.MethodReturnedFault(this.operationName, duration);
}
}
if (TD2.OperationFaultedIsEnabled())
{
using (new OperationContextScopeHelper(this.OperationContext))
{
TD2.OperationFaulted(this.operationName,
TraceUtility.GetUtcBasedDurationForTrace(this.beginOperation));
}
}
}
void TrackMethodFailed()
{
if (this.performanceCountersEnabled)
{
long duration = this.GetDuration();
using (new OperationContextScopeHelper(this.OperationContext))
{
PerformanceCounters.MethodReturnedError(this.operationName, duration);
}
}
if (TD2.OperationFailedIsEnabled())
{
using (new OperationContextScopeHelper(this.OperationContext))
{
TD2.OperationFailed(this.operationName,
TraceUtility.GetUtcBasedDurationForTrace(this.beginOperation));
}
}
}
long GetDuration()
{
long currentTime = 0;
long duration = 0;
if ((this.beginTime >= 0) &&
(System.Runtime.Interop.UnsafeNativeMethods.QueryPerformanceCounter(out currentTime) != 0))
{
duration = currentTime - this.beginTime;
}
return duration;
}
void TrackMethodSucceeded()
{
if (this.performanceCountersEnabled)
{
long duration = this.GetDuration();
using (new OperationContextScopeHelper(this.OperationContext))
{
PerformanceCounters.MethodReturnedSuccess(this.operationName, duration);
}
}
if (TD2.OperationCompletedIsEnabled())
{
using (new OperationContextScopeHelper(this.OperationContext))
{
TD2.OperationCompleted(this.operationName,
TraceUtility.GetUtcBasedDurationForTrace(this.beginOperation));
}
}
}
void TrackMethodCompleted(object returnValue)
{
// WorkflowOperationInvoker always deals at the Message/Message level
Message faultMessage = returnValue as Message;
if (faultMessage != null && faultMessage.IsFault)
{
TrackMethodFaulted();
}
else
{
TrackMethodSucceeded();
}
}
bool ProcessRequest()
{
this.TrackMethodCalled();
this.ProcessInitializationTraces();
if (this.notification == null)
{
return OnResumeBookmark();
}
string sessionId = this.OperationContext.SessionId;
if (sessionId == null)
{
return OnResumeBookmark();
}
// if there is a session, queue up this request in the per session pending request queue before notifying
// the dispatcher to start the next invoke
IAsyncResult pendingAsyncResult = this.workflowInstance.BeginWaitForPendingOperations(sessionId, this.timeoutHelper.RemainingTime(), this.PrepareAsyncCompletion(handleEndWaitForPendingOperations), this);
bool completed;
this.notification.NotifyInvokeReceived();
if (pendingAsyncResult.CompletedSynchronously)
{
completed = HandleEndWaitForPendingOperations(pendingAsyncResult);
}
else
{
completed = false;
}
return completed;
}
void RemovePendingOperation()
{
if (this.pendingAsyncResult != null)
{
this.workflowInstance.RemovePendingOperation(this.OperationContext.SessionId, this.pendingAsyncResult);
this.pendingAsyncResult = null;
}
}
static bool HandleEndWaitForPendingOperations(IAsyncResult result)
{
WorkflowOperationContext thisPtr = (WorkflowOperationContext)result.AsyncState;
thisPtr.pendingAsyncResult = result;
bool success = false;
try
{
thisPtr.workflowInstance.EndWaitForPendingOperations(result);
bool retval = thisPtr.OnResumeBookmark();
success = true;
return retval;
}
finally
{
if (!success)
{
thisPtr.RemovePendingOperation();
}
}
}
bool OnResumeBookmark()
{
bool success = false;
try
{
IAsyncResult nextResult = this.workflowInstance.BeginResumeProtocolBookmark(
this.bookmark, this.bookmarkScope, this,
this.timeoutHelper.RemainingTime(), this.PrepareAsyncCompletion(handleEndResumeBookmark), this);
bool completed;
if (nextResult.CompletedSynchronously)
{
completed = HandleEndResumeBookmark(nextResult);
}
else
{
completed = false;
}
success = true;
return completed;
}
finally
{
if (!success)
{
this.RemovePendingOperation();
}
}
}
static bool HandleEndResumeBookmark(IAsyncResult result)
{
WorkflowOperationContext thisPtr = (WorkflowOperationContext)result.AsyncState;
bool completed = false;
bool shouldAbandon = true;
try
{
BookmarkResumptionResult resumptionResult = thisPtr.workflowInstance.EndResumeProtocolBookmark(result);
if (resumptionResult != BookmarkResumptionResult.Success)
{
// Raise UnkownMessageReceivedEvent when we fail to resume bookmark
thisPtr.OperationContext.Host.RaiseUnknownMessageReceived(thisPtr.OperationContext.IncomingMessage);
// Only delay-retry this operation once (and only if retries are supported). Future calls will ensure the bookmark is set.
if (thisPtr.workflowInstance.BufferedReceiveManager != null)
{
bool bufferSuccess = thisPtr.workflowInstance.BufferedReceiveManager.BufferReceive(
thisPtr.OperationContext, thisPtr.receiveContext, thisPtr.bookmark.Name, BufferedReceiveState.WaitingOnBookmark, false);
if (bufferSuccess)
{
if (TD.BufferOutOfOrderMessageNoBookmarkIsEnabled())
{
TD.BufferOutOfOrderMessageNoBookmark(thisPtr.workflowInstance.Id.ToString(), thisPtr.bookmark.Name);
}
shouldAbandon = false;
}
}
// The throw exception is intentional whether or not BufferedReceiveManager is set.
// This is to allow exception to bubble up the stack to WCF to cleanup various state (like Transaction).
// This is queue scenario and as far as the client is concerned, the client will not see any exception.
throw FxTrace.Exception.AsError(new FaultException(OperationExecutionFault.CreateOperationNotAvailableFault(thisPtr.workflowInstance.Id, thisPtr.bookmark.Name)));
}
lock (thisPtr.thisLock)
{
if (thisPtr.CurrentState == State.ResultReceived)
{
thisPtr.CurrentState = State.Completed;
if (thisPtr.pendingException != null)
{
throw FxTrace.Exception.AsError(thisPtr.pendingException);
}
completed = true;
}
else
{
thisPtr.CurrentState = State.WaitForResult;
completed = false;
}
// we are not really completed until the ReceiveContext finishes its work
if (completed)
{
completed = thisPtr.ProcessReceiveContext();
}
shouldAbandon = false;
}
}
finally
{
if (shouldAbandon)
{
BufferedReceiveManager.AbandonReceiveContext(thisPtr.receiveContext);
}
thisPtr.RemovePendingOperation();
}
return completed;
}
bool ProcessReceiveContext()
{
if (this.receiveContext != null)
{
if (handleEndProcessReceiveContext == null)
{
handleEndProcessReceiveContext = new AsyncCompletion(HandleEndProcessReceiveContext);
}
IAsyncResult nextResult = ReceiveContextAsyncResult.BeginProcessReceiveContext(this, this.receiveContext, PrepareAsyncCompletion(handleEndProcessReceiveContext), this);
return SyncContinue(nextResult);
}
return true;
}
static bool HandleEndProcessReceiveContext(IAsyncResult result)
{
ReceiveContextAsyncResult.EndProcessReceiveContext(result);
return true;
}
static void Finally(AsyncResult result, Exception completionException)
{
WorkflowOperationContext thisPtr = (WorkflowOperationContext)result;
thisPtr.EmitTransferFromInstanceId();
if (completionException != null)
{
if (completionException is FaultException)
{
thisPtr.TrackMethodFaulted();
}
else
{
thisPtr.TrackMethodFailed();
}
}
else
{
thisPtr.TrackMethodCompleted(thisPtr.operationReturnValue);
}
thisPtr.ProcessFinalizationTraces();
// will be a no-op if we were never added to the instance
thisPtr.workflowInstance.ReleaseContext(thisPtr);
thisPtr.RemovePendingOperation();
}
enum State
{
BookmarkResumption,
WaitForResult,
ResultReceived,
Completed
}
class OperationContextScopeHelper : IDisposable
{
OperationContext currentOperationContext;
public OperationContextScopeHelper(OperationContext operationContext)
{
this.currentOperationContext = OperationContext.Current;
OperationContext.Current = operationContext;
}
void IDisposable.Dispose()
{
OperationContext.Current = this.currentOperationContext;
}
}
class ReceiveContextAsyncResult : AsyncResult
{
static AsyncCompletion handleEndComplete = new AsyncCompletion(HandleEndComplete);
WorkflowOperationContext context;
ReceiveContext receiveContext;
ReceiveContextAsyncResult(WorkflowOperationContext context, ReceiveContext receiveContext, AsyncCallback callback, object state)
: base(callback, state)
{
this.context = context;
this.receiveContext = receiveContext;
if (ProcessReceiveContext())
{
base.Complete(true);
}
}
public static IAsyncResult BeginProcessReceiveContext(WorkflowOperationContext context, ReceiveContext receiveContext, AsyncCallback callback, object state)
{
return new ReceiveContextAsyncResult(context, receiveContext, callback, state);
}
public static void EndProcessReceiveContext(IAsyncResult result)
{
ReceiveContextAsyncResult.End(result);
}
public static void End(IAsyncResult result)
{
AsyncResult.End(result);
}
bool ProcessReceiveContext()
{
IAsyncResult result;
using (PrepareTransactionalCall(this.context.CurrentTransaction))
{
if (this.context.CurrentTransaction != null)
{
// make sure we Abandon if the transaction ends up with an outcome of Aborted
this.context.CurrentTransaction.TransactionCompleted += new TransactionCompletedEventHandler(OnTransactionComplete);
}
result = this.receiveContext.BeginComplete(
this.context.timeoutHelper.RemainingTime(), PrepareAsyncCompletion(handleEndComplete), this);
}
return SyncContinue(result);
}
// This happens out-of-band of ReceiveAsyncResult.
// When transaction was aborted, we best-effort abandon the context.
void OnTransactionComplete(object sender, TransactionEventArgs e)
{
if (e.Transaction.TransactionInformation.Status != TransactionStatus.Committed)
{
BufferedReceiveManager.AbandonReceiveContext(this.context.receiveContext);
}
}
static bool HandleEndComplete(IAsyncResult result)
{
ReceiveContextAsyncResult thisPtr = (ReceiveContextAsyncResult)result.AsyncState;
thisPtr.receiveContext.EndComplete(result);
return true;
}
}
}
}
// 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
- SoapIncludeAttribute.cs
- MutexSecurity.cs
- DesignerDataTable.cs
- DataControlImageButton.cs
- CollectionViewProxy.cs
- ErrorEventArgs.cs
- SQLSingleStorage.cs
- XNameConverter.cs
- SourceFileBuildProvider.cs
- LocatorGroup.cs
- basenumberconverter.cs
- ExecutionTracker.cs
- TemplateControlBuildProvider.cs
- TrackingMemoryStreamFactory.cs
- CacheForPrimitiveTypes.cs
- HttpChannelFactory.cs
- ProviderMetadataCachedInformation.cs
- JsonFormatGeneratorStatics.cs
- MarshalByValueComponent.cs
- XmlSerializer.cs
- ReachFixedPageSerializer.cs
- Models.cs
- EventBindingService.cs
- DeferredBinaryDeserializerExtension.cs
- AncillaryOps.cs
- TextElement.cs
- ToolStripOverflow.cs
- InternalsVisibleToAttribute.cs
- ClientSettingsSection.cs
- CompleteWizardStep.cs
- Setter.cs
- ToolStripTextBox.cs
- Select.cs
- FileDialogPermission.cs
- ServiceMetadataContractBehavior.cs
- ConfigViewGenerator.cs
- CreateParams.cs
- Set.cs
- TransactionChannelFaultConverter.cs
- SemaphoreSecurity.cs
- Viewport3DAutomationPeer.cs
- _PooledStream.cs
- MergeEnumerator.cs
- PropertyValueEditor.cs
- XmlSchemaProviderAttribute.cs
- Byte.cs
- Rule.cs
- PriorityChain.cs
- GiveFeedbackEventArgs.cs
- BasicCellRelation.cs
- DataObjectAttribute.cs
- RequestCacheValidator.cs
- DynamicHyperLink.cs
- DesignerSerializerAttribute.cs
- Set.cs
- OrCondition.cs
- WebPartZoneCollection.cs
- oledbmetadatacolumnnames.cs
- FormsAuthenticationEventArgs.cs
- AQNBuilder.cs
- RenderingEventArgs.cs
- RequestReplyCorrelator.cs
- ConfigUtil.cs
- OverloadGroupAttribute.cs
- Stacktrace.cs
- FilterEventArgs.cs
- DataGridViewToolTip.cs
- CqlParserHelpers.cs
- TextServicesLoader.cs
- OutgoingWebRequestContext.cs
- DataViewSetting.cs
- DirectionalLight.cs
- SamlAssertionDirectKeyIdentifierClause.cs
- TextCompositionManager.cs
- SiteMapSection.cs
- WarningException.cs
- OdbcParameterCollection.cs
- BaseValidator.cs
- ResizeGrip.cs
- SQLMoneyStorage.cs
- DbException.cs
- ScrollBar.cs
- SequenceNumber.cs
- Keywords.cs
- ACL.cs
- Propagator.Evaluator.cs
- WebRequestModuleElement.cs
- SwitchElementsCollection.cs
- DataGridViewCellStyleConverter.cs
- OverflowException.cs
- CaseInsensitiveHashCodeProvider.cs
- DynamicMethod.cs
- DataKey.cs
- SafeBitVector32.cs
- SecurityRuntime.cs
- QuaternionAnimationBase.cs
- MouseGesture.cs
- WebPartCancelEventArgs.cs
- ResourceManagerWrapper.cs
- DataGridViewRowHeightInfoPushedEventArgs.cs