ป้องกันคุณสมบัติไม่ให้ต่อเนื่องใน web API

ฉันใช้ MVC 4 web API และ asp.net เว็บฟอร์ม 4.0 เพื่อสร้าง API ที่เหลือ มันใช้งานได้ดี:

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

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

    return httpResponseMessage;
}

ตอนนี้ฉันต้องป้องกันไม่ให้คุณสมบัติบางอย่างที่จะต่อเนื่องกัน ฉันรู้ว่าฉันสามารถใช้ LINQ ในรายการและได้รับเฉพาะคุณสมบัติที่ฉันต้องการและโดยทั่วไปมันเป็นวิธีการที่ดี แต่ในสถานการณ์ปัจจุบันsomethingวัตถุนั้นซับซ้อนเกินไปและฉันต้องการชุดของคุณสมบัติที่แตกต่างกันในวิธีการที่แตกต่างกันดังนั้นจึงเป็น ง่ายต่อการทำเครื่องหมาย ณ รันไทม์แต่ละคุณสมบัติที่ต้องถูกละเว้น

มีวิธีทำเช่นนั้นหรือไม่?

ASP.NET Web API ใช้Json.Netเป็นฟอร์แมตเตอร์เริ่มต้นดังนั้นหากแอปพลิเคชันของคุณใช้ JSON เป็นรูปแบบข้อมูลเท่านั้นคุณสามารถใช้[JsonIgnore]เพื่อละเว้นคุณสมบัติสำหรับการทำให้เป็นอนุกรม:

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

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

แต่วิธีนี้ไม่รองรับรูปแบบ XML ดังนั้นในกรณีที่แอปพลิเคชันของคุณต้องรองรับรูปแบบ XML มากกว่า (หรือสนับสนุน XML เท่านั้น) แทนที่จะใช้Json.Netคุณควรใช้[DataContract]ซึ่งรองรับทั้ง JSON และ 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; }
}

เพื่อความเข้าใจที่มากขึ้นคุณสามารถอ่านบทความอย่างเป็นทางการ

ตามหน้าเอกสารของ Web API JSON และ XML Serialization ใน ASP.NET Web APIเพื่อป้องกันการทำให้เป็นอนุกรมในคุณสมบัติคุณสามารถใช้[JsonIgnore]Json serializer หรือ[IgnoreDataMember]สำหรับ XML serializer เริ่มต้นได้

อย่างไรก็ตามในการทดสอบฉันสังเกตเห็นว่า[IgnoreDataMember]ป้องกันการทำให้เป็นอนุกรมสำหรับทั้งคำขอ XML และ Json ดังนั้นฉันขอแนะนำให้ใช้สิ่งนั้นแทนที่จะตกแต่งคุณสมบัติที่มีคุณสมบัติหลายอย่าง

แทนที่จะปล่อยให้ทุกอย่างเป็นอนุกรมโดยค่าเริ่มต้นคุณสามารถใช้วิธี "เลือกรับ" ในสถานการณ์สมมตินี้เฉพาะคุณสมบัติที่คุณระบุเท่านั้นที่ได้รับอนุญาตให้ทำเป็นอนุกรม คุณทำสิ่งนี้ด้วยDataContractAttributeและDataMemberAttributeพบได้ในเนมสเปซSystem.Runtime.Serialization

DataContactAttributeถูกนำไปใช้ในชั้นเรียนและDataMemberAttributeนำมาใช้กับสมาชิกแต่ละคนที่คุณต้องการจะต่อเนื่อง:

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

กล้าฉันบอกว่านี่เป็นวิธีที่ดีกว่าเพราะมันบังคับให้คุณตัดสินใจอย่างชัดเจนเกี่ยวกับสิ่งที่จะทำหรือไม่ทำผ่านการทำให้เป็นอันดับ นอกจากนี้ยังอนุญาตให้คลาสโมเดลของคุณอยู่ในโครงการด้วยตัวเองโดยไม่ต้องพึ่งพา JSON.net เพียงเพราะมีบางสิ่งที่คุณเกิดขึ้นในการทำให้เป็นอนุกรมกับ JSON.net

