Create Image Server using WCF WEB HTTP Service

Last post I wrote on WCF Web HTTP Service: why and how. This post was for beginners in which I discussed how to get it started and write your fist WCF WEB HTTP Service. In this post we will go one step further and learn to work with streams or to be precisely images. Service will return image based on the input from client. We are going to create an image server. Image server will do following task

  • Read requested image from file system on server
  • Convert that to stream
  • Return stream to clients

We are going to create WCF WEB HTTP Service which will act as image server. So to start with let us create Service Contract.

 


using System.IO;
using System.ServiceModel;
using System.ServiceModel.Web;

namespace Demo1
{    
    [ServiceContract]
    public interface IService1
    {
        [OperationContract]
        [WebGet]
        Stream FetchImage(string imageName);      
       
    }
}


In above Service, there is one Operation Contract which returns a stream. Operation Contract can be accessed using baseurl/FetchImage?imageName={imagename with extension}. Client will pass image name in query parameter to fetch a particular image. If image is not present on image then null would be returned from service.

Service implementation is very simple. You need to do following steps to fetch image and return it as stream.

Step 1: First check for existence of the image. If it exists got to step 2 else go to step 4

Step 2: Read image as FileStream

Step 3: Set Outgoing Request Content Type as image/jpeg

Step 4: convert string Image does not exist as stream and return

Service is implemented as below,


public class Service1 : IService1
    {       

        public Stream FetchImage(string imageName)
        {
            string filePath = @"c:\\" + imageName;

            if (File.Exists(filePath))
            {
                FileStream fs = File.OpenRead(filePath);
                WebOperationContext.Current.OutgoingRequest.ContentType = "image/jpeg";
                return fs;
            }
            else
            {
                byte[] byteArray = Encoding.UTF8.GetBytes(" Requested Image does not exist :(");
                MemoryStream strm = new MemoryStream(byteArray);
                return strm;
            }
        }        
    }


Service implementation is very simple but one line of code in which we are explicitly saying that outgoing response content type is image/jpeg

image

Already we have covered this in previous post about EndPoint configuration but for quick reference open markup of .svc file and add use Factory method System.ServiceModel.Activation.WebServiceHostFactory to create WEB HTTP Service.

image

This is what all you need to do to create an Image Server as WCF WEB HTTP Service. You can test server from IE browser.

image

And if requested image is not present then error message will be rendered as below,

image

Now you can go ahead and consume and work with this image server in any kind of client able to perform HTTP GET operation. In further post we will get into details of consuming this service from various kind of clients. I hope this post will help you.

About these ads

WCF Web HTTP Service: why and how

Very often I talk on WCF to user groups and find developers confused on various forms of WCF. For example some of the questions I get are as follows

  • How to create REST Service
  • Can we create REST and SOAP Service together
  • What is WCF Web HTTP Service
  • How Web HTTP Service and WCF REST Service are different to each other
  • Can I host HTTP Service and REST Service in a console application
  • Why we need REST and HTTP Services
  • What kind of security can be applied on REST and HTTP Services and many more questions of this kind

In this post I will answer few of the above questions regarding WCF Web HTTP Services.

By definition, WCF Web HTTP programming model allows services to be exposed on non-SOAP EndPoints and helps to create WEB HTTP Services. Now a question may arise that why we need HTTP Services and what are the advantages of using that.

Mainly HTTP Services are designed and created for wide range of clients. Any application capable of following can be potential clients

  • Understand HTTP protocols and verbs
  • Can process URI and URL Schemes
  • Can work with different types of message and data formats
  • Perform HTTP Get and HTTP Post operations

Web HTTP Services doesn’t work on SOAP message format however any serilizable type can be returned from Web HTTP Services. Since HTTP Service does not work with SOAP so all WCF Security features cannot be applied on this. However basic Transport level security can be applied to WCF Web HTTP Services.

Let us see how we can create a very basic WCF Web HTTP Service. Create WCF Service Application project from WCF tab to create Web HTTP Service

image

After creation of project we need to create Service Contract.


 [ServiceContract]
    public interface IService1
    {

        [OperationContract]
        [WebGet]
        string HelloGet(string   name);

        [OperationContract]
        [WebInvoke]
        string  HelloPost(string  name);
       
    }


Above I have created very basic service. Service contains only two methods. One method will work on HTTP GET and other will work on HTTP POST operation. There are restrictions on passing parameters in query string. For example string can be passed in query parameter.


