JSON to C# Converter: แปลง JSON เป็น C# Class แบบสะอาดตาในไม่กี่วินาที

นักพัฒนา .NET ทุกคนเคยเจอสถานการณ์นี้ — เรียก API แล้วได้ JSON ก้อนใหญ่กลับมา และต้องเขียน C# class รองรับมันก่อนถึงจะ deserialize อะไรได้ การนั่งพิมพ์ class เหล่านั้นเองเป็นงานที่น่าเบื่อ ผิดพลาดง่าย และแทบจะเป็นฝันร้ายถ้า payload มีการ nest กันหกชั้น JSON to C# Converter ทำส่วนที่น่าเบื่อนั้นแทนคุณ — วาง JSON sample, คัดลอก C# class ที่สะอาดและ compile ได้ทันที พร้อมใช้กับ System.Text.Json

จุดที่ทำให้เครื่องมือนี้ต่างจาก generator ออนไลน์ทั่วไปคือความสามารถในการควบคุมรายละเอียด คุณเลือกชื่อ root class เอง ตัดสินใจว่าจะใส่ [JsonPropertyName] attributes หรือไม่ และเปิด/ปิด nullable reference types ได้ตาม C# language version ของโปรเจกต์ และเพราะทุกอย่างทำงาน 100% client-side ใน browser ของคุณ JSON จะไม่มีทางออกจากเครื่อง — ซึ่งสำคัญมากเมื่อคุณทำงานกับ API response ภายใน, ข้อมูลลูกค้า หรือ webhook payload ที่เป็นความลับทางการค้า

ในคู่มือนี้เราจะพาไปดูว่า converter ทำงานอย่างไร JSON type แม็ปกับ C# type อย่างไร และสถานการณ์จริงที่ class ที่ generate อัตโนมัติช่วยประหยัดเวลาให้คุณได้เท่าไหร่

ทำไมต้องใช้ JSON to C# Converter?

• ประหยัดเวลาได้ทันที การแปลง JSON response ที่มี 40 fields ซ้อนกันหลายชั้นเป็น C# class ด้วยมือใช้เวลา 20–30 นาที แถมเสี่ยงพิมพ์ผิด converter ทำเสร็จในไม่ถึงวินาที พร้อม naming ที่สม่ำเสมอทุก nested type
• ออกแบบมาเพื่อความเป็นส่วนตัว การแปลงเกิดขึ้นใน browser ทั้งหมด ไม่มีการยิงไป server ไม่มีการ upload ไม่มี log — ปลอดภัยกับ enterprise payload ที่ผูก NDA และ API ภายในองค์กร
• output พร้อมใช้กับ System.Text.Json class ที่ได้มาใช้ [JsonPropertyName] attributes จึงทำงานได้ทันทีกับ serializer ที่มาพร้อม .NET สมัยใหม่ — ไม่ต้องติดตั้ง NuGet package เพิ่ม
• รองรับ nullable reference types โปรเจกต์เป็น C# 8+ และเปิด <Nullable>enable</Nullable> อยู่ใช่ไหม? เปิด toggle แล้วจะได้ annotation แบบ string?, object? ในจุดที่ JSON sample สมเหตุสมผล
• จัดการ nesting และ array อย่างฉลาด object ที่ซ้อนกันกลายเป็น nested class ที่มีชื่อชัดเจน และ array กลายเป็น List<T> พร้อมชื่อ item class ที่ singularize อัตโนมัติ — ไม่ใช่กอง object กับ ArrayList รก ๆ
• เยี่ยมสำหรับการเรียนรู้ ถ้าคุณเพิ่งเริ่มเขียน C# หรือเพิ่งรู้จัก JSON serialization การเทียบ payload กับ class ที่ generate ให้ คือวิธีที่เร็วที่สุดวิธีหนึ่งในการทำความเข้าใจว่า type system ทั้งสองฝั่งเชื่อมโยงกันอย่างไร

ฟีเจอร์เด่น

มีรายละเอียดสองจุดที่น่าชี้ให้เห็น อย่างแรกคือ logic การ singularize — JSON key อย่าง "items" ที่เก็บ array ของ object จะสร้าง class ชื่อ Item และ "order_lines" กลายเป็น OrderLine ทำให้ property ที่เป็น collection อ่านแล้วเป็นธรรมชาติในภาษา C# อย่างที่สองคือการ escape — ชื่อ property ที่มี quote หรือ backslash จะถูก escape ให้ถูกต้องภายใน attribute [JsonPropertyName] ดังนั้นแม้ payload จาก third-party จะแสนจะเละ ก็ได้โค้ดที่ compile ได้เสมอ

วิธีใช้งาน

