ngăn tài sản không được tuần tự hóa trong API web

Tôi đang sử dụng API web MVC 4 và các mẫu web asp.net 4.0 để xây dựng API còn lại. Nó hoạt động rất tốt:

[HttpGet]
public HttpResponseMessage Me(string hash)
{
    HttpResponseMessage httpResponseMessage;
    List<Something> somethings = ...

    httpResponseMessage = Request.CreateResponse(HttpStatusCode.OK, 
                                 new { result = true, somethings = somethings });

    return httpResponseMessage;
}

Bây giờ tôi cần phải ngăn chặn một số thuộc tính được nối tiếp. Tôi biết tôi có thể sử dụng một số LINQ trong danh sách và chỉ nhận các thuộc tính tôi cần, và nói chung đó là một cách tiếp cận tốt, nhưng trong kịch bản hiện tại, somethingđối tượng quá phức tạp và tôi cần một tập các thuộc tính khác nhau trong các phương thức khác nhau, vì vậy nó dễ dàng hơn để đánh dấu, tại thời gian chạy, mỗi thuộc tính được bỏ qua.

Có cách nào làm được việc này không?

ASP.NET Web API sử dụng Json.Netlàm định dạng mặc định, vì vậy nếu ứng dụng của bạn chỉ sử dụng JSON làm định dạng dữ liệu, bạn có thể sử dụng [JsonIgnore]để bỏ qua thuộc tính để tuần tự hóa:

public class Foo
{
    public int Id { get; set; }
    public string Name { get; set; }

    [JsonIgnore]
    public List<Something> Somethings { get; set; }
}

Nhưng, cách này không hỗ trợ định dạng XML. Vì vậy, trong trường hợp ứng dụng của bạn phải hỗ trợ định dạng XML nhiều hơn (hoặc chỉ hỗ trợ XML), thay vì sử dụng Json.Net, bạn nên sử dụng [DataContract]hỗ trợ cả JSON và XML:

[DataContract]
public class Foo
{
    [DataMember]
    public int Id { get; set; }
    [DataMember]
    public string Name { get; set; }

    //Ignore by default
    public List<Something> Somethings { get; set; }
}

Để hiểu rõ hơn, bạn có thể đọc bài viết chính thức .

Theo trang tài liệu API Web JSON và XML serialization trong ASP.NET Web API để ngăn chặn rõ ràng việc tuần tự hóa trên một thuộc tính mà bạn có thể sử dụng [JsonIgnore]cho trình tuần tự Json hoặc [IgnoreDataMember]cho trình tuần tự XML mặc định.

Tuy nhiên, trong thử nghiệm tôi đã nhận thấy rằng [IgnoreDataMember]ngăn chặn việc tuần tự hóa cho cả các yêu cầu XML và Json, vì vậy tôi khuyên bạn nên sử dụng điều đó thay vì trang trí một thuộc tính có nhiều thuộc tính.

Thay vì để mọi thứ được tuần tự hóa theo mặc định, bạn có thể thực hiện phương pháp "chọn tham gia". Trong trường hợp này, chỉ các thuộc tính bạn chỉ định mới được phép nối tiếp. Bạn làm điều này với DataContractAttributevà DataMemberAttribute, được tìm thấy trong không gian tên System.R.78.Serialization .

Cái DataContactAttributenày được áp dụng cho lớp và cái DataMemberAttributeđược áp dụng cho mỗi thành viên bạn muốn được tuần tự hóa:

[DataContract]
public class MyClass {

  [DataMember]
  public int Id { get; set;} // Serialized

  [DataMember]
  public string Name { get; set; } // Serialized

  public string DontExposeMe { get; set; } // Will not be serialized
}

Dare tôi nói rằng đây là một cách tiếp cận tốt hơn bởi vì nó buộc bạn phải đưa ra quyết định rõ ràng về những gì sẽ hoặc sẽ không làm cho nó thông qua tuần tự hóa. Nó cũng cho phép các lớp mô hình của bạn tự sống trong một dự án mà không cần phụ thuộc vào JSON.net chỉ vì một nơi nào khác bạn tình cờ sắp xếp chúng với JSON.net.

