Code:
/ Dotnetfx_Win7_3.5.1 / Dotnetfx_Win7_3.5.1 / 3.5.1 / DEVDIV / depot / DevDiv / releases / Orcas / NetFXw7 / wpf / src / Core / CSharp / System / Windows / Duration.cs / 1 / Duration.cs
//------------------------------------------------------------------------------
// Microsoft Windows Client Platform
// Copyright (c) Microsoft Corporation, 2004
//
// File: Duration.cs
//-----------------------------------------------------------------------------
// Allow suppression of certain presharp messages
#pragma warning disable 1634, 1691
using System.ComponentModel;
using SR=MS.Internal.PresentationCore.SR;
using SRID=MS.Internal.PresentationCore.SRID;
namespace System.Windows
{
///
/// Duration struct provides sentinel values that are not included in TimeSpan.
/// This structure may represent a TimeSpan, Automatic, or Forever value.
///
[TypeConverter(typeof(DurationConverter))]
public struct Duration
{
private TimeSpan _timeSpan;
private DurationType _durationType;
///
/// Creates a Duration from a TimeSpan.
///
///
public Duration(TimeSpan timeSpan)
{
if (timeSpan < TimeSpan.Zero)
{
throw new ArgumentException(SR.Get(SRID.Timing_InvalidArgNonNegative), "timeSpan");
}
_durationType = DurationType.TimeSpan;
_timeSpan = timeSpan;
}
#region Operators
//
// Since Duration has two special values, for comparison purposes
// Duration.Forever behaves like Double.PositiveInfinity and
// Duration.Automatic behaves almost entirely like Double.NaN
// Any comparision with Automatic returns false, except for ==.
// Unlike NaN, Automatic == Automatic is true.
//
///
/// Implicitly creates a Duration from a TimeSpan.
///
///
///
/// Adds two Durations together.
///
///
///
/// If both Durations have values then this returns a Duration
/// representing the sum of those two values; otherwise a Duration representing null.
public static Duration operator +(Duration t1, Duration t2)
{
if (t1.HasTimeSpan && t2.HasTimeSpan)
{
return new Duration(t1._timeSpan + t2._timeSpan);
}
else if (t1._durationType != DurationType.Automatic
&& t2._durationType != DurationType.Automatic)
{
// Neither t1 nor t2 are Automatic, so one is Forever
// while the other is Forever or a TimeSpan. Either way
// the sum is Forever.
return Duration.Forever;
}
else
{
// Automatic + anything is Automatic
return Duration.Automatic;
}
}
///
/// Subracts one Duration from another.
///
///
///
/// If both Durations have values then this returns a Duration
/// representing the value of the second subtracted from the first; otherwise a Duration representing null.
public static Duration operator -(Duration t1, Duration t2)
{
if (t1.HasTimeSpan && t2.HasTimeSpan)
{
return new Duration(t1._timeSpan - t2._timeSpan);
}
else if (t1._durationType == DurationType.Forever
&& t2.HasTimeSpan)
{
// The only way for the result to be Forever is
// if t1 is Forever and t2 is a TimeSpan
return Duration.Forever;
}
else
{
// This covers the following conditions:
// Forever - Forever
// TimeSpan - Forever
// TimeSpan - Automatic
// Forever - Automatic
// Automatic - Automatic
// Automatic - Forever
// Automatic - TimeSpan
return Duration.Automatic;
}
}
///
/// Indicates whether two Durations are equal.
///
///
///
/// true if both of the Durations have values and those values are equal or if both
/// Durations represent null; otherwise false.
public static bool operator ==(Duration t1, Duration t2)
{
return t1.Equals(t2);
}
///
/// Indicates whether two Durations are not equal.
///
///
///
/// true if exactly one of t1 and t2 represents a value or if they both represent
/// values and those values are not equal; otherwise false.
public static bool operator !=(Duration t1, Duration t2)
{
return !(t1.Equals(t2));
}
///
/// Indicates whether one Duration is greater than another.
///
///
///
/// true if both t1 and t2 have values and the value of t1
/// is greater than the value of t2; otherwise false. Forever is
/// considered greater than all finite values and any comparison
/// with Automatic returns false.
public static bool operator >(Duration t1, Duration t2)
{
if (t1.HasTimeSpan && t2.HasTimeSpan)
{
return t1._timeSpan > t2._timeSpan;
}
else if (t1.HasTimeSpan && t2._durationType == DurationType.Forever)
{
// TimeSpan > Forever is false;
return false;
}
else if (t1._durationType == DurationType.Forever && t2.HasTimeSpan)
{
// Forever > TimeSpan is true;
return true;
}
else
{
// Cases covered:
// Either t1 or t2 are Automatic,
// or t1 and t2 are both Forever
return false;
}
}
///
/// Indicates whether one Duration is greater than or equal to another.
///
///
///
/// true if both t1 and t2 have values and the value of t1
/// is greater than or equal to the value of t2; otherwise false.
/// Forever is considered greater than all finite values and any
/// comparison with Automatic returns false.
public static bool operator >=(Duration t1, Duration t2)
{
if (t1._durationType == DurationType.Automatic && t2._durationType == DurationType.Automatic)
{
// Automatic == Automatic
return true;
}
else if (t1._durationType == DurationType.Automatic || t2._durationType == DurationType.Automatic)
{
// Automatic compared to anything else is false
return false;
}
else
{
return !(t1 < t2);
}
}
///
/// Indicates whether one Duration is less than another.
///
///
///
/// true if both t1 and t2 have values and the value of t1
/// is less than the value of t2; otherwise false. Forever is
/// considered greater than all finite values and any comparison
/// with Automatic returns false
public static bool operator <(Duration t1, Duration t2)
{
if (t1.HasTimeSpan && t2.HasTimeSpan)
{
return t1._timeSpan < t2._timeSpan;
}
else if (t1.HasTimeSpan && t2._durationType == DurationType.Forever)
{
// TimeSpan < Forever is true;
return true;
}
else if (t1._durationType == DurationType.Forever && t2.HasTimeSpan)
{
// Forever < TimeSpan is true;
return false;
}
else
{
// Cases covered:
// Either t1 or t2 are Automatic,
// or t1 and t2 are both Forever
return false;
}
}
///
/// Indicates whether one Duration is less than or equal to another.
///
///
///
/// true if both t1 and t2 have values and the value of t1
/// is less than or equal to the value of t2; otherwise false.
/// Forever is considered greater than all finite values and any
/// comparison with Automatic returns false.
public static bool operator <=(Duration t1, Duration t2)
{
if (t1._durationType == DurationType.Automatic && t2._durationType == DurationType.Automatic)
{
// Automatic == Automatic
return true;
}
else if (t1._durationType == DurationType.Automatic || t2._durationType == DurationType.Automatic)
{
// Automatic compared to anything else is false
return false;
}
else
{
return !(t1 > t2);
}
}
///
/// Compares one Duration value to another.
///
///
///
///
/// A negative value, zero or a positive value, respectively, if t1 is
/// less than, equal or greater than t2.
///
/// Duration.Automatic is a special case and has the following return values:
///
/// -1 if t1 is Automatic and t2 is not Automatic
/// 0 if t1 and t2 are Automatic
/// 1 if t1 is not Automatic and t2 is Automatic
///
/// This mirrors Double.CompareTo()'s treatment of Double.NaN
///
public static int Compare(Duration t1, Duration t2)
{
if (t1._durationType == DurationType.Automatic)
{
if (t2._durationType == DurationType.Automatic)
{
return 0;
}
else
{
return -1;
}
}
else if (t2._durationType == DurationType.Automatic)
{
return 1;
}
else // Neither are Automatic, do a standard comparison
{
if (t1 < t2)
{
return -1;
}
else if (t1 > t2)
{
return 1;
}
else // Neither is greater than the other
{
return 0;
}
}
}
///
/// Returns the specified instance of Duration.
///
///
/// Returns duration.
public static Duration Plus(Duration duration)
{
return duration;
}
///
/// Returns the specified instance of Duration.
///
///
/// Returns duration.
public static Duration operator +(Duration duration)
{
return duration;
}
#endregion
#region Properties
///
/// Indicates whether this Duration is a TimeSpan value.
///
/// true if this Duration is a TimeSpan value.
public bool HasTimeSpan
{
get
{
return (_durationType == DurationType.TimeSpan);
}
}
///
/// Returns a Duration that represents an Automatic value.
///
/// A Duration that represents an Automatic value.
public static Duration Automatic
{
get
{
Duration duration = new Duration();
duration._durationType = DurationType.Automatic;
return duration;
}
}
///
/// Returns a Duration that represents a Forever value.
///
/// A Duration that represents a Forever value.
public static Duration Forever
{
get
{
Duration duration = new Duration();
duration._durationType = DurationType.Forever;
return duration;
}
}
///
/// Returns the TimeSpan value that this Duration represents.
///
/// The TimeSpan value that this Duration represents.
/// Thrown if this Duration represents null.
public TimeSpan TimeSpan
{
get
{
if (HasTimeSpan)
{
return _timeSpan;
}
else
{
#pragma warning suppress 56503 // Suppress presharp warning: Follows a pattern similar to Nullable.
throw new InvalidOperationException(SR.Get(SRID.Timing_NotTimeSpan, this));
}
}
}
#endregion
#region Methods
///
/// Adds the specified Duration to this instance.
///
///
/// A Duration that represents the value of this instance plus the value of duration.
public Duration Add(Duration duration)
{
return this + duration;
}
///
/// Indicates whether the specified Object is equal to this Duration.
///
///
/// true if value is a Duration and is equal to this instance; otherwise false.
public override bool Equals(Object value)
{
if (value == null)
{
return false;
}
else if (value is Duration)
{
return Equals((Duration)value);
}
else
{
return false;
}
}
///
/// Indicates whether the specified Duration is equal to this Duration.
///
///
/// true if duration is equal to this instance; otherwise false.
public bool Equals(Duration duration)
{
if (HasTimeSpan)
{
if (duration.HasTimeSpan)
{
return _timeSpan == duration._timeSpan;
}
else
{
return false;
}
}
else
{
return _durationType == duration._durationType;
}
}
///
/// Indicates whether the specified Durations are equal.
///
///
///
/// true if t1 equals t2; otherwise false.
public static bool Equals(Duration t1, Duration t2)
{
return t1.Equals(t2);
}
///
/// Returns a hash code for this instance.
///
/// A 32-bit signed integer hash code.
public override int GetHashCode()
{
if (HasTimeSpan)
{
return _timeSpan.GetHashCode();
}
else
{
return _durationType.GetHashCode() + 17;
}
}
///
/// Subtracts the specified Duration from this instance.
///
///
/// A Duration whose value is the result of the value of this instance minus the value of duration.
public Duration Subtract(Duration duration)
{
return this - duration;
}
///
/// Creates a string representation of this Duration.
///
/// A string representation of this Duration.
public override string ToString()
{
if (HasTimeSpan)
{
return TypeDescriptor.GetConverter(_timeSpan).ConvertToString(_timeSpan);
}
else if (_durationType == DurationType.Forever)
{
return "Forever";
}
else // IsAutomatic
{
return "Automatic";
}
}
#endregion
///
/// An enumeration of the different types of Duration behaviors.
///
private enum DurationType
{
Automatic,
TimeSpan,
Forever
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
//------------------------------------------------------------------------------
// Microsoft Windows Client Platform
// Copyright (c) Microsoft Corporation, 2004
//
// File: Duration.cs
//-----------------------------------------------------------------------------
// Allow suppression of certain presharp messages
#pragma warning disable 1634, 1691
using System.ComponentModel;
using SR=MS.Internal.PresentationCore.SR;
using SRID=MS.Internal.PresentationCore.SRID;
namespace System.Windows
{
///
/// Duration struct provides sentinel values that are not included in TimeSpan.
/// This structure may represent a TimeSpan, Automatic, or Forever value.
///
[TypeConverter(typeof(DurationConverter))]
public struct Duration
{
private TimeSpan _timeSpan;
private DurationType _durationType;
///
/// Creates a Duration from a TimeSpan.
///
///
public Duration(TimeSpan timeSpan)
{
if (timeSpan < TimeSpan.Zero)
{
throw new ArgumentException(SR.Get(SRID.Timing_InvalidArgNonNegative), "timeSpan");
}
_durationType = DurationType.TimeSpan;
_timeSpan = timeSpan;
}
#region Operators
//
// Since Duration has two special values, for comparison purposes
// Duration.Forever behaves like Double.PositiveInfinity and
// Duration.Automatic behaves almost entirely like Double.NaN
// Any comparision with Automatic returns false, except for ==.
// Unlike NaN, Automatic == Automatic is true.
//
///
/// Implicitly creates a Duration from a TimeSpan.
///
///
///
/// Adds two Durations together.
///
///
///
/// If both Durations have values then this returns a Duration
/// representing the sum of those two values; otherwise a Duration representing null.
public static Duration operator +(Duration t1, Duration t2)
{
if (t1.HasTimeSpan && t2.HasTimeSpan)
{
return new Duration(t1._timeSpan + t2._timeSpan);
}
else if (t1._durationType != DurationType.Automatic
&& t2._durationType != DurationType.Automatic)
{
// Neither t1 nor t2 are Automatic, so one is Forever
// while the other is Forever or a TimeSpan. Either way
// the sum is Forever.
return Duration.Forever;
}
else
{
// Automatic + anything is Automatic
return Duration.Automatic;
}
}
///
/// Subracts one Duration from another.
///
///
///
/// If both Durations have values then this returns a Duration
/// representing the value of the second subtracted from the first; otherwise a Duration representing null.
public static Duration operator -(Duration t1, Duration t2)
{
if (t1.HasTimeSpan && t2.HasTimeSpan)
{
return new Duration(t1._timeSpan - t2._timeSpan);
}
else if (t1._durationType == DurationType.Forever
&& t2.HasTimeSpan)
{
// The only way for the result to be Forever is
// if t1 is Forever and t2 is a TimeSpan
return Duration.Forever;
}
else
{
// This covers the following conditions:
// Forever - Forever
// TimeSpan - Forever
// TimeSpan - Automatic
// Forever - Automatic
// Automatic - Automatic
// Automatic - Forever
// Automatic - TimeSpan
return Duration.Automatic;
}
}
///
/// Indicates whether two Durations are equal.
///
///
///
/// true if both of the Durations have values and those values are equal or if both
/// Durations represent null; otherwise false.
public static bool operator ==(Duration t1, Duration t2)
{
return t1.Equals(t2);
}
///
/// Indicates whether two Durations are not equal.
///
///
///
/// true if exactly one of t1 and t2 represents a value or if they both represent
/// values and those values are not equal; otherwise false.
public static bool operator !=(Duration t1, Duration t2)
{
return !(t1.Equals(t2));
}
///
/// Indicates whether one Duration is greater than another.
///
///
///
/// true if both t1 and t2 have values and the value of t1
/// is greater than the value of t2; otherwise false. Forever is
/// considered greater than all finite values and any comparison
/// with Automatic returns false.
public static bool operator >(Duration t1, Duration t2)
{
if (t1.HasTimeSpan && t2.HasTimeSpan)
{
return t1._timeSpan > t2._timeSpan;
}
else if (t1.HasTimeSpan && t2._durationType == DurationType.Forever)
{
// TimeSpan > Forever is false;
return false;
}
else if (t1._durationType == DurationType.Forever && t2.HasTimeSpan)
{
// Forever > TimeSpan is true;
return true;
}
else
{
// Cases covered:
// Either t1 or t2 are Automatic,
// or t1 and t2 are both Forever
return false;
}
}
///
/// Indicates whether one Duration is greater than or equal to another.
///
///
///
/// true if both t1 and t2 have values and the value of t1
/// is greater than or equal to the value of t2; otherwise false.
/// Forever is considered greater than all finite values and any
/// comparison with Automatic returns false.
public static bool operator >=(Duration t1, Duration t2)
{
if (t1._durationType == DurationType.Automatic && t2._durationType == DurationType.Automatic)
{
// Automatic == Automatic
return true;
}
else if (t1._durationType == DurationType.Automatic || t2._durationType == DurationType.Automatic)
{
// Automatic compared to anything else is false
return false;
}
else
{
return !(t1 < t2);
}
}
///
/// Indicates whether one Duration is less than another.
///
///
///
/// true if both t1 and t2 have values and the value of t1
/// is less than the value of t2; otherwise false. Forever is
/// considered greater than all finite values and any comparison
/// with Automatic returns false
public static bool operator <(Duration t1, Duration t2)
{
if (t1.HasTimeSpan && t2.HasTimeSpan)
{
return t1._timeSpan < t2._timeSpan;
}
else if (t1.HasTimeSpan && t2._durationType == DurationType.Forever)
{
// TimeSpan < Forever is true;
return true;
}
else if (t1._durationType == DurationType.Forever && t2.HasTimeSpan)
{
// Forever < TimeSpan is true;
return false;
}
else
{
// Cases covered:
// Either t1 or t2 are Automatic,
// or t1 and t2 are both Forever
return false;
}
}
///
/// Indicates whether one Duration is less than or equal to another.
///
///
///
/// true if both t1 and t2 have values and the value of t1
/// is less than or equal to the value of t2; otherwise false.
/// Forever is considered greater than all finite values and any
/// comparison with Automatic returns false.
public static bool operator <=(Duration t1, Duration t2)
{
if (t1._durationType == DurationType.Automatic && t2._durationType == DurationType.Automatic)
{
// Automatic == Automatic
return true;
}
else if (t1._durationType == DurationType.Automatic || t2._durationType == DurationType.Automatic)
{
// Automatic compared to anything else is false
return false;
}
else
{
return !(t1 > t2);
}
}
///
/// Compares one Duration value to another.
///
///
///
///
/// A negative value, zero or a positive value, respectively, if t1 is
/// less than, equal or greater than t2.
///
/// Duration.Automatic is a special case and has the following return values:
///
/// -1 if t1 is Automatic and t2 is not Automatic
/// 0 if t1 and t2 are Automatic
/// 1 if t1 is not Automatic and t2 is Automatic
///
/// This mirrors Double.CompareTo()'s treatment of Double.NaN
///
public static int Compare(Duration t1, Duration t2)
{
if (t1._durationType == DurationType.Automatic)
{
if (t2._durationType == DurationType.Automatic)
{
return 0;
}
else
{
return -1;
}
}
else if (t2._durationType == DurationType.Automatic)
{
return 1;
}
else // Neither are Automatic, do a standard comparison
{
if (t1 < t2)
{
return -1;
}
else if (t1 > t2)
{
return 1;
}
else // Neither is greater than the other
{
return 0;
}
}
}
///
/// Returns the specified instance of Duration.
///
///
/// Returns duration.
public static Duration Plus(Duration duration)
{
return duration;
}
///
/// Returns the specified instance of Duration.
///
///
/// Returns duration.
public static Duration operator +(Duration duration)
{
return duration;
}
#endregion
#region Properties
///
/// Indicates whether this Duration is a TimeSpan value.
///
/// true if this Duration is a TimeSpan value.
public bool HasTimeSpan
{
get
{
return (_durationType == DurationType.TimeSpan);
}
}
///
/// Returns a Duration that represents an Automatic value.
///
/// A Duration that represents an Automatic value.
public static Duration Automatic
{
get
{
Duration duration = new Duration();
duration._durationType = DurationType.Automatic;
return duration;
}
}
///
/// Returns a Duration that represents a Forever value.
///
/// A Duration that represents a Forever value.
public static Duration Forever
{
get
{
Duration duration = new Duration();
duration._durationType = DurationType.Forever;
return duration;
}
}
///
/// Returns the TimeSpan value that this Duration represents.
///
/// The TimeSpan value that this Duration represents.
/// Thrown if this Duration represents null.
public TimeSpan TimeSpan
{
get
{
if (HasTimeSpan)
{
return _timeSpan;
}
else
{
#pragma warning suppress 56503 // Suppress presharp warning: Follows a pattern similar to Nullable.
throw new InvalidOperationException(SR.Get(SRID.Timing_NotTimeSpan, this));
}
}
}
#endregion
#region Methods
///
/// Adds the specified Duration to this instance.
///
///
/// A Duration that represents the value of this instance plus the value of duration.
public Duration Add(Duration duration)
{
return this + duration;
}
///
/// Indicates whether the specified Object is equal to this Duration.
///
///
/// true if value is a Duration and is equal to this instance; otherwise false.
public override bool Equals(Object value)
{
if (value == null)
{
return false;
}
else if (value is Duration)
{
return Equals((Duration)value);
}
else
{
return false;
}
}
///
/// Indicates whether the specified Duration is equal to this Duration.
///
///
/// true if duration is equal to this instance; otherwise false.
public bool Equals(Duration duration)
{
if (HasTimeSpan)
{
if (duration.HasTimeSpan)
{
return _timeSpan == duration._timeSpan;
}
else
{
return false;
}
}
else
{
return _durationType == duration._durationType;
}
}
///
/// Indicates whether the specified Durations are equal.
///
///
///
/// true if t1 equals t2; otherwise false.
public static bool Equals(Duration t1, Duration t2)
{
return t1.Equals(t2);
}
///
/// Returns a hash code for this instance.
///
/// A 32-bit signed integer hash code.
public override int GetHashCode()
{
if (HasTimeSpan)
{
return _timeSpan.GetHashCode();
}
else
{
return _durationType.GetHashCode() + 17;
}
}
///
/// Subtracts the specified Duration from this instance.
///
///
/// A Duration whose value is the result of the value of this instance minus the value of duration.
public Duration Subtract(Duration duration)
{
return this - duration;
}
///
/// Creates a string representation of this Duration.
///
/// A string representation of this Duration.
public override string ToString()
{
if (HasTimeSpan)
{
return TypeDescriptor.GetConverter(_timeSpan).ConvertToString(_timeSpan);
}
else if (_durationType == DurationType.Forever)
{
return "Forever";
}
else // IsAutomatic
{
return "Automatic";
}
}
#endregion
///
/// An enumeration of the different types of Duration behaviors.
///
private enum DurationType
{
Automatic,
TimeSpan,
Forever
}
}
}
// 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
- AssemblySettingAttributes.cs
- HtmlFormParameterWriter.cs
- RuntimeConfig.cs
- XPathAncestorQuery.cs
- MiniCustomAttributeInfo.cs
- HwndStylusInputProvider.cs
- PersonalizationStateInfo.cs
- WebCategoryAttribute.cs
- Geometry3D.cs
- _ConnectStream.cs
- RadioButton.cs
- SendKeys.cs
- StrongNameKeyPair.cs
- ChangesetResponse.cs
- UshortList2.cs
- TextCompositionEventArgs.cs
- EndpointAddress10.cs
- NumericExpr.cs
- BoolExpr.cs
- MaskedTextProvider.cs
- Debug.cs
- DbgCompiler.cs
- XmlSchemaException.cs
- WindowsRichEdit.cs
- WindowsListViewSubItem.cs
- MemberDomainMap.cs
- Assembly.cs
- ProcessHostMapPath.cs
- DataGridViewTopLeftHeaderCell.cs
- Point3DConverter.cs
- FactoryGenerator.cs
- _AcceptOverlappedAsyncResult.cs
- DataServiceSaveChangesEventArgs.cs
- BeginStoryboard.cs
- FontSizeConverter.cs
- DataRecord.cs
- ComponentFactoryHelpers.cs
- JsonDeserializer.cs
- DataGrid.cs
- QilXmlReader.cs
- InternalPolicyElement.cs
- Byte.cs
- SamlSerializer.cs
- ErrorFormatterPage.cs
- NameObjectCollectionBase.cs
- SerializationTrace.cs
- TagMapInfo.cs
- BrowserCapabilitiesCodeGenerator.cs
- PingReply.cs
- TrustManagerMoreInformation.cs
- MimeMapping.cs
- ContextActivityUtils.cs
- CheckedListBox.cs
- ContextDataSourceView.cs
- ElementsClipboardData.cs
- MULTI_QI.cs
- UserControlBuildProvider.cs
- Int32Collection.cs
- EnumConverter.cs
- Stacktrace.cs
- CommandHelpers.cs
- TemplateContent.cs
- XmlAttributeCache.cs
- MappedMetaModel.cs
- LinqDataSourceView.cs
- TimeSpanMinutesConverter.cs
- SourceLineInfo.cs
- SqlStatistics.cs
- DataKeyPropertyAttribute.cs
- AbstractExpressions.cs
- ThrowHelper.cs
- BlockCollection.cs
- ExtenderControl.cs
- Operand.cs
- PathFigureCollection.cs
- HebrewNumber.cs
- XmlTypeMapping.cs
- ElementNotEnabledException.cs
- AudioFileOut.cs
- SqlNodeTypeOperators.cs
- DES.cs
- RemoteWebConfigurationHost.cs
- DataSourceView.cs
- WindowsPen.cs
- FilteredAttributeCollection.cs
- DbConnectionOptions.cs
- ControlAdapter.cs
- RelationshipConverter.cs
- TemplateKeyConverter.cs
- DataContractSerializer.cs
- ScriptIgnoreAttribute.cs
- IOException.cs
- CompositeFontFamily.cs
- StringInfo.cs
- StagingAreaInputItem.cs
- Parsers.cs
- LineServices.cs
- ScrollChangedEventArgs.cs
- SelectionPattern.cs
- WebPartAuthorizationEventArgs.cs