Archive for the ‘C#’ Category

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.

string objects are immutable in C#

Posted: August 2, 2012 in C#, Uncategorized
Tags: ,

All string objects are immutable in C#. Objects of the class string, once created, can never represent any value other than the one they were constructed with. All operations that seem to “change” a string instead produce a new one. This is inefficient with memory, but extremely useful with regard to being able to trust that a string won’t change out form under you- because as long as you don’t change your reference, the string being referred to will never change.

A mutable object, by contrast, has data fields that can be altered. One or more of its methods will change the contents of the object, or it has a Property that, when written into, will change the value of the object.

If you have a mutable object- the most similar one to String is StringBuffer- then you have to make a copy of it if you want to be absolutely sure it won’t change out from under you. This is why mutable objects are dangerous to use as keys into any form of Dictionary or set- the objects themselves could change, and the data structure would have no way of knowing, leading to corrupt data that would, eventually, crash your program.

However, you can change its contents- so it’s much, much more memory efficient than making a complete copy because you wanted to change a single character, or something similar.

Generally, the right thing to do is use mutable objects while you’re creating something, and immutable objects once you’re done. This applies to objects that have immutable forms, of course; most of the collections don’t. It’s often useful to provide read-only forms of collections, though, which is the equivalent of immutable, when sending the internal state of your collection to other contexts- otherwise, something could take that return value, do something to it, and corrupt your data.

Just Trying To Explain string Concept 🙂

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.

Sometimes we require to invoke postback of a control but cannot set AutoPostBack property to true. In such case we can make use of __doPostBack method of Javascript. 

I`ll Give you A Simple Example How You Can Do This..

______________________________________________________________________________________

Include these 3 tags into your .aspx page.

<input type=”hidden” name =”__EVENTTARGET” value =”” />
<input type=”hidden” name =”__EVENTARGUMENT” value =”” />
<a id=”LButton3″ href=”javascript:__doPostBack(‘Button2′,’ ‘)”>LinkButton</a>

Here we have on anchor tag we want a server side event to fire on click of this link.

Now write this javascript function . Form1 is the id of your form.

<script type=”text/javascript”>

function __doPostBack(eventTarget, eventArgument) {
document.Form1.__EVENTTARGET.value = eventTarget;
document.Form1.__EVENTARGUMENT.value = eventArgument;
document.Form1.submit();
}
</script>

______________________________________________________________________________________

Now, Lets talk about Server Side operations . You Have To Write this code in your .cs file

protected void Page_Load(object sender, EventArgs e)
{
if (Request.Form[“__EVENTTARGET”] == “Button2”)
{
//fire event
Button2_Click(this, new EventArgs());
}
}

protected void Button2_Click(object sender, EventArgs e)
{
Response.Write(“postback event fired”);
}

_______________________________________________________________________________________

this will fire your Button2_Click event..

This Is Basic , Now You Can Modify This Code as You Want 🙂

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

Waiting For Your Valuable Feedback.

To Get The Contacts first of all we have to create an application on windows live which you can create from Here   press create application button by which you can get API key and secret.

Now You Can Put This Tag Into Your aspx Page ..

<a href=”https://oauth.live.com/authorize?client_id=YOURCLIENTID&scope=wl.basic&client_secret=YOURCLIENTSECRET&response_type=code&redirect_uri=”Your aspx Page url” > Click To Get Msn Contacts </a>

Then You Have To Make One More Class..  You Can Say MsnImport.cs

public class MsnImport
{
private const string wlCookie = “wl_auth”;
private const string clientId = “YOURCLIENTID”;
private string Callback = “URL Of Your Page Where You Want To Redirect From Msn”;
private const string clientSecret = “YOURCLIENTSECRET”;
private const string oauthUrl = “https://oauth.live.com/token&#8221;;
private List<string> emaillist = new List<string>();
public MsnImport(int agentid)
{
}
public List<string> GetMsnContacts(string code)
{

try
{
HttpContext context = HttpContext.Current;
string verifier = code;
OAuthToken token;
OAuthError error;

if (!string.IsNullOrEmpty(verifier))
{
RequestAccessTokenByVerifier(verifier, out token, out error);
}
}
catch (Exception ex) { }
return emaillist;
}
private void RequestAccessTokenByVerifier(string verifier, out OAuthToken token, out OAuthError error)
{
string content = String.Format(“client_id={0}&redirect_uri={1}&client_secret={2}&code={3}&grant_type=authorization_code”,
HttpUtility.UrlEncode(clientId),
HttpUtility.UrlEncode(Callback),
HttpUtility.UrlEncode(clientSecret),
HttpUtility.UrlEncode(verifier));
RequestAccessToken(content, out token, out error);
}
private void RequestAccessToken(string postContent, out OAuthToken token, out OAuthError error)
{
token = null;
error = null;
HttpWebRequest request = WebRequest.Create(oauthUrl) as HttpWebRequest;
request.Method = “POST”;
try
{
using (StreamWriter writer = new StreamWriter(request.GetRequestStream()))
{
writer.Write(postContent);
}
HttpWebResponse response = request.GetResponse() as HttpWebResponse;
if (response != null)
{
DataContractJsonSerializer serializer = new DataContractJsonSerializer(typeof(OAuthToken));
token = serializer.ReadObject(response.GetResponseStream()) as OAuthToken;
if (token != null)
{
RequestContacts(token.AccessToken);
}
}
}
catch (Exception ex)
{

}

}
private void RequestContacts(string AccessToken)
{
string content = String.Format(“access_token={0}”, HttpUtility.UrlEncode(AccessToken));
string url = “https://apis.live.net/v5.0/me/contacts?&#8221; + content;
//string url = “https://apis.live.net/v5.0/me/contacts?access_token=&#8221; + AccessToken;
HttpWebRequest request = WebRequest.Create(url) as HttpWebRequest;
//request.Method = “POST”;
request.Method = WebRequestMethods.Http.Get;
HttpWebResponse response = (HttpWebResponse)request.GetResponse();
StreamReader reader = new StreamReader(response.GetResponseStream());
string tmp = reader.ReadToEnd();
JavaScriptSerializer ser = new JavaScriptSerializer();
Dictionary<string, object> dictionary = ser.Deserialize<Dictionary<string, object>>(tmp);
DisplayDictionary(dictionary);
}
public bool DisplayDictionary(Dictionary<string, object> dict)
{
bool bSuccess = false;
string abc = string.Empty;
foreach (string strKey in dict.Keys)
{
string strOutput = “”;// “”.PadLeft(indentLevel * 8) + strKey + “:”;
object o = dict[strKey];
if (o is Dictionary<string, object>)
{
DisplayDictionary((Dictionary<string, object>)o);
}
else if (o is ArrayList)
{
foreach (object oChild in ((ArrayList)o))
{
if (oChild is string)
{
strOutput = ((string)oChild);
}
else if (oChild is Dictionary<string, object>)
{
DisplayDictionary((Dictionary<string, object>)oChild);
}
}
}
else
{
if (o != null)
{
strOutput = o.ToString();
if (strKey == “name”)
{
if (strOutput.Contains(“@”))
emaillist.Add(strOutput);
}
}
}
}
return bSuccess;
}
}
[DataContract]
public class OAuthToken
{
[DataMember(Name = OAuthConstants.AccessToken)]
public string AccessToken { get; set; }
[DataMember(Name = OAuthConstants.RefreshToken)]
public string RefreshToken { get; set; }
[DataMember(Name = OAuthConstants.ExpiresIn)]
public string ExpiresIn { get; set; }
[DataMember(Name = OAuthConstants.Scope)]
public string Scope { get; set; }
}
public static class OAuthConstants
{
public const string ClientID = “client_id”;
public const string ClientSecret = “client_secret”;
public const string Callback = “redirect_uri”;
public const string ClientState = “state”;
public const string Scope = “scope”;
public const string Code = “code”;
public const string AccessToken = “access_token”;
public const string ExpiresIn = “expires_in”;
public const string RefreshToken = “refresh_token”;
public const string ResponseType = “response_type”;
public const string GrantType = “grant_type”;
public const string Error = “error”;
public const string ErrorDescription = “error_description”;
public const string Display = “display”;
}
[DataContract]
public class OAuthError
{
public OAuthError(string code, string desc)
{
this.Code = code;
this.Description = desc;
}
[DataMember(Name = OAuthConstants.Error)]
public string Code { get; private set; }
[DataMember(Name = OAuthConstants.ErrorDescription)]
public string Description { get; private set; }
}

_______________________________________________________________________________________

In Your .aspx Page You Have To Write This Code in Page_Load()

if (Request.QueryString[“code”] != null)
{
GetMsnContacts(Request.QueryString[“code”].ToString());
}

You Can Call This Method In Method In Your .aspx Page

private void GetMsnContacts(string code)
{
MsnImport msnImport = new MsnImport();
List<string> emaillist = new List<string>();
emaillist = msnImport.GetMsnContacts(code);
}

_______________________________________________________________________________________

By Implementing The Above Code You Can Easily Import Msn Contacts ..

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

Waiting For Your Valuable Feedback.

In Many Sites We Can See There Are Options Of Importing Contacts From Gmail,Yahoo,AOL, Msn ..To Invite Friends To Join your website Or Something Like That..

Importing Gmail Contacts Is Not A Real Big Task . Google Has Provided Few dll`s Through Which You Can Import Gmail Contacts ..

