Fault Contract - Handling Errors in WCF service

What is FaultContract?

How do you handle errors in ASP.NET? It's very simple - just by adding the simple Try & Catch blocks. But when you come to WCF Service, if any unexpected error occurred (like SQL server down/Unavailability of data/Divide By Zero) in service, then error/Exception details can be passed to Client by using Fault Contract.

False Assumption

Most people think that we can't throw FaultException in catch block. It should be only based on some condition (if condition). But it is a false assumption. The main objective is, any type of exceptions(Predicted or Unpredicted) from service to be passed to Client (WCF Service consumer).

Using code:-

    [DataContract()]

    public class CustomError

    {

        [DataMember()]

        public string ErrorCode;

        [DataMember()]

        public string Title;

        [DataMember()]

        public string ErrorDetail;

    }

    [ServiceContract()]

    public interface IGreetingService

    {

        [OperationContract()]

        [FaultContract(typeof(CustomError))]

        string Greet(string userName);

    }

    public class GreetingService : IGreetingService

    {

        public string Greet(string userName)

        {

            // predicted Errors

            if (string.IsNullOrWhiteSpace(userName))

            {

                var exception = new CustomError()

                {

                    ErrorCode = "401",

                    Title = "Null or empty",

                    ErrorDetail = "Null or empty user name has been                                          provided"

                };

                throw new FaultException<CustomError>(exception, "Reason :                                                       Input error");

            }

            // Unpredictable Errors...

            try

            {

              SqlConnection con = new SqlConnection(StrConnectionString);

                con.Open();

                // some database operation code..

                con.Close();

            }

            catch (SqlException sqlEx)

            {

               var exception = new CustomError()

               {

                   ErrorCode = "402",

                   Title = "Null or empty",

                   ErrorDetail = "Connection can not open this " +

                                 "time either connection string is wrong                                     or Sever is down. Try later"

               };

               throw new FaultException<CustomError>(exception, "Reason :                                                       Server down");

            }

            catch (Exception ex)

            {

                var exception = new CustomError()

                {

                    ErrorCode = "403",

                    Title = "Null or empty",

                    ErrorDetail = "unforeseen error occurred. Please try                                      later."

                };

                throw new FaultException<CustomError>(exception, "Reason :                                                        Unforeseen Error");

              

            }

           // If there is no Error...

            return string.Format("Welcome {0}", userName);

        }

    }




In this post I explained how to handle exception at service side in WCF. I hope you enjoyed this post please comments your feed back and quires. Thank You.

Serialization of .NET classes into JSON object in C#.Net ?

What is Serialization  ?

Serialization is a programming technique that converts an object in memory to a sequence of bytes. The serialized data is suitable for storage in files and databases, and can be sent to other computer systems across network protocols.

you will see how to use features built-in to the .NET framework to serialize objects to JavaScript object notation (JSON). JSON stores objects and collections of objects in a human-readable, structured text format, and is commonly used in client/server architectures because of its high level of compatibility across a wide range of client programming languages.

.NET Framework Classes

In version 3.5 (and in later versions) of the .NET framework, classes for serializing and deserializing to JSON are included in the framework. The main classes you will use are in System.Runtime.Serialization and System.Runtime.Serialization.Json.

The general process for serializing and deserializing JSON from C# is:

• Add a reference to the System.Runtime.Serialization library.
• Add using directives for System.Runtime.Serialization and System.Runtime.Serialization.Json.
• Define classes for the objects represented using DataContract and DataMember attributes.
• Create an instance of DataContractJsonSerializer.
• Use WriteObject() to serialize an object to a stream.
• Use ReadObject() to deserialize an object from a JSON stream.

Classes and Service Contracts

DataContracts are agreements between clients and servers that describe the information that is to be exchanged between them. Windows Communication Foundation (WCF) uses these extensively, however, you only need a small familiarity with them to use the DataContractJsonSerializer.


The DataContract attribute is used to mark a class as suitable for serialization/deserialization by the DataContractJsonSerializer. The example below defines a class with the minimum attributes needed to work with the serializer.

The attribute DataMember can also be used to control certain elements in the serialization and deserialization process. It has five properties:

Property Name

