JavaScriptTypeResolver Osztály

Definíció

Névtér:: System.Web.Script.Serialization

Szerelvény:: System.Web.Extensions.dll

Fontos

Egyes információk olyan, kiadás előtti termékekre vonatkoznak, amelyek a kiadásig még jelentősen módosulhatnak. A Microsoft nem vállal kifejezett vagy törvényi garanciát az itt megjelenő információért.

Az egyéni típusú feloldó implementálására szolgáló absztrakt alaposztályt biztosítja.

public ref class JavaScriptTypeResolver abstract

public abstract class JavaScriptTypeResolver

type JavaScriptTypeResolver = class

Public MustInherit Class JavaScriptTypeResolver

Öröklődés: Object
JavaScriptTypeResolver

Származtatott: System.Web.Script.Serialization.SimpleTypeResolver

Példák

Az alábbi példa bemutatja, hogyan hozhat létre egyéni JavaScriptTypeResolver objektumot, és hogyan használhatja az objektum szerializálására vagy deszerializálására.

using System;
using System.Linq;
using System.Web.Script.Serialization;

namespace SampleApp
{
   class Program
   {
       static void Main(string[] args)
       {
           // The object array to serialize.
           Person[] people = new Person[]
           {
               new Person()
               {
                   Name = "Kristen Solstad",
                   Age = 15,
                   HomeAddress = new Address()
                   {
                       Street1 = "123 Palm Ave",
                       City = "Some City",
                       StateOrProvince = "ST",
                       Country = "United States",
                       PostalCode = "00000"
                   }
               },
               new Adult()
               {
                   Name = "Alex Johnson",
                   Age = 39,
                   Occupation = "Mechanic",
                   HomeAddress = new Address()
                   {
                       Street1 = "445 Lorry Way",
                       Street2 = "Unit 3A",
                       City = "Some City",
                       Country = "United Kingdom",
                       PostalCode = "AA0 A00"
                   }
               }
           };

           // Serialize the object array, then write it to the console.
           string serializedData = SerializePeopleArray(people);
           Console.WriteLine("Serialized:");
           Console.WriteLine(serializedData);
           Console.WriteLine();

           // Now deserialize the object array.
           Person[] deserializedArray = DeserializePeopleArray(serializedData);
           Console.WriteLine("Deserialized " + deserializedArray.Length + " people.");
           foreach (Person person in deserializedArray)
           {
               Console.WriteLine(person.Name + " (Age " + person.Age + ") [" + person.GetType() + "]");
           }
       }

       static string SerializePeopleArray(Person[] people)
       {
           // The custom type resolver to use.
           // Note: Except for primitives like int and string, *every* type that
           // we might see in the object graph must be listed here.
           CustomTypeResolver resolver = new CustomTypeResolver(
               typeof(Person),
               typeof(Adult),
               typeof(Address));

           // Instantiate the serializer.
           JavaScriptSerializer serializer = new JavaScriptSerializer(resolver);

           // Serialize the object array, then return it.
           string serialized = serializer.Serialize(people);
           return serialized;
       }

       static Person[] DeserializePeopleArray(string serializedData)
       {
           // The custom type resolver to use.
           // Note: This is the same list that was provided to the Serialize routine.
           CustomTypeResolver resolver = new CustomTypeResolver(
               typeof(Person),
               typeof(Adult),
               typeof(Address));

           // Instantiate the serializer.
           JavaScriptSerializer serializer = new JavaScriptSerializer(resolver);

           // Deserialize the object array, then return it.
           Person[] deserialized = serializer.Deserialize<Person[]>(serializedData);
           return deserialized;
       }
   }

   public class Person
   {
       public string Name { get; set; }
       public int Age { get; set; }
       public Address HomeAddress { get; set; }
   }

   public class Adult : Person
   {
       public string Occupation { get; set; }
   }

   public class Address
   {
       public string Street1 { get; set; }
       public string Street2 { get; set; }
       public string City { get; set; }
       public string StateOrProvince { get; set; }
       public string Country { get; set; }
       public string PostalCode { get; set; }
   }

   // A custom JavaScriptTypeResolver that restricts the payload
   // to a set of known good types.
   class CustomTypeResolver : JavaScriptTypeResolver
   {
       private readonly Type[] _allowedTypes;

       public CustomTypeResolver(params Type[] allowedTypes)
       {
           if (allowedTypes == null)
           {
               throw new ArgumentNullException("allowedTypes");
           }

           // Make a copy of the array the caller gave us.
           _allowedTypes = (Type[])allowedTypes.Clone();
       }

       public override Type ResolveType(string id)
       {
           // Iterate over all of the allowed types, looking for a match
           // for the 'id' parameter. Calling Type.GetType(id) is dangerous,
           // so we instead perform a match on the Type.FullName property.
           foreach (Type allowedType in _allowedTypes)
           {
               if (allowedType.FullName == id)
               {
                   return allowedType;
               }
           }

           // The caller provided a type we don't recognize. This could be
           // dangerous, so we'll fail the operation immediately.
           throw new ArgumentException("Unknown type: " + id, "id");
       }

       public override string ResolveTypeId(Type type)
       {
           // Before we serialize data, quickly double-check to make
           // sure we're allowed to deserialize the data. Otherwise it's
           // no good serializing something if we can't deserialize it.
           if (_allowedTypes.Contains(type))
           {
               return type.FullName;
           }

           throw new InvalidOperationException("Cannot serialize an object of type " + type + ". Did you forget to add it to the allow list?");
       }
   }
}

Az előző alkalmazás az alábbiakat adja ki a konzolra, olvashatóság céljából formázva.

