asp.net web api 2: beginner guide -...

ContentsIntroduction

ImplementingaWebAPIProject

PassingComplexObjectstoaWebAPIMethod

WebAPIClientImplementations

WorkingwiththeHttpClientAPI

AccessingtheWebAPIfromjQuery

PassingaParameterfromjQuery

ScaffoldingwithWebAPI

ScaffoldontheEntityFramework

RoutinginASP.NETWebAPI

AttributeRouting

ImplementingMultipleSerializationMethods

UsingJSONSerialization

UsingXMLSerialization

HelpPageGenerationfromXMLDocumentation

WCFviaWebAPI

References

AbouttheauthorAmbilyhavebeenaMicrosoftMVPin2011andaMicrosoftTechnologyEvangelist.Herfocus area includes .NET technologies, Windows 8, Team Foundation Server andHTML5/jQuery.SheisalsoanauthorforSimple-Talk,CodeProjectanddotnetfunda.Herblogisathttp://ambilykk.com.

Aboutthisbook

ThisshortBookexplainsWebAPIdesign,concepts,features,andhelppagegeneration.This isastarterguidefor thosewhowant toquicklyunderstandthebasicsofWebAPI.Topicscoveredinthisbookare:

ImplementingWebAPIWebAPIClientImplementations–ASP.NETMVCandjQueryScaffoldingwithWebAPI–EntityFrameworkRoutinginWebAPIImplementingMultipleSerializationOptionsHelpPageGeneration

Share your feedbacks, criticisms, and suggestions of improvements toauthor.ambily@outlook.com

IntroductionASP.NETWebAPIisaframeworkforbuildingHTTPservicesthatcanbeaccessedfromvariousclients,suchasbrowsersandmobiledevices.ASP.NETWebAPIwasintroducedaspartofASP.NETMVC4;however,ithasitsoriginsinWCFasWCFWebAPI.Thisnew HTTP service model is simple to develop and contains common HTTP features,includingCaching,StatusCode,andsoon.

Inthisshortbook,wewilldiscussWebAPIdesign,concepts,features,andcompareWebAPIwithWCF.

ImplementingaWebAPIProjectLet’sstartourdiscussionwithasampleWebAPIproject.WewillbeusingVisualStudio2013asourdevelopmentenvironment.OurfirststepwillbetocreateanASP.NETMVCprojectbasedontheWebAPItemplate,asshowninFigure1.

Figure1:CreatinganASP.NETMVCprojectbasedontheWebAPItemplate

Next,we’ll create a samplemodel inside themodel folder in theMVC solution.RightclickontheModelfolderfromthesolutionexplorerandselectAdd->ClassasshowninFigure2.

Figure2:AddnewModel

Forthiswalk-through,IamusingtheProductmodeldefinedinListing1.

Listing1:DefiningtheProductmodel

publicclassProduct

{

publicintId{get;set;}

publicstringName{get;set;}

publicstringCategory{get;set;}

publicdecimalPrice{get;set;}

}

Oncetheproductmodelisready,letuscreateanewAPIcontrollerinsidethecontrollers’folder toprocess theProductmodel.Bydefault, anMVCprojectbasedon theWebAPItemplate adds two controllers: one inherited from theController class and the other fromApiControllerclass.

Right-click the controllers folder in Solution Explorer and add a new controller byselectingtheEmptyAPIcontrolleroptionundertemplateasshowninFigure3.

Figure3:AddEmptyAPIController

Provideappropriatenameforthenewcontroller;sayProductsController.

Figure4:AddController

ProductsController will define two methods for getting list of products and selected

product based on product id. The code for the sample controller should look like thatshowninListing2.

Listing2:AddinganApiControllerclasstothesampleproject

publicclassProductsController:ApiController

{

//Definetheproductslist

List<Product>products=newList<Product>();

///<summary>

///WebAPImethodtoreturnlistofproducts

///</summary>

///<returns></returns>

publicIEnumerable<Product>GetAllProducts()

{

GetProducts();

returnproducts;

}

privatevoidGetProducts()

{

products.Add(newProduct{Id=1,Name=“Television”,Category=“Electronic”,Price=82000});

products.Add(newProduct{Id=2,Name=“Refrigerator”,Category=“Electronic”,Price=23000});

products.Add(newProduct{Id=3,Name=“Mobiles”,Category=“Electronic”,Price=20000});

products.Add(newProduct{Id=4,Name=“Laptops”,Category=“Electronic”,Price=45000});

products.Add(newProduct{Id=5,Name=“iPads”,Category=“Electronic”,Price=67000});

products.Add(newProduct{Id=6,Name=“Toys”,Category=“GiftItems”,Price=15000});

}

///<summary>

///WebAPImethodtoretrurnselectedproductbasedonthepassedid

///</summary>

///<paramname=“selectedId”></param>

///<returns></returns>

publicIEnumerable<Product>GetProducts(intselectedId)

{

if(products.Count()>0)

{

returnproducts.Where(p=>p.Id==selectedId);

}

else

{

GetProducts();

returnproducts.Where(p=>p.Id==selectedId);

}

}

}

