Posts Tagged ‘technology’

Read Rss feed in c#

Posted: August 9, 2012 in ASP.net, C#
Tags: , , , , ,

In this Article I am going to explain how you can read rss xml file into c# . It is very easy , you just have to follow few steps to catch xml feed into your code .

Here i`ll show you how can catch the rss feed , then you can display it on your website as you want .

to implement it you need to understand the function i am writing below :-

public void TestFeed()
{
var NewsRSS = XDocument.Load(“https://dotnetgeekblog.wordpress.com/feed/”); // to load XML file in variable
var rssItemsList = from d in NewsRSS.Descendants(“item”)
select d;
int count = rssItemsList.Count(); //get the count of feed items
foreach (var rssItem in rssItemsList)
{
XElement pubdate = rssItem.Descendants(“pubDate”).FirstOrDefault(); //to get the published date of news
string publishDate = string.Empty;
if (pubdate != null)
{
publishDate = pubdate.Value;
DateTime time = DateTime.Now;
string dayofWeek = time.DayOfWeek.ToString();
string dayofmonth = time.Month.ToString();
string year = time.Year.ToString();
}
string title = rssItem.Descendants(“title”).FirstOrDefault() == null ? string.Empty : rssItem.Descendants(“title”).FirstOrDefault().Value; //to set values in variable
string link = rssItem.Descendants(“link”).FirstOrDefault() == null ? string.Empty : rssItem.Descendants(“link”).FirstOrDefault().Value;//to set values in variable
string description = rssItem.Descendants(“description”).FirstOrDefault() == null ? string.Empty : rssItem.Descendants(“description”).FirstOrDefault().Value;
string guid = rssItem.Descendants(“guid”).FirstOrDefault() == null ? string.Empty : rssItem.Descendants(“guid”).FirstOrDefault().Value;//to set values in variable
string summarry = string.Empty;
if (!string.IsNullOrEmpty(description))
{
int length = description.Length;
if (length > 200)
summarry = description.Substring(0, 199) + “…”;
else
summarry = description;
}
}
}

 

This is just an example . Now You Can Play With It As you Want 😉

Hope This Post Will Help you Somehow . . 🙂

Waiting For Your Valuable Feedback.

In This Blog I`m going to discuss how we can make custom captcha image .. We can do this by simple coding only . I will tell you one simple method how we can make captcha image ..

We can do this in following steps. This time i have written all comments 🙂

Step 1 : Make a class CaptchaImage in you App_Code Folder . and write the following code in that class .

///

/// Summary description for CaptchaImage.
///

 

