Fixing the No overload for method problem
<p>I am keep having the "No overload for method 'GenerateSignature' takes 9 arguments" problem. Can you please tell me what is wrong with this class.
This code is the sample from the Oauth.net . I think it too old for my asp.net 3.5 or 4.0.</p>

<p>default.aspx</p>

<pre><code>&lt;%@ Page Language="C#" AutoEventWireup="true"%&gt;
&lt;%@ Import Namespace="OAuth" %&gt;
&lt;%@ Import Namespace="System" %&gt;
&lt;%@ Import Namespace="System.Net" %&gt;
&lt;%@ Import Namespace="System.IO" %&gt;
&lt;!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"&gt;

&lt;html xmlns="http://www.w3.org/1999/xhtml"&gt;
&lt;head runat="server"&gt;
    &lt;title&gt;&lt;/title&gt;
&lt;/head&gt;
&lt;body&gt;
    &lt;form id="form1" runat="server"&gt;
    &lt;div&gt;
    &lt;%
OAuthBase oauth = new OAuthBase();
Uri url = new Uri("http://ssdsdafdasfdsafdsa.example.net/photos?file=vacation.jpg&amp;size=original");
string signature = oauth.GenerateSignature(url,"dpf43f3p2l4k3l03", "kd94hf93k423kf44", "nnch734d00sl2jdk", "pfkkdhi9sl3r4s00", "GET", oauth.GenerateTimeStamp(), oauth.GenerateNonce(), OAuthBase.SignatureTypes.HMACSHA1);
         %&gt;
    &lt;/div&gt;
    &lt;/form&gt;
&lt;/body&gt;
&lt;/html&gt;
</code></pre>

<p>The app_code
//THE APP_CODE</p>

<pre><code>using System;
using System.Security.Cryptography;
using System.Collections.Generic;
using System.Text;
using System.Web;

namespace OAuth {
    public class OAuthBase {
        /// &lt;summary&gt;
        /// Provides a predefined set of algorithms that are supported officially by the protocol
        /// &lt;/summary&gt;
        public enum SignatureTypes {
            HMACSHA1,
            PLAINTEXT,
            RSASHA1
        }

        /// &lt;summary&gt;
        /// Provides an internal structure to sort the query parameter
        /// &lt;/summary&gt;
        protected class QueryParameter {
            private string name = null;
            private string value = null;

            public QueryParameter(string name, string value) {
                this.name = name;
                this.value = value;
            }

            public string Name {
                get { return name; }
            }

            public string Value {
                get { return value; }
            }            
        }

        /// &lt;summary&gt;
        /// Comparer class used to perform the sorting of the query parameters
        /// &lt;/summary&gt;
        protected class QueryParameterComparer : IComparer&lt;QueryParameter&gt; {

            #region IComparer&lt;QueryParameter&gt; Members

            public int Compare(QueryParameter x, QueryParameter y) {
                if (x.Name == y.Name) {
                    return string.Compare(x.Value, y.Value);
                } else {
                    return string.Compare(x.Name, y.Name);
                }
            }

            #endregion
        }

        protected const string OAuthVersion = "1.0";
        protected const string OAuthParameterPrefix = "oauth_";

        //
        // List of know and used oauth parameters' names
        //        
        protected const string OAuthConsumerKeyKey = "oauth_consumer_key";
        protected const string OAuthCallbackKey = "oauth_callback";
        protected const string OAuthVersionKey = "oauth_version";
        protected const string OAuthSignatureMethodKey = "oauth_signature_method";
        protected const string OAuthSignatureKey = "oauth_signature";
        protected const string OAuthTimestampKey = "oauth_timestamp";
        protected const string OAuthNonceKey = "oauth_nonce";
        protected const string OAuthTokenKey = "oauth_token";
        protected const string OAuthTokenSecretKey = "oauth_token_secret";

        protected const string HMACSHA1SignatureType = "HMAC-SHA1";
        protected const string PlainTextSignatureType = "PLAINTEXT";
        protected const string RSASHA1SignatureType = "RSA-SHA1";

        protected Random random = new Random();

        protected string unreservedChars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_.~";

