使用像这样的简单类/接口
public interface IThing
{
string Name { get; set; }
}
public class Thing : IThing
{
public int Id { get; set; }
public string Name { get; set; }
}
如何获取仅具有“名称”属性（仅底层接口的属性）的 JSON 字符串？
实际上，当我这样做时：
var serialized = JsonConvert.SerializeObject((IThing)theObjToSerialize, Formatting.Indented);
Console.WriteLine(serialized);
我得到完整的对象作为 JSON (Id + Name);
我使用的方法，
public class InterfaceContractResolver : DefaultContractResolver
{
private readonly Type _InterfaceType;
public InterfaceContractResolver (Type InterfaceType)
{
_InterfaceType = InterfaceType;
}
protected override IList<JsonProperty> CreateProperties(Type type, MemberSerialization memberSerialization)
{
//IList<JsonProperty> properties = base.CreateProperties(type, memberSerialization);
IList<JsonProperty> properties = base.CreateProperties(_InterfaceType, memberSerialization);
return properties;
}
}
// To serialize do this:
var settings = new JsonSerializerSettings() {
ContractResolver = new InterfaceContractResolver (typeof(IThing))
});
string json = JsonConvert.SerializeObject(theObjToSerialize, settings);
这里还有另一个变化。代码来自http://www.tomdupont.net/2015/09/how-to-only-serialize-interface.html与此处的其他答案相比有以下改进
Interface2[]那么Interface1它将被序列化。我试图序列化一个 WCF 代理对象，结果 JSON 出现在{}. 原来所有属性都设置为，Ignore=true所以我不得不添加一个循环来将它们全部设置为不被忽略。
public class InterfaceContractResolver : DefaultContractResolver
{
private readonly Type[] _interfaceTypes;
private readonly ConcurrentDictionary<Type, Type> _typeToSerializeMap;
public InterfaceContractResolver(params Type[] interfaceTypes)
{
_interfaceTypes = interfaceTypes;
_typeToSerializeMap = new ConcurrentDictionary<Type, Type>();
}
protected override IList<JsonProperty> CreateProperties(
Type type,
MemberSerialization memberSerialization)
{
var typeToSerialize = _typeToSerializeMap.GetOrAdd(
type,
t => _interfaceTypes.FirstOrDefault(
it => it.IsAssignableFrom(t)) ?? t);
var props = base.CreateProperties(typeToSerialize, memberSerialization);
// mark all props as not ignored
foreach (var prop in props)
{
prop.Ignored = false;
}
return props;
}
}
受@user3161686 的启发，这里有一个小的修改InterfaceContractResolver：
public class InterfaceContractResolver<TInterface> : DefaultContractResolver where TInterface : class
{
protected override IList<JsonProperty> CreateProperties(Type type, MemberSerialization memberSerialization)
{
IList<JsonProperty> properties = base.CreateProperties(typeof(TInterface), memberSerialization);
return properties;
}
}
您可以使用条件序列化。看看这个链接。基本上，您需要实现IContractResolver接口，重载ShouldSerialize方法并将解析器传递给 Json 序列化器的构造函数。
和属性的替代方法[JsonIgnore]。如果您的类被序列化程序标记，则只会处理用属性标记的属性（是“选择退出”模型，而是“可选”）。[DataContract][DataMember][DataContract][DataMember]JsonIgnoreDataContract
[DataContract]
public class Thing : IThing
{
[DataMember]
public int Id { get; set; }
public string Name { get; set; }
}
这两种方法的局限性在于它们必须在类中实现，您不能将它们添加到接口定义中。
您可以添加[JsonIgnore]注释以忽略属性。
除了@monrow 给出的答案之外，您还可以使用默认的 [DataContract] 和 [DataMember] 看看这个
我想分享一下我们在面对这项任务时最终做了什么。鉴于 OP 的接口和类...
public interface IThing
{
string Name { get; set; }
}
public class Thing : IThing
{
public int Id { get; set; }
public string Name { get; set; }
}
...我们创建了一个直接实现接口的类...
public class DirectThing : IThing
{
public string Name { get; set; }
}
然后简单地序列化我们的Thing实例，将其反序列化为 a DirectThing，然后将其序列化为 a DirectThing：
var thing = new Thing();
JsonConvert.SerializeObject(
JsonConvert.DeserializeObject<DirectThing>(JsonConvert.SerializeObject(thing)));
这种方法可以与长接口继承链一起使用……您只需要DirectThing在感兴趣的级别上创建一个直接类（在此示例中）。无需担心反射或属性。
从维护的角度来看，DirectThing如果您添加成员，则该类很容易维护，IThing因为如果您没有将它们也放入，编译器会出错DirectThing。但是，如果您从中删除成员 XIThing 并将其放入Thing，那么您必须记住将其删除，DirectThing否则 X 将成为最终结果。
从性能的角度来看，这里发生了三个（反）序列化操作而不是一个，因此根据您的情况，您可能希望评估基于反射器/属性的解决方案与此解决方案的性能差异。就我而言，我只是在小范围内这样做，所以我并不担心一些微/毫秒的潜在损失。
希望对某人有所帮助！
最后我得到了它什么时候不起作用......如果你想在另一个复杂的对象中拥有它，它将不会被正确序列化。
所以我制作了一个版本，它将只提取存储在特定程序集中的数据以及具有相同基本接口的类型。
所以它被制成.Net Core JsonContractResolver。
除了数据提取之外，它还解决了：
a）在向客户端发送数据之前进行驼峰式转换
b）使用允许范围内的最顶层接口（通过程序集） c）修复字段的顺序：来自大多数基类的字段将首先列出，嵌套对象将也符合这个规则。
public class OutputJsonResolver : DefaultContractResolver
{
#region Static Members
private static readonly object syncTargets = new object();
private static readonly Dictionary<Type, IList<JsonProperty>> Targets = new Dictionary<Type, IList<JsonProperty>>();
private static readonly Assembly CommonAssembly = typeof(ICommon).Assembly;
#endregion
#region Override Members
protected override IList<JsonProperty> CreateProperties(Type type, MemberSerialization memberSerialization)
{
if (type.Assembly != OutputJsonResolver.CommonAssembly)
return base.CreateProperties(type, memberSerialization);
IList<JsonProperty> properties;
if (OutputJsonResolver.Targets.TryGetValue(type, out properties) == false)
{
lock (OutputJsonResolver.syncTargets)
{
if (OutputJsonResolver.Targets.ContainsKey(type) == false)
{
properties = this.CreateCustomProperties(type, memberSerialization);
OutputJsonResolver.Targets[type] = properties;
}
}
}
return properties;
}
protected override string ResolvePropertyName(string propertyName)
{
return propertyName.ToCase(Casing.Camel);
}
#endregion
#region Assistants
private IList<JsonProperty> CreateCustomProperties(Type type, MemberSerialization memberSerialization)
{
// Hierarchy
IReadOnlyList<Type> types = this.GetTypes(type);
// Head
Type head = types.OrderByDescending(item => item.GetInterfaces().Length).FirstOrDefault();
// Sources
IList<JsonProperty> sources = base.CreateProperties(head, memberSerialization);
// Targets
IList<JsonProperty> targets = new List<JsonProperty>(sources.Count);
// Repository
IReadOnlyDistribution<Type, JsonProperty> repository = sources.ToDistribution(item => item.DeclaringType);
foreach (Type current in types.Reverse())
{
IReadOnlyPage<JsonProperty> page;
if (repository.TryGetValue(current, out page) == true)
targets.AddRange(page);
}
return targets;
}
private IReadOnlyList<Type> GetTypes(Type type)
{
List<Type> types = new List<Type>();
if (type.IsInterface == true)
types.Add(type);
types.AddRange(type.GetInterfaces());
return types;
}
#endregion
}