Serialized:
[
    {
        "__type": "SampleApp.Person",
        "Name": "Kristen Solstad",
        "Age": 15,
        "HomeAddress": {
            "__type": "SampleApp.Address",
            "Street1": "123 Palm Ave",
            "Street2": null,
            "City": "Some City",
            "StateOrProvince": "ST",
            "Country": "United States",
            "PostalCode": "00000"
        }
    },
    {
        "__type": "SampleApp.Adult",
        "Occupation": "Mechanic",
        "Name": "Alex Johnson",
        "Age": 39,
        "HomeAddress": {
            "__type": "SampleApp.Address",
            "Street1": "445 Lorry Way",
            "Street2": "Unit 3A",
            "City": "Some City",
            "StateOrProvince": null,
            "Country": "United Kingdom",
            "PostalCode": "AA0 A00"
        }
    }
]

Deserialized 2 people.
Kristen Solstad (Age 15) [SampleApp.Person]
Alex Johnson (Age 39) [SampleApp.Adult]

Az előző példában a Adult típus alosztályozza a típust Person . Az egyéni JavaScriptTypeResolver adatok a létrehozott JSON-hasznos adatok részeként tartalmazzák a típusadatokat. Ez lehetővé teszi a korlátozott polimorfizmust, ha a JSON hasznos adatát újra deszerializálja egy .NET objektumgráfba. A hasznos adatok szabályozhatják, hogy egy alappéldányt Person vagy származtatott példányt Adult vissza kell-e adni a hívónak.

Ez a minta biztonságos, mert a deszerializálás szabályozására egy mechanizmust allow-list használ. A kód:

Inicializálja az CustomTypeResolver engedélyezett típusok explicit listáját.
A deszerializálási folyamatot csak jóváhagyott típuslistára korlátozza. A korlátozás megakadályozza a deszerializálási támadásokat, ahol a távoli ügyfél rosszindulatú __type adatokat határoz meg a JSON hasznos adataiban, és a kiszolgálót veszélyes típus deszerializálására csalja.

Annak ellenére, hogy az alkalmazás csak a legfelső szintű tömb részeként számít Person a deszerializálásra és Adult a példányok deszerializálására, mégis hozzá kell adni Address az engedélyezési listához, mert:

Szerializál vagy PersonAdult szerializál egy Address objektumgráf részeként.
Az objektumgráfban esetlegesen előforduló összes típust figyelembe kell venni az engedélyezési listában. Primitívek, mint és intstring nem kell megadni.

Warning

Ne hívjon Type.GetType(id) a metóduson ResolveType belül. Ez biztonsági vunerability-t eredményezhet az alkalmazásban. Ehelyett iterálja végig az engedélyezett típusok listáját, és hasonlítsa össze a tulajdonságukat Type.FullName a bejövő idtípussal, ahogyan az az előző példában is látható.

Megjegyzések

Az JavaScriptTypeResolver osztály a következő szolgáltatásokhoz nyújt szolgáltatásokat:

Felügyelt típusadatok konvertálása sztringértékké a ResolveTypeId metóduson keresztül.
Sztringérték feloldása a megfelelő felügyelt típusra a ResolveType metóduson keresztül.

Ha az JavaScriptSerializer objektum egyéni típusokat szerializál, a szerializált JavaScript Object Notation (JSON) sztringben megadhat egy olyan értéket, amely típusinformációkat tartalmaz. A deszerializálás során hivatkozhat erre a sztringértékre annak meghatározásához, JavaScriptSerializer hogy melyik felügyelt típusra konvertálja a JSON-sztringet.

Ha típusfeloldót ad meg a JavaScriptSerializer példánynak, a szerializáló a ResolveTypeId felügyelt típus és ResolveType a sztringérték közötti megfeleltetési módszereket fogja használni a szerializálási és deszerializálási folyamat során.

Az JavaScriptTypeResolver osztály az osztály alaposztálya SimpleTypeResolver , amely egy felügyelt típusú szerelvény által minősített nevet használó típusfeloldó implementációját biztosítja.

Note

Ha egy JavaScriptTypeResolverJSON-t használ, az eredményként kapott JSON hasznos adat egy speciális __type tulajdonságot tartalmaz. Ez a tulajdonság tartalmazza a céltípus teljes nevét, beleértve a névteret is. Egyéni feloldó használata előtt ellenőrizze, hogy a céltípus teljes neve nem tartalmaz-e bizalmas vagy kiemelt adatokat.

Megjegyzések az implementálókhoz

Típusfeloldó implementálásakor a metódus által ResolveTypeId(Type) visszaadott sztringnek ugyanarra a felügyelt típusra kell megfeleltetnie, amikor a sztringértéket átadja a ResolveType(String) metódusnak.

Konstruktorok

Name	Description
JavaScriptTypeResolver()	Inicializálja a JavaScriptTypeResolver osztály új példányát.

Metódusok

Name	Description
Equals(Object)	Meghatározza, hogy a megadott objektum egyenlő-e az aktuális objektummal. (Öröklődés forrása Object)
GetHashCode()	Ez az alapértelmezett kivonatoló függvény. (Öröklődés forrása Object)
GetType()	Lekéri az Type aktuális példányt. (Öröklődés forrása Object)
MemberwiseClone()	Az aktuális Objectpéldány sekély másolatát hozza létre. (Öröklődés forrása Object)
ResolveType(String)	Származtatott osztály felülírásakor a Type megadott típusnévhez társított objektumot adja vissza.
ResolveTypeId(Type)	Származtatott osztály felülírásakor a megadott Type objektum típusnevét adja vissza.
ToString()	Az aktuális objektumot jelképező sztringet ad vissza. (Öröklődés forrása Object)

A következőre érvényes:

Visszajelzés

Hasznosnak találta ezt az oldalt?