Tuesday, August 27, 2013

remove extra space between two words using C# 

RegexOptions options = RegexOptions.None;
Regex regex = new Regex(@"[ ]{2,}", options);     
tempo = regex.Replace(tempo, @" ");
 or even:
myString = Regex.Replace(myString, @"\s+", " ");
By at No comments:

Thursday, August 22, 2013

Add CData Section to existing xml string in C#

public class Example
    {
        static void Main(string[] args)
        {
           //Create the xml in the XmlDocument
            XmlDocument dom = new XmlDocument();
            //Root of xml
            XmlElement root = dom.CreateElement("root");
            //Sub nodes
            XmlElement id = dom.CreateElement("id");
            id.InnerText = "1";
            XmlElement name = dom.CreateElement("name");
            XmlCDataSection cdata = dom.CreateCDataSection("<test>");
            name.AppendChild(cdata);
            root.AppendChild(id);
            root.AppendChild(name);
            dom.AppendChild(root);
          
            //Output to the StringBuilder
            StringBuilder sbu = new StringBuilder();
            StringWriter sw = new StringWriter(sbu);
            XmlTextWriter writer = new XmlTextWriter(sw);
            writer.Formatting = Formatting.Indented;
            dom.WriteTo(writer);
            //Output this xml
            Console.WriteLine(sbu.ToString());

            //Read this xml string out
            XmlDocument doc2 = new XmlDocument();
            doc2.LoadXml(sbu.ToString());
        }
     }
By at No comments:

Wednesday, August 14, 2013

get everything after a certain index in string c# 

string str = "MyNamespace.SubNameSpace.MyClassName";
string str1 = str.Substring(str.LastIndexOf('.') + 1);
By at No comments:

Friday, August 9, 2013

Remove Duplicate value from textbox by javascript

javascript function
<script type="text/javascript">

function dublicate(control){
   
      var tmipwords = document.getElementById(control).value;
      var arrTracemd = tmipwords.split(/,/);
     
      var arrNewTracemd = [];
      var seenTracemd = {};
      for(var i=0;i<arrTracemd.length;i++)
      {
     
            if (!seenTracemd[arrTracemd[i]])
            {
            seenTracemd[arrTracemd[i]]=true;
            arrNewTracemd.push(arrTracemd[i]);
          }
    }
    var finalv=arrNewTracemd.join(","); 
    document.getElementById(control).value = finalv;

}


</script>

Check button put on html
<asp:TextBox runat="server" ID="txtSkillKeyWord"></asp:TextBox>
(Value should be separate with (,))
<input type="button" onclick="dublicate('txtSkillKeyWord');" value="Check Duplicate">





By at No comments:

Thursday, August 8, 2013

maxstringcontentlength, maxbuffersize, and maxreceivedmessagesize (and others) in WCF

MaxDepth – A positive integer that specifies the maximum nested node depth per read. The default value is 32. Maximum is 2147483647.
MaxBufferSize – Gets or sets the maximum size of the buffer to use. For buffered messages this value is the same as MaxReceivedMessageSize. For streamed messages, this value is the maximum size of the SOAP headers, which must be read in buffered mode. Default value is 65536. Maximum value is 2147483647.
MaxReceivedMessageSize -  Gets or sets the maximum size for a message that can be processed by the binding. Must match what you put in the MaxBufferSize.  Default value is 65536. Maximum is 2147483647.
MaxStringContentLength – A positive integer that specifies the maximum characters allowed in XML element content. Default value is 8192. Maximum is 2147483647. This property actually belongs to the XMLReader that is called under the covers by WCF.  When deserializing the message this property is used to block messages over a certain size.
MaxArrayLength – A positive integer that specifies the maximum allowed array length of data being received by WCF from a client. The default value is 16384. Maximum is 2147483647.
MaxBytesPerRead – A positive integer that specifies the maximum allowed bytes returned per read. The default value is 4096. Maximum is 2147483647.
MaxNameTableCharCount– A positive integer that specifies the maximum characters allowed in a table name. The default value is 16384. Maximum is 2147483647.
MaxArrayLength – A positive integer that specifies the maximum allowed array length of data being received by WCF from a client. The default value is 16384. Maximum is 2147483647.



