Проблема отображения при создании универсального метода

Используйте один универсальный метод с отражением для динамического сопоставления свойств JSON с объектами модели, избегая нескольких реализаций MapFromJson. Это централизует и упрощает процесс сопоставления различных типов.

public interface IJsonResult
{
}


public class JsonResult1 : IJsonResult
{
    public List<Product> ProductLists { get; set; }
}

public class JsonResult2 : IJsonResult
{
    public List<User> UserLists { get; set; }
}

public class Result1
{
    public string Price { get; set; }
    public string Id { get; set; }
}

public class Result2
{
    public string firstName { get; set; }
    public string lastName { get; set; }
    public string Id { get; set; }
}

public class Product
{
    public string Price { get; set; }
    public string ID { get; set; }
}

public class User
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string ID { get; set; }
}

public class DataService
{
    public async Task<List<T>> GetMethod<T, J>(string id, string jsonString) where J : IJsonResult
    {
        return await Task.Run(() => MapFromJson<T, J>(jsonString));
    }

    private List<T> MapFromJson<T, J>(string jsonString) where J : IJsonResult
    {
        var info = JsonConvert.DeserializeObject<J>(jsonString);
        var mylist = new List<T>();

        // Use reflection to get the lists and map to the result type
        var listProperty = typeof(J).GetProperties().FirstOrDefault(p => p.PropertyType.IsGenericType);
        if (listProperty != null)
        {
            var itemList = (IEnumerable<object>)listProperty.GetValue(info);

            foreach (var item in itemList)
            {
                var result = Activator.CreateInstance<T>();

                foreach (var prop in typeof(T).GetProperties())
                {
                    var itemProp = item.GetType().GetProperty(prop.Name, BindingFlags.IgnoreCase | BindingFlags.Public | BindingFlags.Instance);
                    if (itemProp != null)
                    {
                        prop.SetValue(result, itemProp.GetValue(item));
                    }
                }

                mylist.Add(result);
            }
        }

        return mylist;
    }
}

// Usage
public async Task ExampleUsage()
{
    var dataService = new DataService();

    string jsonString1 = ""; // Your JSON string for Result1
    List<Result1> result1List = await dataService.GetMethod<Result1, JsonResult1>("someId", jsonString1);

    string jsonString2 = ""; // Your JSON string for Result2
    List<Result2> result2List = await dataService.GetMethod<Result2, JsonResult2>("someId", jsonString2);
}

Мы можем сделать следующее (некрасиво, но изменить нельзя JsonResult*)

public async Task<List<TResult>> GetGenericMethod
<TResult, TJsonResult, TItem>(
string id, string a, Func<TItem, TResult> mapper
, Func<TJsonResult, IEnumerable<TItem>> getIterator)
 {
    TJsonResult info = JsonConvert.DeserializeObject<TJsonResult>(a);
    // shorter version
    //return getIterator(info)
    //.Select(mapper)
    //.ToList();
    List<TResult> mylist = new List<TResult>();
    IEnumerable<TItem> enumerable = getIterator(info);
    foreach (var item in enumerable) {
        mylist.Add(mapper(item));
    }
    return mylist;
}

Пример использования:

var jsonResult1 = new JsonResult1();
jsonResult1.ProductLists = new List<Product>();
jsonResult1.ProductLists.Add(new Product { ID = "3", Price = "4" });
jsonResult1.ProductLists.Add(new Product { ID = "7", Price = "8" });

var serialized = JsonConvert.SerializeObject(jsonResult1);
Func<Product, Result1> mapper = p => new Result1 {
    Price = p.Price,
    Id = p.ID
}; // this can be a method and not a lambda

var result = await GetFirstMethod<Result1, JsonResult1, Product>(
"", serialized, mapper, r => r.ProductLists);
foreach (var element in result) {
    Console.WriteLine(element);
}

Первоначально я использовал производный тип от JSonResult1, который реализовал IEnumerable<T>, чтобы использовать перечислитель, но, вдохновленный другим ответом (от ipodtouch0218), в этом, похоже, нет реальной необходимости, и мы можем просто использовать Func<TJsonResult, IEnumerable<TItem>> для менее многословного и так же, как функциональный код.

Вероятно, это самый запутанный ответ, который только можно себе представить, но вы можете использовать словарь, чтобы делегаты могли сопоставлять три разных типа:

public class Mapping {
    public static readonly Dictionary<(Type,Type), Mapping> RegisteredMappings = new();
    public Func<object,IEnumerable<object>> enumerate;
    public Func<object,object> map;
    
    public static void Register<T,M,R>(Func<T, IEnumerable<M>> enumerateFunc, Func<M, R> mappingFunc) where T : class where M : class where R : class {
        RegisteredMappings.Add((typeof(T), typeof(R)), new Mapping {
            enumerate = (object input) => enumerateFunc((T) input),
            map = (object input) => mappingFunc((M) input),
        });
    }
}

public static List<R> Get<T,R>(string id, string a) {
    if (!Mapping.RegisteredMappings.TryGetValue((typeof(T), typeof(R)), out Mapping mapping)) {
        throw new ArgumentException($"No mapping exists between {typeof(T).Name} and {typeof(R).Name}");
    }

    T info = JsonConvert.DeserializeObject<T>(a);
    List<R> list = new();

    foreach (var item in mapping.enumerate(info)) {
        list.Add((R) mapping.map(item));
    }

    return list;
}

Пример использования:

public static void Main()
{
    // Example JSON for JsonResult1 (Product) and JsonResult2 (User)
    string productJson = "{\"ProductLists\": [{\"Price\": \"100.00\", \"ID\": \"XYZ\"},{\"Price\": \"50.00\", \"ID\": \"ABC\"}]}";
    string userJson = "{\"UserLists\": [{\"FirstName\": \"Mark\", \"LastName\": \"B.\", \"ID\": \"XYZ\"},{\"FirstName\": \"Joseph\", \"LastName\": \"S.\", \"ID\": \"ABC\"}]}";

    // Register the mapping from JsonResult1 -> Result1 and JsonResult2 -> Result2 (using the Product/User classes as an intermediary)
    Mapping.Register<JsonResult1, Product, Result1>(EnumerateProducts, MapProduct);
    Mapping.Register<JsonResult2, User, Result2>(EnumerateUsers, MapUser);

    // Example usage
    List<Result1> productResults = Get<JsonResult1, Result1>("unused", productJson);
    Console.WriteLine(string.Join(',', productResults.Select(product => product.Price)));
    // -> 100.00,50.00

    List<Result2> userResults = Get<JsonResult2, Result2>("unused", userJson);
    Console.WriteLine(string.Join(',', userResults.Select(user => user.firstName)));
    // -> Mark,Joseph
}

public static IEnumerable<Product> EnumerateProducts(JsonResult1 jr1) => jr1.ProductLists;
public static Result1 MapProduct(Product p) {
    return new Result1 {
        Price = p.Price,
        Id = p.ID,
    };
}
public static IEnumerable<User> EnumerateUsers(JsonResult2 jr2) => jr2.UserLists;
public static Result2 MapUser(User u) {
    return new Result2 {
        firstName = u.FirstName,
        lastName = u.LastName,
        Id = u.ID
    };
}

Таким образом, вам нужно будет зарегистрировать каждое сопоставление только один раз при загрузке, и тогда вам больше никогда не придется ссылаться на них. Просто вызов функции с указанными типами ввода/результата будет работать.