Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

mcs/class/referencesource/System.Web/Abstractions/HttpApplicationStateBase.cs

@@ -0,0 +1,144 @@
+//------------------------------------------------------------------------------
+// <copyright file="HttpApplicationStateBase.cs" company="Microsoft">
+//     Copyright (c) Microsoft Corporation.  All rights reserved.
+// </copyright>
+//------------------------------------------------------------------------------
+
+namespace System.Web {
+    using System;
+    using System.Collections;
+    using System.Collections.Specialized;
+    using System.Diagnostics.CodeAnalysis;
+    using System.Runtime.CompilerServices;
+
+    [SuppressMessage("Microsoft.Naming", "CA1710:IdentifiersShouldHaveCorrectSuffix",
+        Justification = "This type is an abstraction for HttpApplicationState.")]
+    [SuppressMessage("Microsoft.Usage", "CA2237:MarkISerializableTypesWithSerializable",
+        Justification = "The abstraction is not meant to be serialized.")]
+    [TypeForwardedFrom("System.Web.Abstractions, Version=3.5.0.0, Culture=Neutral, PublicKeyToken=31bf3856ad364e35")]
+    public abstract class HttpApplicationStateBase : NameObjectCollectionBase, ICollection {
+
+        [SuppressMessage("Microsoft.Performance", "CA1819:PropertiesShouldNotReturnArrays",
+            Justification = "Matches HttpApplicationState class")]
+        public virtual string[] AllKeys {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual HttpApplicationStateBase Contents {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        [SuppressMessage("Microsoft.Security", "CA2123:OverrideLinkDemandsShouldBeIdenticalToBase")]
+        public override int Count {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        [SuppressMessage("Microsoft.Security", "CA2123:OverrideLinkDemandsShouldBeIdenticalToBase")]
+        public virtual bool IsSynchronized {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        [SuppressMessage("Microsoft.Security", "CA2123:OverrideLinkDemandsShouldBeIdenticalToBase")]
+        public virtual object SyncRoot {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual object this[int index] {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual object this[string name] {
+            get {
+                throw new NotImplementedException();
+            }
+            set {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual HttpStaticObjectsCollectionBase StaticObjects {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual void Add(string name, object value) {
+            throw new NotImplementedException();
+        }
+
+        public virtual void Clear() {
+            throw new NotImplementedException();
+        }
+
+        [SuppressMessage("Microsoft.Security", "CA2123:OverrideLinkDemandsShouldBeIdenticalToBase")]
+        public virtual void CopyTo(Array array, int index) {
+            throw new NotImplementedException();
+        }
+
+        [SuppressMessage("Microsoft.Naming", "CA1716:IdentifiersShouldNotMatchKeywords", MessageId = "Get",
+            Justification = "Matches HttpApplicationState class")]
+        public virtual object Get(int index) {
+            throw new NotImplementedException();
+        }
+
+        [SuppressMessage("Microsoft.Naming", "CA1716:IdentifiersShouldNotMatchKeywords", MessageId = "Get",
+            Justification = "Matches HttpApplicationState class")]
+        public virtual object Get(string name) {
+            throw new NotImplementedException();
+        }
+
+        [SuppressMessage("Microsoft.Security", "CA2123:OverrideLinkDemandsShouldBeIdenticalToBase")]
+        public override IEnumerator GetEnumerator() {
+            throw new NotImplementedException();
+        }
+
+        public virtual string GetKey(int index) {
+            throw new NotImplementedException();
+        }
+
+        public virtual void Lock() {
+            throw new NotImplementedException();
+        }
+
+        public virtual void Remove(string name) {
+            throw new NotImplementedException();
+        }
+
+        public virtual void RemoveAll() {
+            throw new NotImplementedException();
+        }
+
+        public virtual void RemoveAt(int index) {
+            throw new NotImplementedException();
+        }
+
+        [SuppressMessage("Microsoft.Naming", "CA1716:IdentifiersShouldNotMatchKeywords", MessageId = "Set",
+            Justification = "Matches HttpApplicationState class")]
+        public virtual void Set(string name, object value) {
+            throw new NotImplementedException();
+        }
+
+        [SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "Un",
+            Justification = "Matches HttpApplicationState class")]
+        [SuppressMessage("Microsoft.Naming", "CA1702:CompoundWordsShouldBeCasedCorrectly", MessageId = "UnLock",
+            Justification = "Matched HttpApplicationState class")]
+        [SuppressMessage("Microsoft.Naming", "CA1706:ShortAcronymsShouldBeUppercase", MessageId="UnLock",
+            Justification = "Matched HttpApplicationState class")]
+        public virtual void UnLock() {
+            throw new NotImplementedException();
+        }
+
+    }
+}

mcs/class/referencesource/System.Web/Abstractions/HttpApplicationStateWrapper.cs

@@ -0,0 +1,156 @@
+//------------------------------------------------------------------------------
+// <copyright file="HttpApplicationStateWrapper.cs" company="Microsoft">
+//     Copyright (c) Microsoft Corporation.  All rights reserved.
+// </copyright>
+//------------------------------------------------------------------------------
+
+namespace System.Web {
+    using System;
+    using System.Collections;
+    using System.Collections.Specialized;
+    using System.Diagnostics.CodeAnalysis;
+    using System.Runtime.Serialization;
+    using System.Security.Permissions;
+    using System.Runtime.CompilerServices;
+
+    [SuppressMessage("Microsoft.Security", "CA2126:TypeLinkDemandsRequireInheritanceDemands", Justification="Workaround for FxCop Bug")]
+    [SuppressMessage("Microsoft.Naming", "CA1710:IdentifiersShouldHaveCorrectSuffix",
+        Justification = "This type is an abstraction for HttpApplicationState.")]
+    [TypeForwardedFrom("System.Web.Abstractions, Version=3.5.0.0, Culture=Neutral, PublicKeyToken=31bf3856ad364e35")]
+    public class HttpApplicationStateWrapper : HttpApplicationStateBase {
+
+        private HttpApplicationState _application;
+
+        public HttpApplicationStateWrapper(HttpApplicationState httpApplicationState) {
+            if (httpApplicationState == null) {
+                throw new ArgumentNullException("httpApplicationState");
+            }
+            _application = httpApplicationState;
+        }
+
+        public override string[] AllKeys {
+            get {
+                return _application.AllKeys;
+            }
+        }
+
+        public override HttpApplicationStateBase Contents {
+            get {
+                return this;
+            }
+        }
+
+        [SuppressMessage("Microsoft.Security", "CA2123:OverrideLinkDemandsShouldBeIdenticalToBase")]
+        public override int Count {
+            get {
+                return _application.Count;
+            }
+        }
+
+        public override bool IsSynchronized {
+            get {
+                return ((ICollection)_application).IsSynchronized;
+            }
+        }
+
+        [SuppressMessage("Microsoft.Security", "CA2123:OverrideLinkDemandsShouldBeIdenticalToBase")]
+        public override NameObjectCollectionBase.KeysCollection Keys {
+            get {
+                return _application.Keys;
+            }
+        }
+
+        public override object SyncRoot {
+            get {
+                return ((ICollection)_application).SyncRoot;
+            }
+        }
+
+        public override object this[int index] {
+            get {
+                return _application[index];
+            }
+        }
+
+        public override object this[string name] {
+            get {
+                return _application[name];
+            }
+            set {
+                _application[name] = value;
+            }
+        }
+
+        public override HttpStaticObjectsCollectionBase StaticObjects {
+            get {
+                // method returns an empty collection rather than null
+                return new HttpStaticObjectsCollectionWrapper(_application.StaticObjects);
+            }
+        }
+
+        public override void Add(string name, object value) {
+            _application.Add(name, value);
+        }
+
+        public override void Clear() {
+            _application.Clear();
+        }
+
+        public override void CopyTo(Array array, int index) {
+            ((ICollection)_application).CopyTo(array, index);
+        }
+
+        public override object Get(int index) {
+            return _application.Get(index);
+        }
+
+        public override object Get(string name) {
+            return _application.Get(name);
+        }
+
+        public override IEnumerator GetEnumerator() {
+            return ((IEnumerable)_application).GetEnumerator();
+        }
+
+        public override string GetKey(int index) {
+            return _application.GetKey(index);
+        }
+
+        [SuppressMessage("Microsoft.Security", "CA2114:MethodSecurityShouldBeASupersetOfType", Justification = "Workaround for FxCop Bug")]
+        [SuppressMessage("Microsoft.Security", "CA2123:OverrideLinkDemandsShouldBeIdenticalToBase")]
+        [SecurityPermission(SecurityAction.Demand, SerializationFormatter=true)]
+        public override void GetObjectData(SerializationInfo info, StreamingContext context) {
+            _application.GetObjectData(info, context);
+        }
+
+        public override void Lock() {
+            _application.Lock();
+        }
+
+        [SuppressMessage("Microsoft.Security", "CA2123:OverrideLinkDemandsShouldBeIdenticalToBase")]
+        public override void OnDeserialization(object sender) {
+            _application.OnDeserialization(sender);
+        }
+
+        public override void Remove(string name) {
+            _application.Remove(name);
+        }
+
+        public override void RemoveAll() {
+            _application.RemoveAll();
+        }
+
+        public override void RemoveAt(int index) {
+            _application.RemoveAt(index);
+        }
+
+        public override void Set(string name, object value) {
+            _application.Set(name, value);
+        }
+
+        public override void UnLock() {
+            _application.UnLock();
+        }
+
+    }
+}

mcs/class/referencesource/System.Web/Abstractions/HttpCachePolicyBase.cs

@@ -0,0 +1,119 @@
+//------------------------------------------------------------------------------
+// <copyright file="HttpCachePolicyBase.cs" company="Microsoft">
+//     Copyright (c) Microsoft Corporation.  All rights reserved.
+// </copyright>
+//------------------------------------------------------------------------------
+
+namespace System.Web {
+    using System.Diagnostics.CodeAnalysis;
+    using System.Runtime.CompilerServices;
+
+    [TypeForwardedFrom("System.Web.Abstractions, Version=3.5.0.0, Culture=Neutral, PublicKeyToken=31bf3856ad364e35")]
+    public abstract class HttpCachePolicyBase {
+        public virtual HttpCacheVaryByContentEncodings VaryByContentEncodings {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual HttpCacheVaryByHeaders VaryByHeaders {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        [SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly",
+            Justification = "Matches HttpCachePolicy class")]
+        public virtual HttpCacheVaryByParams VaryByParams {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual void AddValidationCallback(HttpCacheValidateHandler handler, object data) {
+            throw new NotImplementedException();
+        }
+
+        public virtual void AppendCacheExtension(string extension) {
+            throw new NotImplementedException();
+        }
+
+        public virtual void SetAllowResponseInBrowserHistory(bool allow) {
+            throw new NotImplementedException();
+        }
+
+        public virtual void SetCacheability(HttpCacheability cacheability) {
+            throw new NotImplementedException();
+        }
+
+        public virtual void SetCacheability(HttpCacheability cacheability, string field) {
+            throw new NotImplementedException();
+        }
+
+        [SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly",
+            Justification = "Matches HttpCachePolicy class")]
+        public virtual void SetETag(string etag) {
+            throw new NotImplementedException();
+        }
+
+        public virtual void SetETagFromFileDependencies() {
+            throw new NotImplementedException();
+        }
+
+        [SuppressMessage("Microsoft.Naming", "CA1716:IdentifiersShouldNotMatchKeywords", MessageId = "Date",
+            Justification = "Matches HttpCachePolicy class")]
+        public virtual void SetExpires(DateTime date) {
+            throw new NotImplementedException();
+        }
+
+        [SuppressMessage("Microsoft.Naming", "CA1716:IdentifiersShouldNotMatchKeywords", MessageId = "Date",
+            Justification = "Matches HttpCachePolicy class")]
+        public virtual void SetLastModified(DateTime date) {
+            throw new NotImplementedException();
+        }
+
+        public virtual void SetLastModifiedFromFileDependencies() {
+            throw new NotImplementedException();
+        }
+
+        public virtual void SetMaxAge(TimeSpan delta) {
+            throw new NotImplementedException();
+        }
+
+        public virtual void SetNoServerCaching() {
+            throw new NotImplementedException();
+        }
+
+        public virtual void SetNoStore() {
+            throw new NotImplementedException();
+        }
+
+        public virtual void SetNoTransforms() {
+            throw new NotImplementedException();
+        }
+
+        public virtual void SetOmitVaryStar(bool omit) {
+            throw new NotImplementedException();
+        }
+
+        public virtual void SetProxyMaxAge(TimeSpan delta) {
+            throw new NotImplementedException();
+        }
+
+        public virtual void SetRevalidation(HttpCacheRevalidation revalidation) {
+            throw new NotImplementedException();
+        }
+
+        public virtual void SetSlidingExpiration(bool slide) {
+            throw new NotImplementedException();
+        }
+
+        public virtual void SetValidUntilExpires(bool validUntilExpires) {
+            throw new NotImplementedException();
+        }
+
+        public virtual void SetVaryByCustom(string custom) {
+            throw new NotImplementedException();
+        }
+    }
+}

mcs/class/referencesource/System.Web/Abstractions/HttpCachePolicyWrapper.cs

@@ -0,0 +1,119 @@
+//------------------------------------------------------------------------------
+// <copyright file="HttpCachePolicyWrapper.cs" company="Microsoft">
+//     Copyright (c) Microsoft Corporation.  All rights reserved.
+// </copyright>
+//------------------------------------------------------------------------------
+
+namespace System.Web {
+    using System.Runtime.CompilerServices;
+
+    [TypeForwardedFrom("System.Web.Abstractions, Version=3.5.0.0, Culture=Neutral, PublicKeyToken=31bf3856ad364e35")]
+    public class HttpCachePolicyWrapper : HttpCachePolicyBase {
+        private HttpCachePolicy _httpCachePolicy;
+
+        public HttpCachePolicyWrapper(HttpCachePolicy httpCachePolicy) {
+            if (httpCachePolicy == null) {
+                throw new ArgumentNullException("httpCachePolicy");
+            }
+            _httpCachePolicy = httpCachePolicy;
+        }
+
+        public override HttpCacheVaryByContentEncodings VaryByContentEncodings {
+            get {
+                return _httpCachePolicy.VaryByContentEncodings;
+            }
+        }
+
+        public override HttpCacheVaryByHeaders VaryByHeaders {
+            get {
+                return _httpCachePolicy.VaryByHeaders;
+            }
+        }
+
+        public override HttpCacheVaryByParams VaryByParams {
+            get {
+                return _httpCachePolicy.VaryByParams;
+            }
+        }
+
+        public override void AddValidationCallback(HttpCacheValidateHandler handler, object data) {
+            _httpCachePolicy.AddValidationCallback(handler, data);
+        }
+
+        public override void AppendCacheExtension(string extension) {
+            _httpCachePolicy.AppendCacheExtension(extension);
+        }
+
+        public override void SetAllowResponseInBrowserHistory(bool allow) {
+            _httpCachePolicy.SetAllowResponseInBrowserHistory(allow);
+        }
+
+        public override void SetCacheability(HttpCacheability cacheability) {
+            _httpCachePolicy.SetCacheability(cacheability);
+        }
+
+        public override void SetCacheability(HttpCacheability cacheability, string field) {
+            _httpCachePolicy.SetCacheability(cacheability, field);
+        }
+
+        public override void SetETag(string etag) {
+            _httpCachePolicy.SetETag(etag);
+        }
+
+        public override void SetETagFromFileDependencies() {
+            _httpCachePolicy.SetETagFromFileDependencies();
+        }
+
+        public override void SetExpires(DateTime date) {
+            _httpCachePolicy.SetExpires(date);
+        }
+
+        public override void SetLastModified(DateTime date) {
+            _httpCachePolicy.SetLastModified(date);
+        }
+
+        public override void SetLastModifiedFromFileDependencies() {
+            _httpCachePolicy.SetLastModifiedFromFileDependencies();
+        }
+
+        public override void SetMaxAge(TimeSpan delta) {
+            _httpCachePolicy.SetMaxAge(delta);
+        }
+
+        public override void SetNoServerCaching() {
+            _httpCachePolicy.SetNoServerCaching();
+        }
+
+        public override void SetNoStore() {
+            _httpCachePolicy.SetNoStore();
+        }
+
+        public override void SetNoTransforms() {
+            _httpCachePolicy.SetNoTransforms();
+        }
+
+        public override void SetOmitVaryStar(bool omit) {
+            _httpCachePolicy.SetOmitVaryStar(omit);
+        }
+
+        public override void SetProxyMaxAge(TimeSpan delta) {
+            _httpCachePolicy.SetProxyMaxAge(delta);
+        }
+
+        public override void SetRevalidation(HttpCacheRevalidation revalidation) {
+            _httpCachePolicy.SetRevalidation(revalidation);
+        }
+
+        public override void SetSlidingExpiration(bool slide) {
+            _httpCachePolicy.SetSlidingExpiration(slide);
+        }
+
+        public override void SetValidUntilExpires(bool validUntilExpires) {
+            _httpCachePolicy.SetValidUntilExpires(validUntilExpires);
+        }
+
+        public override void SetVaryByCustom(string custom) {
+            _httpCachePolicy.SetVaryByCustom(custom);
+        }
+    }
+}

mcs/class/referencesource/System.Web/Abstractions/HttpContextBase.cs

@@ -0,0 +1,318 @@
+//------------------------------------------------------------------------------
+// <copyright file="HttpContextBase.cs" company="Microsoft">
+//     Copyright (c) Microsoft Corporation.  All rights reserved.
+// </copyright>
+//------------------------------------------------------------------------------
+
+namespace System.Web {
+    using System;
+    using System.Collections;
+    using System.Collections.Generic;
+    using System.ComponentModel;
+    using System.Diagnostics.CodeAnalysis;
+    using System.Globalization;
+    using System.Runtime.CompilerServices;
+    using System.Security.Principal;
+    using System.Threading.Tasks;
+    using System.Web.Caching;
+    using System.Web.Configuration;
+    using System.Web.Instrumentation;
+    using System.Web.Profile;
+    using System.Web.SessionState;
+    using System.Web.WebSockets;
+
+    [TypeForwardedFrom("System.Web.Abstractions, Version=3.5.0.0, Culture=Neutral, PublicKeyToken=31bf3856ad364e35")]
+    [SuppressMessage("Microsoft.Usage", "CA2302:FlagServiceProviders", Justification ="IServiceProvider implementation is not supported on this abstract class.")]
+    public abstract class HttpContextBase : IServiceProvider
+    {
+        [SuppressMessage("Microsoft.Design", "CA1030:UseEventsWhereAppropriate", Justification = @"The normal event pattern doesn't work between HttpContext and HttpContextBase since the signatures differ.")]
+        public virtual ISubscriptionToken AddOnRequestCompleted(Action<HttpContextBase> callback) {
+            throw new NotImplementedException();
+        }
+
+        [SuppressMessage("Microsoft.Performance", "CA1819:PropertiesShouldNotReturnArrays",
+            Justification = "Matches HttpContext class")]
+        public virtual Exception[] AllErrors {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        [EditorBrowsable(EditorBrowsableState.Advanced)]
+        public virtual bool AllowAsyncDuringSyncStages {
+            get {
+                throw new NotImplementedException();
+            }
+            set {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual HttpApplicationStateBase Application {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual HttpApplication ApplicationInstance {
+            get {
+                throw new NotImplementedException();
+            }
+            set {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual AsyncPreloadModeFlags AsyncPreloadMode {
+            get {
+                throw new NotImplementedException();
+            }
+            set {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual Cache Cache {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual IHttpHandler CurrentHandler {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual RequestNotification CurrentNotification {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        [SuppressMessage("Microsoft.Naming", "CA1716:IdentifiersShouldNotMatchKeywords", MessageId = "Error",
+            Justification = "Matches HttpContext class")]
+        public virtual Exception Error {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual IHttpHandler Handler {
+            get {
+                throw new NotImplementedException();
+            }
+            set {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual bool IsCustomErrorEnabled {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual bool IsDebuggingEnabled {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual bool IsPostNotification {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual bool IsWebSocketRequest {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual bool IsWebSocketRequestUpgrading {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual IDictionary Items {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual PageInstrumentationService PageInstrumentation {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual IHttpHandler PreviousHandler {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual ProfileBase Profile {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual HttpRequestBase Request {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual HttpResponseBase Response {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual HttpServerUtilityBase Server {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual HttpSessionStateBase Session {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual bool SkipAuthorization {
+            get {
+                throw new NotImplementedException();
+            }
+            set {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual DateTime Timestamp {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual bool ThreadAbortOnTimeout {
+            get {
+                throw new NotImplementedException();
+            }
+            set {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual TraceContext Trace {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual IPrincipal User {
+            get {
+                throw new NotImplementedException();
+            }
+            set {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual string WebSocketNegotiatedProtocol {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual IList<string> WebSocketRequestedProtocols {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual void AcceptWebSocketRequest(Func<AspNetWebSocketContext, Task> userFunc) {
+            throw new NotImplementedException();
+        }
+
+        public virtual void AcceptWebSocketRequest(Func<AspNetWebSocketContext, Task> userFunc, AspNetWebSocketOptions options) {
+            throw new NotImplementedException();
+        }       
+
+        public virtual void AddError(Exception errorInfo) {
+            throw new NotImplementedException();
+        }
+
+        public virtual void ClearError() {
+            throw new NotImplementedException();
+        }
+
+        public virtual ISubscriptionToken DisposeOnPipelineCompleted(IDisposable target) {
+            throw new NotImplementedException();
+        }
+
+        public virtual object GetGlobalResourceObject(string classKey, string resourceKey) {
+            throw new NotImplementedException();
+        }
+
+        public virtual object GetGlobalResourceObject(string classKey, string resourceKey, CultureInfo culture) {
+            throw new NotImplementedException();
+        }
+
+        public virtual object GetLocalResourceObject(string virtualPath, string resourceKey) {
+            throw new NotImplementedException();
+        }
+
+        public virtual object GetLocalResourceObject(string virtualPath, string resourceKey, CultureInfo culture) {
+            throw new NotImplementedException();
+        }
+
+        public virtual object GetSection(string sectionName) {
+            throw new NotImplementedException();
+        }
+
+        public virtual void RemapHandler(IHttpHandler handler) {
+            throw new NotImplementedException();
+        }
+
+        [SuppressMessage("Microsoft.Naming", "CA1720:AvoidTypeNamesInParameters",
+            Justification = "Matches HttpContext class")]
+        public virtual void RewritePath(string path) {
+            throw new NotImplementedException();
+        }
+
+        [SuppressMessage("Microsoft.Naming", "CA1720:AvoidTypeNamesInParameters",
+            Justification = "Matches HttpContext class")]
+        public virtual void RewritePath(string path, bool rebaseClientPath) {
+            throw new NotImplementedException();
+        }
+
+        [SuppressMessage("Microsoft.Naming", "CA1720:AvoidTypeNamesInParameters",
+            Justification = "Matches HttpContext class")]
+        public virtual void RewritePath(string filePath, string pathInfo, string queryString) {
+            throw new NotImplementedException();
+        }
+
+        [SuppressMessage("Microsoft.Naming", "CA1720:AvoidTypeNamesInParameters",
+            Justification = "Matches HttpContext class")]
+        public virtual void RewritePath(string filePath, string pathInfo, string queryString, bool setClientFilePath) {
+            throw new NotImplementedException();
+        }
+
+        public virtual void SetSessionStateBehavior(SessionStateBehavior sessionStateBehavior) {
+            throw new NotImplementedException();
+        }
+
+        #region IServiceProvider Members
+        [SuppressMessage("Microsoft.Security", "CA2123:OverrideLinkDemandsShouldBeIdenticalToBase")]
+        public virtual object GetService(Type serviceType) {
+            throw new NotImplementedException();
+        }
+        #endregion
+    }
+}

mcs/class/referencesource/System.Web/Abstractions/HttpContextWrapper.cs

@@ -0,0 +1,327 @@
+//------------------------------------------------------------------------------
+// <copyright file="HttpContextWrapper2.cs" company="Microsoft">
+//     Copyright (c) Microsoft Corporation.  All rights reserved.
+// </copyright>
+//------------------------------------------------------------------------------
+
+namespace System.Web {
+    using System;
+    using System.Collections;
+    using System.Collections.Generic;
+    using System.ComponentModel;
+    using System.Diagnostics.CodeAnalysis;
+    using System.Globalization;
+    using System.Runtime.CompilerServices;
+    using System.Security.Principal;
+    using System.Threading.Tasks;
+    using System.Web.Caching;
+    using System.Web.Configuration;
+    using System.Web.Instrumentation;
+    using System.Web.Profile;
+    using System.Web.SessionState;
+    using System.Web.WebSockets;
+
+    [TypeForwardedFrom("System.Web.Abstractions, Version=3.5.0.0, Culture=Neutral, PublicKeyToken=31bf3856ad364e35")]
+    public class HttpContextWrapper : HttpContextBase {
+        private readonly HttpContext _context;
+
+        public HttpContextWrapper(HttpContext httpContext) {
+            if (httpContext == null) {
+                throw new ArgumentNullException("httpContext");
+            }
+            _context = httpContext;
+        }
+
+        public override ISubscriptionToken AddOnRequestCompleted(Action<HttpContextBase> callback) {
+            return _context.AddOnRequestCompleted(WrapCallback(callback));
+        }
+
+        public override Exception[] AllErrors {
+            get {
+                return _context.AllErrors;
+            }
+        }
+
+        [EditorBrowsable(EditorBrowsableState.Advanced)]
+        public override bool AllowAsyncDuringSyncStages {
+            get {
+                return _context.AllowAsyncDuringSyncStages;
+            }
+            set {
+                _context.AllowAsyncDuringSyncStages = value;
+            }
+        }
+
+        public override HttpApplicationStateBase Application {
+            get {
+                return new HttpApplicationStateWrapper(_context.Application);
+            }
+        }
+
+        //
+        public override HttpApplication ApplicationInstance {
+            get {
+                return _context.ApplicationInstance;
+            }
+            set {
+                _context.ApplicationInstance = value;
+            }
+        }
+
+        public override AsyncPreloadModeFlags AsyncPreloadMode {
+            get {
+                return _context.AsyncPreloadMode;
+            }
+            set {
+                _context.AsyncPreloadMode = value;
+            }
+        }
+
+        //
+        public override Cache Cache {
+            get {
+                return _context.Cache;
+            }
+        }
+
+        public override IHttpHandler CurrentHandler {
+            get {
+                return _context.CurrentHandler;
+            }
+        }
+
+        public override RequestNotification CurrentNotification {
+            get {
+                return _context.CurrentNotification;
+            }
+        }
+
+        public override Exception Error {
+            get {
+                return _context.Error;
+            }
+        }
+
+        public override IHttpHandler Handler {
+            get {
+                return _context.Handler;
+            }
+            set {
+                _context.Handler = value;
+            }
+        }
+
+        public override bool IsCustomErrorEnabled {
+            get {
+                return _context.IsCustomErrorEnabled;
+            }
+        }
+
+        public override bool IsDebuggingEnabled {
+            get {
+                return _context.IsDebuggingEnabled;
+            }
+        }
+
+        public override bool IsPostNotification {
+            get {
+                return _context.IsPostNotification;
+            }
+        }
+
+        public override bool IsWebSocketRequest {
+            get {
+                return _context.IsWebSocketRequest;
+            }
+        }
+
+        public override bool IsWebSocketRequestUpgrading {
+            get {
+                return _context.IsWebSocketRequestUpgrading;
+            }
+        }
+
+        public override IDictionary Items {
+            get {
+                return _context.Items;
+            }
+        }
+
+        public override PageInstrumentationService PageInstrumentation {
+            get {
+                return _context.PageInstrumentation;
+            }
+        }
+
+        public override IHttpHandler PreviousHandler {
+            get {
+                return _context.PreviousHandler;
+            }
+        }
+
+        //
+        public override ProfileBase Profile {
+            get {
+                return _context.Profile;
+            }
+        }
+
+        public override HttpRequestBase Request {
+            get {
+                return new HttpRequestWrapper(_context.Request);
+            }
+        }
+
+        public override HttpResponseBase Response {
+            get {
+                return new HttpResponseWrapper(_context.Response);
+            }
+        }
+
+        public override HttpServerUtilityBase Server {
+            get {
+                return new HttpServerUtilityWrapper(_context.Server);
+            }
+        }
+
+        public override HttpSessionStateBase Session {
+            get {
+                HttpSessionState session = _context.Session;
+                return (session != null) ? new HttpSessionStateWrapper(session) : null;
+            }
+        }
+
+        public override bool SkipAuthorization {
+            get {
+                return _context.SkipAuthorization;
+            }
+            set {
+                _context.SkipAuthorization = value;
+            }
+        }
+
+        public override DateTime Timestamp {
+            get {
+                return _context.Timestamp;
+            }
+        }
+
+        public override bool ThreadAbortOnTimeout {
+            get {
+                return _context.ThreadAbortOnTimeout;
+            }
+            set {
+                _context.ThreadAbortOnTimeout = value;
+            }
+        }
+
+        //
+        public override TraceContext Trace {
+            get {
+                return _context.Trace;
+            }
+        }
+
+        public override IPrincipal User {
+            get {
+                return _context.User;
+            }
+            set {
+                _context.User = value;
+            }
+        }
+
+        public override string WebSocketNegotiatedProtocol {
+            get {
+                return _context.WebSocketNegotiatedProtocol;
+            }
+        }
+
+        public override IList<string> WebSocketRequestedProtocols {
+            get {
+                return _context.WebSocketRequestedProtocols;
+            }
+        }
+
+        public override void AcceptWebSocketRequest(Func<AspNetWebSocketContext, Task> userFunc) {
+            _context.AcceptWebSocketRequest(userFunc);
+        }
+
+        public override void AcceptWebSocketRequest(Func<AspNetWebSocketContext, Task> userFunc, AspNetWebSocketOptions options) {
+            _context.AcceptWebSocketRequest(userFunc, options);
+        }    
+
+        public override void AddError(Exception errorInfo) {
+            _context.AddError(errorInfo);
+        }
+
+        public override void ClearError() {
+            _context.ClearError();
+        }
+
+        public override ISubscriptionToken DisposeOnPipelineCompleted(IDisposable target) {
+            return _context.DisposeOnPipelineCompleted(target);
+        }
+
+        [SuppressMessage("Microsoft.Globalization", "CA1304:SpecifyCultureInfo",
+            Justification = "Matches HttpContext class")]
+        public override object GetGlobalResourceObject(string classKey, string resourceKey) {
+            return HttpContext.GetGlobalResourceObject(classKey, resourceKey);
+        }
+
+        public override object GetGlobalResourceObject(string classKey, string resourceKey, CultureInfo culture) {
+            return HttpContext.GetGlobalResourceObject(classKey, resourceKey, culture);
+        }
+
+        [SuppressMessage("Microsoft.Globalization", "CA1304:SpecifyCultureInfo",
+            Justification = "Matches HttpContext class")]
+        public override object GetLocalResourceObject(string virtualPath, string resourceKey) {
+            return HttpContext.GetLocalResourceObject(virtualPath, resourceKey);
+        }
+
+        public override object GetLocalResourceObject(string virtualPath, string resourceKey, CultureInfo culture) {
+            return HttpContext.GetLocalResourceObject(virtualPath, resourceKey, culture);
+        }
+
+        public override object GetSection(string sectionName) {
+            return _context.GetSection(sectionName);
+        }
+
+        public override void RemapHandler(IHttpHandler handler) {
+            _context.RemapHandler(handler);
+        }
+
+        public override void RewritePath(string path) {
+            _context.RewritePath(path);
+        }
+
+        public override void RewritePath(string path, bool rebaseClientPath) {
+            _context.RewritePath(path, rebaseClientPath);
+        }
+
+        public override void RewritePath(string filePath, string pathInfo, string queryString) {
+            _context.RewritePath(filePath, pathInfo, queryString);
+        }
+
+        public override void RewritePath(string filePath, string pathInfo, string queryString, bool setClientFilePath) {
+            _context.RewritePath(filePath, pathInfo, queryString, setClientFilePath);
+        }
+
+        public override void SetSessionStateBehavior(SessionStateBehavior sessionStateBehavior) {
+            _context.SetSessionStateBehavior(sessionStateBehavior);
+        }
+
+        public override object GetService(Type serviceType) {
+            return ((IServiceProvider)_context).GetService(serviceType);
+        }
+
+        internal static Action<HttpContext> WrapCallback(Action<HttpContextBase> callback) {
+            if (callback != null) {
+                return context => callback(new HttpContextWrapper(context));
+            }
+            else {
+                return null;
+            }
+        }
+    }
+}

mcs/class/referencesource/System.Web/Abstractions/HttpFileCollectionBase.cs

@@ -0,0 +1,98 @@
+//------------------------------------------------------------------------------
+// <copyright file="HttpFileCollectionBase.cs" company="Microsoft">
+//     Copyright (c) Microsoft Corporation.  All rights reserved.
+// </copyright>
+//------------------------------------------------------------------------------
+
+namespace System.Web {
+    using System;
+    using System.Collections;
+    using System.Collections.Generic;
+    using System.Collections.Specialized;
+    using System.Diagnostics.CodeAnalysis;
+    using System.Runtime.CompilerServices;
+
+    [TypeForwardedFrom("System.Web.Abstractions, Version=3.5.0.0, Culture=Neutral, PublicKeyToken=31bf3856ad364e35")]
+    [SuppressMessage("Microsoft.Naming", "CA1710:IdentifiersShouldHaveCorrectSuffix",
+        Justification = "This type is an abstraction for HttpFileCollectionBase.")]
+    [SuppressMessage("Microsoft.Usage", "CA2237:MarkISerializableTypesWithSerializable",
+        Justification = "The abstraction is not meant to be serialized.")]
+    public abstract class HttpFileCollectionBase : NameObjectCollectionBase, ICollection {
+
+        [SuppressMessage("Microsoft.Performance", "CA1819:PropertiesShouldNotReturnArrays",
+            Justification = "Matches HttpFileCollectionBase class")]
+        public virtual string[] AllKeys {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        [SuppressMessage("Microsoft.Security", "CA2123:OverrideLinkDemandsShouldBeIdenticalToBase")]
+        public override int Count {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        [SuppressMessage("Microsoft.Security", "CA2123:OverrideLinkDemandsShouldBeIdenticalToBase")]
+        public virtual bool IsSynchronized {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        [SuppressMessage("Microsoft.Security", "CA2123:OverrideLinkDemandsShouldBeIdenticalToBase")]
+        public virtual object SyncRoot {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual HttpPostedFileBase this[string name] {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual HttpPostedFileBase this[int index] {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        [SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "dest",
+            Justification = "Matches HttpFileCollectionBase class")]
+        [SuppressMessage("Microsoft.Security", "CA2123:OverrideLinkDemandsShouldBeIdenticalToBase")]
+        public virtual void CopyTo(Array dest, int index) {
+            throw new NotImplementedException();
+        }
+
+        [SuppressMessage("Microsoft.Naming", "CA1716:IdentifiersShouldNotMatchKeywords", MessageId = "Get",
+            Justification = "Matches HttpFileCollection class")]
+        public virtual HttpPostedFileBase Get(int index) {
+            throw new NotImplementedException();
+        }
+
+        [SuppressMessage("Microsoft.Naming", "CA1716:IdentifiersShouldNotMatchKeywords", MessageId = "Get",
+            Justification = "Matches HttpFileCollection class")]
+        public virtual HttpPostedFileBase Get(string name) {
+            throw new NotImplementedException();
+        }
+
+        [SuppressMessage("Microsoft.Naming", "CA1716:IdentifiersShouldNotMatchKeywords", MessageId = "Get",
+            Justification = "Matches HttpFileCollection class")]
+        public virtual IList<HttpPostedFileBase> GetMultiple(string name) {
+            throw new NotImplementedException();
+        }
+
+        [SuppressMessage("Microsoft.Security", "CA2123:OverrideLinkDemandsShouldBeIdenticalToBase")]
+        public override IEnumerator GetEnumerator() {
+            throw new NotImplementedException();
+        }
+
+        public virtual string GetKey(int index) {
+            throw new NotImplementedException();
+        }
+
+    }
+}

mcs/class/referencesource/System.Web/Abstractions/HttpFileCollectionWrapper.cs

@@ -0,0 +1,120 @@
+//------------------------------------------------------------------------------
+// <copyright file="HttpFileCollectionWrapper.cs" company="Microsoft">
+//     Copyright (c) Microsoft Corporation.  All rights reserved.
+// </copyright>
+//------------------------------------------------------------------------------
+
+namespace System.Web {
+    using System;
+    using System.Collections;
+    using System.Collections.Generic;
+    using System.Collections.Specialized;
+    using System.Diagnostics;
+    using System.Diagnostics.CodeAnalysis;
+    using System.Linq;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.Serialization;
+    using System.Security.Permissions;
+
+    [TypeForwardedFrom("System.Web.Abstractions, Version=3.5.0.0, Culture=Neutral, PublicKeyToken=31bf3856ad364e35")]
+    [SuppressMessage("Microsoft.Security", "CA2126:TypeLinkDemandsRequireInheritanceDemands", Justification = "Workaround for FxCop Bug")]
+    [SuppressMessage("Microsoft.Naming", "CA1710:IdentifiersShouldHaveCorrectSuffix",
+        Justification = "This type is an abstraction for HttpFileCollection.")]
+    public class HttpFileCollectionWrapper : HttpFileCollectionBase {
+
+        private HttpFileCollection _collection;
+
+        public HttpFileCollectionWrapper(HttpFileCollection httpFileCollection) {
+            if (httpFileCollection == null) {
+                throw new ArgumentNullException("httpFileCollection");
+            }
+            _collection = httpFileCollection;
+        }
+
+        public override string[] AllKeys {
+            get {
+                return _collection.AllKeys;
+            }
+        }
+
+        public override int Count {
+            get {
+                return ((ICollection)_collection).Count;
+            }
+        }
+
+        public override bool IsSynchronized {
+            get {
+                return ((ICollection)_collection).IsSynchronized;
+            }
+        }
+
+        [SuppressMessage("Microsoft.Security", "CA2123:OverrideLinkDemandsShouldBeIdenticalToBase")]
+        public override NameObjectCollectionBase.KeysCollection Keys {
+            get {
+                return _collection.Keys;
+            }
+        }
+
+        public override object SyncRoot {
+            get {
+                return ((ICollection)_collection).SyncRoot;
+            }
+        }
+
+        public override HttpPostedFileBase this[string name] {
+            get {
+                HttpPostedFile file = _collection[name];
+                return (file != null) ? new HttpPostedFileWrapper(file) : null;
+            }
+        }
+
+        public override HttpPostedFileBase this[int index] {
+            get {
+                HttpPostedFile file = _collection[index];
+                return (file != null) ? new HttpPostedFileWrapper(file) : null;
+            }
+        }
+
+        public override void CopyTo(Array dest, int index) {
+            _collection.CopyTo(dest, index);
+        }
+
+        public override HttpPostedFileBase Get(int index) {
+            HttpPostedFile file = _collection.Get(index);
+            return (file != null) ? new HttpPostedFileWrapper(file) : null;
+        }
+
+        public override HttpPostedFileBase Get(string name) {
+            HttpPostedFile file = _collection.Get(name);
+            return (file != null) ? new HttpPostedFileWrapper(file) : null;
+        }
+
+        public override IList<HttpPostedFileBase> GetMultiple(string name) {
+            ICollection<HttpPostedFile> files = _collection.GetMultiple(name);
+            Debug.Assert(files != null);
+            return files.Select(f => (HttpPostedFileBase)new HttpPostedFileWrapper(f)).ToList().AsReadOnly();
+        }
+
+        public override IEnumerator GetEnumerator() {
+            return ((IEnumerable)_collection).GetEnumerator();
+        }
+
+        public override string GetKey(int index) {
+            return _collection.GetKey(index);
+        }
+
+        [SuppressMessage("Microsoft.Security", "CA2114:MethodSecurityShouldBeASupersetOfType", Justification = "Workaround for FxCop Bug")]
+        [SuppressMessage("Microsoft.Security", "CA2123:OverrideLinkDemandsShouldBeIdenticalToBase")]
+        [SecurityPermission(SecurityAction.Demand, SerializationFormatter=true)]
+        public override void GetObjectData(SerializationInfo info, StreamingContext context) {
+            _collection.GetObjectData(info, context);
+        }
+
+        [SuppressMessage("Microsoft.Security", "CA2123:OverrideLinkDemandsShouldBeIdenticalToBase")]
+        public override void OnDeserialization(object sender) {
+            _collection.OnDeserialization(sender);
+        }
+
+    }
+}

mcs/class/referencesource/System.Web/Abstractions/HttpPostedFileBase.cs

@@ -0,0 +1,47 @@
+//------------------------------------------------------------------------------
+// <copyright file="HttpPostedFileBase.cs" company="Microsoft">
+//     Copyright (c) Microsoft Corporation.  All rights reserved.
+// </copyright>
+//------------------------------------------------------------------------------
+
+namespace System.Web {
+    using System;
+    using System.Diagnostics.CodeAnalysis;
+    using System.IO;
+    using System.Runtime.CompilerServices;
+
+    [TypeForwardedFrom("System.Web.Abstractions, Version=3.5.0.0, Culture=Neutral, PublicKeyToken=31bf3856ad364e35")]
+    public abstract class HttpPostedFileBase {
+
+        public virtual int ContentLength {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual string ContentType {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual string FileName {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual Stream InputStream {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        [SuppressMessage("Microsoft.Naming", "CA1702:CompoundWordsShouldBeCasedCorrectly", MessageId = "filename",
+            Justification = "Matches HttpPostedFile class")]
+        public virtual void SaveAs(string filename) {
+            throw new NotImplementedException();
+        }
+
+    }
+}

mcs/class/referencesource/System.Web/Abstractions/HttpPostedFileWrapper.cs

@@ -0,0 +1,53 @@
+//------------------------------------------------------------------------------
+// <copyright file="HttpPostedFileWrapper.cs" company="Microsoft">
+//     Copyright (c) Microsoft Corporation.  All rights reserved.
+// </copyright>
+//------------------------------------------------------------------------------
+
+namespace System.Web {
+    using System;
+    using System.IO;
+    using System.Runtime.CompilerServices;
+
+    [TypeForwardedFrom("System.Web.Abstractions, Version=3.5.0.0, Culture=Neutral, PublicKeyToken=31bf3856ad364e35")]
+    public class HttpPostedFileWrapper : HttpPostedFileBase {
+
+        private HttpPostedFile _file;
+
+        public HttpPostedFileWrapper(HttpPostedFile httpPostedFile) {
+            if (httpPostedFile == null) {
+                throw new ArgumentNullException("httpPostedFile");
+            }
+            _file = httpPostedFile;
+        }
+
+        public override int ContentLength {
+            get {
+                return _file.ContentLength;
+            }
+        }
+
+        public override string ContentType {
+            get {
+                return _file.ContentType;
+            }
+        }
+
+        public override string FileName {
+            get {
+                return _file.FileName;
+            }
+        }
+
+        public override Stream InputStream {
+            get {
+                return _file.InputStream;
+            }
+        }
+
+        public override void SaveAs(string filename) {
+            _file.SaveAs(filename);
+        }
+
+    }
+}

mcs/class/referencesource/System.Web/Abstractions/HttpRequestBase.cs

@@ -0,0 +1,380 @@
+//------------------------------------------------------------------------------
+// <copyright file="HttpRequestBase.cs" company="Microsoft">
+//     Copyright (c) Microsoft Corporation.  All rights reserved.
+// </copyright>
+//------------------------------------------------------------------------------
+
+namespace System.Web {
+    using System;
+    using System.Collections.Specialized;
+    using System.Diagnostics.CodeAnalysis;
+    using System.IO;
+    using System.Runtime.CompilerServices;
+    using System.Security.Authentication.ExtendedProtection;
+    using System.Security.Principal;
+    using System.Text;
+    using System.Threading;
+    using System.Web.Routing;
+
+    [TypeForwardedFrom("System.Web.Abstractions, Version=3.5.0.0, Culture=Neutral, PublicKeyToken=31bf3856ad364e35")]
+    public abstract class HttpRequestBase {
+        [SuppressMessage("Microsoft.Performance", "CA1819:PropertiesShouldNotReturnArrays",
+            Justification = "Matches HttpRequest class")]
+        public virtual String[] AcceptTypes {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual String ApplicationPath {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        [SuppressMessage("Microsoft.Naming", "CA1706:ShortAcronymsShouldBeUppercase", MessageId="ID")]
+        [SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "ID")]
+        public virtual String AnonymousID {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual String AppRelativeCurrentExecutionFilePath {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual HttpBrowserCapabilitiesBase Browser {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual ChannelBinding HttpChannelBinding {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual HttpClientCertificate ClientCertificate {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual Encoding ContentEncoding {
+            get {
+                throw new NotImplementedException();
+            }
+            set {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual int ContentLength {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual String ContentType {
+            get {
+                throw new NotImplementedException();
+            }
+            set {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual HttpCookieCollection Cookies {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual String CurrentExecutionFilePath {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual string CurrentExecutionFilePathExtension {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual String FilePath {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual HttpFileCollectionBase Files {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual Stream Filter {
+            get {
+                throw new NotImplementedException();
+            }
+            set {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual NameValueCollection Form {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual String HttpMethod {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual Stream InputStream {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual bool IsAuthenticated {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual bool IsLocal {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual bool IsSecureConnection {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        [SuppressMessage("Microsoft.Naming", "CA1702:CompoundWordsShouldBeCasedCorrectly",
+            Justification = "Matches HttpRequest class")]
+        public virtual WindowsIdentity LogonUserIdentity {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        [SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly",
+            Justification = "Matches HttpRequest class")]
+        public virtual NameValueCollection Params {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual String Path {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual String PathInfo {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual String PhysicalApplicationPath {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual String PhysicalPath {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        [SuppressMessage("Microsoft.Design", "CA1056:UriPropertiesShouldNotBeStrings",
+            Justification = "Matches HttpRequest class")]
+        public virtual String RawUrl {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual ReadEntityBodyMode ReadEntityBodyMode {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual RequestContext RequestContext {
+            get {
+                throw new NotImplementedException();
+            }
+            set {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual String RequestType {
+            get {
+                throw new NotImplementedException();
+            }
+            set {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual NameValueCollection ServerVariables {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual CancellationToken TimedOutToken {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual ITlsTokenBindingInfo TlsTokenBindingInfo {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual int TotalBytes {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual UnvalidatedRequestValuesBase Unvalidated {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual Uri Url {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual Uri UrlReferrer {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual String UserAgent {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        [SuppressMessage("Microsoft.Performance", "CA1819:PropertiesShouldNotReturnArrays",
+            Justification = "Matches HttpRequest class")]
+        public virtual String[] UserLanguages {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual String UserHostAddress {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual String UserHostName {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual NameValueCollection Headers {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual NameValueCollection QueryString {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual String this[String key] {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual void Abort() {
+            throw new NotImplementedException();
+        }
+
+        public virtual byte[] BinaryRead(int count) {
+            throw new NotImplementedException();
+        }
+
+        public virtual Stream GetBufferedInputStream() {
+            throw new NotImplementedException();
+        }
+
+        [SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "Bufferless", Justification = "Inline with HttpRequest.GetBufferlessInputStream")]
+        public virtual Stream GetBufferlessInputStream() {
+            throw new NotImplementedException();
+        }
+
+        [SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "Bufferless", Justification = "Inline with HttpRequest.GetBufferlessInputStream")]
+        public virtual Stream GetBufferlessInputStream(bool disableMaxRequestLength) {
+            throw new NotImplementedException();
+        }
+
+        public virtual void InsertEntityBody() {
+            throw new NotImplementedException();
+        }
+
+        public virtual void InsertEntityBody(byte[] buffer, int offset, int count) {
+            throw new NotImplementedException();
+        }
+
+        public virtual int[] MapImageCoordinates(String imageFieldName) {
+            throw new NotImplementedException();
+        }
+
+        public virtual double[] MapRawImageCoordinates(String imageFieldName) {
+            throw new NotImplementedException();
+        }
+
+        public virtual String MapPath(String virtualPath) {
+            throw new NotImplementedException();
+        }
+
+        public virtual String MapPath(string virtualPath, string baseVirtualDir, bool allowCrossAppMapping) {
+            throw new NotImplementedException();
+        }
+
+        public virtual void ValidateInput() {
+            throw new NotImplementedException();
+        }
+
+        [SuppressMessage("Microsoft.Naming", "CA1702:CompoundWordsShouldBeCasedCorrectly",
+            Justification = "Matches HttpRequest class")]
+        public virtual void SaveAs(String filename, bool includeHeaders) {
+            throw new NotImplementedException();
+        }
+    }
+}

mcs/class/referencesource/System.Web/Abstractions/HttpRequestWrapper.cs

@@ -0,0 +1,373 @@
+//------------------------------------------------------------------------------
+// <copyright file="HttpRequestWrapper.cs" company="Microsoft">
+//     Copyright (c) Microsoft Corporation.  All rights reserved.
+// </copyright>
+//------------------------------------------------------------------------------
+ 
+namespace System.Web {
+    using System;
+    using System.Collections.Specialized;
+    using System.IO;
+    using System.Runtime.CompilerServices;
+    using System.Security.Authentication.ExtendedProtection;
+    using System.Security.Principal;
+    using System.Text;
+    using System.Threading;
+    using System.Web.Routing;
+
+    [TypeForwardedFrom("System.Web.Abstractions, Version=3.5.0.0, Culture=Neutral, PublicKeyToken=31bf3856ad364e35")]
+    public class HttpRequestWrapper : HttpRequestBase {
+        private HttpRequest _httpRequest;
+
+        public HttpRequestWrapper(HttpRequest httpRequest) {
+            if (httpRequest == null) {
+                throw new ArgumentNullException("httpRequest");
+            }
+            _httpRequest = httpRequest;
+        }
+
+        public override HttpBrowserCapabilitiesBase Browser {
+            get {
+                return new HttpBrowserCapabilitiesWrapper(_httpRequest.Browser);
+            }
+        }
+
+        public override NameValueCollection Params {
+            get {
+                return _httpRequest.Params;
+            }
+        }
+
+        public override string Path {
+            get {
+                return _httpRequest.Path;
+            }
+        }
+
+        public override string FilePath {
+            get {
+                return _httpRequest.FilePath;
+            }
+        }
+
+        public override NameValueCollection Headers {
+            get {
+                return _httpRequest.Headers;
+            }
+        }
+
+        public override NameValueCollection QueryString {
+            get {
+                return _httpRequest.QueryString;
+            }
+        }
+
+        public override string[] AcceptTypes {
+            get {
+                return _httpRequest.AcceptTypes;
+            }
+        }
+
+        public override string ApplicationPath {
+            get {
+                return _httpRequest.ApplicationPath;
+            }
+        }
+
+        public override string AnonymousID {
+            get {
+                return _httpRequest.AnonymousID;
+            }
+        }
+
+        public override string AppRelativeCurrentExecutionFilePath {
+            get {
+                return _httpRequest.AppRelativeCurrentExecutionFilePath;
+            }
+        }
+
+        public override ChannelBinding HttpChannelBinding {
+            get {
+                return _httpRequest.HttpChannelBinding;
+            }
+        }
+
+        public override HttpClientCertificate ClientCertificate {
+            get {
+                return _httpRequest.ClientCertificate;
+            }
+        }
+
+        public override Encoding ContentEncoding {
+            get {
+                return _httpRequest.ContentEncoding;
+            }
+            set {
+                _httpRequest.ContentEncoding = value;
+            }
+        }
+
+        public override int ContentLength {
+            get {
+                return _httpRequest.ContentLength;
+            }
+        }
+
+        public override string ContentType {
+            get {
+                return _httpRequest.ContentType;
+            }
+            set {
+                _httpRequest.ContentType = value;
+            }
+        }
+
+        public override HttpCookieCollection Cookies {
+            get {
+                return _httpRequest.Cookies;
+            }
+        }
+
+        public override string CurrentExecutionFilePath {
+            get {
+                return _httpRequest.CurrentExecutionFilePath;
+            }
+        }
+
+        public override string CurrentExecutionFilePathExtension {
+            get {
+                return _httpRequest.CurrentExecutionFilePathExtension;
+            }
+        }
+
+        public override HttpFileCollectionBase Files {
+            get {
+                // method returns an empty collection rather than null
+                return new HttpFileCollectionWrapper(_httpRequest.Files);
+            }
+        }
+
+        public override Stream Filter {
+            get {
+                return _httpRequest.Filter;
+            }
+            set {
+                _httpRequest.Filter = value;
+            }
+        }
+
+        public override NameValueCollection Form {
+            get {
+                return _httpRequest.Form;
+            }
+        }
+
+        public override string HttpMethod {
+            get {
+                return _httpRequest.HttpMethod;
+            }
+        }
+
+        public override Stream InputStream {
+            get {
+                return _httpRequest.InputStream;
+            }
+        }
+
+        public override bool IsAuthenticated {
+            get {
+                return _httpRequest.IsAuthenticated;
+            }
+        }
+
+        public override bool IsLocal {
+            get {
+                return _httpRequest.IsLocal;
+            }
+        }
+
+        public override bool IsSecureConnection {
+            get {
+                return _httpRequest.IsSecureConnection;
+            }
+        }
+
+        public override WindowsIdentity LogonUserIdentity {
+            get {
+                return _httpRequest.LogonUserIdentity;
+            }
+        }
+
+        public override string PathInfo {
+            get {
+                return _httpRequest.PathInfo;
+            }
+        }
+
+        public override string PhysicalApplicationPath {
+            get {
+                return _httpRequest.PhysicalApplicationPath;
+            }
+        }
+
+        public override string PhysicalPath {
+            get {
+                return _httpRequest.PhysicalPath;
+            }
+        }
+
+        public override string RawUrl {
+            get {
+                return _httpRequest.RawUrl;
+            }
+        }
+
+        public override ReadEntityBodyMode ReadEntityBodyMode {
+            get {
+                return _httpRequest.ReadEntityBodyMode;
+            }
+        }
+
+        public override RequestContext RequestContext {
+            get {
+                return _httpRequest.RequestContext;
+            }
+            set {
+                _httpRequest.RequestContext = value;
+            }
+        }
+
+        public override string RequestType {
+            get {
+                return _httpRequest.RequestType;
+            }
+            set {
+                _httpRequest.RequestType = value;
+            }
+        }
+
+        public override NameValueCollection ServerVariables {
+            get { 
+                return _httpRequest.ServerVariables;
+            }
+        }
+
+        public override CancellationToken TimedOutToken {
+            get {
+                return _httpRequest.TimedOutToken;
+            }
+        }
+
+        public override ITlsTokenBindingInfo TlsTokenBindingInfo {
+            get {
+                return _httpRequest.TlsTokenBindingInfo;
+            }
+        }
+
+        public override int TotalBytes {
+            get {
+                return _httpRequest.TotalBytes;
+            }
+        }
+
+        public override UnvalidatedRequestValuesBase Unvalidated {
+            get {
+                return new UnvalidatedRequestValuesWrapper(_httpRequest.Unvalidated);
+            }
+        }
+
+        public override Uri Url {
+            get {
+                return _httpRequest.Url;
+            }
+        }
+
+        public override Uri UrlReferrer {
+            get {
+                return _httpRequest.UrlReferrer;
+            }
+        }
+
+        public override string UserAgent {
+            get {
+                return _httpRequest.UserAgent;
+            }
+        }
+
+        public override string[] UserLanguages {
+            get {
+                return _httpRequest.UserLanguages;
+            }
+        }
+
+        public override string UserHostAddress {
+            get {
+                return _httpRequest.UserHostAddress;
+            }
+        }
+
+        public override string UserHostName {
+            get {
+                return _httpRequest.UserHostName;
+            }
+        }
+
+        public override string this[string key] {
+            get {
+                return _httpRequest[key];
+            }
+        }
+
+        public override void Abort() {
+            _httpRequest.Abort();
+        }
+
+        public override byte[] BinaryRead(int count) {
+            return _httpRequest.BinaryRead(count);
+        }
+
+        public override Stream GetBufferedInputStream() {
+            return _httpRequest.GetBufferedInputStream();
+        }
+
+        public override Stream GetBufferlessInputStream() {
+            return _httpRequest.GetBufferlessInputStream();
+        }
+
+        public override Stream GetBufferlessInputStream(bool disableMaxRequestLength) {
+            return _httpRequest.GetBufferlessInputStream(disableMaxRequestLength);
+        }
+        
+        public override void InsertEntityBody() {
+            _httpRequest.InsertEntityBody();
+        }
+
+        public override void InsertEntityBody(byte[] buffer, int offset, int count) {
+            _httpRequest.InsertEntityBody(buffer, offset, count);
+        }
+
+        public override int[] MapImageCoordinates(string imageFieldName) {
+            return _httpRequest.MapImageCoordinates(imageFieldName);
+        }
+
+        public override double[] MapRawImageCoordinates(string imageFieldName) {
+            return _httpRequest.MapRawImageCoordinates(imageFieldName);
+        }
+
+        public override string MapPath(string virtualPath) {
+            return _httpRequest.MapPath(virtualPath);
+        }
+
+        public override string MapPath(string virtualPath, string baseVirtualDir, bool allowCrossAppMapping) {
+            return _httpRequest.MapPath(virtualPath, baseVirtualDir, allowCrossAppMapping);
+        }
+
+        public override void ValidateInput() {
+            _httpRequest.ValidateInput();
+        }
+
+        public override void SaveAs(string filename, bool includeHeaders) {
+            _httpRequest.SaveAs(filename, includeHeaders);
+        }
+    }
+}

mcs/class/referencesource/System.Web/Abstractions/HttpResponseWrapper.cs

@@ -0,0 +1,488 @@
+//------------------------------------------------------------------------------
+// <copyright file="HttpResponseWrapper.cs" company="Microsoft">
+//     Copyright (c) Microsoft Corporation.  All rights reserved.
+// </copyright>
+//------------------------------------------------------------------------------
+
+namespace System.Web {
+    using System;
+    using System.Collections;
+    using System.Collections.Specialized;
+    using System.IO;
+    using System.Runtime.CompilerServices;
+    using System.Text;
+    using System.Threading;
+    using System.Threading.Tasks;
+    using System.Web.Caching;
+    using System.Web.Routing;
+
+    [TypeForwardedFrom("System.Web.Abstractions, Version=3.5.0.0, Culture=Neutral, PublicKeyToken=31bf3856ad364e35")]
+    public class HttpResponseWrapper : HttpResponseBase {
+        private HttpResponse _httpResponse;
+
+        public HttpResponseWrapper(HttpResponse httpResponse) {
+            if (httpResponse == null) {
+                throw new ArgumentNullException("httpResponse");
+            }
+            _httpResponse = httpResponse;
+        }
+
+        public override bool Buffer {
+            get {
+                return _httpResponse.Buffer;
+            }
+            set {
+                _httpResponse.Buffer = value;
+            }
+        }
+
+        public override bool BufferOutput {
+            get {
+                return _httpResponse.BufferOutput;
+            }
+            set {
+                _httpResponse.BufferOutput = value;
+            }
+        }
+
+        public override HttpCachePolicyBase Cache {
+            get {
+                return new HttpCachePolicyWrapper(_httpResponse.Cache);
+            }
+        }
+
+        public override string CacheControl {
+            get {
+                return _httpResponse.CacheControl;
+            }
+            set {
+                _httpResponse.CacheControl = value;
+            }
+        }
+
+        public override string Charset {
+            get {
+                return _httpResponse.Charset;
+            }
+            set {
+                _httpResponse.Charset = value;
+            }
+        }
+
+        public override CancellationToken ClientDisconnectedToken {
+            get {
+                return _httpResponse.ClientDisconnectedToken;
+            }
+        }
+
+        public override Encoding ContentEncoding {
+            get {
+                return _httpResponse.ContentEncoding;
+            }
+            set {
+                _httpResponse.ContentEncoding = value;
+            }
+        }
+
+        public override string ContentType {
+            get {
+                return _httpResponse.ContentType;
+            }
+            set {
+                _httpResponse.ContentType = value;
+            }
+        }
+
+        public override HttpCookieCollection Cookies {
+            get {
+                return _httpResponse.Cookies;
+            }
+        }
+
+        public override int Expires {
+            get {
+                return _httpResponse.Expires;
+            }
+            set {
+                _httpResponse.Expires = value;
+            }
+        }
+
+        public override DateTime ExpiresAbsolute {
+            get {
+                return _httpResponse.ExpiresAbsolute;
+            }
+            set {
+                _httpResponse.ExpiresAbsolute = value;
+            }
+        }
+
+        public override Stream Filter {
+            get {
+                return _httpResponse.Filter;
+            }
+            set {
+                _httpResponse.Filter = value;
+            }
+        }
+
+        public override NameValueCollection Headers {
+            get {
+                return _httpResponse.Headers;
+            }
+        }
+
+        public override bool HeadersWritten {
+            get {
+                return _httpResponse.HeadersWritten;
+            }
+        }
+
+        public override Encoding HeaderEncoding {
+            get {
+                return _httpResponse.HeaderEncoding;
+            }
+            set {
+                _httpResponse.HeaderEncoding = value;
+            }
+        }
+
+        public override bool IsClientConnected {
+            get {
+                return _httpResponse.IsClientConnected;
+            }
+        }
+
+        public override bool IsRequestBeingRedirected {
+            get {
+                return _httpResponse.IsRequestBeingRedirected;
+            }
+        }
+
+        public override TextWriter Output {
+            get {
+                return _httpResponse.Output;
+            }
+            set {
+                _httpResponse.Output = value;
+            }
+        }
+
+        public override Stream OutputStream {
+            get {
+                return _httpResponse.OutputStream;
+            }
+        }
+
+        public override string RedirectLocation {
+            get {
+                return _httpResponse.RedirectLocation;
+            }
+            set {
+                _httpResponse.RedirectLocation = value;
+            }
+        }
+
+        public override string Status {
+            get {
+                return _httpResponse.Status;
+            }
+            set {
+                _httpResponse.Status = value;
+            }
+        }
+
+        public override int StatusCode {
+            get {
+                return _httpResponse.StatusCode;
+            }
+            set {
+                _httpResponse.StatusCode = value;
+            }
+        }
+
+        public override string StatusDescription {
+            get {
+                return _httpResponse.StatusDescription;
+            }
+            set {
+                _httpResponse.StatusDescription = value;
+            }
+        }
+
+        public override int SubStatusCode {
+            get {
+                return _httpResponse.SubStatusCode;
+            }
+            set {
+                _httpResponse.SubStatusCode = value;
+            }
+        }
+
+        public override bool SupportsAsyncFlush {
+            get {
+                return _httpResponse.SupportsAsyncFlush;
+            }
+        }
+
+        public override bool SuppressContent {
+            get {
+                return _httpResponse.SuppressContent;
+            }
+            set {
+                _httpResponse.SuppressContent = value;
+            }
+        }
+
+        public override bool SuppressDefaultCacheControlHeader {
+            get {
+                return _httpResponse.SuppressDefaultCacheControlHeader;
+            }
+            set {
+                _httpResponse.SuppressDefaultCacheControlHeader = value;
+            }
+        }
+
+        public override bool SuppressFormsAuthenticationRedirect {
+            get {
+                return _httpResponse.SuppressFormsAuthenticationRedirect;
+            }
+            set {
+                _httpResponse.SuppressFormsAuthenticationRedirect = value;
+            }
+        }
+
+        public override bool TrySkipIisCustomErrors {
+            get {
+                return _httpResponse.TrySkipIisCustomErrors;
+            }
+            set {
+                _httpResponse.TrySkipIisCustomErrors = value;
+            }
+        }
+
+        public override void AddCacheItemDependency(string cacheKey) {
+            _httpResponse.AddCacheItemDependency(cacheKey);
+        }
+
+        public override void AddCacheItemDependencies(ArrayList cacheKeys) {
+            _httpResponse.AddCacheItemDependencies(cacheKeys);
+        }
+
+        public override void AddCacheItemDependencies(string[] cacheKeys) {
+            _httpResponse.AddCacheItemDependencies(cacheKeys);
+        }
+
+        public override void AddCacheDependency(params CacheDependency[] dependencies) {
+            _httpResponse.AddCacheDependency(dependencies);
+        }
+
+        public override void AddFileDependency(string filename) {
+            _httpResponse.AddFileDependency(filename);
+        }
+
+        public override ISubscriptionToken AddOnSendingHeaders(Action<HttpContextBase> callback) {
+            return _httpResponse.AddOnSendingHeaders(HttpContextWrapper.WrapCallback(callback));
+        }
+
+        public override void AddFileDependencies(ArrayList filenames) {
+            _httpResponse.AddFileDependencies(filenames);
+        }
+
+        public override void AddFileDependencies(string[] filenames) {
+            _httpResponse.AddFileDependencies(filenames);
+        }
+
+        public override void AddHeader(string name, string value) {
+            _httpResponse.AddHeader(name, value);
+        }
+
+        public override void AppendCookie(HttpCookie cookie) {
+            _httpResponse.AppendCookie(cookie);
+        }
+
+        public override void AppendHeader(string name, string value) {
+            _httpResponse.AppendHeader(name, value);
+        }
+
+        public override void AppendToLog(string param) {
+            _httpResponse.AppendToLog(param);
+        }
+
+        public override string ApplyAppPathModifier(string virtualPath) {
+            return _httpResponse.ApplyAppPathModifier(virtualPath);
+        }
+
+        public override IAsyncResult BeginFlush(AsyncCallback callback, Object state) {
+            return _httpResponse.BeginFlush(callback, state);
+        }
+
+        public override void BinaryWrite(byte[] buffer) {
+            _httpResponse.BinaryWrite(buffer);
+        }
+
+        public override void Clear() {
+            _httpResponse.Clear();
+        }
+
+        public override void ClearContent() {
+            _httpResponse.ClearContent();
+        }
+
+        public override void ClearHeaders() {
+            _httpResponse.ClearHeaders();
+        }
+
+        public override void Close() {
+            _httpResponse.Close();
+        }
+
+        public override void DisableKernelCache() {
+            _httpResponse.DisableKernelCache();
+        }
+
+        public override void DisableUserCache() {
+            _httpResponse.DisableUserCache();
+        }
+
+        public override void End() {
+            _httpResponse.End();
+        }
+
+        public override void EndFlush(IAsyncResult asyncResult) {
+            _httpResponse.EndFlush(asyncResult);
+        }
+
+        public override void Flush() {
+            _httpResponse.Flush();
+        }
+
+        public override Task FlushAsync() {
+            return _httpResponse.FlushAsync();
+        }
+
+        public override void Pics(string value) {
+            _httpResponse.Pics(value);
+        }
+
+        public override void Redirect(string url) {
+            _httpResponse.Redirect(url);
+        }
+
+        public override void Redirect(string url, bool endResponse) {
+            _httpResponse.Redirect(url, endResponse);
+        }
+
+        public override void RedirectPermanent(String url) {
+            _httpResponse.RedirectPermanent(url);
+        }
+
+        public override void RedirectPermanent(String url, bool endResponse) {
+            _httpResponse.RedirectPermanent(url, endResponse);
+        }
+
+        public override void RedirectToRoute(object routeValues) {
+            _httpResponse.RedirectToRoute(routeValues);
+        }
+
+        public override void RedirectToRoute(string routeName) {
+            _httpResponse.RedirectToRoute(routeName);
+        }
+
+        public override void RedirectToRoute(RouteValueDictionary routeValues) {
+            _httpResponse.RedirectToRoute(routeValues);
+        }
+
+        public override void RedirectToRoute(string routeName, object routeValues) {
+            _httpResponse.RedirectToRoute(routeName, routeValues);
+        }
+
+        public override void RedirectToRoute(string routeName, RouteValueDictionary routeValues) {
+            _httpResponse.RedirectToRoute(routeName, routeValues);
+        }
+
+        public override void RedirectToRoutePermanent(object routeValues) {
+            _httpResponse.RedirectToRoutePermanent(routeValues);
+        }
+
+        public override void RedirectToRoutePermanent(string routeName) {
+            _httpResponse.RedirectToRoutePermanent(routeName);
+        }
+
+        public override void RedirectToRoutePermanent(RouteValueDictionary routeValues) {
+            _httpResponse.RedirectToRoutePermanent(routeValues);
+        }
+
+        public override void RedirectToRoutePermanent(string routeName, object routeValues) {
+            _httpResponse.RedirectToRoutePermanent(routeName, routeValues);
+        }
+
+        public override void RedirectToRoutePermanent(string routeName, RouteValueDictionary routeValues) {
+            _httpResponse.RedirectToRoutePermanent(routeName, routeValues);
+        }
+
+        public override void RemoveOutputCacheItem(string path) {
+            HttpResponse.RemoveOutputCacheItem(path);
+        }
+
+        public override void RemoveOutputCacheItem(string path, string providerName) {
+            HttpResponse.RemoveOutputCacheItem(path, providerName);
+        }
+
+        public override void SetCookie(HttpCookie cookie) {
+            _httpResponse.SetCookie(cookie);
+        }
+
+        public override void TransmitFile(string filename) {
+            _httpResponse.TransmitFile(filename);
+        }
+
+        public override void TransmitFile(string filename, long offset, long length) {
+            _httpResponse.TransmitFile(filename, offset, length);
+        }
+
+        public override void Write(string s) {
+            _httpResponse.Write(s);
+        }
+
+        public override void Write(char ch) {
+            _httpResponse.Write(ch);
+        }
+
+        public override void Write(char[] buffer, int index, int count) {
+            _httpResponse.Write(buffer, index, count);
+        }
+
+        public override void Write(object obj) {
+            _httpResponse.Write(obj);
+        }
+
+        public override void WriteFile(string filename) {
+            _httpResponse.WriteFile(filename);
+        }
+
+        public override void WriteFile(string filename, bool readIntoMemory) {
+            _httpResponse.WriteFile(filename, readIntoMemory);
+        }
+
+        public override void WriteFile(string filename, long offset, long size) {
+            _httpResponse.WriteFile(filename, offset, size);
+        }
+
+        public override void WriteFile(IntPtr fileHandle, long offset, long size) {
+            _httpResponse.WriteFile(fileHandle, offset, size);
+        }
+
+        public override void WriteSubstitution(HttpResponseSubstitutionCallback callback) {
+            _httpResponse.WriteSubstitution(callback);
+        }
+
+        public override void PushPromise(string path) {
+            _httpResponse.PushPromise(path);
+        }
+
+        public override void PushPromise(string path, string method, NameValueCollection headers) {
+            _httpResponse.PushPromise(path, method, headers);
+        }
+    }
+}

mcs/class/referencesource/System.Web/Abstractions/HttpServerUtilityBase.cs

@@ -0,0 +1,176 @@
+//------------------------------------------------------------------------------
+// <copyright file="HttpServerUtilityBase.cs" company="Microsoft">
+//     Copyright (c) Microsoft Corporation.  All rights reserved.
+// </copyright>
+//------------------------------------------------------------------------------
+
+namespace System.Web {
+    using System.Collections.Specialized;
+    using System.Diagnostics.CodeAnalysis;
+    using System.IO;
+    using System.Runtime.CompilerServices;
+
+    [TypeForwardedFrom("System.Web.Abstractions, Version=3.5.0.0, Culture=Neutral, PublicKeyToken=31bf3856ad364e35")]
+    public abstract class HttpServerUtilityBase {
+        public virtual string MachineName {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual int ScriptTimeout {
+            get {
+                throw new NotImplementedException();
+            }
+            set {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual void ClearError() {
+            throw new NotImplementedException();
+        }
+
+        [SuppressMessage("Microsoft.Naming", "CA1706:ShortAcronymsShouldBeUppercase", MessageId="ID")]
+        [SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "ID")]
+        public virtual object CreateObject(string progID) {
+            throw new NotImplementedException();
+        }
+
+        public virtual object CreateObject(Type type) {
+            throw new NotImplementedException();
+        }
+
+        public virtual object CreateObjectFromClsid(string clsid) {
+            throw new NotImplementedException();
+        }
+
+        public virtual void Execute(string path) {
+            throw new NotImplementedException();
+        }
+
+        public virtual void Execute(string path, TextWriter writer) {
+            throw new NotImplementedException();
+        }
+
+        public virtual void Execute(string path, bool preserveForm) {
+            throw new NotImplementedException();
+        }
+
+        public virtual void Execute(string path, TextWriter writer, bool preserveForm) {
+            throw new NotImplementedException();
+        }
+
+        public virtual void Execute(IHttpHandler handler, TextWriter writer, bool preserveForm) {
+            throw new NotImplementedException();
+        }
+
+        [SuppressMessage("Microsoft.Design", "CA1024:UsePropertiesWhereAppropriate",
+            Justification = "Matches HttpServerUtility class")]
+        public virtual Exception GetLastError() {
+            throw new NotImplementedException();
+        }
+
+        [SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly",
+            Justification = "Matches HttpServerUtility class")]
+        public virtual string HtmlDecode(string s) {
+            throw new NotImplementedException();
+        }
+
+        [SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly",
+            Justification = "Matches HttpServerUtility class")]
+        public virtual void HtmlDecode(string s, TextWriter output) {
+            throw new NotImplementedException();
+        }
+
+        [SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly",
+            Justification = "Matches HttpServerUtility class")]
+        public virtual string HtmlEncode(string s) {
+            throw new NotImplementedException();
+        }
+
+        [SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly",
+            Justification = "Matches HttpServerUtility class")]
+        public virtual void HtmlEncode(string s, TextWriter output) {
+            throw new NotImplementedException();
+        }
+
+        public virtual string MapPath(string path) {
+            throw new NotImplementedException();
+        }
+
+        public virtual void Transfer(string path, bool preserveForm) {
+            throw new NotImplementedException();
+        }
+
+        public virtual void Transfer(string path) {
+            throw new NotImplementedException();
+        }
+
+        public virtual void Transfer(IHttpHandler handler, bool preserveForm) {
+            throw new NotImplementedException();
+        }
+
+        public virtual void TransferRequest(string path) {
+            throw new NotImplementedException();
+        }
+
+        public virtual void TransferRequest(string path, bool preserveForm) {
+            throw new NotImplementedException();
+        }
+
+        public virtual void TransferRequest(string path, bool preserveForm, string method, NameValueCollection headers) {
+            throw new NotImplementedException();
+        }
+
+        public virtual void TransferRequest(string path, bool preserveForm, string method, NameValueCollection headers, bool preserveUser) {
+            throw new NotImplementedException();
+        }
+
+        [SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly",
+            Justification = "Matches HttpServerUtility class")]
+        [SuppressMessage("Microsoft.Design", "CA1055:UriReturnValuesShouldNotBeStrings",
+            Justification = "Matches HttpServerUtility class")]
+        public virtual string UrlDecode(string s) {
+            throw new NotImplementedException();
+        }
+
+        [SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly",
+            Justification = "Matches HttpServerUtility class")]
+        public virtual void UrlDecode(string s, TextWriter output) {
+            throw new NotImplementedException();
+        }
+
+        [SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly",
+            Justification = "Matches HttpServerUtility class")]
+        [SuppressMessage("Microsoft.Design", "CA1055:UriReturnValuesShouldNotBeStrings",
+            Justification = "Matches HttpServerUtility class")]
+        public virtual string UrlEncode(string s) {
+            throw new NotImplementedException();
+        }
+
+        [SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly",
+            Justification = "Matches HttpServerUtility class")]
+        public virtual void UrlEncode(string s, TextWriter output) {
+            throw new NotImplementedException();
+        }
+
+        [SuppressMessage("Microsoft.Design", "CA1055:UriReturnValuesShouldNotBeStrings",
+            Justification = "Matches HttpServerUtility class")]
+        [SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly",
+            Justification = "Matches HttpServerUtility class")]
+        public virtual string UrlPathEncode(string s) {
+            throw new NotImplementedException();
+        }
+
+        public virtual byte[] UrlTokenDecode(string input) {
+            throw new NotImplementedException();
+        }
+
+        [SuppressMessage("Microsoft.Design", "CA1055:UriReturnValuesShouldNotBeStrings",
+            Justification = "Matches HttpServerUtility class")]
+        public virtual string UrlTokenEncode(byte[] input) {
+            throw new NotImplementedException();
+        }
+    }
+}

mcs/class/referencesource/System.Web/Abstractions/HttpServerUtilityWrapper.cs

@@ -0,0 +1,154 @@
+//------------------------------------------------------------------------------
+// <copyright file="HttpServerUtilityWrapper.cs" company="Microsoft">
+//     Copyright (c) Microsoft Corporation.  All rights reserved.
+// </copyright>
+//------------------------------------------------------------------------------
+
+namespace System.Web {
+    using System.Collections.Specialized;
+    using System.IO;
+    using System.Runtime.CompilerServices;
+
+    [TypeForwardedFrom("System.Web.Abstractions, Version=3.5.0.0, Culture=Neutral, PublicKeyToken=31bf3856ad364e35")]
+    public class HttpServerUtilityWrapper : HttpServerUtilityBase {
+        private HttpServerUtility _httpServerUtility;
+
+        public HttpServerUtilityWrapper(HttpServerUtility httpServerUtility) {
+            if (httpServerUtility == null) {
+                throw new ArgumentNullException("httpServerUtility");
+            }
+            _httpServerUtility = httpServerUtility;
+        }
+
+        public override Exception GetLastError() {
+            return _httpServerUtility.GetLastError();
+        }
+
+        public override string MachineName {
+            get {
+                return _httpServerUtility.MachineName;
+            }
+        }
+
+        public override int ScriptTimeout {
+            get {
+                return _httpServerUtility.ScriptTimeout;
+            }
+            set {
+                _httpServerUtility.ScriptTimeout = value;
+            }
+        }
+
+        public override void ClearError() {
+            _httpServerUtility.ClearError();
+        }
+
+        public override object CreateObject(string progID) {
+            return _httpServerUtility.CreateObject(progID);
+        }
+
+        public override object CreateObject(Type type) {
+            return _httpServerUtility.CreateObject(type);
+        }
+
+        public override object CreateObjectFromClsid(string clsid) {
+            return _httpServerUtility.CreateObjectFromClsid(clsid);
+        }
+
+        public override void Execute(string path) {
+            _httpServerUtility.Execute(path);
+        }
+
+        public override void Execute(string path, TextWriter writer) {
+            _httpServerUtility.Execute(path, writer);
+        }
+
+        public override void Execute(string path, bool preserveForm) {
+            _httpServerUtility.Execute(path, preserveForm);
+        }
+
+        public override void Execute(string path, TextWriter writer, bool preserveForm) {
+            _httpServerUtility.Execute(path, writer, preserveForm);
+        }
+
+        public override void Execute(IHttpHandler handler, TextWriter writer, bool preserveForm) {
+            _httpServerUtility.Execute(handler, writer, preserveForm);
+        }
+
+        public override string HtmlDecode(string s) {
+            return _httpServerUtility.HtmlDecode(s);
+        }
+
+        public override void HtmlDecode(string s, TextWriter output) {
+            _httpServerUtility.HtmlDecode(s, output);
+        }
+
+        public override string HtmlEncode(string s) {
+            return _httpServerUtility.HtmlEncode(s);
+        }
+
+        public override void HtmlEncode(string s, TextWriter output) {
+            _httpServerUtility.HtmlEncode(s, output);
+        }
+
+        public override string MapPath(string path) {
+            return _httpServerUtility.MapPath(path);
+        }
+
+        public override void Transfer(string path, bool preserveForm) {
+            _httpServerUtility.Transfer(path, preserveForm);
+        }
+
+        public override void Transfer(string path) {
+            _httpServerUtility.Transfer(path);
+        }
+
+        public override void Transfer(IHttpHandler handler, bool preserveForm) {
+            _httpServerUtility.Transfer(handler, preserveForm);
+        }
+
+        public override void TransferRequest(string path) {
+            _httpServerUtility.TransferRequest(path);
+        }
+
+        public override void TransferRequest(string path, bool preserveForm) {
+            _httpServerUtility.TransferRequest(path, preserveForm);
+        }
+
+        public override void TransferRequest(string path, bool preserveForm, string method, NameValueCollection headers) {
+            _httpServerUtility.TransferRequest(path, preserveForm, method, headers);
+        }
+
+        public override void TransferRequest(string path, bool preserveForm, string method, NameValueCollection headers, bool preserveUser) {
+            _httpServerUtility.TransferRequest(path, preserveForm, method, headers, preserveUser);
+        }
+
+        public override string UrlDecode(string s) {
+            return _httpServerUtility.UrlDecode(s);
+        }
+
+        public override void UrlDecode(string s, TextWriter output) {
+            _httpServerUtility.UrlDecode(s, output);
+        }
+
+        public override string UrlEncode(string s) {
+            return _httpServerUtility.UrlEncode(s);
+        }
+
+        public override void UrlEncode(string s, TextWriter output) {
+            _httpServerUtility.UrlEncode(s, output);
+        }
+
+        public override string UrlPathEncode(string s) {
+            return _httpServerUtility.UrlPathEncode(s);
+        }
+
+        public override byte[] UrlTokenDecode(string input) {
+            return HttpServerUtility.UrlTokenDecode(input);
+        }
+
+        public override string UrlTokenEncode(byte[] input) {
+            return HttpServerUtility.UrlTokenEncode(input);
+        }
+    }
+}

mcs/class/referencesource/System.Web/Abstractions/HttpSessionStateBase.cs

@@ -0,0 +1,180 @@
+//------------------------------------------------------------------------------
+// <copyright file="HttpSessionStateBase.cs" company="Microsoft">
+//     Copyright (c) Microsoft Corporation.  All rights reserved.
+// </copyright>
+//------------------------------------------------------------------------------
+
+namespace System.Web {
+    using System.Collections;
+    using System.Collections.Specialized;
+    using System.Diagnostics.CodeAnalysis;
+    using System.Web.SessionState;
+    using System.Runtime.CompilerServices;
+
+    [TypeForwardedFrom("System.Web.Abstractions, Version=3.5.0.0, Culture=Neutral, PublicKeyToken=31bf3856ad364e35")]
+    [SuppressMessage("Microsoft.Naming", "CA1710:IdentifiersShouldHaveCorrectSuffix",
+        Justification = "This is consistent with the type it abstracts in System.Web.dll.")]
+    public abstract class HttpSessionStateBase : ICollection, IEnumerable {
+        public virtual int CodePage {
+            get {
+                throw new NotImplementedException();
+            }
+            set {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual HttpSessionStateBase Contents {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual HttpCookieMode CookieMode {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual bool IsCookieless {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual bool IsNewSession {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual bool IsReadOnly {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual NameObjectCollectionBase.KeysCollection Keys {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        [SuppressMessage("Microsoft.Naming", "CA1705:LongAcronymsShouldBePascalCased",
+            Justification = "This is consistent with the type it abstracts in System.Web.dll.")]
+        public virtual int LCID {
+            get {
+                throw new NotImplementedException();
+            }
+            set {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual SessionStateMode Mode {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        [SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "ID",
+            Justification = "This is consistent with the type it abstracts in System.Web.dll.")]
+        public virtual string SessionID {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual HttpStaticObjectsCollectionBase StaticObjects {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual int Timeout {
+            get {
+                throw new NotImplementedException();
+            }
+            set {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual object this[int index] {
+            get {
+                throw new NotImplementedException();
+            }
+            set {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual object this[string name] {
+            get {
+                throw new NotImplementedException();
+            }
+            set {
+                throw new NotImplementedException();
+            }
+        }
+
+        public virtual void Abandon() {
+            throw new NotImplementedException();
+        }
+
+        public virtual void Add(string name, object value) {
+            throw new NotImplementedException();
+        }
+
+        public virtual void Clear() {
+            throw new NotImplementedException();
+        }
+
+        public virtual void Remove(string name) {
+            throw new NotImplementedException();
+        }
+
+        public virtual void RemoveAll() {
+            throw new NotImplementedException();
+        }
+
+        public virtual void RemoveAt(int index) {
+            throw new NotImplementedException();
+        }
+
+        #region ICollection Members
+        [SuppressMessage("Microsoft.Security", "CA2123:OverrideLinkDemandsShouldBeIdenticalToBase")]
+        public virtual void CopyTo(Array array, int index) {
+            throw new NotImplementedException();
+        }
+
+        [SuppressMessage("Microsoft.Security", "CA2123:OverrideLinkDemandsShouldBeIdenticalToBase")]
+        public virtual int Count {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        [SuppressMessage("Microsoft.Security", "CA2123:OverrideLinkDemandsShouldBeIdenticalToBase")]
+        public virtual bool IsSynchronized {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+
+        [SuppressMessage("Microsoft.Security", "CA2123:OverrideLinkDemandsShouldBeIdenticalToBase")]
+        public virtual object SyncRoot {
+            get {
+                throw new NotImplementedException();
+            }
+        }
+        #endregion
+
+        #region IEnumerable Members
+        [SuppressMessage("Microsoft.Security", "CA2123:OverrideLinkDemandsShouldBeIdenticalToBase")]
+        public virtual IEnumerator GetEnumerator() {
+            throw new NotImplementedException();
+        }
+        #endregion
+    }
+}

mcs/class/referencesource/System.Web/Abstractions/HttpSessionStateWrapper.cs

@@ -0,0 +1,186 @@
+//------------------------------------------------------------------------------
+// <copyright file="HttpSessionStateWrapper.cs" company="Microsoft">
+//     Copyright (c) Microsoft Corporation.  All rights reserved.
+// </copyright>
+//------------------------------------------------------------------------------
+
+namespace System.Web {
+    using System.Collections;
+    using System.Collections.Specialized;
+    using System.Diagnostics.CodeAnalysis;
+    using System.Web.SessionState;
+    using System.Runtime.CompilerServices;
+
+    [TypeForwardedFrom("System.Web.Abstractions, Version=3.5.0.0, Culture=Neutral, PublicKeyToken=31bf3856ad364e35")]
+    [SuppressMessage("Microsoft.Naming", "CA1710:IdentifiersShouldHaveCorrectSuffix",
+        Justification = "This type name needs to match the ASP.NET 2.0 type name.")]
+    public class HttpSessionStateWrapper : HttpSessionStateBase {
+        private readonly HttpSessionState _session;
+
+        public HttpSessionStateWrapper(HttpSessionState httpSessionState) {
+            if (httpSessionState == null) {
+                throw new ArgumentNullException("httpSessionState");
+            }
+            _session = httpSessionState;
+        }
+
+        public override int CodePage {
+            get {
+                return _session.CodePage;
+            }
+            set {
+                _session.CodePage = value;
+            }
+        }
+
+        public override HttpSessionStateBase Contents {
+            get {
+                return this;
+            }
+        }
+
+        public override HttpCookieMode CookieMode {
+            get {
+                return _session.CookieMode;
+            }
+        }
+
+        public override bool IsCookieless {
+            get {
+                return _session.IsCookieless;
+            }
+        }
+
+        public override bool IsNewSession {
+            get {
+                return _session.IsNewSession;
+            }
+        }
+
+        public override bool IsReadOnly {
+            get {
+                return _session.IsReadOnly;
+            }
+        }
+
+        public override NameObjectCollectionBase.KeysCollection Keys {
+            get {
+                return _session.Keys;
+            }
+        }
+
+        public override int LCID {
+            get {
+                return _session.LCID;
+            }
+            set {
+                _session.LCID = value;
+            }
+        }
+
+        public override SessionStateMode Mode {
+            get {
+                return _session.Mode;
+            }
+        }
+
+        public override string SessionID {
+            get {
+                return _session.SessionID;
+            }
+        }
+
+        public override HttpStaticObjectsCollectionBase StaticObjects {
+            get {
+                // method returns an empty collection rather than null
+                return new HttpStaticObjectsCollectionWrapper(_session.StaticObjects);
+            }
+        }
+
+        public override int Timeout {
+            get {
+                return _session.Timeout;
+            }
+            set {
+                _session.Timeout = value;
+            }
+        }
+
+        public override object this[int index] {
+            get {
+                return _session[index];
+            }
+            set {
+                _session[index] = value;
+            }
+        }
+
+        public override object this[string name] {
+            get {
+                return _session[name];
+            }
+            set {
+                _session[name] = value;
+            }
+        }
+
+        public override void Abandon() {
+            _session.Abandon();
+        }
+
+        public override void Add(string name, object value) {
+            _session.Add(name, value);
+        }
+
+        public override void Clear() {
+            _session.Clear();
+        }
+
+        public override void Remove(string name) {
+            _session.Remove(name);
+        }
+
+        public override void RemoveAll() {
+            _session.RemoveAll();
+        }
+
+        public override void RemoveAt(int index) {
+            _session.RemoveAt(index);
+        }
+
+        #region ICollection Members
+        [SuppressMessage("Microsoft.Security", "CA2123:OverrideLinkDemandsShouldBeIdenticalToBase")]
+        public override void CopyTo(Array array, int index) {
+            _session.CopyTo(array, index);
+        }
+
+        [SuppressMessage("Microsoft.Security", "CA2123:OverrideLinkDemandsShouldBeIdenticalToBase")]
+        public override int Count {
+            get {
+                return _session.Count;
+            }
+        }
+
+        [SuppressMessage("Microsoft.Security", "CA2123:OverrideLinkDemandsShouldBeIdenticalToBase")]
+        public override bool IsSynchronized {
+            get {
+                return _session.IsSynchronized;
+            }
+        }
+
+        [SuppressMessage("Microsoft.Security", "CA2123:OverrideLinkDemandsShouldBeIdenticalToBase")]
+        public override object SyncRoot {
+            get {
+                return _session.SyncRoot;
+            }
+        }
+        #endregion
+
+        #region IEnumerable Members
+        [SuppressMessage("Microsoft.Security", "CA2123:OverrideLinkDemandsShouldBeIdenticalToBase")]
+        public override IEnumerator GetEnumerator() {
+            return _session.GetEnumerator();
+        }
+        #endregion
+    }
+}