Code:
/ WCF / WCF / 3.5.30729.1 / untmp / Orcas / SP / ndp / cdf / src / WCF / ServiceModel / System / ServiceModel / Security / RequestSecurityTokenResponse.cs / 1 / RequestSecurityTokenResponse.cs
//------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//-----------------------------------------------------------
namespace System.ServiceModel.Security
{
using System;
using System.ServiceModel.Channels;
using System.ServiceModel;
using System.Xml;
using System.Security.Cryptography;
using System.Security.Cryptography.Xml;
using System.Runtime.Serialization;
using System.Xml.Serialization;
using System.Xml.Schema;
using System.Security.Principal;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.IdentityModel.Claims;
using System.IdentityModel.Policy;
using System.IdentityModel.Tokens;
using System.IdentityModel.Selectors;
using System.ServiceModel.Security.Tokens;
using System.IO;
using System.ServiceModel.Security;
using Psha1DerivedKeyGenerator = System.IdentityModel.Psha1DerivedKeyGenerator;
using System.ServiceModel.Dispatcher;
class RequestSecurityTokenResponse : BodyWriter
{
static int minSaneKeySizeInBits = 8 * 8; // 8 Bytes.
static int maxSaneKeySizeInBits = (16 * 1024) * 8; // 16 K
SecurityStandardsManager standardsManager;
string context;
int keySize;
bool computeKey;
string tokenType;
SecurityKeyIdentifierClause requestedAttachedReference;
SecurityKeyIdentifierClause requestedUnattachedReference;
SecurityToken issuedToken;
SecurityToken proofToken;
SecurityToken entropyToken;
BinaryNegotiation negotiationData;
XmlElement rstrXml;
DateTime effectiveTime;
DateTime expirationTime;
bool isLifetimeSet;
byte[] authenticator;
bool isReceiver;
bool isReadOnly;
byte[] cachedWriteBuffer;
int cachedWriteBufferLength;
bool isRequestedTokenClosed;
object appliesTo;
XmlObjectSerializer appliesToSerializer;
Type appliesToType;
Object thisLock = new Object();
XmlBuffer issuedTokenBuffer;
public RequestSecurityTokenResponse()
: this(SecurityStandardsManager.DefaultInstance)
{
}
public RequestSecurityTokenResponse(MessageSecurityVersion messageSecurityVersion, SecurityTokenSerializer securityTokenSerializer)
: this(SecurityUtils.CreateSecurityStandardsManager(messageSecurityVersion, securityTokenSerializer))
{
}
public RequestSecurityTokenResponse(XmlElement requestSecurityTokenResponseXml,
string context,
string tokenType,
int keySize,
SecurityKeyIdentifierClause requestedAttachedReference,
SecurityKeyIdentifierClause requestedUnattachedReference,
bool computeKey,
DateTime validFrom,
DateTime validTo,
bool isRequestedTokenClosed)
: this(SecurityStandardsManager.DefaultInstance,
requestSecurityTokenResponseXml,
context,
tokenType,
keySize,
requestedAttachedReference,
requestedUnattachedReference,
computeKey,
validFrom,
validTo,
isRequestedTokenClosed,
null)
{
}
public RequestSecurityTokenResponse(MessageSecurityVersion messageSecurityVersion,
SecurityTokenSerializer securityTokenSerializer,
XmlElement requestSecurityTokenResponseXml,
string context,
string tokenType,
int keySize,
SecurityKeyIdentifierClause requestedAttachedReference,
SecurityKeyIdentifierClause requestedUnattachedReference,
bool computeKey,
DateTime validFrom,
DateTime validTo,
bool isRequestedTokenClosed)
: this(SecurityUtils.CreateSecurityStandardsManager(messageSecurityVersion, securityTokenSerializer),
requestSecurityTokenResponseXml,
context,
tokenType,
keySize,
requestedAttachedReference,
requestedUnattachedReference,
computeKey,
validFrom,
validTo,
isRequestedTokenClosed,
null)
{
}
internal RequestSecurityTokenResponse(SecurityStandardsManager standardsManager)
: base(true)
{
if (standardsManager == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("standardsManager"));
}
this.standardsManager = standardsManager;
effectiveTime = SecurityUtils.MinUtcDateTime;
expirationTime = SecurityUtils.MaxUtcDateTime;
isRequestedTokenClosed = false;
this.isLifetimeSet = false;
this.isReceiver = false;
this.isReadOnly = false;
}
internal RequestSecurityTokenResponse(SecurityStandardsManager standardsManager,
XmlElement rstrXml,
string context,
string tokenType,
int keySize,
SecurityKeyIdentifierClause requestedAttachedReference,
SecurityKeyIdentifierClause requestedUnattachedReference,
bool computeKey,
DateTime validFrom,
DateTime validTo,
bool isRequestedTokenClosed,
XmlBuffer issuedTokenBuffer)
: base(true)
{
if (standardsManager == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("standardsManager"));
}
this.standardsManager = standardsManager;
if (rstrXml == null)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("rstrXml");
this.rstrXml = rstrXml;
this.context = context;
this.tokenType = tokenType;
this.keySize = keySize;
this.requestedAttachedReference = requestedAttachedReference;
this.requestedUnattachedReference = requestedUnattachedReference;
this.computeKey = computeKey;
this.effectiveTime = validFrom.ToUniversalTime();
this.expirationTime = validTo.ToUniversalTime();
this.isLifetimeSet = true;
this.isRequestedTokenClosed = isRequestedTokenClosed;
this.issuedTokenBuffer = issuedTokenBuffer;
this.isReceiver = true;
this.isReadOnly = true;
}
public string Context
{
get
{
return this.context;
}
set
{
if (this.IsReadOnly)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.ObjectIsReadOnly)));
this.context = value;
}
}
public string TokenType
{
get
{
return this.tokenType;
}
set
{
if (this.IsReadOnly)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.ObjectIsReadOnly)));
this.tokenType = value;
}
}
public SecurityKeyIdentifierClause RequestedAttachedReference
{
get
{
return this.requestedAttachedReference;
}
set
{
if (this.IsReadOnly)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.ObjectIsReadOnly)));
this.requestedAttachedReference = value;
}
}
public SecurityKeyIdentifierClause RequestedUnattachedReference
{
get
{
return this.requestedUnattachedReference;
}
set
{
if (this.IsReadOnly)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.ObjectIsReadOnly)));
this.requestedUnattachedReference = value;
}
}
public DateTime ValidFrom
{
get
{
return this.effectiveTime;
}
}
public DateTime ValidTo
{
get
{
return this.expirationTime;
}
}
public bool ComputeKey
{
get
{
return this.computeKey;
}
set
{
if (this.IsReadOnly)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.ObjectIsReadOnly)));
this.computeKey = value;
}
}
public int KeySize
{
get
{
return this.keySize;
}
set
{
if (this.IsReadOnly)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.ObjectIsReadOnly)));
if (value < 0)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("value", SR.GetString(SR.ValueMustBeNonNegative)));
this.keySize = value;
}
}
public bool IsRequestedTokenClosed
{
get
{
return this.isRequestedTokenClosed;
}
set
{
if (this.IsReadOnly)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.ObjectIsReadOnly)));
this.isRequestedTokenClosed = value;
}
}
public bool IsReadOnly
{
get
{
return this.isReadOnly;
}
}
protected Object ThisLock
{
get
{
return this.thisLock;
}
}
internal bool IsReceiver
{
get
{
return this.isReceiver;
}
}
internal SecurityStandardsManager StandardsManager
{
get
{
return this.standardsManager;
}
set
{
if (this.IsReadOnly)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.ObjectIsReadOnly)));
this.standardsManager = (value != null ? value : SecurityStandardsManager.DefaultInstance);
}
}
public SecurityToken EntropyToken
{
get
{
if (this.isReceiver)
{
// PreSharp Bug: Property get methods should not throw exceptions.
#pragma warning suppress 56503
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.ItemNotAvailableInDeserializedRSTR, "EntropyToken")));
}
return this.entropyToken;
}
}
public SecurityToken RequestedSecurityToken
{
get
{
if (this.isReceiver)
{
// PreSharp Bug: Property get methods should not throw exceptions.
#pragma warning suppress 56503
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.ItemNotAvailableInDeserializedRSTR, "IssuedToken")));
}
return this.issuedToken;
}
set
{
if (this.isReadOnly)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.ObjectIsReadOnly)));
this.issuedToken = value;
}
}
public SecurityToken RequestedProofToken
{
get
{
if (this.isReceiver)
{
// PreSharp Bug: Property get methods should not throw exceptions.
#pragma warning suppress 56503
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.ItemNotAvailableInDeserializedRSTR, "ProofToken")));
}
return this.proofToken;
}
set
{
if (this.isReadOnly)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.ObjectIsReadOnly)));
this.proofToken = value;
}
}
public XmlElement RequestSecurityTokenResponseXml
{
get
{
if (!this.isReceiver)
{
// PreSharp Bug: Property get methods should not throw exceptions.
#pragma warning suppress 56503
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.ItemAvailableInDeserializedRSTROnly, "RequestSecurityTokenXml")));
}
return this.rstrXml;
}
}
internal object AppliesTo
{
get
{
if (this.isReceiver)
{
// PreSharp Bug: Property get methods should not throw exceptions.
#pragma warning suppress 56503
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.ItemNotAvailableInDeserializedRST, "AppliesTo")));
}
return this.appliesTo;
}
}
internal XmlObjectSerializer AppliesToSerializer
{
get
{
if (this.isReceiver)
{
// PreSharp Bug: Property get methods should not throw exceptions.
#pragma warning suppress 56503
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.ItemNotAvailableInDeserializedRST, "AppliesToSerializer")));
}
return this.appliesToSerializer;
}
}
internal Type AppliesToType
{
get
{
if (this.isReceiver)
{
// PreSharp Bug: Property get methods should not throw exceptions.
#pragma warning suppress 56503
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.ItemNotAvailableInDeserializedRST, "AppliesToType")));
}
return this.appliesToType;
}
}
internal bool IsLifetimeSet
{
get
{
if (this.isReceiver)
{
// PreSharp Bug: Property get methods should not throw exceptions.
#pragma warning suppress 56503
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.ItemNotAvailableInDeserializedRSTR, "IsLifetimeSet")));
}
return this.isLifetimeSet;
}
}
internal XmlBuffer IssuedTokenBuffer
{
get
{
return this.issuedTokenBuffer;
}
}
public void SetIssuerEntropy(byte[] issuerEntropy)
{
if (this.IsReadOnly)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.ObjectIsReadOnly)));
this.entropyToken = (issuerEntropy != null) ? new NonceToken(issuerEntropy) : null;
}
internal void SetIssuerEntropy(WrappedKeySecurityToken issuerEntropy)
{
if (this.IsReadOnly)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.ObjectIsReadOnly)));
this.entropyToken = issuerEntropy;
}
public SecurityToken GetIssuerEntropy()
{
return this.GetIssuerEntropy(null);
}
internal SecurityToken GetIssuerEntropy(SecurityTokenResolver resolver)
{
if (this.isReceiver)
{
return this.standardsManager.TrustDriver.GetEntropy(this, resolver);
}
else
return this.entropyToken;
}
public void SetLifetime(DateTime validFrom, DateTime validTo)
{
if (this.IsReadOnly)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.ObjectIsReadOnly)));
if (validFrom.ToUniversalTime() > validTo.ToUniversalTime())
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument(SR.GetString(SR.EffectiveGreaterThanExpiration));
}
this.effectiveTime = validFrom.ToUniversalTime();
this.expirationTime = validTo.ToUniversalTime();
this.isLifetimeSet = true;
}
public void SetAppliesTo(T appliesTo, XmlObjectSerializer serializer)
{
if (this.IsReadOnly)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.ObjectIsReadOnly)));
if (appliesTo != null && serializer == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("serializer");
}
this.appliesTo = appliesTo;
this.appliesToSerializer = serializer;
this.appliesToType = typeof(T);
}
public void GetAppliesToQName(out string localName, out string namespaceUri)
{
if (!this.isReceiver)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.ItemAvailableInDeserializedRSTOnly, "MatchesAppliesTo")));
this.standardsManager.TrustDriver.GetAppliesToQName(this, out localName, out namespaceUri);
}
public T GetAppliesTo()
{
return this.GetAppliesTo(DataContractSerializerDefaults.CreateSerializer(typeof(T), DataContractSerializerDefaults.MaxItemsInObjectGraph));
}
public T GetAppliesTo(XmlObjectSerializer serializer)
{
if (this.isReceiver)
{
if (serializer == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("serializer");
}
return this.standardsManager.TrustDriver.GetAppliesTo(this, serializer);
}
else
{
return (T)this.appliesTo;
}
}
internal void SetBinaryNegotiation(BinaryNegotiation negotiation)
{
if (negotiation == null)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("negotiation");
if (this.IsReadOnly)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.ObjectIsReadOnly)));
this.negotiationData = negotiation;
}
internal BinaryNegotiation GetBinaryNegotiation()
{
if (this.isReceiver)
return this.standardsManager.TrustDriver.GetBinaryNegotiation(this);
else
return this.negotiationData;
}
internal void SetAuthenticator(byte[] authenticator)
{
if (authenticator == null)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("authenticator");
if (this.IsReadOnly)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.ObjectIsReadOnly)));
this.authenticator = DiagnosticUtility.Utility.AllocateByteArray(authenticator.Length);
Buffer.BlockCopy(authenticator, 0, this.authenticator, 0, authenticator.Length);
}
internal byte[] GetAuthenticator()
{
if (this.isReceiver)
return this.standardsManager.TrustDriver.GetAuthenticator(this);
else
{
if (this.authenticator == null)
return null;
else
{
byte[] result = DiagnosticUtility.Utility.AllocateByteArray(this.authenticator.Length);
Buffer.BlockCopy(this.authenticator, 0, result, 0, this.authenticator.Length);
return result;
}
}
}
void OnWriteTo(XmlWriter w)
{
if (this.isReceiver)
{
this.rstrXml.WriteTo(w);
}
else
{
this.standardsManager.TrustDriver.WriteRequestSecurityTokenResponse(this, w);
}
}
public void WriteTo(XmlWriter writer)
{
if (writer == null)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("writer");
if (this.IsReadOnly)
{
// cache the serialized bytes to ensure repeatability
if (this.cachedWriteBuffer == null)
{
MemoryStream stream = new MemoryStream();
using (XmlDictionaryWriter binaryWriter = XmlDictionaryWriter.CreateBinaryWriter(stream, XD.Dictionary))
{
this.OnWriteTo(binaryWriter);
binaryWriter.Flush();
stream.Flush();
stream.Seek(0, SeekOrigin.Begin);
this.cachedWriteBuffer = stream.GetBuffer();
this.cachedWriteBufferLength = (int)stream.Length;
}
}
writer.WriteNode(XmlDictionaryReader.CreateBinaryReader(this.cachedWriteBuffer, 0, this.cachedWriteBufferLength, XD.Dictionary, XmlDictionaryReaderQuotas.Max), false);
}
else
this.OnWriteTo(writer);
}
public static RequestSecurityTokenResponse CreateFrom(XmlReader reader)
{
return CreateFrom(SecurityStandardsManager.DefaultInstance, reader);
}
public static RequestSecurityTokenResponse CreateFrom(XmlReader reader, MessageSecurityVersion messageSecurityVersion, SecurityTokenSerializer securityTokenSerializer)
{
return CreateFrom(SecurityUtils.CreateSecurityStandardsManager(messageSecurityVersion, securityTokenSerializer), reader);
}
internal static RequestSecurityTokenResponse CreateFrom(SecurityStandardsManager standardsManager, XmlReader reader)
{
return standardsManager.TrustDriver.CreateRequestSecurityTokenResponse(reader);
}
protected override void OnWriteBodyContents(XmlDictionaryWriter writer)
{
WriteTo(writer);
}
public void MakeReadOnly()
{
if (!this.isReadOnly)
{
this.isReadOnly = true;
this.OnMakeReadOnly();
}
}
public GenericXmlSecurityToken GetIssuedToken(SecurityTokenResolver resolver, IList allowedAuthenticators, SecurityKeyEntropyMode keyEntropyMode, byte[] requestorEntropy, string expectedTokenType,
ReadOnlyCollection authorizationPolicies)
{
return this.GetIssuedToken(resolver, allowedAuthenticators, keyEntropyMode, requestorEntropy, expectedTokenType, authorizationPolicies, 0, false);
}
public virtual GenericXmlSecurityToken GetIssuedToken(SecurityTokenResolver resolver, IList allowedAuthenticators, SecurityKeyEntropyMode keyEntropyMode, byte[] requestorEntropy, string expectedTokenType,
ReadOnlyCollection authorizationPolicies, int defaultKeySize, bool isBearerKeyType)
{
if (!this.isReceiver)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.ItemAvailableInDeserializedRSTROnly, "GetIssuedToken")));
return this.standardsManager.TrustDriver.GetIssuedToken(this, resolver, allowedAuthenticators, keyEntropyMode, requestorEntropy, expectedTokenType, authorizationPolicies, defaultKeySize, isBearerKeyType);
}
public virtual GenericXmlSecurityToken GetIssuedToken(string expectedTokenType, ReadOnlyCollection authorizationPolicies, RSA clientKey)
{
if (!this.isReceiver)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.ItemAvailableInDeserializedRSTROnly, "GetIssuedToken")));
return this.standardsManager.TrustDriver.GetIssuedToken(this, expectedTokenType, authorizationPolicies, clientKey);
}
protected internal virtual void OnWriteCustomAttributes(XmlWriter writer)
{ }
protected internal virtual void OnWriteCustomElements(XmlWriter writer)
{ }
protected virtual void OnMakeReadOnly() { }
public static byte[] ComputeCombinedKey(byte[] requestorEntropy, byte[] issuerEntropy, int keySizeInBits)
{
if (requestorEntropy == null)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("requestorEntropy");
if (issuerEntropy == null)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("issuerEntropy");
// Do a sanity check here. We don't want to allow invalid keys or keys that are too
// large.
if ((keySizeInBits < minSaneKeySizeInBits) || (keySizeInBits > maxSaneKeySizeInBits))
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SecurityNegotiationException(SR.GetString(SR.InvalidKeySizeSpecifiedInNegotiation, keySizeInBits, minSaneKeySizeInBits, maxSaneKeySizeInBits)));
Psha1DerivedKeyGenerator generator = new Psha1DerivedKeyGenerator(requestorEntropy);
return generator.GenerateDerivedKey(new byte[] { }, issuerEntropy, keySizeInBits, 0);
}
}
}
// 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
- regiisutil.cs
- EntityViewContainer.cs
- HMAC.cs
- MenuItem.cs
- PagesSection.cs
- OdbcPermission.cs
- EncryptedPackage.cs
- Knowncolors.cs
- RoutedUICommand.cs
- BuiltInExpr.cs
- EntityDataSourceValidationException.cs
- DataGridViewColumnEventArgs.cs
- NativeMethods.cs
- GenericEnumerator.cs
- RelationshipConverter.cs
- AnnotationHighlightLayer.cs
- PointCollection.cs
- Thread.cs
- Internal.cs
- GenericXmlSecurityTokenAuthenticator.cs
- NonBatchDirectoryCompiler.cs
- Bitmap.cs
- Queue.cs
- DynamicQueryableWrapper.cs
- PropertyStore.cs
- DateTimeConstantAttribute.cs
- SymmetricAlgorithm.cs
- ServerIdentity.cs
- DataStorage.cs
- milexports.cs
- _LocalDataStoreMgr.cs
- CodeCastExpression.cs
- StylusTip.cs
- indexingfiltermarshaler.cs
- EmptyCollection.cs
- ExpressionList.cs
- GuidelineSet.cs
- SQLDouble.cs
- WebMethodAttribute.cs
- CompressEmulationStream.cs
- AbsoluteQuery.cs
- followingsibling.cs
- XmlStreamNodeWriter.cs
- Base64Stream.cs
- RawStylusActions.cs
- ThemeableAttribute.cs
- GetParentChain.cs
- SemanticValue.cs
- EntityObject.cs
- PolyLineSegmentFigureLogic.cs
- XmlAnyAttributeAttribute.cs
- GridViewCancelEditEventArgs.cs
- SrgsElementFactory.cs
- SpellerInterop.cs
- COAUTHIDENTITY.cs
- X509Extension.cs
- LinqToSqlWrapper.cs
- DataGridClipboardCellContent.cs
- TextRange.cs
- Rectangle.cs
- DependencyPropertyDescriptor.cs
- SqlInternalConnectionSmi.cs
- RegisteredArrayDeclaration.cs
- XmlCountingReader.cs
- ProxyAttribute.cs
- HttpApplication.cs
- DnsPermission.cs
- ConfigurationLockCollection.cs
- TimelineGroup.cs
- SortAction.cs
- SelectionEditingBehavior.cs
- URI.cs
- NestedContainer.cs
- NameValueFileSectionHandler.cs
- DefaultProxySection.cs
- HitTestWithPointDrawingContextWalker.cs
- ConditionalWeakTable.cs
- _FtpControlStream.cs
- RegexCompilationInfo.cs
- MediaTimeline.cs
- WSAddressing10ProblemHeaderQNameFault.cs
- RelatedImageListAttribute.cs
- StringWriter.cs
- HitTestWithGeometryDrawingContextWalker.cs
- CapabilitiesState.cs
- ContextStack.cs
- BaseComponentEditor.cs
- ListBase.cs
- Style.cs
- ParallelDesigner.cs
- Normalization.cs
- XmlAttribute.cs
- EventProviderWriter.cs
- TreeViewItemAutomationPeer.cs
- ServiceOperation.cs
- FileDetails.cs
- LinkTarget.cs
- MLangCodePageEncoding.cs
- SystemException.cs
- cookiecollection.cs