如何简化全球机场JSON对应的C#类生成？能否使用泛型？

Absolutely, you don’t need to generate thousands of redundant classes for this scenario—there’s a much cleaner approach, and while generics play a role here, the core solution revolves around reusing a single entity class paired with a dictionary container. Let me break this down for you:

Step 1: Define a Single Airport Entity Class #

All your airport entries share the exact same structure, so you only need one class to represent any airport. This eliminates the need for generating a unique class per ICAO code:

public class Airport
{
    public string Icao { get; set; }
    public string Iata { get; set; }
    public string Name { get; set; }
    public string City { get; set; }
    public string State { get; set; }
    public string Country { get; set; }
    public int Elevation { get; set; }
    public double Lat { get; set; }
    public double Lon { get; set; }
    public string Tz { get; set; }
}

Step 2: Use a Dictionary to Hold All Airports #

Your JSON structure is a key-value pair collection where each key is an ICAO code (like "00AK") and the value is the corresponding airport data. The perfect fit for this in C# is a Dictionary<string, Airport>—it’s optimized for fast lookups (critical when dealing with 100k+ entries) and maps directly to your JSON format.

Here’s how you’d deserialize your JSON data using System.Text.Json (the built-in serializer in .NET Core/.NET 5+):

using System.Text.Json;

// Assume jsonContent is your raw JSON string/file content
var airportDictionary = JsonSerializer.Deserialize<Dictionary<string, Airport>>(jsonContent);

If you’re using Newtonsoft.Json (Json.NET), the syntax is similar:

using Newtonsoft.Json;

var airportDictionary = JsonConvert.DeserializeObject<Dictionary<string, Airport>>(jsonContent);

Why This Works Better Than Generating Individual Classes #

• No redundancy: You only maintain one class instead of 100k+—way easier to update if the airport data structure changes (e.g., adding a "timezoneOffset" field).
• Efficient memory usage: Dictionaries are designed to handle large collections efficiently, and reusing the same class type reduces memory overhead from duplicate type metadata.
• Easy access: You can quickly fetch any airport by its ICAO code with var myAirport = airportDictionary["00AK"];.

Do Generics Fit Here? #

Absolutely—Dictionary<TKey, TValue> is a generic collection, and that’s exactly what we’re using here. The TKey is string (for the ICAO code) and TValue is our Airport class. If you wanted to create a generic method to handle similar key-value JSON structures for other entities (e.g., weather stations, ports), you could write something like this:

public static Dictionary<string, T> DeserializeKeyedJson<T>(string jsonContent)
{
    return JsonSerializer.Deserialize<Dictionary<string, T>>(jsonContent);
}

// Usage for airports:
var airports = DeserializeKeyedJson<Airport>(jsonContent);

But for your specific airport use case, the direct Dictionary<string, Airport> approach is already clean and efficient—no need to overcomplicate it with extra generic abstractions unless you plan to reuse the logic for other datasets.

Key Takeaway #

Forget generating individual classes for each airport. Use a single Airport class to model the data structure, then load all entries into a Dictionary<string, Airport>. This is the standard approach for handling large key-value JSON datasets in C# and will save you tons of time and maintainability headaches.

内容的提问来源于stack exchange，提问作者VIGNESH WARAN