        /// &lt;summary&gt;
        /// Helper function to compute a hash value
        /// &lt;/summary&gt;
        /// &lt;param name="hashAlgorithm"&gt;The hashing algoirhtm used. If that algorithm needs some initialization, like HMAC and its derivatives, they should be initialized prior to passing it to this function&lt;/param&gt;
        /// &lt;param name="data"&gt;The data to hash&lt;/param&gt;
        /// &lt;returns&gt;a Base64 string of the hash value&lt;/returns&gt;
        private string ComputeHash(HashAlgorithm hashAlgorithm, string data) {
            if (hashAlgorithm == null) {
                throw new ArgumentNullException("hashAlgorithm");
            }

            if (string.IsNullOrEmpty(data)) {
                throw new ArgumentNullException("data");
            }

            byte[] dataBuffer = System.Text.Encoding.ASCII.GetBytes(data);
            byte[] hashBytes = hashAlgorithm.ComputeHash(dataBuffer);

            return Convert.ToBase64String(hashBytes);
        }

        /// &lt;summary&gt;
        /// Internal function to cut out all non oauth query string parameters (all parameters not begining with "oauth_")
        /// &lt;/summary&gt;
        /// &lt;param name="parameters"&gt;The query string part of the Url&lt;/param&gt;
        /// &lt;returns&gt;A list of QueryParameter each containing the parameter name and value&lt;/returns&gt;
        private List&lt;QueryParameter&gt; GetQueryParameters(string parameters) {
            if (parameters.StartsWith("?")) {
                parameters = parameters.Remove(0, 1);
            }

            List&lt;QueryParameter&gt; result = new List&lt;QueryParameter&gt;();

            if (!string.IsNullOrEmpty(parameters)) {
                string[] p = parameters.Split('&amp;');
                foreach (string s in p) {
                    if (!string.IsNullOrEmpty(s) &amp;&amp; !s.StartsWith(OAuthParameterPrefix)) {
                        if (s.IndexOf('=') &gt; -1) {
                            string[] temp = s.Split('=');
                            result.Add(new QueryParameter(temp[0], temp[1]));
                        } else {
                            result.Add(new QueryParameter(s, string.Empty));
                        }
                    }
                }
            }

            return result;
        }

        /// &lt;summary&gt;
        /// This is a different Url Encode implementation since the default .NET one outputs the percent encoding in lower case.
        /// While this is not a problem with the percent encoding spec, it is used in upper case throughout OAuth
        /// &lt;/summary&gt;
        /// &lt;param name="value"&gt;The value to Url encode&lt;/param&gt;
        /// &lt;returns&gt;Returns a Url encoded string&lt;/returns&gt;
        protected string UrlEncode(string value) {
            StringBuilder result = new StringBuilder();

            foreach (char symbol in value) {
                if (unreservedChars.IndexOf(symbol) != -1) {
                    result.Append(symbol);
                } else {
                    result.Append('%' + String.Format("{0:X2}", (int)symbol));
                }
            }

            return result.ToString();
        }

        /// &lt;summary&gt;
        /// Normalizes the request parameters according to the spec
        /// &lt;/summary&gt;
        /// &lt;param name="parameters"&gt;The list of parameters already sorted&lt;/param&gt;
        /// &lt;returns&gt;a string representing the normalized parameters&lt;/returns&gt;
        protected string NormalizeRequestParameters(IList&lt;QueryParameter&gt; parameters) {         
            StringBuilder sb = new StringBuilder();
            QueryParameter p = null;
            for (int i = 0; i &lt; parameters.Count; i++) {
                p = parameters[i];
                sb.AppendFormat("{0}={1}", p.Name, p.Value);

                if (i &lt; parameters.Count - 1) {
                    sb.Append("&amp;");
                }
            }

            return sb.ToString();
        }