public class Service1 : IService1
    {       

        public string HelloGet(string name)
        {
            return "Hello GET " + name; 
        }

        public string HelloPost(string name)
        {
            return "Hello POST" + name; 
        }
    }



Above Service Contract is implemented as below. It’s very simple implementation in which service is returning string with concatenating of input string parameters.

Now there are various ways WCF WEB HTTP Services can be hosted and its EndPoint can be configured. You can configure and host service

  • In IIS
  • In Windows Services Application
  • In Managed Application like Console Application
  • Windows Azure Services

In this post let us learn how EndPoint can be configured for Web Server hosting like IIS. It’s very simple to configure EndPoints for HTTP Services. You can use Factory method System.ServiceModel.Activation.WebServiceHostFactory to create WEB HTTP Service.

image

You can fetch service from browser by navigating to URL as below. Keep in mind that port number could be different in your scenario.

http://localhost:55400/Service1.svc/HelloGet?name=dj

You can notice that we are passing input dj as string in query parameter. Response from service will be as below,

image

Another way service can be configured and hosted in a console application. In Console Application first you need to add reference of System.ServiceModel and System.ServiceModel.Web in the project.


using System;
using System.ServiceModel;
using System.ServiceModel.Description;
using System.ServiceModel.Web;
using Demo1;

namespace ConsoleAppHostingService
{
    class Program
    {
        static void Main(string[] args)
        {
            WebServiceHost host = new WebServiceHost(typeof(Service1), new Uri("http://localhost:8989/"));
            ServiceEndpoint endpoint = host.AddServiceEndpoint(typeof(IService1), new WebHttpBinding(), "");
            ServiceDebugBehavior sdb = host.Description.Behaviors.Find<ServiceDebugBehavior>();
            sdb.HttpHelpPageEnabled = false;
            host.Open();
            Console.WriteLine("Service is running");
            Console.WriteLine("Press enter to quit...");
            Console.ReadLine();
            host.Close();

        }
    }
}


Few points about above hosting code are as follows

  • WEB HTTP Service should be hosted in a WebServiceHost instance.
  • WebHttpBinding is used to created HTTP Service
  • Help page is disabled

On running Console Application, service can be accessed on URL passed in WebServiceHost instance

image

In this way you can create WCF WEB HTTP Service. In further posts we will learn how to consume this service in various kind of clients and work with different kind of data format. I hope this post will help you.

CRUD operation on ASP.NET Web API from .NET client

In this post we will learn to work with CRUD operation on ASP.NET Web API. We will learn

  • To create CRUD operation on ASP.NET Web API
  • Using Entity model to create model
  • Creating repository to perform CRUD operation
  • Consuming service in .NET Console Client

I can draw architecture of this blog post as following,

image

Let us follow step by step approach to perform CRUD operation using ASP.NET Web API service.

Create ASP.Net Web API

In this part of blog, we will learn to create ASP.NET Web API. To create launch Visual Studio and create a project by choosing ASP.NET MVC 4 Web Application template.

image

Next you select Web API from the existing project template. Make sure to select Razor as View engine in drop down.

clip_image002

Next we need to add model. We will use ADO.Net Entity model to create model out of database. To add model, right click on the Models folder and select Add New Item. Next from Data tab select ADO.NET Entity Data Model

clip_image004

Next select Generate from database option and click on Next.

clip_image005

In next dialog box, you need to configure Connection Properties. Here select Northwind database after giving server name.

clip_image006

After configuring connection, you will get Entity Data Model Wizard populated with connection string as below. Click on next to proceed further

clip_image007

Here you need to select tables, views etc. For purpose of this post, let us select three tables, Customers, Employees and Products. After selecting tables click on Finish to create model of database in project.

clip_image008

We are going to work with Product table. To perform CRUD operation on this, let us go ahead and created a Repository. To create this right click on model and add an Interface from Code tab. I am giving name as IProductRepository.

clip_image010

In this interface we will define all the operations needed to be performed on Product table. Interface is defined as below,


using System.Collections.Generic;

namespace NorthwindService.Models
{
    public  interface IProductRepository
    {
        IEnumerable<Product> GetProducts();
        bool AddProduct(Product p);
        bool UpdateProduct(Product p);
        bool DeleteProduct(int ProductID);
    }
}

Next we need to implement CRUD operation. To do that add a class and implement IProductRepository in that class. Let us implement all four operations one by one.