RuntheprojectandaccesstheAPIbyappendingtheuniformresourcelocator(URL)with/api/Products,asinhttp://localhost:59509/api/Products.ThisapicallwillreturnthelistofProducts.WecanalsoaccesstheGetProductsmethodbypassingtheSelectedIdargumentaspartofthequerystring:http://localhost:59509/api/Products?SelectedId=2.

By defaultWeb API returns JSON data, so when you run theWeb API directly frombrowser,itwillprompttosaveoropentheJSONoutput.FollowingFigureshowstheapioutputforthe/api/Productsrequest.

Figure5:WebAPIResponse-JSONformat

PassingComplexObjectstoaWebAPIMethodPassingasimplevalueisastraightforwardprocessinWebAPI,butinmostcasesyou’llneedtopassacomplexobjectasamethodparameter.Youcanpasstheseobjectseitherbyusingthe[FromUrl]orbyusing[FromBody]attribute.The[FromBody]attributereadsdatafromtherequestbody.However, theattributecanbeusedonlyoncein themethodparameterlist.

LetusunderstandtheimportanceofusingcomplexparametersusingthecodesnippetinListing3,whichexpectsacomplexobject,Time,asitsinput.

Listing3:Passingacomplexobjectasamethodparameter

publicclassSampleController:ApiController

{

///<summary>

///Getthetimebasedonpassedparameters

///</summary>

///<paramname=“t”></param>

///<returns></returns>

publicstringGetTime(Timet)

{

returnstring.Format(“ReceivedTime:{0}:{1}.{2}”,t.Hour,t.Minute,t.Second);

}

}

publicclassTime

{

publicintHour{get;set;}

publicintMinute{get;set;}

publicintSecond{get;set;}

}

Now,letustrytopassthevaluestotheGetTimemethodusingtheHour,MinuteandSecondvalues.ThiswillthrowtheObjectreferencenotsettoaninstanceofanobjectexception.

Eventhoughwehavementionedthevaluesrelatedtothefieldsof theTimeobject,APImethodisnotabletomapthevaluesproperlytotheparameter.Nowmodifythecodetoinclude the [FromUri] attribute so it canhandle thecomplexobject fromquerystring.Asyoucanseeinthefollowingsnippet,weincludethe [FromUri]attributebeforespecifyingtheTimeobject:

publicstringGetTime([FromUri]Timet)

{––––––-}

InvokethewebAPImethodwiththesamevaluesbeforeandobservetheresult,asshowninFigure5.

Figure6:ReceivingsuccessfulresultswhencallingtheGetTimemethod

WebAPIClientImplementationsWebAPIcanbeconsumedfromdifferentapplicationsincludingwebapplications,clientsidetechnologieslikejQueryandAngularJS,nativemobileapplicationsandsoon.Thissection discuss about how we can invoke Web API from various client applications;ASP.NETMVCandjQuery.

WorkingwiththeHttpClientAPIHttpClient is an extensible API for accessing any services or web sites exposed overHTTP. The HttpClient API was introduced as part of the WCFWeb API but is nowavailableaspartofASP.NETWebAPIin.NETFramework4.5.YoucanuseHttpClienttoaccessWebAPImethodsfromacode-behindfileandfromservicessuchasWCF.

The code snippet shown in Listing 4 creates an HttpClient object and uses it forasynchronousaccesstoproductsAPImethods.Referthecodecommentstounderstandthecodesnippet.

Listing4:CreatinganHttpClientobjecttoaccesssampleAPImethods

//asynchronousaccessingofwebapimethod

asyncTaskGetData()

