WCF service returning an array of dictionary

Question

I\'ve been trying to use a SilverLight client to call an ASP.Net WCF service that would return a Dictionary. That worked fine when the val

Answer 1

First of all you should configure WCF tracing in app cofig file that can help you to understand what happends under the hood of service communications. In this case you can easily get all errors that occurs during communication process.

Now, lets try to solve your problem. I almost confident that problem in in known types. In service-oriented world you should manually define all concrete types that can participate in service contract, because DataContractSerializer doesn't provide such information in serialized objects.

In this case it mean, that you should do following:

[ServiceKnownType(typeof(string))] 
[ServiceKnownType(typeof(Guid))]
[ServiceKnownType(typeof(int))] // but I think DataContractSerializer can deal himself with primitives
[ServiceKnownType(typeof(YourClass))] //UserDefined types you should add manually
public Dictionary<string, object> GetObject()

Also I recommended to you do not use object in service contract because it VERY error prone. Consider, that later you or one of your colleagues modifies one line of code:

new Dictionary<string, object>()
{
 { "pty1", 4 },
 { "pty2", Guid.NewGuid() },
 { "pty3", new SomeClass() }, //OOPS!!!
}

In this case, when your service tries to return this Dictionary you encounter runtime failure because DataContractSerializer doesn't expect SomeClass in this contract.

One way to solve this problem is to create separate type:

[DataContract]
[KnownType(typeof(Guid))]
[KnownType(typeof(SomeClass1))]
[KnownType(typeof(SomeClass2))]
public class MyType
{
  private MyType(object obj) {
     Object = obj;
  }

  public static MyType FromSomeClass1(SomeClass1 c1) {
    return new MyType(c1);
  }

  public static MyType FromSomeClass2(SomeClass2 c2) {
    return new MyType(c2);
  }

  public static MyType FromGuid(Guid guid) {
    return new MyType(guid);
  }

  [DataMember]
  public object Object { get; private set; }
}

In this case if you want to add some new type, you should add factory method and KnownTypeAttribute (this approach more verbose, but less error prone).

However, if your client and service written on WCF, you can sacrifice main service-oriented principles and use NetDataContractSerializer instead DataContractSerializer. NetDataContractSerializer is designed to complement DataContractSerializer. You can serialize a type using NetDataContractSerializer and deserialize with DataContractSerializer. But NetDataContractSerializer includes CLR type information in the serialized XML, whereas the DataContractSerializer does not. Therefore, the NetDataContractSerializer can used in serialization and deserialization with any CLR types without any KnownTypes stuff.

Answer 2

Try defining a class the has a single property. That property is a Dictionary of string, object.

Mark the class with DataContract / DataMember. Then define your interface using that class.

Answer 3

However, I now have a scenario where I need one of the values to be an array of dictionary !

The problem is that WCF doesn't know how to serializer / deserialize an array of objects that isn't marked with DataMember attribute and / or isn't added to ServiceKnownTypes.

For example, if there is some service method, that takes an arbitrary object as a parameter

public interface IService
    function DoSomething(Parameter as Object) as integer
end interface

and you want to pass, say an array of integers Integer(), you must explicitly add this array of integers type to service known types.

<ServiceKnownType(GetType(Integer()))>
public interface IService
    function DoSomething(Parameter as Object) as integer
end interface

Then service method can be called

dim Service as IService
dim Argument as Integer()
Service.DoSomething(Argument)

Any ideas how to fix it ?

Try adding <ServiceKnownType(GetType(Dictionary(Of String, Object)()))> attribute.