Note : All these operations would be defined under ProductRepository class.

We can fetch all the Products as below by writing simple LINQ

public IEnumerable<Product> GetProducts()
        {
            NorthwindEntities entities = new NorthwindEntities();
            var products = from r in entities.Products select r;
            return products.ToList();
        }


A product can be added as below,


 public bool AddProduct(Product p)
        {
            try
            {
                NorthwindEntities entities = new NorthwindEntities();
                entities.Products.Add(p);
                entities.SaveChanges();
                return true; 
            }
            catch (Exception ex)
            {
                return false; 
            }

        }


Product can be updated as below,


public bool UpdateProduct(Product p)
        {
            try
            {
                NorthwindEntities entities = new NorthwindEntities();
                Product proudctToUpdate = (from r in entities.Products where 
                                               r.ProductID == p.ProductID select r).FirstOrDefault();

                proudctToUpdate.ProductName = p.ProductName;
                proudctToUpdate.UnitPrice = p.UnitPrice;
                entities.SaveChanges();
                return true;
            }
            catch (Exception ex)
            {
                return false;
            }
        }


Product can be deleted as below,


public bool DeleteProduct(int productID)
        {
            try
            {
                NorthwindEntities entities = new NorthwindEntities();
                Product proudctToDelete = (from r in entities.Products
                                           where
                                               r.ProductID == productID
                                           select r).FirstOrDefault();
                entities.Products.Remove(proudctToDelete);
                entities.SaveChanges();
                return true;
            }
            catch (Exception ex)
            {
                return false;
            }
        }

After creating repository for CRUD operation, let us go ahead and create Controller. To create Controller, right click on the Controller folder and select Add new Controller. You need to rename Controller name to ProductsController.

image

You will get controller class created as following. Make sure that you have changed Controller to ApiController

clip_image002[6]

Now we can create CRUD operation as below,

Products can be fetched as below,

static readonly IProductRepository repository = new ProductRepository();

        public IEnumerable<Product> GetProducts()
        {
            return repository.GetProducts();
        }

A new record can be created as following. We are passing Product as a resource to create here. While creating new record make sure

  • Action name is PostProduct. Essentially Action name should be started with Post to perform insert operation
  • Pass Product as input parameter
  • Return HttpResponse

We are calling AddProduct method of Repository class. Repository class is returning true on successful insertion of record. We are checking returned value and constructing returned HttpResponse.


public HttpResponseMessage PostProduct(Product p)
        {
            bool result = repository.AddProduct(p);
            HttpResponseMessage response;
            if(result)
            {
            response  = Request.CreateResponse(System.Net.HttpStatusCode.Created);
            }
            else
            {
                response = Request.CreateResponse(System.Net.HttpStatusCode.ExpectationFailed);
            
            }
            return response ; 
        }

Modification of resource or Put operation can be performed as below. It is exactly same as Put operation with two differences

  • Action or function name starts from Put
  • UpdateProduct function of Repository class is being called.
  public HttpResponseMessage PutProduct(Product p)
        {
            bool result = repository.UpdateProduct(p);
            HttpResponseMessage response;
           if(result)
            {
                response = Request.CreateResponse(System.Net.HttpStatusCode.OK);
            }
            else
            {
                 response  = Request.CreateResponse(System.Net.HttpStatusCode.ExpectationFailed);
            
            }
            return response ; 

        }

Delete of resource or Put operation can be performed as below. It is exactly same as other operation with two differences

  • Action or function name starts from Delete
  • It takes Id as input parameter to delete record with particular id
  • DeleteProduct function of Repository class is being called.

 public HttpResponseMessage DeleteProduct(int id)
        {
            bool result = repository.DeleteProduct(id);
            HttpResponseMessage response;
            if(result)
            {
            response  = Request.CreateResponse(System.Net.HttpStatusCode.OK);
            }
            else
            {
                response = Request.CreateResponse(System.Net.HttpStatusCode.ExpectationFailed);
            
            }
            return response ; 

        }

This is what all you need to do to create ASP.NET Web API with CRUD operation on Northwind database.

Creating .NET or Console Client

We are going to create .NET Console client to consumer service we created earlier. To create Console Application project, you need to select Console Application project template from Windows tab. After creating project, right click on project and select manage Nuget packages. Here search for Microsoft.AspNet.WebApi.Client library. Install this NuGet package in client project.

image

After installing package, add following namespaces in project,