1. เปิด JSON to C# Converter ใน browser
2. วาง JSON sample ลงในช่อง input — จะเป็น API response, config file หรือ webhook payload ก็ได้ รองรับ top-level array ด้วย
3. ตั้งชื่อ root class ให้สื่อความหมายกับ domain ของคุณ เช่น OrderResponse หรือ StripeWebhook
4. สลับ toggle Include JsonPropertyName attributes และ Use nullable reference types ตาม convention ของโปรเจกต์
5. กดปุ่มคัดลอก C# ที่ generate จากช่อง output แล้วนำไปวางในโปรเจกต์ได้เลย — compile ได้ทันที

นี่คือตัวอย่าง input กับผลลัพธ์ที่ได้ กำหนด JSON นี้:

{
  "orderId": "A-1288",
  "customer": { "name": "Ana", "vip": true },
  "items": [{ "sku": "KB-01", "qty": 2, "price": 45.5 }]
}

converter จะ generate ให้:

public class Order
{
    [JsonPropertyName("orderId")]
    public string OrderId { get; set; }

    [JsonPropertyName("customer")]
    public Customer Customer { get; set; }

    [JsonPropertyName("items")]
    public List<Item> Items { get; set; }
}

public class Customer
{
    [JsonPropertyName("name")]
    public string Name { get; set; }

    [JsonPropertyName("vip")]
    public bool Vip { get; set; }
}

public class Item
{
    [JsonPropertyName("sku")]
    public string Sku { get; set; }

    [JsonPropertyName("qty")]
    public int Qty { get; set; }

    [JsonPropertyName("price")]
    public double Price { get; set; }
}

แนวคิดที่ควรเข้าใจ: Type Mapping และ Serialization

JSON type แม็ปกับ C# type อย่างไร — JSON string กลายเป็น string ตัวเลขกลายเป็น int หรือ double ขึ้นอยู่กับมีจุดทศนิยมหรือไม่ boolean กลายเป็น bool และ array กลายเป็น List<T> ส่วน null ใน sample จะแม็ปเป็น object — หรือ object? ถ้าเปิด nullable reference types — เพราะ null เพียงค่าเดียวบอกไม่ได้ว่า type ที่แท้จริงคืออะไร ถ้าคุณควบคุม API อยู่ การให้ sample ที่ข้อมูลเต็มที่สุด (ทุก field มีค่า) จะได้ class ที่แม่นยำที่สุด

ทำไม [JsonPropertyName] ถึงสำคัญ — API ส่วนใหญ่ใช้ camelCase ในขณะที่ convention ของ .NET บังคับ property แบบ PascalCase ถ้าไม่ใช้ attribute คุณต้องไปตั้ง JsonSerializerOptions ให้ PropertyNamingPolicy = CamelCase — ซึ่งโอเคสำหรับ API ของตัวเอง แต่เปราะบางมากเมื่อ class เดียวต้องคุยกับแหล่งข้อมูลสองที่ที่ตัวพิมพ์ไม่เหมือนกัน การตรึงแต่ละ property เข้ากับ JSON key เดิมด้วย [JsonPropertyName] ทำให้ class พึ่งพาตัวเองได้ และไม่หวั่นต่อ configuration ของ serializer ที่เปลี่ยนไป

Nullable reference types ในทางปฏิบัติ — ตั้งแต่ C# 8 nullability ของ reference type เป็นส่วนหนึ่งของ type system และโปรเจกต์ใหม่เปิดใช้เป็น default toggle นี้ทำให้ generate annotation ที่สอดคล้องกับ setting ของโปรเจกต์ คุณจึงไม่ต้องเสียเวลาชั่วโมงครึ่งไล่แก้ warning CS8618 ("non-nullable property must contain a non-null value") หลังวางโค้ดที่ generate ลงใน solution สมัยใหม่

จากนั้น deserialize ได้ในบรรทัดเดียว — เมื่อมี class ที่ generate แล้ว การใช้งานง่ายแค่นี้:

var order = JsonSerializer.Deserialize<Order>(json, jsonOptions);

นี่คือรางวัลทั้งหมดของกระบวนการ — งาน modeling หลายนาทียุบเหลือแค่ วาง, กด, คัดลอก

ตัวอย่างการใช้งานจริง

เรียก REST API จาก third-party

คุณกำลัง integrate กับ payment provider, shipping API หรือ microservice ภายใน และ documentation ให้ตัวอย่าง response มาแค่ก้อนเดียว วางตัวอย่างนั้นลง converter ตั้งชื่อ root class ว่า PaymentResponse แล้วคุณจะมี typed client model ทันที ห่อมันด้วย HttpClient service เล็ก ๆ ก็จบ — ไม่ต้องเลื่อนอ่าน docs ทั้งหน้าเพื่อเดา type ของแต่ละ field

