C# without naming convention option

Author: dandro

cli/src/config.rs

@@ -56,6 +56,7 @@ pub struct GoParams {
 pub struct CSharpParams {
     pub type_mappings: HashMap<String, String>,
     pub namespace: String,
+    pub without_csharp_naming_convention: bool,
 }
 
 /// The paramters that are used to configure the behaviour of typeshare

cli/src/main.rs

@@ -168,6 +168,7 @@ fn language(
         SupportedLanguage::CSharp => Box::new(CSharp {
             namespace: config.csharp.namespace,
             type_mappings: config.csharp.type_mappings,
+            without_csharp_naming_convention: config.csharp.without_csharp_naming_convention,
             ..Default::default()
         }),
         #[cfg(feature = "go")]

core/data/tests/anonymous_struct_with_rename/output.cs

@@ -0,0 +1,38 @@
+#nullable enable
+
+using System.Reflection;
+using JsonSubTypes;
+using Newtonsoft.Json;
+using System.Runtime.Serialization;
+
+/** Generated type representing the anonymous struct variant `List` of the `AnonymousStructWithRename` Rust enum */
+public class AnonymousStructWithRenameListInner {
+	public IEnumerable<string> list { get; set; }
+}
+
+/** Generated type representing the anonymous struct variant `LongFieldNames` of the `AnonymousStructWithRename` Rust enum */
+public class AnonymousStructWithRenameLongFieldNamesInner {
+	public string some_long_field_name { get; set; }
+	public bool and { get; set; }
+	public IEnumerable<string> but_one_more { get; set; }
+}
+
+/** Generated type representing the anonymous struct variant `KebabCase` of the `AnonymousStructWithRename` Rust enum */
+public class AnonymousStructWithRenameKebabCaseInner {
+	public IEnumerable<string> another-list { get; set; }
+	public string camelCaseStringField { get; set; }
+	public bool something-else { get; set; }
+}
+
+[JsonConverter(typeof(JsonSubtypes), "type")]
+[JsonSubtypes.KnownSubType(typeof(List), "List")]
+[JsonSubtypes.KnownSubType(typeof(LongFieldNames), "LongFieldNames")]
+[JsonSubtypes.KnownSubType(typeof(KebabCase), "KebabCase")]
+public abstract record AnonymousStructWithRename 
+{
+	public record list(AnonymousStructWithRenameListInner Content): AnonymousStructWithRename();
+	public record longFieldNames(AnonymousStructWithRenameLongFieldNamesInner Content): AnonymousStructWithRename();
+	public record kebabCase(AnonymousStructWithRenameKebabCaseInner Content): AnonymousStructWithRename();
+}
+
+

core/data/tests/can_handle_serde_rename/output.cs

@@ -0,0 +1,20 @@
+#nullable enable
+
+using System.Reflection;
+using JsonSubTypes;
+using Newtonsoft.Json;
+using System.Runtime.Serialization;
+
+public class OtherType {
+}
+
+/** This is a comment. */
+public class Person {
+	public string name { get; set; }
+	public ushort age { get; set; }
+	public int extraSpecialFieldOne { get; set; }
+	public IEnumerable<string>? extraSpecialFieldTwo { get; set; }
+	public OtherType nonStandardDataType { get; set; }
+	public IEnumerable<OtherType>? nonStandardDataTypeInArray { get; set; }
+}
+

core/data/tests/can_handle_serde_rename_all/output.cs

@@ -0,0 +1,23 @@
+#nullable enable
+
+using System.Reflection;
+using JsonSubTypes;
+using Newtonsoft.Json;
+using System.Runtime.Serialization;
+
+/** This is a Person struct with camelCase rename */
+public class Person {
+	public string firstName { get; set; }
+	public string lastName { get; set; }
+	public ushort age { get; set; }
+	public int extraSpecialField1 { get; set; }
+	public IEnumerable<string>? extraSpecialField2 { get; set; }
+}
+
+/** This is a Person2 struct with UPPERCASE rename */
+public class Person2 {
+	public string FIRST_NAME { get; set; }
+	public string LAST_NAME { get; set; }
+	public ushort AGE { get; set; }
+}
+

core/data/tests/can_handle_serde_rename_on_top_level/output.cs

@@ -0,0 +1,20 @@
+#nullable enable
+
+using System.Reflection;
+using JsonSubTypes;
+using Newtonsoft.Json;
+using System.Runtime.Serialization;
+
+public class OtherType {
+}
+
+/** This is a comment. */
+public class PersonTwo {
+	public string name { get; set; }
+	public ushort age { get; set; }
+	public int extraSpecialFieldOne { get; set; }
+	public IEnumerable<string>? extraSpecialFieldTwo { get; set; }
+	public OtherType nonStandardDataType { get; set; }
+	public IEnumerable<OtherType>? nonStandardDataTypeInArray { get; set; }
+}
+

core/data/tests/can_override_types/output.cs

@@ -0,0 +1,28 @@
+#nullable enable
+
+using System.Reflection;
+using JsonSubTypes;
+using Newtonsoft.Json;
+using System.Runtime.Serialization;
+
+public class OverrideStruct {
+	public char fieldToOverride { get; set; }
+}
+
+/** Generated type representing the anonymous struct variant `AnonymousStructVariant` of the `OverrideEnum` Rust enum */
+public class OverrideEnumAnonymousStructVariantInner {
+	public char fieldToOverride { get; set; }
+}
+
+[JsonConverter(typeof(JsonSubtypes), "type")]
+[JsonSubtypes.KnownSubType(typeof(UnitVariant), "UnitVariant")]
+[JsonSubtypes.KnownSubType(typeof(TupleVariant), "TupleVariant")]
+[JsonSubtypes.KnownSubType(typeof(AnonymousStructVariant), "AnonymousStructVariant")]
+public abstract record OverrideEnum 
+{
+	public record UnitVariant(): OverrideEnum();
+	public record TupleVariant(string Content) : OverrideEnum();
+	public record AnonymousStructVariant(OverrideEnumAnonymousStructVariantInner Content): OverrideEnum();
+}
+
+

core/data/tests/kebab_case_rename/output.cs

@@ -0,0 +1,14 @@
+#nullable enable
+
+using System.Reflection;
+using JsonSubTypes;
+using Newtonsoft.Json;
+using System.Runtime.Serialization;
+
+/** This is a comment. */
+public class Things {
+	public string bla { get; set; }
+	public string? label { get; set; }
+	public string? label-left { get; set; }
+}
+

core/src/language/csharp.rs

@@ -21,6 +21,8 @@ pub struct CSharp {
     pub no_version_header: bool,
     /// Namespace to use in the generated file
     pub namespace: String,
+    /// Disable C# property naming convention and follow Serde renaming rules on properties
+    pub without_csharp_naming_convention: bool,
 }
 
 impl Language for CSharp {
@@ -343,12 +345,18 @@ impl CSharp {
             .filter(|v| v.iter().any(|dec| dec.name() == "readonly"))
             .is_some();
 
+        let property_name = if self.without_csharp_naming_convention {
+            field.id.renamed.clone()
+        } else {
+            csharp_property_aware_rename(&field.id.renamed)
+        };
+
         writeln!(
             w,
             "\tpublic {}{} {} {{ get;{} }}",
             cs_ty,
             optional.then(|| "?").unwrap_or_default(),
-            csharp_property_aware_rename(&field.id.renamed),
+            property_name,
             if !is_readonly { " set;" } else { "" },
         )?;
 

core/src/rust_types.rs

@@ -411,7 +411,7 @@ pub enum RustTypeFormatError {
     GenericsForbiddenInGo(String),
     #[error("Generic type `{0}` cannot be used as a map key in Typescript")]
     GenericKeyForbiddenInTS(String),
-    #[error("Type aliases not support in C# 11 or lower")]
+    #[error("Type aliases are not supported in C# 11 or lower")]
     TypeAliasesForbiddenInCS(String),
     #[error("Type Unit is not supported in C#")]
     TypeUnitInCS(),