bindings>
   <webHttpBinding>
    <binding name="wsHttpBinding" closeTimeout="00:01:00"
       openTimeout="00:01:00" receiveTimeout="00:10:00" sendTimeout="00:01:00"
       allowCookies="false" bypassProxyOnLocal="false"
       hostNameComparisonMode="StrongWildcard"
       maxBufferSize="2147483647" maxBufferPoolSize="2147483647"
       maxReceivedMessageSize="2147483647"
       transferMode="Buffered"
       useDefaultWebProxy="true">
     <readerQuotas maxDepth="2147483647" maxStringContentLength="2147483647"
                          maxArrayLength="2147483647"
                          maxBytesPerRead="2147483647" maxNameTableCharCount="2147483647" />
    </binding>
   </webHttpBinding>
  </bindings>




Give same binding on server and on client side 
otherwise you will get error..
By at No comments:

Wednesday, August 7, 2013

Get Yahoo Contact for C#



Get Yahoo Contact for C#

Create new Website

Create AppCode Folder

Create OAuthBase.cs in AppCode Folder like
using System;
using System.Security.Cryptography;
using System.Collections.Generic;
using System.Text;
using System.Web;

namespace OAuth
{
    public class OAuthBase
    {

        /// <summary>
        /// Provides a predefined set of algorithms that are supported officially by the protocol
        /// </summary>
        public enum SignatureTypes
        {
            HMACSHA1,
            PLAINTEXT,
            RSASHA1
        }

        /// <summary>
        /// Provides an internal structure to sort the query parameter
        /// </summary>
        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; }
            }
        }

        /// <summary>
        /// Comparer class used to perform the sorting of the query parameters
        /// </summary>
        protected class QueryParameterComparer : IComparer<QueryParameter>
        {

            #region IComparer<QueryParameter> 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-_.~";

        /// <summary>
        /// Helper function to compute a hash value
        /// </summary>
        /// <param name="hashAlgorithm">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</param>
        /// <param name="data">The data to hash</param>
        /// <returns>a Base64 string of the hash value</returns>
        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);
        }

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

            List<QueryParameter> result = new List<QueryParameter>();

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

            return result;
        }

        /// <summary>
        /// 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
        /// </summary>
        /// <param name="value">The value to Url encode</param>
        /// <returns>Returns a Url encoded string</returns>
        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();
        }

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

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

            return sb.ToString();
        }

        /// <summary>
        /// Generate the signature base that is used to produce the signature
        /// </summary>
        /// <param name="url">The full url that needs to be signed including its non OAuth url parameters</param>
        /// <param name="consumerKey">The consumer key</param>       
        /// <param name="token">The token, if available. If not available pass null or an empty string</param>
        /// <param name="tokenSecret">The token secret, if available. If not available pass null or an empty string</param>
        /// <param name="httpMethod">The http method used. Must be a valid HTTP method verb (POST,GET,PUT, etc)</param>
        /// <param name="signatureType">The signature type. To use the default values use <see cref="OAuthBase.SignatureTypes">OAuthBase.SignatureTypes</see>.</param>
        /// <returns>The signature base</returns>
        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<QueryParameter> 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" && url.Port == 80) || (url.Scheme == "https" && url.Port == 443)))
            {
                normalizedUrl += ":" + url.Port;
            }
            normalizedUrl += url.AbsolutePath;
            normalizedRequestParameters = NormalizeRequestParameters(parameters);

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

            return signatureBase.ToString();
        }

        /// <summary>
        /// Generate the signature value based on the given signature base and hash algorithm
        /// </summary>
        /// <param name="signatureBase">The signature based as produced by the GenerateSignatureBase method or by any other means</param>
        /// <param name="hash">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</param>
        /// <returns>A base64 string of the hash value</returns>
        public string GenerateSignatureUsingHash(string signatureBase, HashAlgorithm hash)
        {
            return ComputeHash(hash, signatureBase);
        }

        /// <summary>
        /// Generates a signature using the HMAC-SHA1 algorithm
        /// </summary>       
        /// <param name="url">The full url that needs to be signed including its non OAuth url parameters</param>
        /// <param name="consumerKey">The consumer key</param>
        /// <param name="consumerSecret">The consumer seceret</param>
        /// <param name="token">The token, if available. If not available pass null or an empty string</param>
        /// <param name="tokenSecret">The token secret, if available. If not available pass null or an empty string</param>
        /// <param name="httpMethod">The http method used. Must be a valid HTTP method verb (POST,GET,PUT, etc)</param>
        /// <returns>A base64 string of the hash value</returns>
        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);
        }

        /// <summary>
        /// Generates a signature using the specified signatureType
        /// </summary>       
        /// <param name="url">The full url that needs to be signed including its non OAuth url parameters</param>
        /// <param name="consumerKey">The consumer key</param>
        /// <param name="consumerSecret">The consumer seceret</param>
        /// <param name="token">The token, if available. If not available pass null or an empty string</param>
        /// <param name="tokenSecret">The token secret, if available. If not available pass null or an empty string</param>
        /// <param name="httpMethod">The http method used. Must be a valid HTTP method verb (POST,GET,PUT, etc)</param>
        /// <param name="signatureType">The type of signature to use</param>
        /// <returns>A base64 string of the hash value</returns>
        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}&{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}&{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");
            }
        }

        /// <summary>
        /// Generate the timestamp for the signature       
        /// </summary>
        /// <returns></returns>
      
        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);
            string timeStamp = ts.TotalSeconds.ToString();
            timeStamp = timeStamp.Substring(0, timeStamp.IndexOf("."));
            return timeStamp;
        }


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

    }
}