รับ webhook payload จาก third-party

Webhook จาก Stripe, GitHub หรือ Shopify วิ่งเข้ามาเป็น JSON ที่ nest ลึกมาก และคุณต้อง deserialize ให้ไวใน handler generate class จาก sample payload ที่จับได้จริง (ดึงจาก dashboard ของ provider หรือจาก log) แล้ว handler ของคุณจะ strongly typed ตั้งแต่ต้นจนจบ และเพราะการแปลงเป็น client-side การวาง payload จริงที่จับมาไม่ใช่ปัญหาเรื่อง compliance

ย้าย config file มาเป็น typed settings

ทีมที่กำลังย้ายจาก appsettings.json แบบหลวม ๆ หรือ JSON config เก่า ไปสู่ options pattern ของ .NET (IOptions<T>) สามารถ generate settings class จากไฟล์ปัจจุบันได้เลย class ที่ได้วางเข้า services.Configure<AppSettings>(configuration.GetSection("App")) ได้ทันทีโดยไม่ต้องพิมพ์ซ้ำ และ [JsonPropertyName] ช่วยให้ทุกอย่าง consistent หาก config ถูกอ่านด้วย System.Text.Json ที่อื่นด้วย

สร้าง DTO สำหรับ ASP.NET Core และ EF Core

ต้องการคู่ request/response DTO สำหรับ endpoint ใหม่ หรือ projection model ที่มีหน้าตาเหมือน JSON export เดิม? generate โครงจาก sample แล้วค่อยปรับ — เปลี่ยนชื่อ, ใส่ validation attributes อย่าง [Required], ตัด field ที่ไม่รับ ทิ้ง converter ให้จุดตั้งต้นเชิงโครงสร้างที่ถูกต้องในไม่กี่วินาที แทนไฟล์เปล่าที่ต้องเริ่มเขียนเองทั้งหมด

Best Practices

• ให้ sample ที่ข้อมูลเต็มที่สุดเท่าที่หาได้ — field ที่ไม่ปรากฏใน sample ไม่มีทางถูก infer type ได้ ใช้ payload ที่ทุก field มีค่า หรือรวมหลาย sample เข้าด้วยกันด้วยมือก่อน
• ตรวจ numeric type ที่ generate ให้ดี — ID ที่ดูเหมือนตัวเลขใน sample ของคุณ อาจเป็น string ในความเป็นจริง เช็คกับ API docs ก่อนส่งงานเสมอ
• เปิด [JsonPropertyName] เมื่อทำงานกับ external API — มันแยกชื่อใน C# ออกจากรูปแบบบน wire ซึ่งเป็นสิ่งที่คุณต้องการเมื่อ third party เปลี่ยนชื่อ field ของเขา
• เปิด nullable reference types ให้ตรงกับโปรเจกต์ — ถ้า .csproj มี <Nullable>enable</Nullable> ให้ generate โดยเปิด toggle นี้ โค้ดจะได้ compile โดยไม่มี warning
• มอง output เป็นจุดตั้งต้น — เติม validation, doc comment และ domain method เมื่อโครงสร้างถูกต้องแล้ว การ generate ดูแลเรื่องรูปร่าง ส่วนพฤติกรรมเป็นหน้าที่ของคุณ
• regenerate เมื่อ API เปลี่ยน — เมื่อ provider เพิ่ม field ใหม่ generate ใหม่จาก sample สด ๆ แล้ว diff กับ class เดิม แทนการลงมือแก้เอง — คุณจะจับ type ที่เปลี่ยนแบบเงียบ ๆ ได้ทัน

สรุปและเริ่มใช้งาน

เลิกนั่งถอด JSON มาเขียน C# ด้วยมือเถอะ วาง payload ถัดไปของคุณลงใน JSON to C# Converter เลือก options ที่ต้องการ แล้วคัดลอก class ที่พร้อมใช้งานจริงได้ในไม่กี่วินาที — เป็นส่วนตัว ทำงานใน browser ทั้งหมด และฟรี

เครื่องมือที่เกี่ยวข้อง:

• JSON to TypeScript — generate TypeScript interface แบบ typed จาก JSON sample เดียวกันสำหรับ frontend ของคุณ
• JSON to Java Converter — สร้าง Java POJO สำหรับ Android หรือ JVM backend จาก JSON payload
• JSON Formatter — เก็บรายละเอียดและ validate JSON ที่เละ ๆ ก่อนส่งเข้า converter ใด ๆ

ขอให้สนุกกับการเขียนโค้ด!