首先，解决引用循环的问题--PreserveReferencesHandling设置控制Json.net是否发出$id和$ref来跟踪对象间引用。如果将此设置为None并且对象图包含循环，则还需要将ReferenceLoopHandling设置为Ignore以防止错误。
现在，要让Json .NET完全忽略所有对象引用，只序列化基元属性（当然除了你的Pseudocontext类），你确实需要一个定制的契约解析器，就像你建议的那样。这并不像你想得那么难。解析器能够为每个属性注入一个ShouldSerialize方法，以控制该属性是否应包含在输出中。因此，您所需要做的就是从默认解析器派生解析器，然后重写CreateProperty方法，使其适当地设置ShouldSerialize。（此处不需要定制JsonConverter，尽管使用该方法可以解决此问题。但是，它需要相当多的代码。）
下面是解析器的代码：

class CustomResolver : DefaultContractResolver
{
    protected override JsonProperty CreateProperty(MemberInfo member, MemberSerialization memberSerialization)
    {
        JsonProperty prop = base.CreateProperty(member, memberSerialization);

        if (prop.DeclaringType != typeof(PseudoContext) && 
            prop.PropertyType.IsClass && 
            prop.PropertyType != typeof(string))
        {
            prop.ShouldSerialize = obj => false;
        }

        return prop;
    }
}

这里是一个完整的演示，展示了解决方案的行动。

class Program
{
    static void Main(string[] args)
    {
        // Set up some dummy data complete with reference loops
        Thing t1 = new Thing { Id = 1, Name = "Flim" };
        Thing t2 = new Thing { Id = 2, Name = "Flam" };

        Widget w1 = new Widget
        {
            Id = 5,
            Name = "Hammer",
            IsActive = true,
            Price = 13.99M,
            Created = new DateTime(2013, 12, 29, 8, 16, 3),
            Color = Color.Red,
        };
        w1.RelatedThings = new List<Thing> { t2 };
        t2.RelatedWidgets = new List<Widget> { w1 };

        Widget w2 = new Widget
        {
            Id = 6,
            Name = "Drill",
            IsActive = true,
            Price = 45.89M,
            Created = new DateTime(2014, 1, 22, 2, 29, 35),
            Color = Color.Blue,
        };
        w2.RelatedThings = new List<Thing> { t1 };
        t1.RelatedWidgets = new List<Widget> { w2 };

        // Here is the container class we wish to serialize
        PseudoContext pc = new PseudoContext
        {
            Things = new List<Thing> { t1, t2 },
            Widgets = new List<Widget> { w1, w2 }
        };

        // Serializer settings
        JsonSerializerSettings settings = new JsonSerializerSettings();
        settings.ContractResolver = new CustomResolver();
        settings.PreserveReferencesHandling = PreserveReferencesHandling.None;
        settings.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;
        settings.Formatting = Formatting.Indented;

        // Do the serialization and output to the console
        string json = JsonConvert.SerializeObject(pc, settings);
        Console.WriteLine(json);
    }

    class PseudoContext
    {
        public List<Thing> Things { get; set; }
        public List<Widget> Widgets { get; set; }
    }

    class Thing
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public List<Widget> RelatedWidgets { get; set; }
    }

    class Widget
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public bool IsActive { get; set; }
        public decimal Price { get; set; }
        public DateTime Created { get; set; }
        public Color Color { get; set; }
        public List<Thing> RelatedThings { get; set; }
    }

    enum Color { Red, White, Blue }
}

输出：

{
  "Things": [
    {
      "Id": 1,
      "Name": "Flim"
    },
    {
      "Id": 2,
      "Name": "Flam"
    }
  ],
  "Widgets": [
    {
      "Id": 5,
      "Name": "Hammer",
      "IsActive": true,
      "Price": 13.99,
      "Created": "2013-12-29T08:16:03",
      "Color": 0
    },
    {
      "Id": 6,
      "Name": "Drill",
      "IsActive": true,
      "Price": 45.89,
      "Created": "2014-01-22T02:29:35",
      "Color": 2
    }
  ]
}

希望这是在你要找的东西的范围内。

此外，如果您正在寻找一种方法来为所有具有不同成员类型名称的模型类执行此操作（* 例如，您有一些由Entity Framework创建的模型 *）此答案会有所帮助，您可以通过它忽略JSON序列化中的导航属性。

一个更简单的方法是修改模型T4模板（.tt），将[JsonIgnore]属性附加到导航属性，这将使原始类型保持可序列化。

还有另一个简单的解决方案，将下面这行代码添加到DbContext构造函数中：

public MyContextEntities() : base("name=MyContextEntities")
    {
        Configuration.ProxyCreationEnabled = false;
    }

JsonConvert不会序列化System.Data.Entity.DynamicProxies.* 命名空间中的所有内容。实际上，您将得到一个json，其中只填充您在Include（）中添加的依赖项。