Gunnar Peipman's ASP.NET blog : Web Services

Developing Delicious applications

DigiMortal — Sat, 15 Aug 2009 11:51:00 GMT

I am developing a little piece of software that interacts with Delicious through HTTP API. Using Delicious API puts you one responsibility – use their service carefully. Don’t flood it and don’t stress it some other way. In this posting I will show you how to get bookmarks from Delicious and how to use their service without stressing it pointlessly.

Why Delicious? Because I keep my bookmarks there. If you are interested in my selection you can always check out what new bookmarks I have. I try to add new bookmarks as often as I find something useful.

Connecting to Delicious

I am using very simple custom class to query my bookmarks at Delicious. My class connects to Delicious using my username and password. As my class is still very yound it has some not so nice things – like hardcoded UrlPrefix. But it is okay for now.

public class DeliciousClient
{
    private readonly string _userName;
    private readonly string _password;
 
    private string UrlPrefix = "https://api.del.icio.us/v1/";
 
    public DeliciousClient(string userName, string password)
    {
        _userName = userName;
        _password = password;
    }
  
    public IList<Bookmark> GetBookmarks(DateTime fromDate,       
                                        DateTime toDate)
    {
        var url = "posts/all?";
        url += "fromdt=";       
        url += fromDate.Date.ToString("yyyy-MM-ddThh:mm:ssZ");
        url += "&todt=";       
        url += toDate.Date.ToString("yyyy-MM-ddThh:mm:ssZ");
 
        string result = RequestData(url);
     
        // Parse XML and return list of bookmarks
    }
 
    private string RequestData(string uri)
    {            
        using (var client = new WebClient())
        {
            var credential = new NetworkCredential(_userName,       
                                  _password);       
      
            client.Credentials = credential;
            var url = UrlPrefix + uri;
            var result = client.DownloadData(url);
  
           return Encoding.Default.GetString(result);
        }            
    }
}

Using this code I am able to connect to Delicious and run my queries to get data. But if I connect to often then Delicious handles my requests as flooding and stops access for hours. With little efforts we are able to avoid it.

Caching queries

To avoid real connections to Delicious we can cache query results for us. Just perform there steps:

Put break-point somewhere where you are able to get pure XML response (RequestData method is good candidate).
Connect to Delicious through your code.
When break-point is hit copy the XML result to clipboard.
Stop your program.
Create new XML-file called DeliciousResponse.xml to bin\Debug folder.
Paste XML to this file and save it.

Now a little trick. We have Debug and Release configurations available out-of-box in Visual Studio. Let’s use them now. Debug configuration defines DEBUG constant for preprocessor. We can therefore write a code that is executed if DEBUG is there.

If DEBUG is defined we will read data from XML-file we created previously. The code is here for GetBookmarks method.

public IList<Bookmark> GetBookmarks(DateTime fromDate,       
                                    DateTime toDate)
{
    var url = "posts/all?";
    url += "fromdt=";       
    url += fromDate.Date.ToString("yyyy-MM-ddThh:mm:ssZ");
    url += "&todt=";       
    url += toDate.Date.ToString("yyyy-MM-ddThh:mm:ssZ");
 
    string result;
#if DEBUG
    using (var reader = new StreamReader(File.OpenRead      
                            ("DeliciousResponse.xml")))
    {
        result = reader.ReadToEnd();
    }
#else
    result = RequestData(url);
#endif
     
    // Parse XML and return list of bookmarks
}

Now you can run your code using Debug configuration and avoid requests to Delicious. If you need real data and communication with Delicious you can switch your project to Release configuration. I think it is very simple and powerful solution for now (of course, I will change my mind when requirements to my software change).

That’s it. If you write something cool for Delicious then let also community to know about it.

List of Microsoft training kits

DigiMortal — Thu, 04 Jun 2009 17:59:00 GMT

Microsoft training kits are pretty good things to explore when you start learning some new technology. Here are links to some training kits I found to be interesting and useful. Some of these live also in my laptop and when I have free moments I explore them to learn more about these technologies. So, the list of training kits is here:

If there are cool training kits that are not in this list then please let me know. :)

Creating DTOs using AutoMapper

