Hey there! I totally get wanting to move past a clunky try-catch approach for validating imported JSON structure in your WPF app. Let's look at a few cleaner, more maintainable solutions that fit your use case.

Option 1: Strongly-Typed Models + JSON Schema Validation (Recommended) #

First, define C# classes that mirror your existing JSON structure—this gives you compile-time safety and makes validation straightforward. Here's how to set it up:

Step 1: Create Your Model Classes #

public class AppConfiguration
{
    public DatabaseSettings Database { get; set; }
    public WebsiteSettings Website { get; set; }
    public List<UserProfile> User { get; set; }
    public ReportServiceSettings ReportService { get; set; }
}

public class DatabaseSettings
{
    public string Instance { get; set; }
    public string UserName { get; set; }
    public string Password { get; set; }
}

public class WebsiteSettings
{
    public string Ip { get; set; }
    public string Port { get; set; }
}

public class UserProfile
{
    // Add properties matching the structure of objects in your User array
    // Example: public string Id { get; set; }, public string DisplayName { get; set; }
}

public class ReportServiceSettings
{
    public string Instance { get; set; }
    public string Ip { get; set; }
    public string Port { get; set; }
}

Step 2: Validate with JSON Schema (.NET 7+) #

If you're on .NET 7 or later, use the built-in System.Text.Json.Schema to generate a schema from your model and validate imported JSON against it. This gives you clear, actionable error messages when the structure doesn't match:

using System.Text.Json;
using System.Text.Json.Schema;

// Generate a schema from your AppConfiguration model
var configSchema = JsonSchemaGenerator.Generate(typeof(AppConfiguration));

// Load the imported JSON file
string importedJson = File.ReadAllText("path/to/imported.json");

// Validate the JSON against the schema
using var jsonDoc = JsonDocument.Parse(importedJson);
var validationResult = configSchema.Validate(jsonDoc);

if (!validationResult.IsValid)
{
    // Handle validation errors (e.g., show a detailed message in your WPF UI)
    foreach (var error in validationResult.Errors)
    {
        Console.WriteLine($"Structure error: {error.Message} at path {error.Path}");
    }
}
else
{
    // Proceed with processing the valid imported data
    var importedConfig = JsonSerializer.Deserialize<AppConfiguration>(importedJson);
}

Option 2: Recursive JObject Structure Comparison #

If you prefer not to use models (or need more flexibility), use JObject (from Newtonsoft.Json) to recursively compare the structure of your local JSON and the imported JSON. This lets you check for missing fields or unexpected extra fields:

using Newtonsoft.Json.Linq;

// Load your local reference config and the imported config
JObject localConfig = JObject.Parse(File.ReadAllText("localConfig.json"));
JObject importedConfig = JObject.Parse(File.ReadAllText("imported.json"));

// Recursive method to validate structure
bool IsStructureMatching(JObject expected, JObject actual)
{
    // Check for missing required properties
    foreach (var expectedProp in expected.Properties())
    {
        if (!actual.ContainsKey(expectedProp.Name))
        {
            Console.WriteLine($"Missing required property: {expectedProp.Name}");
            return false;
        }

        // Recurse into nested objects
        if (expectedProp.Value is JObject expectedNested && actual[expectedProp.Name] is JObject actualNested)
        {
            if (!IsStructureMatching(expectedNested, actualNested))
                return false;
        }

        // Validate array item structure (if your User array has consistent objects)
        if (expectedProp.Value is JArray expectedArray && actual[expectedProp.Name] is JArray actualArray)
        {
            if (expectedArray.Any() && actualArray.Any())
            {
                if (expectedArray.First is JObject expectedItem && actualArray.First is JObject actualItem)
                {
                    if (!IsStructureMatching(expectedItem, actualItem))
                        return false;
                }
            }
        }
    }

    // Optional: Check for unexpected extra properties
    foreach (var actualProp in actual.Properties())
    {
        if (!expected.ContainsKey(actualProp.Name))
        {
            Console.WriteLine($"Unexpected property: {actualProp.Name}");
            // Uncomment below if you want to reject extra fields entirely
            // return false;
        }
    }

    return true;
}

bool isValid = IsStructureMatching(localConfig, importedConfig);
if (isValid)
{
    // Imported JSON has the correct structure—proceed with processing
}

Why These Are Better Than Try-Catch #

• Clear Error Feedback: You get specific details about what's wrong (missing fields, incorrect types) instead of a generic exception.
• Maintainable: If your config structure changes, updating model classes or the schema is far easier than adjusting scattered catch blocks.
• Intentional: Your code explicitly states that you're validating structure, making it easier for other developers (or future you) to understand the logic.

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