EnumToJsonMultipleTypes.cs

using System;
using System.Collections.Generic;
using Newtonsoft.Json;
using Newtonsoft.Json.Converters;
using Newtonsoft.Json.Serialization;

// Original enum with the StringEnumConverter attribute
[JsonConverter(typeof(StringEnumConverter))]
public enum UserRole
{
    Admin = 0,
    User = 1,
    Moderator = 2,
    Guest = 3
}

// Another enum with the same attribute
[JsonConverter(typeof(StringEnumConverter))]
public enum PaymentType
{
    CreditCard = 0,
    BankTransfer = 1,
    PayPal = 2
}

// User class
public class User
{
    public int Id { get; set; }
    public string Name { get; set; }
    public UserRole Role { get; set; }
    public PaymentType PreferredPaymentMethod { get; set; }
}

public class Program
{
    public static void Main()
    {
        var user = new User
        {
            Id = 1,
            Name = "John Doe",
            Role = UserRole.Admin,
            PreferredPaymentMethod = PaymentType.CreditCard
        };

        // Only UserRole will be serialized as an integer, PaymentType remains as string
        var settings = new JsonSerializerSettings
        {
            ContractResolver = new SelectiveEnumContractResolver(typeof(UserRole))
            // Could add multiple enums: new SelectiveEnumContractResolver(typeof(UserRole), typeof(AnotherEnum))
        };
        
        string json = JsonConvert.SerializeObject(user, settings);
        Console.WriteLine(json);
        
        // For ASP.NET Core example, see below
    }
}

// Generic contract resolver that targets specific enum types
public class SelectiveEnumContractResolver : DefaultContractResolver
{
    private readonly HashSet<Type> _enumTypesToSerializeAsIntegers;
    
    public SelectiveEnumContractResolver(params Type[] enumTypes)
    {
        _enumTypesToSerializeAsIntegers = new HashSet<Type>();
        
        foreach (var type in enumTypes)
        {
            if (type.IsEnum)
            {
                _enumTypesToSerializeAsIntegers.Add(type);
            }
        }
    }
    
    protected override JsonContract CreateContract(Type objectType)
    {
        JsonContract contract = base.CreateContract(objectType);
        
        // Only remove JsonConverter for specific enum types
        if (objectType.IsEnum && _enumTypesToSerializeAsIntegers.Contains(objectType))
        {
            contract.Converter = null;
        }
        
        return contract;
    }
}

// Usage in ASP.NET Core for specific controllers
/*
[ApiController]
[Route("api/[controller]")]
public class UsersController : ControllerBase
{
    private readonly JsonSerializerSettings _jsonSettings;
    
    public UsersController()
    {
        _jsonSettings = new JsonSerializerSettings
        {
            ContractResolver = new SelectiveEnumContractResolver(typeof(UserRole))
        };
    }
    
    [HttpGet("{id}")]
    public IActionResult GetUser(int id)
    {
        var user = // Get user from repository
        
        // Override the default serialization for this specific action
        return new JsonResult(user, _jsonSettings);
    }
}
*/

// For global configuration with selective enums:
/*
public void ConfigureServices(IServiceCollection services)
{
    services.AddControllers()
            .AddNewtonsoftJson(options =>
            {
                options.SerializerSettings.ContractResolver = 
                    new SelectiveEnumContractResolver(typeof(UserRole), typeof(OtherEnum));
            });
}
*/

// Extension method for more convenient usage:
public static class JsonExtensions
{
    public static string SerializeWithIntegerEnums<T>(this T obj, params Type[] enumTypes)
    {
        var settings = new JsonSerializerSettings
        {
            ContractResolver = new SelectiveEnumContractResolver(enumTypes)
        };
        
        return JsonConvert.SerializeObject(obj, settings);
    }
}

// Usage example of the extension method:
// string json = user.SerializeWithIntegerEnums(typeof(UserRole));