DigiMortal — Sun, 01 Mar 2009 18:00:00 GMT

There is one small and nice object to object mapper called AutoMapper. I gave it a little try and I found it very useful. Specially if you have web service and you are using DTOs to move data between client and server. Good news is that AutoMapper is able to perform these mappings and you don't have to write more code than couple of lines. Let’s see example.

Suppose you have following classes: Order, OrderLine, Customer and OrderDto. OrderDto is DTO we are using to send order data to client. I have really simple classes for example purposes, so don’t try to find any good practices here.

public class Party
{
    public string DisplayName { get; set; }
}
 
public class Order
{
    public string OrderNo { get; set; }
    public DateTime OrderDate { get; set; }
    public List<OrderLine> OrderLines { get; set; }
    public Party Customer { get; set; }
 
    public decimal GetTotal()
    {
        var query = from line in OrderLines
                    select line;
        return query.Sum<OrderLine>(a => a.Sum);
    }
}
 
public class OrderLine
{
    public string LineItem { get; set; }
    public decimal Sum { get; set; }
}
 
public class OrderDTO
{
    public string CustomerDisplayName { get; set; }
    public string OrderNo { get; set; }
    public DateTime OrderDate { get; set; }
    public decimal Total { get; set; }
 
    public static OrderDTO Create(Order order)
    {
        var dto = new OrderDTO();
        dto.CustomerDisplayName = order.Customer.DisplayName;
        dto.OrderDate = order.OrderDate;
        dto.OrderNo = order.OrderNo;
        dto.Total = order.GetTotal();
        return dto;
    }
}

DTO creation and initialization is done in OrderDTO.Create() method. The code here is short if we compare it to real life DTOs. And usually we write this code manually. Here is the code that creates order and asks order DTO from OrderDTO class.

public void ClassicDTOExample()
{
    var party = new Party();
    party.DisplayName = "Smith, John";
 
    var order = new Order();
    order.OrderDate = DateTime.Now;
    order.Customer = party;
    order.OrderNo = "102";
 
    order.OrderLines = new List<OrderLine>();
    order.OrderLines.Add(      
            new OrderLine() { LineItem = "Tea", Sum = 10 }       
        );
    order.OrderLines.Add(      
            new OrderLine() { LineItem = "Coffee", Sum = 15 }       
        );
    order.OrderLines.Add(      
            new OrderLine() { LineItem = "Juice", Sum = 5 }       
        );
 
    var dto = OrderDTO.Create(order);
}

Now let’s see how AutoMapper works. All we have to is to define mappings and use names of class members so auto mapping can take place. We need to modify OrderDTO class and remove Create() method. Our example code also changes a little bit.

public class OrderDTO
{
    public string CustomerDisplayName { get; set; }
    public string OrderNo { get; set; }
    public DateTime OrderDate { get; set; }
    public decimal Total { get; set; }
}
 
public void AutoMapperDTOExample()
{
    var party = new Party();
    party.DisplayName = "Smith, John";
 
    var order = new Order();
    order.OrderDate = DateTime.Now;
    order.Customer = party;
    order.OrderNo = "102";
 
    order.OrderLines = new List<OrderLine>();
    order.OrderLines.Add(      
            new OrderLine() { LineItem = "Tea", Sum = 10 }       
        );
    order.OrderLines.Add(      
            new OrderLine() { LineItem = "Coffee", Sum = 15 }       
        );
    order.OrderLines.Add(      
            new OrderLine() { LineItem = "Juice", Sum = 5 }       
        );
 
    Mapper.CreateMap<Order, OrderDTO>();
 
    var dto = Mapper.Map<Order, OrderDTO>(order);
}

As you can see we have now one method less to test and worry about. Pay attention to DTO member names – I chose names so that AutoMapper can understand what members of order and OrderDTO match. If I look what is inside order DTO created by AutoMapper I see something like this in my locals window.

The most interesting here is OrderDTO member Total. If you look at code above you can see that Order class has method GetTotal(). The value of GetTotal() was automatically mapped to Total property of OrderDTO class.

Although AutoMapper is pretty new and I’m not sure how good it is for using in production code I am sure that another tool for everydays work is coming.