Điều này làm việc cho tôi: Tạo một trình giải quyết hợp đồng tùy chỉnh có thuộc tính công khai gọi là AllowList của kiểu mảng chuỗi. Trong hành động của bạn, sửa đổi thuộc tính đó tùy thuộc vào những gì hành động cần trả lại.

1. tạo một trình giải quyết hợp đồng tùy chỉnh:

public class PublicDomainJsonContractResolverOptIn : DefaultContractResolver
{
    public string[] AllowList { get; set; }

    protected override IList<JsonProperty> CreateProperties(Type type, MemberSerialization memberSerialization)
    {
        IList<JsonProperty> properties = base.CreateProperties(type, memberSerialization);

        properties = properties.Where(p => AllowList.Contains(p.PropertyName)).ToList();
        return properties;
    }
}

2. sử dụng trình giải quyết hợp đồng tùy chỉnh trong hành động

[HttpGet]
public BinaryImage Single(int key)
{
    //limit properties that are sent on wire for this request specifically
    var contractResolver = Configuration.Formatters.JsonFormatter.SerializerSettings.ContractResolver as PublicDomainJsonContractResolverOptIn;
    if (contractResolver != null)
        contractResolver.AllowList = new string[] { "Id", "Bytes", "MimeType", "Width", "Height" };

    BinaryImage image = new BinaryImage { Id = 1 };
    //etc. etc.
    return image;
}

Cách tiếp cận này cho phép tôi cho phép / không cho phép yêu cầu cụ thể thay vì sửa đổi định nghĩa lớp. Và nếu bạn không cần tuần tự hóa XML, đừng quên tắt nó trong App_Start\WebApiConfig.csAPI của bạn hoặc API của bạn sẽ trả về các thuộc tính bị chặn nếu máy khách yêu cầu xml thay vì json.

//remove xml serialization
var appXmlType = config.Formatters.XmlFormatter.SupportedMediaTypes.FirstOrDefault(t => t.MediaType == "application/xml");
config.Formatters.XmlFormatter.SupportedMediaTypes.Remove(appXmlType);

Tôi sẽ chỉ cho bạn 2 cách để thực hiện những gì bạn muốn:

Cách thứ nhất: Trang trí trường của bạn với thuộc tính JsonProperty để bỏ qua việc tuần tự hóa trường đó nếu nó là null.

public class Foo
{
    public int Id { get; set; }
    public string Name { get; set; }

    [JsonProperty(NullValueHandling = NullValueHandling.Ignore)]
    public List<Something> Somethings { get; set; }
}

Cách thứ hai: Nếu bạn đang đàm phán với một số tình huống phức tạp thì bạn có thể sử dụng quy ước Api Web ("ShouldSerialize") để bỏ qua việc tuần tự hóa trường đó tùy thuộc vào một số logic cụ thể.

public class Foo
{
    public int Id { get; set; }
    public string Name { get; set; }

    public List<Something> Somethings { get; set; }

    public bool ShouldSerializeSomethings() {
         var resultOfSomeLogic = false;
         return resultOfSomeLogic; 
    }
}

WebApi sử dụng JSON.Net và nó sử dụng sự phản chiếu để tuần tự hóa nên khi nó đã phát hiện (ví dụ), phương thức ShouldSerializeFieldX (), trường có tên FieldX sẽ không được tuần tự hóa.

Tôi đến trễ trò chơi, nhưng một đối tượng ẩn danh sẽ thực hiện mánh khóe:

[HttpGet]
public HttpResponseMessage Me(string hash)
{
    HttpResponseMessage httpResponseMessage;
    List<Something> somethings = ...

    var returnObjects = somethings.Select(x => new {
        Id = x.Id,
        OtherField = x.OtherField
    });

    httpResponseMessage = Request.CreateResponse(HttpStatusCode.OK, 
                                 new { result = true, somethings = returnObjects });

    return httpResponseMessage;
}

Thử sử dụng IgnoreDataMembertài sản

public class Foo
    {
        [IgnoreDataMember]
        public int Id { get; set; }
        public string Name { get; set; }
    }

