WCF ERROR: The server did not provide a meaningful reply;

Question

please somebody can help me to find out what is happened. I have my WCF service which worked fine, and now suddenly I have this error: The server did not provide a meaningful reply; this might be caused by a contract mismatch, a premature session shutdown or an internal server error I must tell that it still works when I select some thousands of records, but when the data is huge I receive this error, although before it worked fine! ``` private static string ConnString = "Server=127.0.0.1; Port=5432; Database=DBname; User Id=UName; Password=MyPassword;" DataTable myDT = new DataTable(); NpgsqlConnection myAccessConn = new NpgsqlConnection(ConnString); myAccessConn.Open(); string query = "SELECT * FROM Twitter"; NpgsqlDataAdapter myDataAdapter = new NpgsqlDataAdapter(query, myAccessConn); myDataAdapter.Fill(myDT); foreach (DataRow dr in myDT.Rows) { **WHEN I HAVE TOO MANY RECORDS IT STOPS HERE** ... ``` web.config ```

Accepted Answer

A different answer, just in case anyone arrives here as I did looking for a general answer to the question.

It seems that the DataContractSerializer that does the donkey-work is incredibly finicky, but doesn't always pass the real error to the client. The server process dies straight after the failure - hence no error can be found. In my case the problem was an enum that was used as flags, but not decorated with the [Flags] attribute (picky or what!).

To solve it I created an instance of the serializer and inspected the error in the debugger; here's a code snippet since I have it to hand.

EDIT: In response to request in comments ...

Amended the code snippet to show the helper method I now use. Much the same as before, but in a handy generic wrapper.

```
public static T CheckCanSerialize<T>(this T returnValue) {
    var lDCS = new System.Runtime.Serialization.DataContractSerializer(typeof(T));

Byte[] lBytes;
    using (var lMem1 = new IO.MemoryStream()) {
        lDCS.WriteObject(lMem1, returnValue);
        lBytes = lMem1.ToArray();
    }

T lResult;
    using (var lMem2 = new IO.MemoryStream(lBytes)) {
        lResult = (T)lDCS.ReadObject(lMem2);
    }

return lResult;
}
```

And to use this, instead of returning an object, return the object after calling the helper method, so

```
public MyDodgyObject MyService() {
    ... do lots of work ...
    return myResult;
}
```

becomes

```
public MyDodgyObject MyService() {
    ... do lots of work ...
    return CheckCanSerialize(myResult);
}
```

Any errors in serialization are then thrown before the service stops paying attention, and so can be analysed in the debugger.

Note; I wouldn't recommend leaving the call in production code, it has the overhead of serializing and deserializing the object, without any real benefit once the code is debugged.

Hope this helps someone - I've wasted about 3 hours trying to track it down.

WCF ERROR: The server did not provide a meaningful reply;

Solution

Problem