Subscribe to Martyr2's Programming Underground        RSS Feed
***** 1 Votes

Bit.ly Class for shortening URLs in VB.NET and C#

Icon 2 Comments
So I was tinkering around with some code and thought "Hey, wouldn't it be great to create a class that could be used to tie into bit.ly's API for shortening URLs?" After having this thought I also thought "I am hungry" so went to get some lunch. Then when I came back, I got to work putting together a quick class that a programmer could use in their projects for submitting long URLs for bit.ly to shorten up. I created it in two .NET languages so that it would be more versatile and save some programmers from having to port it from one language to the other. Now lets get shortening on this episode of the Programming Underground!

<The movie 'Avatar' theme music, but with a dash of Felica Day singing 'Wanna date my avatar'>

The idea behind our class is that we are going to first create the object with a default login and API key or provide our own. By calling the method "Shorten" and giving it a nice long URL we are going to...

1) Contact bit.ly using their API URL
2) Fetch the result from bit.ly in XML format
3) Parse that XML to fetch the "shotUrl" element
4) Return that element's value to the caller of the method

The whole process is pretty straight forward. Being that we are counting on an external source that may or may not respond, could provide a bad response, or just plain ignore us we have to build in a few error handling traps. We want to make sure this class works even if the underlying API isn't. Let's start with the VB.NET version of this class and then we will move on to the C# version. These classes can be placed in their own class file and called from anywhere in the project.

Imports System.Text
Imports System.Xml
Imports System.IO
Imports System.Net

Public Class bitly
	Private loginAccount As String
	Private apiKeyForAccount As String

	Private submitPath As String = "http://api.bit.ly/shorten?version=2.0.1&format=xml"
	Private errorStatus As Integer = 0
	Private errorStatusMessage As String = ""


	' Constructors (overloaded and chained)
	Public Sub New()
		Me.New("bitlyapidemo", "R_0da49e0a9118ff35f52f629d2d71bf07")
	End Sub


	Public Sub New(ByVal login As String, ByVal APIKey As String)
		loginAccount = login
		apiKeyForAccount = APIKey

		submitPath &= "&login=" & loginAccount & "&apiKey=" & apiKeyForAccount
	End Sub


	' Properties to retrieve error information.
	Public ReadOnly Property ErrorCode() As Integer
		Get
			Return errorStatus
		End Get
	End Property

	Public ReadOnly Property ErrorMessage() As String
		Get
			Return errorStatusMessage
		End Get
	End Property


	' Main shorten function which takes in the long URL and returns the bit.ly shortened URL
	Public Function shorten(ByVal url As String) As String

		errorStatus = 0
		errorStatusMessage = ""

		Dim doc As XmlDocument
		doc = buildDocument(url)

		If Not doc.DocumentElement Is Nothing Then

			Dim shortenedNode As XmlNode = doc.DocumentElement.SelectSingleNode("results/nodeKeyVal/shortUrl")

			If Not shortenedNode Is Nothing Then

				Return shortenedNode.InnerText

			Else

				getErrorCode(doc)

			End If
		Else

			errorStatus = -1
			errorStatusMessage = "Unable to connect to bit.ly for shortening of URL"
		End If

		Return ""

	End Function


	' Sets error code and message in the situation we receive a response, but there was
	' something wrong with our submission.
	Private Sub getErrorCode(ByVal doc As XmlDocument)

		Dim errorNode As XmlNode = doc.DocumentElement.SelectSingleNode("errorCode")
		Dim errorMessageNode As XmlNode = doc.DocumentElement.SelectSingleNode("errorMessage")

		If Not errorNode Is Nothing Then

			errorStatus = Convert.ToInt32(errorNode.InnerText)
			errorStatusMessage = errorMessageNode.InnerText
		End If
	End Sub


	' Builds an XmlDocument using the XML returned by bit.ly in response 
	' to our URL being submitted
	Private Function buildDocument(ByVal url As String) As XmlDocument

		Dim doc As New XmlDocument

		Try

			' Load the XML response into an XML Document and return it.
			doc.LoadXml(readSource(submitPath + "&longUrl=" + url))
			Return doc

		Catch e As Exception

			Return New XmlDocument()
		End Try
	End Function


	' Fetches a result from bit.ly provided the URL submitted
	Private Function readSource(ByVal url As String) As String
		Dim client As New WebClient

		Try

			Using reader As New StreamReader(client.OpenRead(url))
				' Read all of the response
				Return reader.ReadToEnd()
				reader.Close()
			End Using

		Catch e As Exception
			Throw e
		End Try

	End Function

End Class



The class is made up of two constructors. One which takes no parameters (providing defaults) and another which takes two parameters representing the login account and API key provided by bit.ly (if you signed up for an account with them). Either way this should work for you even if you don't have an account. In addition to the constructors, we provide two properties that can be used to retrieve an error code and error message in the event that something terrible and horrible happens. You can use these to check and see what is going on. We also specify the shorten public method which is the main method of the class and takes in the long URL. When this method finished, it will provide the caller a short URL string returned by bit.ly.

There is a small supporting cast of private helper functions which take separate jobs of communicating with bit.ly, building an XmlDocument using the XML response returned from the bit.ly API and another to yank out any error codes and messages in the rare chance that any are found.