public class CaptchaImage
{
// Public properties (all read-only).
public string Text
{
get { return this.text; }
}
public Bitmap Image
{
get { return this.image; }
}
public int Width
{
get { return this.width; }
}
public int Height
{
get { return this.height; }
}

// Internal properties.
private string text;
private int width;
private int height;
private string familyName;
private Bitmap image;

// For generating random numbers.
private Random random = new Random();

// ====================================================================
// Initializes a new instance of the CaptchaImage class using the
// specified text, width and height.
// ====================================================================
public CaptchaImage(string s, int width, int height)
{
this.text = s;
this.SetDimensions(width, height);
this.GenerateImage();
}

// ====================================================================
// Initializes a new instance of the CaptchaImage class using the
// specified text, width, height and font family.
// ====================================================================
public CaptchaImage(string s, int width, int height, string familyName)
{
this.text = s;
this.SetDimensions(width, height);
this.SetFamilyName(familyName);
this.GenerateImage();
}

// ====================================================================
// This member overrides Object.Finalize.
// ====================================================================
~CaptchaImage()
{
Dispose(false);
}

// ====================================================================
// Releases all resources used by this object.
// ====================================================================
public void Dispose()
{
GC.SuppressFinalize(this);
this.Dispose(true);
}

// ====================================================================
// Custom Dispose method to clean up unmanaged resources.
// ====================================================================
protected virtual void Dispose(bool disposing)
{
if (disposing)
// Dispose of the bitmap.
this.image.Dispose();
}

// ====================================================================
// Sets the image width and height.
// ====================================================================
private void SetDimensions(int width, int height)
{
// Check the width and height.
if (width <= 0)
throw new ArgumentOutOfRangeException(“width”, width, “Argument out of range, must be greater than zero.”);
if (height <= 0) throw new ArgumentOutOfRangeException(“height”, height, “Argument out of range, must be greater than zero.”); this.width = width; this.height = height; } // ==================================================================== // Sets the font used for the image text. // ==================================================================== private void SetFamilyName(string familyName) { // If the named font is not installed, default to a system font. try { Font font = new Font(this.familyName, 12F); this.familyName = familyName; font.Dispose(); } catch (Exception ex) { this.familyName = System.Drawing.FontFamily.GenericSerif.Name; } } // ==================================================================== // Creates the bitmap image. // ==================================================================== private void GenerateImage() { // Create a new 32-bit bitmap image. Bitmap bitmap = new Bitmap(this.width, this.height, PixelFormat.Format32bppArgb); // Create a graphics object for drawing. Graphics g = Graphics.FromImage(bitmap); g.SmoothingMode = SmoothingMode.AntiAlias; Rectangle rect = new Rectangle(0, 0, this.width, this.height); // Fill in the background. HatchBrush hatchBrush = new HatchBrush(HatchStyle.SmallConfetti, Color.White, Color.White); g.FillRectangle(hatchBrush, rect); // Set up the text font. SizeF size; float fontSize = rect.Height + 1; Font font; // Adjust the font size until the text fits within the image. do { fontSize–; font = new Font(this.familyName, fontSize, FontStyle.Bold); size = g.MeasureString(this.text, font); } while (size.Width > rect.Width);

// Set up the text format.
StringFormat format = new StringFormat();
format.Alignment = StringAlignment.Center;
format.LineAlignment = StringAlignment.Center;

// Create a path using the text and warp it randomly.
GraphicsPath path = new GraphicsPath();
path.AddString(this.text, font.FontFamily, (int) font.Style, font.Size, rect, format);
float v = 4F;
PointF[] points =
{
new PointF(this.random.Next(rect.Width) / v, this.random.Next(rect.Height) / v),
new PointF(rect.Width – this.random.Next(rect.Width) / v, this.random.Next(rect.Height) / v),
new PointF(this.random.Next(rect.Width) / v, rect.Height – this.random.Next(rect.Height) / v),
new PointF(rect.Width – this.random.Next(rect.Width) / v, rect.Height – this.random.Next(rect.Height) / v)
};
Matrix matrix = new Matrix();
matrix.Translate(0F, 0F);
path.Warp(points, rect, matrix, WarpMode.Perspective, 0F);

// Draw the text.
hatchBrush = new HatchBrush(HatchStyle.LargeConfetti, Color.Black, Color.Black);
g.FillPath(hatchBrush, path);

// Add some random noise.
int m = Math.Max(rect.Width, rect.Height);
for (int i = 0; i < (int) (rect.Width * rect.Height / 30F); i++)
{
int x = this.random.Next(rect.Width);
int y = this.random.Next(rect.Height);
int w = this.random.Next(m / 50);
int h = this.random.Next(m / 50);
g.FillEllipse(hatchBrush, x, y, w, h);
}

// Clean up.
font.Dispose();
hatchBrush.Dispose();
g.Dispose();

// Set the image.
this.image = bitmap;
}
}

__________________________________________________________________________________________

Step 2: Now Make One .aspx page and Name That Page JpegImage.aspx . Now paste the code into JpegImage.cs file.

private Random random = new Random();
protected void Page_Load(object sender, EventArgs e)
{
if (this.Session[“CaptchaImageText”] == null)
{
this.Session[“CaptchaImageText”] = GenerateRandomCode();
}
// Create a CAPTCHA image using the text stored in the Session object.
CaptchaImage.CaptchaImage ci = new CaptchaImage.CaptchaImage(this.Session[“CaptchaImageText”].ToString(), 125, 30, “Century Schoolbook”);

// Change the response headers to output a JPEG image.
this.Response.Clear();
this.Response.ContentType = “image/jpeg”;

// Write the image to the response stream in JPEG format.
ci.Image.Save(this.Response.OutputStream, ImageFormat.Jpeg);

// Dispose of the CAPTCHA image object.
ci.Dispose();
}
private string GenerateRandomCode()
{
string s = “”;
for (int i = 0; i < 6; i++)
s = String.Concat(s, this.random.Next(10).ToString());
return s;
}

________________________________________________________________________________________________

Step 3 : Now add more web form named Captcha.aspx and add this code in Captcha.cs file