{

StringBuilderresult=newStringBuilder();

//DefinethehttpClientobject

using(HttpClientclient=newHttpClient())

{

//DefinethebaseaddressoftheMVCapplicationhostingthewebapi

//accessingthewebapifromthesamesolution

client.BaseAddress=newUri(HttpContext.Current.Request.Url.AbsoluteUri);

//Definetheserializationusedjson/xml/etc

client.DefaultRequestHeaders.Accept.Add(

newMediaTypeWithQualityHeaderValue(“application/json”));

//Callthemethod

HttpResponseMessageresponse=client.GetAsync(“api/products”).Result;

if(response.IsSuccessStatusCode)

{

//Converttheresultintobusinessobject

varproducts=response.Content.ReadAsAsync<IEnumerable<Product>>().Result;

foreach(varpinproducts)

{

result.Append(string.Format(“{0}–[Price:{1}Category:{2}]”,p.Name,p.Price,p.Category));

}

}

else

{

result.Append(string.Format(“Error Code:-{0}ErrorDetails:{1}”,(int)response.StatusCode,response.ReasonPhrase));

}

}

data.Text=result.ToString();

}

AccessingtheWebAPIfromjQueryFromanHTML5Webapplication,youcanuse jQuery todirectlyaccess theWebAPI.You call theAPI by using the getJSON()method to extract the business object from theresult. jQuery can identify internal fields associated with the business object, such asdata[i].Price.

ThecodesnippetinListing5retrievesdatafromourProductAPImethodsanddisplaysthedatainatabularformat.Referthecodecommentstounderstandthecodesnippet.Listing5:UsingjQuerytoretrievedatafromtheWebAPImethods

<head>

<title></title>

<scriptsrc=“Scripts/jquery-1.8.2.js”></script>

<scripttype=“text/javascript”>