        /// &lt;summary&gt;
        /// Generate the signature base that is used to produce the signature
        /// &lt;/summary&gt;
        /// &lt;param name="url"&gt;The full url that needs to be signed including its non OAuth url parameters&lt;/param&gt;
        /// &lt;param name="consumerKey"&gt;The consumer key&lt;/param&gt;        
        /// &lt;param name="token"&gt;The token, if available. If not available pass null or an empty string&lt;/param&gt;
        /// &lt;param name="tokenSecret"&gt;The token secret, if available. If not available pass null or an empty string&lt;/param&gt;
        /// &lt;param name="httpMethod"&gt;The http method used. Must be a valid HTTP method verb (POST,GET,PUT, etc)&lt;/param&gt;
        /// &lt;param name="signatureType"&gt;The signature type. To use the default values use &lt;see cref="OAuthBase.SignatureTypes"&gt;OAuthBase.SignatureTypes&lt;/see&gt;.&lt;/param&gt;
        /// &lt;returns&gt;The signature base&lt;/returns&gt;
        public string GenerateSignatureBase(Uri url, string consumerKey, string token, string tokenSecret, string httpMethod, string timeStamp, string nonce, string signatureType, out string normalizedUrl, out string normalizedRequestParameters) {
            if (token == null) {
                token = string.Empty;
            }

            if (tokenSecret == null) {
                tokenSecret = string.Empty;
            }

            if (string.IsNullOrEmpty(consumerKey)) {
                throw new ArgumentNullException("consumerKey");
            }

            if (string.IsNullOrEmpty(httpMethod)) {
                throw new ArgumentNullException("httpMethod");
            }

            if (string.IsNullOrEmpty(signatureType)) {
                throw new ArgumentNullException("signatureType");
            }

            normalizedUrl = null;
            normalizedRequestParameters = null;

            List&lt;QueryParameter&gt; parameters = GetQueryParameters(url.Query);
            parameters.Add(new QueryParameter(OAuthVersionKey, OAuthVersion));
            parameters.Add(new QueryParameter(OAuthNonceKey, nonce));
            parameters.Add(new QueryParameter(OAuthTimestampKey, timeStamp));
            parameters.Add(new QueryParameter(OAuthSignatureMethodKey, signatureType));
            parameters.Add(new QueryParameter(OAuthConsumerKeyKey, consumerKey));

            if (!string.IsNullOrEmpty(token)) {
                parameters.Add(new QueryParameter(OAuthTokenKey, token));
            }

            parameters.Sort(new QueryParameterComparer());

            normalizedUrl = string.Format("{0}://{1}", url.Scheme, url.Host);
            if (!((url.Scheme == "http" &amp;&amp; url.Port == 80) || (url.Scheme == "https" &amp;&amp; url.Port == 443)))
            {
                normalizedUrl += ":" + url.Port;
            }
            normalizedUrl += url.AbsolutePath;
            normalizedRequestParameters = NormalizeRequestParameters(parameters);

            StringBuilder signatureBase = new StringBuilder();          
            signatureBase.AppendFormat("{0}&amp;", httpMethod.ToUpper());
            signatureBase.AppendFormat("{0}&amp;", UrlEncode(normalizedUrl));
            signatureBase.AppendFormat("{0}", UrlEncode(normalizedRequestParameters));

            return signatureBase.ToString();
        }

        /// &lt;summary&gt;
        /// Generate the signature value based on the given signature base and hash algorithm
        /// &lt;/summary&gt;
        /// &lt;param name="signatureBase"&gt;The signature based as produced by the GenerateSignatureBase method or by any other means&lt;/param&gt;
        /// &lt;param name="hash"&gt;The hash algorithm used to perform the hashing. If the hashing algorithm requires initialization or a key it should be set prior to calling this method&lt;/param&gt;
        /// &lt;returns&gt;A base64 string of the hash value&lt;/returns&gt;
        public string GenerateSignatureUsingHash(string signatureBase, HashAlgorithm hash) {
            return ComputeHash(hash, signatureBase);
        }

