Creating API with MVC ApiController part 2

In my previous post I wrote about first steps in creating Rest-full API by using ApiController. Now it`s time to make next step and go a little bit dipper inside web services created in MVC. In this post I want to describe two very important aspect:

• creating a real life scenario for web service implementation of POCO entity
• extend presented scenario and make it asynchronous

To complete this tutorial one more class is needed. This class is a simple fake of some database which  is wrapper around a very few collections and allow all CRUD operation. Moreover the implementation of this fake database uses a singleton design pattern to prevent creating instance of it each time and maintain state between web service calls.

Code Snippet

86. /// <summary>
87.         /// Represents a fake database.
88.         /// </summary>
89.         public sealed class FakeDbContext
90.         {
91.             private static volatile FakeDbContext instance;
92.             private static object syncRoot = new Object();
93.  
94.             private FakeDbContext()
95.             {
96.                 this.Users = new List<User>();
97.                 this.Dictionary = new Dictionary<string, string>();
98.             }
99.  
100.             public static FakeDbContext Instance
101.             {
102.                 get
103.                 {
104.                     if (instance == null)
105.                     {
106.                         lock (syncRoot)
107.                         {
108.                             if (instance == null)
109.                                 instance = new FakeDbContext();
110.                         }
111.                     }
112.  
113.                     return instance;
114.                 }
115.             }
116.  
117.             public List<User> Users { get; set; }
118.  
119.             public Dictionary<string, string> Dictionary { get; set; }
120.         }

The real life scenario that we want to implement is a simple web service which expose all CRUD operation and of course it`s base on REST. In the following class each API functions return the same type HttpResponseMessage which represent a standard HTTP response. This type contains two important properties: StatusCode - which represent a  HTTP response status code and Content - which store body of the response if any. The the easiest to produce a HttpResponseMessage is calling one of many build-in functions which are responsible for creating a fully qualified response based on several input parameter:

• Request.CreateResponse - the simplest method for returning any type of response with or without content
• Request.CreateResponse<T>  - create a success response with content of T type
• Request.CreateErrorResponse - create  a error response and requires to specify HTTP code status and exception

Code Snippet

125. /// <summary>
126.         /// Represent a controller for managing <see cref="User"/>.
127.         /// </summary>
128.         public class UserController : ApiController
129.         {
130.             public UserController()
131.             {
132.                 if (!FakeDbContext.Instance.Users.Any())
133.                 {
134.                     FakeDbContext.Instance.Users = new List<User>()
135.                 {
136.                     new  User(){ Id = 1, FirstName = "Roberto", LastName="Carlos", Email="robi_carlo@gmail.com"},
137.                     new  User(){ Id = 2, FirstName = "Zinédine", LastName="Zidane", Email="zizu@live.com"},
138.                     new  User(){ Id = 2, FirstName = "Peter", LastName="Schmeichel", Email="scheisse@yahoo.com"},
139.                 };
140.                 }
141.             }
142.  
143.             // GET api/person
144.             [HttpGet]
145.             public HttpResponseMessage Get()
146.             {
147.                 return Request.CreateResponse<ReadOnlyCollection<User>>(HttpStatusCode.OK, FakeDbContext.Instance.Users.AsReadOnly());
148.             }
149.  
150.             // GET api/person/5
151.             [HttpGet]
152.             public HttpResponseMessage Get(int id)
153.             {
154.                 var resultUser = FakeDbContext.Instance.Users.FirstOrDefault(u => u.Id == id);
155.                 if (resultUser == null)
156.                 {
157.                     return Request.CreateErrorResponse(HttpStatusCode.NotFound, "User dones`t exists.");
158.                 }
159.  
160.                 return Request.CreateResponse<User>(HttpStatusCode.OK, resultUser);
161.             }
162.  
163.             // POST api/person
164.             [HttpPost]
165.             public HttpResponseMessage Post(User value)
166.             {
167.                 if (value == null)
168.                 {
169.                     return Request.CreateErrorResponse(HttpStatusCode.BadRequest, "Null User object.");
170.                 }
171.  
172.                 // Checking user already exists in a list.
173.                 if (FakeDbContext.Instance.Users.Contains(value))
174.                 {
175.                     return Request.CreateErrorResponse(HttpStatusCode.Conflict, "User already exists.");
176.                 }
177.                 else
178.                 {
179.                     FakeDbContext.Instance.Users.Add(value);
180.                 }
181.  
182.                 return Request.CreateResponse(HttpStatusCode.Created);
183.             }
184.  
185.             // PUT api/person/5
186.             [HttpPut]
187.             public HttpResponseMessage Put(int id, [FromBody] User value)
188.             {
189.                 if (value == null)
190.                 {
191.                     return Request.CreateErrorResponse(HttpStatusCode.BadRequest, "Null User object.");
192.                 }
193.  
194.                 if (!FakeDbContext.Instance.Users.Any(u => u.Id == id))
195.                 {
196.                     return Request.CreateErrorResponse(HttpStatusCode.NotFound, "User dones`t exists.");
197.                 }
198.                 else
199.                 {
200.                     FakeDbContext.Instance.Users.Remove(value);
201.                     FakeDbContext.Instance.Users.Add(value);
202.                 }
203.  
204.                 return Request.CreateResponse(HttpStatusCode.OK);
205.             }
206.  
207.             // DELETE api/person/5
208.             [HttpDelete]
209.             public HttpResponseMessage Delete(int id)
210.             {
211.                 var personToDelete = FakeDbContext.Instance.Users.FirstOrDefault(u => u.Id == id);
212.                 if (personToDelete == null)
213.                 {
214.                     return Request.CreateErrorResponse(HttpStatusCode.NotFound, "User dones`t exists.");
215.                 }
216.                 else
217.                 {
218.                     FakeDbContext.Instance.Users.Remove(personToDelete);
219.                 }
220.  
221.                 return Request.CreateResponse(HttpStatusCode.OK);
222.             }
223.         }

Now our service is ready to use and we run it and we can call each GET, POST, PUT and DELETE function by using any of HTTP Client.

Picture 1. Calling GET and POST API  from test HTTP Client.

Whole source code of the project is available here.

Thank you.