Step 1 :  Download Google data API setup from the specified URL :

Step 2: Add These dll`s into Your Bin Folder ..
1.Google.GData.Apps.dll
2.Google.GData.Client.dll
3.Google.GData.Contacts.dll
4.Google.GData.Extensions.dll

Step 3 :Add These Namespace To Your Codebehind.
using Google.GData.Contacts;
using Google.GData.Client;
using Google.GData.Extensions;
using Google.Contacts;

Step 4 : Add This Function Into Your Code behind :

public static DataSet GetGmailContacts(string App_Name, string Uname, string UPassword)

{

DataSet ds = new DataSet();

DataTable dt = new DataTable();

DataColumn C2 = new DataColumn();

C2.DataType = Type.GetType(“System.String”);

C2.ColumnName = “EmailID”;

dt.Columns.Add(C2);

RequestSettings rs = new RequestSettings(App_Name, Uname, UPassword);

rs.AutoPaging = true;

ContactsRequest cr = new ContactsRequest(rs);

Feed<Contact> f = cr.GetContacts();

foreach (Contact t in f.Entries)
{

foreach (EMail email in t.Emails)
{

DataRow dr1 = dt.NewRow();

dr1[“EmailID”] = email.Address.ToString();

dt.Rows.Add(dr1);

}

}

ds.Tables.Add(dt);

return ds;

}

By This Function You Can import Your Gmail Contacts . Your Contacts Will Be Saved In Dataset..You Can Bind that Dataset To Your .aspx File.

You Can Call This Method Like :

DataSet ds = GetGmailContacts(“Web Application!”, “UserName”, “Password”);

Hope This Post Will Help you Somehow . . :)

Waiting For Your Valuable Feedback.