JSON .NET Custom Symbol Resolver

You could make a helper method to do this. The helper method could first deserialize everything to a JToken hierarchy, then recursively search for and replace the variables using a replacement function you supply. After the replacement, it could then use JToken.ToObject() to hydrate it into your target class(es). The only catch in the plan is that the original JSON has to be valid. So, I would propose using specially-formatted string values for your variables instead, such that there is no chance of one getting confused with a normal string value. Perhaps something like this:

{
    "foo": "$(bar)"
}

Here is what the code for the helper might look like:

public static class JsonHelper
{
    public static T DeserializeAndReplace<T>(string json, Func<string, object> replaceFunc)
    {
        return ReplaceVariables(JToken.Parse(json), replaceFunc).ToObject<T>();
    }

    public static JToken ReplaceVariables(JToken token, Func<string, object> replaceFunc)
    {
        if (token.Type == JTokenType.Object)
        {
            JObject copy = new JObject();
            foreach (JProperty prop in token.Children<JProperty>())
            {
                copy.Add(prop.Name, ReplaceVariables(prop.Value, replaceFunc));
            }
            return copy;
        }
        if (token.Type == JTokenType.Array)
        {
            JArray copy = new JArray();
            foreach (JToken item in token.Children())
            {
                copy.Add(ReplaceVariables(item, replaceFunc));
            }
            return copy;
        }
        if (token.Type == JTokenType.String)
        {
            string s = (string)token;
            if (s.StartsWith("$(") && s.EndsWith(")"))
            {
                object value = replaceFunc(s.Substring(2, s.Length - 3));
                return (value != null ? JToken.FromObject(value) : JValue.CreateNull());
            }
        }
        return token;
    }
}

Here is a demo showing the helper in action:

class Program
{
    static void Main(string[] args)
    {
        string json = @"
        [
            {
                ""name"" : ""normal"",
                ""bar"" : { ""baz"" : ""quux"" }
            },
            {
                ""name"" : ""$(cool)"",
                ""bar"" : ""$(bar)""
            },
        ]";

        var list = JsonHelper.DeserializeAndReplace<List<Foo>>(json, ReplaceVariable);

        foreach (Foo foo in list)
        {
            Console.WriteLine("name: " + foo.Name);
            Console.WriteLine("bar.baz: " + foo.Bar.Baz);
            Console.WriteLine();
        }
    }

    private static object ReplaceVariable(string variable)
    {
        if (variable == "bar") return new Bar { Baz = "foobar" };
        if (variable == "cool") return "whip";
        return null;
    }
}

class Foo
{
    public string Name { get; set; }
    public Bar Bar { get; set; }
}

class Bar
{
    public string Baz { get; set; }
}

Output:

name: normal
bar.baz: quux

name: whip
bar.baz: foobar

Fiddle: https://dotnetfiddle.net/5T9lmd