OAuth is a new wave in the website security protocol or to be precise an API access delegation protocol’. OAuth allows a client application to obtain user consent (as access tokens) for executing operations over private resources on his behalf.

 OAuth allows you to share your private resources (photos, videos, contact list, bank accounts) stored on one site with another site without having to hand out your username and password. There are many reasons why one should not share their private credentials. Giving your email account password to a social network  site so they can look up your friends is the same thing as going to dinner and giving your ATM card and PIN code to the waiter when it’s time to pay. Any restaurant asking for your PIN code will go out of business, but when it comes to the web, users put themselves at risk sharing the same private information. OAuth here comes to the rescue.

If you want to know more about how OAuth works, you should read the following posts

• “Begginer’s Guide to OAuth – Part I”
• “Begginer’s Guide to OAuth – Part II – Protocol Workflow”
• “Begginer’s Guide to OAuth – Part III – Security Architecture”

Now, if we analyze the specification in more detail, we will see that the real purpose behind OAuth is to create a network of collaboration between applications. It will not be necessary anymore to keep all our stuff just in a single place, we can have for instance our pictures in a website, our contacts in another place and a third application making use of them, all these applications collaborating together.

Currently we hear OAuth being mostly associated with the social networking sites like Twitter, yahoo, google etc. However this is going to change in future, I see it being implemented in the cloud computing environment to provide more seamless access. Google has released its OpenID/OAuth implementation. This is a major step forward in the Interoperability field. The work that Google has released is very important and it will allow, for instance, that a user from Zoho Writer can use data from a Google Docs Spreadsheet and then make the result available in his Linkedin profile.

 Similarly I think with Microsoft releasing its new cloud computing platform Azure. The OAuth definitely comes into play more so important than ever before.

 Some of the OAuth .NET Faremwork Library available are :

• Alex Henderson (Aka Bittercoder) has written a pretty good OAuth library in .NET for implementing an OAuth consumer and service provider. The library is available here under a MIT license (do wherever you want with it), and it is very easy to use. Alex has definitively made a very good work. 
• Madgex has released an open source OAuth library for .NET (released under the MIT License). Documentation and demos are available.
• C# Eran Sandler has contributed a basic C# class that performs signing.
• VB.NET Nicolas Tarzia has translated Eran Sandler’s C# library into VB.NET.

  Here is some OAuth Implementation examples in .NET

• Pablo M. Cibraro (aka Cibrax) has given a great example of implementing OAuth Channel for WCF.
• For implementing OAuth in ASP.NET MVC

In the last blog i talked about MonoDevelop an open source cross platform IDE for .NET development. This cross platform .NET development was only possible due to the Mono Framework.

Mono is a software platform designed to allow developers to easily create cross platform applications. It is an open source implementation of Microsoft’s .Net Framework based on the ECMA standards for C# and the Common Language Runtime. We feel that by embracing a successful, standardized software platform, we can lower the barriers to producing great applications for Linux.

The Components

There are several components that make up Mono:

C# Compiler – The C# compiler is feature complete for compiling C# 1.0 and 2.0 (ECMA), and also contains many of the C# 3.0 features.

Mono Runtime – The runtime implements the ECMA Common Language Infrastructure (CLI). The runtime provides a Just-in-Time (JIT) compiler, an Ahead-of-Time compiler (AOT), a library loader, the garbage collector, a threading system and interoperability functionality.

Base Class Library – The Mono platform provides a comprehensive set of classes that provide a solid foundation to build applications on. These classes are compatible with Microsoft’s .Net Framework classes.

Mono Class Library – Mono also provides many classes that go above and beyond the Base Class Library provided by Microsoft. These provide additional functionality that are useful, especially in building Linux applications. Some examples are classes for Gtk+, Zip files, LDAP, OpenGL, Cairo, POSIX, etc.

The Benefits

There are many benefits to choosing Mono for application development:

Popularity – Built on the success of .Net, there are millions of developers that have experience building applications in C#. There are also tens of thousands of books, websites, tutorials, and example source code to help with any imaginable problem.

Higher-Level Programming – All Mono languages benefit from many features of the runtime, like automatic memory management, reflection, generics, and threading. These features allow you to concentrate on writing your application instead of writing system infrastructure code.

Base Class Library – Having a comprehensive class library provides thousands of built in classes to increase productivity. Need socket code or a hashtable? There’s no need to write your own as it’s built into the platform.

Cross Platform – Mono is built to be cross platform. Mono runs on Linux, Microsoft Windows, Mac OS X, BSD, and Sun Solaris, Nintendo Wii, Sony PlayStation 3, Apple iPhone. It also runs on x86, x86-64, IA64, PowerPC, SPARC (32), ARM, Alpha, s390, s390x (32 and 64 bits) and more. Developing your application with Mono allows you to run on nearly any computer in existance (details).

Common Language Runtime (CLR) – The CLR allows you to choose the programming language you like best to work with, and it can interoperate with code written in any other CLR language. For example, you can write a class in C#, inherit from it in VB.Net, and use it in Eiffel. You can choose to write code in Mono in a variety of programming languages.

–courtesy mono project

As I said that I am a technology evangelist. I like new technology in .NET as well as open source. Other thing which I liked was Mac. But before MonoDevelop both were two different worlds. You could not develop a .NET application on a Mac OS X. MonoDevelop has solved most of my problem or you can say it is the new bridge between different platforms.

