custom javascript deserializer in c#

The difficulty here is that a JavaScriptConverter allows you to map a JSON object from and to a c# class -- but in your JSON, "xyz" is just a string, not an object. Thus you can't specify a converter for someOtherDataType and instead must specify converters for every class that contains an instance of someOtherDataType.

(Note that the custom converter functionality in Json.NET does not have this restriction. If you were willing to switch to that library you could write a JsonConverter converting all uses of someOtherDataType from and to a JSON string.)

To write such a JavaScriptConverter:

1. Override JavaScriptConverter.Deserialize
2. Create a second Dictionary<string, Object> filtering out the fields requiring custom conversion.
3. Call new JavaScriptSerializer.ConvertToType<T> to deserialize the standard fields from the filtered dictionary.
4. Manually convert the remaining fields.
5. Override SupportedTypes to return the container type.

Thus, in your example, you could do:

public class example
{
    public string abc;
    public someOtherDataType xyz;
}

// Example implementation only.
public class someOtherDataType
{
    public string SomeProperty { get; set; }

    public static someOtherDataType CreateFromJsonObject(object xyzValue)
    {
        if (xyzValue is string)
        {
            return new someOtherDataType { SomeProperty = (string)xyzValue };
        }
        return null;
    }
}

class exampleConverter : JavaScriptConverter
{
    public override IEnumerable<Type> SupportedTypes
    {
        get { return new[] { typeof(example) }; }
    }

    // Custom conversion code below

    public override object Deserialize(IDictionary<string, object> dictionary, Type type, JavaScriptSerializer serializer)
    {
        var defaultDict = dictionary.Where(pair => pair.Key != "xyz").ToDictionary(pair => pair.Key, pair => pair.Value);
        var overrideDict = dictionary.Where(pair => !(pair.Key != "xyz")).ToDictionary(pair => pair.Key, pair => pair.Value);

        // Use a "fresh" JavaScriptSerializer here to avoid infinite recursion.
        var value = (example)new JavaScriptSerializer().ConvertToType<example>(defaultDict);

        object xyzValue;
        if (overrideDict.TryGetValue("xyz", out xyzValue))
        {
            value.xyz = someOtherDataType.CreateFromJsonObject(xyzValue);
        }
        return value;
    }

    public override IDictionary<string, object> Serialize(object obj, JavaScriptSerializer serializer)
    {
        throw new NotImplementedException();
    }
}

And then, to test:

public class TestClass
{
    public static void Test()
    {
        // receive json string
        string json = @"{
""abc"" : ""valueabc"",
""xyz"" : ""valueXYZ""
}";
        var serializer = new JavaScriptSerializer();
        serializer.RegisterConverters(new JavaScriptConverter[]
         { 
             new exampleConverter()
         });

        var example = serializer.Deserialize<example>(json);
        Debug.Assert(example.abc == "valueabc" && example.xyz.SomeProperty == "valueXYZ"); // No assert
    }
}