Fault Contract How to communicate error information from a service to a client

Good evening friends I am Dhanja Kumar and I am MEP on Connected System

In this particular video tutorial we are going to learn how we can work with fault contract in WCF

We will see that if you are not handling the exception at the service side

then how the whole proxy is getting failed while a single error is coming at a service site

and we'll look ahead and see how we can handle an exception

handle and exception and expose that exception using fault contract. So for the theoretical part of our technical definition of fault contract and description

of our contract you can refer my other articles. But here in this purpose of this video is to completely show you or rather give you a demo

that how we can achieve a fault contract. So let's go ahead and open your Visual Studio

I have Visual Studio 210. You can do the same thing in Visual Studio 2.2

or to wait also. Just go ahead and create a new WCF service application. What I'm going to do here

What I'm going to do is that first I'll show you my service without handling the exception

and then I'll show you that while we handle the exception how you are going to do that

Just go ahead from WCF tab, select WCF service application project template

Remember if you are using Visual Studio 2008 you will get WCF service application project template

under web tab not in WCF tab. Fine. Give some name here I'm giving his name demo fault service

What I'm going to do here is that I'll create a very simple service which will have only one operation contract and that will do operation of division

It's taking time here. here go ahead and delete whatever default code is given to you by WCF the

purpose of this default code is only to show you that how you can write a simple

service we really don't don't need those codes so what I done here is that I have

deleted all the default code which is getting created by WCF when we are

creating a WCF service I believe here all of you who is, anyone of you who is watching this video, they must be aware of what is operation contract and all

Just create an operation contract which will return a double. and which will take two number two parameters two number of the double type the

purpose of this of operation contract is very simple to or divide two number and

as I told you that our main core purpose of this particular video is to find

out how we can work with fault contract okay now go here and just implement

that so just copy paste that from here make it public return number one

divided by number two. This is a very simple implementation. If you see the code we are just dividing to number

and I am going to rely on the default binding which is given by WCF for in

for in for you and that is wave HTTP sorry WS HTTP binding

let's go ahead and run first compile your service run it

In the main time, again I want to say the same thing is that right now I have written

a service which is not handling the exception. So if some exception is coming at a service side, our client will get that exception in

term of that whole proxy will get corrupted because we are not handling that

We'll see that ahead. Up to this point our service is up and running

Fine. Just copy paste this particular URL that is our end point of our service

And what I'm going to do is that I'm going to open a new Visual Studio and go ahead and just create a console client

Fine enough, this is a very simple console client and add your service here as service reference

Copy place the end point URL, sorry, end point of your service. That's right

of your service does you are a if you see our service is successfully added

that the function and the name is space of your service my project name is

console application 3 so it's that now create a proxy all you know that

service 1 since our service name is service 1 so WCS is already created for your

service 1 client class you can create a proxy using that class what is a proxy

actually proxy is nothing but instance of your service at a client site service is

nothing but a class which is running on on an external machine so really to use that

class you need to instant say that class right so proxy is nothing but

instance of the service at a client's side now we have created that and if you

see prox we can call the div method like a simple other methods of a normal

class and here we need to pass a let us say to parameter 30 and 5 and passing and

and save the result in a variable code result. Print that. Now go ahead and run your client

What I did here is the first line is that I created a proxy of the service In second line normally you know very easily I calling or only one operation contract

given passing the two parameters, two double-intuitive parameter to that function. In third line, I'm just displaying the result which is coming from the service

Let's go ahead and run this particular client application. and here we are getting the expected result 0 right because when you divide 30 by 5

even there is 0 right now what I am going to show you is that just change your

number 2 from 5 to 0 now at a service side we are expecting or divide by 0 exception

because we cannot divide any number by 0 right so here some exception is coming right

and we have some exceptions we are expecting and that particular exception we have not handled at a service site so let's go ahead and again

run and see what's happening we are getting of you know some wire result

we are getting some unexpected you really don't know what is that it means exception is not handled right so what I'm gonna do is that let's handle

the exception and see how we can display a meaningful error message to our client that

what really happening. If we run again, we really are not getting any idea like what is happening, what is

NAN and whatever. In your case you might get a runtime, runtime exception

In my case I'm getting the NAN. If you are using Visual Studio 2008 you might get a runtime exception

So now go ahead to your service. this is my service create instance of divided by zero exception

and we check if number two is equal to equal to zero then only we need

to handle exception right Then what we'll do? To throw new fault exception, that is divided by zero exception

And that takes to parameter one is this exception. And other is you can say number two is zero at service

side. Fine. Now if you see this particular line that why I am using fault

exception slash T, fault exception divided zero exception because if you want to

propagate exception exception from service to a client we need to use the

generic fault exception class rather than rather than rather than the than the normal fault exception class which we normally use in our dot net programs

Because we need to, we really don't need, we really don't know that what type of exception

our service is going to throw at a runtime That is why we need a generic exception So the exception is really the exception which we are using here is that except is a generic exception and that is fault exception T

Now this T can take anything. This T can take any CLR type, this particular T can take any CLR type, this particular T can

take any data contract. Or in our case we are taking it as a data contract. it as a divided by zero exception. Fine

Now, we have implemented the exception or we can say in other words that we have handled

the exception at the service site. But really we need to say to our client that we have handled some exceptions

And that is done through something called fall contract. Type of divide by juries

So our services compile successfully is again run your service. Service is up and running

Now again go back to your client and update your service reference because we have done changes in our service

So we need to update our service reference such that our changes get reflected with a client

Now go ahead and run your service. run your client sorry and here you are getting number two is zero at a

service side right now what you need to do is that why we got this runtime

error because at a client side we have not handled the exception so what we

really need to do is that go to your client before calling this a normal simple dot net exception handling if exception is coming

so catch exception px console dot right line px dot masses now our output should be

Here we are. So number two is your service side. So here in this way using FFAR contract

and F F F F Contract T, the General F F F Contract Plus, we can pass our technology specific

exception to our generic error information to the client. So it was for me in this video for

you that how we can use the FFAR contract and pass the exception message to client

Thank you so much and in further videos I'll show you how we can pass data contact as an exception type to our client. Thank you so much