DotNetOpenAuth.Messaging no longer relies on ccrewrite.exe

52 files changed, 665 insertions, 352 deletions

diff --git a/src/DotNetOpenAuth.Messaging/Assumes.cs b/src/DotNetOpenAuth.Messaging/Assumes.cs
new file mode 100644
index 0000000..43de627
--- /dev/null
+++ b/src/DotNetOpenAuth.Messaging/Assumes.cs
@@ -0,0 +1,95 @@
+//-----------------------------------------------------------------------
+// <copyright file="Assumes.cs" company="Andrew Arnott">
+//     Copyright (c) Andrew Arnott. All rights reserved.
+// </copyright>
+//-----------------------------------------------------------------------
+
+namespace DotNetOpenAuth {
+	using System;
+	using System.Collections.Generic;
+	using System.Diagnostics;
+	using System.Linq;
+	using System.Text;
+
+	/// <summary>
+	/// Internal state consistency checks that throw an internal error exception when they fail.
+	/// </summary>
+	internal static class Assumes {
+		/// <summary>
+		/// Validates some expression describing the acceptable condition evaluates to true.
+		/// </summary>
+		/// <param name="condition">The expression that must evaluate to true to avoid an internal error exception.</param>
+		/// <param name="message">The message to include with the exception.</param>
+		[DebuggerStepThrough]
+		internal static void True(bool condition, string message = null) {
+			if (!condition) {
+				Fail(message);
+			}
+		}
+
+		/// <summary>
+		/// Validates some expression describing the acceptable condition evaluates to true.
+		/// </summary>
+		/// <param name="condition">The expression that must evaluate to true to avoid an internal error exception.</param>
+		/// <param name="unformattedMessage">The unformatted message.</param>
+		/// <param name="args">Formatting arguments.</param>
+		[DebuggerStepThrough]
+		internal static void True(bool condition, string unformattedMessage, params object[] args) {
+			if (!condition) {
+				Fail(String.Format(unformattedMessage, args));
+			}
+		}
+
+		/// <summary>
+		/// Throws an internal error exception.
+		/// </summary>
+		/// <param name="message">The message.</param>
+		internal static void Fail(string message = null) {
+			if (message != null) {
+				throw new InternalErrorException(message);
+			} else {
+				throw new InternalErrorException();
+			}
+		}
+
+		/// <summary>
+		/// An internal error exception that should never be caught.
+		/// </summary>
+		[Serializable]
+		private class InternalErrorException : Exception {
+			/// <summary>
+			/// Initializes a new instance of the <see cref="InternalErrorException"/> class.
+			/// </summary>
+			internal InternalErrorException() {
+			}
+
+			/// <summary>
+			/// Initializes a new instance of the <see cref="InternalErrorException"/> class.
+			/// </summary>
+			/// <param name="message">The message.</param>
+			internal InternalErrorException(string message) : base(message) {
+			}
+
+			/// <summary>
+			/// Initializes a new instance of the <see cref="InternalErrorException"/> class.
+			/// </summary>
+			/// <param name="message">The message.</param>
+			/// <param name="inner">The inner exception.</param>
+			internal InternalErrorException(string message, Exception inner) : base(message, inner) {
+			}
+
+			/// <summary>
+			/// Initializes a new instance of the <see cref="InternalErrorException"/> class.
+			/// </summary>
+			/// <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"/> that holds the serialized object data about the exception being thrown.</param>
+			/// <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext"/> that contains contextual information about the source or destination.</param>
+			/// <exception cref="T:System.ArgumentNullException">The <paramref name="info"/> parameter is null. </exception>
+			/// <exception cref="T:System.Runtime.Serialization.SerializationException">The class name is null or <see cref="P:System.Exception.HResult"/> is zero (0). </exception>
+			protected InternalErrorException(
+			  System.Runtime.Serialization.SerializationInfo info,
+			  System.Runtime.Serialization.StreamingContext context)
+				: base(info, context) {
+			}
+		}
+	}
+}
diff --git a/src/DotNetOpenAuth.Messaging/Configuration/TrustedProviderConfigurationCollection.cs b/src/DotNetOpenAuth.Messaging/Configuration/TrustedProviderConfigurationCollection.cs
index f5e62f4..1a287fd 100644
--- a/src/DotNetOpenAuth.Messaging/Configuration/TrustedProviderConfigurationCollection.cs
+++ b/src/DotNetOpenAuth.Messaging/Configuration/TrustedProviderConfigurationCollection.cs
@@ -32,7 +32,7 @@ namespace DotNetOpenAuth.Configuration {
 		/// <param name="elements">The elements to initialize the collection with.</param>
 		[SuppressMessage("Microsoft.Usage", "CA2214:DoNotCallOverridableMethodsInConstructors", Justification = "Seems unavoidable")]
 		internal TrustedProviderConfigurationCollection(IEnumerable<TrustedProviderEndpointConfigurationElement> elements) {
-			Contract.Requires<ArgumentNullException>(elements != null);
+			Requires.NotNull(elements, "elements");
 
 			foreach (TrustedProviderEndpointConfigurationElement element in elements) {
 				this.BaseAdd(element);
diff --git a/src/DotNetOpenAuth.Messaging/Configuration/TypeConfigurationCollection.cs b/src/DotNetOpenAuth.Messaging/Configuration/TypeConfigurationCollection.cs
index 93415d5..95b9c50 100644
--- a/src/DotNetOpenAuth.Messaging/Configuration/TypeConfigurationCollection.cs
+++ b/src/DotNetOpenAuth.Messaging/Configuration/TypeConfigurationCollection.cs
@@ -31,7 +31,7 @@ namespace DotNetOpenAuth.Configuration {
 		/// </summary>
 		/// <param name="elements">The elements that should be added to the collection initially.</param>
 		internal TypeConfigurationCollection(IEnumerable<Type> elements) {
-			Contract.Requires<ArgumentNullException>(elements != null);
+			Requires.NotNull(elements, "elements");
 
 			foreach (Type element in elements) {
 				this.BaseAdd(new TypeConfigurationElement<T> { TypeName = element.AssemblyQualifiedName });
diff --git a/src/DotNetOpenAuth.Messaging/DotNetOpenAuth.Messaging.csproj b/src/DotNetOpenAuth.Messaging/DotNetOpenAuth.Messaging.csproj
index 06452ec..801f447 100644
--- a/src/DotNetOpenAuth.Messaging/DotNetOpenAuth.Messaging.csproj
+++ b/src/DotNetOpenAuth.Messaging/DotNetOpenAuth.Messaging.csproj
@@ -11,6 +11,7 @@
     <ProjectGuid>{60426312-6AE5-4835-8667-37EDEA670222}</ProjectGuid>
     <AppDesignerFolder>Properties</AppDesignerFolder>
     <AssemblyName>DotNetOpenAuth.Messaging</AssemblyName>
+    <CodeContractsRewritingDisabled>true</CodeContractsRewritingDisabled>
   </PropertyGroup>
   <Import Project="$(ProjectRoot)tools\DotNetOpenAuth.Product.props" />
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
@@ -18,6 +19,7 @@
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
   </PropertyGroup>
   <ItemGroup>
+    <Compile Include="Assumes.cs" />
     <Compile Include="Messaging\Bindings\AsymmetricCryptoKeyStoreWrapper.cs" />
     <Compile Include="Messaging\Bindings\CryptoKey.cs" />
     <Compile Include="Messaging\Bindings\CryptoKeyCollisionException.cs" />
@@ -128,6 +130,7 @@
     <Compile Include="Loggers\TraceLogger.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="Reporting.cs" />
+    <Compile Include="Requires.cs" />
     <Compile Include="Strings.Designer.cs">
       <AutoGen>True</AutoGen>
       <DesignTime>True</DesignTime>
diff --git a/src/DotNetOpenAuth.Messaging/Logger.cs b/src/DotNetOpenAuth.Messaging/Logger.cs
index 48007ed..c9283cd 100644
--- a/src/DotNetOpenAuth.Messaging/Logger.cs
+++ b/src/DotNetOpenAuth.Messaging/Logger.cs
@@ -142,7 +142,7 @@ namespace DotNetOpenAuth {
 		/// <param name="name">A name that will be included in the log file.</param>
 		/// <returns>The <see cref="ILog"/> instance created with the given name.</returns>
 		internal static ILog Create(string name) {
-			Contract.Requires<ArgumentException>(!String.IsNullOrEmpty(name));
+			Requires.NotNullOrEmpty(name, "name");
 			return InitializeFacade(name);
 		}
 
@@ -153,7 +153,7 @@ namespace DotNetOpenAuth {
 		/// <param name="name">A name that will be included in the log file.</param>
 		/// <returns>The <see cref="ILog"/> instance created with the given name.</returns>
 		internal static ILog CreateWithBanner(string name) {
-			Contract.Requires<ArgumentException>(!String.IsNullOrEmpty(name));
+			Requires.NotNullOrEmpty(name, "name");
 			ILog log = Create(name);
 			log.Info(Util.LibraryVersion);
 			return log;
@@ -165,7 +165,7 @@ namespace DotNetOpenAuth {
 		/// <param name="type">A type whose full name that will be included in the log file.</param>
 		/// <returns>The <see cref="ILog"/> instance created with the given type name.</returns>
 		internal static ILog Create(Type type) {
-			Contract.Requires<ArgumentNullException>(type != null);
+			Requires.NotNull(type, "type");
 
 			return Create(type.FullName);
 		}
diff --git a/src/DotNetOpenAuth.Messaging/Messaging/BinaryDataBagFormatter.cs b/src/DotNetOpenAuth.Messaging/Messaging/BinaryDataBagFormatter.cs
index 591adc3..0c20955 100644
--- a/src/DotNetOpenAuth.Messaging/Messaging/BinaryDataBagFormatter.cs
+++ b/src/DotNetOpenAuth.Messaging/Messaging/BinaryDataBagFormatter.cs
@@ -44,7 +44,7 @@ namespace DotNetOpenAuth.Messaging {
 		/// <param name="decodeOnceOnly">The nonce store to use to ensure that this instance is only decoded once.</param>
 		protected internal BinaryDataBagFormatter(ICryptoKeyStore cryptoKeyStore = null, string bucket = null, bool signed = false, bool encrypted = false, bool compressed = false, TimeSpan? minimumAge = null, TimeSpan? maximumAge = null, INonceStore decodeOnceOnly = null)
 			: base(cryptoKeyStore, bucket, signed, encrypted, compressed, minimumAge, maximumAge, decodeOnceOnly) {
-			Contract.Requires<ArgumentException>((cryptoKeyStore != null && bucket != null) || (!signed && !encrypted));
+			Requires.True((cryptoKeyStore != null && bucket != null) || (!signed && !encrypted), null);
 		}
 
 		/// <summary>
diff --git a/src/DotNetOpenAuth.Messaging/Messaging/Bindings/AsymmetricCryptoKeyStoreWrapper.cs b/src/DotNetOpenAuth.Messaging/Messaging/Bindings/AsymmetricCryptoKeyStoreWrapper.cs
index 0f2ac05..2691202 100644
--- a/src/DotNetOpenAuth.Messaging/Messaging/Bindings/AsymmetricCryptoKeyStoreWrapper.cs
+++ b/src/DotNetOpenAuth.Messaging/Messaging/Bindings/AsymmetricCryptoKeyStoreWrapper.cs
@@ -40,9 +40,9 @@ namespace DotNetOpenAuth.Messaging.Bindings {
 		/// <param name="dataStore">The data store.</param>
 		/// <param name="asymmetricCrypto">The asymmetric protection to apply to symmetric keys.  Must include the private key.</param>
 		public AsymmetricCryptoKeyStoreWrapper(ICryptoKeyStore dataStore, RSACryptoServiceProvider asymmetricCrypto) {
-			Contract.Requires<ArgumentNullException>(dataStore != null);
-			Contract.Requires<ArgumentNullException>(asymmetricCrypto != null);
-			Contract.Requires<ArgumentException>(!asymmetricCrypto.PublicOnly);
+			Requires.NotNull(dataStore, "dataStore");
+			Requires.NotNull(asymmetricCrypto, "asymmetricCrypto");
+			Requires.True(!asymmetricCrypto.PublicOnly, "asymmetricCrypto");
 			this.dataStore = dataStore;
 			this.asymmetricCrypto = asymmetricCrypto;
 		}
diff --git a/src/DotNetOpenAuth.Messaging/Messaging/Bindings/CryptoKey.cs b/src/DotNetOpenAuth.Messaging/Messaging/Bindings/CryptoKey.cs
index cd10199..7160014 100644
--- a/src/DotNetOpenAuth.Messaging/Messaging/Bindings/CryptoKey.cs
+++ b/src/DotNetOpenAuth.Messaging/Messaging/Bindings/CryptoKey.cs
@@ -33,8 +33,8 @@ namespace DotNetOpenAuth.Messaging.Bindings {
 		/// <param name="key">The cryptographic key.</param>
 		/// <param name="expiresUtc">The expires UTC.</param>
 		public CryptoKey(byte[] key, DateTime expiresUtc) {
-			Contract.Requires<ArgumentNullException>(key != null);
-			Contract.Requires<ArgumentException>(expiresUtc.Kind == DateTimeKind.Utc);
+			Requires.NotNull(key, "key");
+			Requires.True(expiresUtc.Kind == DateTimeKind.Utc, "expiresUtc");
 			this.key = key;
 			this.expiresUtc = expiresUtc;
 		}
diff --git a/src/DotNetOpenAuth.Messaging/Messaging/Bindings/ExpiredMessageException.cs b/src/DotNetOpenAuth.Messaging/Messaging/Bindings/ExpiredMessageException.cs
index cfe7f6c..196946d 100644
--- a/src/DotNetOpenAuth.Messaging/Messaging/Bindings/ExpiredMessageException.cs
+++ b/src/DotNetOpenAuth.Messaging/Messaging/Bindings/ExpiredMessageException.cs
@@ -21,8 +21,8 @@ namespace DotNetOpenAuth.Messaging.Bindings {
 		/// <param name="faultedMessage">The expired message.</param>
 		public ExpiredMessageException(DateTime utcExpirationDate, IProtocolMessage faultedMessage)
 			: base(string.Format(CultureInfo.CurrentCulture, MessagingStrings.ExpiredMessage, utcExpirationDate.ToLocalTime(), DateTime.Now), faultedMessage) {
-			Contract.Requires<ArgumentException>(utcExpirationDate.Kind == DateTimeKind.Utc);
-			Contract.Requires<ArgumentNullException>(faultedMessage != null);
+			Requires.True(utcExpirationDate.Kind == DateTimeKind.Utc, "utcExpirationDate");
+			Requires.NotNull(faultedMessage, "faultedMessage");
 		}
 
 		/// <summary>
diff --git a/src/DotNetOpenAuth.Messaging/Messaging/Bindings/ICryptoKeyStore.cs b/src/DotNetOpenAuth.Messaging/Messaging/Bindings/ICryptoKeyStore.cs
index 815c488..861ba89 100644
--- a/src/DotNetOpenAuth.Messaging/Messaging/Bindings/ICryptoKeyStore.cs
+++ b/src/DotNetOpenAuth.Messaging/Messaging/Bindings/ICryptoKeyStore.cs
@@ -72,8 +72,8 @@ namespace DotNetOpenAuth.Messaging.Bindings {
 		/// The cryptographic key, or <c>null</c> if no matching key was found.
 		/// </returns>
 		CryptoKey ICryptoKeyStore.GetKey(string bucket, string handle) {
-			Contract.Requires<ArgumentException>(!String.IsNullOrEmpty(bucket));
-			Contract.Requires<ArgumentException>(!String.IsNullOrEmpty(handle));
+			Requires.NotNullOrEmpty(bucket, "bucket");
+			Requires.NotNullOrEmpty(handle, "handle");
 			throw new NotImplementedException();
 		}
 
@@ -85,7 +85,7 @@ namespace DotNetOpenAuth.Messaging.Bindings {
 		/// A sequence of handles and keys, ordered by descending <see cref="CryptoKey.ExpiresUtc"/>.
 		/// </returns>
 		IEnumerable<KeyValuePair<string, CryptoKey>> ICryptoKeyStore.GetKeys(string bucket) {
-			Contract.Requires<ArgumentException>(!String.IsNullOrEmpty(bucket));
+			Requires.NotNullOrEmpty(bucket, "bucket");
 			Contract.Ensures(Contract.Result<IEnumerable<KeyValuePair<string, CryptoKey>>>() != null);
 			throw new NotImplementedException();
 		}
@@ -98,9 +98,9 @@ namespace DotNetOpenAuth.Messaging.Bindings {
 		/// <param name="key">The key to store.</param>
 		/// <exception cref="CryptoKeyCollisionException">Thrown in the event of a conflict with an existing key in the same bucket and with the same handle.</exception>
 		void ICryptoKeyStore.StoreKey(string bucket, string handle, CryptoKey key) {
-			Contract.Requires<ArgumentException>(!String.IsNullOrEmpty(bucket));
-			Contract.Requires<ArgumentException>(!String.IsNullOrEmpty(handle));
-			Contract.Requires<ArgumentNullException>(key != null);
+			Requires.NotNullOrEmpty(bucket, "bucket");
+			Requires.NotNullOrEmpty(handle, "handle");
+			Requires.NotNull(key, "key");
 			throw new NotImplementedException();
 		}
 
@@ -110,8 +110,8 @@ namespace DotNetOpenAuth.Messaging.Bindings {
 		/// <param name="bucket">The bucket name.  Case sensitive.</param>
 		/// <param name="handle">The key handle.  Case sensitive.</param>
 		void ICryptoKeyStore.RemoveKey(string bucket, string handle) {
-			Contract.Requires<ArgumentException>(!String.IsNullOrEmpty(bucket));
-			Contract.Requires<ArgumentException>(!String.IsNullOrEmpty(handle));
+			Requires.NotNullOrEmpty(bucket, "bucket");
+			Requires.NotNullOrEmpty(handle, "handle");
 			throw new NotImplementedException();
 		}
 	}
diff --git a/src/DotNetOpenAuth.Messaging/Messaging/Bindings/StandardReplayProtectionBindingElement.cs b/src/DotNetOpenAuth.Messaging/Messaging/Bindings/StandardReplayProtectionBindingElement.cs
index bb56cfd..78fd1d5 100644
--- a/src/DotNetOpenAuth.Messaging/Messaging/Bindings/StandardReplayProtectionBindingElement.cs
+++ b/src/DotNetOpenAuth.Messaging/Messaging/Bindings/StandardReplayProtectionBindingElement.cs
@@ -42,7 +42,7 @@ namespace DotNetOpenAuth.Messaging.Bindings {
 		/// <param name="nonceStore">The store where nonces will be persisted and checked.</param>
 		/// <param name="allowEmptyNonces">A value indicating whether zero-length nonces will be allowed.</param>
 		internal StandardReplayProtectionBindingElement(INonceStore nonceStore, bool allowEmptyNonces) {
-			Contract.Requires<ArgumentNullException>(nonceStore != null);
+			Requires.NotNull(nonceStore, "nonceStore");
 
 			this.nonceStore = nonceStore;
 			this.AllowZeroLengthNonce = allowEmptyNonces;
diff --git a/src/DotNetOpenAuth.Messaging/Messaging/CachedDirectWebResponse.cs b/src/DotNetOpenAuth.Messaging/Messaging/CachedDirectWebResponse.cs
index 111d636..2f3a1d9 100644
--- a/src/DotNetOpenAuth.Messaging/Messaging/CachedDirectWebResponse.cs
+++ b/src/DotNetOpenAuth.Messaging/Messaging/CachedDirectWebResponse.cs
@@ -38,8 +38,8 @@ namespace DotNetOpenAuth.Messaging {
 		/// <param name="maximumBytesToRead">The maximum bytes to read.</param>
 		internal CachedDirectWebResponse(Uri requestUri, HttpWebResponse response, int maximumBytesToRead)
 			: base(requestUri, response) {
-			Contract.Requires<ArgumentNullException>(requestUri != null);
-			Contract.Requires<ArgumentNullException>(response != null);
+			Requires.NotNull(requestUri, "requestUri");
+			Requires.NotNull(response, "response");
 			this.responseStream = CacheNetworkStreamAndClose(response, maximumBytesToRead);
 
 			// BUGBUG: if the response was exactly maximumBytesToRead, we'll incorrectly believe it was truncated.
@@ -58,8 +58,8 @@ namespace DotNetOpenAuth.Messaging {
 		/// <param name="responseStream">The response stream.</param>
 		internal CachedDirectWebResponse(Uri requestUri, Uri responseUri, WebHeaderCollection headers, HttpStatusCode statusCode, string contentType, string contentEncoding, MemoryStream responseStream)
 			: base(requestUri, responseUri, headers, statusCode, contentType, contentEncoding) {
-			Contract.Requires<ArgumentNullException>(requestUri != null);
-			Contract.Requires<ArgumentNullException>(responseStream != null);
+			Requires.NotNull(requestUri, "requestUri");
+			Requires.NotNull(responseStream, "responseStream");
 			this.responseStream = responseStream;
 		}
 
@@ -159,7 +159,7 @@ namespace DotNetOpenAuth.Messaging {
 		/// <returns>The seekable Stream instance that contains a copy of what was returned in the HTTP response.</returns>
 		[SuppressMessage("Microsoft.Globalization", "CA1303:Do not pass literals as localized parameters", MessageId = "System.Diagnostics.Contracts.__ContractsRuntime.Assume(System.Boolean,System.String,System.String)", Justification = "No localization required.")]
 		private static MemoryStream CacheNetworkStreamAndClose(HttpWebResponse response, int maximumBytesToRead) {
-			Contract.Requires<ArgumentNullException>(response != null);
+			Requires.NotNull(response, "response");
 			Contract.Ensures(Contract.Result<MemoryStream>() != null);
 
 			// Now read and cache the network stream
diff --git a/src/DotNetOpenAuth.Messaging/Messaging/Channel.cs b/src/DotNetOpenAuth.Messaging/Messaging/Channel.cs
index cb32ca3..7f83612 100644
--- a/src/DotNetOpenAuth.Messaging/Messaging/Channel.cs
+++ b/src/DotNetOpenAuth.Messaging/Messaging/Channel.cs
@@ -145,7 +145,7 @@ namespace DotNetOpenAuth.Messaging {
 		/// </param>
 		/// <param name="bindingElements">The binding elements to use in sending and receiving messages.</param>
 		protected Channel(IMessageFactory messageTypeProvider, params IChannelBindingElement[] bindingElements) {
-			Contract.Requires<ArgumentNullException>(messageTypeProvider != null);
+			Requires.NotNull(messageTypeProvider, "messageTypeProvider");
 
 			this.messageTypeProvider = messageTypeProvider;
 			this.WebRequestHandler = new StandardWebRequestHandler();
@@ -193,7 +193,7 @@ namespace DotNetOpenAuth.Messaging {
 			}
 
 			set {
-				Contract.Requires<ArgumentOutOfRangeException>(value >= 500 && value <= 4096);
+				Requires.InRange(value >= 500 && value <= 4096, "value");
 				this.maximumIndirectMessageUrlLength = value;
 			}
 		}
@@ -207,7 +207,7 @@ namespace DotNetOpenAuth.Messaging {
 			}
 
 			set {
-				Contract.Requires<ArgumentNullException>(value != null);
+				Requires.NotNull(value, "value");
 				this.messageDescriptions = value;
 			}
 		}
@@ -277,7 +277,7 @@ namespace DotNetOpenAuth.Messaging {
 			}
 
 			set {
-				Contract.Requires<ArgumentNullException>(value != null);
+				Requires.NotNull(value, "value");
 				this.cachePolicy = value;
 			}
 		}
@@ -300,8 +300,8 @@ namespace DotNetOpenAuth.Messaging {
 		/// </remarks>
 		[EditorBrowsable(EditorBrowsableState.Never), Obsolete("Use the Respond method instead, and prepare for execution to continue on this page beyond the call to Respond.")]
 		public void Send(IProtocolMessage message) {
-			Contract.Requires<InvalidOperationException>(HttpContext.Current != null, MessagingStrings.CurrentHttpContextRequired);
-			Contract.Requires<ArgumentNullException>(message != null);
+			Requires.ValidState(HttpContext.Current != null, MessagingStrings.CurrentHttpContextRequired);
+			Requires.NotNull(message, "message");
 			this.PrepareResponse(message).Respond(HttpContext.Current, true);
 		}
 
@@ -315,8 +315,8 @@ namespace DotNetOpenAuth.Messaging {
 		/// Requires an HttpContext.Current context.
 		/// </remarks>
 		public void Respond(IProtocolMessage message) {
-			Contract.Requires<InvalidOperationException>(HttpContext.Current != null, MessagingStrings.CurrentHttpContextRequired);
-			Contract.Requires<ArgumentNullException>(message != null);
+			Requires.ValidState(HttpContext.Current != null, MessagingStrings.CurrentHttpContextRequired);
+			Requires.NotNull(message, "message");
 			this.PrepareResponse(message).Respond();
 		}
 
@@ -327,7 +327,7 @@ namespace DotNetOpenAuth.Messaging {
 		/// <param name="message">The one-way message to send</param>
 		/// <returns>The pending user agent redirect based message to be sent as an HttpResponse.</returns>
 		public OutgoingWebResponse PrepareResponse(IProtocolMessage message) {
-			Contract.Requires<ArgumentNullException>(message != null);
+			Requires.NotNull(message, "message");
 			Contract.Ensures(Contract.Result<OutgoingWebResponse>() != null);
 
 			this.ProcessOutgoingMessage(message);
@@ -407,7 +407,7 @@ namespace DotNetOpenAuth.Messaging {
 		/// <exception cref="ProtocolException">Thrown when a request message of an unexpected type is received.</exception>
 		public bool TryReadFromRequest<TRequest>(HttpRequestInfo httpRequest, out TRequest request)
 			where TRequest : class, IProtocolMessage {
-			Contract.Requires<ArgumentNullException>(httpRequest != null);
+			Requires.NotNull(httpRequest, "httpRequest");
 			Contract.Ensures(Contract.Result<bool>() == (Contract.ValueAtReturn<TRequest>(out request) != null));
 
 			IProtocolMessage untypedRequest = this.ReadFromRequest(httpRequest);
@@ -448,7 +448,7 @@ namespace DotNetOpenAuth.Messaging {
 		[SuppressMessage("Microsoft.Design", "CA1004:GenericMethodsShouldProvideTypeParameter", Justification = "This returns and verifies the appropriate message type.")]
 		public TRequest ReadFromRequest<TRequest>(HttpRequestInfo httpRequest)
 			where TRequest : class, IProtocolMessage {
-			Contract.Requires<ArgumentNullException>(httpRequest != null);
+			Requires.NotNull(httpRequest, "httpRequest");
 			TRequest request;
 			if (this.TryReadFromRequest<TRequest>(httpRequest, out request)) {
 				return request;
@@ -463,7 +463,7 @@ namespace DotNetOpenAuth.Messaging {
 		/// <param name="httpRequest">The request to search for an embedded message.</param>
 		/// <returns>The deserialized message, if one is found.  Null otherwise.</returns>
 		public IDirectedProtocolMessage ReadFromRequest(HttpRequestInfo httpRequest) {
-			Contract.Requires<ArgumentNullException>(httpRequest != null);
+			Requires.NotNull(httpRequest, "httpRequest");
 
 			if (Logger.Channel.IsInfoEnabled && httpRequest.UrlBeforeRewriting != null) {
 				Logger.Channel.InfoFormat("Scanning incoming request for messages: {0}", httpRequest.UrlBeforeRewriting.AbsoluteUri);
@@ -490,7 +490,7 @@ namespace DotNetOpenAuth.Messaging {
 		[SuppressMessage("Microsoft.Design", "CA1004:GenericMethodsShouldProvideTypeParameter", Justification = "This returns and verifies the appropriate message type.")]
 		public TResponse Request<TResponse>(IDirectedProtocolMessage requestMessage)
 			where TResponse : class, IProtocolMessage {
-			Contract.Requires<ArgumentNullException>(requestMessage != null);
+			Requires.NotNull(requestMessage, "requestMessage");
 			Contract.Ensures(Contract.Result<TResponse>() != null);
 
 			IProtocolMessage response = this.Request(requestMessage);
@@ -509,7 +509,7 @@ namespace DotNetOpenAuth.Messaging {
 		/// <returns>The remote party's response.  Guaranteed to never be null.</returns>
 		/// <exception cref="ProtocolException">Thrown if the response does not include a protocol message.</exception>
 		public IProtocolMessage Request(IDirectedProtocolMessage requestMessage) {
-			Contract.Requires<ArgumentNullException>(requestMessage != null);
+			Requires.NotNull(requestMessage, "requestMessage");
 
 			this.ProcessOutgoingMessage(requestMessage);
 			Logger.Channel.DebugFormat("Sending {0} request.", requestMessage.GetType().Name);
@@ -604,7 +604,7 @@ namespace DotNetOpenAuth.Messaging {
 		/// <exception cref="InvalidOperationException">Thrown if <see cref="HttpContext.Current">HttpContext.Current</see> == <c>null</c>.</exception>
 		[SuppressMessage("Microsoft.Design", "CA1024:UsePropertiesWhereAppropriate", Justification = "Costly call should not be a property.")]
 		protected internal virtual HttpRequestInfo GetRequestFromContext() {
-			Contract.Requires<InvalidOperationException>(HttpContext.Current != null && HttpContext.Current.Request != null, MessagingStrings.HttpContextRequired);
+			Requires.ValidState(HttpContext.Current != null && HttpContext.Current.Request != null, MessagingStrings.HttpContextRequired);
 			Contract.Ensures(Contract.Result<HttpRequestInfo>() != null);
 			Contract.Ensures(Contract.Result<HttpRequestInfo>().Url != null);
 			Contract.Ensures(Contract.Result<HttpRequestInfo>().RawUrl != null);
@@ -653,7 +653,7 @@ namespace DotNetOpenAuth.Messaging {
 		/// </summary>
 		/// <param name="message">The message about to be encoded and sent.</param>
 		protected virtual void OnSending(IProtocolMessage message) {
-			Contract.Requires<ArgumentNullException>(message != null);
+			Requires.NotNull(message, "message");
 
 			var sending = this.Sending;
 			if (sending != null) {
@@ -668,7 +668,7 @@ namespace DotNetOpenAuth.Messaging {
 		/// <returns>The response to the web request.</returns>
 		/// <exception cref="ProtocolException">Thrown on network or protocol errors.</exception>
 		protected virtual IncomingWebResponse GetDirectResponse(HttpWebRequest webRequest) {
-			Contract.Requires<ArgumentNullException>(webRequest != null);
+			Requires.NotNull(webRequest, "webRequest");
 			return this.WebRequestHandler.GetResponse(webRequest);
 		}
 
@@ -683,8 +683,8 @@ namespace DotNetOpenAuth.Messaging {
 		/// this method to eliminate all use of an HTTP transport.
 		/// </remarks>
 		protected virtual IProtocolMessage RequestCore(IDirectedProtocolMessage request) {
-			Contract.Requires<ArgumentNullException>(request != null);
-			Contract.Requires<ArgumentException>(request.Recipient != null, MessagingStrings.DirectedMessageMissingRecipient);
+			Requires.NotNull(request, "request");
+			Requires.True(request.Recipient != null, "request", MessagingStrings.DirectedMessageMissingRecipient);
 
 			HttpWebRequest webRequest = this.CreateHttpRequest(request);
 			IDictionary<string, string> responseFields;
@@ -728,7 +728,7 @@ namespace DotNetOpenAuth.Messaging {
 		/// <param name="request">The request to search for an embedded message.</param>
 		/// <returns>The deserialized message, if one is found.  Null otherwise.</returns>
 		protected virtual IDirectedProtocolMessage ReadFromRequestCore(HttpRequestInfo request) {
-			Contract.Requires<ArgumentNullException>(request != null);
+			Requires.NotNull(request, "request");
 
 			Logger.Channel.DebugFormat("Incoming HTTP request: {0} {1}", request.HttpMethod, request.UrlBeforeRewriting.AbsoluteUri);
 
@@ -757,7 +757,7 @@ namespace DotNetOpenAuth.Messaging {
 		/// <param name="recipient">Information about where the message was directed.  Null for direct response messages.</param>
 		/// <returns>The deserialized message, or null if no message could be recognized in the provided data.</returns>
 		protected virtual IProtocolMessage Receive(Dictionary<string, string> fields, MessageReceivingEndpoint recipient) {
-			Contract.Requires<ArgumentNullException>(fields != null);
+			Requires.NotNull(fields, "fields");
 
 			this.FilterReceivedFields(fields);
 			IProtocolMessage message = this.MessageFactory.GetNewRequestMessage(recipient, fields);
@@ -784,9 +784,9 @@ namespace DotNetOpenAuth.Messaging {
 		/// <param name="message">The message to send.</param>
 		/// <returns>The pending user agent redirect based message to be sent as an HttpResponse.</returns>
 		protected virtual OutgoingWebResponse PrepareIndirectResponse(IDirectedProtocolMessage message) {
-			Contract.Requires<ArgumentNullException>(message != null);
-			Contract.Requires<ArgumentException>(message.Recipient != null, MessagingStrings.DirectedMessageMissingRecipient);
-			Contract.Requires<ArgumentException>((message.HttpMethods & (HttpDeliveryMethods.GetRequest | HttpDeliveryMethods.PostRequest)) != 0);
+			Requires.NotNull(message, "message");
+			Requires.True(message.Recipient != null, "message", MessagingStrings.DirectedMessageMissingRecipient);
+			Requires.True((message.HttpMethods & (HttpDeliveryMethods.GetRequest | HttpDeliveryMethods.PostRequest)) != 0, "message");
 			Contract.Ensures(Contract.Result<OutgoingWebResponse>() != null);
 
 			Contract.Assert(message != null && message.Recipient != null);
@@ -834,9 +834,9 @@ namespace DotNetOpenAuth.Messaging {
 		/// <returns>The encoded HTTP response.</returns>
 		[Pure]
 		protected virtual OutgoingWebResponse Create301RedirectResponse(IDirectedProtocolMessage message, IDictionary<string, string> fields, bool payloadInFragment = false) {
-			Contract.Requires<ArgumentNullException>(message != null);
-			Contract.Requires<ArgumentException>(message.Recipient != null, MessagingStrings.DirectedMessageMissingRecipient);
-			Contract.Requires<ArgumentNullException>(fields != null);
+			Requires.NotNull(message, "message");
+			Requires.True(message.Recipient != null, "message", MessagingStrings.DirectedMessageMissingRecipient);
+			Requires.NotNull(fields, "fields");
 			Contract.Ensures(Contract.Result<OutgoingWebResponse>() != null);
 
 			// As part of this redirect, we include an HTML body in order to get passed some proxy filters
@@ -870,9 +870,9 @@ namespace DotNetOpenAuth.Messaging {
 		/// <param name="fields">The pre-serialized fields from the message.</param>
 		/// <returns>The encoded HTTP response.</returns>
 		protected virtual OutgoingWebResponse CreateFormPostResponse(IDirectedProtocolMessage message, IDictionary<string, string> fields) {
-			Contract.Requires<ArgumentNullException>(message != null);
-			Contract.Requires<ArgumentException>(message.Recipient != null, MessagingStrings.DirectedMessageMissingRecipient);
-			Contract.Requires<ArgumentNullException>(fields != null);
+			Requires.NotNull(message, "message");
+			Requires.True(message.Recipient != null, "message", MessagingStrings.DirectedMessageMissingRecipient);
+			Requires.NotNull(fields, "fields");
 			Contract.Ensures(Contract.Result<OutgoingWebResponse>() != null);
 
 			WebHeaderCollection headers = new WebHeaderCollection();
@@ -919,8 +919,8 @@ namespace DotNetOpenAuth.Messaging {
 		/// is overridden and does not require this method.
 		/// </remarks>
 		protected virtual HttpWebRequest CreateHttpRequest(IDirectedProtocolMessage request) {
-			Contract.Requires<ArgumentNullException>(request != null);
-			Contract.Requires<ArgumentException>(request.Recipient != null, MessagingStrings.DirectedMessageMissingRecipient);
+			Requires.NotNull(request, "request");
+			Requires.True(request.Recipient != null, "request", MessagingStrings.DirectedMessageMissingRecipient);
 			Contract.Ensures(Contract.Result<HttpWebRequest>() != null);
 			throw new NotImplementedException();
 		}
@@ -943,7 +943,7 @@ namespace DotNetOpenAuth.Messaging {
 		/// <returns>A JSON string.</returns>
 		[SuppressMessage("Microsoft.Usage", "CA2202:Do not dispose objects multiple times", Justification = "This Dispose is safe.")]
 		protected virtual string SerializeAsJson(IMessage message) {
-			Contract.Requires<ArgumentNullException>(message != null);
+			Requires.NotNull(message, "message");
 
 			MessageDictionary messageDictionary = this.MessageDescriptions.GetAccessor(message);
 			using (var memoryStream = new MemoryStream()) {
@@ -963,7 +963,7 @@ namespace DotNetOpenAuth.Messaging {
 		/// <param name="json">A JSON string.</param>
 		/// <returns>The simple "key":"value" pairs from a JSON-encoded object.</returns>
 		protected virtual IDictionary<string, string> DeserializeFromJson(string json) {
-			Contract.Requires<ArgumentException>(!String.IsNullOrEmpty(json));
+			Requires.NotNullOrEmpty(json, "json");
 
 			var dictionary = new Dictionary<string, string>();
 			using (var jsonReader = JsonReaderWriterFactory.CreateJsonReader(Encoding.UTF8.GetBytes(json), this.XmlDictionaryReaderQuotas)) {
@@ -981,7 +981,7 @@ namespace DotNetOpenAuth.Messaging {
 		/// except when sending ONE WAY request messages.
 		/// </remarks>
 		protected void ProcessOutgoingMessage(IProtocolMessage message) {
-			Contract.Requires<ArgumentNullException>(message != null);
+			Requires.NotNull(message, "message");
 
 			Logger.Channel.DebugFormat("Preparing to send {0} ({1}) message.", message.GetType().Name, message.Version);
 			this.OnSending(message);
@@ -1040,8 +1040,8 @@ namespace DotNetOpenAuth.Messaging {
 		/// This method satisfies OAuth 1.0 section 5.2, item #3.
 		/// </remarks>
 		protected virtual HttpWebRequest InitializeRequestAsGet(IDirectedProtocolMessage requestMessage) {
-			Contract.Requires<ArgumentNullException>(requestMessage != null);
-			Contract.Requires<ArgumentException>(requestMessage.Recipient != null, MessagingStrings.DirectedMessageMissingRecipient);
+			Requires.NotNull(requestMessage, "requestMessage");
+			Requires.True(requestMessage.Recipient != null, "requestMessage", MessagingStrings.DirectedMessageMissingRecipient);
 
 			var messageAccessor = this.MessageDescriptions.GetAccessor(requestMessage);
 			var fields = messageAccessor.Serialize();
@@ -1063,8 +1063,8 @@ namespace DotNetOpenAuth.Messaging {
 		/// This method satisfies OAuth 1.0 section 5.2, item #3.
 		/// </remarks>
 		protected virtual HttpWebRequest InitializeRequestAsHead(IDirectedProtocolMessage requestMessage) {
-			Contract.Requires<ArgumentNullException>(requestMessage != null);
-			Contract.Requires<ArgumentException>(requestMessage.Recipient != null, MessagingStrings.DirectedMessageMissingRecipient);
+			Requires.NotNull(requestMessage, "requestMessage");
+			Requires.True(requestMessage.Recipient != null, "requestMessage", MessagingStrings.DirectedMessageMissingRecipient);
 
 			HttpWebRequest request = this.InitializeRequestAsGet(requestMessage);
 			request.Method = "HEAD";
@@ -1082,7 +1082,7 @@ namespace DotNetOpenAuth.Messaging {
 		/// This method satisfies OAuth 1.0 section 5.2, item #2 and OpenID 2.0 section 4.1.2.
 		/// </remarks>
 		protected virtual HttpWebRequest InitializeRequestAsPost(IDirectedProtocolMessage requestMessage) {
-			Contract.Requires<ArgumentNullException>(requestMessage != null);
+			Requires.NotNull(requestMessage, "requestMessage");
 			Contract.Ensures(Contract.Result<HttpWebRequest>() != null);
 
 			var messageAccessor = this.MessageDescriptions.GetAccessor(requestMessage);
@@ -1116,7 +1116,7 @@ namespace DotNetOpenAuth.Messaging {
 		/// This method is simply a standard HTTP PUT request with the message parts serialized to the query string.
 		/// </remarks>
 		protected virtual HttpWebRequest InitializeRequestAsPut(IDirectedProtocolMessage requestMessage) {
-			Contract.Requires<ArgumentNullException>(requestMessage != null);
+			Requires.NotNull(requestMessage, "requestMessage");
 			Contract.Ensures(Contract.Result<HttpWebRequest>() != null);
 
 			HttpWebRequest request = this.InitializeRequestAsGet(requestMessage);
@@ -1133,7 +1133,7 @@ namespace DotNetOpenAuth.Messaging {
 		/// This method is simply a standard HTTP DELETE request with the message parts serialized to the query string.
 		/// </remarks>
 		protected virtual HttpWebRequest InitializeRequestAsDelete(IDirectedProtocolMessage requestMessage) {
-			Contract.Requires<ArgumentNullException>(requestMessage != null);
+			Requires.NotNull(requestMessage, "requestMessage");
 			Contract.Ensures(Contract.Result<HttpWebRequest>() != null);
 
 			HttpWebRequest request = this.InitializeRequestAsGet(requestMessage);
@@ -1151,8 +1151,8 @@ namespace DotNetOpenAuth.Messaging {
 		/// the request stream, but does not call <see cref="HttpWebRequest.GetResponse"/>.
 		/// </remarks>
 		protected void SendParametersInEntity(HttpWebRequest httpRequest, IDictionary<string, string> fields) {
-			Contract.Requires<ArgumentNullException>(httpRequest != null);
-			Contract.Requires<ArgumentNullException>(fields != null);
+			Requires.NotNull(httpRequest, "httpRequest");
+			Requires.NotNull(fields, "fields");
 
 			string requestBody = MessagingUtilities.CreateQueryString(fields);
 			byte[] requestBytes = PostEntityEncoding.GetBytes(requestBody);
@@ -1193,7 +1193,7 @@ namespace DotNetOpenAuth.Messaging {
 		/// This can be due to tampering, replay attack or expiration, among other things.
 		/// </exception>
 		protected virtual void ProcessIncomingMessage(IProtocolMessage message) {
-			Contract.Requires<ArgumentNullException>(message != null);
+			Requires.NotNull(message, "message");
 
 			if (Logger.Channel.IsInfoEnabled) {
 				var messageAccessor = this.MessageDescriptions.GetAccessor(message, true);
@@ -1276,8 +1276,8 @@ namespace DotNetOpenAuth.Messaging {
 		/// </remarks>
 		/// <exception cref="ArgumentException">Thrown if a binding element is new or missing in one of the ordered lists.</exception>
 		protected void CustomizeBindingElementOrder(IEnumerable<IChannelBindingElement> outgoingOrder, IEnumerable<IChannelBindingElement> incomingOrder) {
-			Contract.Requires<ArgumentNullException>(outgoingOrder != null);
-			Contract.Requires<ArgumentNullException>(incomingOrder != null);
+			Requires.NotNull(outgoingOrder, "outgoingOrder");
+			Requires.NotNull(incomingOrder, "incomingOrder");
 			ErrorUtilities.VerifyArgument(this.IsBindingElementOrderValid(outgoingOrder), MessagingStrings.InvalidCustomBindingElementOrder);
 			ErrorUtilities.VerifyArgument(this.IsBindingElementOrderValid(incomingOrder), MessagingStrings.InvalidCustomBindingElementOrder);
 
@@ -1295,7 +1295,7 @@ namespace DotNetOpenAuth.Messaging {
 		/// <returns>The properly ordered list of elements.</returns>
 		/// <exception cref="ProtocolException">Thrown when the binding elements are incomplete or inconsistent with each other.</exception>
 		private static IEnumerable<IChannelBindingElement> ValidateAndPrepareBindingElements(IEnumerable<IChannelBindingElement> elements) {
-			Contract.Requires<ArgumentException>(elements == null || elements.All(e => e != null));
+			Requires.NullOrWithNoNullElements(elements, "elements");
 			Contract.Ensures(Contract.Result<IEnumerable<IChannelBindingElement>>() != null);
 			if (elements == null) {
 				return new IChannelBindingElement[0];
@@ -1368,7 +1368,7 @@ namespace DotNetOpenAuth.Messaging {
 		/// Thrown when any required message part does not have a value.
 		/// </exception>
 		private void EnsureValidMessageParts(IProtocolMessage message) {
-			Contract.Requires<ArgumentNullException>(message != null);
+			Requires.NotNull(message, "message");
 			MessageDictionary dictionary = this.MessageDescriptions.GetAccessor(message);
 			MessageDescription description = this.MessageDescriptions.Get(message);
 			description.EnsureMessagePartsPassBasicValidation(dictionary);
@@ -1384,7 +1384,7 @@ namespace DotNetOpenAuth.Messaging {
 		/// </returns>
 		[Pure]
 		private bool IsBindingElementOrderValid(IEnumerable<IChannelBindingElement> order) {
-			Contract.Requires<ArgumentNullException>(order != null);
+			Requires.NotNull(order, "order");
 
 			// Check that the same number of binding elements are defined.
 			if (order.Count() != this.OutgoingBindingElements.Count) {
diff --git a/src/DotNetOpenAuth.Messaging/Messaging/ChannelContract.cs b/src/DotNetOpenAuth.Messaging/Messaging/ChannelContract.cs
index 9b85d28..bf313ef 100644
--- a/src/DotNetOpenAuth.Messaging/Messaging/ChannelContract.cs
+++ b/src/DotNetOpenAuth.Messaging/Messaging/ChannelContract.cs
@@ -30,7 +30,7 @@ namespace DotNetOpenAuth.Messaging {
 		/// </returns>
 		/// <exception cref="ProtocolException">Thrown when the response is not valid.</exception>
 		protected override IDictionary<string, string> ReadFromResponseCore(IncomingWebResponse response) {
-			Contract.Requires<ArgumentNullException>(response != null);
+			Requires.NotNull(response, "response");
 			throw new NotImplementedException();
 		}
 
@@ -46,7 +46,7 @@ namespace DotNetOpenAuth.Messaging {
 		/// This method implements spec V1.0 section 5.3.
 		/// </remarks>
 		protected override OutgoingWebResponse PrepareDirectResponse(IProtocolMessage response) {
-			Contract.Requires<ArgumentNullException>(response != null);
+			Requires.NotNull(response, "response");
 			Contract.Ensures(Contract.Result<OutgoingWebResponse>() != null);
 			throw new NotImplementedException();
 		}
diff --git a/src/DotNetOpenAuth.Messaging/Messaging/ChannelEventArgs.cs b/src/DotNetOpenAuth.Messaging/Messaging/ChannelEventArgs.cs
index 1e71bf2..e09e655 100644
--- a/src/DotNetOpenAuth.Messaging/Messaging/ChannelEventArgs.cs
+++ b/src/DotNetOpenAuth.Messaging/Messaging/ChannelEventArgs.cs
@@ -17,7 +17,7 @@ namespace DotNetOpenAuth.Messaging {
 		/// </summary>
 		/// <param name="message">The message behind the fired event..</param>
 		internal ChannelEventArgs(IProtocolMessage message) {
-			Contract.Requires<ArgumentNullException>(message != null);
+			Requires.NotNull(message, "message");
 
 			this.Message = message;
 		}
diff --git a/src/DotNetOpenAuth.Messaging/Messaging/DataBagFormatterBase.cs b/src/DotNetOpenAuth.Messaging/Messaging/DataBagFormatterBase.cs
index 9cb63e6..86ada44 100644
--- a/src/DotNetOpenAuth.Messaging/Messaging/DataBagFormatterBase.cs
+++ b/src/DotNetOpenAuth.Messaging/Messaging/DataBagFormatterBase.cs
@@ -109,8 +109,8 @@ namespace DotNetOpenAuth.Messaging {
 		/// <param name="decodeOnceOnly">The nonce store to use to ensure that this instance is only decoded once.</param>
 		protected DataBagFormatterBase(ICryptoKeyStore cryptoKeyStore = null, string bucket = null, bool signed = false, bool encrypted = false, bool compressed = false, TimeSpan? minimumAge = null, TimeSpan? maximumAge = null, INonceStore decodeOnceOnly = null)
 			: this(signed, encrypted, compressed, maximumAge, decodeOnceOnly) {
-			Contract.Requires<ArgumentException>(!String.IsNullOrEmpty(bucket) || cryptoKeyStore == null);
-			Contract.Requires<ArgumentException>(cryptoKeyStore != null || (!signed && !encrypted));
+			Requires.True(!String.IsNullOrEmpty(bucket) || cryptoKeyStore == null, null);
+			Requires.True(cryptoKeyStore != null || (!signed && !encrypted), null);
 
 			this.cryptoKeyStore = cryptoKeyStore;
 			this.cryptoKeyBucket = bucket;
@@ -128,8 +128,8 @@ namespace DotNetOpenAuth.Messaging {
 		/// <param name="maximumAge">The maximum age of a token that can be decoded; useful only when <paramref name="decodeOnceOnly"/> is <c>true</c>.</param>
 		/// <param name="decodeOnceOnly">The nonce store to use to ensure that this instance is only decoded once.</param>
 		private DataBagFormatterBase(bool signed = false, bool encrypted = false, bool compressed = false, TimeSpan? maximumAge = null, INonceStore decodeOnceOnly = null) {
-			Contract.Requires<ArgumentException>(signed || decodeOnceOnly == null);
-			Contract.Requires<ArgumentException>(maximumAge.HasValue || decodeOnceOnly == null);
+			Requires.True(signed || decodeOnceOnly == null, null);
+			Requires.True(maximumAge.HasValue || decodeOnceOnly == null, null);
 
 			this.signed = signed;
 			this.maximumAge = maximumAge;
@@ -272,8 +272,8 @@ namespace DotNetOpenAuth.Messaging {
 		///   <c>true</c> if the signature is valid; otherwise, <c>false</c>.
 		/// </returns>
 		private bool IsSignatureValid(byte[] signedData, byte[] signature, string symmetricSecretHandle) {
-			Contract.Requires<ArgumentNullException>(signedData != null);
-			Contract.Requires<ArgumentNullException>(signature != null);
+			Requires.NotNull(signedData, "signedData");
+			Requires.NotNull(signature, "signature");
 
 			if (this.asymmetricSigning != null) {
 				using (var hasher = new SHA1CryptoServiceProvider()) {
@@ -293,8 +293,8 @@ namespace DotNetOpenAuth.Messaging {
 		/// The calculated signature.
 		/// </returns>
 		private byte[] CalculateSignature(byte[] bytesToSign, string symmetricSecretHandle) {
-			Contract.Requires<ArgumentNullException>(bytesToSign != null);
-			Contract.Requires<InvalidOperationException>(this.asymmetricSigning != null || this.cryptoKeyStore != null);
+			Requires.NotNull(bytesToSign, "bytesToSign");
+			Requires.ValidState(this.asymmetricSigning != null || this.cryptoKeyStore != null);
 			Contract.Ensures(Contract.Result<byte[]>() != null);
 
 			if (this.asymmetricSigning != null) {
@@ -319,7 +319,7 @@ namespace DotNetOpenAuth.Messaging {
 		/// The encrypted value.
 		/// </returns>
 		private byte[] Encrypt(byte[] value, out string symmetricSecretHandle) {
-			Contract.Requires<InvalidOperationException>(this.asymmetricEncrypting != null || this.cryptoKeyStore != null);
+			Requires.ValidState(this.asymmetricEncrypting != null || this.cryptoKeyStore != null);
 
 			if (this.asymmetricEncrypting != null) {
 				symmetricSecretHandle = null;
@@ -340,7 +340,7 @@ namespace DotNetOpenAuth.Messaging {
 		/// The decrypted value.
 		/// </returns>
 		private byte[] Decrypt(byte[] value, string symmetricSecretHandle) {
-			Contract.Requires<InvalidOperationException>(this.asymmetricEncrypting != null || symmetricSecretHandle != null);
+			Requires.ValidState(this.asymmetricEncrypting != null || symmetricSecretHandle != null);
 
 			if (this.asymmetricEncrypting != null) {
 				return this.asymmetricEncrypting.DecryptWithRandomSymmetricKey(value);
diff --git a/src/DotNetOpenAuth.Messaging/Messaging/EnumerableCache.cs b/src/DotNetOpenAuth.Messaging/Messaging/EnumerableCache.cs
index be65bca..f6ea55e 100644
--- a/src/DotNetOpenAuth.Messaging/Messaging/EnumerableCache.cs
+++ b/src/DotNetOpenAuth.Messaging/Messaging/EnumerableCache.cs
@@ -35,7 +35,7 @@ namespace DotNetOpenAuth.Messaging {
 		/// to avoid double-caching.</para>
 		/// </remarks>
 		public static IEnumerable<T> CacheGeneratedResults<T>(this IEnumerable<T> sequence) {
-			Contract.Requires<ArgumentNullException>(sequence != null);
+			Requires.NotNull(sequence, "sequence");
 
 			// Don't create a cache for types that don't need it.
 			if (sequence is IList<T> ||
@@ -83,7 +83,7 @@ namespace DotNetOpenAuth.Messaging {
 			/// </summary>
 			/// <param name="generator">The generator.</param>
 			internal EnumerableCache(IEnumerable<T> generator) {
-				Contract.Requires<ArgumentNullException>(generator != null);
+				Requires.NotNull(generator, "generator");
 
 				this.generator = generator;
 			}
@@ -141,7 +141,7 @@ namespace DotNetOpenAuth.Messaging {
 				/// </summary>
 				/// <param name="parent">The parent cached enumerable whose GetEnumerator method is calling this constructor.</param>
 				internal EnumeratorCache(EnumerableCache<T> parent) {
-					Contract.Requires<ArgumentNullException>(parent != null);
+					Requires.NotNull(parent, "parent");
 
 					this.parent = parent;
 				}
diff --git a/src/DotNetOpenAuth.Messaging/Messaging/ErrorUtilities.cs b/src/DotNetOpenAuth.Messaging/Messaging/ErrorUtilities.cs
index c9e6e26..c6a652b 100644
--- a/src/DotNetOpenAuth.Messaging/Messaging/ErrorUtilities.cs
+++ b/src/DotNetOpenAuth.Messaging/Messaging/ErrorUtilities.cs
@@ -26,7 +26,7 @@ namespace DotNetOpenAuth.Messaging {
 		/// <returns>The newly constructed (unthrown) exception.</returns>
 		[Pure]
 		internal static Exception Wrap(Exception inner, string errorMessage, params object[] args) {
-			Contract.Requires<ArgumentNullException>(args != null);
+			Requires.NotNull(args, "args");
 			Contract.Assume(errorMessage != null);
 			return new ProtocolException(string.Format(CultureInfo.CurrentCulture, errorMessage, args), inner);
 		}
@@ -73,7 +73,7 @@ namespace DotNetOpenAuth.Messaging {
 		/// <exception cref="InternalErrorException">Thrown if <paramref name="condition"/> evaluates to <c>false</c>.</exception>
 		[Pure]
 		internal static void VerifyInternal(bool condition, string errorMessage, params object[] args) {
-			Contract.Requires<ArgumentNullException>(args != null);
+			Requires.NotNull(args, "args");
 			Contract.Ensures(condition);
 			Contract.EnsuresOnThrow<InternalErrorException>(!condition);
 			Contract.Assume(errorMessage != null);
@@ -122,7 +122,7 @@ namespace DotNetOpenAuth.Messaging {
 		/// <exception cref="NotSupportedException">Thrown if <paramref name="condition"/> evaluates to <c>false</c>.</exception>
 		[Pure]
 		internal static void VerifySupported(bool condition, string errorMessage, params object[] args) {
-			Contract.Requires<ArgumentNullException>(args != null);
+			Requires.NotNull(args, "args");
 			Contract.Ensures(condition);
 			Contract.EnsuresOnThrow<NotSupportedException>(!condition);
 			Contract.Assume(errorMessage != null);
@@ -140,7 +140,7 @@ namespace DotNetOpenAuth.Messaging {
 		/// <exception cref="InvalidOperationException">Thrown if <paramref name="condition"/> evaluates to <c>false</c>.</exception>
 		[Pure]
 		internal static void VerifyOperation(bool condition, string errorMessage, params object[] args) {
-			Contract.Requires<ArgumentNullException>(args != null);
+			Requires.NotNull(args, "args");
 			Contract.Ensures(condition);
 			Contract.EnsuresOnThrow<InvalidOperationException>(!condition);
 			Contract.Assume(errorMessage != null);
@@ -159,7 +159,7 @@ namespace DotNetOpenAuth.Messaging {
 		/// <exception cref="HostErrorException">Thrown if <paramref name="condition"/> evaluates to <c>false</c>.</exception>
 		[Pure]
 		internal static void VerifyHost(bool condition, string errorMessage, params object[] args) {
-			Contract.Requires<ArgumentNullException>(args != null);
+			Requires.NotNull(args, "args");
 			Contract.Ensures(condition);
 			Contract.EnsuresOnThrow<ProtocolException>(!condition);
 			Contract.Assume(errorMessage != null);
@@ -178,8 +178,8 @@ namespace DotNetOpenAuth.Messaging {
 		/// <exception cref="ProtocolException">Thrown if <paramref name="condition"/> evaluates to <c>false</c>.</exception>
 		[Pure]
 		internal static void VerifyProtocol(bool condition, IProtocolMessage faultedMessage, string errorMessage, params object[] args) {
-			Contract.Requires<ArgumentNullException>(args != null);
-			Contract.Requires<ArgumentNullException>(faultedMessage != null);
+			Requires.NotNull(args, "args");
+			Requires.NotNull(faultedMessage, "faultedMessage");
 			Contract.Ensures(condition);
 			Contract.EnsuresOnThrow<ProtocolException>(!condition);
 			Contract.Assume(errorMessage != null);
@@ -197,7 +197,7 @@ namespace DotNetOpenAuth.Messaging {
 		/// <exception cref="ProtocolException">Thrown if <paramref name="condition"/> evaluates to <c>false</c>.</exception>
 		[Pure]
 		internal static void VerifyProtocol(bool condition, string message, params object[] args) {
-			Contract.Requires<ArgumentNullException>(args != null);
+			Requires.NotNull(args, "args");
 			Contract.Ensures(condition);
 			Contract.EnsuresOnThrow<ProtocolException>(!condition);
 			Contract.Assume(message != null);
@@ -229,7 +229,7 @@ namespace DotNetOpenAuth.Messaging {
 		/// <exception cref="ProtocolException">Always thrown.</exception>
 		[Pure]
 		internal static Exception ThrowProtocol(string message, params object[] args) {
-			Contract.Requires<ArgumentNullException>(args != null);
+			Requires.NotNull(args, "args");
 			Contract.Assume(message != null);
 			VerifyProtocol(false, message, args);
 
@@ -245,7 +245,7 @@ namespace DotNetOpenAuth.Messaging {
 		/// <returns>Nothing.  It's just here so the caller can throw this method for C# compilation check.</returns>
 		[Pure]
 		internal static Exception ThrowFormat(string message, params object[] args) {
-			Contract.Requires<ArgumentNullException>(args != null);
+			Requires.NotNull(args, "args");
 			Contract.Assume(message != null);
 			throw new FormatException(string.Format(CultureInfo.CurrentCulture, message, args));
 		}
@@ -259,7 +259,7 @@ namespace DotNetOpenAuth.Messaging {
 		/// <exception cref="FormatException">Thrown when <paramref name="condition"/> is <c>false</c>.</exception>
 		[Pure]
 		internal static void VerifyFormat(bool condition, string message, params object[] args) {
-			Contract.Requires<ArgumentNullException>(args != null);
+			Requires.NotNull(args, "args");
 			Contract.Ensures(condition);
 			Contract.EnsuresOnThrow<FormatException>(!condition);
 			Contract.Assume(message != null);
@@ -277,7 +277,7 @@ namespace DotNetOpenAuth.Messaging {
 		/// <exception cref="ArgumentException">Thrown if <paramref name="condition"/> evaluates to <c>false</c>.</exception>
 		[Pure]
 		internal static void VerifyArgument(bool condition, string message, params object[] args) {
-			Contract.Requires<ArgumentNullException>(args != null);
+			Requires.NotNull(args, "args");
 			Contract.Ensures(condition);
 			Contract.EnsuresOnThrow<ArgumentException>(!condition);
 			Contract.Assume(message != null);
@@ -295,7 +295,7 @@ namespace DotNetOpenAuth.Messaging {
 		/// <returns>Never returns anything.  It always throws.</returns>
 		[Pure]
 		internal static Exception ThrowArgumentNamed(string parameterName, string message, params object[] args) {
-			Contract.Requires<ArgumentNullException>(args != null);
+			Requires.NotNull(args, "args");
 			Contract.Assume(message != null);
 			throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, message, args), parameterName);
 		}
@@ -310,7 +310,7 @@ namespace DotNetOpenAuth.Messaging {
 		/// <exception cref="ArgumentException">Thrown if <paramref name="condition"/> evaluates to <c>false</c>.</exception>
 		[Pure]
 		internal static void VerifyArgumentNamed(bool condition, string parameterName, string message, params object[] args) {
-			Contract.Requires<ArgumentNullException>(args != null);
+			Requires.NotNull(args, "args");
 			Contract.Ensures(condition);
 			Contract.EnsuresOnThrow<ArgumentException>(!condition);
 			Contract.Assume(message != null);
diff --git a/src/DotNetOpenAuth.Messaging/Messaging/HttpRequestInfo.cs b/src/DotNetOpenAuth.Messaging/Messaging/HttpRequestInfo.cs
index 6ce87a8..0cf37a5 100644
--- a/src/DotNetOpenAuth.Messaging/Messaging/HttpRequestInfo.cs
+++ b/src/DotNetOpenAuth.Messaging/Messaging/HttpRequestInfo.cs
@@ -51,7 +51,7 @@ namespace DotNetOpenAuth.Messaging {
 		/// </summary>
 		/// <param name="request">The ASP.NET structure to copy from.</param>
 		public HttpRequestInfo(HttpRequest request) {
-			Contract.Requires<ArgumentNullException>(request != null);
+			Requires.NotNull(request, "request");
 			Contract.Ensures(this.HttpMethod == request.HttpMethod);
 			Contract.Ensures(this.Url == request.Url);
 			Contract.Ensures(this.RawUrl == request.RawUrl);
@@ -88,10 +88,10 @@ namespace DotNetOpenAuth.Messaging {
 		/// <param name="headers">Headers in the HTTP request.</param>
 		/// <param name="inputStream">The entity stream, if any.  (POST requests typically have these).  Use <c>null</c> for GET requests.</param>
 		public HttpRequestInfo(string httpMethod, Uri requestUrl, string rawUrl, WebHeaderCollection headers, Stream inputStream) {
-			Contract.Requires<ArgumentNullException>(!string.IsNullOrEmpty(httpMethod));
-			Contract.Requires<ArgumentNullException>(requestUrl != null);
-			Contract.Requires<ArgumentNullException>(rawUrl != null);
-			Contract.Requires<ArgumentNullException>(headers != null);
+			Requires.NotNullOrEmpty(httpMethod, "httpMethod");
+			Requires.NotNull(requestUrl, "requestUrl");
+			Requires.NotNull(rawUrl, "rawUrl");
+			Requires.NotNull(headers, "headers");
 
 			this.HttpMethod = httpMethod;
 			this.Url = requestUrl;
@@ -108,7 +108,7 @@ namespace DotNetOpenAuth.Messaging {
 		/// </summary>
 		/// <param name="listenerRequest">Details on the incoming HTTP request.</param>
 		public HttpRequestInfo(HttpListenerRequest listenerRequest) {
-			Contract.Requires<ArgumentNullException>(listenerRequest != null);
+			Requires.NotNull(listenerRequest, "listenerRequest");
 
 			this.HttpMethod = listenerRequest.HttpMethod;
 			this.Url = listenerRequest.Url;
@@ -130,8 +130,8 @@ namespace DotNetOpenAuth.Messaging {
 		/// <param name="request">The WCF incoming request structure to get the HTTP information from.</param>
 		/// <param name="requestUri">The URI of the service endpoint.</param>
 		public HttpRequestInfo(HttpRequestMessageProperty request, Uri requestUri) {
-			Contract.Requires<ArgumentNullException>(request != null);
-			Contract.Requires<ArgumentNullException>(requestUri != null);
+			Requires.NotNull(request, "request");
+			Requires.NotNull(requestUri, "requestUri");
 
 			this.HttpMethod = request.Method;
 			this.Headers = request.Headers;
@@ -158,7 +158,7 @@ namespace DotNetOpenAuth.Messaging {
 		/// </summary>
 		/// <param name="request">The HttpWebRequest (that was never used) to copy from.</param>
 		internal HttpRequestInfo(WebRequest request) {
-			Contract.Requires<ArgumentNullException>(request != null);
+			Requires.NotNull(request, "request");
 
 			this.HttpMethod = request.Method;
 			this.Url = request.RequestUri;
@@ -317,8 +317,8 @@ namespace DotNetOpenAuth.Messaging {
 		/// is a read-only kind of <see cref="NameValueCollection"/>.
 		/// </remarks>
 		internal static Uri GetPublicFacingUrl(HttpRequest request, NameValueCollection serverVariables) {
-			Contract.Requires<ArgumentNullException>(request != null);
-			Contract.Requires<ArgumentNullException>(serverVariables != null);
+			Requires.NotNull(request, "request");
+			Requires.NotNull(serverVariables, "serverVariables");
 
 			// Due to URL rewriting, cloud computing (i.e. Azure)
 			// and web farms, etc., we have to be VERY careful about what
@@ -370,7 +370,7 @@ namespace DotNetOpenAuth.Messaging {
 		/// <param name="request">The request.</param>
 		/// <returns>The URI that the outside world used to create this request.</returns>
 		private static Uri GetPublicFacingUrl(HttpRequest request) {
-			Contract.Requires<ArgumentNullException>(request != null);
+			Requires.NotNull(request, "request");
 			return GetPublicFacingUrl(request, request.ServerVariables);
 		}
 
@@ -380,7 +380,7 @@ namespace DotNetOpenAuth.Messaging {
 		/// <param name="url">A full URL.</param>
 		/// <returns>A raw URL that might have come in on the HTTP verb.</returns>
 		private static string MakeUpRawUrlFromUrl(Uri url) {
-			Contract.Requires<ArgumentNullException>(url != null);
+			Requires.NotNull(url, "url");
 			return url.AbsolutePath + url.Query + url.Fragment;
 		}
 
@@ -390,7 +390,7 @@ namespace DotNetOpenAuth.Messaging {
 		/// <param name="pairs">The collection a HTTP headers.</param>
 		/// <returns>A new collection of the given headers.</returns>
 		private static WebHeaderCollection GetHeaderCollection(NameValueCollection pairs) {
-			Contract.Requires<ArgumentNullException>(pairs != null);
+			Requires.NotNull(pairs, "pairs");
 
 			WebHeaderCollection headers = new WebHeaderCollection();
 			foreach (string key in pairs) {
diff --git a/src/DotNetOpenAuth.Messaging/Messaging/IChannelBindingElement.cs b/src/DotNetOpenAuth.Messaging/Messaging/IChannelBindingElement.cs
index f502f17..9dac9b3 100644
--- a/src/DotNetOpenAuth.Messaging/Messaging/IChannelBindingElement.cs
+++ b/src/DotNetOpenAuth.Messaging/Messaging/IChannelBindingElement.cs
@@ -113,8 +113,8 @@ namespace DotNetOpenAuth.Messaging {
 		/// <see cref="MessagePartAttribute.RequiredProtection"/> properties where applicable.
 		/// </remarks>
 		MessageProtections? IChannelBindingElement.ProcessOutgoingMessage(IProtocolMessage message) {
-			Contract.Requires<ArgumentNullException>(message != null);
-			Contract.Requires<InvalidOperationException>(((IChannelBindingElement)this).Channel != null);
+			Requires.NotNull(message, "message");
+			Requires.ValidState(((IChannelBindingElement)this).Channel != null);
 			throw new NotImplementedException();
 		}
 
@@ -136,8 +136,8 @@ namespace DotNetOpenAuth.Messaging {
 		/// <see cref="MessagePartAttribute.RequiredProtection"/> properties where applicable.
 		/// </remarks>
 		MessageProtections? IChannelBindingElement.ProcessIncomingMessage(IProtocolMessage message) {
-			Contract.Requires<ArgumentNullException>(message != null);
-			Contract.Requires<InvalidOperationException>(((IChannelBindingElement)this).Channel != null);
+			Requires.NotNull(message, "message");
+			Requires.ValidState(((IChannelBindingElement)this).Channel != null);
 			throw new NotImplementedException();
 		}
 
diff --git a/src/DotNetOpenAuth.Messaging/Messaging/IDataBagFormatter.cs b/src/DotNetOpenAuth.Messaging/Messaging/IDataBagFormatter.cs
index c7dcc42..fd1c15d 100644
--- a/src/DotNetOpenAuth.Messaging/Messaging/IDataBagFormatter.cs
+++ b/src/DotNetOpenAuth.Messaging/Messaging/IDataBagFormatter.cs
@@ -50,7 +50,7 @@ namespace DotNetOpenAuth.Messaging {
 		/// <param name="message">The message to serialize.  Must not be null.</param>
 		/// <returns>A non-null, non-empty value.</returns>
 		string IDataBagFormatter<T>.Serialize(T message) {
-			Contract.Requires<ArgumentNullException>(message != null);
+			Requires.NotNull(message, "message");
 			Contract.Ensures(!String.IsNullOrEmpty(Contract.Result<string>()));
 
 			throw new System.NotImplementedException();
@@ -63,8 +63,8 @@ namespace DotNetOpenAuth.Messaging {
 		/// <param name="data">The serialized form of the <see cref="DataBag"/> to deserialize.  Must not be null or empty.</param>
 		/// <returns>The deserialized value.  Never null.</returns>
 		T IDataBagFormatter<T>.Deserialize(IProtocolMessage containingMessage, string data) {
-			Contract.Requires<ArgumentNullException>(containingMessage != null);
-			Contract.Requires<ArgumentException>(!String.IsNullOrEmpty(data));
+			Requires.NotNull(containingMessage, "containingMessage");
+			Requires.NotNullOrEmpty(data, "data");
 			Contract.Ensures(Contract.Result<T>() != null);
 
 			throw new System.NotImplementedException();
diff --git a/src/DotNetOpenAuth.Messaging/Messaging/IDirectWebRequestHandler.cs b/src/DotNetOpenAuth.Messaging/Messaging/IDirectWebRequestHandler.cs
index d47da4a..add35f9 100644
--- a/src/DotNetOpenAuth.Messaging/Messaging/IDirectWebRequestHandler.cs
+++ b/src/DotNetOpenAuth.Messaging/Messaging/IDirectWebRequestHandler.cs
@@ -140,7 +140,7 @@ namespace DotNetOpenAuth.Messaging {
 		/// a single exception type for hosts to catch.</para>
 		/// </remarks>
 		Stream IDirectWebRequestHandler.GetRequestStream(HttpWebRequest request) {
-			Contract.Requires<ArgumentNullException>(request != null);
+			Requires.NotNull(request, "request");
 			throw new System.NotImplementedException();
 		}
 
@@ -164,8 +164,8 @@ namespace DotNetOpenAuth.Messaging {
 		/// a single exception type for hosts to catch.</para>
 		/// </remarks>
 		Stream IDirectWebRequestHandler.GetRequestStream(HttpWebRequest request, DirectWebRequestOptions options) {
-			Contract.Requires<ArgumentNullException>(request != null);
-			Contract.Requires<NotSupportedException>(((IDirectWebRequestHandler)this).CanSupport(options), MessagingStrings.DirectWebRequestOptionsNotSupported);
+			Requires.NotNull(request, "request");
+			Requires.Support(((IDirectWebRequestHandler)this).CanSupport(options), MessagingStrings.DirectWebRequestOptionsNotSupported);
 			////ErrorUtilities.VerifySupported(((IDirectWebRequestHandler)this).CanSupport(options), string.Format(MessagingStrings.DirectWebRequestOptionsNotSupported, options, this.GetType().Name));
 			throw new System.NotImplementedException();
 		}
@@ -186,7 +186,7 @@ namespace DotNetOpenAuth.Messaging {
 		/// value, if set, should be Closed before throwing.
 		/// </remarks>
 		IncomingWebResponse IDirectWebRequestHandler.GetResponse(HttpWebRequest request) {
-			Contract.Requires<ArgumentNullException>(request != null);
+			Requires.NotNull(request, "request");
 			Contract.Ensures(Contract.Result<IncomingWebResponse>() != null);
 			Contract.Ensures(Contract.Result<IncomingWebResponse>().ResponseStream != null);
 			throw new System.NotImplementedException();
@@ -209,10 +209,10 @@ namespace DotNetOpenAuth.Messaging {
 		/// value, if set, should be Closed before throwing.
 		/// </remarks>
 		IncomingWebResponse IDirectWebRequestHandler.GetResponse(HttpWebRequest request, DirectWebRequestOptions options) {
-			Contract.Requires<ArgumentNullException>(request != null);
-			Contract.Requires<NotSupportedException>(((IDirectWebRequestHandler)this).CanSupport(options), MessagingStrings.DirectWebRequestOptionsNotSupported);
+			Requires.NotNull(request, "request");
 			Contract.Ensures(Contract.Result<IncomingWebResponse>() != null);
 			Contract.Ensures(Contract.Result<IncomingWebResponse>().ResponseStream != null);
+			Requires.Support(((IDirectWebRequestHandler)this).CanSupport(options), MessagingStrings.DirectWebRequestOptionsNotSupported);
 
 			////ErrorUtilities.VerifySupported(((IDirectWebRequestHandler)this).CanSupport(options), string.Format(MessagingStrings.DirectWebRequestOptionsNotSupported, options, this.GetType().Name));
 			throw new System.NotImplementedException();
diff --git a/src/DotNetOpenAuth.Messaging/Messaging/IMessageFactory.cs b/src/DotNetOpenAuth.Messaging/Messaging/IMessageFactory.cs
index f9ddf3d..b44bbbf 100644
--- a/src/DotNetOpenAuth.Messaging/Messaging/IMessageFactory.cs
+++ b/src/DotNetOpenAuth.Messaging/Messaging/IMessageFactory.cs
@@ -66,8 +66,8 @@ namespace DotNetOpenAuth.Messaging {
 		/// deserialize to.  Null if the request isn't recognized as a valid protocol message.
 		/// </returns>
 		IDirectedProtocolMessage IMessageFactory.GetNewRequestMessage(MessageReceivingEndpoint recipient, IDictionary<string, string> fields) {
-			Contract.Requires<ArgumentNullException>(recipient != null);
-			Contract.Requires<ArgumentNullException>(fields != null);
+			Requires.NotNull(recipient, "recipient");
+			Requires.NotNull(fields, "fields");
 
 			throw new NotImplementedException();
 		}
@@ -83,8 +83,8 @@ namespace DotNetOpenAuth.Messaging {
 		/// deserialize to.  Null if the request isn't recognized as a valid protocol message.
 		/// </returns>
 		IDirectResponseProtocolMessage IMessageFactory.GetNewResponseMessage(IDirectedProtocolMessage request, IDictionary<string, string> fields) {
-			Contract.Requires<ArgumentNullException>(request != null);
-			Contract.Requires<ArgumentNullException>(fields != null);
+			Requires.NotNull(request, "request");
+			Requires.NotNull(fields, "fields");
 			throw new NotImplementedException();
 		}
 
diff --git a/src/DotNetOpenAuth.Messaging/Messaging/IncomingWebResponse.cs b/src/DotNetOpenAuth.Messaging/Messaging/IncomingWebResponse.cs
index 70b1032..90d2f1f 100644
--- a/src/DotNetOpenAuth.Messaging/Messaging/IncomingWebResponse.cs
+++ b/src/DotNetOpenAuth.Messaging/Messaging/IncomingWebResponse.cs
@@ -39,8 +39,8 @@ namespace DotNetOpenAuth.Messaging {
 		/// <param name="requestUri">The original request URI.</param>
 		/// <param name="response">The response to initialize from.  The network stream is used by this class directly.</param>
 		protected IncomingWebResponse(Uri requestUri, HttpWebResponse response) {
-			Contract.Requires<ArgumentNullException>(requestUri != null);
-			Contract.Requires<ArgumentNullException>(response != null);
+			Requires.NotNull(requestUri, "requestUri");
+			Requires.NotNull(response, "response");
 
 			this.RequestUri = requestUri;
 			if (!string.IsNullOrEmpty(response.ContentType)) {
@@ -66,7 +66,7 @@ namespace DotNetOpenAuth.Messaging {
 		/// <param name="contentType">Type of the content.</param>
 		/// <param name="contentEncoding">The content encoding.</param>
 		protected IncomingWebResponse(Uri requestUri, Uri responseUri, WebHeaderCollection headers, HttpStatusCode statusCode, string contentType, string contentEncoding) {
-			Contract.Requires<ArgumentNullException>(requestUri != null);
+			Requires.NotNull(requestUri, "requestUri");
 
 			this.RequestUri = requestUri;
 			this.Status = statusCode;
diff --git a/src/DotNetOpenAuth.Messaging/Messaging/IncomingWebResponseContract.cs b/src/DotNetOpenAuth.Messaging/Messaging/IncomingWebResponseContract.cs
index e9c1941..8c9a6df 100644
--- a/src/DotNetOpenAuth.Messaging/Messaging/IncomingWebResponseContract.cs
+++ b/src/DotNetOpenAuth.Messaging/Messaging/IncomingWebResponseContract.cs
@@ -45,8 +45,8 @@ namespace DotNetOpenAuth.Messaging {
 		/// be the self same instance.
 		/// </remarks>
 		internal override CachedDirectWebResponse GetSnapshot(int maximumBytesToCache) {
-			Contract.Requires<ArgumentOutOfRangeException>(maximumBytesToCache >= 0);
-			Contract.Requires<InvalidOperationException>(this.RequestUri != null);
+			Requires.InRange(maximumBytesToCache >= 0, "maximumBytesToCache");
+			Requires.ValidState(this.RequestUri != null);
 			Contract.Ensures(Contract.Result<CachedDirectWebResponse>() != null);
 			throw new NotImplementedException();
 		}
diff --git a/src/DotNetOpenAuth.Messaging/Messaging/KeyedCollectionDelegate.cs b/src/DotNetOpenAuth.Messaging/Messaging/KeyedCollectionDelegate.cs
index 5555f9c..c0a08df 100644
--- a/src/DotNetOpenAuth.Messaging/Messaging/KeyedCollectionDelegate.cs
+++ b/src/DotNetOpenAuth.Messaging/Messaging/KeyedCollectionDelegate.cs
@@ -27,7 +27,7 @@ namespace DotNetOpenAuth.Messaging {
 		/// </summary>
 		/// <param name="getKeyForItemDelegate">The delegate that gets the key for a given item.</param>
 		internal KeyedCollectionDelegate(Func<TItem, TKey> getKeyForItemDelegate) {
-			Contract.Requires<ArgumentNullException>(getKeyForItemDelegate != null);
+			Requires.NotNull(getKeyForItemDelegate, "getKeyForItemDelegate");
 
 			this.getKeyForItemDelegate = getKeyForItemDelegate;
 		}
diff --git a/src/DotNetOpenAuth.Messaging/Messaging/MessageReceivingEndpoint.cs b/src/DotNetOpenAuth.Messaging/Messaging/MessageReceivingEndpoint.cs
index e39a047..ca7c5df 100644
--- a/src/DotNetOpenAuth.Messaging/Messaging/MessageReceivingEndpoint.cs
+++ b/src/DotNetOpenAuth.Messaging/Messaging/MessageReceivingEndpoint.cs
@@ -22,9 +22,9 @@ namespace DotNetOpenAuth.Messaging {
 		/// <param name="method">The HTTP method(s) allowed.</param>
 		public MessageReceivingEndpoint(string locationUri, HttpDeliveryMethods method)
 			: this(new Uri(locationUri), method) {
-			Contract.Requires<ArgumentNullException>(locationUri != null);
-			Contract.Requires<ArgumentOutOfRangeException>(method != HttpDeliveryMethods.None);
-			Contract.Requires<ArgumentOutOfRangeException>((method & HttpDeliveryMethods.HttpVerbMask) != 0, MessagingStrings.GetOrPostFlagsRequired);
+			Requires.NotNull(locationUri, "locationUri");
+			Requires.InRange(method != HttpDeliveryMethods.None, "method");
+			Requires.InRange((method & HttpDeliveryMethods.HttpVerbMask) != 0, "method", MessagingStrings.GetOrPostFlagsRequired);
 		}
 
 		/// <summary>
@@ -33,9 +33,9 @@ namespace DotNetOpenAuth.Messaging {
 		/// <param name="location">The URL of this endpoint.</param>
 		/// <param name="method">The HTTP method(s) allowed.</param>
 		public MessageReceivingEndpoint(Uri location, HttpDeliveryMethods method) {
-			Contract.Requires<ArgumentNullException>(location != null);
-			Contract.Requires<ArgumentOutOfRangeException>(method != HttpDeliveryMethods.None);
-			Contract.Requires<ArgumentOutOfRangeException>((method & HttpDeliveryMethods.HttpVerbMask) != 0, MessagingStrings.GetOrPostFlagsRequired);
+			Requires.NotNull(location, "location");
+			Requires.InRange(method != HttpDeliveryMethods.None, "method");
+			Requires.InRange((method & HttpDeliveryMethods.HttpVerbMask) != 0, "method", MessagingStrings.GetOrPostFlagsRequired);
 
 			this.Location = location;
 			this.AllowedMethods = method;
diff --git a/src/DotNetOpenAuth.Messaging/Messaging/MessageSerializer.cs b/src/DotNetOpenAuth.Messaging/Messaging/MessageSerializer.cs
index 7b0cfab..957ea41 100644
--- a/src/DotNetOpenAuth.Messaging/Messaging/MessageSerializer.cs
+++ b/src/DotNetOpenAuth.Messaging/Messaging/MessageSerializer.cs
@@ -33,8 +33,7 @@ namespace DotNetOpenAuth.Messaging {
 		/// that will be serialized and deserialized using this class.</param>
 		[ContractVerification(false)] // bugs/limitations in CC static analysis
 		private MessageSerializer(Type messageType) {
-			Contract.Requires<ArgumentNullException>(messageType != null);
-			Contract.Requires<ArgumentException>(typeof(IMessage).IsAssignableFrom(messageType));
+			Requires.NotNullSubtype<IMessage>(messageType, "messageType");
 			Contract.Ensures(this.messageType != null);
 			this.messageType = messageType;
 		}
@@ -46,8 +45,7 @@ namespace DotNetOpenAuth.Messaging {
 		/// <returns>A message serializer for the given message type.</returns>
 		[ContractVerification(false)] // bugs/limitations in CC static analysis
 		internal static MessageSerializer Get(Type messageType) {
-			Contract.Requires<ArgumentNullException>(messageType != null);
-			Contract.Requires<ArgumentException>(typeof(IMessage).IsAssignableFrom(messageType));
+			Requires.NotNullSubtype<IMessage>(messageType, "messageType");
 
 			return new MessageSerializer(messageType);
 		}
@@ -58,8 +56,8 @@ namespace DotNetOpenAuth.Messaging {
 		/// <param name="messageDictionary">The message dictionary to fill with the JSON-deserialized data.</param>
 		/// <param name="reader">The JSON reader.</param>
 		internal static void DeserializeJsonAsFlatDictionary(IDictionary<string, string> messageDictionary, XmlDictionaryReader reader) {
-			Contract.Requires<ArgumentNullException>(messageDictionary != null);
-			Contract.Requires<ArgumentNullException>(reader != null);
+			Requires.NotNull(messageDictionary, "messageDictionary");
+			Requires.NotNull(reader, "reader");
 
 			reader.Read(); // one extra one to skip the root node.
 			while (reader.Read()) {
@@ -86,8 +84,8 @@ namespace DotNetOpenAuth.Messaging {
 		/// </remarks>
 		[Pure]
 		internal static void Serialize(MessageDictionary messageDictionary, XmlDictionaryWriter writer) {
-			Contract.Requires<ArgumentNullException>(messageDictionary != null);
-			Contract.Requires<ArgumentNullException>(writer != null);
+			Requires.NotNull(messageDictionary, "messageDictionary");
+			Requires.NotNull(writer, "writer");
 
 			writer.WriteStartElement("root");
 			writer.WriteAttributeString("type", "object");
@@ -132,8 +130,8 @@ namespace DotNetOpenAuth.Messaging {
 		/// to create the <see cref="XmlDictionaryReader"/> instance capable of reading JSON.
 		/// </remarks>
 		internal static void Deserialize(MessageDictionary messageDictionary, XmlDictionaryReader reader) {
-			Contract.Requires<ArgumentNullException>(messageDictionary != null);
-			Contract.Requires<ArgumentNullException>(reader != null);
+			Requires.NotNull(messageDictionary, "messageDictionary");
+			Requires.NotNull(reader, "reader");
 
 			DeserializeJsonAsFlatDictionary(messageDictionary, reader);
 
@@ -150,7 +148,7 @@ namespace DotNetOpenAuth.Messaging {
 		[Pure]
 		[SuppressMessage("Microsoft.Performance", "CA1822:MarkMembersAsStatic", Justification = "Parallel design with Deserialize method.")]
 		internal IDictionary<string, string> Serialize(MessageDictionary messageDictionary) {
-			Contract.Requires<ArgumentNullException>(messageDictionary != null);
+			Requires.NotNull(messageDictionary, "messageDictionary");
 			Contract.Ensures(Contract.Result<IDictionary<string, string>>() != null);
 
 			// Rather than hand back the whole message dictionary (which 
@@ -181,8 +179,8 @@ namespace DotNetOpenAuth.Messaging {
 		/// <param name="messageDictionary">The message to deserialize into.</param>
 		/// <exception cref="ProtocolException">Thrown when protocol rules are broken by the incoming message.</exception>
 		internal void Deserialize(IDictionary<string, string> fields, MessageDictionary messageDictionary) {
-			Contract.Requires<ArgumentNullException>(fields != null);
-			Contract.Requires<ArgumentNullException>(messageDictionary != null);
+			Requires.NotNull(fields, "fields");
+			Requires.NotNull(messageDictionary, "messageDictionary");
 
 			var messageDescription = messageDictionary.Description;
 
diff --git a/src/DotNetOpenAuth.Messaging/Messaging/MessagingUtilities.cs b/src/DotNetOpenAuth.Messaging/Messaging/MessagingUtilities.cs
index e88f2a9..9277734 100644
--- a/src/DotNetOpenAuth.Messaging/Messaging/MessagingUtilities.cs
+++ b/src/DotNetOpenAuth.Messaging/Messaging/MessagingUtilities.cs
@@ -140,7 +140,7 @@ namespace DotNetOpenAuth.Messaging {
 		/// <param name="response">The response to send to the user agent.</param>
 		/// <returns>The <see cref="ActionResult"/> instance to be returned by the Controller's action method.</returns>
 		public static ActionResult AsActionResult(this OutgoingWebResponse response) {
-			Contract.Requires<ArgumentNullException>(response != null);
+			Requires.NotNull(response, "response");
 			return new OutgoingWebResponseActionResult(response);
 		}
 
@@ -152,7 +152,7 @@ namespace DotNetOpenAuth.Messaging {
 		[SuppressMessage("Microsoft.Usage", "CA2234:PassSystemUriObjectsInsteadOfStrings", Justification = "The Uri merging requires use of a string value.")]
 		[SuppressMessage("Microsoft.Design", "CA1024:UsePropertiesWhereAppropriate", Justification = "Expensive call should not be a property.")]
 		public static Uri GetRequestUrlFromContext() {
-			Contract.Requires<InvalidOperationException>(HttpContext.Current != null && HttpContext.Current.Request != null, MessagingStrings.HttpContextRequired);
+			Requires.ValidState(HttpContext.Current != null && HttpContext.Current.Request != null, MessagingStrings.HttpContextRequired);
 			HttpContext context = HttpContext.Current;
 
 			return HttpRequestInfo.GetPublicFacingUrl(context.Request, context.Request.ServerVariables);
@@ -165,8 +165,8 @@ namespace DotNetOpenAuth.Messaging {
 		/// <param name="prefix">The prefix for parameters to remove.  A period is NOT automatically appended.</param>
 		/// <returns>Either a new Uri with the parameters removed if there were any to remove, or the same Uri instance if no parameters needed to be removed.</returns>
 		public static Uri StripQueryArgumentsWithPrefix(this Uri uri, string prefix) {
-			Contract.Requires<ArgumentNullException>(uri != null);
-			Contract.Requires<ArgumentException>(!String.IsNullOrEmpty(prefix));
+			Requires.NotNull(uri, "uri");
+			Requires.NotNullOrEmpty(prefix, "prefix");
 
 			NameValueCollection queryArgs = HttpUtility.ParseQueryString(uri.Query);
 			var matchingKeys = queryArgs.Keys.OfType<string>().Where(key => key.StartsWith(prefix, StringComparison.OrdinalIgnoreCase)).ToList();
@@ -190,9 +190,9 @@ namespace DotNetOpenAuth.Messaging {
 		/// <param name="parts">The parts to include in the POST entity.</param>
 		/// <returns>The HTTP response.</returns>
 		public static IncomingWebResponse PostMultipart(this HttpWebRequest request, IDirectWebRequestHandler requestHandler, IEnumerable<MultipartPostPart> parts) {
-			Contract.Requires<ArgumentNullException>(request != null);
-			Contract.Requires<ArgumentNullException>(requestHandler != null);
-			Contract.Requires<ArgumentNullException>(parts != null);
+			Requires.NotNull(request, "request");
+			Requires.NotNull(requestHandler, "requestHandler");
+			Requires.NotNull(parts, "parts");
 
 			PostMultipartNoGetResponse(request, requestHandler, parts);
 			return requestHandler.GetResponse(request);
@@ -272,8 +272,8 @@ namespace DotNetOpenAuth.Messaging {
 		/// <param name="collection">The collection to add to.</param>
 		/// <param name="values">The values to add to the collection.</param>
 		public static void AddRange<T>(this ICollection<T> collection, IEnumerable<T> values) {
-			Contract.Requires<ArgumentNullException>(collection != null);
-			Contract.Requires<ArgumentNullException>(values != null);
+			Requires.NotNull(collection, "collection");
+			Requires.NotNull(values, "values");
 
 			foreach (var value in values) {
 				collection.Add(value);
@@ -298,7 +298,7 @@ namespace DotNetOpenAuth.Messaging {
 		/// <param name="collection">The collection to modify.</param>
 		/// <param name="values">The new values to fill the collection.</param>
 		internal static void ResetContents<T>(this ICollection<T> collection, IEnumerable<T> values) {
-			Contract.Requires<ArgumentNullException>(collection != null);
+			Requires.NotNull(collection, "collection");
 
 			collection.Clear();
 			if (values != null) {
@@ -313,8 +313,8 @@ namespace DotNetOpenAuth.Messaging {
 		/// <param name="messageDescription">The message description whose parts should be removed from the URL.</param>
 		/// <returns>A cleaned URL.</returns>
 		internal static Uri StripMessagePartsFromQueryString(this Uri uri, MessageDescription messageDescription) {
-			Contract.Requires<ArgumentNullException>(uri != null);
-			Contract.Requires<ArgumentNullException>(messageDescription != null);
+			Requires.NotNull(uri, "uri");
+			Requires.NotNull(messageDescription, "messageDescription");
 
 			NameValueCollection queryArgs = HttpUtility.ParseQueryString(uri.Query);
 			var matchingKeys = queryArgs.Keys.OfType<string>().Where(key => messageDescription.Mapping.ContainsKey(key)).ToList();
@@ -337,9 +337,9 @@ namespace DotNetOpenAuth.Messaging {
 		/// <param name="requestHandler">The request handler.</param>
 		/// <param name="parts">The parts to include in the POST entity.</param>
 		internal static void PostMultipartNoGetResponse(this HttpWebRequest request, IDirectWebRequestHandler requestHandler, IEnumerable<MultipartPostPart> parts) {
-			Contract.Requires<ArgumentNullException>(request != null);
-			Contract.Requires<ArgumentNullException>(requestHandler != null);
-			Contract.Requires<ArgumentNullException>(parts != null);
+			Requires.NotNull(request, "request");
+			Requires.NotNull(requestHandler, "requestHandler");
+			Requires.NotNull(parts, "parts");
 
 			Reporting.RecordFeatureUse("MessagingUtilities.PostMultipart");
 			parts = parts.CacheGeneratedResults();
@@ -390,8 +390,8 @@ namespace DotNetOpenAuth.Messaging {
 		/// <param name="fields">The fields to include.</param>
 		/// <returns>A value prepared for an HTTP header.</returns>
 		internal static string AssembleAuthorizationHeader(string scheme, IEnumerable<KeyValuePair<string, string>> fields) {
-			Contract.Requires<ArgumentException>(!String.IsNullOrEmpty(scheme));
-			Contract.Requires<ArgumentNullException>(fields != null);
+			Requires.NotNullOrEmpty(scheme, "scheme");
+			Requires.NotNull(fields, "fields");
 
 			var authorization = new StringBuilder();
 			authorization.Append(scheme);
@@ -415,7 +415,7 @@ namespace DotNetOpenAuth.Messaging {
 		/// <param name="authorizationHeader">The authorization header.  May be null or empty.</param>
 		/// <returns>A sequence of key=value pairs discovered in the header.  Never null, but may be empty.</returns>
 		internal static IEnumerable<KeyValuePair<string, string>> ParseAuthorizationHeader(string scheme, string authorizationHeader) {
-			Contract.Requires<ArgumentException>(!String.IsNullOrEmpty(scheme));
+			Requires.NotNullOrEmpty(scheme, "scheme");
 			Contract.Ensures(Contract.Result<IEnumerable<KeyValuePair<string, string>>>() != null);
 
 			string prefix = scheme + " ";
@@ -446,8 +446,8 @@ namespace DotNetOpenAuth.Messaging {
 		/// <param name="payload">The encrypted/signed blob.</param>
 		/// <returns>The combined encoded value.</returns>
 		internal static string CombineKeyHandleAndPayload(string handle, string payload) {
-			Contract.Requires<ArgumentException>(!String.IsNullOrEmpty(handle));
-			Contract.Requires<ArgumentException>(!String.IsNullOrEmpty(payload));
+			Requires.NotNullOrEmpty(handle, "handle");
+			Requires.NotNullOrEmpty(payload, "payload");
 			Contract.Ensures(!String.IsNullOrEmpty(Contract.Result<string>()));
 
 			return handle + "!" + payload;
@@ -462,9 +462,9 @@ namespace DotNetOpenAuth.Messaging {
 		/// <param name="handle">The crypto key handle.</param>
 		/// <param name="dataBlob">The encrypted/signed data.</param>
 		internal static void ExtractKeyHandleAndPayload(IProtocolMessage containingMessage, string messagePart, string keyHandleAndBlob, out string handle, out string dataBlob) {
-			Contract.Requires<ArgumentNullException>(containingMessage != null);
-			Contract.Requires<ArgumentException>(!String.IsNullOrEmpty(messagePart));
-			Contract.Requires<ArgumentException>(!String.IsNullOrEmpty(keyHandleAndBlob));
+			Requires.NotNull(containingMessage, "containingMessage");
+			Requires.NotNullOrEmpty(messagePart, "messagePart");
+			Requires.NotNullOrEmpty(keyHandleAndBlob, "keyHandleAndBlob");
 
 			int privateHandleIndex = keyHandleAndBlob.IndexOf('!');
 			ErrorUtilities.VerifyProtocol(privateHandleIndex > 0, MessagingStrings.UnexpectedMessagePartValue, messagePart, keyHandleAndBlob);
@@ -513,8 +513,8 @@ namespace DotNetOpenAuth.Messaging {
 		/// <param name="allowableCharacters">The allowable characters.</param>
 		/// <returns>A random string.</returns>
 		internal static string GetRandomString(int length, string allowableCharacters) {
-			Contract.Requires<ArgumentOutOfRangeException>(length >= 0);
-			Contract.Requires<ArgumentException>(allowableCharacters != null && allowableCharacters.Length >= 2);
+			Requires.InRange(length >= 0, "length");
+			Requires.True(allowableCharacters != null && allowableCharacters.Length >= 2, "allowableCharacters");
 
 			char[] randomString = new char[length];
 			for (int i = 0; i < length; i++) {
@@ -532,8 +532,8 @@ namespace DotNetOpenAuth.Messaging {
 		/// <param name="encoding">The encoding to use when converting the string to a byte array.</param>
 		/// <returns>A base64 encoded string.</returns>
 		internal static string ComputeHash(this HashAlgorithm algorithm, string value, Encoding encoding = null) {
-			Contract.Requires<ArgumentNullException>(algorithm != null);
-			Contract.Requires<ArgumentNullException>(value != null);
+			Requires.NotNull(algorithm, "algorithm");
+			Requires.NotNull(value, "value");
 			Contract.Ensures(Contract.Result<string>() != null);
 
 			encoding = encoding ?? Encoding.UTF8;
@@ -551,8 +551,8 @@ namespace DotNetOpenAuth.Messaging {
 		/// <param name="encoding">The encoding to use when converting the string to a byte array.</param>
 		/// <returns>A base64 encoded string.</returns>
 		internal static string ComputeHash(this HashAlgorithm algorithm, IDictionary<string, string> data, Encoding encoding = null) {
-			Contract.Requires<ArgumentNullException>(algorithm != null);
-			Contract.Requires<ArgumentNullException>(data != null);
+			Requires.NotNull(algorithm, "algorithm");
+			Requires.NotNull(data, "data");
 			Contract.Ensures(Contract.Result<string>() != null);
 
 			// Assemble the dictionary to sign, taking care to remove the signature itself
@@ -572,8 +572,8 @@ namespace DotNetOpenAuth.Messaging {
 		/// <param name="encoding">The encoding to use when converting the string to a byte array.</param>
 		/// <returns>A base64 encoded string.</returns>
 		internal static string ComputeHash(this HashAlgorithm algorithm, IEnumerable<KeyValuePair<string, string>> sortedData, Encoding encoding = null) {
-			Contract.Requires<ArgumentNullException>(algorithm != null);
-			Contract.Requires<ArgumentNullException>(sortedData != null);
+			Requires.NotNull(algorithm, "algorithm");
+			Requires.NotNull(sortedData, "sortedData");
 			Contract.Ensures(Contract.Result<string>() != null);
 
 			return ComputeHash(algorithm, CreateQueryString(sortedData), encoding);
@@ -665,8 +665,8 @@ namespace DotNetOpenAuth.Messaging {
 		/// <param name="buffer">The buffer to encrypt.</param>
 		/// <returns>The encrypted data.</returns>
 		internal static byte[] EncryptWithRandomSymmetricKey(this RSACryptoServiceProvider crypto, byte[] buffer) {
-			Contract.Requires<ArgumentNullException>(crypto != null);
-			Contract.Requires<ArgumentNullException>(buffer != null);
+			Requires.NotNull(crypto, "crypto");
+			Requires.NotNull(buffer, "buffer");
 
 			using (var symmetricCrypto = new RijndaelManaged()) {
 				symmetricCrypto.Mode = CipherMode.CBC;
@@ -700,8 +700,8 @@ namespace DotNetOpenAuth.Messaging {
 		/// <returns>The decrypted data.</returns>
 		[SuppressMessage("Microsoft.Usage", "CA2202:Do not dispose objects multiple times", Justification = "This Dispose is safe.")]
 		internal static byte[] DecryptWithRandomSymmetricKey(this RSACryptoServiceProvider crypto, byte[] buffer) {
-			Contract.Requires<ArgumentNullException>(crypto != null);
-			Contract.Requires<ArgumentNullException>(buffer != null);
+			Requires.NotNull(crypto, "crypto");
+			Requires.NotNull(buffer, "buffer");
 
 			using (var encryptedStream = new MemoryStream(buffer)) {
 				var encryptedStreamReader = new BinaryReader(encryptedStream);
@@ -747,9 +747,9 @@ namespace DotNetOpenAuth.Messaging {
 		/// A key-value pair whose key is the secret's handle and whose value is the cryptographic key.
 		/// </returns>
 		internal static KeyValuePair<string, CryptoKey> GetCurrentKey(this ICryptoKeyStore cryptoKeyStore, string bucket, TimeSpan minimumRemainingLife, int keySize = 256) {
-			Contract.Requires<ArgumentNullException>(cryptoKeyStore != null);
-			Contract.Requires<ArgumentException>(!String.IsNullOrEmpty(bucket));
-			Contract.Requires<ArgumentException>(keySize % 8 == 0);
+			Requires.NotNull(cryptoKeyStore, "cryptoKeyStore");
+			Requires.NotNullOrEmpty(bucket, "bucket");
+			Requires.True(keySize % 8 == 0, "keySize");
 
 			var cryptoKeyPair = cryptoKeyStore.GetKeys(bucket).FirstOrDefault(pair => pair.Value.Key.Length == keySize / 8);
 			if (cryptoKeyPair.Value == null || cryptoKeyPair.Value.ExpiresUtc < DateTime.UtcNow + minimumRemainingLife) {
@@ -782,7 +782,7 @@ namespace DotNetOpenAuth.Messaging {
 		/// <returns>The compressed data.</returns>
 		[SuppressMessage("Microsoft.Usage", "CA2202:Do not dispose objects multiple times", Justification = "This Dispose is safe.")]
 		internal static byte[] Compress(byte[] buffer) {
-			Contract.Requires<ArgumentNullException>(buffer != null);
+			Requires.NotNull(buffer, "buffer");
 			Contract.Ensures(Contract.Result<byte[]>() != null);
 
 			using (var ms = new MemoryStream()) {
@@ -800,7 +800,7 @@ namespace DotNetOpenAuth.Messaging {
 		/// <param name="buffer">The buffer to decompress.</param>
 		/// <returns>The decompressed data.</returns>
 		internal static byte[] Decompress(byte[] buffer) {
-			Contract.Requires<ArgumentNullException>(buffer != null);
+			Requires.NotNull(buffer, "buffer");
 			Contract.Ensures(Contract.Result<byte[]>() != null);
 
 			using (var compressedDataStream = new MemoryStream(buffer)) {
@@ -837,7 +837,7 @@ namespace DotNetOpenAuth.Messaging {
 		/// <param name="base64WebSafe">The base64-encoded string.  May be web-safe encoded.</param>
 		/// <returns>A data buffer.</returns>
 		internal static byte[] FromBase64WebSafeString(string base64WebSafe) {
-			Contract.Requires<ArgumentException>(!String.IsNullOrEmpty(base64WebSafe));
+			Requires.NotNullOrEmpty(base64WebSafe, "base64WebSafe");
 			Contract.Ensures(Contract.Result<byte[]>() != null);
 
 			// Restore the padding characters and original URL-unsafe characters.
@@ -907,8 +907,8 @@ namespace DotNetOpenAuth.Messaging {
 		/// <param name="headers">The headers to add.</param>
 		/// <param name="response">The <see cref="HttpResponse"/> instance to set the appropriate values to.</param>
 		internal static void ApplyHeadersToResponse(WebHeaderCollection headers, HttpResponse response) {
-			Contract.Requires<ArgumentNullException>(headers != null);
-			Contract.Requires<ArgumentNullException>(response != null);
+			Requires.NotNull(headers, "headers");
+			Requires.NotNull(response, "response");
 
 			foreach (string headerName in headers) {
 				switch (headerName) {
@@ -932,8 +932,8 @@ namespace DotNetOpenAuth.Messaging {
 		/// <param name="headers">The headers to add.</param>
 		/// <param name="response">The <see cref="HttpListenerResponse"/> instance to set the appropriate values to.</param>
 		internal static void ApplyHeadersToResponse(WebHeaderCollection headers, HttpListenerResponse response) {
-			Contract.Requires<ArgumentNullException>(headers != null);
-			Contract.Requires<ArgumentNullException>(response != null);
+			Requires.NotNull(headers, "headers");
+			Requires.NotNull(response, "response");
 
 			foreach (string headerName in headers) {
 				switch (headerName) {
@@ -961,10 +961,10 @@ namespace DotNetOpenAuth.Messaging {
 		/// The positions are NOT reset after copying is complete.
 		/// </remarks>
 		internal static int CopyTo(this Stream copyFrom, Stream copyTo) {
-			Contract.Requires<ArgumentNullException>(copyFrom != null);
-			Contract.Requires<ArgumentNullException>(copyTo != null);
-			Contract.Requires<ArgumentException>(copyFrom.CanRead, MessagingStrings.StreamUnreadable);
-			Contract.Requires<ArgumentException>(copyTo.CanWrite, MessagingStrings.StreamUnwritable);
+			Requires.NotNull(copyFrom, "copyFrom");
+			Requires.NotNull(copyTo, "copyTo");
+			Requires.True(copyFrom.CanRead, "copyFrom", MessagingStrings.StreamUnreadable);
+			Requires.True(copyTo.CanWrite, "copyTo", MessagingStrings.StreamUnwritable);
 			return CopyUpTo(copyFrom, copyTo, int.MaxValue);
 		}
 #endif
@@ -981,10 +981,10 @@ namespace DotNetOpenAuth.Messaging {
 		/// The positions are NOT reset after copying is complete.
 		/// </remarks>
 		internal static int CopyUpTo(this Stream copyFrom, Stream copyTo, int maximumBytesToCopy) {
-			Contract.Requires<ArgumentNullException>(copyFrom != null);
-			Contract.Requires<ArgumentNullException>(copyTo != null);
-			Contract.Requires<ArgumentException>(copyFrom.CanRead, MessagingStrings.StreamUnreadable);
-			Contract.Requires<ArgumentException>(copyTo.CanWrite, MessagingStrings.StreamUnwritable);
+			Requires.NotNull(copyFrom, "copyFrom");
+			Requires.NotNull(copyTo, "copyTo");
+			Requires.True(copyFrom.CanRead, "copyFrom", MessagingStrings.StreamUnreadable);
+			Requires.True(copyTo.CanWrite, "copyTo", MessagingStrings.StreamUnwritable);
 
 			byte[] buffer = new byte[1024];
 			int readBytes;
@@ -1005,8 +1005,8 @@ namespace DotNetOpenAuth.Messaging {
 		/// <param name="copyFrom">The stream to copy bytes from.</param>
 		/// <returns>A seekable stream with the same contents as the original.</returns>
 		internal static Stream CreateSnapshot(this Stream copyFrom) {
-			Contract.Requires<ArgumentNullException>(copyFrom != null);
-			Contract.Requires<ArgumentException>(copyFrom.CanRead);
+			Requires.NotNull(copyFrom, "copyFrom");
+			Requires.True(copyFrom.CanRead, "copyFrom", MessagingStrings.StreamUnreadable);
 
 			MemoryStream copyTo = new MemoryStream(copyFrom.CanSeek ? (int)copyFrom.Length : 4 * 1024);
 			try {
@@ -1025,8 +1025,8 @@ namespace DotNetOpenAuth.Messaging {
 		/// <param name="request">The request to clone.</param>
 		/// <returns>The newly created instance.</returns>
 		internal static HttpWebRequest Clone(this HttpWebRequest request) {
-			Contract.Requires<ArgumentNullException>(request != null);
-			Contract.Requires<ArgumentException>(request.RequestUri != null);
+			Requires.NotNull(request, "request");
+			Requires.True(request.RequestUri != null, "request");
 			return Clone(request, request.RequestUri);
 		}
 
@@ -1037,8 +1037,8 @@ namespace DotNetOpenAuth.Messaging {
 		/// <param name="newRequestUri">The new recipient of the request.</param>
 		/// <returns>The newly created instance.</returns>
 		internal static HttpWebRequest Clone(this HttpWebRequest request, Uri newRequestUri) {
-			Contract.Requires<ArgumentNullException>(request != null);
-			Contract.Requires<ArgumentNullException>(newRequestUri != null);
+			Requires.NotNull(request, "request");
+			Requires.NotNull(newRequestUri, "newRequestUri");
 
 			var newRequest = (HttpWebRequest)WebRequest.Create(newRequestUri);
 
@@ -1104,8 +1104,8 @@ namespace DotNetOpenAuth.Messaging {
 		/// <param name="second">The second array in the comparison. May not be null.</param>
 		/// <returns>True if the arrays equal; false otherwise.</returns>
 		internal static bool AreEquivalent<T>(T[] first, T[] second) {
-			Contract.Requires<ArgumentNullException>(first != null);
-			Contract.Requires<ArgumentNullException>(second != null);
+			Requires.NotNull(first, "first");
+			Requires.NotNull(second, "second");
 			if (first.Length != second.Length) {
 				return false;
 			}
@@ -1129,8 +1129,8 @@ namespace DotNetOpenAuth.Messaging {
 		/// or other secret.
 		/// </remarks>
 		internal static bool AreEquivalentConstantTime(byte[] first, byte[] second) {
-			Contract.Requires<ArgumentNullException>(first != null);
-			Contract.Requires<ArgumentNullException>(second != null);
+			Requires.NotNull(first, "first");
+			Requires.NotNull(second, "second");
 			if (first.Length != second.Length) {
 				return false;
 			}
@@ -1219,8 +1219,8 @@ namespace DotNetOpenAuth.Messaging {
 		/// <param name="second">The second dictionary in the comparison. May not be null.</param>
 		/// <returns>True if the arrays equal; false otherwise.</returns>
 		internal static bool AreEquivalent<TKey, TValue>(IDictionary<TKey, TValue> first, IDictionary<TKey, TValue> second) {
-			Contract.Requires<ArgumentNullException>(first != null);
-			Contract.Requires<ArgumentNullException>(second != null);
+			Requires.NotNull(first, "first");
+			Requires.NotNull(second, "second");
 			return AreEquivalent(first.ToArray(), second.ToArray());
 		}
 
@@ -1232,7 +1232,7 @@ namespace DotNetOpenAuth.Messaging {
 		/// <param name="args">The dictionary of key/values to read from.</param>
 		/// <returns>The formulated querystring style string.</returns>
 		internal static string CreateQueryString(IEnumerable<KeyValuePair<string, string>> args) {
-			Contract.Requires<ArgumentNullException>(args != null);
+			Requires.NotNull(args, "args");
 			Contract.Ensures(Contract.Result<string>() != null);
 
 			if (args.Count() == 0) {
@@ -1268,7 +1268,7 @@ namespace DotNetOpenAuth.Messaging {
 		/// in the query string, the existing ones are <i>not</i> replaced.
 		/// </remarks>
 		internal static void AppendQueryArgs(this UriBuilder builder, IEnumerable<KeyValuePair<string, string>> args) {
-			Contract.Requires<ArgumentNullException>(builder != null);
+			Requires.NotNull(builder, "builder");
 
 			if (args != null && args.Count() > 0) {
 				StringBuilder sb = new StringBuilder(50 + (args.Count() * 10));
@@ -1297,7 +1297,7 @@ namespace DotNetOpenAuth.Messaging {
 		/// in the fragment, the existing ones are <i>not</i> replaced.
 		/// </remarks>
 		internal static void AppendFragmentArgs(this UriBuilder builder, IEnumerable<KeyValuePair<string, string>> args) {
-			Contract.Requires<ArgumentNullException>(builder != null);
+			Requires.NotNull(builder, "builder");
 
 			if (args != null && args.Count() > 0) {
 				StringBuilder sb = new StringBuilder(50 + (args.Count() * 10));
@@ -1321,7 +1321,7 @@ namespace DotNetOpenAuth.Messaging {
 		/// If null, <paramref name="builder"/> is not changed.
 		/// </param>
 		internal static void AppendAndReplaceQueryArgs(this UriBuilder builder, IEnumerable<KeyValuePair<string, string>> args) {
-			Contract.Requires<ArgumentNullException>(builder != null);
+			Requires.NotNull(builder, "builder");
 
 			if (args != null && args.Count() > 0) {
 				NameValueCollection aggregatedArgs = HttpUtility.ParseQueryString(builder.Query);
@@ -1394,7 +1394,7 @@ namespace DotNetOpenAuth.Messaging {
 		/// <param name="messageDictionary">The message to copy the extra data into.</param>
 		/// <param name="extraParameters">The extra data to copy into the message.  May be null to do nothing.</param>
 		internal static void AddExtraParameters(this MessageDictionary messageDictionary, IDictionary<string, string> extraParameters) {
-			Contract.Requires<ArgumentNullException>(messageDictionary != null);
+			Requires.NotNull(messageDictionary, "messageDictionary");
 
 			if (extraParameters != null) {
 				foreach (var pair in extraParameters) {
@@ -1415,7 +1415,7 @@ namespace DotNetOpenAuth.Messaging {
 		/// <param name="sequence">The sequence.</param>
 		/// <returns>A dictionary.</returns>
 		internal static Dictionary<TKey, TValue> ToDictionary<TKey, TValue>(this IEnumerable<KeyValuePair<TKey, TValue>> sequence) {
-			Contract.Requires<ArgumentNullException>(sequence != null);
+			Requires.NotNull(sequence, "sequence");
 			return sequence.ToDictionary(pair => pair.Key, pair => pair.Value);
 		}
 
@@ -1480,9 +1480,9 @@ namespace DotNetOpenAuth.Messaging {
 		/// <param name="comparer">A comparison function to compare keys.</param>
 		/// <returns>An System.Linq.IOrderedEnumerable&lt;TElement&gt; whose elements are sorted according to a key.</returns>
 		internal static IOrderedEnumerable<TSource> OrderBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Comparison<TKey> comparer) {
-			Contract.Requires<ArgumentNullException>(source != null);
-			Contract.Requires<ArgumentNullException>(comparer != null);
-			Contract.Requires<ArgumentNullException>(keySelector != null);
+			Requires.NotNull(source, "source");
+			Requires.NotNull(comparer, "comparer");
+			Requires.NotNull(keySelector, "keySelector");
 			Contract.Ensures(Contract.Result<IOrderedEnumerable<TSource>>() != null);
 			return System.Linq.Enumerable.OrderBy<TSource, TKey>(source, keySelector, new ComparisonHelper<TKey>(comparer));
 		}
@@ -1500,7 +1500,7 @@ namespace DotNetOpenAuth.Messaging {
 		/// if their <see cref="IDirectedProtocolMessage.Recipient"/> property is non-null.
 		/// </remarks>
 		internal static bool IsRequest(this IDirectedProtocolMessage message) {
-			Contract.Requires<ArgumentNullException>(message != null);
+			Requires.NotNull(message, "message");
 			return message.Recipient != null;
 		}
 
@@ -1518,7 +1518,7 @@ namespace DotNetOpenAuth.Messaging {
 		/// <see cref="IDirectResponseProtocolMessage.OriginatingRequest"/> property is non-null.
 		/// </remarks>
 		internal static bool IsDirectResponse(this IDirectResponseProtocolMessage message) {
-			Contract.Requires<ArgumentNullException>(message != null);
+			Requires.NotNull(message, "message");
 			return message.OriginatingRequest != null;
 		}
 
@@ -1528,8 +1528,8 @@ namespace DotNetOpenAuth.Messaging {
 		/// <param name="writer">The binary writer.</param>
 		/// <param name="buffer">The buffer.</param>
 		internal static void WriteBuffer(this BinaryWriter writer, byte[] buffer) {
-			Contract.Requires<ArgumentNullException>(writer != null);
-			Contract.Requires<ArgumentNullException>(buffer != null);
+			Requires.NotNull(writer, "writer");
+			Requires.NotNull(buffer, "buffer");
 			writer.Write(buffer.Length);
 			writer.Write(buffer, 0, buffer.Length);
 		}
@@ -1540,7 +1540,7 @@ namespace DotNetOpenAuth.Messaging {
 		/// <param name="reader">The binary reader positioned at the buffer length.</param>
 		/// <returns>The read buffer.</returns>
 		internal static byte[] ReadBuffer(this BinaryReader reader) {
-			Contract.Requires<ArgumentNullException>(reader != null);
+			Requires.NotNull(reader, "reader");
 			int length = reader.ReadInt32();
 			byte[] buffer = new byte[length];
 			ErrorUtilities.VerifyProtocol(reader.Read(buffer, 0, length) == length, "Unexpected buffer length.");
@@ -1606,7 +1606,7 @@ namespace DotNetOpenAuth.Messaging {
 		/// host actually having this configuration element present.
 		/// </remarks>
 		internal static string EscapeUriDataStringRfc3986(string value) {
-			Contract.Requires<ArgumentNullException>(value != null);
+			Requires.NotNull(value, "value");
 
 			// Start with RFC 2396 escaping by calling the .NET method to do the work.
 			// This MAY sometimes exhibit RFC 3986 behavior (according to the documentation).
@@ -1686,7 +1686,7 @@ namespace DotNetOpenAuth.Messaging {
 			/// </summary>
 			/// <param name="comparison">The comparison method to use.</param>
 			internal ComparisonHelper(Comparison<T> comparison) {
-				Contract.Requires<ArgumentNullException>(comparison != null);
+				Requires.NotNull(comparison, "comparison");
 
 				this.comparison = comparison;
 			}
diff --git a/src/DotNetOpenAuth.Messaging/Messaging/MultipartPostPart.cs b/src/DotNetOpenAuth.Messaging/Messaging/MultipartPostPart.cs
index eff40dd..f72ad6c 100644
--- a/src/DotNetOpenAuth.Messaging/Messaging/MultipartPostPart.cs
+++ b/src/DotNetOpenAuth.Messaging/Messaging/MultipartPostPart.cs
@@ -32,7 +32,7 @@ namespace DotNetOpenAuth.Messaging {
 		/// </summary>
 		/// <param name="contentDisposition">The content disposition of the part.</param>
 		public MultipartPostPart(string contentDisposition) {
-			Contract.Requires<ArgumentException>(!string.IsNullOrEmpty(contentDisposition));
+			Requires.NotNullOrEmpty(contentDisposition, "contentDisposition");
 
 			this.ContentDisposition = contentDisposition;
 			this.ContentAttributes = new Dictionary<string, string>();
@@ -99,8 +99,8 @@ namespace DotNetOpenAuth.Messaging {
 		/// <param name="value">The value.</param>
 		/// <returns>The constructed part.</returns>
 		public static MultipartPostPart CreateFormPart(string name, string value) {
-			Contract.Requires<ArgumentException>(!string.IsNullOrEmpty(name));
-			Contract.Requires<ArgumentException>(value != null);
+			Requires.NotNullOrEmpty(name, "name");
+			Requires.NotNull(value, "value");
 
 			var part = new MultipartPostPart("form-data");
 			try {
@@ -121,9 +121,9 @@ namespace DotNetOpenAuth.Messaging {
 		/// <param name="contentType">Type of the content in HTTP Content-Type format.</param>
 		/// <returns>The constructed part.</returns>
 		public static MultipartPostPart CreateFormFilePart(string name, string filePath, string contentType) {
-			Contract.Requires<ArgumentException>(!string.IsNullOrEmpty(name));
-			Contract.Requires<ArgumentException>(!string.IsNullOrEmpty(filePath));
-			Contract.Requires<ArgumentException>(!string.IsNullOrEmpty(contentType));
+			Requires.NotNullOrEmpty(name, "name");
+			Requires.NotNullOrEmpty(filePath, "filePath");
+			Requires.NotNullOrEmpty(contentType, "contentType");
 
 			string fileName = Path.GetFileName(filePath);
 			var fileStream = File.OpenRead(filePath);
@@ -144,10 +144,10 @@ namespace DotNetOpenAuth.Messaging {
 		/// <param name="content">The content of the file.</param>
 		/// <returns>The constructed part.</returns>
 		public static MultipartPostPart CreateFormFilePart(string name, string fileName, string contentType, Stream content) {
-			Contract.Requires<ArgumentException>(!string.IsNullOrEmpty(name));
-			Contract.Requires<ArgumentException>(!string.IsNullOrEmpty(fileName));
-			Contract.Requires<ArgumentException>(!string.IsNullOrEmpty(contentType));
-			Contract.Requires<ArgumentException>(content != null);
+			Requires.NotNullOrEmpty(name, "name");
+			Requires.NotNullOrEmpty(fileName, "fileName");
+			Requires.NotNullOrEmpty(contentType, "contentType");
+			Requires.NotNull(content, "content");
 
 			var part = new MultipartPostPart("file");
 			try {
diff --git a/src/DotNetOpenAuth.Messaging/Messaging/NetworkDirectWebResponse.cs b/src/DotNetOpenAuth.Messaging/Messaging/NetworkDirectWebResponse.cs
index 800d2ba..8fb69a1 100644
--- a/src/DotNetOpenAuth.Messaging/Messaging/NetworkDirectWebResponse.cs
+++ b/src/DotNetOpenAuth.Messaging/Messaging/NetworkDirectWebResponse.cs
@@ -42,8 +42,8 @@ namespace DotNetOpenAuth.Messaging {
 		/// <param name="response">The response.</param>
 		internal NetworkDirectWebResponse(Uri requestUri, HttpWebResponse response)
 			: base(requestUri, response) {
-			Contract.Requires<ArgumentNullException>(requestUri != null);
-			Contract.Requires<ArgumentNullException>(response != null);
+			Requires.NotNull(requestUri, "requestUri");
+			Requires.NotNull(response, "response");
 			this.httpWebResponse = response;
 			this.responseStream = response.GetResponseStream();
 		}
diff --git a/src/DotNetOpenAuth.Messaging/Messaging/OutgoingWebResponse.cs b/src/DotNetOpenAuth.Messaging/Messaging/OutgoingWebResponse.cs
index b4bc22d..b48ab5e 100644
--- a/src/DotNetOpenAuth.Messaging/Messaging/OutgoingWebResponse.cs
+++ b/src/DotNetOpenAuth.Messaging/Messaging/OutgoingWebResponse.cs
@@ -51,7 +51,7 @@ namespace DotNetOpenAuth.Messaging {
 		/// <param name="response">The <see cref="HttpWebResponse"/> to clone.</param>
 		/// <param name="maximumBytesToRead">The maximum bytes to read from the response stream.</param>
 		protected internal OutgoingWebResponse(HttpWebResponse response, int maximumBytesToRead) {
-			Contract.Requires<ArgumentNullException>(response != null);
+			Requires.NotNull(response, "response");
 
 			this.Status = response.StatusCode;
 			this.Headers = response.Headers;
@@ -128,7 +128,7 @@ namespace DotNetOpenAuth.Messaging {
 		/// </remarks>
 		[EditorBrowsable(EditorBrowsableState.Never), Obsolete("Use the Respond method instead, and prepare for execution to continue on this page beyond the call to Respond.")]
 		public virtual void Send() {
-			Contract.Requires<InvalidOperationException>(HttpContext.Current != null && HttpContext.Current.Request != null, MessagingStrings.HttpContextRequired);
+			Requires.ValidState(HttpContext.Current != null && HttpContext.Current.Request != null, MessagingStrings.HttpContextRequired);
 
 			this.Send(HttpContext.Current);
 		}
@@ -154,7 +154,7 @@ namespace DotNetOpenAuth.Messaging {
 		/// Requires a current HttpContext.
 		/// </remarks>
 		public virtual void Respond() {
-			Contract.Requires<InvalidOperationException>(HttpContext.Current != null && HttpContext.Current.Request != null, MessagingStrings.HttpContextRequired);
+			Requires.ValidState(HttpContext.Current != null && HttpContext.Current.Request != null, MessagingStrings.HttpContextRequired);
 
 			this.Respond(HttpContext.Current);
 		}
@@ -167,7 +167,7 @@ namespace DotNetOpenAuth.Messaging {
 		/// <param name="context">The context of the HTTP request whose response should be set.
 		/// Typically this is <see cref="HttpContext.Current"/>.</param>
 		public virtual void Respond(HttpContext context) {
-			Contract.Requires<ArgumentNullException>(context != null);
+			Requires.NotNull(context, "context");
 
 			this.Respond(context, false);
 		}
@@ -177,7 +177,7 @@ namespace DotNetOpenAuth.Messaging {
 		/// </summary>
 		/// <param name="response">The response to set to this message.</param>
 		public virtual void Send(HttpListenerResponse response) {
-			Contract.Requires<ArgumentNullException>(response != null);
+			Requires.NotNull(response, "response");
 
 			response.StatusCode = (int)this.Status;
 			MessagingUtilities.ApplyHeadersToResponse(this.Headers, response);
@@ -203,7 +203,7 @@ namespace DotNetOpenAuth.Messaging {
 		/// rather than cause a redirect.
 		/// </remarks>
 		internal Uri GetDirectUriRequest(Channel channel) {
-			Contract.Requires<ArgumentNullException>(channel != null);
+			Requires.NotNull(channel, "channel");
 
 			var message = this.OriginalMessage as IDirectedProtocolMessage;
 			if (message == null) {
@@ -255,7 +255,7 @@ namespace DotNetOpenAuth.Messaging {
 		/// <see cref="HttpApplication.CompleteRequest"/> rather than <see cref="HttpResponse.End"/>
 		/// to avoid a <see cref="ThreadAbortException"/>.</param>
 		protected internal virtual void Respond(HttpContext context, bool endRequest) {
-			Contract.Requires<ArgumentNullException>(context != null);
+			Requires.NotNull(context, "context");
 
 			context.Response.Clear();
 			context.Response.StatusCode = (int)this.Status;
diff --git a/src/DotNetOpenAuth.Messaging/Messaging/OutgoingWebResponseActionResult.cs b/src/DotNetOpenAuth.Messaging/Messaging/OutgoingWebResponseActionResult.cs
index f2b31e9..86dbb58 100644
--- a/src/DotNetOpenAuth.Messaging/Messaging/OutgoingWebResponseActionResult.cs
+++ b/src/DotNetOpenAuth.Messaging/Messaging/OutgoingWebResponseActionResult.cs
@@ -25,7 +25,7 @@ namespace DotNetOpenAuth.Messaging {
 		/// </summary>
 		/// <param name="response">The response.</param>
 		internal OutgoingWebResponseActionResult(OutgoingWebResponse response) {
-			Contract.Requires<ArgumentNullException>(response != null);
+			Requires.NotNull(response, "response");
 			this.response = response;
 		}
 
diff --git a/src/DotNetOpenAuth.Messaging/Messaging/ProtocolException.cs b/src/DotNetOpenAuth.Messaging/Messaging/ProtocolException.cs
index fb9ec6d..cf3ccb8 100644
--- a/src/DotNetOpenAuth.Messaging/Messaging/ProtocolException.cs
+++ b/src/DotNetOpenAuth.Messaging/Messaging/ProtocolException.cs
@@ -45,7 +45,7 @@ namespace DotNetOpenAuth.Messaging {
 		/// <param name="faultedMessage">The message that was the cause of the exception.  Must not be null.</param>
 		protected internal ProtocolException(string message, IProtocolMessage faultedMessage)
 			: base(message) {
-			Contract.Requires<ArgumentNullException>(faultedMessage != null);
+			Requires.NotNull(faultedMessage, "faultedMessage");
 			this.FaultedMessage = faultedMessage;
 		}
 
diff --git a/src/DotNetOpenAuth.Messaging/Messaging/Reflection/IMessagePartEncoder.cs b/src/DotNetOpenAuth.Messaging/Messaging/Reflection/IMessagePartEncoder.cs
index 03534f2..bbb3737 100644
--- a/src/DotNetOpenAuth.Messaging/Messaging/Reflection/IMessagePartEncoder.cs
+++ b/src/DotNetOpenAuth.Messaging/Messaging/Reflection/IMessagePartEncoder.cs
@@ -56,7 +56,7 @@ namespace DotNetOpenAuth.Messaging.Reflection {
 		/// The <paramref name="value"/> in string form, ready for message transport.
 		/// </returns>
 		string IMessagePartEncoder.Encode(object value) {
-			Contract.Requires<ArgumentNullException>(value != null);
+			Requires.NotNull(value, "value");
 			throw new NotImplementedException();
 		}
 
@@ -69,7 +69,7 @@ namespace DotNetOpenAuth.Messaging.Reflection {
 		/// </returns>
 		/// <exception cref="FormatException">Thrown when the string value given cannot be decoded into the required object type.</exception>
 		object IMessagePartEncoder.Decode(string value) {
-			Contract.Requires<ArgumentNullException>(value != null);
+			Requires.NotNull(value, "value");
 			throw new NotImplementedException();
 		}
 
diff --git a/src/DotNetOpenAuth.Messaging/Messaging/Reflection/MessageDescription.cs b/src/DotNetOpenAuth.Messaging/Messaging/Reflection/MessageDescription.cs
index 7dbab80..9a8098b 100644
--- a/src/DotNetOpenAuth.Messaging/Messaging/Reflection/MessageDescription.cs
+++ b/src/DotNetOpenAuth.Messaging/Messaging/Reflection/MessageDescription.cs
@@ -30,9 +30,8 @@ namespace DotNetOpenAuth.Messaging.Reflection {
 		/// <param name="messageType">Type of the message.</param>
 		/// <param name="messageVersion">The message version.</param>
 		internal MessageDescription(Type messageType, Version messageVersion) {
-			Contract.Requires<ArgumentNullException>(messageType != null);
-			Contract.Requires<ArgumentException>(typeof(IMessage).IsAssignableFrom(messageType));
-			Contract.Requires<ArgumentNullException>(messageVersion != null);
+			Requires.NotNullSubtype<IMessage>(messageType, "messageType");
+			Requires.NotNull(messageVersion, "messageVersion");
 
 			this.MessageType = messageType;
 			this.MessageVersion = messageVersion;
@@ -80,7 +79,7 @@ namespace DotNetOpenAuth.Messaging.Reflection {
 		/// <returns>The dictionary accessor to the message</returns>
 		[Pure]
 		internal MessageDictionary GetDictionary(IMessage message) {
-			Contract.Requires<ArgumentNullException>(message != null);
+			Requires.NotNull(message, "message");
 			Contract.Ensures(Contract.Result<MessageDictionary>() != null);
 			return this.GetDictionary(message, false);
 		}
@@ -93,7 +92,7 @@ namespace DotNetOpenAuth.Messaging.Reflection {
 		/// <returns>The dictionary accessor to the message</returns>
 		[Pure]
 		internal MessageDictionary GetDictionary(IMessage message, bool getOriginalValues) {
-			Contract.Requires<ArgumentNullException>(message != null);
+			Requires.NotNull(message, "message");
 			Contract.Ensures(Contract.Result<MessageDictionary>() != null);
 			return new MessageDictionary(message, this, getOriginalValues);
 		}
@@ -123,11 +122,11 @@ namespace DotNetOpenAuth.Messaging.Reflection {
 		/// <param name="parts">The key/value pairs of the serialized message.</param>
 		/// <returns>A value indicating whether the provided data fits the message's basic requirements.</returns>
 		internal bool CheckMessagePartsPassBasicValidation(IDictionary<string, string> parts) {
-			Contract.Requires<ArgumentNullException>(parts != null);
+			Requires.NotNull(parts, "parts");
 
 			return this.CheckRequiredMessagePartsArePresent(parts.Keys, false) &&
-			       this.CheckRequiredProtocolMessagePartsAreNotEmpty(parts, false) &&
-			       this.CheckMessagePartsConstantValues(parts, false);
+				   this.CheckRequiredProtocolMessagePartsAreNotEmpty(parts, false) &&
+				   this.CheckMessagePartsConstantValues(parts, false);
 		}
 
 		/// <summary>
@@ -142,7 +141,7 @@ namespace DotNetOpenAuth.Messaging.Reflection {
 		/// if <paramref name="throwOnFailure"/> is <c>true</c>.
 		/// </exception>
 		private bool CheckRequiredMessagePartsArePresent(IEnumerable<string> keys, bool throwOnFailure) {
-			Contract.Requires<ArgumentNullException>(keys != null);
+			Requires.NotNull(keys, "keys");
 
 			var missingKeys = (from part in this.Mapping.Values
 							   where part.IsRequired && !keys.Contains(part.Name)
@@ -176,7 +175,7 @@ namespace DotNetOpenAuth.Messaging.Reflection {
 		/// if <paramref name="throwOnFailure"/> is <c>true</c>.
 		/// </exception>
 		private bool CheckRequiredProtocolMessagePartsAreNotEmpty(IDictionary<string, string> partValues, bool throwOnFailure) {
-			Contract.Requires<ArgumentNullException>(partValues != null);
+			Requires.NotNull(partValues, "partValues");
 
 			string value;
 			var emptyValuedKeys = (from part in this.Mapping.Values
@@ -206,15 +205,14 @@ namespace DotNetOpenAuth.Messaging.Reflection {
 		/// <param name="partValues">The part values.</param>
 		/// <param name="throwOnFailure">if set to <c>true</c>, this method will throw on failure.</param>
 		/// <returns>A value indicating whether all the requirements are met.</returns>
-		private bool CheckMessagePartsConstantValues(IDictionary<string, string> partValues, bool throwOnFailure)
-		{
-			Contract.Requires<ArgumentNullException>(partValues != null);
+		private bool CheckMessagePartsConstantValues(IDictionary<string, string> partValues, bool throwOnFailure) {
+			Requires.NotNull(partValues, "partValues");
 
 			var badConstantValues = (from part in this.Mapping.Values
-			                         where part.IsConstantValueAvailableStatically
-			                         where partValues.ContainsKey(part.Name)
-			                         where !string.Equals(partValues[part.Name], part.StaticConstantValue, StringComparison.Ordinal)
-			                         select part.Name).ToArray();
+									 where part.IsConstantValueAvailableStatically
+									 where partValues.ContainsKey(part.Name)
+									 where !string.Equals(partValues[part.Name], part.StaticConstantValue, StringComparison.Ordinal)
+									 select part.Name).ToArray();
 			if (badConstantValues.Length > 0) {
 				if (throwOnFailure) {
 					ErrorUtilities.ThrowProtocol(
diff --git a/src/DotNetOpenAuth.Messaging/Messaging/Reflection/MessageDescriptionCollection.cs b/src/DotNetOpenAuth.Messaging/Messaging/Reflection/MessageDescriptionCollection.cs
index e332fc4..79ef172 100644
--- a/src/DotNetOpenAuth.Messaging/Messaging/Reflection/MessageDescriptionCollection.cs
+++ b/src/DotNetOpenAuth.Messaging/Messaging/Reflection/MessageDescriptionCollection.cs
@@ -64,9 +64,8 @@ namespace DotNetOpenAuth.Messaging.Reflection {
 		[SuppressMessage("Microsoft.Globalization", "CA1303:Do not pass literals as localized parameters", MessageId = "System.Diagnostics.Contracts.__ContractsRuntime.Assume(System.Boolean,System.String,System.String)", Justification = "No localization required.")]
 		[Pure]
 		internal MessageDescription Get(Type messageType, Version messageVersion) {
-			Contract.Requires<ArgumentNullException>(messageType != null);
-			Contract.Requires<ArgumentException>(typeof(IMessage).IsAssignableFrom(messageType));
-			Contract.Requires<ArgumentNullException>(messageVersion != null);
+			Requires.NotNullSubtype<IMessage>(messageType, "messageType");
+			Requires.NotNull(messageVersion, "messageVersion");
 			Contract.Ensures(Contract.Result<MessageDescription>() != null);
 
 			MessageTypeAndVersion key = new MessageTypeAndVersion(messageType, messageVersion);
@@ -94,7 +93,7 @@ namespace DotNetOpenAuth.Messaging.Reflection {
 		/// </returns>
 		[Pure]
 		internal MessageDescription Get(IMessage message) {
-			Contract.Requires<ArgumentNullException>(message != null);
+			Requires.NotNull(message, "message");
 			Contract.Ensures(Contract.Result<MessageDescription>() != null);
 			return this.Get(message.GetType(), message.Version);
 		}
@@ -106,7 +105,7 @@ namespace DotNetOpenAuth.Messaging.Reflection {
 		/// <returns>The dictionary.</returns>
 		[Pure]
 		internal MessageDictionary GetAccessor(IMessage message) {
-			Contract.Requires<ArgumentNullException>(message != null);
+			Requires.NotNull(message, "message");
 			return this.GetAccessor(message, false);
 		}
 
@@ -118,7 +117,7 @@ namespace DotNetOpenAuth.Messaging.Reflection {
 		/// <returns>The dictionary.</returns>
 		[Pure]
 		internal MessageDictionary GetAccessor(IMessage message, bool getOriginalValues) {
-			Contract.Requires<ArgumentNullException>(message != null);
+			Requires.NotNull(message, "message");
 			return this.Get(message).GetDictionary(message, getOriginalValues);
 		}
 
@@ -143,8 +142,8 @@ namespace DotNetOpenAuth.Messaging.Reflection {
 			/// <param name="messageType">Type of the message.</param>
 			/// <param name="messageVersion">The message version.</param>
 			internal MessageTypeAndVersion(Type messageType, Version messageVersion) {
-				Contract.Requires<ArgumentNullException>(messageType != null);
-				Contract.Requires<ArgumentNullException>(messageVersion != null);
+				Requires.NotNull(messageType, "messageType");
+				Requires.NotNull(messageVersion, "messageVersion");
 
 				this.type = messageType;
 				this.version = messageVersion;
diff --git a/src/DotNetOpenAuth.Messaging/Messaging/Reflection/MessageDictionary.cs b/src/DotNetOpenAuth.Messaging/Messaging/Reflection/MessageDictionary.cs
index 2b60a9c..54e2dd5 100644
--- a/src/DotNetOpenAuth.Messaging/Messaging/Reflection/MessageDictionary.cs
+++ b/src/DotNetOpenAuth.Messaging/Messaging/Reflection/MessageDictionary.cs
@@ -42,8 +42,8 @@ namespace DotNetOpenAuth.Messaging.Reflection {
 		/// <param name="getOriginalValues">A value indicating whether this message dictionary will retrieve original values instead of normalized ones.</param>
 		[Pure]
 		internal MessageDictionary(IMessage message, MessageDescription description, bool getOriginalValues) {
-			Contract.Requires<ArgumentNullException>(message != null);
-			Contract.Requires<ArgumentNullException>(description != null);
+			Requires.NotNull(message, "message");
+			Requires.NotNull(description, "description");
 
 			this.message = message;
 			this.description = description;
@@ -389,7 +389,7 @@ namespace DotNetOpenAuth.Messaging.Reflection {
 		/// </summary>
 		/// <param name="fields">The data to load into the message.</param>
 		public void Deserialize(IDictionary<string, string> fields) {
-			Contract.Requires<ArgumentNullException>(fields != null);
+			Requires.NotNull(fields, "fields");
 			this.Serializer.Deserialize(fields, this);
 		}
 
diff --git a/src/DotNetOpenAuth.Messaging/Messaging/Reflection/MessagePart.cs b/src/DotNetOpenAuth.Messaging/Messaging/Reflection/MessagePart.cs
index 83f489a..f439c4d 100644
--- a/src/DotNetOpenAuth.Messaging/Messaging/Reflection/MessagePart.cs
+++ b/src/DotNetOpenAuth.Messaging/Messaging/Reflection/MessagePart.cs
@@ -105,9 +105,9 @@ namespace DotNetOpenAuth.Messaging.Reflection {
 		/// </param>
 		[SuppressMessage("Microsoft.Maintainability", "CA1502:AvoidExcessiveComplexity", Justification = "Unavoidable"), SuppressMessage("Microsoft.Performance", "CA1800:DoNotCastUnnecessarily", Justification = "Code contracts requires it.")]
 		internal MessagePart(MemberInfo member, MessagePartAttribute attribute) {
-			Contract.Requires<ArgumentNullException>(member != null);
-			Contract.Requires<ArgumentException>(member is FieldInfo || member is PropertyInfo);
-			Contract.Requires<ArgumentNullException>(attribute != null);
+			Requires.NotNull(member, "member");
+			Requires.True(member is FieldInfo || member is PropertyInfo, "member");
+			Requires.NotNull(attribute, "attribute");
 
 			this.field = member as FieldInfo;
 			this.property = member as PropertyInfo;
@@ -199,7 +199,7 @@ namespace DotNetOpenAuth.Messaging.Reflection {
 		/// </summary>
 		internal string StaticConstantValue {
 			get {
-				Contract.Requires<InvalidOperationException>(this.IsConstantValueAvailableStatically);
+				Requires.ValidState(this.IsConstantValueAvailableStatically);
 				return this.ToString(this.field.GetValue(null), false);
 			}
 		}
@@ -220,8 +220,8 @@ namespace DotNetOpenAuth.Messaging.Reflection {
 		/// <param name="toValue">The function to convert a string to the custom type.</param>
 		[SuppressMessage("Microsoft.Globalization", "CA1303:Do not pass literals as localized parameters", MessageId = "System.Diagnostics.Contracts.__ContractsRuntime.Requires<System.ArgumentNullException>(System.Boolean,System.String,System.String)", Justification = "Code contracts"), SuppressMessage("Microsoft.Naming", "CA2204:Literals should be spelled correctly", MessageId = "toString", Justification = "Code contracts"), SuppressMessage("Microsoft.Naming", "CA2204:Literals should be spelled correctly", MessageId = "toValue", Justification = "Code contracts")]
 		internal static void Map<T>(Func<T, string> toString, Func<T, string> toOriginalString, Func<string, T> toValue) {
-			Contract.Requires<ArgumentNullException>(toString != null);
-			Contract.Requires<ArgumentNullException>(toValue != null);
+			Requires.NotNull(toString, "toString");
+			Requires.NotNull(toValue, "toValue");
 
 			if (toOriginalString == null) {
 				toOriginalString = toString;
@@ -240,7 +240,7 @@ namespace DotNetOpenAuth.Messaging.Reflection {
 		/// <param name="message">The message instance containing the member whose value should be set.</param>
 		/// <param name="value">The string representation of the value to set.</param>
 		internal void SetValue(IMessage message, string value) {
-			Contract.Requires<ArgumentNullException>(message != null);
+			Requires.NotNull(message, "message");
 
 			try {
 				if (this.IsConstantValue) {
@@ -343,7 +343,7 @@ namespace DotNetOpenAuth.Messaging.Reflection {
 		/// <param name="messagePartEncoder">The message part encoder type.</param>
 		/// <returns>An instance of the desired encoder.</returns>
 		private static IMessagePartEncoder GetEncoder(Type messagePartEncoder) {
-			Contract.Requires<ArgumentNullException>(messagePartEncoder != null);
+			Requires.NotNull(messagePartEncoder, "messagePartEncoder");
 			Contract.Ensures(Contract.Result<IMessagePartEncoder>() != null);
 
 			IMessagePartEncoder encoder;
diff --git a/src/DotNetOpenAuth.Messaging/Messaging/Reflection/ValueMapping.cs b/src/DotNetOpenAuth.Messaging/Messaging/Reflection/ValueMapping.cs
index b0b8b47..9c0fa83 100644
--- a/src/DotNetOpenAuth.Messaging/Messaging/Reflection/ValueMapping.cs
+++ b/src/DotNetOpenAuth.Messaging/Messaging/Reflection/ValueMapping.cs
@@ -36,8 +36,8 @@ namespace DotNetOpenAuth.Messaging.Reflection {
 		/// <param name="toOriginalString">The mapping function that converts some custom value to its original (non-normalized) string.  May be null if the same as the <paramref name="toString"/> function.</param>
 		/// <param name="toValue">The mapping function that converts a string to some custom value.</param>
 		internal ValueMapping(Func<object, string> toString, Func<object, string> toOriginalString, Func<string, object> toValue) {
-			Contract.Requires<ArgumentNullException>(toString != null);
-			Contract.Requires<ArgumentNullException>(toValue != null);
+			Requires.NotNull(toString, "toString");
+			Requires.NotNull(toValue, "toValue");
 
 			this.ValueToString = toString;
 			this.ValueToOriginalString = toOriginalString ?? toString;
@@ -49,7 +49,7 @@ namespace DotNetOpenAuth.Messaging.Reflection {
 		/// </summary>
 		/// <param name="encoder">The encoder.</param>
 		internal ValueMapping(IMessagePartEncoder encoder) {
-			Contract.Requires<ArgumentNullException>(encoder != null);
+			Requires.NotNull(encoder, "encoder");
 			var nullEncoder = encoder as IMessagePartNullEncoder;
 			string nullString = nullEncoder != null ? nullEncoder.EncodedNullValue : null;
 
diff --git a/src/DotNetOpenAuth.Messaging/Messaging/StandardMessageFactory.cs b/src/DotNetOpenAuth.Messaging/Messaging/StandardMessageFactory.cs
index b28ce74..5db206e 100644
--- a/src/DotNetOpenAuth.Messaging/Messaging/StandardMessageFactory.cs
+++ b/src/DotNetOpenAuth.Messaging/Messaging/StandardMessageFactory.cs
@@ -41,8 +41,8 @@ namespace DotNetOpenAuth.Messaging {
 		/// </summary>
 		/// <param name="messageTypes">The message types that this factory may instantiate.</param>
 		public virtual void AddMessageTypes(IEnumerable<MessageDescription> messageTypes) {
-			Contract.Requires<ArgumentNullException>(messageTypes != null);
-			Contract.Requires<ArgumentException>(messageTypes.All(msg => msg != null));
+			Requires.NotNull(messageTypes, "messageTypes");
+			Requires.True(messageTypes.All(msg => msg != null), "messageTypes");
 
 			var unsupportedMessageTypes = new List<MessageDescription>(0);
 			foreach (MessageDescription messageDescription in messageTypes) {
@@ -139,8 +139,8 @@ namespace DotNetOpenAuth.Messaging {
 		/// </returns>
 		/// <exception cref="ProtocolException">May be thrown if the incoming data is ambiguous.</exception>
 		protected virtual MessageDescription GetMessageDescription(MessageReceivingEndpoint recipient, IDictionary<string, string> fields) {
-			Contract.Requires<ArgumentNullException>(recipient != null);
-			Contract.Requires<ArgumentNullException>(fields != null);
+			Requires.NotNull(recipient, "recipient");
+			Requires.NotNull(fields, "fields");
 
 			var matches = this.requestMessageTypes.Keys
 				.Where(message => message.CheckMessagePartsPassBasicValidation(fields))
@@ -172,8 +172,8 @@ namespace DotNetOpenAuth.Messaging {
 		/// </returns>
 		/// <exception cref="ProtocolException">May be thrown if the incoming data is ambiguous.</exception>
 		protected virtual MessageDescription GetMessageDescription(IDirectedProtocolMessage request, IDictionary<string, string> fields) {
-			Contract.Requires<ArgumentNullException>(request != null);
-			Contract.Requires<ArgumentNullException>(fields != null);
+			Requires.NotNull(request, "request");
+			Requires.NotNull(fields, "fields");
 
 			var matches = (from responseMessageType in this.responseMessageTypes
 			               let message = responseMessageType.Key
@@ -206,8 +206,8 @@ namespace DotNetOpenAuth.Messaging {
 		/// <param name="recipient">The recipient.</param>
 		/// <returns>The instantiated message.  Never null.</returns>
 		protected virtual IDirectedProtocolMessage InstantiateAsRequest(MessageDescription messageDescription, MessageReceivingEndpoint recipient) {
-			Contract.Requires<ArgumentNullException>(messageDescription != null);
-			Contract.Requires<ArgumentNullException>(recipient != null);
+			Requires.NotNull(messageDescription, "messageDescription");
+			Requires.NotNull(recipient, "recipient");
 			Contract.Ensures(Contract.Result<IDirectedProtocolMessage>() != null);
 
 			ConstructorInfo ctor = this.requestMessageTypes[messageDescription];
@@ -221,8 +221,8 @@ namespace DotNetOpenAuth.Messaging {
 		/// <param name="request">The request that resulted in this response.</param>
 		/// <returns>The instantiated message.  Never null.</returns>
 		protected virtual IDirectResponseProtocolMessage InstantiateAsResponse(MessageDescription messageDescription, IDirectedProtocolMessage request) {
-			Contract.Requires<ArgumentNullException>(messageDescription != null);
-			Contract.Requires<ArgumentNullException>(request != null);
+			Requires.NotNull(messageDescription, "messageDescription");
+			Requires.NotNull(request, "request");
 			Contract.Ensures(Contract.Result<IDirectResponseProtocolMessage>() != null);
 
 			Type requestType = request.GetType();
@@ -247,9 +247,9 @@ namespace DotNetOpenAuth.Messaging {
 		/// <param name="derivedType">The concrete class that implements the <paramref name="assignableType"/>.</param>
 		/// <returns>The distance between the two types.  0 if the types are equivalent, 1 if the type immediately derives from or implements the base type, or progressively higher integers.</returns>
 		private static int GetDerivationDistance(Type assignableType, Type derivedType) {
-			Contract.Requires<ArgumentNullException>(assignableType != null);
-			Contract.Requires<ArgumentNullException>(derivedType != null);
-			Contract.Requires<ArgumentException>(assignableType.IsAssignableFrom(derivedType));
+			Requires.NotNull(assignableType, "assignableType");
+			Requires.NotNull(derivedType, "derivedType");
+			Requires.True(assignableType.IsAssignableFrom(derivedType), "assignableType");
 
 			// If this is the two types are equivalent...
 			if (derivedType.IsAssignableFrom(assignableType))
@@ -275,8 +275,8 @@ namespace DotNetOpenAuth.Messaging {
 		/// <param name="comparison">The string comparison method to use.</param>
 		/// <returns>A non-negative integer no greater than the count of elements in the smallest collection.</returns>
 		private static int CountInCommon(ICollection<string> collection1, ICollection<string> collection2, StringComparison comparison = StringComparison.Ordinal) {
-			Contract.Requires<ArgumentNullException>(collection1 != null);
-			Contract.Requires<ArgumentNullException>(collection2 != null);
+			Requires.NotNull(collection1, "collection1");
+			Requires.NotNull(collection2, "collection2");
 			Contract.Ensures(Contract.Result<int>() >= 0 && Contract.Result<int>() <= Math.Min(collection1.Count, collection2.Count));
 
 			return collection1.Count(value1 => collection2.Any(value2 => string.Equals(value1, value2, comparison)));
@@ -289,8 +289,8 @@ namespace DotNetOpenAuth.Messaging {
 		/// <param name="requestType">Type of the request message.</param>
 		/// <returns>A sequence of matching constructors.</returns>
 		private IEnumerable<ConstructorInfo> FindMatchingResponseConstructors(MessageDescription messageDescription, Type requestType) {
-			Contract.Requires<ArgumentNullException>(messageDescription != null);
-			Contract.Requires<ArgumentNullException>(requestType != null);
+			Requires.NotNull(messageDescription, "messageDescription");
+			Requires.NotNull(requestType, "requestType");
 
 			return this.responseMessageTypes[messageDescription].Where(pair => pair.Key.IsAssignableFrom(requestType)).Select(pair => pair.Value);
 		}
diff --git a/src/DotNetOpenAuth.Messaging/Messaging/StandardMessageFactoryChannel.cs b/src/DotNetOpenAuth.Messaging/Messaging/StandardMessageFactoryChannel.cs
index 1fc3608..acfc004 100644
--- a/src/DotNetOpenAuth.Messaging/Messaging/StandardMessageFactoryChannel.cs
+++ b/src/DotNetOpenAuth.Messaging/Messaging/StandardMessageFactoryChannel.cs
@@ -34,8 +34,8 @@ namespace DotNetOpenAuth.Messaging {
 		/// <param name="bindingElements">The binding elements to apply to the channel.</param>
 		protected StandardMessageFactoryChannel(ICollection<Type> messageTypes, ICollection<Version> versions, params IChannelBindingElement[] bindingElements)
 			: base(new StandardMessageFactory(), bindingElements) {
-			Contract.Requires<ArgumentNullException>(messageTypes != null);
-			Contract.Requires<ArgumentNullException>(versions != null);
+			Requires.NotNull(messageTypes, "messageTypes");
+			Requires.NotNull(versions, "versions");
 
 			this.messageTypes = messageTypes;
 			this.versions = versions;
@@ -93,8 +93,8 @@ namespace DotNetOpenAuth.Messaging {
 		/// <returns>The generated/retrieved message descriptions.</returns>
 		private static IEnumerable<MessageDescription> GetMessageDescriptions(ICollection<Type> messageTypes, ICollection<Version> versions, MessageDescriptionCollection descriptionsCache)
 		{
-			Contract.Requires<ArgumentNullException>(messageTypes != null);
-			Contract.Requires<ArgumentNullException>(descriptionsCache != null);
+			Requires.NotNull(messageTypes, "messageTypes");
+			Requires.NotNull(descriptionsCache, "descriptionsCache");
 			Contract.Ensures(Contract.Result<IEnumerable<MessageDescription>>() != null);
 
 			// Get all the MessageDescription objects through the standard cache,
diff --git a/src/DotNetOpenAuth.Messaging/Messaging/StandardWebRequestHandler.cs b/src/DotNetOpenAuth.Messaging/Messaging/StandardWebRequestHandler.cs
index a5725cd..6c6a7bb 100644
--- a/src/DotNetOpenAuth.Messaging/Messaging/StandardWebRequestHandler.cs
+++ b/src/DotNetOpenAuth.Messaging/Messaging/StandardWebRequestHandler.cs
@@ -226,7 +226,7 @@ namespace DotNetOpenAuth.Messaging {
 		/// <param name="request">The request.</param>
 		/// <param name="preparingPost"><c>true</c> if this is a POST request whose headers have not yet been sent out; <c>false</c> otherwise.</param>
 		private static void PrepareRequest(HttpWebRequest request, bool preparingPost) {
-			Contract.Requires<ArgumentNullException>(request != null);
+			Requires.NotNull(request, "request");
 
 			// Be careful to not try to change the HTTP headers that have already gone out.
 			if (preparingPost || request.Method == "GET") {
diff --git a/src/DotNetOpenAuth.Messaging/Messaging/UntrustedWebRequestHandler.cs b/src/DotNetOpenAuth.Messaging/Messaging/UntrustedWebRequestHandler.cs
index a1a34a5..2d94130 100644
--- a/src/DotNetOpenAuth.Messaging/Messaging/UntrustedWebRequestHandler.cs
+++ b/src/DotNetOpenAuth.Messaging/Messaging/UntrustedWebRequestHandler.cs
@@ -88,7 +88,7 @@ namespace DotNetOpenAuth.Messaging {
 		/// </summary>
 		/// <param name="chainedWebRequestHandler">The chained web request handler.</param>
 		public UntrustedWebRequestHandler(IDirectWebRequestHandler chainedWebRequestHandler) {
-			Contract.Requires<ArgumentNullException>(chainedWebRequestHandler != null);
+			Requires.NotNull(chainedWebRequestHandler, "chainedWebRequestHandler");
 
 			this.chainedWebRequestHandler = chainedWebRequestHandler;
 			if (Debugger.IsAttached) {
@@ -112,7 +112,7 @@ namespace DotNetOpenAuth.Messaging {
 			}
 
 			set {
-				Contract.Requires<ArgumentOutOfRangeException>(value >= 2048);
+				Requires.InRange(value >= 2048, "value");
 				this.maximumBytesToRead = value;
 			}
 		}
@@ -127,7 +127,7 @@ namespace DotNetOpenAuth.Messaging {
 			}
 
 			set {
-				Contract.Requires<ArgumentOutOfRangeException>(value >= 0);
+				Requires.InRange(value >= 0, "value");
 				this.maximumRedirections = value;
 			}
 		}
@@ -314,7 +314,7 @@ namespace DotNetOpenAuth.Messaging {
 		/// 	<c>true</c> if this is a loopback IP address; <c>false</c> otherwise.
 		/// </returns>
 		private static bool IsIPv6Loopback(IPAddress ip) {
-			Contract.Requires<ArgumentNullException>(ip != null);
+			Requires.NotNull(ip, "ip");
 			byte[] addressBytes = ip.GetAddressBytes();
 			for (int i = 0; i < addressBytes.Length - 1; i++) {
 				if (addressBytes[i] != 0) {
@@ -337,9 +337,9 @@ namespace DotNetOpenAuth.Messaging {
 		/// 	<c>true</c> if the specified host falls within at least one of the given lists; otherwise, <c>false</c>.
 		/// </returns>
 		private static bool IsHostInList(string host, ICollection<string> stringList, ICollection<Regex> regexList) {
-			Contract.Requires<ArgumentException>(!String.IsNullOrEmpty(host));
-			Contract.Requires<ArgumentNullException>(stringList != null);
-			Contract.Requires<ArgumentNullException>(regexList != null);
+			Requires.NotNullOrEmpty(host, "host");
+			Requires.NotNull(stringList, "stringList");
+			Requires.NotNull(regexList, "regexList");
 			foreach (string testHost in stringList) {
 				if (string.Equals(host, testHost, StringComparison.OrdinalIgnoreCase)) {
 					return true;
@@ -395,7 +395,7 @@ namespace DotNetOpenAuth.Messaging {
 		/// 	<c>true</c> if [is URI allowable] [the specified URI]; otherwise, <c>false</c>.
 		/// </returns>
 		private bool IsUriAllowable(Uri uri) {
-			Contract.Requires<ArgumentNullException>(uri != null);
+			Requires.NotNull(uri, "uri");
 			if (!this.allowableSchemes.Contains(uri.Scheme)) {
 				Logger.Http.WarnFormat("Rejecting URL {0} because it uses a disallowed scheme.", uri);
 				return false;
@@ -455,7 +455,7 @@ namespace DotNetOpenAuth.Messaging {
 		/// <param name="request">The request to prepare.</param>
 		/// <param name="preparingPost"><c>true</c> if this is a POST request whose headers have not yet been sent out; <c>false</c> otherwise.</param>
 		private void PrepareRequest(HttpWebRequest request, bool preparingPost) {
-			Contract.Requires<ArgumentNullException>(request != null);
+			Requires.NotNull(request, "request");
 
 			// Be careful to not try to change the HTTP headers that have already gone out.
 			if (preparingPost || request.Method == "GET") {
diff --git a/src/DotNetOpenAuth.Messaging/Messaging/UriStyleMessageFormatter.cs b/src/DotNetOpenAuth.Messaging/Messaging/UriStyleMessageFormatter.cs
index 9bffc3d..2c653d0 100644
--- a/src/DotNetOpenAuth.Messaging/Messaging/UriStyleMessageFormatter.cs
+++ b/src/DotNetOpenAuth.Messaging/Messaging/UriStyleMessageFormatter.cs
@@ -46,7 +46,7 @@ namespace DotNetOpenAuth.Messaging {
 		/// <param name="decodeOnceOnly">The nonce store to use to ensure that this instance is only decoded once.</param>
 		protected internal UriStyleMessageFormatter(ICryptoKeyStore cryptoKeyStore = null, string bucket = null, bool signed = false, bool encrypted = false, bool compressed = false, TimeSpan? minimumAge = null, TimeSpan? maximumAge = null, INonceStore decodeOnceOnly = null)
 			: base(cryptoKeyStore, bucket, signed, encrypted, compressed, minimumAge, maximumAge, decodeOnceOnly) {
-			Contract.Requires<ArgumentException>((cryptoKeyStore != null && !String.IsNullOrEmpty(bucket)) || (!signed && !encrypted));
+			Requires.True((cryptoKeyStore != null && !String.IsNullOrEmpty(bucket)) || (!signed && !encrypted), null);
 		}
 
 		/// <summary>
diff --git a/src/DotNetOpenAuth.Messaging/Reporting.cs b/src/DotNetOpenAuth.Messaging/Reporting.cs
index f197e81..0bbbcec 100644
--- a/src/DotNetOpenAuth.Messaging/Reporting.cs
+++ b/src/DotNetOpenAuth.Messaging/Reporting.cs
@@ -554,7 +554,7 @@ namespace DotNetOpenAuth {
 		/// If an existing identifier is not found, a new one is created, persisted, and returned.
 		/// </remarks>
 		private static Guid GetOrCreateOriginIdentity() {
-			Contract.Requires<InvalidOperationException>(file != null);
+			Requires.ValidState(file != null);
 			Contract.Ensures(Contract.Result<Guid>() != Guid.Empty);
 
 			Guid identityGuid = Guid.Empty;
@@ -584,7 +584,7 @@ namespace DotNetOpenAuth {
 		/// <param name="fileName">The filename to sanitize.</param>
 		/// <returns>The filename, with any and all invalid filename characters replaced with the hyphen (-) character.</returns>
 		private static string SanitizeFileName(string fileName) {
-			Contract.Requires<ArgumentException>(!String.IsNullOrEmpty(fileName));
+			Requires.NotNullOrEmpty(fileName, "fileName");
 			char[] invalidCharacters = Path.GetInvalidFileNameChars();
 			if (fileName.IndexOfAny(invalidCharacters) < 0) {
 				return fileName; // nothing invalid about this filename.
@@ -651,8 +651,8 @@ namespace DotNetOpenAuth {
 			/// <param name="fileName">Name of the file.</param>
 			/// <param name="maximumElements">The maximum number of elements to track.</param>
 			internal PersistentHashSet(IsolatedStorageFile storage, string fileName, int maximumElements) {
-				Contract.Requires<ArgumentNullException>(storage != null);
-				Contract.Requires<ArgumentException>(!String.IsNullOrEmpty(fileName));
+				Requires.NotNull(storage, "storage");
+				Requires.NotNullOrEmpty(fileName, "fileName");
 				this.FileName = fileName;
 				this.maximumElements = maximumElements;
 
@@ -796,8 +796,8 @@ namespace DotNetOpenAuth {
 			/// <param name="storage">The storage location.</param>
 			/// <param name="fileName">Name of the file.</param>
 			internal PersistentCounter(IsolatedStorageFile storage, string fileName) {
-				Contract.Requires<ArgumentNullException>(storage != null);
-				Contract.Requires<ArgumentException>(!String.IsNullOrEmpty(fileName));
+				Requires.NotNull(storage, "storage");
+				Requires.NotNullOrEmpty(fileName, "fileName");
 				this.FileName = fileName;
 
 				// Load the file into memory.
diff --git a/src/DotNetOpenAuth.Messaging/Requires.cs b/src/DotNetOpenAuth.Messaging/Requires.cs
new file mode 100644
index 0000000..c7b641a
--- /dev/null
+++ b/src/DotNetOpenAuth.Messaging/Requires.cs
@@ -0,0 +1,187 @@
+//-----------------------------------------------------------------------
+// <copyright file="Requires.cs" company="Andrew Arnott">
+//     Copyright (c) Andrew Arnott. All rights reserved.
+// </copyright>
+//-----------------------------------------------------------------------
+
+namespace DotNetOpenAuth {
+	using System;
+	using System.Collections.Generic;
+	using System.Diagnostics;
+	using System.Diagnostics.Contracts;
+	using System.Globalization;
+	using System.Linq;
+	using System.Text;
+	using DotNetOpenAuth.Messaging;
+
+	/// <summary>
+	/// Argument validation checks that throw some kind of ArgumentException when they fail (unless otherwise noted).
+	/// </summary>
+	internal static class Requires {
+		/// <summary>
+		/// Validates that a given parameter is not null.
+		/// </summary>
+		/// <typeparam name="T">The type of the parameter</typeparam>
+		/// <param name="value">The value.</param>
+		/// <param name="parameterName">Name of the parameter.</param>
+		[ContractArgumentValidator, DebuggerStepThrough]
+		internal static void NotNull<T>(T value, string parameterName) where T : class {
+			if (value == null) {
+				throw new ArgumentNullException(parameterName);
+			}
+
+			Contract.EndContractBlock();
+		}
+
+		/// <summary>
+		/// Validates that a parameter is not null or empty.
+		/// </summary>
+		/// <param name="value">The value.</param>
+		/// <param name="parameterName">Name of the parameter.</param>
+		[ContractArgumentValidator, DebuggerStepThrough]
+		internal static void NotNullOrEmpty(string value, string parameterName) {
+			NotNull(value, parameterName);
+			True(value.Length > 0, parameterName, Strings.EmptyStringNotAllowed);
+			Contract.EndContractBlock();
+		}
+
+		/// <summary>
+		/// Validates that an argument is either null or is a sequence with no null elements.
+		/// </summary>
+		/// <typeparam name="T">The type of elements in the sequence.</typeparam>
+		/// <param name="sequence">The sequence.</param>
+		/// <param name="parameterName">Name of the parameter.</param>
+		[ContractArgumentValidator, DebuggerStepThrough]
+		internal static void NullOrWithNoNullElements<T>(IEnumerable<T> sequence, string parameterName) where T : class {
+			if (sequence != null) {
+				if (sequence.Any(e => e == null)) {
+					throw new ArgumentException(MessagingStrings.SequenceContainsNullElement, parameterName);
+				}
+			}
+		}
+
+		/// <summary>
+		/// Validates some expression describing the acceptable range for an argument evaluates to true.
+		/// </summary>
+		/// <param name="condition">The expression that must evaluate to true to avoid an <see cref="ArgumentOutOfRangeException"/>.</param>
+		/// <param name="parameterName">Name of the parameter.</param>
+		/// <param name="message">The message to include with the exception.</param>
+		[ContractArgumentValidator, DebuggerStepThrough]
+		internal static void InRange(bool condition, string parameterName, string message = null) {
+			if (!condition) {
+				throw new ArgumentOutOfRangeException(parameterName, message);
+			}
+
+			Contract.EndContractBlock();
+		}
+
+		/// <summary>
+		/// Validates some expression describing the acceptable condition for an argument evaluates to true.
+		/// </summary>
+		/// <param name="condition">The expression that must evaluate to true to avoid an <see cref="ArgumentException"/>.</param>
+		/// <param name="parameterName">Name of the parameter.</param>
+		/// <param name="message">The message to include with the exception.</param>
+		[ContractArgumentValidator, DebuggerStepThrough]
+		internal static void True(bool condition, string parameterName, string message = null) {
+			if (!condition) {
+				throw new ArgumentException(message ?? Strings.InvalidArgument, parameterName);
+			}
+
+			Contract.EndContractBlock();
+		}
+
+		/// <summary>
+		/// Validates some expression describing the acceptable condition for an argument evaluates to true.
+		/// </summary>
+		/// <param name="condition">The expression that must evaluate to true to avoid an <see cref="ArgumentException"/>.</param>
+		/// <param name="parameterName">Name of the parameter.</param>
+		/// <param name="unformattedMessage">The unformatted message.</param>
+		/// <param name="args">Formatting arguments.</param>
+		[ContractArgumentValidator, DebuggerStepThrough]
+		internal static void True(bool condition, string parameterName, string unformattedMessage, params object[] args) {
+			if (!condition) {
+				throw new ArgumentException(String.Format(unformattedMessage, args), parameterName);
+			}
+
+			Contract.EndContractBlock();
+		}
+
+		/// <summary>
+		/// Validates some expression describing the acceptable condition for an argument evaluates to true.
+		/// </summary>
+		/// <param name="condition">The expression that must evaluate to true to avoid an <see cref="InvalidOperationException"/>.</param>
+		[ContractArgumentValidator, DebuggerStepThrough]
+		internal static void ValidState(bool condition) {
+			if (!condition) {
+				throw new InvalidOperationException();
+			}
+
+			Contract.EndContractBlock();
+		}
+
+		/// <summary>
+		/// Validates some expression describing the acceptable condition for an argument evaluates to true.
+		/// </summary>
+		/// <param name="condition">The expression that must evaluate to true to avoid an <see cref="InvalidOperationException"/>.</param>
+		/// <param name="message">The message to include with the exception.</param>
+		[ContractArgumentValidator, DebuggerStepThrough]
+		internal static void ValidState(bool condition, string message) {
+			if (!condition) {
+				throw new InvalidOperationException(message);
+			}
+
+			Contract.EndContractBlock();
+		}
+
+		/// <summary>
+		/// Validates some expression describing the acceptable condition for an argument evaluates to true.
+		/// </summary>
+		/// <param name="condition">The expression that must evaluate to true to avoid an <see cref="InvalidOperationException"/>.</param>
+		/// <param name="unformattedMessage">The unformatted message.</param>
+		/// <param name="args">Formatting arguments.</param>
+		[ContractArgumentValidator, DebuggerStepThrough]
+		internal static void ValidState(bool condition, string unformattedMessage, params object[] args) {
+			if (!condition) {
+				throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, unformattedMessage, args));
+			}
+
+			Contract.EndContractBlock();
+		}
+
+		/// <summary>
+		/// Validates that some argument describes a type that is or derives from a required type.
+		/// </summary>
+		/// <typeparam name="T">The type that the argument must be or derive from.</typeparam>
+		/// <param name="type">The type given in the argument.</param>
+		/// <param name="parameterName">Name of the parameter.</param>
+		[ContractArgumentValidator, DebuggerStepThrough]
+		internal static void NotNullSubtype<T>(Type type, string parameterName) {
+			NotNull(type, parameterName);
+			True(typeof(T).IsAssignableFrom(type), parameterName, MessagingStrings.UnexpectedType, typeof(T).FullName, type.FullName);
+
+			Contract.EndContractBlock();
+		}
+
+		/// <summary>
+		/// Throws an <see cref="NotSupportedException"/> if a condition does not evaluate to <c>true</c>.
+		/// </summary>
+		/// <param name="condition">The expression that must evaluate to true to avoid an <see cref="NotSupportedException"/>.</param>
+		/// <param name="message">The message.</param>
+		[DebuggerStepThrough]
+		internal static void Support(bool condition, string message) {
+			if (!condition) {
+				throw new NotSupportedException(message);
+			}
+		}
+
+		/// <summary>
+		/// Throws an <see cref="ArgumentException"/>
+		/// </summary>
+		/// <param name="parameterName">Name of the parameter.</param>
+		/// <param name="message">The message.</param>
+		[DebuggerStepThrough]
+		internal static void Fail(string parameterName, string message) {
+			throw new ArgumentException(message, parameterName);
+		}
+	}
+}
diff --git a/src/DotNetOpenAuth.Messaging/Strings.Designer.cs b/src/DotNetOpenAuth.Messaging/Strings.Designer.cs
index 1461f83..21411a1 100644
--- a/src/DotNetOpenAuth.Messaging/Strings.Designer.cs
+++ b/src/DotNetOpenAuth.Messaging/Strings.Designer.cs
@@ -1,7 +1,7 @@
 //------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated by a tool.
-//     Runtime Version:4.0.30319.1
+//     Runtime Version:4.0.30319.17291
 //
 //     Changes to this file may cause incorrect behavior and will be lost if
 //     the code is regenerated.
@@ -88,6 +88,24 @@ namespace DotNetOpenAuth {
         }
         
         /// <summary>
+        ///   Looks up a localized string similar to The empty string is not allowed..
+        /// </summary>
+        internal static string EmptyStringNotAllowed {
+            get {
+                return ResourceManager.GetString("EmptyStringNotAllowed", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to The argument has an unexpected value..
+        /// </summary>
+        internal static string InvalidArgument {
+            get {
+                return ResourceManager.GetString("InvalidArgument", resourceCulture);
+            }
+        }
+        
+        /// <summary>
         ///   Looks up a localized string similar to No current HttpContext was detected, so an {0} instance must be explicitly provided or specified in the .config file.  Call the constructor overload that takes an {0}..
         /// </summary>
         internal static string StoreRequiredWhenNoHttpContextAvailable {
diff --git a/src/DotNetOpenAuth.Messaging/Strings.resx b/src/DotNetOpenAuth.Messaging/Strings.resx
index 4b78664..1c69ef7 100644
--- a/src/DotNetOpenAuth.Messaging/Strings.resx
+++ b/src/DotNetOpenAuth.Messaging/Strings.resx
@@ -129,4 +129,10 @@
   <data name="EmbeddedResourceUrlProviderRequired" xml:space="preserve">
     <value>The current IHttpHandler is not one of types: {0}.  An embedded resource URL provider must be set in your .config file.</value>
   </data>
+  <data name="EmptyStringNotAllowed" xml:space="preserve">
+    <value>The empty string is not allowed.</value>
+  </data>
+  <data name="InvalidArgument" xml:space="preserve">
+    <value>The argument has an unexpected value.</value>
+  </data>
 </root>
\ No newline at end of file
diff --git a/src/DotNetOpenAuth.Messaging/UriUtil.cs b/src/DotNetOpenAuth.Messaging/UriUtil.cs
index 819c406..57360f5 100644
--- a/src/DotNetOpenAuth.Messaging/UriUtil.cs
+++ b/src/DotNetOpenAuth.Messaging/UriUtil.cs
@@ -30,7 +30,7 @@ namespace DotNetOpenAuth {
 		/// </returns>
 		[ContractVerification(false)] // bugs/limitations in CC static analysis
 		internal static bool QueryStringContainPrefixedParameters(this Uri uri, string prefix) {
-			Contract.Requires<ArgumentException>(!string.IsNullOrEmpty(prefix));
+			Requires.NotNullOrEmpty(prefix, "prefix");
 			if (uri == null) {
 				return false;
 			}
@@ -48,7 +48,7 @@ namespace DotNetOpenAuth {
 		/// 	<c>true</c> if the URI represents an encrypted request; otherwise, <c>false</c>.
 		/// </returns>
 		internal static bool IsTransportSecure(this Uri uri) {
-			Contract.Requires<ArgumentNullException>(uri != null);
+			Requires.NotNull(uri, "uri");
 			return string.Equals(uri.Scheme, "https", StringComparison.OrdinalIgnoreCase);
 		}
 
@@ -59,7 +59,7 @@ namespace DotNetOpenAuth {
 		/// <param name="builder">The UriBuilder to render as a string.</param>
 		/// <returns>The string version of the Uri.</returns>
 		internal static string ToStringWithImpliedPorts(this UriBuilder builder) {
-			Contract.Requires<ArgumentNullException>(builder != null);
+			Requires.NotNull(builder, "builder");
 			Contract.Ensures(Contract.Result<string>() != null);
 
 			// We only check for implied ports on HTTP and HTTPS schemes since those
diff --git a/src/DotNetOpenAuth.Messaging/Util.cs b/src/DotNetOpenAuth.Messaging/Util.cs
index d6f8f23..6b63a36 100644
--- a/src/DotNetOpenAuth.Messaging/Util.cs
+++ b/src/DotNetOpenAuth.Messaging/Util.cs
@@ -209,7 +209,7 @@ namespace DotNetOpenAuth {
 			/// <param name="obj">The object that may be serialized to string form.</param>
 			/// <param name="toString">The method that will serialize the object if called upon.</param>
 			public DelayedToString(T obj, Func<T, string> toString) {
-				Contract.Requires<ArgumentNullException>(toString != null);
+				Requires.NotNull(toString, "toString");
 
 				this.obj = obj;
 				this.toString = toString;
diff --git a/tools/DotNetOpenAuth.Product.props b/tools/DotNetOpenAuth.Product.props
index ef5a106..03a0de7 100644
--- a/tools/DotNetOpenAuth.Product.props
+++ b/tools/DotNetOpenAuth.Product.props
@@ -2,7 +2,6 @@
 <Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
 	<PropertyGroup>
 		<MSBuildAllProjects>$(MSBuildAllProjects);$(MSBuildThisFile)</MSBuildAllProjects>
-		<CodeContractsAssemblyMode>1</CodeContractsAssemblyMode>
 	</PropertyGroup>
 	<PropertyGroup>
 		<OutputType>Library</OutputType>
@@ -23,7 +22,6 @@ http://opensource.org/licenses/ms-pl.html
 		<CodeAnalysisModuleSuppressionsFile>GlobalSuppressions.cs</CodeAnalysisModuleSuppressionsFile>
 		<CodeAnalysisUseTypeNameInSuppression>true</CodeAnalysisUseTypeNameInSuppression>
 
-		<CodeContractsEnableRuntimeChecking>True</CodeContractsEnableRuntimeChecking>
 		<CodeContractsCustomRewriterAssembly />
 		<CodeContractsCustomRewriterClass />
 		<CodeContractsRunCodeAnalysis>False</CodeContractsRunCodeAnalysis>
@@ -43,10 +41,21 @@ http://opensource.org/licenses/ms-pl.html
 		<CodeContractsRuntimeCallSiteRequires>False</CodeContractsRuntimeCallSiteRequires>
 		<CodeContractsEmitXMLDocs>True</CodeContractsEmitXMLDocs>
 		<CodeContractsRedundantAssumptions>False</CodeContractsRedundantAssumptions>
-		<CodeContractsReferenceAssembly>Build</CodeContractsReferenceAssembly>
 		<CodeContractsExtraRewriteOptions />
 	</PropertyGroup>
 
+	<PropertyGroup Condition=" '$(CodeContractsRewritingDisabled)' == 'true' ">
+		<CodeContractsAssemblyMode>0</CodeContractsAssemblyMode>
+		<CodeContractsEnableRuntimeChecking>False</CodeContractsEnableRuntimeChecking>
+		<CodeContractsReferenceAssembly Condition=" '$(Configuration)' == 'Release' ">Build</CodeContractsReferenceAssembly>
+	</PropertyGroup>
+
+	<PropertyGroup Condition=" '$(CodeContractsRewritingDisabled)' != 'true' ">
+		<CodeContractsAssemblyMode>1</CodeContractsAssemblyMode>
+		<CodeContractsEnableRuntimeChecking>True</CodeContractsEnableRuntimeChecking>
+		<CodeContractsReferenceAssembly>Build</CodeContractsReferenceAssembly>
+	</PropertyGroup>
+
 	<PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
 		<DebugSymbols>true</DebugSymbols>
 		<DebugType>full</DebugType>