สิ่งนี้ใช้งานได้สำหรับฉัน: สร้างตัวแก้ไขสัญญาที่กำหนดเองซึ่งมีทรัพย์สินสาธารณะชื่อ AllowList ของสตริงอาร์เรย์ชนิด ในการดำเนินการของคุณแก้ไขคุณสมบัตินั้นขึ้นอยู่กับสิ่งที่การกระทำที่ต้องการกลับ

1.สร้างเครื่องมือแก้ไขสัญญาที่กำหนดเอง:

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.ใช้ตัวแก้ไขสัญญาที่กำหนดเองในการดำเนินการ

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

วิธีการนี้อนุญาตให้ฉันอนุญาต / ไม่อนุญาตการร้องขอที่เฉพาะเจาะจงแทนที่จะแก้ไขข้อกำหนดคลาส และหากคุณไม่ต้องการการทำให้เป็นอันดับ XML อย่าลืมที่จะปิดมันในของคุณApp_Start\WebApiConfig.csหรือ API ของคุณจะกลับคุณสมบัติที่ถูกบล็อกหากลูกค้าร้องขอ xml แทน json

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

ฉันจะแสดง 2 วิธีในการบรรลุสิ่งที่คุณต้องการ:

วิธีแรก: ตกแต่งฟิลด์ของคุณด้วยแอตทริบิวต์ JsonProperty เพื่อข้ามการทำให้เป็นอนุกรมของฟิลด์นั้นหากเป็นโมฆะ

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

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

วิธีที่สอง: หากคุณกำลังเจรจากับสถานการณ์ที่ซับซ้อนบางอย่างคุณสามารถใช้การประชุม Web Api ("ShouldSerialize") เพื่อข้ามการทำให้เป็นอันดับของฟิลด์นั้นขึ้นอยู่กับตรรกะเฉพาะบางอย่าง

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 ใช้ JSON.Net และใช้การสะท้อนกับการทำให้เป็นอนุกรมดังนั้นเมื่อตรวจพบ (ตัวอย่าง) เมธอด ShouldSerializeFieldX () เมธอดฟิลด์ที่มีชื่อ FieldX จะไม่ถูกทำให้เป็นอนุกรม

ฉันมาสายเกมแล้ว แต่วัตถุที่ไม่ระบุตัวตนจะทำเคล็ดลับ:

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

ลองใช้IgnoreDataMemberคุณสมบัติ

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

เกือบเหมือนกับคำตอบของ greatbear302 แต่ฉันสร้าง ContractResolver ต่อคำขอ

1) สร้าง ContractResolver แบบกำหนดเอง

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) ใช้ตัวแก้ไขสัญญาที่กำหนดเองในการดำเนินการ

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

แก้ไข:

มันใช้งานไม่ได้ตามที่คาดไว้ (แยกตัวแก้ปัญหาต่อคำขอ) ฉันจะใช้วัตถุที่ไม่ระบุชื่อ

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

คุณอาจสามารถใช้ AutoMapper และใช้การ.Ignore()แมปแล้วส่งวัตถุที่แมป

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

ทำงานได้ดีโดยเพิ่ม: [IgnoreDataMember]

ด้านบนของคุณสมบัติเช่น:

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

สิ่งนี้ใช้ได้กับ ApiController รหัส:

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

ด้วยเหตุผลบางอย่าง[IgnoreDataMember]ไม่ได้ผลสำหรับฉันและบางครั้งฉันก็รับStackOverflowException(หรือคล้ายกัน) ดังนั้น (หรือเพิ่มเติม) แทนฉันได้เริ่มใช้รูปแบบที่มีลักษณะเช่นนี้เมื่อPOSTเข้าObjectsสู่ API ของฉัน:

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

    //Do some stuff with the object

    return Ok(myObjectConverted);
}

ดังนั้นโดยทั่วไปฉันผ่านJObjectและแปลงหลังจากที่ได้รับปัญหา aviod ที่เกิดจาก serializer ในตัวที่บางครั้งทำให้เกิดวนรอบไม่สิ้นสุดในขณะที่แยกวัตถุ

หากมีคนรู้เหตุผลว่าสิ่งนี้เป็นความคิดที่ไม่ดีโปรดแจ้งให้เราทราบ

มันอาจจะคุ้มค่าที่จะสังเกตว่ามันเป็นรหัสต่อไปนี้สำหรับ EntityFramework Class-property ที่ทำให้เกิดปัญหา (ถ้าสองคลาสอ้างอิงถึงซึ่งกันและกัน):

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