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
- AttributeQuery.cs
- DesignerVerb.cs
- MatrixKeyFrameCollection.cs
- CustomAttribute.cs
- SystemFonts.cs
- GridViewDeletedEventArgs.cs
- TagPrefixInfo.cs
- MetadataAssemblyHelper.cs
- CaseStatement.cs
- HelpKeywordAttribute.cs
- DataServiceKeyAttribute.cs
- RtfFormatStack.cs
- Splitter.cs
- XamlInt32CollectionSerializer.cs
- PropertyRef.cs
- BinaryFormatterWriter.cs
- ListViewSelectEventArgs.cs
- EntityDataSourceUtil.cs
- ListViewItemMouseHoverEvent.cs
- ValidatorCollection.cs
- DataKey.cs
- SqlCacheDependencyDatabase.cs
- PropertyChangeTracker.cs
- EntityContainerEmitter.cs
- XmlEventCache.cs
- ValueConversionAttribute.cs
- ControlType.cs
- CharAnimationBase.cs
- IconBitmapDecoder.cs
- XmlEntityReference.cs
- UDPClient.cs
- ProcessDesigner.cs
- DataRecordObjectView.cs
- DefaultProxySection.cs
- SystemNetHelpers.cs
- Point3DCollectionValueSerializer.cs
- EmptyElement.cs
- ButtonFlatAdapter.cs
- TextEditorCharacters.cs
- Converter.cs
- DeviceSpecificChoiceCollection.cs
- HelpPage.cs
- ActivityExecutionFilter.cs
- TypeDependencyAttribute.cs
- SqlDataReaderSmi.cs
- BamlResourceSerializer.cs
- FullTextBreakpoint.cs
- RootBrowserWindow.cs
- TrackBar.cs
- WrappedIUnknown.cs
- WebPartActionVerb.cs
- TypeConverterHelper.cs
- DataGridViewCellStyleContentChangedEventArgs.cs
- ACE.cs
- MultiTrigger.cs
- RepeaterCommandEventArgs.cs
- ScrollChangedEventArgs.cs
- DBConnection.cs
- PagedDataSource.cs
- DockPattern.cs
- ShaderEffect.cs
- EventLogRecord.cs
- ToolbarAUtomationPeer.cs
- PaginationProgressEventArgs.cs
- EllipseGeometry.cs
- CompiledQuery.cs
- FileSystemWatcher.cs
- XamlHostingSection.cs
- StringFreezingAttribute.cs
- ConfigurationLoader.cs
- DesignerAutoFormatCollection.cs
- InternalTypeHelper.cs
- BamlRecordWriter.cs
- ModelPropertyCollectionImpl.cs
- InitializationEventAttribute.cs
- XmlSchemaElement.cs
- safex509handles.cs
- CodeTypeReference.cs
- SharedDp.cs
- AgileSafeNativeMemoryHandle.cs
- DrawingCollection.cs
- SiteMapHierarchicalDataSourceView.cs
- ClassDataContract.cs
- OrderByExpression.cs
- SortedList.cs
- ModelService.cs
- SingleAnimation.cs
- BatchServiceHost.cs
- ExceptionHelpers.cs
- InvalidAsynchronousStateException.cs
- SQLRoleProvider.cs
- FontSizeConverter.cs
- IntegerFacetDescriptionElement.cs
- CursorConverter.cs
- CellParagraph.cs
- WSSecurityJan2004.cs
- SqlDataSourceCache.cs
- UInt64Storage.cs
- NullableConverter.cs
- XmlILTrace.cs