Code:
/ WCF / WCF / 3.5.30729.1 / untmp / Orcas / SP / ndp / cdf / src / WCF / ServiceModel / System / ServiceModel / Channels / Connection.cs / 1 / Connection.cs
//------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//-----------------------------------------------------------
namespace System.ServiceModel.Channels
{
using System.IO;
using System.ServiceModel;
using System.Threading;
using System.Diagnostics;
using System.Net;
// Low level abstraction for a socket/pipe
interface IConnection
{
byte[] AsyncReadBuffer { get; }
int AsyncReadBufferSize { get; }
TraceEventType ExceptionEventType { get; set;}
IPEndPoint RemoteIPEndPoint { get; }
void Abort();
void Close(TimeSpan timeout);
void Shutdown(TimeSpan timeout);
IAsyncResult BeginWrite(byte[] buffer, int offset, int size, bool immediate, TimeSpan timeout,
AsyncCallback callback, object state);
void EndWrite(IAsyncResult result);
void Write(byte[] buffer, int offset, int size, bool immediate, TimeSpan timeout);
void Write(byte[] buffer, int offset, int size, bool immediate, TimeSpan timeout, BufferManager bufferManager);
int Read(byte[] buffer, int offset, int size, TimeSpan timeout);
AsyncReadResult BeginRead(int offset, int size, TimeSpan timeout, WaitCallback callback, object state);
int EndRead();
// very ugly listener stuff
object DuplicateAndClose(int targetProcessId);
object GetCoreTransport();
bool Validate(Uri uri);
}
enum AsyncReadResult
{
Completed,
Queued,
}
// Low level abstraction for connecting a socket/pipe
interface IConnectionInitiator
{
IConnection Connect(Uri uri, TimeSpan timeout);
IAsyncResult BeginConnect(Uri uri, TimeSpan timeout, AsyncCallback callback, object state);
IConnection EndConnect(IAsyncResult result);
}
// Low level abstraction for listening for sockets/pipes
interface IConnectionListener : IDisposable
{
void Listen();
IAsyncResult BeginAccept(AsyncCallback callback, object state);
IConnection EndAccept(IAsyncResult result);
}
abstract class DelegatingConnection : IConnection
{
IConnection connection;
protected DelegatingConnection(IConnection connection)
{
this.connection = connection;
}
public virtual byte[] AsyncReadBuffer
{
get { return connection.AsyncReadBuffer; }
}
public virtual int AsyncReadBufferSize
{
get { return connection.AsyncReadBufferSize; }
}
public TraceEventType ExceptionEventType
{
get { return connection.ExceptionEventType; }
set { connection.ExceptionEventType = value; }
}
protected IConnection Connection
{
get { return connection; }
}
public IPEndPoint RemoteIPEndPoint
{
get { return connection.RemoteIPEndPoint; }
}
public virtual void Abort()
{
connection.Abort();
}
public virtual void Close(TimeSpan timeout)
{
connection.Close(timeout);
}
public virtual void Shutdown(TimeSpan timeout)
{
connection.Shutdown(timeout);
}
public virtual object DuplicateAndClose(int targetProcessId)
{
return connection.DuplicateAndClose(targetProcessId);
}
public virtual object GetCoreTransport()
{
return connection.GetCoreTransport();
}
public virtual bool Validate(Uri uri)
{
return connection.Validate(uri);
}
public virtual IAsyncResult BeginWrite(byte[] buffer, int offset, int size, bool immediate, TimeSpan timeout,
AsyncCallback callback, object state)
{
return connection.BeginWrite(buffer, offset, size, immediate, timeout, callback, state);
}
public virtual void EndWrite(IAsyncResult result)
{
connection.EndWrite(result);
}
public virtual void Write(byte[] buffer, int offset, int size, bool immediate, TimeSpan timeout)
{
connection.Write(buffer, offset, size, immediate, timeout);
}
public virtual void Write(byte[] buffer, int offset, int size, bool immediate, TimeSpan timeout, BufferManager bufferManager)
{
connection.Write(buffer, offset, size, immediate, timeout, bufferManager);
}
public virtual int Read(byte[] buffer, int offset, int size, TimeSpan timeout)
{
return connection.Read(buffer, offset, size, timeout);
}
public virtual AsyncReadResult BeginRead(int offset, int size, TimeSpan timeout,
WaitCallback callback, object state)
{
return connection.BeginRead(offset, size, timeout, callback, state);
}
public virtual int EndRead()
{
return connection.EndRead();
}
}
class PreReadConnection : DelegatingConnection
{
int asyncBytesRead;
byte[] preReadData;
int preReadOffset;
int preReadCount;
public PreReadConnection(IConnection innerConnection, byte[] initialData)
: this(innerConnection, initialData, 0, initialData.Length)
{
}
public PreReadConnection(IConnection innerConnection, byte[] initialData, int initialOffset, int initialSize)
: base(innerConnection)
{
this.preReadData = initialData;
this.preReadOffset = initialOffset;
this.preReadCount = initialSize;
}
public void AddPreReadData(byte[] initialData, int initialOffset, int initialSize)
{
if (this.preReadCount > 0)
{
byte[] tempBuffer = this.preReadData;
this.preReadData = DiagnosticUtility.Utility.AllocateByteArray(initialSize + this.preReadCount);
Buffer.BlockCopy(tempBuffer, this.preReadOffset, this.preReadData, 0, this.preReadCount);
Buffer.BlockCopy(initialData, initialOffset, this.preReadData, this.preReadCount, initialSize);
this.preReadOffset = 0;
this.preReadCount += initialSize;
}
else
{
this.preReadData = initialData;
this.preReadOffset = initialOffset;
this.preReadCount = initialSize;
}
}
public override int Read(byte[] buffer, int offset, int size, TimeSpan timeout)
{
ConnectionUtilities.ValidateBufferBounds(buffer, offset, size);
if (this.preReadCount > 0)
{
int bytesToCopy = Math.Min(size, this.preReadCount);
Buffer.BlockCopy(this.preReadData, this.preReadOffset, buffer, offset, bytesToCopy);
this.preReadOffset += bytesToCopy;
this.preReadCount -= bytesToCopy;
return bytesToCopy;
}
return base.Read(buffer, offset, size, timeout);
}
public override AsyncReadResult BeginRead(int offset, int size, TimeSpan timeout, WaitCallback callback, object state)
{
ConnectionUtilities.ValidateBufferBounds(AsyncReadBufferSize, offset, size);
if (this.preReadCount > 0)
{
int bytesToCopy = Math.Min(size, this.preReadCount);
Buffer.BlockCopy(this.preReadData, this.preReadOffset, AsyncReadBuffer, offset, bytesToCopy);
this.preReadOffset += bytesToCopy;
this.preReadCount -= bytesToCopy;
this.asyncBytesRead = bytesToCopy;
return AsyncReadResult.Completed;
}
return base.BeginRead(offset, size, timeout, callback, state);
}
public override int EndRead()
{
if (this.asyncBytesRead > 0)
{
int retValue = this.asyncBytesRead;
this.asyncBytesRead = 0;
return retValue;
}
return base.EndRead();
}
}
class ConnectionStream : Stream
{
TimeSpan closeTimeout;
int readTimeout;
int writeTimeout;
IConnection connection;
bool immediate;
public ConnectionStream(IConnection connection, IDefaultCommunicationTimeouts defaultTimeouts)
{
this.connection = connection;
this.closeTimeout = defaultTimeouts.CloseTimeout;
this.ReadTimeout = TimeoutHelper.ToMilliseconds(defaultTimeouts.ReceiveTimeout);
this.WriteTimeout = TimeoutHelper.ToMilliseconds(defaultTimeouts.SendTimeout);
immediate = true;
}
public IConnection Connection
{
get { return connection; }
}
public override bool CanRead
{
get { return true; }
}
public override bool CanSeek
{
get { return false; }
}
public override bool CanTimeout
{
get { return true; }
}
public override bool CanWrite
{
get { return true; }
}
public TimeSpan CloseTimeout
{
get { return closeTimeout; }
set { this.closeTimeout = value; }
}
public override int ReadTimeout
{
get { return this.readTimeout; }
set
{
if (value < -1)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("value", value,
SR.GetString(SR.ValueMustBeInRange, -1, int.MaxValue)));
}
this.readTimeout = value;
}
}
public override int WriteTimeout
{
get { return this.writeTimeout; }
set
{
if (value < -1)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("value", value,
SR.GetString(SR.ValueMustBeInRange, -1, int.MaxValue)));
}
this.writeTimeout = value;
}
}
public bool Immediate
{
get { return immediate; }
set { immediate = value; }
}
public override long Length
{
get
{
#pragma warning suppress 56503 // [....], required by the Stream.Length contract
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException(SR.GetString(SR.SeekNotSupported)));
}
}
public override long Position
{
get
{
#pragma warning suppress 56503 // [....], required by the Stream.Position contract
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException(SR.GetString(SR.SeekNotSupported)));
}
set
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException(SR.GetString(SR.SeekNotSupported)));
}
}
public TraceEventType ExceptionEventType
{
get { return connection.ExceptionEventType; }
set { connection.ExceptionEventType = value; }
}
public void Abort()
{
connection.Abort();
}
public override void Close()
{
connection.Close(this.CloseTimeout);
}
public override void Flush()
{
// NOP
}
public override IAsyncResult BeginWrite(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
{
return connection.BeginWrite(buffer, offset, count, this.Immediate, TimeoutHelper.FromMilliseconds(this.WriteTimeout), callback, state);
}
public override void EndWrite(IAsyncResult asyncResult)
{
connection.EndWrite(asyncResult);
}
public override void Write(byte[] buffer, int offset, int count)
{
connection.Write(buffer, offset, count, this.Immediate, TimeoutHelper.FromMilliseconds(this.WriteTimeout));
}
public override IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
{
return new ReadAsyncResult(connection, buffer, offset, count, TimeoutHelper.FromMilliseconds(this.ReadTimeout), callback, state);
}
public override int EndRead(IAsyncResult asyncResult)
{
return ReadAsyncResult.End(asyncResult);
}
public override int Read(byte[] buffer, int offset, int count)
{
return this.Read(buffer, offset, count, TimeoutHelper.FromMilliseconds(this.ReadTimeout));
}
protected int Read(byte[] buffer, int offset, int count, TimeSpan timeout)
{
return connection.Read(buffer, offset, count, timeout);
}
public override long Seek(long offset, SeekOrigin origin)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException(SR.GetString(SR.SeekNotSupported)));
}
public override void SetLength(long value)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException(SR.GetString(SR.SeekNotSupported)));
}
public void Shutdown(TimeSpan timeout)
{
connection.Shutdown(timeout);
}
public bool Validate(Uri uri)
{
return connection.Validate(uri);
}
class ReadAsyncResult : AsyncResult
{
int bytesRead;
byte[] buffer;
int offset;
IConnection connection;
static WaitCallback onAsyncReadComplete;
public ReadAsyncResult(IConnection connection, byte[] buffer, int offset, int count, TimeSpan timeout,
AsyncCallback callback, object state)
: base(callback, state)
{
this.buffer = buffer;
this.offset = offset;
this.connection = connection;
if (onAsyncReadComplete == null)
{
onAsyncReadComplete = new WaitCallback(OnAsyncReadComplete);
}
AsyncReadResult readResult = this.connection.BeginRead(0, Math.Min(count, this.connection.AsyncReadBufferSize),
timeout, onAsyncReadComplete, this);
if (readResult == AsyncReadResult.Completed)
{
HandleRead();
base.Complete(true);
}
}
void HandleRead()
{
bytesRead = this.connection.EndRead();
Buffer.BlockCopy(this.connection.AsyncReadBuffer, 0, buffer, offset, bytesRead);
}
public static int End(IAsyncResult result)
{
ReadAsyncResult thisPtr = AsyncResult.End(result);
return thisPtr.bytesRead;
}
static void OnAsyncReadComplete(object state)
{
ReadAsyncResult thisPtr = (ReadAsyncResult)state;
Exception completionException = null;
try
{
thisPtr.HandleRead();
}
#pragma warning suppress 56500 // [....], transferring exception to another thread
catch (Exception e)
{
if (DiagnosticUtility.IsFatal(e))
{
throw;
}
completionException = e;
}
thisPtr.Complete(false, completionException);
}
}
}
class StreamConnection : IConnection
{
byte[] asyncReadBuffer;
int bytesRead;
ConnectionStream innerStream;
AsyncCallback onRead;
IAsyncResult readResult;
WaitCallback readCallback;
Stream stream;
public StreamConnection(Stream stream, ConnectionStream innerStream)
{
DiagnosticUtility.DebugAssert(stream != null, "StreamConnection: Stream cannot be null.");
DiagnosticUtility.DebugAssert(innerStream != null, "StreamConnection: Inner stream cannot be null.");
this.stream = stream;
this.innerStream = innerStream;
onRead = DiagnosticUtility.ThunkAsyncCallback(new AsyncCallback(OnRead));
}
public byte[] AsyncReadBuffer
{
get
{
if (this.asyncReadBuffer == null)
{
lock (ThisLock)
{
if (this.asyncReadBuffer == null)
{
this.asyncReadBuffer = DiagnosticUtility.Utility.AllocateByteArray(innerStream.Connection.AsyncReadBufferSize);
}
}
}
return this.asyncReadBuffer;
}
}
public int AsyncReadBufferSize
{
get { return innerStream.Connection.AsyncReadBufferSize; }
}
public Stream Stream
{
get { return this.stream; }
}
public object ThisLock
{
get { return this; }
}
public TraceEventType ExceptionEventType
{
get { return innerStream.ExceptionEventType; }
set { innerStream.ExceptionEventType = value; }
}
public IPEndPoint RemoteIPEndPoint
{
get
{
#pragma warning suppress 56503 // Not publicly accessible and this should never be called.
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotImplementedException());
}
}
public void Abort()
{
innerStream.Abort();
}
Exception ConvertIOException(IOException ioException)
{
if (ioException.InnerException is TimeoutException)
{
return new TimeoutException(ioException.InnerException.Message, ioException);
}
else if (ioException.InnerException is CommunicationObjectAbortedException)
{
return new CommunicationObjectAbortedException(ioException.InnerException.Message, ioException);
}
else if (ioException.InnerException is CommunicationException)
{
return new CommunicationException(ioException.InnerException.Message, ioException);
}
else
{
return new CommunicationException(SR.GetString(SR.StreamError), ioException);
}
}
public void Close(TimeSpan timeout)
{
innerStream.CloseTimeout = timeout;
try
{
stream.Close();
}
catch (IOException ioException)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(ConvertIOException(ioException));
}
}
public void Shutdown(TimeSpan timeout)
{
innerStream.Shutdown(timeout);
}
public object DuplicateAndClose(int targetProcessId)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotImplementedException());
}
public virtual object GetCoreTransport()
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotImplementedException());
}
public bool Validate(Uri uri)
{
return innerStream.Validate(uri);
}
public IAsyncResult BeginWrite(byte[] buffer, int offset, int size, bool immediate, TimeSpan timeout,
AsyncCallback callback, object state)
{
try
{
innerStream.Immediate = immediate;
SetWriteTimeout(timeout);
return stream.BeginWrite(buffer, offset, size, callback, state);
}
catch (IOException ioException)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(ConvertIOException(ioException));
}
}
public void EndWrite(IAsyncResult result)
{
try
{
stream.EndWrite(result);
}
catch (IOException ioException)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(ConvertIOException(ioException));
}
}
public void Write(byte[] buffer, int offset, int size, bool immediate, TimeSpan timeout)
{
try
{
innerStream.Immediate = immediate;
SetWriteTimeout(timeout);
stream.Write(buffer, offset, size);
}
catch (IOException ioException)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(ConvertIOException(ioException));
}
}
public void Write(byte[] buffer, int offset, int size, bool immediate, TimeSpan timeout, BufferManager bufferManager)
{
Write(buffer, offset, size, immediate, timeout);
bufferManager.ReturnBuffer(buffer);
}
void SetReadTimeout(TimeSpan timeout)
{
int timeoutInMilliseconds = TimeoutHelper.ToMilliseconds(timeout);
if (stream.CanTimeout)
{
stream.ReadTimeout = timeoutInMilliseconds;
}
innerStream.ReadTimeout = timeoutInMilliseconds;
}
void SetWriteTimeout(TimeSpan timeout)
{
int timeoutInMilliseconds = TimeoutHelper.ToMilliseconds(timeout);
if (stream.CanTimeout)
{
stream.WriteTimeout = timeoutInMilliseconds;
}
innerStream.WriteTimeout = timeoutInMilliseconds;
}
public int Read(byte[] buffer, int offset, int size, TimeSpan timeout)
{
try
{
SetReadTimeout(timeout);
return stream.Read(buffer, offset, size);
}
catch (IOException ioException)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(ConvertIOException(ioException));
}
}
public AsyncReadResult BeginRead(int offset, int size, TimeSpan timeout, WaitCallback callback, object state)
{
ConnectionUtilities.ValidateBufferBounds(AsyncReadBufferSize, offset, size);
readCallback = callback;
try
{
SetReadTimeout(timeout);
IAsyncResult localResult = stream.BeginRead(AsyncReadBuffer, offset, size, onRead, state);
if (!localResult.CompletedSynchronously)
{
return AsyncReadResult.Queued;
}
bytesRead = stream.EndRead(localResult);
}
catch (IOException ioException)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(ConvertIOException(ioException));
}
return AsyncReadResult.Completed;
}
public int EndRead()
{
if (this.readResult != null)
{
IAsyncResult localResult = this.readResult;
this.readResult = null;
try
{
bytesRead = stream.EndRead(localResult);
}
catch (IOException ioException)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(ConvertIOException(ioException));
}
}
return bytesRead;
}
void OnRead(IAsyncResult result)
{
if (result.CompletedSynchronously)
{
return;
}
if (this.readResult != null)
{
DiagnosticUtility.DebugAssert("StreamConnection: OnRead called twice.");
throw DiagnosticUtility.ExceptionUtility.ThrowHelperInternal(false);
}
this.readResult = result;
readCallback(result.AsyncState);
}
}
class ConnectionMessageProperty
{
IConnection connection;
public ConnectionMessageProperty(IConnection connection)
{
this.connection = connection;
}
public static string Name
{
get { return "iconnection"; }
}
public IConnection Connection
{
get { return this.connection; }
}
}
static class ConnectionUtilities
{
internal static void CloseNoThrow(IConnection connection, TimeSpan timeout)
{
bool success = false;
try
{
connection.Close(timeout);
success = true;
}
catch (TimeoutException e)
{
if (DiagnosticUtility.ShouldTraceInformation)
{
DiagnosticUtility.ExceptionUtility.TraceHandledException(e, TraceEventType.Information);
}
}
catch (CommunicationException e)
{
if (DiagnosticUtility.ShouldTraceInformation)
{
DiagnosticUtility.ExceptionUtility.TraceHandledException(e, TraceEventType.Information);
}
}
finally
{
if (!success)
{
connection.Abort();
}
}
}
internal static void ValidateBufferBounds(ArraySegment buffer)
{
ValidateBufferBounds(buffer.Array, buffer.Offset, buffer.Count);
}
internal static void ValidateBufferBounds(byte[] buffer, int offset, int size)
{
if (buffer == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("buffer");
}
ValidateBufferBounds(buffer.Length, offset, size);
}
internal static void ValidateBufferBounds(int bufferSize, int offset, int size)
{
if (offset < 0)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("offset", offset, SR.GetString(
SR.ValueMustBeNonNegative)));
}
if (offset > bufferSize)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("offset", offset, SR.GetString(
SR.OffsetExceedsBufferSize, bufferSize)));
}
if (size <= 0)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("size", size, SR.GetString(
SR.ValueMustBePositive)));
}
int remainingBufferSpace = bufferSize - offset;
if (size > remainingBufferSpace)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("size", size, SR.GetString(
SR.SizeExceedsRemainingBufferSpace, remainingBufferSpace)));
}
}
}
}
// 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
- UriSection.cs
- AVElementHelper.cs
- UnauthorizedWebPart.cs
- Material.cs
- FrameSecurityDescriptor.cs
- DataListCommandEventArgs.cs
- PreProcessor.cs
- QilUnary.cs
- IsolatedStorageException.cs
- KeyboardNavigation.cs
- CodeRegionDirective.cs
- TextEditorSelection.cs
- RefreshEventArgs.cs
- RuleInfoComparer.cs
- Int32Animation.cs
- SessionSymmetricMessageSecurityProtocolFactory.cs
- XmlSerializableWriter.cs
- TypedReference.cs
- XNameConverter.cs
- UnrecognizedPolicyAssertionElement.cs
- WmlValidatorAdapter.cs
- PointUtil.cs
- MimeObjectFactory.cs
- HtmlInputSubmit.cs
- Timer.cs
- MetadataItem_Static.cs
- MarshalByRefObject.cs
- ALinqExpressionVisitor.cs
- XmlBinaryWriterSession.cs
- WhitespaceRuleReader.cs
- DataContract.cs
- Wildcard.cs
- VisualStyleInformation.cs
- TextModifierScope.cs
- QuaternionRotation3D.cs
- ProcessModuleCollection.cs
- ButtonBase.cs
- EmbeddedMailObjectsCollection.cs
- EmbeddedMailObject.cs
- ObjectDataSourceMethodEventArgs.cs
- XmlTextReaderImplHelpers.cs
- SmtpNtlmAuthenticationModule.cs
- DbConnectionFactory.cs
- PropertyItemInternal.cs
- DashStyles.cs
- DtdParser.cs
- PropertyGridEditorPart.cs
- ReadOnlyCollectionBase.cs
- GroupBoxRenderer.cs
- RequestCacheManager.cs
- ReadOnlyDictionary.cs
- TypeDescriptor.cs
- HtmlFormWrapper.cs
- DataSet.cs
- SoapMessage.cs
- SessionPageStatePersister.cs
- XmlParserContext.cs
- IntranetCredentialPolicy.cs
- WebRequest.cs
- SqlCacheDependencyDatabaseCollection.cs
- XmlSchemaObjectTable.cs
- AutoSizeComboBox.cs
- NotifyIcon.cs
- LineServicesCallbacks.cs
- ObjectTag.cs
- CodeTypeMemberCollection.cs
- TypefaceMetricsCache.cs
- TableAdapterManagerGenerator.cs
- WaitForChangedResult.cs
- ConfigurationLocation.cs
- MonthCalendar.cs
- DoubleCollection.cs
- Accessible.cs
- GB18030Encoding.cs
- CatalogPartDesigner.cs
- FormViewPageEventArgs.cs
- HelpProvider.cs
- DesignerRegionCollection.cs
- LineMetrics.cs
- XDeferredAxisSource.cs
- Journaling.cs
- WebPartCloseVerb.cs
- PageTextBox.cs
- RequestCacheValidator.cs
- XmlSchemaSet.cs
- ToolboxItemSnapLineBehavior.cs
- TextPointer.cs
- DynamicValidatorEventArgs.cs
- ChangeToolStripParentVerb.cs
- IdentitySection.cs
- MailDefinition.cs
- EntitySet.cs
- ChannelManager.cs
- CodeGenerator.cs
- ToolboxItemLoader.cs
- BaseValidator.cs
- GlyphingCache.cs
- MethodRental.cs
- ListBox.cs
- RolePrincipal.cs