DTO - not only for web services

DigiMortal — Fri, 18 Jul 2008 05:47:00 GMT

Usually developers think that DTO (Data Transfer Object) is something related to web services where data serialization is required to move data from one point of network to another. It is clear that in most cases there is no point to move complex data structures over network when client side needs this data in pretty simple form. That's why DTOs are created - they are simple, easily serializable and there is no data that client side doesn't need. But there are also other DTOs you may find useful.

User Interface DTOs

User Interface (UI) may also need some DTOs. By example, data bound controls try usually to save bounded data to their ViewState. But what happens when data source is list on some objects and not DataTable as we can usually see from beginner tutorials? DataTable is serializable and therefore it is easy to save DataTable to ViewState. But objects are often not marked as serializable and binding them to data bound controls may cause exceptions.

This problem can be solved using DTOs. We can create DTOs as flat objects that are serializable. They doesn't contain any child objects - only properties with their values. We can wrap source data to DTOs and bind list of these DTOs to our data bound controls.

Search criteria DTOs

In one of our current project we are using some DTOs to define search criterias. These DTOs are also flat ones because they store only ID-s of search conditions, string tokens and dates. There is one main search DTO and some internal search DTOs. This far we are happy with this solution because if we design those DTOs carefully they are very easy and convenient to use in client code.

Search sitemap DTOs

ASP.NET Futures has support for search engine sitemaps (follow this reference to take a look at the code examples). To let it create a search engine sitemap for products you must define class for products that has specific attributes required by sitemap generating system. This object is also simple DTO because it has no complex attributes.

I am sure that there are many more DTOs, these three were just examples of some additional DTOs besides DTOs we are using with web services. Okay, and as a last word - DTO is design pattern refered also to as Value Object in Sun.

Using WCF Services with PHP

DigiMortal — Mon, 17 Sep 2007 08:32:00 GMT

I recently wrote two postings on the subject of WCF services: WCF Services – Let's Get Started and WCF and Unit Tests. One could see that creating and testing services was not complicated at all. Let's go on and take some steps nearer to the real world – our service is used by SOAP clients running on different platforms.

I conducted my first experiment with PHP. PHP is widely used in the world of the Web and in all likelihood there will dawn a day when DT is asked just for such an integration. As PHP4 development and support is soon going to be discontinued, I didn't bother with an example using PHP4 SOAP tools. PHP5 is on the market and it comes with a quick and stable SOAP library. The performance is many times better than in case of similar widgets written for PHP4.

I have Apache and PHP5 running on Windows and for SOAP support I have to use an extension named php_soap.dll. Thus, I have to remove the comment mark in front of the appropriate php.ini line and restart Apache.

As an example I will present a PHP code calling the service's Add() method and writing the result on the screen. An example of WCF code can be found in our blog, in the posting WCF Services – Let's Get Started.

<?php
header('Content-Type: text/plain');

echo "WCF Test\r\n\r\n";

$client = new SoapClient('http://gamma/wcftest/MathService.svc?wsdl');
$obj->x = 2.5;
$obj->y = 3.5;
$retval = $client->Add($obj);

echo "2.5 + 3.5 = " . $retval->AddResult;
?>

If nothing went wrong, the result should be something like this:

    WCF Test
    2.5 + 3.5 = 6

As you can see, using WCF services in PHP is very simple. The SOAP library provided along with PHP5 does a great deal of the work "behind the curtains", leaving us with an easily readable brief code.

WCF and Unit Tests

DigiMortal — Wed, 12 Sep 2007 22:03:00 GMT

Good practices demand tests for every new thing you have been able to get running. Otherwise our TDD chief is glum and moody during smoke breaks. So, to maintain the ever cheerful and busy climate in our office, this posting is going to discuss testing.

After installing WCF and getting it to work I also installed everything required for unit tests. It means I installed NUnit and TestDriven.Net and added a tests project to the project mentioned in the previous posting discussing WCF. I created an ordinary DLL library project for the tests, so it could be used with versions of Visual Studio that do not have built-in tests.

To use NUnit with a testing project you have to add a reference to nunit.framework.dll located under Program Files in the NUnit bin directory. This completes all preparations and we can continue with the tests.

