Consuming Feeds And Web Services In Razor Web Pages

4.82 (11 votes)

Increasing numbers of businesses are making services and data available to third parties via Web Services or feeds. Data format and protocols can vary significantly across service providers, so here is a look at how to manage the consumption of a number of popular formats delivered through REST and SOAP services within a web site built using the ASP.NET Web Pages framework.

The proliferation of Web Service APIs over that last 5 years or so has been immense, as more and more businesses expose their inner workings through formal contracts. You can find an API for almost any informational need; from weather forecasts to stock prices, email validation services to parcel tracking and much more. There are nearly 9000 of them listed at These services are all based on the provision of data via HTTP. They are provided via a variety of protocols, with REST being the most popular. For that reason, I shall cover REST based services first.

RESTful Web Services

A key characteristic of REST services is the explicit use of HTTP methods: GET, POST, PUT, DELETE etc to execute data operations semantically. GET is used to obtain data. POST is used to create new instances of data (like an SQL INSERT operation). PUT is the equivalent to SQL's UPDATE, and DELETE means the same thing in both paradigms. Since the scope of this article is the consumption of services, I will look only at the GET operation. Data formats vary. The most popular formats are JSON and XML (increasingly, ATOM) for representing structured data, although these services can return simple strings if that's all that is needed.

One of the main characteristics of REST-based services and a key driver behind their growing popularity is simplicity. An endpoint or resource is simply represented by a URL. Data operations are executed via a GET request and can accept parameters which are passed via the query string.


Javascript Object Notation (JSON) is a lightweight text-based format for data exchange. Because it is structured, it is relatively easy to work with in both server-side and client-side code. The following code shows how to use the WebClient class to make an HTTP GET request to the Twitter search service for tweets that include "webmatrix":

var client = new WebClient();
var json = client.DownloadString("");

The image below shows the JSON that's returned as captured by Fiddler:

