Mammt's questions

我有一个PagedList<>实现接口的类，称为IPagedList<>

该类没有公共构造函数，但可以通过静态方法创建Create

    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);
    }

此方法只是调用声明的构造函数private protected。

如果Create直接调用该方法，则返回的对象是IPagedList<T>

然而，当通过反射调用该方法时，返回的类型是PagedList<T>

这是反射的代码

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!;

这种行为正常吗？是不是因为我使用了 才发生这种情况dynamic？

当创建的对象返回给调用者时，它期望IPagedList<T>我得到一个异常，说

System.InvalidCastException：无法将类型“ApiResult 1[PagedList1[ProgramResponse]]”的对象转换为类型“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)

我包括反序列化 IPagedList 对象的完整 JsonConverter

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...]
    }

}

我正在尝试获取具有私有设置器的类的所有属性。这似乎很简单，但是我遇到了一种奇怪但可能正常的行为。

这是我已经实施的解决方案

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;
}

我还创建了一些简单的类用于测试

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;
    }
}

为了测试这个我正在使用

[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);
}

第一个测试成功，而第二个测试失败。更具体地说，在第二个测试中，代码 varallProperties = type.GetProperties(BindingFlags.Public | BindingFlags.Instance);返回两个属性，但基类的属性没有 setter 方法。这与第一个测试不一致，因为在第一个测试中，该属性确实有一个定义为私有的 set 方法。

关于这种行为有什么建议/解释吗？

编辑 根据评论的建议，我更好地解释问题的范围。最终目标是构造具有以下特征的某些类型的对象：

• 可以是直接从众所周知的基类继承的类（例如Entity），该基类具有一个带有私有设置器的 Guid 类型的唯一实例属性
• 可以是从抽象基类继承的类，而抽象基类又继承自Entity
• 所有实例属性都有一个私有的 setter
• 所有类都有一个公共静态工厂方法Create，当然每个类的调用参数都不同

我想了解实体框架如何处理这种构造技术，它使用私有无参数构造函数来创建对象实例。

编辑2

我最终写出了一个解决方案，它与 Jamiec 和 Gert Arnold 提出的两个解决方案非常相似。我在这里写出来供参考。谢谢大家！

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;
}