Code:
/ 4.0 / 4.0 / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / cdf / src / WF / Activities / Rules / ConditionChanges.cs / 1305376 / ConditionChanges.cs
using System;
using System.Collections;
using System.Collections.Specialized;
using System.Collections.Generic;
using System.ComponentModel;
using System.ComponentModel.Design;
using System.ComponentModel.Design.Serialization;
using System.Diagnostics;
using System.Globalization;
using System.Workflow.ComponentModel;
using System.Workflow.ComponentModel.Design;
using System.Workflow.ComponentModel.Compiler;
using System.Workflow.ComponentModel.Serialization;
namespace System.Workflow.Activities.Rules
{
#region ConditionChangeAction
[DesignerSerializer(typeof(WorkflowMarkupSerializer), typeof(WorkflowMarkupSerializer))]
public abstract class RuleConditionChangeAction : WorkflowChangeAction
{
public abstract string ConditionName { get; }
protected override ValidationErrorCollection ValidateChanges(Activity activity)
{
// No validations required.
return new ValidationErrorCollection();
}
}
#endregion
#region RuleSetChangeAction
[DesignerSerializer(typeof(WorkflowMarkupSerializer), typeof(WorkflowMarkupSerializer))]
public abstract class RuleSetChangeAction : WorkflowChangeAction
{
public abstract string RuleSetName { get; }
protected override ValidationErrorCollection ValidateChanges(Activity activity)
{
// No validations can be done since we don't know the context the policy
// will execute in (i.e. no idea what the "this" object will be)
return new ValidationErrorCollection();
}
}
#endregion
#region AddedConditionAction
public sealed class AddedConditionAction : RuleConditionChangeAction
{
private RuleCondition _conditionDefinition;
public AddedConditionAction(RuleCondition addedConditionDefinition)
{
if (null == addedConditionDefinition)
throw new ArgumentNullException("addedConditionDefinition");
_conditionDefinition = addedConditionDefinition;
}
public AddedConditionAction()
{
}
public override string ConditionName
{
get { return _conditionDefinition.Name; }
}
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
public RuleCondition ConditionDefinition
{
get
{
return this._conditionDefinition;
}
set
{
if (null == value)
throw new ArgumentNullException("value");
this._conditionDefinition = value;
}
}
protected override bool ApplyTo(Activity rootActivity)
{
if (rootActivity == null)
return false;
RuleDefinitions rules = rootActivity.GetValue(RuleDefinitions.RuleDefinitionsProperty) as RuleDefinitions;
if (rules == null)
{
rules = new RuleDefinitions();
((Activity)rootActivity).SetValue(RuleDefinitions.RuleDefinitionsProperty, rules);
}
//
bool setRuntimeMode = false;
if (rules.Conditions.RuntimeMode)
{
rules.Conditions.RuntimeMode = false;
setRuntimeMode = true;
}
try
{
rules.Conditions.Add(this.ConditionDefinition);
}
finally
{
if(setRuntimeMode)
rules.Conditions.RuntimeMode = true;
}
return true;
}
}
#endregion
#region RemovedConditionAction
public sealed class RemovedConditionAction : RuleConditionChangeAction
{
private RuleCondition _conditionDefinition;
public RemovedConditionAction(RuleCondition removedConditionDefinition)
{
if (null == removedConditionDefinition)
throw new ArgumentNullException("removedConditionDefinition");
_conditionDefinition = removedConditionDefinition;
}
public RemovedConditionAction()
{
}
public override string ConditionName
{
get { return _conditionDefinition.Name; }
}
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
public RuleCondition ConditionDefinition
{
get
{
return this._conditionDefinition;
}
set
{
if (null == value)
throw new ArgumentNullException("value");
this._conditionDefinition = value;
}
}
protected override bool ApplyTo(Activity rootActivity)
{
if (rootActivity == null)
return false;
RuleDefinitions rules = rootActivity.GetValue(RuleDefinitions.RuleDefinitionsProperty) as RuleDefinitions;
if (rules == null || rules.Conditions == null)
return false;
//
bool setRuntimeMode = false;
if (rules.Conditions.RuntimeMode)
{
rules.Conditions.RuntimeMode = false;
setRuntimeMode = true;
}
try
{
return rules.Conditions.Remove(this.ConditionDefinition.Name);
}
finally
{
if(setRuntimeMode)
rules.Conditions.RuntimeMode = true;
}
}
}
#endregion
#region UpdatedConditionAction
public sealed class UpdatedConditionAction : RuleConditionChangeAction
{
private RuleCondition _conditionDefinition;
private RuleCondition _newConditionDefinition;
public UpdatedConditionAction(RuleCondition conditionDefinition, RuleCondition newConditionDefinition)
{
if (null == conditionDefinition)
throw new ArgumentNullException("conditionDefinition");
if (null == newConditionDefinition)
throw new ArgumentNullException("newConditionDefinition");
if (newConditionDefinition.Name != conditionDefinition.Name)
{
string message = string.Format(CultureInfo.CurrentCulture, Messages.ConditionNameNotIdentical, newConditionDefinition.Name, conditionDefinition.Name);
throw new ArgumentException(message);
}
_conditionDefinition = conditionDefinition;
_newConditionDefinition = newConditionDefinition;
}
public UpdatedConditionAction()
{
}
public override string ConditionName
{
get { return _conditionDefinition.Name; }
}
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
public RuleCondition ConditionDefinition
{
get
{
return this._conditionDefinition;
}
set
{
if (null == value)
throw new ArgumentNullException("value");
this._conditionDefinition = value;
}
}
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
public RuleCondition NewConditionDefinition
{
get
{
return this._newConditionDefinition;
}
set
{
if (null == value)
throw new ArgumentNullException("value");
this._newConditionDefinition = value;
}
}
protected override bool ApplyTo(Activity rootActivity)
{
if (rootActivity == null)
return false;
RuleDefinitions rules = rootActivity.GetValue(RuleDefinitions.RuleDefinitionsProperty) as RuleDefinitions;
if (rules == null || rules.Conditions == null)
return false;
if (rules.Conditions[this.ConditionDefinition.Name] == null)
return false;
//
bool setRuntimeMode = false;
if (rules.Conditions.RuntimeMode)
{
rules.Conditions.RuntimeMode = false;
setRuntimeMode = true;
}
try
{
rules.Conditions.Remove(this.ConditionDefinition.Name);
rules.Conditions.Add(this.NewConditionDefinition);
}
finally
{
if(setRuntimeMode)
rules.Conditions.RuntimeMode = true;
}
return true;
}
}
#endregion
#region AddedRuleSetAction
public sealed class AddedRuleSetAction : RuleSetChangeAction
{
private RuleSet ruleset;
public AddedRuleSetAction(RuleSet addedRuleSetDefinition)
{
if (addedRuleSetDefinition == null)
throw new ArgumentNullException("addedRuleSetDefinition");
ruleset = addedRuleSetDefinition;
}
public AddedRuleSetAction()
{
}
public override string RuleSetName
{
get { return ruleset.Name; }
}
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
public RuleSet RuleSetDefinition
{
get { return ruleset; }
set
{
if (null == value)
throw new ArgumentNullException("value");
ruleset = value;
}
}
protected override bool ApplyTo(Activity rootActivity)
{
if (rootActivity == null)
return false;
RuleDefinitions rules = rootActivity.GetValue(RuleDefinitions.RuleDefinitionsProperty) as RuleDefinitions;
if (rules == null)
{
rules = new RuleDefinitions();
((Activity)rootActivity).SetValue(RuleDefinitions.RuleDefinitionsProperty, rules);
}
//
bool setRuntimeMode = false;
if (rules.RuleSets.RuntimeMode)
{
rules.RuleSets.RuntimeMode = false;
setRuntimeMode = true;
}
try
{
rules.RuleSets.Add(ruleset);
}
finally
{
if(setRuntimeMode)
rules.RuleSets.RuntimeMode = true;
}
return true;
}
}
#endregion
#region RemovedRuleSetAction
public sealed class RemovedRuleSetAction : RuleSetChangeAction
{
private RuleSet ruleset;
public RemovedRuleSetAction(RuleSet removedRuleSetDefinition)
{
if (removedRuleSetDefinition == null)
throw new ArgumentNullException("removedRuleSetDefinition");
ruleset = removedRuleSetDefinition;
}
public RemovedRuleSetAction()
{
}
public override string RuleSetName
{
get { return ruleset.Name; }
}
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
public RuleSet RuleSetDefinition
{
get { return ruleset; }
set
{
if (null == value)
throw new ArgumentNullException("value");
ruleset = value;
}
}
protected override bool ApplyTo(Activity rootActivity)
{
if (rootActivity == null)
return false;
RuleDefinitions rules = rootActivity.GetValue(RuleDefinitions.RuleDefinitionsProperty) as RuleDefinitions;
if (rules == null || rules.RuleSets == null)
return false;
//
bool setRuntimeMode = false;
if (rules.RuleSets.RuntimeMode)
{
rules.RuleSets.RuntimeMode = false;
setRuntimeMode = true;
}
try
{
return rules.RuleSets.Remove(ruleset.Name);
}
finally
{
if(setRuntimeMode)
rules.RuleSets.RuntimeMode = true;
}
}
}
#endregion
#region UpdatedRuleSetAction
public sealed class UpdatedRuleSetAction : RuleSetChangeAction
{
private RuleSet original;
private RuleSet updated;
public UpdatedRuleSetAction(RuleSet originalRuleSetDefinition, RuleSet updatedRuleSetDefinition)
{
if (originalRuleSetDefinition == null)
throw new ArgumentNullException("originalRuleSetDefinition");
if (updatedRuleSetDefinition == null)
throw new ArgumentNullException("updatedRuleSetDefinition");
if (originalRuleSetDefinition.Name != updatedRuleSetDefinition.Name)
{
string message = string.Format(CultureInfo.CurrentCulture, Messages.ConditionNameNotIdentical, originalRuleSetDefinition.Name, updatedRuleSetDefinition.Name);
throw new ArgumentException(message);
}
original = originalRuleSetDefinition;
updated = updatedRuleSetDefinition;
}
public UpdatedRuleSetAction()
{
}
public override string RuleSetName
{
get { return original.Name; }
}
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
public RuleSet OriginalRuleSetDefinition
{
get { return original; }
set
{
if (null == value)
throw new ArgumentNullException("value");
original = value;
}
}
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
public RuleSet UpdatedRuleSetDefinition
{
get { return updated; }
set
{
if (null == value)
throw new ArgumentNullException("value");
updated = value;
}
}
protected override bool ApplyTo(Activity rootActivity)
{
if (rootActivity == null)
return false;
RuleDefinitions rules = rootActivity.GetValue(RuleDefinitions.RuleDefinitionsProperty) as RuleDefinitions;
if (rules == null || rules.RuleSets == null)
return false;
if (rules.RuleSets[RuleSetName] == null)
return false;
//
bool setRuntimeMode = false;
if (rules.Conditions.RuntimeMode)
{
rules.Conditions.RuntimeMode = false;
setRuntimeMode = true;
}
try
{
rules.RuleSets.Remove(RuleSetName);
rules.RuleSets.Add(updated);
}
finally
{
if(setRuntimeMode)
rules.RuleSets.RuntimeMode = true;
}
return true;
}
}
#endregion
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
using System;
using System.Collections;
using System.Collections.Specialized;
using System.Collections.Generic;
using System.ComponentModel;
using System.ComponentModel.Design;
using System.ComponentModel.Design.Serialization;
using System.Diagnostics;
using System.Globalization;
using System.Workflow.ComponentModel;
using System.Workflow.ComponentModel.Design;
using System.Workflow.ComponentModel.Compiler;
using System.Workflow.ComponentModel.Serialization;
namespace System.Workflow.Activities.Rules
{
#region ConditionChangeAction
[DesignerSerializer(typeof(WorkflowMarkupSerializer), typeof(WorkflowMarkupSerializer))]
public abstract class RuleConditionChangeAction : WorkflowChangeAction
{
public abstract string ConditionName { get; }
protected override ValidationErrorCollection ValidateChanges(Activity activity)
{
// No validations required.
return new ValidationErrorCollection();
}
}
#endregion
#region RuleSetChangeAction
[DesignerSerializer(typeof(WorkflowMarkupSerializer), typeof(WorkflowMarkupSerializer))]
public abstract class RuleSetChangeAction : WorkflowChangeAction
{
public abstract string RuleSetName { get; }
protected override ValidationErrorCollection ValidateChanges(Activity activity)
{
// No validations can be done since we don't know the context the policy
// will execute in (i.e. no idea what the "this" object will be)
return new ValidationErrorCollection();
}
}
#endregion
#region AddedConditionAction
public sealed class AddedConditionAction : RuleConditionChangeAction
{
private RuleCondition _conditionDefinition;
public AddedConditionAction(RuleCondition addedConditionDefinition)
{
if (null == addedConditionDefinition)
throw new ArgumentNullException("addedConditionDefinition");
_conditionDefinition = addedConditionDefinition;
}
public AddedConditionAction()
{
}
public override string ConditionName
{
get { return _conditionDefinition.Name; }
}
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
public RuleCondition ConditionDefinition
{
get
{
return this._conditionDefinition;
}
set
{
if (null == value)
throw new ArgumentNullException("value");
this._conditionDefinition = value;
}
}
protected override bool ApplyTo(Activity rootActivity)
{
if (rootActivity == null)
return false;
RuleDefinitions rules = rootActivity.GetValue(RuleDefinitions.RuleDefinitionsProperty) as RuleDefinitions;
if (rules == null)
{
rules = new RuleDefinitions();
((Activity)rootActivity).SetValue(RuleDefinitions.RuleDefinitionsProperty, rules);
}
//
bool setRuntimeMode = false;
if (rules.Conditions.RuntimeMode)
{
rules.Conditions.RuntimeMode = false;
setRuntimeMode = true;
}
try
{
rules.Conditions.Add(this.ConditionDefinition);
}
finally
{
if(setRuntimeMode)
rules.Conditions.RuntimeMode = true;
}
return true;
}
}
#endregion
#region RemovedConditionAction
public sealed class RemovedConditionAction : RuleConditionChangeAction
{
private RuleCondition _conditionDefinition;
public RemovedConditionAction(RuleCondition removedConditionDefinition)
{
if (null == removedConditionDefinition)
throw new ArgumentNullException("removedConditionDefinition");
_conditionDefinition = removedConditionDefinition;
}
public RemovedConditionAction()
{
}
public override string ConditionName
{
get { return _conditionDefinition.Name; }
}
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
public RuleCondition ConditionDefinition
{
get
{
return this._conditionDefinition;
}
set
{
if (null == value)
throw new ArgumentNullException("value");
this._conditionDefinition = value;
}
}
protected override bool ApplyTo(Activity rootActivity)
{
if (rootActivity == null)
return false;
RuleDefinitions rules = rootActivity.GetValue(RuleDefinitions.RuleDefinitionsProperty) as RuleDefinitions;
if (rules == null || rules.Conditions == null)
return false;
//
bool setRuntimeMode = false;
if (rules.Conditions.RuntimeMode)
{
rules.Conditions.RuntimeMode = false;
setRuntimeMode = true;
}
try
{
return rules.Conditions.Remove(this.ConditionDefinition.Name);
}
finally
{
if(setRuntimeMode)
rules.Conditions.RuntimeMode = true;
}
}
}
#endregion
#region UpdatedConditionAction
public sealed class UpdatedConditionAction : RuleConditionChangeAction
{
private RuleCondition _conditionDefinition;
private RuleCondition _newConditionDefinition;
public UpdatedConditionAction(RuleCondition conditionDefinition, RuleCondition newConditionDefinition)
{
if (null == conditionDefinition)
throw new ArgumentNullException("conditionDefinition");
if (null == newConditionDefinition)
throw new ArgumentNullException("newConditionDefinition");
if (newConditionDefinition.Name != conditionDefinition.Name)
{
string message = string.Format(CultureInfo.CurrentCulture, Messages.ConditionNameNotIdentical, newConditionDefinition.Name, conditionDefinition.Name);
throw new ArgumentException(message);
}
_conditionDefinition = conditionDefinition;
_newConditionDefinition = newConditionDefinition;
}
public UpdatedConditionAction()
{
}
public override string ConditionName
{
get { return _conditionDefinition.Name; }
}
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
public RuleCondition ConditionDefinition
{
get
{
return this._conditionDefinition;
}
set
{
if (null == value)
throw new ArgumentNullException("value");
this._conditionDefinition = value;
}
}
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
public RuleCondition NewConditionDefinition
{
get
{
return this._newConditionDefinition;
}
set
{
if (null == value)
throw new ArgumentNullException("value");
this._newConditionDefinition = value;
}
}
protected override bool ApplyTo(Activity rootActivity)
{
if (rootActivity == null)
return false;
RuleDefinitions rules = rootActivity.GetValue(RuleDefinitions.RuleDefinitionsProperty) as RuleDefinitions;
if (rules == null || rules.Conditions == null)
return false;
if (rules.Conditions[this.ConditionDefinition.Name] == null)
return false;
//
bool setRuntimeMode = false;
if (rules.Conditions.RuntimeMode)
{
rules.Conditions.RuntimeMode = false;
setRuntimeMode = true;
}
try
{
rules.Conditions.Remove(this.ConditionDefinition.Name);
rules.Conditions.Add(this.NewConditionDefinition);
}
finally
{
if(setRuntimeMode)
rules.Conditions.RuntimeMode = true;
}
return true;
}
}
#endregion
#region AddedRuleSetAction
public sealed class AddedRuleSetAction : RuleSetChangeAction
{
private RuleSet ruleset;
public AddedRuleSetAction(RuleSet addedRuleSetDefinition)
{
if (addedRuleSetDefinition == null)
throw new ArgumentNullException("addedRuleSetDefinition");
ruleset = addedRuleSetDefinition;
}
public AddedRuleSetAction()
{
}
public override string RuleSetName
{
get { return ruleset.Name; }
}
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
public RuleSet RuleSetDefinition
{
get { return ruleset; }
set
{
if (null == value)
throw new ArgumentNullException("value");
ruleset = value;
}
}
protected override bool ApplyTo(Activity rootActivity)
{
if (rootActivity == null)
return false;
RuleDefinitions rules = rootActivity.GetValue(RuleDefinitions.RuleDefinitionsProperty) as RuleDefinitions;
if (rules == null)
{
rules = new RuleDefinitions();
((Activity)rootActivity).SetValue(RuleDefinitions.RuleDefinitionsProperty, rules);
}
//
bool setRuntimeMode = false;
if (rules.RuleSets.RuntimeMode)
{
rules.RuleSets.RuntimeMode = false;
setRuntimeMode = true;
}
try
{
rules.RuleSets.Add(ruleset);
}
finally
{
if(setRuntimeMode)
rules.RuleSets.RuntimeMode = true;
}
return true;
}
}
#endregion
#region RemovedRuleSetAction
public sealed class RemovedRuleSetAction : RuleSetChangeAction
{
private RuleSet ruleset;
public RemovedRuleSetAction(RuleSet removedRuleSetDefinition)
{
if (removedRuleSetDefinition == null)
throw new ArgumentNullException("removedRuleSetDefinition");
ruleset = removedRuleSetDefinition;
}
public RemovedRuleSetAction()
{
}
public override string RuleSetName
{
get { return ruleset.Name; }
}
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
public RuleSet RuleSetDefinition
{
get { return ruleset; }
set
{
if (null == value)
throw new ArgumentNullException("value");
ruleset = value;
}
}
protected override bool ApplyTo(Activity rootActivity)
{
if (rootActivity == null)
return false;
RuleDefinitions rules = rootActivity.GetValue(RuleDefinitions.RuleDefinitionsProperty) as RuleDefinitions;
if (rules == null || rules.RuleSets == null)
return false;
//
bool setRuntimeMode = false;
if (rules.RuleSets.RuntimeMode)
{
rules.RuleSets.RuntimeMode = false;
setRuntimeMode = true;
}
try
{
return rules.RuleSets.Remove(ruleset.Name);
}
finally
{
if(setRuntimeMode)
rules.RuleSets.RuntimeMode = true;
}
}
}
#endregion
#region UpdatedRuleSetAction
public sealed class UpdatedRuleSetAction : RuleSetChangeAction
{
private RuleSet original;
private RuleSet updated;
public UpdatedRuleSetAction(RuleSet originalRuleSetDefinition, RuleSet updatedRuleSetDefinition)
{
if (originalRuleSetDefinition == null)
throw new ArgumentNullException("originalRuleSetDefinition");
if (updatedRuleSetDefinition == null)
throw new ArgumentNullException("updatedRuleSetDefinition");
if (originalRuleSetDefinition.Name != updatedRuleSetDefinition.Name)
{
string message = string.Format(CultureInfo.CurrentCulture, Messages.ConditionNameNotIdentical, originalRuleSetDefinition.Name, updatedRuleSetDefinition.Name);
throw new ArgumentException(message);
}
original = originalRuleSetDefinition;
updated = updatedRuleSetDefinition;
}
public UpdatedRuleSetAction()
{
}
public override string RuleSetName
{
get { return original.Name; }
}
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
public RuleSet OriginalRuleSetDefinition
{
get { return original; }
set
{
if (null == value)
throw new ArgumentNullException("value");
original = value;
}
}
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
public RuleSet UpdatedRuleSetDefinition
{
get { return updated; }
set
{
if (null == value)
throw new ArgumentNullException("value");
updated = value;
}
}
protected override bool ApplyTo(Activity rootActivity)
{
if (rootActivity == null)
return false;
RuleDefinitions rules = rootActivity.GetValue(RuleDefinitions.RuleDefinitionsProperty) as RuleDefinitions;
if (rules == null || rules.RuleSets == null)
return false;
if (rules.RuleSets[RuleSetName] == null)
return false;
//
bool setRuntimeMode = false;
if (rules.Conditions.RuntimeMode)
{
rules.Conditions.RuntimeMode = false;
setRuntimeMode = true;
}
try
{
rules.RuleSets.Remove(RuleSetName);
rules.RuleSets.Add(updated);
}
finally
{
if(setRuntimeMode)
rules.RuleSets.RuntimeMode = true;
}
return true;
}
}
#endregion
}
// 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
- FieldReference.cs
- SqlNodeAnnotations.cs
- UrlMappingsModule.cs
- WebControlAdapter.cs
- TraceRecord.cs
- WebSysDefaultValueAttribute.cs
- TextFormatterImp.cs
- Oid.cs
- WithParamAction.cs
- SessionStateSection.cs
- ToolStripPanel.cs
- DetailsViewCommandEventArgs.cs
- EventData.cs
- ImageListStreamer.cs
- DecoratedNameAttribute.cs
- OdbcUtils.cs
- GatewayDefinition.cs
- SequentialActivityDesigner.cs
- basecomparevalidator.cs
- ScalarOps.cs
- ReflectionServiceProvider.cs
- OpCopier.cs
- TimersDescriptionAttribute.cs
- WorkflowRuntimeElement.cs
- CreateUserWizardStep.cs
- TimeSpanConverter.cs
- RoleGroupCollection.cs
- LinqExpressionNormalizer.cs
- UserThread.cs
- ResourceReferenceKeyNotFoundException.cs
- DiagnosticsElement.cs
- Message.cs
- ButtonField.cs
- SoundPlayerAction.cs
- CompiledQuery.cs
- propertyentry.cs
- CopyOfAction.cs
- SqlClientWrapperSmiStream.cs
- TextBoxView.cs
- SettingsPropertyNotFoundException.cs
- FixedPosition.cs
- WizardStepBase.cs
- FormsAuthenticationTicket.cs
- XPathExpr.cs
- BackStopAuthenticationModule.cs
- SystemEvents.cs
- CompilationUnit.cs
- BeginStoryboard.cs
- LineServicesCallbacks.cs
- TabPage.cs
- TypeGeneratedEventArgs.cs
- PageWrapper.cs
- HandleTable.cs
- PreviewKeyDownEventArgs.cs
- ProfileModule.cs
- TriggerCollection.cs
- DataTrigger.cs
- TextBox.cs
- DynamicValueConverter.cs
- SynchronousChannel.cs
- DesignBindingEditor.cs
- MD5Cng.cs
- CultureSpecificCharacterBufferRange.cs
- MemoryStream.cs
- TagMapCollection.cs
- DataGridViewRowCollection.cs
- SrgsGrammar.cs
- SerializationSectionGroup.cs
- ButtonBase.cs
- BitmapEffectGeneralTransform.cs
- ProtocolViolationException.cs
- SessionSymmetricTransportSecurityProtocolFactory.cs
- HMACSHA384.cs
- XmlResolver.cs
- IdnElement.cs
- UnsafeNativeMethods.cs
- ToolStripMenuItem.cs
- CapabilitiesUse.cs
- ProxyWebPart.cs
- SmtpMail.cs
- ContextMarshalException.cs
- CurrentChangedEventManager.cs
- HeaderPanel.cs
- XmlCustomFormatter.cs
- GestureRecognizer.cs
- HostedHttpRequestAsyncResult.cs
- RuleElement.cs
- CopyAction.cs
- X509RawDataKeyIdentifierClause.cs
- ProtectedConfigurationProviderCollection.cs
- _BufferOffsetSize.cs
- ToolStripOverflowButton.cs
- SqlDataSourceConfigureSortForm.cs
- RootDesignerSerializerAttribute.cs
- XmlChildNodes.cs
- DashStyles.cs
- Rfc2898DeriveBytes.cs
- ViewCellSlot.cs
- TextStore.cs
- SlipBehavior.cs