We Keep Coding

Mapping Two Different Objects dynamically in C#

Object1:
{
"UserId": 123,
"Name": "testuser",
"Roles": [
{
"UserRole": "Admin"
},
{
"UserRole": "NonAdmin"
}
]
}
Object2:
{
"Id": 123,
"EmpName": "testuser",
"UserRoles": [
{
"EmpRole": "Admin"
},
{
"EmpRole": "NonAdmin"
}
]
}
I'm trying to map this object in C# using automapper. It is working fine but we need to map this object dynamically without using C# code, like keep this properties in Json file or database. Is there any other approach? We need to avoid code changes in C# if any new property is added or removed in any object, so we are looking to convert object1 to Object2 dynamically without code change.

Strongly Typed IDs and JSON Schema generation in C#

I like the idea of Strongly Typed IDs and I am using it for some time. I use it also in DTOs without and major problems... till now. I have a use case where I need to generate JSON Schema from some classes which uses Strongly Type IDs like following:
[StronglyTypedId(StronglyTypedIdBackingType.Long)]
public partial struct TweetId
{
}
public class Tweet
{
public TweetId Id {get; set;}
}
So, as described, TweetID is represented as long base type.
The problem arises when I want to generate JSON Schema from this type. I am currently using Newtonsoft.Json.Schema (I also tried some others) using this code:
JSchemaGenerator generator = new JSchemaGenerator();
JSchema quotesSchema = generator.Generate(typeof(Tweet));
The result I get is:
{
"definitions": {
"Tweet": {
"type": [
"object"
],
"properties": {
"Id": {
"$ref": "#/definitions/TweetId"
}
}
},
"TweetId": {},
},
"type": "object",
"$ref": "#/definitions/Tweet"
}
But what I want is:
{
"definitions": {
"Tweet": {
"type": [
"object"
],
"properties": {
"Id": {
"type": "integer"
}
}
}
},
"type": "object",
"$ref": "#/definitions/Tweet"
}
Do you have any idea how to achive this? Newtonsoft.Json.Schema is not mendatory.

how to detect namespace when creating a class through a custom template in dotnet cli

I'm making a custom class dotnet new template and below is my template.json. This works but I can't figure out how to detect current namespace and replace it.
template.json:
{
"$schema": "http://json.schemastore.org/template",
"author": "name",
"classifications": [ "core", "console", "class" ],
"tags": {
"language": "C#",
"type": "item"
},
"identity": "Template.ClassTemplate",
"name": "Editable Class Template",
"shortName": "class",
"sourceName": "Class1"
}
C# template code file name is Class1.cs:
using System;
namespace newClass{
public class Class1{
}
}
command line to make new class:
dotnet new class -n class_name
resulting c# file below and is named class_name.cs:
using System;
namespace newClass{
public class class_name{
}
}
I would like to know how to detect the namespace so I can have the option to change it or have the namespace either detected and set automatically. Thanks!

You can specify on the command line with your own parameter.
I got this from the samples repo https://github.com/dotnet/dotnet-template-samples/tree/master/02-add-parameters
{
"$schema": "http://json.schemastore.org/template",
"author": "name",
"classifications": [ "core", "console", "class" ],
"tags": {
"language": "C#",
"type": "item"
},
"identity": "Template.ClassTemplate",
"name": "Editable Class Template",
"shortName": "class",
"sourceName": "Class1",
"symbols": {
"namespace": {
"type": "parameter",
"defaultValue": "MyNamespace",
"replaces": "MY_NAMESPACE"
}
}
}
And it will replace the value in your source
using System;
namespace MY_NAMESPACE
{
public class Class1
{
}
}
Usage:
dotnet new class -n class_name --namespace Foo

How can I map REST entities with my own models

I have been given a REST service which provides some strange names, see json fomart below.
I have created some classes to map them to JSON using the following line:
var data = JsonConvert.DeserializeObject<SSTR)(jsond).inhoud_b.ToArray();
I have created classes such as:
Class inhoud_b {...}
Class bidt{...}
etc.
Json:
{
"nmbr": 0,
"tp": 1,
"sort": {
"sorted": false,
"unsorted": true
},
"inhoud_b":[
{
"bidt": {
"id": "144a207b-dd48-4ebe-87cb-153e3c6179c4",
"knldge": null,
"lTT": null,
"lD": {
"id": "52",
"text": "EM"
}
}
},
{
"bidt": {
"id": "155B307b-dd48-4ebe-87cb-125487856579",
"knldge": null,
"lTT": null,
"lDg": {
"id": "523",
"text": "AM"
}
}
}
],
"first": true,
"totalElements": 2
}
My question is, how can I map these entities with my own more meaningful models and use my models in my own code rather than those entities which don't make any sense to other developers?
Thank you.

You can use the JsonPropertyAttribute to annotate your model properties with their corresponding property name in the JSON - https://www.newtonsoft.com/json/help/html/JsonPropertyName.htm

Convert Swagger to C# object [duplicate]

This question already has answers here:
How do deserialize JSON with non-standard (and varying) property names (in .NET)
(3 answers)
Closed 5 years ago.
Is there an easy way to convert Json string to C# object?
I have a swagger file in json format and need to make it to C# object
{
"swagger": "2.0",
"info": {
"version": "Profiles",
"title": "Profiles"
},
"paths": {
"/api/Profiles/Get": {
"get": {
"tags": [ "Profiles"],
"operationId": "Profiles_GetById",
"consumes": [],
"produces": [],
"parameters": [{ "name": "id"}]
}
},
"/api/Profiles": {
"get": {
"tags": [
"Profiles"
],
"operationId": "Profiles_GetBySubscriptionid",
"consumes": [],
"produces": [],
"parameters": [{ "name": "subscriptionId"}]
}
}
},
"definitions": {}
}
So the problem that I am facing right now is that I have no idea how to convert paths to properties of my C# object. Specifically, I have no clue how I define a C# object properties for "/api/Profiles/Get", or "/api/Profiles".
public class SwaggerObject
{
[JsonProperty("paths")]
public SwaggerPath Paths { get; set;}
}
public class SwaggerPath {
...
}

If you have a valid swagger definition, you can use AutoRest to generate a client for you. The auto-generated client includes models for all of the types you define in your swagger document.
You can then call Newtonsoft.Json.JsonConvert.DeserializeObject<MyModel>(json​) after you retrieve the response. Better yet, you can you the auto generated client to make the HTTP calls in your .NET code.