Mammt's questions

Eu tenho uma PagedList<>classe que implementa uma interface chamadaIPagedList<>

A classe não tem um construtor público, mas pode ser criada por meio de um método estático chamadoCreate

    public static IPagedList<T> Create(IEnumerable<T> items, int pageNumber, int pageSize, int totalItems) {
        Ensure.That.IsNotNull(items);
        Ensure.That.IsNotZeroOrNegative(pageNumber);
        Ensure.That.IsNotZeroOrNegative(pageSize);

        var totalItemCount = totalItems;
        return new PagedList<T>(items, pageNumber, pageSize, totalItemCount);
    }

Este método simplesmente invoca o construtor que é declarado private protected.

Se o Createmétodo for invocado diretamente, o objeto retornado será umIPagedList<T>

Entretanto, quando o método é invocado por meio de reflexão, o tipo retornado é umPagedList<T>

Este é o código para reflexão

var typeToCall = typeof(PagedList<>).MakeGenericType(targetType);
MethodInfo createMethod = typeToCall.GetMethod("Create")!;
dynamic result = createMethod.Invoke(null, new object[] { value, pageNumber, pageSize, totalItems })!;
return (IPagedList)result!;

Esse comportamento é normal? Acontece porque estou usando dynamic?

Quando o objeto criado é retornado ao chamador, que espera um IPagedList<T>I obtém uma exceção que diz