1. EmitDefaultValue:- Sets whether or not to serialize the default values for the fields and properties being serialized.
2. IsRequired:-  Whether the member must be present in the JSON code when deserializing.
3. Name :- The name of the member when serialized.
4. Order:- The order of the serialization or  deserialization.
5. TypeId :-  With derived classes, TypeId is a unique  identifier for this attribute.

Attribute properties are included in the DataMember attribute by specifying the property name and value in parenthesis as shown in this modified version of the UserReg class.

[DataContract]

    class UserReg

    {

        [DataMember(IsRequired = true)]

        public String FirstName;

        [DataMember]

        public String LastName;

        [DataMember(IsRequired = true)]

        public String Gender;

        [DataMember(Name = "EmailAddress", IsRequired = true)]

        public String EmailID;

        [DataMember(IsRequired = true)]

        public String MobileNo;

        [DataMember]

        public String Country;

        [DataMember]

        public String State;

        [DataMember]

        public String City;

        [DataMember]

        public String Address;

        [DataMember]

        public int PinCode;

    }

The example above uses the name property to change how the member EmailID appears in the serialized output. It also marks all members, apart from icon, as required.

Specifying the attribute properties can be useful when building a contract to an existing service that uses names that cannot be used in your class. When serialized,

Serialization with the DataContractJsonSerializer

To serialize a .NET object to JSON, you must create an instance of DataContractJsonSerializer. The constructor for this class has one parameter: a reference to the type of .NET object that is to be serialized or deserialized.

Use the method WriteObject() to perform the serialization and send the output to the specified stream. It can work with most streams that are derived from System.IO.Stream – such as file streams, memory streams, and network streams.

class TestSerialization

    {

        static void Main(string[] args)

        {

            UserReg userReg = new UserReg()

            {

                FirstName = "Rampal",

                LastName = "Singh",

                Gender = "Male",

                EmailID = "rampal.singh0586@gmail.com",

                MobileNo = "8861447949",

                Country = "India",

                State = "Uttar Pradesh",

                City = "Moradbad",

                Address = "Prakash Nagar",

                PinCode = 244255

            };

            DataContractJsonSerializer js = new DataContractJsonSerializer(typeof(UserReg));

            MemoryStream ms = new MemoryStream();

            js.WriteObject(ms, userReg);

            Console.WriteLine("\r\nSerializing of .NET Class into JSON Object in C#\r\n");

            ms.Position = 0;

            StreamReader sr = new StreamReader(ms);

            Console.WriteLine(sr.ReadToEnd());

            sr.Close();

            ms.Close();

            Console.ReadKey();

        }

    }

The code above produces the following JSON output:

Deserialization with the DataContractJsonSerializer

Deserialization takes JSON-formatted data and converts it into a .NET object in memory. As with serialization, this relies on using an instance of DataContractJsonSerializer. Generally speaking, you will be loading JSON data from a stream (most likely a network stream from communicating with a web server), however, in this example the JSON is hardcoded into a string and then accessed through a MemoryStream.

To deserialize JSON from a stream, use the method ReadObject(). This returns an Object type that you can cast to the desired class.

class TestSerialization

    {

        static void Main(string[] args)

        {

String userData = "{ \"FirstName\": \"Rampal\", \"LastName\": \"Singh\", \"Gender\": \"Male\", \"EmailAddress\": \"rampal.singh0586@gmail.com\", \"MobileNo\": \"8861447949\", \"Country\": \"India\", \"State\": \"Uttar Pradesh\" , \"City\": \"Moradabad\" , \"Address\": \"Prakash Nagar\", \"PinCode\": \"244255\"}";

            DataContractJsonSerializer js = new DataContractJsonSerializer(typeof(UserReg));

            MemoryStream ms = new MemoryStream(System.Text.ASCIIEncoding.ASCII.GetBytes(userData));

            UserReg userreg = (UserReg)js.ReadObject(ms);

            Console.WriteLine("\r\nDeserializing JSON object into .NET class Object in C#\r\n");

            Console.WriteLine("User Name: " + userreg.FirstName + "' '" + userreg.LastName);

            Console.WriteLine("Address: " + userreg.Address);

            ms.Close();

            Console.ReadKey();

       }

  }

Output Result:-

In the above post I explain with example how to Serialization  the .NET classes into JSON objects and Deserialization back into .NET classes as objects. I hove this post very useful to you. I request you to please comments your feedback and questions here. Thamk Your