New Methods for the Service

To have more things to test I added a couple of new methods to the service. Nothing complicated, just subtraction, multiplication and division, to cover all the four basic operations. Thus, we have to change the service contract and service class. The changes are as follows.

[ServiceContract()]
public interface IMathService
{
    [OperationContract]
    double Add(double x, double y);
    [OperationContract]
    double Subtract(double x, double y);
    [OperationContract]
    double Divide(double x, double y);
    [OperationContract]
    double Multiply(double x, double y);
}

public class MathService : IMathService
{
    public double Add(double x, double y)
    {
        return x + y;
    }
    public double Subtract(double x, double y)
    {
        return x - y;
    }
    public double Multiply(double x, double y)
    {
        return x * y;
    }
    public double Divide(double x, double y)
    {
        return x / y;
    }
}

Unit Tests

For testing I created a class named MathServiceTest. We also have to add a Service Reference to the project and provide it with the URL to the MathService service. When the service is in place we can continue with the tests class.

To prevent creating and closing the service connection at every step we will connect to the service at the beginning of testing and disconnect after completing the tests.

using System;
using System.Collections.Generic;
using System.ServiceModel;
using System.Text;
using NUnit.Framework;
using WCFTestTests.gamma;

namespace WCFTestTests
{
    [TestFixture]
    public class MathServiceTest
    {
        private MathServiceClient client;
        
        [TestFixtureSetUp]
        public void Initialize()
        {
            this.client = new MathServiceClient();
            this.client.Open();
        }

        [TestFixtureTearDown]
        public void TearDown()
        {
            if (this.client.State != CommunicationState.Closed)
                this.client.Close();
        }
    }
}

Next, we will add testing methods for all methods of the service.

using System;
using System.Collections.Generic;
using System.ServiceModel;
using System.Text;
using NUnit.Framework;
using WCFTestTests.gamma;

namespace WCFTestTests
{
    [TestFixture]
    public class MathServiceTest
    {
        private MathServiceClient client;
        
        [TestFixtureSetUp]
        public void Initialize()
        {
            this.client = new MathServiceClient();
            this.client.Open();
        }

        [TestFixtureTearDown]
        public void TearDown()
        {
            if (this.client.State != CommunicationState.Closed)
                this.client.Close();
        }

        [Test]
        public void AddTest()
        {
            Assert.AreEqual(5, client.Add(2, 3));
        }

        [Test]
        public void SubtractTest()
        {
            Assert.AreEqual(3, client.Subtract(8, 5));
        }

        [Test]
        public void MultiplyTest()
        {
            Assert.AreEqual(12, client.Multiply(2, 6));
        }

        [Test]
        public void DivideTest()
        {
            Assert.AreEqual(4, client.Divide(12, 3));
        }
    }
}

Let's start the NUnit GUI and run the test.

Press the right mouse button on the tests project, select Test With from the menu
and then NUnit from the submenu. The NUnit GUI opens.

NUnit GUI displays all classes containing tests, and tests included in the classes.
Tests can be run within a specific class, if required.

It seems I got lucky – all tests have succeeded!

If nothing went wrong all tests are displayed in green. It means we can safely say the service code works correctly. It went well with me this time, I hope you are as lucky or even luckier than I.

Coverage Test

At first, I didn't want to touch the Coverage Test at this time. When I started it, however, I noticed something that should be mentioned here, to widen the reader's horizons.

Let's start the coverage test. It's located in the same menu as the NUnit GUI. TestDriven.Net comes with NCover that enables us to run coverage tests. TestDriven.Net completes the coverage test automatically. You only have to select the appropriate item from the menu, and the results are displayed in a window.

Coverage test failed – code exists that is never run for our project,
unless we change the code.

As we can see the coverage test fails. Methods exist that are never used. These methods have been generated by the service's proxy generator and they are the four overloads of the proxy constructor.

If required, we can remove these constructors from the service's proxy, but refreshing the service causes these constructors to be automatically regenerated. If anybody knows how to prevent it, a comment would be welcome.

Summary