using System.Net.Http;
using System.Net.Http.Headers;

Before we perform any operation, first initialize following in the project. Below

  • Initializing HttpClient
  • Setting base address
  • Setting Http Request Header as JSON
 HttpClient client = new HttpClient();
            client.BaseAddress = new Uri("http://localhost:37780/api/");
          
            client.DefaultRequestHeaders.Accept.Add(
                new MediaTypeWithQualityHeaderValue("application/json"));



After initializing HttpClient and base address, we need to create client side representation of Product class. Let us create Product class at client side. Make sure that definition of class is same as the server side. Client side Product class is as following,


public class Product
    {
        public int ProductID { get; set; }
        public string ProductName { get; set; }
        public Nullable<int> SupplierID { get; set; }
        public Nullable<int> CategoryID { get; set; }
        public string QuantityPerUnit { get; set; }
        public Nullable<decimal> UnitPrice { get; set; }
        public Nullable<short> UnitsInStock { get; set; }
        public Nullable<short> UnitsOnOrder { get; set; }
        public Nullable<short> ReorderLevel { get; set; }
        public bool Discontinued { get; set; }
    }



Read Products from service

You can fetch all the Products as below.



 HttpResponseMessage response = client.GetAsync("products").Result;
            if (response.IsSuccessStatusCode)
            {
                var products = response.Content.ReadAsAsync<IEnumerable<Product>>().Result;
                foreach (var p in products)
                {
                    Console.WriteLine("{0}\t{1};\t{2}", p.ProductName, p.UnitPrice, p.QuantityPerUnit);
                }
            }
            else
            {
                Console.WriteLine("{0} ({1})", (int)response.StatusCode, response.ReasonPhrase);
            }


We are fetching records performing following steps in above code.

  • Records being fetched using GetAsync method of HttpClient class.
  • We are passing name of entity in GetAsync
  • After fetching records reading JSON data using Conent.ReadAsAsync() method of HttpResponseMessage
  • If response is erroneous then we are displaying error code as output.

Creating a Record

To create record or insert a record (in this case Product), we need to perform following steps ,

  • Create instance of product to be inserted
  • Perform PostAsJsonAsync operation on HttpClient and pass entity name and object to be inserted as parameter
  • On successful insertion you will get successful status code else error code.

Following code snippet will create a Product in database perform Put operation using ASP.NET Web API.


 Product p = new Product
            {
                ProductName = "DJ'S Pen",
                QuantityPerUnit = "20",
                Discontinued = true

            };
            HttpResponseMessage response = client.PostAsJsonAsync("products", p).Result;
            if (response.IsSuccessStatusCode)
            {
                Console.WriteLine("{0} ({1})", (int)response.StatusCode, response.ReasonPhrase);
            }
            else
            {
                Console.WriteLine("{0} ({1})", (int)response.StatusCode, response.ReasonPhrase);
            }


On successful creation of record you will get response as below,

clip_image001

Updating Record

Updating record is exactly same as creating record. Only you need to use PutAsJsonAsync() method. You can update a record as below,

Product p = new Product
            {
                ProductID = 90,
                ProductName = "DJ'S Bat",
                QuantityPerUnit = "20",
                Discontinued = true

            };
            HttpResponseMessage response = client.PutAsJsonAsync("products", p).Result;
            if (response.IsSuccessStatusCode)
            {
                Console.WriteLine("{0} ({1})", (int)response.StatusCode, response.ReasonPhrase);
            }
            else
            {
                Console.WriteLine("{0} ({1})", (int)response.StatusCode, response.ReasonPhrase);
            }

On successful update you should get success message as below,

clip_image001[6]

Deleting Record

You can delete a resource using DeleteAsync function. You need to pass URI of the resource to be deleted.


HttpResponseMessage response = client.DeleteAsync("Products/90").Result;
            if (response.IsSuccessStatusCode)
            {
                Console.WriteLine("{0} ({1})", (int)response.StatusCode, response.ReasonPhrase);
            }
            else
            {
                Console.WriteLine("{0} ({1})", (int)response.StatusCode, response.ReasonPhrase);
            }

Here 90 is ProductId we want to delete. On successful deletion you will get success message as below,

clip_image001[8]

Conclusion

In this blog post we learn following items,

  1. Using ADO.NET Entity Model as model in Web API
  2. Creating CRUD operation on ASP.NET Web API
  3. Consuming service in .NET client

I hope you find this post useful. Thanks for reading.