        /// &lt;summary&gt;
        /// Generates a signature using the HMAC-SHA1 algorithm
        /// &lt;/summary&gt;      
        /// &lt;param name="url"&gt;The full url that needs to be signed including its non OAuth url parameters&lt;/param&gt;
        /// &lt;param name="consumerKey"&gt;The consumer key&lt;/param&gt;
        /// &lt;param name="consumerSecret"&gt;The consumer seceret&lt;/param&gt;
        /// &lt;param name="token"&gt;The token, if available. If not available pass null or an empty string&lt;/param&gt;
        /// &lt;param name="tokenSecret"&gt;The token secret, if available. If not available pass null or an empty string&lt;/param&gt;
        /// &lt;param name="httpMethod"&gt;The http method used. Must be a valid HTTP method verb (POST,GET,PUT, etc)&lt;/param&gt;
        /// &lt;returns&gt;A base64 string of the hash value&lt;/returns&gt;
        public string GenerateSignature(Uri url, string consumerKey, string consumerSecret, string token, string tokenSecret, string httpMethod, string timeStamp, string nonce, out string normalizedUrl, out string normalizedRequestParameters) {            
            return GenerateSignature(url, consumerKey, consumerSecret, token, tokenSecret, httpMethod, timeStamp, nonce, SignatureTypes.HMACSHA1, out normalizedUrl, out normalizedRequestParameters);
        }

        /// &lt;summary&gt;
        /// Generates a signature using the specified signatureType 
        /// &lt;/summary&gt;      
        /// &lt;param name="url"&gt;The full url that needs to be signed including its non OAuth url parameters&lt;/param&gt;
        /// &lt;param name="consumerKey"&gt;The consumer key&lt;/param&gt;
        /// &lt;param name="consumerSecret"&gt;The consumer seceret&lt;/param&gt;
        /// &lt;param name="token"&gt;The token, if available. If not available pass null or an empty string&lt;/param&gt;
        /// &lt;param name="tokenSecret"&gt;The token secret, if available. If not available pass null or an empty string&lt;/param&gt;
        /// &lt;param name="httpMethod"&gt;The http method used. Must be a valid HTTP method verb (POST,GET,PUT, etc)&lt;/param&gt;
        /// &lt;param name="signatureType"&gt;The type of signature to use&lt;/param&gt;
        /// &lt;returns&gt;A base64 string of the hash value&lt;/returns&gt;
        public string GenerateSignature(Uri url, string consumerKey, string consumerSecret, string token, string tokenSecret, string httpMethod, string timeStamp, string nonce, SignatureTypes signatureType, out string normalizedUrl, out string normalizedRequestParameters) {
            normalizedUrl = null;
            normalizedRequestParameters = null;

            switch (signatureType) {
                case SignatureTypes.PLAINTEXT:                  
                    return HttpUtility.UrlEncode(string.Format("{0}&amp;{1}", consumerSecret, tokenSecret));
                case SignatureTypes.HMACSHA1:                   
                    string signatureBase = GenerateSignatureBase(url, consumerKey, token, tokenSecret, httpMethod, timeStamp, nonce, HMACSHA1SignatureType, out normalizedUrl, out normalizedRequestParameters);

                    HMACSHA1 hmacsha1 = new HMACSHA1();
                    hmacsha1.Key = Encoding.ASCII.GetBytes(string.Format("{0}&amp;{1}", UrlEncode(consumerSecret), string.IsNullOrEmpty(tokenSecret) ? "" : UrlEncode(tokenSecret)));

                    return GenerateSignatureUsingHash(signatureBase, hmacsha1);                                        
                case SignatureTypes.RSASHA1:
                    throw new NotImplementedException();
                default:
                    throw new ArgumentException("Unknown signature type", "signatureType");
            }
        }

        /// &lt;summary&gt;
        /// Generate the timestamp for the signature        
        /// &lt;/summary&gt;
        /// &lt;returns&gt;&lt;/returns&gt;
        public virtual string GenerateTimeStamp() {
            // Default implementation of UNIX time of the current UTC time
            TimeSpan ts = DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0, 0);
            return Convert.ToInt64(ts.TotalSeconds).ToString();            
        }

        /// &lt;summary&gt;
        /// Generate a nonce
        /// &lt;/summary&gt;
        /// &lt;returns&gt;&lt;/returns&gt;
        public virtual string GenerateNonce() {
            // Just a simple implementation of a random number between 123400 and 9999999
            return random.Next(123400, 9999999).ToString();            
        }

    }
}
</code></pre>
