Code:
/ 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / Net / System / Net / cookiecontainer.cs / 1305376 / cookiecontainer.cs
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//-----------------------------------------------------------------------------
namespace System.Net {
using System.Collections;
using System.Threading;
using System.Globalization;
using System.Net.NetworkInformation;
using System.Text;
internal struct HeaderVariantInfo {
string m_name;
CookieVariant m_variant;
internal HeaderVariantInfo(string name, CookieVariant variant) {
m_name = name;
m_variant = variant;
}
internal string Name {
get {
return m_name;
}
}
internal CookieVariant Variant {
get {
return m_variant;
}
}
}
//
// CookieContainer
//
// Manage cookies for a user (implicit). Based on RFC 2965
//
///
/// [To be supplied.]
///
[Serializable]
public class CookieContainer {
public const int DefaultCookieLimit = 300;
public const int DefaultPerDomainCookieLimit = 20;
public const int DefaultCookieLengthLimit = 4096;
static readonly HeaderVariantInfo [] HeaderInfo = {
new HeaderVariantInfo(HttpKnownHeaderNames.SetCookie, CookieVariant.Rfc2109),
new HeaderVariantInfo(HttpKnownHeaderNames.SetCookie2, CookieVariant.Rfc2965)
};
// fields
Hashtable m_domainTable = new Hashtable();
int m_maxCookieSize = DefaultCookieLengthLimit;
int m_maxCookies = DefaultCookieLimit;
int m_maxCookiesPerDomain = DefaultPerDomainCookieLimit;
int m_count = 0;
string m_fqdnMyDomain = String.Empty;
// constructors
///
/// [To be supplied.]
///
public CookieContainer() {
string domain = IPGlobalProperties.InternalGetIPGlobalProperties().DomainName;
if (domain != null && domain.Length > 1)
{
m_fqdnMyDomain = '.' + domain;
}
//Otherwise it will remain string.Empty
}
///
/// [To be supplied.]
///
public CookieContainer(int capacity) : this(){
if (capacity <= 0) {
throw new ArgumentException(SR.GetString(SR.net_toosmall), "Capacity");
}
m_maxCookies = capacity;
}
///
/// [To be supplied.]
///
public CookieContainer(int capacity, int perDomainCapacity, int maxCookieSize) : this(capacity) {
if (perDomainCapacity != Int32.MaxValue && (perDomainCapacity <= 0 || perDomainCapacity > capacity)) {
throw new ArgumentOutOfRangeException("perDomainCapacity", SR.GetString(SR.net_cookie_capacity_range, "PerDomainCapacity", 0, capacity));
}
m_maxCookiesPerDomain = perDomainCapacity;
if (maxCookieSize <= 0) {
throw new ArgumentException(SR.GetString(SR.net_toosmall), "MaxCookieSize");
}
m_maxCookieSize = maxCookieSize;
}
// properties
///
/// Note that after shrinking the capacity Count can become greater than Capacity.
///
public int Capacity {
get {
return m_maxCookies;
}
set {
if (value <= 0 || (value < m_maxCookiesPerDomain && m_maxCookiesPerDomain != Int32.MaxValue)) {
throw new ArgumentOutOfRangeException("value", SR.GetString(SR.net_cookie_capacity_range, "Capacity", 0, m_maxCookiesPerDomain));
}
if (value < m_maxCookies) {
m_maxCookies = value;
AgeCookies(null);
}
m_maxCookies = value;
}
}
///
/// returns the total number of cookies in the container.
///
public int Count {
get {
return m_count;
}
}
///
/// [To be supplied.]
///
public int MaxCookieSize {
get {
return m_maxCookieSize;
}
set {
if (value <= 0) {
throw new ArgumentOutOfRangeException("value");
}
m_maxCookieSize = value;
}
}
///
/// After shrinking domain capacity each domain will less hold than new domain capacity
///
public int PerDomainCapacity {
get {
return m_maxCookiesPerDomain;
}
set {
if (value <= 0 || (value > m_maxCookies && value != Int32.MaxValue)) {
throw new ArgumentOutOfRangeException("value");
}
if (value < m_maxCookiesPerDomain) {
m_maxCookiesPerDomain = value;
AgeCookies(null);
}
m_maxCookiesPerDomain = value;
}
}
// methods
///
/// [To be supplied.]
///
//This method will construct faked URI, Domain property is required for param.
public void Add(Cookie cookie) {
if (cookie == null) {
throw new ArgumentNullException("cookie");
}
if (cookie.Domain.Length == 0) {
throw new ArgumentException(SR.GetString(SR.net_emptystringcall), "cookie.Domain");
}
Uri uri;
StringBuilder uriSb = new StringBuilder();
// We cannot add an invalid cookie into the container.
// Trying to prepare Uri for the cookie verification
uriSb.Append(cookie.Secure ? Uri.UriSchemeHttps : Uri.UriSchemeHttp).Append(Uri.SchemeDelimiter);
// If the original cookie has an explicitly set domain, copy it over
// to the new cookie
if (!cookie.DomainImplicit) {
if (cookie.Domain[0] == '.') {
uriSb.Append("0"); // Uri cctor should eat this, faked host.
}
}
uriSb.Append(cookie.Domain);
// Either keep Port as implici or set it according to original cookie
if (cookie.PortList != null) {
uriSb.Append(":").Append(cookie.PortList[0]);
}
// Path must be present, set to root by default
uriSb.Append(cookie.Path);
if (!Uri.TryCreate(uriSb.ToString(), UriKind.Absolute, out uri))
throw new CookieException(SR.GetString(SR.net_cookie_attribute, "Domain", cookie.Domain));
// We don't know cookie verification status -> re-create cookie and verify it
Cookie new_cookie = cookie.Clone();
new_cookie.VerifySetDefaults(new_cookie.Variant, uri, IsLocalDomain(uri.Host), m_fqdnMyDomain, true, true);
Add(new_cookie, true);
}
private void AddRemoveDomain(string key, PathList value) {
// Hashtable support multiple readers ans one writer
// Synchronize writers (make them to be just one)
lock(this) {
if (value == null) {
m_domainTable.Remove(key);
}
else {
m_domainTable[key] = value;
}
}
}
// This method is called *only* when cookie verification is done,
// so unlike with public Add(Cookie cookie) the cookie is in sane condition
internal void Add(Cookie cookie, bool throwOnError) {
PathList pathList;
if (cookie.Value.Length > m_maxCookieSize) {
if (throwOnError) {
throw new CookieException(SR.GetString(SR.net_cookie_size, cookie.ToString(), m_maxCookieSize));
}
return;
}
try {
pathList = (PathList)m_domainTable[cookie.DomainKey];
if (pathList == null) {
pathList = new PathList();
AddRemoveDomain(cookie.DomainKey, pathList);
}
int domain_count = pathList.GetCookiesCount();
CookieCollection cookies = (CookieCollection)pathList[cookie.Path];
if (cookies == null) {
cookies = new CookieCollection();
pathList[cookie.Path] = cookies;
}
if(cookie.Expired) {
//Explicit removal command (Max-Age == 0)
lock (cookies) {
int idx = cookies.IndexOf(cookie);
if (idx != -1) {
cookies.RemoveAt(idx);
--m_count;
}
}
}
else {
//This is about real cookie adding, check Capacity first
if (domain_count >= m_maxCookiesPerDomain && !AgeCookies(cookie.DomainKey)) {
return; //cannot age -> reject new cookie
}
else if (this.m_count >= m_maxCookies && !AgeCookies(null)) {
return; //cannot age -> reject new cookie
}
//about to change the collection
lock (cookies) {
m_count += cookies.InternalAdd(cookie, true);
}
}
}
catch (Exception e) {
if (e is ThreadAbortException || e is StackOverflowException || e is OutOfMemoryException) {
throw;
}
if (throwOnError) {
throw new CookieException(SR.GetString(SR.net_container_add_cookie), e);
}
}
}
//
// This function, once called, must delete at least one cookie
// If there are expired cookies in given scope they are cleaned up
// If nothing found the least used Collection will be found and removed
// from the container.
//
// Also note that expired cookies are also removed during request preparation
// (this.GetCookies method)
//
// Param. 'domain' == null means to age in the whole container
//
private bool AgeCookies(string domain) {
// border case => shrinked to zero
if(m_maxCookies == 0 || m_maxCookiesPerDomain == 0) {
m_domainTable = new Hashtable();
m_count = 0;
return false;
}
int removed = 0;
DateTime oldUsed = DateTime.MaxValue;
DateTime tempUsed;
CookieCollection lruCc = null;
string lruDomain = null;
string tempDomain = null;
PathList pathList;
int domain_count = 0;
int itemp = 0;
float remainingFraction = 1.0F;
// the container was shrinked, might need additional cleanup for each domain
if (m_count > m_maxCookies) {
// Means the fraction of the container to be left
// Each domain will be cut accordingly
remainingFraction = (float)m_maxCookies/(float)m_count;
}
foreach (DictionaryEntry entry in m_domainTable) {
if (domain == null) {
tempDomain = (string) entry.Key;
pathList = (PathList) entry.Value; //aliasing to trick foreach
}
else {
tempDomain = domain;
pathList = (PathList) m_domainTable[domain];
}
domain_count = 0; // cookies in the domain
foreach (CookieCollection cc in pathList.Values) {
itemp = ExpireCollection(cc);
removed += itemp;
m_count -= itemp; //update this container count;
domain_count += cc.Count;
// we also find the least used cookie collection in ENTIRE container
// we count the collection as LRU only if it holds 1+ elements
if (cc.Count > 0 && (tempUsed = cc.TimeStamp(CookieCollection.Stamp.Check)) < oldUsed) {
lruDomain = tempDomain;
lruCc = cc;
oldUsed = tempUsed;
}
}
// Check if we have reduced to the limit of the domain by expiration only
int min_count = Math.Min((int)(domain_count*remainingFraction), Math.Min(m_maxCookiesPerDomain, m_maxCookies)-1);
if (domain_count > min_count) {
//That case require sorting all domain collections by timestamp
Array cookies = Array.CreateInstance(typeof(CookieCollection), pathList.Count);
Array stamps = Array.CreateInstance(typeof(DateTime), pathList.Count);
foreach (CookieCollection cc in pathList.Values) {
stamps.SetValue(cc.TimeStamp(CookieCollection.Stamp.Check), itemp);
cookies.SetValue(cc ,itemp );
++itemp ;
}
Array.Sort(stamps, cookies);
itemp = 0;
for (int i = 0; i < pathList.Count; ++i) {
CookieCollection cc = (CookieCollection)cookies.GetValue(i);
lock (cc) {
while (domain_count > min_count && cc.Count > 0) {
cc.RemoveAt(0);
--domain_count;
--m_count;
++removed;
}
}
if (domain_count <= min_count ) {
break;
}
}
if (domain_count > min_count && domain != null) {
//cannot complete aging of explicit domain (no cookie adding allowed)
return false;
}
}
// we have completed aging of specific domain
if (domain != null) {
return true;
}
}
// The rest is for entire container aging
// We must get at least one free slot.
//Don't need to appy LRU if we already cleaned something
if (removed != 0) {
return true;
}
if (oldUsed == DateTime.MaxValue) {
//Something strange. Either capacity is 0 or all collections are locked with cc.Used
return false;
}
// Remove oldest cookies from the least used collection
lock (lruCc) {
while (m_count >= m_maxCookies && lruCc.Count > 0) {
lruCc.RemoveAt(0);
--m_count;
}
}
return true;
}
//return number of cookies removed from the collection
private int ExpireCollection(CookieCollection cc) {
int oldCount = cc.Count;
int idx = oldCount-1;
lock (cc) {
//Cannot use enumerator as we are going to alter collection
while (idx >= 0) {
Cookie cookie = cc[idx];
if (cookie.Expired) {
cc.RemoveAt(idx);
}
--idx;
}
}
return oldCount - cc.Count;
}
///
/// [To be supplied.]
///
// <
public void Add(CookieCollection cookies) {
if (cookies == null) {
throw new ArgumentNullException("cookies");
}
foreach (Cookie c in cookies) {
Add(c);
}
}
//
// This will try (if needed) get the full domain name of the host given the Uri
// NEVER call this function from internal methods with 'fqdnRemote' == NULL
// Since this method counts security issue for DNS and hence will slow
// the performance
//
internal bool IsLocalDomain(string host) {
int dot = host.IndexOf('.');
if (dot == -1) {
// No choice but to treat it as a host on the local domain
// This also covers 'localhost' and 'loopback'
return true;
}
// quick test for usual case - loopback addresses for IPv4 and IPv6
if ((host == "127.0.0.1") || (host == "::1") || (host == "0:0:0:0:0:0:0:1"))
{
return true;
}
// test domain membership
if (string.Compare(m_fqdnMyDomain, 0, host, dot, m_fqdnMyDomain.Length, StringComparison.OrdinalIgnoreCase ) == 0)
{
return true;
}
// test for "127.###.###.###" without using regex
string[] ipParts = host.Split('.');
if (ipParts != null && ipParts.Length == 4 && ipParts[0] == "127")
{
int i;
for (i = 1; i < 4; i++)
{
switch (ipParts[i].Length)
{
case 3:
if (ipParts[i][2] < '0' || ipParts[i][2] > '9')
{
break;
}
goto case 2;
case 2:
if (ipParts[i][1] < '0' || ipParts[i][1] > '9')
{
break;
}
goto case 1;
case 1:
if (ipParts[i][0] < '0' || ipParts[i][0] > '9')
{
break;
}
continue;
}
break;
}
if (i == 4)
{
return true;
}
}
return false;
}
///
/// [To be supplied.]
///
public void Add(Uri uri, Cookie cookie) {
if (uri == null) {
throw new ArgumentNullException("uri");
}
if(cookie == null) {
throw new ArgumentNullException("cookie");
}
Cookie new_cookie = cookie.Clone();
new_cookie.VerifySetDefaults(new_cookie.Variant, uri, IsLocalDomain(uri.Host), m_fqdnMyDomain, true, true);
Add(new_cookie, true);
}
///
/// [To be supplied.]
///
public void Add(Uri uri, CookieCollection cookies) {
if (uri == null) {
throw new ArgumentNullException("uri");
}
if(cookies == null) {
throw new ArgumentNullException("cookies");
}
bool isLocalDomain = IsLocalDomain(uri.Host);
foreach (Cookie c in cookies) {
Cookie new_cookie = c.Clone();
new_cookie.VerifySetDefaults(new_cookie.Variant, uri, isLocalDomain, m_fqdnMyDomain, true, true);
Add(new_cookie, true);
}
}
internal CookieCollection CookieCutter(Uri uri, string headerName, string setCookieHeader, bool isThrow) {
GlobalLog.Print("CookieContainer#" + ValidationHelper.HashString(this) + "::CookieCutter() uri:" + uri + " headerName:" + headerName + " setCookieHeader:" + setCookieHeader + " isThrow:" + isThrow);
CookieCollection cookies = new CookieCollection();
CookieVariant variant = CookieVariant.Unknown;
if (headerName == null) {
variant = CookieVariant.Default;
}
else for (int i = 0; i < HeaderInfo.Length; ++i) {
if ((String.Compare(headerName, HeaderInfo[i].Name, StringComparison.OrdinalIgnoreCase ) == 0)) {
variant = HeaderInfo[i].Variant;
}
}
bool isLocalDomain = IsLocalDomain(uri.Host);
try {
CookieParser parser = new CookieParser(setCookieHeader);
do {
Cookie cookie = parser.Get();
GlobalLog.Print("CookieContainer#" + ValidationHelper.HashString(this) + "::CookieCutter() CookieParser returned cookie:" + ValidationHelper.ToString(cookie));
if (cookie == null) {
break;
}
//Parser marks invalid cookies this way
if (ValidationHelper.IsBlankString(cookie.Name)) {
if(isThrow) {
throw new CookieException(SR.GetString(SR.net_cookie_format));
}
//Otherwise, ignore (reject) cookie
continue;
}
// this will set the default values from the response URI
// AND will check for cookie validity
if(!cookie.VerifySetDefaults(variant, uri, isLocalDomain, m_fqdnMyDomain, true, isThrow)) {
continue;
}
// If many same cookies arrive we collapse them into just one, hence setting
// parameter isStrict = true below
cookies.InternalAdd(cookie, true);
} while (true);
}
catch (Exception e) {
if (e is ThreadAbortException || e is StackOverflowException || e is OutOfMemoryException) {
throw;
}
if(isThrow) {
throw new CookieException(SR.GetString(SR.net_cookie_parse_header, uri.AbsoluteUri), e);
}
}
foreach (Cookie c in cookies) {
Add(c, isThrow);
}
return cookies;
}
///
/// [To be supplied.]
///
public CookieCollection GetCookies(Uri uri) {
if (uri == null) {
throw new ArgumentNullException("uri");
}
return InternalGetCookies(uri);
}
internal CookieCollection InternalGetCookies(Uri uri) {
bool isSecure = (uri.Scheme == Uri.UriSchemeHttps);
int port = uri.Port;
CookieCollection cookies = new CookieCollection();
ArrayList nameKeys = new ArrayList();
int firstCompatibleVersion0SpecKey = 0;
string fqdnRemote = uri.Host;
int dot = fqdnRemote.IndexOf('.');
if (dot == -1) {
// DNS.resolve may return short names even for other inet domains ;-(
// We _don't_ know what the exact domain is, so try also grab short hostname cookies.
nameKeys.Add(fqdnRemote);
// add a preceding dot (null host)
nameKeys.Add("." + fqdnRemote);
// grab long name from the local domain
if (m_fqdnMyDomain != null && m_fqdnMyDomain.Length != 0) {
nameKeys.Add(fqdnRemote + m_fqdnMyDomain);
// grab the local domain itself
nameKeys.Add(m_fqdnMyDomain);
firstCompatibleVersion0SpecKey = 3;
}
else {
firstCompatibleVersion0SpecKey = 1;
}
}
else {
// grab the host itself
nameKeys.Add(fqdnRemote);
// add a preceding dot (null host)
nameKeys.Add("." + fqdnRemote);
// grab the host domain
nameKeys.Add(fqdnRemote.Substring(dot));
firstCompatibleVersion0SpecKey = 2;
// The following block is only for compatibility with Version0 spec.
// Still, we'll add only Plain-Variant cookies if found under below keys
if (fqdnRemote.Length > 2) {
// We ignore the '.' at the end on the name
int last = fqdnRemote.LastIndexOf('.', fqdnRemote.Length-2);
//AND keys with <2 dots inside.
if (last > 0) {
last = fqdnRemote.LastIndexOf('.', last-1);
}
if (last != -1) {
while ((dot < last) && (dot = fqdnRemote.IndexOf('.', dot+1)) != -1) {
nameKeys.Add(fqdnRemote.Substring(dot));
}
}
}
}
foreach (string key in nameKeys) {
bool found = false;
bool defaultAdded = false;
PathList pathList = (PathList)m_domainTable[key];
--firstCompatibleVersion0SpecKey;
if (pathList == null) {
continue;
}
foreach (DictionaryEntry entry in pathList) {
string path = (string)entry.Key;
if (uri.AbsolutePath.StartsWith(CookieParser.CheckQuoted(path))) {
found = true;
CookieCollection cc = (CookieCollection)entry.Value;
cc.TimeStamp(CookieCollection.Stamp.Set);
MergeUpdateCollections(cookies, cc, port, isSecure, (firstCompatibleVersion0SpecKey<0));
if (path == "/") {
defaultAdded = true;
}
}
else if (found) {
break;
}
}
if (!defaultAdded) {
CookieCollection cc = (CookieCollection)pathList["/"];
if (cc != null) {
cc.TimeStamp(CookieCollection.Stamp.Set);
MergeUpdateCollections(cookies, cc, port, isSecure, (firstCompatibleVersion0SpecKey<0));
}
}
// Remove unused domain
// (This is the only place that does domain removal)
if(pathList.Count == 0) {
AddRemoveDomain(key, null);
}
}
return cookies;
}
private void MergeUpdateCollections(CookieCollection destination, CookieCollection source, int port, bool isSecure, bool isPlainOnly) {
// we may change it
lock (source) {
//cannot use foreach as we going update 'source'
for (int idx = 0 ; idx < source.Count; ++idx) {
bool to_add = false;
Cookie cookie = source[idx];
if (cookie.Expired) {
//If expired, remove from container and don't add to the destination
source.RemoveAt(idx);
--m_count;
--idx;
}
else {
//Add only if port does match to this request URI
//or was not present in the original response
if(isPlainOnly && cookie.Variant != CookieVariant.Plain) {
;//don;t add
}
else if(cookie.PortList != null)
{
foreach (int p in cookie.PortList) {
if(p == port) {
to_add = true;
break;
}
}
}
else {
//it was implicit Port, always OK to add
to_add = true;
}
//refuse adding secure cookie into 'unsecure' destination
if (cookie.Secure && !isSecure) {
to_add = false;
}
if (to_add) {
// In 'source' are already orederd.
// If two same cookies come from dif 'source' then they
// will follow (not replace) each other.
destination.InternalAdd(cookie, false);
}
}
}
}
}
///
/// [To be supplied.]
///
public string GetCookieHeader(Uri uri) {
if (uri == null) {
throw new ArgumentNullException("uri");
}
string dummy;
return GetCookieHeader(uri, out dummy);
}
internal string GetCookieHeader(Uri uri, out string optCookie2) {
CookieCollection cookies = InternalGetCookies(uri);
string cookieString = String.Empty;
string delimiter = String.Empty;
foreach (Cookie cookie in cookies) {
cookieString += delimiter + cookie.ToString();
delimiter = "; ";
}
optCookie2 = cookies.IsOtherVersionSeen ?
(Cookie.SpecialAttributeLiteral +
Cookie.VersionAttributeName +
Cookie.EqualsLiteral +
Cookie.MaxSupportedVersion.ToString(NumberFormatInfo.InvariantInfo)) : String.Empty;
return cookieString;
}
//public CookieCollection Parse(string cookieName) {
// return new CookieCollection();
//}
//public WebHeaderCollection Headers() {
//}
//public void Remove(Cookie cookie) {
//}
//public void Remove(string cookieName) {
//}
//public void RemoveAll(Cookie cookie) {
//}
//public void RemoveAll(string cookieName) {
//}
//public void SetCookie(Cookie cookie) {
//}
//public void SetCookies(CookieCollection cookies) {
//}
///
/// [To be supplied.]
///
//<
public void SetCookies(Uri uri, string cookieHeader) {
if (uri == null) {
throw new ArgumentNullException("uri");
}
if(cookieHeader == null) {
throw new ArgumentNullException("cookieHeader");
}
CookieCutter(uri, null, cookieHeader, true); //will throw on error
}
#if DEBUG
///
/// [To be supplied.]
///
internal void Dump() {
GlobalLog.Print("CookieContainer:");
foreach (DictionaryEntry de in m_domainTable) {
GlobalLog.Print("domain = \"" + de.Key + "\"");
((PathList)de.Value).Dump();
}
}
#endif
}
[Serializable]
internal class PathList {
SortedList m_list = (SortedList.Synchronized(new SortedList(PathListComparer.StaticInstance)));
public PathList() {
}
public int Count {
get {
return m_list.Count;
}
}
public int GetCookiesCount() {
int count = 0;
foreach (CookieCollection cc in m_list.Values) {
count += cc.Count;
}
return count;
}
public ICollection Values {
get {
return m_list.Values;
}
}
public object this[string s] {
get {
return m_list[s];
}
set {
m_list[s] = value;
}
}
public IEnumerator GetEnumerator() {
return m_list.GetEnumerator();
}
[Serializable]
class PathListComparer : IComparer {
internal static readonly PathListComparer StaticInstance = new PathListComparer();
int IComparer.Compare(object ol, object or) {
string pathLeft = CookieParser.CheckQuoted((string)ol);
string pathRight = CookieParser.CheckQuoted((string)or);
int ll = pathLeft.Length;
int lr = pathRight.Length;
int length = Math.Min(ll, lr);
for (int i = 0; i < length; ++i) {
if (pathLeft[i] != pathRight[i]) {
return pathLeft[i] - pathRight[i];
}
}
return lr - ll;
}
}
#if DEBUG
public void Dump() {
GlobalLog.Print("PathList:");
foreach (DictionaryEntry cookies in this) {
GlobalLog.Print("collection = \"" + cookies.Key + "\"");
((CookieCollection)cookies.Value).Dump();
}
}
#endif
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- QueryOutputWriter.cs
- cache.cs
- SQLInt32.cs
- UInt16Converter.cs
- ElementUtil.cs
- ArrayConverter.cs
- WebBodyFormatMessageProperty.cs
- Viewport3DVisual.cs
- CodeTypeParameterCollection.cs
- EntityContainerAssociationSetEnd.cs
- XmlImplementation.cs
- BaseCodePageEncoding.cs
- ViewLoader.cs
- ConfigurationValidatorAttribute.cs
- TextReader.cs
- CodeGeneratorOptions.cs
- HitTestDrawingContextWalker.cs
- Registry.cs
- CompoundFileIOPermission.cs
- SpinWait.cs
- XmlCharCheckingReader.cs
- embossbitmapeffect.cs
- BevelBitmapEffect.cs
- CssClassPropertyAttribute.cs
- AssemblyHash.cs
- VisualTarget.cs
- CodeNamespaceImportCollection.cs
- ReflectionTypeLoadException.cs
- FlowLayoutSettings.cs
- SystemWebSectionGroup.cs
- HttpServerUtilityWrapper.cs
- KeyConverter.cs
- TextBox.cs
- DataTableMapping.cs
- XmlWriterTraceListener.cs
- XPathBuilder.cs
- ServiceNotStartedException.cs
- KeyInterop.cs
- DataServiceKeyAttribute.cs
- ConnectionStringsExpressionBuilder.cs
- EncryptedXml.cs
- SimpleTypeResolver.cs
- ClientUrlResolverWrapper.cs
- DeviceSpecificDialogCachedState.cs
- NewExpression.cs
- PropertyChangeTracker.cs
- WsrmMessageInfo.cs
- EnumMemberAttribute.cs
- WindowsPrincipal.cs
- ParserExtension.cs
- X500Name.cs
- CodeBinaryOperatorExpression.cs
- Predicate.cs
- PolicyManager.cs
- X509SecurityTokenParameters.cs
- DataTableClearEvent.cs
- RenderingEventArgs.cs
- HwndHostAutomationPeer.cs
- SapiRecognizer.cs
- XmlAnyAttributeAttribute.cs
- RecognizerInfo.cs
- ObjectStorage.cs
- TaiwanCalendar.cs
- TransformCollection.cs
- TableRow.cs
- SQLRoleProvider.cs
- ConfigErrorGlyph.cs
- TextTreeTextBlock.cs
- AmbientProperties.cs
- ExceptionRoutedEventArgs.cs
- ThrowHelper.cs
- Resources.Designer.cs
- DataGridViewDataErrorEventArgs.cs
- TimeManager.cs
- OletxDependentTransaction.cs
- _NestedSingleAsyncResult.cs
- ComponentEditorForm.cs
- StaticSiteMapProvider.cs
- ButtonBaseDesigner.cs
- SqlServices.cs
- WeakEventTable.cs
- TimelineClockCollection.cs
- SerializationEventsCache.cs
- SimpleBitVector32.cs
- SiteOfOriginContainer.cs
- PropertyMappingExceptionEventArgs.cs
- EntityDataSourceQueryBuilder.cs
- CodeMemberMethod.cs
- BamlWriter.cs
- PropertyGridEditorPart.cs
- TypedTableGenerator.cs
- Input.cs
- HttpApplicationFactory.cs
- WebConfigurationFileMap.cs
- Object.cs
- TemplateKeyConverter.cs
- WindowsGraphicsCacheManager.cs
- RealizationContext.cs
- ColumnWidthChangingEvent.cs
- DetailsViewModeEventArgs.cs