JavaScriptTypeResolver Klas

Definitie

Naamruimte:: System.Web.Script.Serialization

Assembly:: System.Web.Extensions.dll

Belangrijk

Bepaalde informatie heeft betrekking op een voorlopige productversie die aanzienlijk kan worden gewijzigd voordat deze wordt uitgebracht. Microsoft biedt geen enkele expliciete of impliciete garanties met betrekking tot de informatie die hier wordt verstrekt.

Biedt de abstracte basisklasse voor het implementeren van een aangepaste type-resolver.

public ref class JavaScriptTypeResolver abstract

public abstract class JavaScriptTypeResolver

type JavaScriptTypeResolver = class

Public MustInherit Class JavaScriptTypeResolver

Overname: Object
JavaScriptTypeResolver

Afgeleid: System.Web.Script.Serialization.SimpleTypeResolver

Voorbeelden

In het volgende voorbeeld ziet u hoe u een aangepast object JavaScriptTypeResolver maakt en hoe u dit kunt gebruiken om een object te serialiseren of deserialiseren.

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

De voorgaande app voert het volgende uit naar de console, opgemaakt voor leesbaarheid.

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]

In het voorgaande voorbeeld wordt het Adult type subklassen van het Person type. Een aangepaste JavaScriptTypeResolver toepassing wordt gebruikt om de typegegevens op te nemen als onderdeel van de gegenereerde JSON-nettolading. Dit maakt beperkt polymorfisme mogelijk bij het deserialiseren van de JSON-nettolading in een .NET objectgrafiek. De nettolading kan bepalen of een basisexemplaren Person of een afgeleid Adult exemplaar terug naar de aanroeper moeten worden geretourneerd.

Dit voorbeeld is veilig omdat er een allow-list mechanisme wordt gebruikt om deserialisatie te beheren. De code:

Initialiseert de CustomTypeResolver met een expliciete lijst met toegestane typen.
Beperkt het deserialisatieproces tot alleen goedgekeurde lijst met typen. De beperking voorkomt deserialisatieaanvallen, waarbij de externe client een kwaadwillende __type in de JSON-nettolading opgeeft en de server misleidt om een gevaarlijk type te deserialiseren.

Hoewel de app alleen verwacht Person dat exemplaren Adult worden gedeserialiseerd als onderdeel van de matrix op het hoogste niveau, is het nog steeds nodig om toe te voegen Address aan de acceptatielijst omdat:

Het serialiseren van een Person of Adult ook serialiseert een Address als onderdeel van de objectgrafiek.
Alle typen die mogelijk aanwezig zijn in de objectgrafiek, moeten worden opgenomen in de acceptatielijst. Primitieven zoals int en string hoeven niet te worden opgegeven.

Warning

Niet aanroepen Type.GetType(id) binnen de ResolveType methode. Dit kan leiden tot een beveiligingsmogelijkheid in de app. In plaats daarvan doorloopt u de lijst met toegestane typen en vergelijkt u de Type.FullName eigenschap ervan met de binnenkomende id, zoals wordt weergegeven in het voorgaande voorbeeld.

Opmerkingen

De JavaScriptTypeResolver klasse biedt de services voor:

Informatie over het beheerde type converteren naar een tekenreekswaarde via de ResolveTypeId methode.
Een tekenreekswaarde terugzetten naar het juiste beheerde type via de ResolveType methode.

Wanneer het JavaScriptSerializer object aangepaste typen serialiseert, kan het eventueel een waarde bevatten die typegegevens bevat in de geserialiseerde JSON-tekenreeks (JavaScript Object Notation). Tijdens de deserialisatie JavaScriptSerializer kunt u vervolgens verwijzen naar deze tekenreekswaarde om het juiste beheerde type te bepalen waarnaar de JSON-tekenreeks wordt geconverteerd.

Als u een type-resolver aan het JavaScriptSerializer exemplaar opgeeft, gebruikt de serializer de ResolveTypeId en ResolveType methoden om respectievelijk tussen het beheerde type en de tekenreekswaarde tijdens het serialisatie- en deserialisatieproces toe te wijzen.

De JavaScriptTypeResolver klasse is de basisklasse voor de SimpleTypeResolver klasse, die een implementatie biedt van een typeomzetting die gebruikmaakt van de assembly-gekwalificeerde naam van het beheerde type.

Note

Wanneer u een JavaScriptTypeResolver, de resulterende JSON-nettolading bevat een speciale __type eigenschap. Deze eigenschap bevat de volledige typenaam, inclusief naamruimte, van het doeltype. Controleer voordat u een aangepaste resolver gebruikt of de volledige naam van het doeltype geen gevoelige of bevoegde informatie bevat.

Notities voor uitvoerders

Wanneer u een type-resolver implementeert, moet de tekenreeks die door de ResolveTypeId(Type) methode wordt geretourneerd, worden toegewezen aan hetzelfde beheerde type wanneer de tekenreekswaarde wordt doorgegeven aan de ResolveType(String) methode.

Constructors

Name	Description
JavaScriptTypeResolver()	Initialiseert een nieuw exemplaar van de JavaScriptTypeResolver klasse.

Methoden

Name	Description
Equals(Object)	Bepaalt of het opgegeven object gelijk is aan het huidige object. (Overgenomen van Object)
GetHashCode()	Fungeert als de standaardhashfunctie. (Overgenomen van Object)
GetType()	Hiermee haalt u de Type huidige instantie op. (Overgenomen van Object)
MemberwiseClone()	Hiermee maakt u een ondiepe kopie van de huidige Object. (Overgenomen van Object)
ResolveType(String)	Wanneer het object wordt overschreven in een afgeleide klasse, wordt het Type object geretourneerd dat is gekoppeld aan de opgegeven typenaam.
ResolveTypeId(Type)	Wanneer deze wordt overschreven in een afgeleide klasse, wordt de typenaam voor het opgegeven Type object geretourneerd.
ToString()	Retourneert een tekenreeks die het huidige object vertegenwoordigt. (Overgenomen van Object)

Van toepassing op

Feedback

Is deze pagina nuttig?