MonoDevelop is an opensource Integrated development environment for Linux platform, Mac OSX and Windows(to be supported in future). It allows you to develop software targeted to Mono and .NET framework. This IDE has feature like intellisense, source control integration and an integrated GUI and Web designer

MonoDevelop has recently launched the latest version of the IDE. To read more about it http://monodevelop.com/Download/MonoDevelop_2.0_Released.

If you’ve worked with Microsoft Visual Studio, you will see many similarities in MonoDevelop and will feel quite comfortable in the Mono environment. If you’re new to MonoDevelop and haven’t worked in Visual Studio, you’ll find that the learning curve is not very steep.

A new competitor for Visual Studio IDE…. eeh…lets see!!

.NET as it had evolved has come up with different API to read and write XML data. If you are using .NET 3.0 and lower version you will have to use XMLDocument aka the classic DOM API. With .NET 3.0 Microsoft had launched Language Integrated Query(LINQ) and with this came one of the feature name the LINQ to XML.

LINQ to XML has a simple model for building XML documents by hand. Whether it be XML sources from a stream or file, or XML created on-the-fly in code there are only a few important types to know and understand. The main ones used in everyday activities are XDocument, XElement and XAttribute.

In this article we will talk about XDocument and XMLDocument.

Lets consider the following test data for our article

<root>

<child id=’123′/>

<child id=’234′/>

…

</root>

Reading the XML

XmlDocument.Load

XmlDocument.Load was the cleanest and easiest to understand. It is necessary that you must know XPath, although the fact is I like XPath. XmlDocument does have some security concerns with XPath injection. Here is how we code to load a document

private static void XmlDocumentReader(string fileName) {

XmlDocument doc = new XmlDocument();

doc.Load(fileName);

XmlNodeList nodes = doc.SelectNodes(“//child”);

if (nodes == null) {

throw new ApplicationException(“invalid data”);

}

foreach (XmlNode node in nodes) {

string id = node.Attributes["id"].Value;

ProcessId(id);

}

}

Another way to query a single node is given below

XmlDocument doc = XmlDocument.Load(fileName);

XmlNode node = doc.SelectSingleNodes(“/root/child[@id=’123’")

LINQ to XML

LINQ to XML was also very easy to read and understand code. XDocument.Load does read the whole document into memory before returning. Due to feature of Lambda expression it has become very easy to traverse the xml document. The query syntax is easier than XPath or XQuery for developers who do not use XPath or XQuery on a daily basis. Here is the code I used to load and search the document:

private static void XDocumentReader(string fileName) {

XDocument doc = XDocument.Load(fileName);

if (doc == null | doc.Root == null) {

throw new ApplicationException("invalid data");

}

foreach (XElement child in doc.Root.Elements("child")) {

XAttribute attr = child.Attribute("id");

if (attr == null) {

throw new ApplicationException("invalid data");

}

string id = attr.Value;

ProcessId(id);

}

}

Another way to query a single node is given below

var xd = XDocument.Load(fileName);

var domQuery =

from c in xd.Descendants("child ")

where (string)c.Attribute("id") == "123"

Writing a new XML

Both the method almost looks similar.

XmlDocument

XmlDocument xmlDoc = new XmlDocument();

// Write down the XML declaration

XmlDeclaration xmlDeclaration = xmlDoc.CreateXmlDeclaration("1.0","utf-8",null);

// Create the root element

XmlElement rootNode  = xmlDoc.CreateElement("root");

xmlDoc.InsertBefore(xmlDeclaration, xmlDoc.DocumentElement);

xmlDoc.AppendChild(rootNode);

// Create a new <child> element and add it to the root node

XmlElement parentNode  = xmlDoc.CreateElement("child");

// Set attribute name and value!

parentNode.SetAttribute("ID", "01");

xmlDoc.DocumentElement.PrependChild(parentNode);

LINQ  to XML

XDocument doc = new XDocument(

new XDeclaration("1.0", "utf-8", "yes"),

new XElement("root",

new XElement ("child", new XAttribute("id", "01")

)

);

Manipulating XML Data

XmlDocument

Here we have to struggle with manipulating the xml data. First take help of XPath to select the node and then use replace node to update it. Or use the feature of delete node and insert new node. Code is given below

XmlDocument doc = new XmlDocument.Load(fileName);

//Select the cd node with the matching title

XmlNode oldCd;

XmlElement root = doc.DocumentElement;

oldCd = root.SelectSingleNode("/root/child[id='1']“);

XmlElement newCd = doc.CreateElement(“child”);

newCd.SetAttribute(“id”,2);

root.ReplaceChild(newCd, oldCd);

//save the output to a file

doc.Save(fileName);

LINQ  to XML

Here the code is very simple to write and understand. The coding time is also very less.

var xd = XDocument.Load(fileName);

var domQuery =

from c in xd.Descendants(“child “)

where (string)c.Attribute(“id”) == “123″

domQuery.Attribute(“id”).Value = 1

xd.save(filename)

Conclusion

Overall speaking both the API’s are equally powerful. However LINQ has made it little bit easier for developer to work with XML Data. I would say if you are using .NET 3.5 and higher you should rather go with LINQ To XML.