readSource() is responsible for connecting to the web source, getting a stream to the API, submitting our aggregated URL string and reading the XML using the ReadToEnd() method of the StreamReader class. It returns this string to the caller which is the buildDocument() method. This method is responsible for taking the XML source string, placing it into an XmlDocument class and parsing out the nodes using XPath. We are looking for the element "shortUrl" here to retrieve the short URL returned from bit.ly.

All this is also done in our C# version shown below...

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Xml;
using System.Net;
using System.IO;

namespace bitly
{
	/// <summary>
	/// This class connects to bit.ly for URL shortening.
	/// 
	/// Class contains an overloaded constructor to take in a personal login and api key
	/// </summary>
  
	class bitly
	{
		private string loginAccount;
		private string apiKeyForAccount;
		private string submitPath = @"http://api.bit.ly/shorten?version=2.0.1&format=xml";
		private int errorStatus = 0;
		private string errorMessage = "";


		/// <summary>
		/// Default constructor which will login with demo credentials
		/// </summary>
		/// <returns>A bitly class object</returns>
		public bitly(): this("bitlyapidemo", "R_0da49e0a9118ff35f52f629d2d71bf07")
		{
			
		}


		/// <summary>
		/// Overloaded constructor that takes a bit.ly login and apikey (if applicable)
		/// </summary>
		/// <returns>A bitly class object</returns>
		public bitly(string login, string APIKey)
		{
			loginAccount = login;
			apiKeyForAccount = APIKey;

			submitPath += "&login=" + loginAccount + "&apiKey=" + apiKeyForAccount;
		}


		// Properties to retrieve error information.
		public int ErrorCode
		{
			get { return errorStatus; }
		}

		public string ErrorMessage
		{
			get { return errorMessage; }
		}


		/// <summary>
		/// Shortens a provided URL
		/// </summary>
		/// <param name="url">A URL</param>
		/// <returns>A shortened bit.ly URL String</returns>
		public string shorten(string url)
		{
			errorStatus = 0;
			errorMessage = "";

			XmlDocument doc = buildDocument(url);

			if (doc.DocumentElement != null)
			{
				XmlNode shortenedNode = doc.DocumentElement.SelectSingleNode("results/nodeKeyVal/shortUrl");

				if (shortenedNode != null)
				{
					return shortenedNode.InnerText;
				}
				else
				{
					errorCode(doc);
				}
			}
			else
			{
				this.errorStatus = -1;
				this.errorMessage = "Unable to connect to bit.ly for shortening of URL";
			}

			return "";

		}


		// Sets error code and message in the situation we receive a response, but there was
		// something wrong with our submission.
		private void errorCode(XmlDocument doc)
		{
			XmlNode errorNode = doc.DocumentElement.SelectSingleNode("errorCode");
			XmlNode errorMessage = doc.DocumentElement.SelectSingleNode("errorMessage");

			if (errorNode != null)
			{
				this.errorStatus = Convert.ToInt32(errorNode.InnerText);
				this.errorMessage = errorMessage.InnerText;
			}
		}
		   
	 
		// Builds an XmlDocument using the XML returned by bit.ly in response 
		// to our URL being submitted
		private XmlDocument buildDocument(string url)
		{
			XmlDocument doc = new XmlDocument();

			try
			{
				// Load the XML response into an XML Document and return it.
				doc.LoadXml(readSource(submitPath + "&longUrl=" + url));
				return doc;
			}
			catch (Exception e)
			{
				return new XmlDocument();
			}
		}


		// Fetches a result from bit.ly provided the URL submitted
		private string readSource(string url)
		{
			WebClient client = new WebClient();

			try
			{
				using (StreamReader reader = new StreamReader(client.OpenRead(url)))
				{
					// Read all of the response
					return reader.ReadToEnd();
					reader.Close();
				}
			}
			catch (Exception e)
			{
				throw e;
			}
		}
	}
}



As you can see this is almost identical to the VB.NET version but with the minor syntax changes. Again we open up our connection, retrieve the string XML response, parse that XML using XPath and return the shortUrl element's data to the caller. We could then use this class as we would for any class anywhere in the project. Place it in the button and use code similar to...

Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click
		Dim b As New bitly

		MessageBox.Show(b.shorten("http://www.cnn.com"))
End Sub



Not too bad huh? With this nifty little class you can quickly and easily use it to build applications which may need to submit URL's for shortening. Perhaps your own twitter client or for anything that would need simple URL's instead of long ones. Have fun playing and tinkering with this code. It is in the public domain, as all code on the Programming Underground is, so if a five finger discount is your specialty... enjoy! Thanks for reading! :)

If you want more blog entries like this, check out the official blog over on The Coders Lexicon. There you will find more code, more guides and more resources for programmers of all skill levels!

2 Comments On This Entry

Page 1 of 1

PsychoCoder Icon

23 August 2009 - 07:43 PM
Awesome Marty!@ I've been tinkering with my own Twitter application and you saved me a ton of work (that is if it's ok that I use it?)
0

Martyr2 Icon

25 August 2009 - 10:39 AM
Of course, all code posted on my blog is in the public domain. Use it as you like! :)
0
Page 1 of 1

September 2014

S M T W T F S
 123456
78910111213
1415 16 17181920
21222324252627
282930