$.getJSON(“api/products”,

function(data){

//Clearthedivdisplayingtheresult

$(“#productView”).empty();

//Createatableandappendthetablebody

var$table=$(‘<tableborder=“2”>’);

var$tbody=$table.append(‘<tbody/>’).children(‘tbody’);

//data-returnvaluefromtheWebAPImethod

for(vari=0;i<data.length;i++){

//addanewrowtothetable

var$trow=$tbody.append(‘<tr/>’).children(‘tr:last’);

//addanewcolumntodisplayName

var$tcol=$trow.append(“<td/>”).children(‘td:last’)

.append(data[i].Name);

//addanewcolumntodisplayCategory

var$tcol=$trow.append(“<td/>”).children(‘td:last’)

.append(data[i].Category);

//addanewcolumntodisplayPrice

var$tcol=$trow.append(“<td/>”).children(‘td:last’)

.append(data[i].Price);

}

//displaythetableinthediv

$table.appendTo(‘#productView’);

});

</script>

</head>

<body>

<divid=“productView”></div>

</body>

</html>

PassingaParameterfromjQueryIn addition to retrieving data from theWebAPImethods, you can use jQuery to passparameters back to the Web API. jQuery supports several methods for passing theparameters.Thefirstapproachistouseseparateparameterset.Thefollowingcodesnippetdemonstrateshowtopassasingleparameter:

$.getJSON(“api/products”,

{selectedId:‘4’},

function(data){….});

Youcanalsopassmultipleparameterswithinaparameterset,asshowninthefollowingsnippet:

$.getJSON(“api/products”,

{selectedId:‘4’,name:‘TV’},

function(data){….});

AnotherapproachyoucantakeistopassaparameterbyappendingittotheURLquerystring,asshowninthefollowingsnippet:$.getJSON(“api/products?selectedId=4”,

function(data){….});

First approach separates the query string or parameter passing from the URL and isappropriate for complexormultiple data passing.Second approach ismore suitable forpassingoneortwoparameters.

ScaffoldingwithWebAPIASP.NET Scaffolding is a code generation framework for ASP.NETWeb applications.Visual Studio includes pre-installed code generators for MVC and Web API projects.VisualStudioautomaticallygeneratestheAPIcoderequiredtoperformvariousoperationsonthespecifiedmodelordatasource.

ScaffoldontheEntityFrameworkTo demonstrate how scaffolding works in a Web API project, we can use the EntityFrameworktodefineourdatabaseandgeneratetheWebAPImethods.First,weneedtoaddanADO.NETentitydatamodelthatdefinesthedata.

Add an ADO.NET Entity DataModel to the project using the Add new Item contextmenu.

Figure7:NewADO.NETEntityDataModel

Select the Empty EF designer model option to define the models using Model Firstapproach.

NOTE: For more details on different entity framework approaches, refer DifferentApproachesofEntityFramework

Figure8:EmptyEFDesignermodel

Design themodels using the EntityDataModel designer. For the sample, use the data

modelbasedontwotables,CourseandStatus,asshowninthenextFigure.

Figure9:AddinganentitydatamodelbasedontheCourseandStatustables

Afterwedefinethedatamodel,wecangeneratetheWebAPIcontrollerthatcorrespondstothemodel.RebuildtheapplicationtogeneratethecodecontextcorrespondingtotheEFdatamodel.Right-clickControllerandthenclickAddController,whichlunchestheAddScaffolddialog box. Select theWebAPI 2Controllerwith actions, usingEntityFrameworkoptionandclickAdd.

Figure10:AddingacontrollerbasedontheEFdatamodel

This will open theAddController window. Select the Course model from the list ofavailable models and select the container corresponding to the course model for DataContext.

Figure11:AddController

IfyouareplanningtoexecutetheWebAPImethodsinasynchronousmanner,selecttheUseasynccontrolleractionscheckbox.ClickonAddtoaddthenewWebAPIcontroller,courseController basedon actions related to theCoursemodel.Samewayadd theWebAPImethodsfortheStatusmodeltoo.

Listing6showstheautomaticcodegeneratedfortheCourseControllerAPIcontroller.Noticethatitcontainsmethodstosupportget,put,post,anddeleteoperationsthatcorrespondtotheselectedmodel.Listing6:CodegeneratedfortheCourseControllerAPIcontroller

publicclassCoursesController:ApiController

{

privateApplicationDbContextdb=newApplicationDbContext();

//GET:api/Courses

publicIQueryable<Course>GetCourses()

{

returndb.Courses;

}

//GET:api/Courses/5

[ResponseType(typeof(Course))]

publicIHttpActionResultGetCourse(intid)

{

Coursecourse=db.Courses.Find(id);

if(course==null)

{

returnNotFound();

}

returnOk(course);

}

//PUT:api/Courses/5

[ResponseType(typeof(void))]

publicIHttpActionResultPutCourse(intid,Coursecourse)

{

if(!ModelState.IsValid)

{

returnBadRequest(ModelState);

}

if(id!=course.CourseId)

{

returnBadRequest();

}

db.Entry(course).State=System.Data.Entity.EntityState.Modified;

try

{

db.SaveChanges();

}

catch(DbUpdateConcurrencyException)

{

if(!CourseExists(id))

{

returnNotFound();

}

else

{

throw;

}

}

returnStatusCode(HttpStatusCode.NoContent);

}

//POST:api/Courses

[ResponseType(typeof(Course))]

publicIHttpActionResultPostCourse(Coursecourse)

{

if(!ModelState.IsValid)

{

returnBadRequest(ModelState);

}

db.Courses.Add(course);

db.SaveChanges();

returnCreatedAtRoute(“DefaultApi”,new{id=course.CourseId},course);

}

//DELETE:api/Courses/5

[ResponseType(typeof(Course))]

publicIHttpActionResultDeleteCourse(intid)

{

Coursecourse=db.Courses.Find(id);

if(course==null)

{

returnNotFound();

}

db.Courses.Remove(course);

db.SaveChanges();

returnOk(course);

}

protectedoverridevoidDispose(booldisposing)

{

if(disposing)

{

db.Dispose();

}

base.Dispose(disposing);

}

privateboolCourseExists(intid)

{

returndb.Courses.Count(e=>e.CourseId==id)>0;

}

}

TheWebAPIscaffoldingfeaturereducesthedevelopmenteffortrequiredtogeneratetheAPI methods necessary to perform CRUD (create, read, update, delete) operations indifferentmodels.

RoutinginASP.NETWebAPIWebAPIusesroutingtomatchuniformresourceidentifiers(URIs)tovariousactions.TheWebApiConfigfile,locatedinsidetheApp_StartnodeinSolutionExplorer,definesthedefaultroutingmechanismusedbyWebAPI.ThemechanismisbasedonacombinationofHTTPmethod, action, and attribute. However, we can define our own routing mechanism tosupportmeaningfulURIs.

For example, in our sample Web API project, we use /api/Products to retrieve productdetails. However, we can instead use api/Products/GetAllProducts by modifying the defaultroutinglogictoinclude{action}aspartoftheURI,asshowninthefollowingcodesnippet:config.Routes.MapHttpRoute(

name:“DefaultApi”,

routeTemplate:“api/{controller}/{action}/{id}”,

defaults:new{id=RouteParameter.Optional}

);

Afterweupdatetheroute,wecanusetheActionNameattributeinourWebAPImethodtospecifytheactionname,asthefollowsnippetshows:

[ActionName(“GetAllProducts”)]

publicIEnumerable<Product>GetAllProducts()

{……………………………..}

NOTE:Use the [NonAction] attribute to indicate that theWebAPImethod is not anAPIactionmethod.

We can also use an HTTP method or Acceptverbs attribute to specify the HTTP actionrequired to access the Web API method. For example, the following snippet uses theHttpGetandHttpPostmethods:

[HttpGet]

publicIEnumerable<Product>GetProducts(intselectedId)

{…………..}

[HttpPost]

publicvoidAddProduct(Productp)

{…………..}

Formultiplemethods,usetheAcceptsverbsattribute,asshowninthefollowingsnippet:[AcceptVerbs(“GET”,“PUT”)]

publicIEnumerable<Product>GetProducts(intselectedId)

{…………..}

AttributeRoutingWeb API 2 introduced the attribute routing. Earlier versions support the conventionalroutingmechanismdiscussed in last section.This approach is good formaintaining theroutinglogicinoneplaceandapplyconsistentlyacrosstheapplication.But,thisapproachlacktheflexibilityofdefiningtheroutingforobjectswithsubgroupslikeProductsmayhave different categories, bookswill have authors, and so on.Attribute routing addressthisissueandprovidestheflexibilitytodefinetheroutingingranularlevels.

Enabletherouting

ForenablingtheattributeroutinginWebAPI,calltheMapHttpAttributeRoutesduringtheconfiguration. Open theWebApiConfig file, located inside the App_Start node in SolutionExplorer.Followingentrydefinetheattributeroutingcapability.

//WebAPIroutes

config.MapHttpAttributeRoutes();

Thisentrywillbeavailable inASP.NETMVC5basedproject; ifnot availableadd theabovestatementtoenabletheattributerouting.

AddRoute

AddtherouteattributetotheWebAPImethodtodefineattributeroutingforspecificWebAPImethods[Route(“ProductDetail/{selectedId}”)]

publicIEnumerable<Product>GetProducts(intselectedId)

{………………………..}

Above method can be accessed now using http://localhost:59509/ProductDetail/2.NoticethatthenewURLnotevenhavetheapiorcontrollernames.

RoutePrefix

Most of the time the controller will have the same format for the routes for all themethods.publicclassProductsController:ApiController

{

[Route(“api/products”)]

publicIEnumerable<Product>GetProducts(){…}

[Route(“api/products/{id}”)]

publicProductGetProduct(intid){…}

}

WecanuseaRoutePrefixtoavoidtheduplicateentryofprefixesforthewebAPImethodRouteattributes.[RoutePrefix(“api/products”)]

publicclassProductsController:ApiController

{

[Route(””)]

publicIEnumerable<Product>GetProducts(){…}

[Route(“{id}”)]

publicProductGetProduct(intid){…}

}

RoutePrefixwillbeappliedincontrollerlevel.

RouteConstraint

Routeconstraintshelpustorestricttheparameterprocessing.Considertheaboutattributeroutingwherewehavedefinedaparameter‘id’,withoutanyconstraint.Eveniftheclientsendastringvalue,theroutingwilltrytomatchtheparameterandthrowanexceptiondueto typemismatch.Toavoid such runtimeexceptions,wecandefine a constraint for therouteparameters.

Routeconstraintwillbedefinedas

{parameter:constraint}

Eg:-

Integerconstraint-{id:int}

Integerwithmaximumvalueas25–{id:max(25)}

Datetimeconstraint–{startDate:datetime}

Guidconstraint–{id:guid}

We can applymultiple constraints to a parameter by separating each constraint using acolon.

{id:int:min(1)}–indicateanintegerwithaminimumvalueof1.

ImplementingMultipleSerializationOptionsWeb API supports numerous serialization methods, including XML and JSON. In thesectionstofollow,we’lltakeacloserlookathowtoimplementthesethreemethodsandthen compare their behavior. Before doing that, however, let’smodify the sampleWebAPIprojecttoreturnbulkdatasowecanbetterunderstandandcomparetheperformanceof the serializationmethods.Listing7 showshow theGetProducts()methodupdated toreturnbulkdata.

privatevoidGetProducts()

{

for(inti=0;i<5000;i++)

{

products.Add(newProduct{Id=i,Name=“Product-”+i,

Category=“TheASP.NETandVisualWebDeveloperteamshavereleasedtheASP.NETandWebTools2012.2update,whichextendstheexistingASP.NETruntimeandaddsnewwebtoolingtoVisualStudio2012.WhetheryouuseWebForms,MVC,WebAPI,oranyotherASP.NETtechnology,thereissomethingcoolinthisupdateforyou.”

Price=1});

}

}

Listing7:UpdatingtheGetProducts()method

UsingJSONSerializationWebAPIusesJSONasitsdefaultserializationmethod.Asaresult,whenyouruntheWebAPIproject, the results are automatically returned in the JSONformat.For example, toretrieve details from Products, you need only use the syntax http://<<server>>:<<port>>/api/ProductstoreturntheresultsintheJSONformat.

UsingXMLSerializationTo use the XML serialization method in a Web API project, you must modify theGlobal.asax fileby inserting the following two linesofcodeat theendofApplication_Start()method:GlobalConfiguration.Configuration.Formatters.RemoveAt(0);

GlobalConfiguration.Configuration.Formatters.XmlFormatter.UseXmlSerializer=true;

After implementing theXMLserializationmethod,youcanretrievedetails fromProductsbyusingthesyntaxhttp://<<server>>:<<port>>/api/Products,thesamesyntaxusedforJSON.

HelpPageGenerationfromXMLDocumentationBy default, Web API provides help pages related to the API methods defined in theproject.WecangeneratethehelppagesfromtheXMLdocumentationsprovidedaspartofthemethoddefinition.

Tocreate thehelppages, expand theAreas node inSolutionExplorer and thenopen theHelpPageConfig.csfile

Figure12:AccessingtheHelpPageConfig.csfileinthesampleWebAPIproject

IntheHelpPageConfig.csfile,un-commentthefollowingstatement:config.SetDocumentationProvider(newXmlDocumentationProvider(HttpContext.Current.Server.MapPath(“~/App_Data/XmlDocument.xml”

Next,enableXMLdocumentationbyselectingtheXMLdocumentationfileoptionintheBuildsectionoftheproject’sproperties,asshowninFigure11.CopythefilenamespecifiedintheconfigfiletotheXMLdocumentationfileoption.

Figure13:EnablingtheXMLdocumentationfileintheWebAPIproject

Now,let’saddtheXMLdocumentationtooursampleAPIcontroller,asshowninListing9.Justbeforeeachmethoddefinition,specify“///”togetthedefaultXMLdocumentationforthemethod.Modifyfurtherwithmorespecificcomments.

///<summary>

///GetAllproductsforourSample

///</summary>

///<returns></returns>

publicIEnumerable<Product>GetAllProducts()

{

–––––

}

///<summary>

///Returnthedetailsofselectedproductdependsontheproductidpassed.

///</summary>

///<paramname=“selectedId”></param>

///<paramname=“name”></param>

///<returns></returns>

publicIEnumerable<Product>GetProducts(intselectedId)

{

––––––

}

Listing9:AddingXMLdocumentationtothesampleAPIcontroller

Onceyou’veupdatedthecontroller,runtheapplicationandnavigatetoAPIlinkatthetop-rightcornerofthebrowserscreen,asshowninnextFigure.

Figure14:ViewingtheAPIlinkintheapplicationwindow

ClicktheAPI linktoopenthehelppage.NoticetheXMLdocumentationcommentsthathadbeenaddedtothecontroller,asshowninnextFigure.

Figure15:ViewingthecommentsintheWebAPIhelpfile

WCFviaWebAPIWCFsupportsnumerousprotocolsandmessagingformats.WithWebAPI,wecancreateonly HTTP-based services. Obviously, we can create HTTP services with WCF, butthey’re hidden inside different abstraction layers. In addition, implementation is morecomplexwithWCFthanwithWebAPI.HTTPimplementedonWCFusestheHTTPpostmodel,andwemaynotbeabletousethemainfeaturesassociatedwithHTTPprotocolssuchasCachingandStatusCode.ByusingWebAPI,wecanperformallactivities likeget,post,andput,andwecanusedifferentHTTPprotocolfeatures.

WCF requires complex binding and addressmanipulation and configurations, butWebAPI is straightforwardandsimple touse.WebAPI isalsoabetterchoice forRESTfullservicecreation.YoucanfindadetailedcomparisonbetweenWCFandWebAPIin theMSDNarticle“WCFandASP.NETWebAPI.”

References1. [DifferentApproachesofEntityFramework]

https://www.simple-talk.com/dotnet/.net-framework/different-approaches-of-entity-framework/

2. [WCFandASP.NETWebAPI]http://msdn.microsoft.com/en-us/library/jj823172.aspx