Download OAuth.Net.Common.dll and reference to bin folder

Create oauth-test.aspx page like
<%@ Page Language="C#" AutoEventWireup="true" CodeFile="oauth-test.aspx.cs" Inherits="test_oauth_test" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
    <title>Untitled Page</title>
</head>
<body>
    <form id="form1" runat="server">
    <div>
        <asp:Button ID="Button1" runat="server" Text="Connect to Yahoo!" OnClick="Button1_Click" />
        <asp:Label runat="server" ID="ResponseMessage1"></asp:Label>
        <asp:GridView ID="grvMyFriends" runat="server" AutoGenerateColumns="false" CellPadding="5"
            GridLines="None">
            <HeaderStyle BackColor="#025A8E" Font-Bold="true" ForeColor="White" HorizontalAlign="Left" />
            <RowStyle BackColor="#DFDFDF" HorizontalAlign="Left" />
            <AlternatingRowStyle BackColor="#F0F0F0" HorizontalAlign="Left" />
            <Columns>
                <asp:TemplateField HeaderText="Email">
                    <ItemTemplate>
                        <%# Container.DataItem %>
                    </ItemTemplate>
                </asp:TemplateField>
            </Columns>
            <EmptyDataTemplate>
                No Friend List Found
            </EmptyDataTemplate>
        </asp:GridView>
    </div>
    </form>
</body>
</html>
Create oauth-test.aspx.cs file like
using System;
using System.Configuration;
using System.Data;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.HtmlControls;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Net;
using System.IO;
using OAuth.Net.Common;
using OAuth.Net.Components;
using OAuth.Net.Consumer;
using OAuth;
using System.Text;
using System.Xml;
using System.Collections;
using System.Collections.Generic;
using System.Net.Mail;
using System.Text.RegularExpressions;

public partial class test_oauth_test : System.Web.UI.Page
{

    string ConsumerKey = ConfigurationManager.AppSettings["ConsumerKey"].ToString();
    string ConsumerSecret = ConfigurationManager.AppSettings["ConsumerSecret"].ToString();
   
   