System.InvalidCastException: Não é possível converter o objeto do tipo 'ApiResult 1[PagedList1[ProgramResponse]]' para o tipo 'ApiResult 1[IPagedList1[ProgramResponse]]'.

   at System.Text.Json.ThrowHelper.ThrowInvalidCastException_DeserializeUnableToAssignValue(Type typeOfValue, Type declaredType)
   at System.Text.Json.JsonSerializer.<UnboxOnRead>g__ThrowUnableToCastValue|50_0[T](Object value)
   at System.Text.Json.JsonSerializer.UnboxOnRead[T](Object value)
   at System.Text.Json.Serialization.JsonConverter`1.TryRead(Utf8JsonReader& reader, Type typeToConvert, JsonSerializerOptions options, ReadStack& state, T& value, Boolean& isPopulatedValue)
   at System.Text.Json.Serialization.JsonConverter`1.ReadCore(Utf8JsonReader& reader, JsonSerializerOptions options, ReadStack& state)
   at System.Text.Json.JsonSerializer.ReadFromSpan[TValue](ReadOnlySpan`1 utf8Json, JsonTypeInfo`1 jsonTypeInfo, Nullable`1 actualByteCount)
   at System.Text.Json.JsonSerializer.ReadFromSpan[TValue](ReadOnlySpan`1 json, JsonTypeInfo`1 jsonTypeInfo)

Estou incluindo o JsonConverter completo que desserializa o objeto IPagedList

internal class NativePagedListConverter : JsonConverter<IPagedList> {
    public override bool CanConvert(Type typeToConvert) {
        return typeToConvert.IsPagedList();
    }

    public override IPagedList? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) {
        if (reader.TokenType != JsonTokenType.StartObject) {
            throw new JsonException();
        }
        int pageNumber = 0;
        int pageSize = 0;
        int totalItems = 0;
        dynamic value = default!;
        var targetType = typeToConvert.GetGenericArguments()[0]!;
        while (reader.Read()) {
            if (reader.TokenType == JsonTokenType.EndObject) {
                break;
            }
            if (reader.TokenType != JsonTokenType.PropertyName) {
                throw new JsonException();
            }
            var propertyName = reader.GetString() ?? string.Empty;
            reader.Read();
            if (propertyName.Equals(nameof(pageNumber), StringComparison.OrdinalIgnoreCase)) {
                pageNumber = reader.GetInt32();
            }
            else if (propertyName.Equals(nameof(pageSize), StringComparison.OrdinalIgnoreCase)) {
                pageSize = reader.GetInt32();
            }
            else if (propertyName.Equals(nameof(totalItems), StringComparison.OrdinalIgnoreCase)) {
                totalItems = reader.GetInt32();
            }
            else if (propertyName.Equals("Items", StringComparison.OrdinalIgnoreCase)) {
                var itemsType = typeof(IEnumerable<>).MakeGenericType(targetType);
                value = JsonSerializer.Deserialize(ref reader, itemsType, options)!;
            }
        }
        var typeToCall = typeof(PagedList<>).MakeGenericType(targetType);
        MethodInfo createMethod = typeToCall.GetMethod("Create")!;
        dynamic result = createMethod.Invoke(null, new object[] { value, pageNumber, pageSize, totalItems })!;
        return (IPagedList)result!;
    }

    public override void Write(Utf8JsonWriter writer, IPagedList value, JsonSerializerOptions options) {
        [...omitted as not interesting for the question...]
    }

}

Estou tentando obter todas as propriedades de uma classe que tem um setter privado. Isso parece muito simples, no entanto, me deparo com um comportamento estranho, mas provavelmente normal.

Esta é a solução que implementei

public static IEnumerable<PropertyInfo> InstanceProperties(this Type type) {
    List<PropertyInfo> results = new();
    var allProperties = type.GetProperties(BindingFlags.Public | BindingFlags.Instance);
    foreach (var property in allProperties) {
        var setMethod = property.GetSetMethod(true);
        if (setMethod != null && setMethod.IsPrivate) {
            results.Add(property);
        }
    }
    return results;
}

Criei algumas classes simples para teste também

public class BaseClass {
    public string Name { get; private set; }
    public BaseClass(string name) {
        Name = name;
    }
}

public class DerivedClass : BaseClass {
    public string Description { get; private set; }
    public DerivedClass(string name, string description) : base(name) {
        Description = description;
    }
}

Para testar isso estou usando

[Fact]
public void InstanceProperties_WithBaseType_ReturnsAllProperties() {
    // Arrange
    Type baseEntityType = typeof(BaseClass);
    // Act
    var result = baseEntityType.InstanceProperties();
    // Assert
    result.Should().NotBeNullOrEmpty();
    result.Count().Should().Be(1);
}

[Fact]
public void InstanceProperties_WithDerivedType_ReturnsAllProperties() {
    // Arrange
    Type baseEntityType = typeof(DerivedClass);
    // Act
    var result = baseEntityType.InstanceProperties();
    // Assert
    result.Should().NotBeNullOrEmpty();
    result.Count().Should().Be(2);
}

O primeiro teste é bem-sucedido enquanto o segundo falha. Mais especificamente no segundo teste, o código var allProperties = type.GetProperties(BindingFlags.Public | BindingFlags.Instance);retorna duas propriedades, porém a propriedade da classe base não tem um método setter. Isso não é propriamente coerente com o primeiro teste, pois nesse caso a propriedade tem um método set que é definido como privado.

Alguma sugestão/explicação sobre esse comportamento?

EDIT Conforme sugestões dos comentários, explico melhor o escopo da questão. O objetivo final é construir alguns tipos de objetos que tenham as seguintes características:

• Podem ser classes que herdam diretamente de uma classe base bem conhecida (por exemplo Entity) que têm uma única propriedade de instância exclusiva do tipo Guid com um setter privado
• Podem ser classes que herdam de uma classe base abstrata que por sua vez herda deEntity
• Todas as propriedades de instância têm um setter privado
• Todas as classes têm um único método de fábrica estático público chamado Createcom, é claro, parâmetros diferentes para cada classe

Gostaria de entender como essa técnica de construção é manipulada pelo Entity Framework, que usa um construtor privado sem parâmetros para criar instâncias de objetos.

EDITAR 2

Acabei escrevendo uma solução que é muito parecida com as duas apresentadas por Jamiec e Gert Arnold. Estou escrevendo aqui para referência. Obrigado a todos!

public static IEnumerable<PropertyInfo> InstanceProperties(this Type type) {
    List<PropertyInfo> results = new();
    Type? leafType = type;
    while (leafType != null) {
        var allProperties = leafType.GetProperties(BindingFlags.Public | BindingFlags.Instance);
        foreach (var property in allProperties) {
            var accessors = property
                .GetAccessors(true)
                .Where(a => a.ReturnType == typeof(void) && a.IsPrivate)
                .ToArray();
            foreach (var accessor in accessors) {
                results.Add(property);
            }
        }
        leafType = leafType.BaseType;
    }
    return results;
}