A good API will offer documentation on the structure of the data it returns so that you know how to work with it, and Twitter is no exception ( although this particular API has been deprecated and may no longer work. The structure consists of a single object that has a number of properties: completed_in, max_id, query, and a collection of objects in another property called results. Each of these objects have a created_at property as well as others including from_user and text.

If you want to work with the data in your client side code, you can use the above code in a separate file that is called via AJAX and that outputs the value of the json variable. Your AJAX call can then make use of the data obtained in a callback. If you want to work with JSON in server-side code, you need to be able to deserialise it to something that C# (or VB) understands. Some APIs provide libraries that you can use in your application to simplify this process and allow you to work with strongly typed objects. However, the Web Pages framework provides a helper for deserialising JSON - the JSON helper. So long as the JSON that you receive from the external source is valid in structure, the JSON helper will be able to convert it to a dynamic object, or if you have a class definition that matches the JSON structure, it can deserialize the JSON into strongly typed objects. In this case, dynamic will do:

    var client = new WebClient();
    var json = client.DownloadString("");
    var search = Json.Decode(json);

@foreach(var result in search.results){
    <p><strong>@result.from_user (@result.from_user_name)</strong><br />
        @result.text<br />


The deprecated Twitter API also offers an ATOM feed. ATOM is an XML format used primarily for syndication feeds in place of RSS, but it is also used for providing a much wider range of data over HTTP. There are a number of ways in which you can obtain an consume an ATOM feed from a RESTful service. Often, the method by which you obtain the data is tied to the library you use to consume the data. I'm going to look at two alternatives: LINQ to XML and the SyndicationFeed class.

LINQ to XML is an all-purpose API for working with XML documents in .NET. It doesn't care what type of XML it is asked to process so it will work with ATOM, RSS or indeed any XML based data. XML documents are represented by the XDocument class which can be instantiated in a number of ways. The easiest way to instantiate an XDocument when working with RESTful services is to pass the URL of the resource into the static Load method:

@using System.Xml.Linq
    var feed = XDocument.Load("");

LINQ to XML resides in System.Xml.Linq, which is not one of the default set of namespaces referenced by the Web Pages framework. Therefore you need to add a using directive to reference the namespace at the top of the page when you want to work with it. Once you have your XDocument, you can query it to extract data. The following sample shows how to obtain the same data as the JSON example, transfer it from the ATOM feed into a collection of anonymous objects and then output it to the browser:

@using System.Xml.Linq
    var feed = XDocument.Load("");
    XNamespace xmlns = "";
    var items = feed.Descendants(xmlns + "entry").Select(item => new {
        Title = item.Element(xmlns + "title").Value,
        Published = item.Element(xmlns + "published").Value,
        Author = item.Element(xmlns + "author").Element(xmlns + "name").Value

@foreach (var item in items) {
    <p><strong>@item.Author</strong><br />
        @item.Title<br />

The SyndicationFeed class is part of the.NET framework and lives in System.ServiceModel.Syndication, which like LINQ to XML is not included in the default Web Pages namespaces, so you need a using directive to be able to work with it. It is designed to work solely with XML that follows the popular syndication formats: RSS and ATOM. The main advantage of using the SyndicationFeed class oer LINQ to XML is that you don't need to query the XML yourself to get values. Since ATOM and RSS are specifications, the structure of documents is known and the SyndicationFeed class parses the XML for you, leaving you with nice IntelliSense-friendly strongly typed objects to work with. It's main disadvantage is that it is very strict in terms of its application of RSS and ATOM rules, and will not parse a document if, for example, the date format differs from the specification. Yahoo's Weather RSS service will fail as the dates in it are currently not RFC 822 compliant.

The SyndicationFeed class also offers a static Load method, but it oddly requires an XmlReader object (from System.Xml) which means another using directive:

@using System.Xml
@using System.ServiceModel.Syndication;
    var feed = SyndicationFeed.Load(new XmlTextReader(""));

Just that one line of code is required to enable you to render the contents:

@foreach (var item in feed.Items) {
    <p><strong>@item.Authors.First().Name</strong><br />
        @item.Title<br />

SOAP Web Services

SOAP is a more complex technology to work with than REST, which is one of the reasons it is losing popularity. However, it was strong in the Enterprise, and I am including the technology in this article in case you find that you are required to work with SOAP-based services that haven't been replaced by REST alternatives yet. Unfortunately, WebMatrix offers no tooling to work with SOAP-based services, so you can either use wsdl.exe (usually found in C:\Program Files (x86)\Microsoft SDKs\Windows\v8.0A\Bin\NETFX 4.0 Tools) to generate proxies based on the metadata included in the service description document (WSDL), or if command line tools and switches make your chest tighten, you can download the free Visual Studio Express For Web and use that instead. I will illustrate the saner latter approach by referencing the sample web service for converting Celsius to Fahrenheit (and vice versa) provided by W3Schools.

The first thing you need to do is locate the URL to the WSDL document for the service you want to reference. This is an XML document describing the operations available, the parameters required and the nature and format of the response. It is also known as the service description - WDSL being an acronym for Web Service Description Language. Next, either from the WEBSITE menu or by right clicking on the web site in the Solution Explorer, choose the Add Service Reference option:

Paste the URL to the WSDL file in the Address box and change the default value of the Namespace to a more meaningful one:

Click the Go button, and wait for the wizard to download the WSDL file and to read it. If the file is found, the available services are listed in the Services pane.

Since this is a .NET service (discernable from the .asmx extension) an HTTP Post method is also provided. We shall ignore that. We want to play with SOAP. Click the OK button. You should get an extra folder with some new files:

A SOAP message consists of a number of elements all represented as XML. The message has an envelope, header, body and a fault section. It must follow SOAP syntax rules, but you don't need to know the details of any of that because the wizard has taken care of generating the proxy classes to manage the construction and transmission of SOAP messages to invoke the web service methods, and to handle the response from the web service and to extract the returned data. It has also added some entries to the web.config file that detail the configuration of the client and endpoints of the service:

        <binding name="TempConvertSoap" />
        <binding name="TempConvertSoap12">
          <textMessageEncoding messageVersion="Soap12" />
          <httpTransport />
      <endpoint address=""
        binding="basicHttpBinding" bindingConfiguration="TempConvertSoap"
        contract="TempConvertService.TempConvertSoap" name="TempConvertSoap" />
      <endpoint address=""
        binding="customBinding" bindingConfiguration="TempConvertSoap12"
        contract="TempConvertService.TempConvertSoap" name="TempConvertSoap12" />

There are two endpoint configurations, both of which have the same address. One is the configuration for the basicHttpBinding (SOAP 1.1) option, and the other is for the SOAP 1.2 option. Since there are multiple configurations for the same endpoint, you have to specify which one to use when invoking the service by passing the configuration name into the proxy client's constructor:

    var service = new TempConvertService.TempConvertSoapClient("TempConvertSoap");

Now that you have a reference to the actual service, you can invoke its operations:

    var service = new TempConvertService.TempConvertSoapClient("TempConvertSoap");
    var result = service.CelsiusToFahrenheit("20");

This example is a simple one in that it returns a single value that results from the calculation as a string. More complex values can be returned in a number of formats. The sample site that accompanies this article includes a weather forecast service example that returns a more complex object. The proxy client that was generated through the Add Service Reference wizard understands from the infomraiton presented in the WSDL file that this object is of type ForecastReturn and has properties such as a City property and creates classes accordingly. You can see it in Intellisense:

Another example in the sample site - the SOAP - XML page features a stock price web service that returns a string. The string is actually a fragment of XML and contains a number of values. If you want to turn this fragment into an XDocument, you should use the XDocument.Parse method:

@using System.Xml.Linq;
    Page.Title = "SOAP example with XML Fragment";
    var service = new StockQuoteService.StockQuoteSoapClient("StockQuoteSoap");
    var fragment = service.GetQuote("MSFT");
    var xml = XDocument.Parse(fragment);
    var stockQuote = xml.Descendants("StockQuotes").Descendants("Stock").Select(quote => new { 
        Symbol = quote.Element("Symbol").Value,
        Last = quote.Element("Last").Value,
        Time = quote.Element("Time").Value,
        Change = quote.Element("Change").Value,
        Open = quote.Element("Open").Value,
        Low = quote.Element("Low").Value,
        Volume = quote.Element("Volume").Value,
        MktCap = quote.Element("MktCap").Value,
        PreviousClose = quote.Element("PreviousClose").Value,
        PercentageChange = quote.Element("PercentageChange").Value,
        AnnRange = quote.Element("AnnRange").Value,
        Earns = quote.Element("Earns").Value,
        PE = quote.Element("P-E").Value,
        Name = quote.Element("Name").Value
<h2>@stockQuote.Name (@stockQuote.Symbol)</h2> 
    Last: @stockQuote.Last<br />
    Change: @stockQuote.Change<br />
    Volume: @stockQuote.Volume


Data for your web application can come from a variety of sources and arrive in a variety of formats. This article covered the most common combinations and provides you with the tools to consume that data in your application.

A sample site containing the source code for the scenarios covered in this article is available as a free download.


You might also like...

Date Posted:
Last Updated:
Posted by:
Total Views to date: 189688


- Marty

appears that this doesn't work anymore. any updates to getting twitter feed?

- Mike


If you follow the link to the API, it will provide you with updated information on their API v1.1. You need to authenticate to be able to use the API these days.

- anuk

could you please tell how to use this with a web service that has .ashx extension.(https://www.someurl.ashx). because this cannot add to the project as reference. cannot continue my work because of this. hope your help

- Mike


That's not a web service. It's a generic handler. You can use WebClient.DownloadString to get the data and depending on its format, process it from there.

- karan

you are right

Recent Comments

Cyrus 26/05/2017 06:00
In response to Razor Pages - The Elevator Pitch
There are some concern about razor pages performance. Is it faster or slower than MVC? would you a a...

Cyrus 26/05/2017 05:44
In response to Razor Pages - Understanding Handler Methods
well done, thank you....

Satyabrata Mohapatra 23/05/2017 11:41
In response to Razor Pages - Understanding Handler Methods
Nice and easy !! Great post....

Cyrus 16/05/2017 19:55
In response to Razor Pages - Getting Started With The Preview
There is something wrong related to microsoft.dotnetcore.mvc.taghelpers! if you remove it from page...

Cyrus 16/05/2017 10:18
In response to Razor Pages - Getting Started With The Preview
well done mike, it was very useful, I really appreciate that....

Satyabrata Mohapatra 16/05/2017 07:21
In response to Razor Pages - Getting Started With The Preview
Finally!!!! web pages in core!!! Super excited !!!! Thank u sir for sharing.....Awaiting on...

Daniele 14/03/2017 10:24
In response to Working With Zip Files In ASP.NET MVC
is it possible give to the user a progress bar of the zipping process? Thanks in advance. ...

Suraj 13/03/2017 22:20
In response to Working With Zip Files In ASP.NET MVC
Very nice article. Thanks....

Satyabrata Mohapatra 19/02/2017 03:01
In response to Free SSL Certificates On IIS With LetsEncrypt
Thanks for sharing. Learned a lot !!...

Gfw 03/02/2017 09:48
In response to Free SSL Certificates On IIS With LetsEncrypt
I have used WinSimple for about the last 9 months - works great. One thing that you want to make of...