To sum it up, I can say that testing WCF services is not complicated as long as the services are simple. The development environment with all necessary tools can be created quickly and one can begin working almost at once. In addition to Unit Tests testDriven.Net also provides our development environment with Coverage Tests.

As I am dealing with a more complicated SOAP project at the moment, I am quietly contemplating the most effective way of testing the SOAP layer architecture after getting it in place. Anyway, it will certainly give me material for a couple of longer postings.

WCF Services – Let's Get Started

DigiMortal — Wed, 12 Sep 2007 16:31:00 GMT

In connection with testing WCF services I had to get the services to work under IIS on my development computer. The default WCF services library created by Visual Studio does not automatically include IIS support. There were other small glitches that I was able to overcome nicely, in spite of everything.

Server

For starters I created a simple service that adds two figures together. What a classic, isn't it? When creating the service, I selected WCF Service Library as the project type. The service file named MathService.cs appears as follows.


using System; 
using System.Collections.Generic; 
using System.Text; 
using System.ServiceModel; 
using System.Runtime.Serialization;
namespace WCFTest 
{ 
    [ServiceContract()] 
    public interface IMathService 
    { 
        [OperationContract] 
        double Add(double x, double y); 
    } 
    public class MathService : IMathService 
    { 
        public double Add(double x, double y) 
        { 
            return x + y; 
        } 
    } 
}

IIS was the next issue. Mapping the project directory under IIS turned out to be pretty pointless as under IIS all application binaries are searched from the /bin directory but on compilation the files are created in the /bin/Debug directory instead. As workaround I wrote some post-build commands for the WCF service project, copying all necessary files to IIS directories as required. Of course, the IIS directory has to be defined as an IIS application.

Next I dealt with the service configuration.

<?xml version="1.0"?>
<configuration> 

  <system.web>
     <compilation debug="false"/>
     <authentication mode="Windows"/>
   </system.web>

    <system.serviceModel>
     <services>
       <service name="WCFTest.MathService"
           behaviorConfiguration="MathServiceBehavior">
           <endpoint address="" 
                  binding="basicHttpBinding"
                  contract="WCFTest.IMathService" />
           <endpoint contract="IMetadataExchange"
                  binding="mexHttpBinding"
                  address="mex" />
       </service>
     </services>
     <behaviors>
       <servicebehaviors>
         <behavior name="MathServiceBehavior"> 
          <servicedebug includeExceptionDetailInFaults="False" />
          <servicemetadata httpGetEnabled="true" /> 
        </behavior> 
      </servicebehaviors> 
    </behaviors> 
    
  </system.serviceModel> 

</configuration>

And now the most exciting part – how to make the service visible under IIS. Creating a file with the service's name and svc extension is sufficient. In my case MathService.svc. The content of the file is simple – it is used to set the name of the service class.

<%@ServiceHost language=c# Debug="true" Service="WCFTest.MathService" %>

Now the service part should be up. It is quite easy to check – you only need to compile the service and enter its URL in the browser. If anything is wrong, we'll get an error message. If everything is OK, we will see a page introducing the service, with the URL of the service's WSDL in the upper part.

Client

To test the service I created a simple client program that adds two figures together and displays the result.

using System; 

using System.Collections.Generic; 
using System.Text; 
using WCFTestConsole.MathService;

namespace WCFTestConsole
{
     class Program
     {
         static void Main(string[] args)
         {
             MathServiceClient client = new MathServiceClient();
             Console.WriteLine("2 + 3 = " + client.Add(2, 3));
             Console.WriteLine("Press any key to exit");
             Console.ReadLine();
        } 

    }     
}

Here I discovered something new and interesting – hooking up the service as a web service behaves differently from adding it as a WCF service. In case of SOAP the wrapper methods created are completely different. They have twice as many arguments as the service method plus two additional arguments for the returned result. Every argument and returned result has an additional Boolean-type parameter indicating whether this parameter has been set or not.

When hooking up the service by adding the service reference to the project, these parameters are not generated because the WCF client is able to solve the situation by itself.

You can read more on this topic from Eugene Osovetsky's blog posting Solving the "disappearing data" issue when using Add Web Reference or Wsdl.exe with WCF services.

Now you have everything you need to get started with WCF and test the results, so I can only wish you success with WCF.