private Random random = new Random();
private string GenerateRandomCode()
{
string s = “”;
for (int i = 0; i < 6; i++)
s = String.Concat(s, this.random.Next(10).ToString());
return s;
}
protected void Page_Load(object sender, EventArgs e)
{
if (!IsPostBack)
{
try
{
this.Session[“CaptchaImageText”] = GenerateRandomCode(); //store generated code in session variable
captchaimage.ImageUrl = “JpegImage.aspx?code=” + System.Guid.NewGuid().ToString(); //set image url
CodeNumberTextBox.Text = “Enter Captcha Text Here”;
}
catch (Exception ex)
{ }

}
}
protected void imgRefresh_Click(object sender, EventArgs e)
{
this.Session[“CaptchaImageText”] = GenerateRandomCode();//store generated code in session variable
captchaimage.ImageUrl = “JpegImage.aspx?code=” + System.Guid.NewGuid().ToString();//set image url
CodeNumberTextBox.Text = “Enter Captcha Text Here”;
}
protected void btnMail_Click(object sender, EventArgs e)
{
if (CodeNumberTextBox.Text == “” || CodeNumberTextBox.Text == “Enter Captcha Text Here” || this.Session[“CaptchaImageText”] == null || this.Session[“CaptchaImageText”].ToString() != CodeNumberTextBox.Text)
{
//error message
return;
}
else
{
//your operation
}
}

________________________________________________________________________________________________

Step 4: Now add this code in Captcha.aspx Page ..

<asp:UpdatePanel ID=”updateCaptcha” runat=”server”>
<ContentTemplate>
<div class=”divcaptcha” id=”divcaptcha” runat=”server”>
<asp:Image ID=”captchaimage” runat=”server” /><asp:Button ID=”imgRefresh” runat=”server”
Height=”24px” Width=”24px” BackColor=”Transparent” BorderStyle=”None” Style=”cursor: pointer; background-image:url(‘refresh.gif’);”
OnClick=”imgRefresh_Click” />
<asp:TextBox ID=”CodeNumberTextBox” runat=”server” Text=”Enter Captcha Text Here”
onBlur=”if(this.value==”) this.value=’Enter Captcha Text Here’;” onFocus=”if(this.value==’Enter Captcha Text Here’) this.value=”;”></asp:TextBox>
<asp:LinkButton ID=”btnMail” runat=”server” Style=”text-decoration: none;
cursor: pointer;” OnClick=”btnMail_Click”>Submit</asp:LinkButton>
</div>

</ContentTemplate>
</asp:UpdatePanel>

 

This Is Just an Example  , You Can Change It According To Your Requirements 🙂

I am uploading Image With This Post Too . :)

Hope This Post Will Help you Somehow . . :) . Feel Free To Ask Anything You Need.

Waiting For Your Valuable Feedback.

Step 1 :  Register your application to get consumer key and consumer secret

Here

Don’t forgot to change prermision to read Contacts

Step 2:  In App_Code Folder Make One New Class . . And Write The Following Code In That Class

________________________________________________________________________________________________

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();
}

}
}

_____________________________________________________________________________________________

Step 3: Now Make 1 .aspx Page ,, Say Yahoo.aspx
Step 4 :Now In yahoo.aspx Page Write this simple code

<asp:Button ID=”Button1″ runat=”server” Text=”Connect to Yahoo!” OnClick=”Button1_Click” />
<asp:GridView ID=”grvMyFriends” runat=”server” AutoGenerateColumns=”true”>

</asp:GridView>

Step 5: Now In Yahoo.aspx.cs File Write This Code :

______________________________________________________________________________________________

public string ConsumerKey
{
get
{
return “YourConsumerKey”;
}
}
public string ConsumerSecret
{
get
{
return “YourConsumerSecret”;
}
}
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;
Page.ClientScript.RegisterStartupScript(typeof(ScriptManager),”refresh”, “// “);

}
else if (!string.IsNullOrEmpty(OauthVerifier))
{
Button1.Visible = false;
if (string.IsNullOrEmpty(OauthYahooGuid))
GetAccessToken(OauthToken, OauthVerifier);
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&#8221;);
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(“YourRedirectUrl”));
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)
{
Page.ClientScript.RegisterStartupScript(typeof(ScriptManager),”openwin”, “// “);
}
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&#8221;);
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);
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[] { ‘&’ });
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[3].IndexOf(“=”);
string oauth_session_handle = returnData[3].Substring(index + 1);
OauthSessionHandle = oauth_session_handle;
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/&#8221; + 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());
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) + “\””;
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);
}
grvMyFriends.DataSource = emails;
grvMyFriends.DataBind();
}

catch (Exception ex)
{
}
}
protected void Button1_Click(object sender, EventArgs e)
{
string authorizationUrl = string.Empty;
authorizationUrl = GetRequestToken();
RedirectUserForAuthorization(authorizationUrl);
}

______________________________________________________________________________________________

Hope This Post Will Help you Somehow 🙂 . . . Feel Free To Ask Anything You Need.

Waiting For Your Valuable Feedback.