    public string OauthVerifier
    {
        get
        {
            try
            {
                if (!string.IsNullOrEmpty(Session["Oauth_Verifier"].ToString()))
                    return Session["Oauth_Verifier"].ToString();
                else
                    return string.Empty;
            }
            catch
            {
                return string.Empty;
            }
        }
        set
        {
            Session["Oauth_Verifier"] = value;
        }
    }
    public string OauthToken
    {
        get
        {
            if (!string.IsNullOrEmpty(Session["Oauth_Token"].ToString()))
                return Session["Oauth_Token"].ToString();
            else
                return string.Empty;
        }
        set
        {
            Session["Oauth_Token"] = value;
        }
    }
    public string OauthTokenSecret
    {
        get
        {
            if (!string.IsNullOrEmpty(Session["Oauth_Token_Secret"].ToString()))
                return Session["Oauth_Token_Secret"].ToString();
            else
                return string.Empty;
        }
        set
        {
            Session["Oauth_Token_Secret"] = value;
        }
    }
    public string OauthSessionHandle
    {
        get
        {
            if (!string.IsNullOrEmpty(Session["Oauth_Session_Handle"].ToString()))
                return Session["Oauth_Session_Handle"].ToString();
            else
                return string.Empty;
        }
        set
        {
            Session["Oauth_Session_Handle"] = value;
        }
    }
    public string OauthYahooGuid
    {
        get
        {
            try
            {
                if (!string.IsNullOrEmpty(Session["Oauth_Yahoo_Guid"].ToString()))
                    return Session["Oauth_Yahoo_Guid"].ToString();
                else
                    return string.Empty;
            }
            catch
            {
                return string.Empty;
            }
        }
        set
        {
            Session["Oauth_Yahoo_Guid"] = value;
        }
    }

