Serialize C# object with two different JsonConverter using Newtonsoft.Json

My use case requires me to serialize/ deserialize c# object for multiple clients, basically an internal client and external client.
My internal client simply uses the objects properties as a naming scheme for the json data. My external client has the exact same properties, but wants to have a different name for some of the properties. In this szenario my client wants the below Customer field to be renamed to Mandant. However it is crucial for me to be still able to serialize to Customer as a field name. Only in certain scenarios I need to be able to serialize for my external client. I am currently using Newtonsoft.Json

My C# class could look something like this:

public class MyClass
{
    public string Customer {get; set;}
}

My expectation would be that I could serialize/ deserialize in two different ways,
e.g. my external client wants the field Customer to be renamed to Mandant.

Serialize for internal client:

{
   "Customer": "MyCustomer"
}

Serialize for external client:

{
   "Mandant": "MyCustomer"
}

Please distinguish between your internal business logic DTOs (or POCOs) and the data you publish to external systems (doesn't matter if it is a customer or another program / tool / library of yourself).

So let's assume you have some kind of data source (e.g. Sql DB, Cosmos DB, Redis cache, etc.). The used source normally has some kind of conventions on how the classes must be designed (Sql mostly has an Id property or follows some scheme to handle 1:many relationships; Cosmos needs a partition key; Redis needs some cache key; etc.). You should stick to these data source rules and model your objects to best fit the given source rules and your requirements (e.g. read optimized, write optimized, etc.).

In a next step define the DTOs on how they are presented to the other systems. Give them the properties and structure as required by the customer (this could be you too, but for another project in the same or another solution). Then write a converter / mapper that takes an object of type A and produces an object of type B (for this purpose you could take a look at AutoMapper to simplify the process). Also it makes sense to create different DTOs also for the same target type, but different operations (e.g. create / update).

All these steps need some effort, but in the long run it will be much easier to distinguish between the different operations and/or customers and prevent you from creating god classes which try to handle multiple things (e.g. customers) at once.

you can use a custom ContractResolver

List<string[]> customerReplaces = new List<string[]> { 
                    new string[] { "Customer", "Mandant" } 
                   };

	var json = JsonConvert.SerializeObject(customer,
				Newtonsoft.Json.Formatting.Indented,
				new JsonSerializerSettings
				{
					ContractResolver = new ReplaceNamesContractResolver(customerReplaces)
				});

public class ReplaceNamesContractResolver : DefaultContractResolver
{
	private readonly List<string[]> _replaces;

	protected override JsonProperty CreateProperty(MemberInfo member, MemberSerialization memberSerialization)
	{

		JsonProperty property = base.CreateProperty(member, memberSerialization);

		var newName = _replaces.Where(v => v[0] == property.PropertyName)
							   .FirstOrDefault()?[1];

		if (newName != null) property.PropertyName = newName;

		return property;
	}

	public ReplaceNamesContractResolver(List<string[]> replaces)
	{
		_replaces = replaces;
	}
}

</details>



# 答案3
**得分**: 0

```csharp
使用 `Newtonsoft.Json` 中的 `JsonProperty` 属性：

```csharp
using Newtonsoft.Json;

public class MyClass 
{ 
    [JsonProperty("Customer")]
    public string Customer { get; set; }

    [JsonProperty("Mandant")]
    public string Mandant 
    { 
        get { return Customer; } 
        set { Customer = value; } 
    }
}
```

然后像这样使用：

```csharp
var obj = new MyClass { Customer = "MyCustomer" };

var SerializedForInternalClient = JsonConvert.SerializeObject(obj); // 输出: {"Customer":"MyCustomer"}
var SerializedForExternalClient = JsonConvert.SerializeObject(obj); // 输出: {"mandant":"MyCustomer"}

var DeserializedForInternalClient = JsonConvert.DeserializeObject<MyClass>(SerializedForInternalClient); // 输出: "MyCustomer"
var DeserializedForExternalClient = JsonConvert.DeserializeObject<MyClass>(SerializedForExternalClient); // 输出: "MyCustomer"
```

<details>
<summary>英文:</summary>

use the `JsonProperty` attribute from `Newtonsoft.Json` :

    using Newtonsoft.Json;
    
    public class MyClass 
    { 
        [JsonProperty(&quot;Customer&quot;)]
        public string Customer { get; set; }
    
        [JsonProperty(&quot;Mandant&quot;)]
        public string Mandant 
        { 
            get { return Customer; } 
            set { Customer = value; } 
        }
    }

then use it like this:

    var obj = new MyClass { Customer = &quot;MyCustomer&quot; };
    
    var SerializedForInternalClient = JsonConvert.SerializeObject(obj); // Output: {&quot;Customer&quot;:&quot;MyCustomer&quot;}
    var SerializedForExternalClient = JsonConvert.SerializeObject(obj); // Output: {&quot;mandant&quot;:&quot;MyCustomer&quot;}
    
    var DeserializedForInternalClient = JsonConvert.DeserializeObject&lt;MyClass&gt;(SerializedForInternalClient); // Output: &quot;MyCustomer&quot;
    var DeserializedForExternalClient = JsonConvert.DeserializeObject&lt;MyClass&gt;(SerializedForExternalClient); // Output: &quot;MyCustomer&quot;



</details>