запобігти серіалізації власності у веб-API

Я використовую веб-API MVC 4 та веб-форми 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об'єкт занадто складний, і мені потрібен різний набір властивостей у різних методах, тому це простіше позначити під час виконання кожну властивість, яку слід ігнорувати.

Чи є спосіб це зробити?

Веб-API ASP.NET використовує 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 або [IgnoreDataMember]для серіалізатора XML за замовчуванням.

Однак при тестуванні я помітив, що [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);

Я покажу вам два способи досягти того, що ви хочете:

Перший спосіб: прикрасьте своє поле атрибутом 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]

Зверху на Propertyp, наприклад:

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, викликані вбудованим серіалізатором, який іноді викликає нескінченний цикл під час розбору об'єктів.

Якщо хтось знає причину, що це якимось чином погана ідея, будь ласка, дайте мені знати.

Можливо, варто відзначити, що саме такий код для властивості EntityFramework Class викликає проблему (Якщо два класи посилаються один на одного):

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