    protected void Page_Load(object sender, EventArgs e)
    {
        if (!IsPostBack)
        {
            string oauth_token = Request["oauth_token"];
            string oauth_verifier = Request["oauth_verifier"];

            if (!string.IsNullOrEmpty(oauth_verifier) && oauth_verifier != "")
            {
                Button1.Visible = false;
                OauthToken = oauth_token;
                OauthVerifier = oauth_verifier;
                RegisterStartupScript("refresh", "<script type='text/javascript'>window.opener.location = 'oauth-test.aspx'; self.close();</script>");
            }
            else if (!string.IsNullOrEmpty(OauthVerifier))
            {
                Button1.Visible = false;
                if (string.IsNullOrEmpty(OauthYahooGuid))
                    GetAccessToken(OauthToken, OauthVerifier);
                //RefreshToken();
                RetriveContacts();
            }
        }

    }
    private string GetRequestToken()
    {
        string authorizationUrl = string.Empty;
        OAuthBase oauth = new OAuthBase();

        Uri uri = new Uri("https://api.login.yahoo.com/oauth/v2/get_request_token");
        string nonce = oauth.GenerateNonce();
        string timeStamp = oauth.GenerateTimeStamp();
        string normalizedUrl;
        string normalizedRequestParameters;
        string sig = oauth.GenerateSignature(uri, ConsumerKey, ConsumerSecret, string.Empty, string.Empty, "GET", timeStamp, nonce, OAuthBase.SignatureTypes.PLAINTEXT, out normalizedUrl, out normalizedRequestParameters); //OAuthBase.SignatureTypes.HMACSHA1
        StringBuilder sbRequestToken = new StringBuilder(uri.ToString());
        sbRequestToken.AppendFormat("?oauth_nonce={0}&", nonce);
        sbRequestToken.AppendFormat("oauth_timestamp={0}&", timeStamp);
        sbRequestToken.AppendFormat("oauth_consumer_key={0}&", ConsumerKey);
        sbRequestToken.AppendFormat("oauth_signature_method={0}&", "PLAINTEXT"); //HMAC-SHA1
        sbRequestToken.AppendFormat("oauth_signature={0}&", sig);
        sbRequestToken.AppendFormat("oauth_version={0}&", "1.0");
        sbRequestToken.AppendFormat("oauth_callback={0}", HttpUtility.UrlEncode("http://localhost:7450/GetYahooContact/oauth-test.aspx"));
        //Response.Write(sbRequestToken.ToString());
        //Response.End();

        try
        {
            string returnStr = string.Empty;
            string[] returnData;

            HttpWebRequest req = (HttpWebRequest)WebRequest.Create(sbRequestToken.ToString());
            HttpWebResponse res = (HttpWebResponse)req.GetResponse();
            StreamReader streamReader = new StreamReader(res.GetResponseStream());
            returnStr = streamReader.ReadToEnd();
            returnData = returnStr.Split(new Char[] { '&' });
            //Response.Write(returnStr);

            int index;
            if (returnData.Length > 0)
            {
                //index = returnData[0].IndexOf("=");
                //string oauth_token = returnData[0].Substring(index + 1);
                //Session["Oauth_Token"] = oauth_token;

                index = returnData[1].IndexOf("=");
                string oauth_token_secret = returnData[1].Substring(index + 1);
                OauthTokenSecret = oauth_token_secret;

                //index = returnData[2].IndexOf("=");
                //int oauth_expires_in;
                //Int32.TryParse(returnData[2].Substring(index + 1), out oauth_expires_in);
                //Session["Oauth_Expires_In"] = oauth_expires_in;

                index = returnData[3].IndexOf("=");
                string oauth_request_auth_url = returnData[3].Substring(index + 1);
                authorizationUrl = HttpUtility.UrlDecode(oauth_request_auth_url);
            }
        }
        catch (WebException ex)
        {
            Response.Write(ex.Message);
        }
        return authorizationUrl;
    }
    private void RedirectUserForAuthorization(string authorizationUrl)
    {
        //Response.Redirect(authorizationUrl);
        RegisterStartupScript("openwin", "<script type='text/javascript'>window.open('" + authorizationUrl + "','mywindow', 'left=250,top=50,menubar=0,resizable=0,location=1,toolbar=0,status=1,scrollbars=0,width=500,height=455');</script>");
    }
    private void GetAccessToken(string oauth_token, string oauth_verifier)
    {
        OAuthBase oauth = new OAuthBase();

        Uri uri = new Uri("https://api.login.yahoo.com/oauth/v2/get_token");
        string nonce = oauth.GenerateNonce();
        string timeStamp = oauth.GenerateTimeStamp();
        string sig = ConsumerSecret + "%26" + OauthTokenSecret;

        StringBuilder sbAccessToken = new StringBuilder(uri.ToString());
        sbAccessToken.AppendFormat("?oauth_consumer_key={0}&", ConsumerKey);
        sbAccessToken.AppendFormat("oauth_signature_method={0}&", "PLAINTEXT"); //HMAC-SHA1
        sbAccessToken.AppendFormat("oauth_signature={0}&", sig);
        sbAccessToken.AppendFormat("oauth_timestamp={0}&", timeStamp);
        sbAccessToken.AppendFormat("oauth_version={0}&", "1.0");
        sbAccessToken.AppendFormat("oauth_token={0}&", oauth_token);
        sbAccessToken.AppendFormat("oauth_nonce={0}&", nonce);
        sbAccessToken.AppendFormat("oauth_verifier={0}", oauth_verifier);
        //Response.Write(sbAccessToken.ToString());
        //Response.End();

        try
        {
            string returnStr = string.Empty;
            string[] returnData;

            HttpWebRequest req = (HttpWebRequest)WebRequest.Create(sbAccessToken.ToString());
            HttpWebResponse res = (HttpWebResponse)req.GetResponse();
            StreamReader streamReader = new StreamReader(res.GetResponseStream());
            returnStr = streamReader.ReadToEnd();
            returnData = returnStr.Split(new Char[] { '&' });
            //Response.Write(returnStr);
            //Response.End();

            int index;
            if (returnData.Length > 0)
            {
                index = returnData[0].IndexOf("=");
                OauthToken = returnData[0].Substring(index + 1);

                index = returnData[1].IndexOf("=");
                string oauth_token_secret = returnData[1].Substring(index + 1);
                OauthTokenSecret = oauth_token_secret;

                //index = returnData[2].IndexOf("=");
                //int oauth_expires_in;
                //Int32.TryParse(returnData[2].Substring(index + 1), out oauth_expires_in);

                index = returnData[3].IndexOf("=");
                string oauth_session_handle = returnData[3].Substring(index + 1);
                OauthSessionHandle = oauth_session_handle;

                //index = returnData[4].IndexOf("=");
                //int oauth_authorization_expires_in;
                //Int32.TryParse(returnData[4].Substring(index + 1), out oauth_authorization_expires_in);

                index = returnData[5].IndexOf("=");
                string xoauth_yahoo_guid = returnData[5].Substring(index + 1);
                OauthYahooGuid = xoauth_yahoo_guid;
            }
        }
        catch (WebException ex)
        {
            Response.Write(ex.Message);
        }
    }
    private void RefreshToken()
    {
        OAuthBase oauth = new OAuthBase();

        Uri uri = new Uri("https://api.login.yahoo.com/oauth/v2/get_token");
        string nonce = oauth.GenerateNonce();
        string timeStamp = oauth.GenerateTimeStamp();
        string sig = ConsumerSecret + "%26" + OauthTokenSecret;

        StringBuilder sbrefreshToken = new StringBuilder(uri.ToString());
        sbrefreshToken.AppendFormat("?oauth_consumer_key={0}&", ConsumerKey);
        sbrefreshToken.AppendFormat("oauth_signature_method={0}&", "PLAINTEXT"); //HMAC-SHA1
        sbrefreshToken.AppendFormat("oauth_signature={0}&", sig);
        sbrefreshToken.AppendFormat("oauth_timestamp={0}&", timeStamp);
        sbrefreshToken.AppendFormat("oauth_version={0}&", "1.0");
        sbrefreshToken.AppendFormat("oauth_token={0}&", OauthToken);
        sbrefreshToken.AppendFormat("oauth_session_handle={0}&", OauthSessionHandle);
        sbrefreshToken.AppendFormat("oauth_nonce={0}", nonce);

        try
        {
            string returnStr = string.Empty;
            string[] returnData;

            HttpWebRequest req = (HttpWebRequest)WebRequest.Create(sbrefreshToken.ToString());
            HttpWebResponse res = (HttpWebResponse)req.GetResponse();
            StreamReader streamReader = new StreamReader(res.GetResponseStream());
            returnStr = streamReader.ReadToEnd();
            returnData = returnStr.Split(new Char[] { '&' });
            //Response.Write(returnStr);

            int index;
            if (returnData.Length > 0)
            {
                index = returnData[0].IndexOf("=");
                string oauth_token = returnData[0].Substring(index + 1);
                OauthToken = oauth_token;

                index = returnData[1].IndexOf("=");
                string oauth_token_secret = returnData[1].Substring(index + 1);
                OauthTokenSecret = oauth_token_secret;

                //index = returnData[2].IndexOf("=");
                //int oauth_expires_in;
                //Int32.TryParse(returnData[2].Substring(index + 1), out oauth_expires_in);

                index = returnData[3].IndexOf("=");
                string oauth_session_handle = returnData[3].Substring(index + 1);
                OauthSessionHandle = oauth_session_handle;

                //index = returnData[4].IndexOf("=");
                //int oauth_authorization_expires_in;
                //Int32.TryParse(returnData[4].Substring(index + 1), out oauth_authorization_expires_in);

                index = returnData[5].IndexOf("=");
                string xoauth_yahoo_guid = returnData[5].Substring(index + 1);
                OauthYahooGuid = xoauth_yahoo_guid;
            }
        }
        catch (WebException ex)
        {
            Response.Write(ex.Message);
        }
    }
    private void RetriveContacts()
    {
        OAuthBase oauth = new OAuthBase();

        Uri uri = new Uri("http://social.yahooapis.com/v1/user/" + OauthYahooGuid + "/contacts?format=XML");
        string nonce = oauth.GenerateNonce();
        string timeStamp = oauth.GenerateTimeStamp();
        string normalizedUrl;
        string normalizedRequestParameters;
        string sig = oauth.GenerateSignature(uri, ConsumerKey, ConsumerSecret, OauthToken, OauthTokenSecret, "GET", timeStamp, nonce, OAuthBase.SignatureTypes.HMACSHA1, out normalizedUrl, out normalizedRequestParameters);

        StringBuilder sbGetContacts = new StringBuilder(uri.ToString());

        //Response.Write("URL: " + sbGetContacts.ToString());
        //Response.End();

        try
        {
            string returnStr = string.Empty;
            HttpWebRequest req = (HttpWebRequest)WebRequest.Create(sbGetContacts.ToString());
            req.Method = "GET";

            string authHeader = "Authorization: OAuth " +
            "realm=\"yahooapis.com\"" +
            ",oauth_consumer_key=\"" + ConsumerKey + "\"" +
            ",oauth_nonce=\"" + nonce + "\"" +
            ",oauth_signature_method=\"HMAC-SHA1\"" +
            ",oauth_timestamp=\"" + timeStamp + "\"" +
            ",oauth_token=\"" + OauthToken + "\"" +
            ",oauth_version=\"1.0\"" +
            ",oauth_signature=\"" + HttpUtility.UrlEncode(sig) + "\"";

            //Response.Write("</br>Headers: " + authHeader);

            req.Headers.Add(authHeader);

            HttpWebResponse res = (HttpWebResponse)req.GetResponse();
            StreamReader streamReader = new StreamReader(res.GetResponseStream());
            returnStr = streamReader.ReadToEnd();
            XmlDocument xmldoc = new XmlDocument();
            xmldoc.LoadXml(returnStr);
            XmlNodeList elemList = xmldoc.DocumentElement.GetElementsByTagName("fields");

            ArrayList emails = new ArrayList();
            for (int i = 0; i < elemList.Count; i++)
            {
                if (elemList[i].ChildNodes[1].InnerText == "email")
                    emails.Add(elemList[i].ChildNodes[2].InnerText);
                //Response.Write(elemList[i].ChildNodes[2].InnerText + "<br/>");
            }
            grvMyFriends.DataSource = emails;
            grvMyFriends.DataBind();
        }
        #region error
        catch (WebException ex)
        {
            //Response.Write(ex.Message);
            Response.Write("<br/>" + ex.Message + "</br>xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx");
            Response.Write("<br/>length: " + ex.Source.Length.ToString());
            Response.Write("<br/>stack trace: " + ex.StackTrace);
            Response.Write("<br/>status: " + ex.Status.ToString());
            HttpWebResponse res = (HttpWebResponse)ex.Response;
            int code = Convert.ToInt32(res.StatusCode);

            Response.Write("<br/>Status Code: (" + code.ToString() + ") " + res.StatusCode.ToString());
            Response.Write("<br/>Status Description: " + res.StatusDescription);

            if (ex.InnerException != null)
            {
                Response.Write("<br/>innerexception: " + ex.InnerException.Message);
            }

            if (ex.Source.Length > 0)
                Response.Write("<br/>source: " + ex.Source.ToString());

            if (res != null)
            {
                for (int i = 0; i < res.Headers.Count; i++)
                {
                    Response.Write("<br/>headers: " + i.ToString() + ": " + res.Headers[i]);
                }
            }
        }
        #endregion error
    }
    protected void Button1_Click(object sender, EventArgs e)
    {
        string authorizationUrl = string.Empty;
        authorizationUrl = GetRequestToken();
        RedirectUserForAuthorization(authorizationUrl);
    }
  
}




Regards,                           
Manish Siddhapara || +91-97258 78998


By at No comments:
Subscribe to: Posts (Atom)

Opps Part 1 : Abstraction

  Abstraction in C# is a fundamental concept of object-oriented programming (OOP) that allows developers t...