Gần giống như câu trả lời của greatbear302, nhưng tôi tạo ContractResolver theo yêu cầu.

1) Tạo ContractResolver tùy chỉnh

public class MyJsonContractResolver : DefaultContractResolver
{
    public List<Tuple<string, string>> ExcludeProperties { get; set; }

    protected override JsonProperty CreateProperty(MemberInfo member, MemberSerialization memberSerialization)
    {
        JsonProperty property = base.CreateProperty(member, memberSerialization);

        if (ExcludeProperties?.FirstOrDefault(
            s => s.Item2 == member.Name && s.Item1 == member.DeclaringType.Name) != null)
        {
            property.ShouldSerialize = instance => { return false; };
        }

        return property;
    }
}

2) Sử dụng trình giải quyết hợp đồng tùy chỉnh trong hành động

public async Task<IActionResult> Sites()
{
    var items = await db.Sites.GetManyAsync();

    return Json(items.ToList(), new JsonSerializerSettings
    {
        ContractResolver = new MyJsonContractResolver()
        {
            ExcludeProperties = new List<Tuple<string, string>>
            {
                Tuple.Create("Site", "Name"),
                Tuple.Create("<TypeName>", "<MemberName>"),
            }
        }
    });
}

Biên tập:

Nó không hoạt động như mong đợi (cô lập trình phân giải theo yêu cầu). Tôi sẽ sử dụng các đối tượng ẩn danh.

public async Task<IActionResult> Sites()
{
    var items = await db.Sites.GetManyAsync();

    return Json(items.Select(s => new
    {
        s.ID,
        s.DisplayName,
        s.Url,
        UrlAlias = s.Url,
        NestedItems = s.NestedItems.Select(ni => new
        {
            ni.Name,
            ni.OrdeIndex,
            ni.Enabled,
        }),
    }));
}

Bạn có thể sử dụng AutoMapper và sử dụng .Ignore()ánh xạ và sau đó gửi đối tượng được ánh xạ

CreateMap<Foo, Foo>().ForMember(x => x.Bar, opt => opt.Ignore());

Hoạt động tốt bằng cách chỉ cần thêm: [IgnoreDataMember]

Trên đầu trang, như:

public class UserSettingsModel
{
    public string UserName { get; set; }
    [IgnoreDataMember]
    public DateTime Created { get; set; }
}

Điều này hoạt động với ApiControll. Mật mã:

[Route("api/Context/UserSettings")]
    [HttpGet, HttpPost]
    public UserSettingsModel UserSettings()
    {
        return _contextService.GetUserSettings();
    }

Vì một số lý do [IgnoreDataMember]không phải lúc nào tôi cũng làm việc và đôi khi tôi nhận được StackOverflowException(hoặc tương tự). Vì vậy, thay vào đó (hoặc ngoài ra) tôi đã bắt đầu sử dụng một mẫu trông giống như thế này khi POSTnhập Objectsvào API của mình:

[Route("api/myroute")]
[AcceptVerbs("POST")]
public IHttpActionResult PostMyObject(JObject myObject)
{
    MyObject myObjectConverted = myObject.ToObject<MyObject>();

    //Do some stuff with the object

    return Ok(myObjectConverted);
}

Vì vậy, về cơ bản tôi vượt qua trong một JObject và chuyển đổi nó sau khi nó đã nhận được các vấn đề aviod gây ra bởi serializer tích hợp đôi khi gây ra một vòng lặp vô hạn trong khi phân tích cú pháp các đối tượng.

Nếu ai đó biết một lý do mà đây là một ý tưởng tồi, xin vui lòng cho tôi biết.

Có thể đáng lưu ý rằng đó là mã sau đây cho thuộc tính Lớp EntityFramework gây ra sự cố (Nếu hai lớp tham chiếu lẫn nhau):

[Serializable]
public partial class MyObject
{
   [IgnoreDataMember]
   public MyOtherObject MyOtherObject => MyOtherObject.GetById(MyOtherObjectId);
}

[Serializable]
public partial class MyOtherObject
{
   [IgnoreDataMember]
   public List<MyObject> MyObjects => MyObject.GetByMyOtherObjectId(Id);
}