JavaScriptTypeResolver Klasse

Definition

public ref class JavaScriptTypeResolver abstract

public abstract class JavaScriptTypeResolver

type JavaScriptTypeResolver = class

Public MustInherit Class JavaScriptTypeResolver

Vererbung

Object

JavaScriptTypeResolver

Abgeleitet

System.Web.Script.Serialization.SimpleTypeResolver

Beispiele

Im folgenden Beispiel wird gezeigt, wie ein benutzerdefiniertes JavaScriptTypeResolver Objekt erstellt und zum Serialisieren oder Deserialisieren eines Objekts verwendet wird.

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

Die vorherige App gibt Folgendes an die Konsole aus, formatiert für die Lesbarkeit.

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]

Im vorherigen Beispiel unterklassiert der Adult Typ den Person Typ. Ein benutzerdefinierter JavaScriptTypeResolver Wird verwendet, um die Typinformationen als Teil der generierten JSON-Nutzlast einzuschließen. Dies ermöglicht eine begrenzte Polymorphität beim Deserialisieren der JSON-Nutzlast zurück in ein .NET-Objektdiagramm. Die Nutzlast kann steuern, ob eine Basisinstanz Person oder eine abgeleitete Adult Instanz zurück an den Aufrufer zurückgegeben werden soll.

Dieses Beispiel ist sicher, da es einen allow-list Mechanismus zum Steuern der Deserialisierung verwendet. Der Code:

• Initialisiert die CustomTypeResolver mit einer expliziten Liste zulässiger Typen.
• Schränkt den Deserialisierungsprozess nur auf eine genehmigte Liste von Typen ein. Die Einschränkung verhindert Deserialisierungsangriffe, bei denen der Remoteclient einen böswilligen __type In der JSON-Nutzlast angibt und den Server dazu bringt, einen gefährlichen Typ zu deserialisieren.

Obwohl die App nur erwartet, dass Person Instanzen Adult als Teil deserialisiert werden, ist es dennoch notwendig, der Zulassungsliste hinzuzufügen Address , denn:

• Beim Serialisieren eines Person oder Adult serialisiert ein Address als Teil des Objektdiagramms.
• Alle Typen, die möglicherweise im Objektdiagramm vorhanden sind, müssen in der Zulassungsliste berücksichtigt werden. Primitiven mögen int und string müssen nicht angegeben werden.

Hinweise

Die JavaScriptTypeResolver -Klasse stellt die Dienste für folgendes bereit:

• Konvertieren von Informationen vom verwalteten Typ in einen Zeichenfolgenwert über die ResolveTypeId -Methode.

• Auflösen eines Zeichenfolgenwerts zurück in den entsprechenden verwalteten Typ über die ResolveType -Methode.

Wenn das JavaScriptSerializer Objekt benutzerdefinierte Typen serialisiert, kann es optional in die serialisierte JSON-Zeichenfolge (JavaScript Object Notation) einen Wert einschließen, der Typinformationen enthält. Kann während der Deserialisierung dann auf diesen Zeichenfolgenwert verweisen, JavaScriptSerializer um den entsprechenden verwalteten Typ zu bestimmen, in den die JSON-Zeichenfolge konvertiert wird.

Wenn Sie einen Typrelöser für die JavaScriptSerializer -Instanz bereitstellen, verwendet der Serialisierer die ResolveTypeId Methoden und ResolveType , um während des Serialisierungs- bzw. Deserialisierungsprozesses zwischen dem verwalteten Typ und dem Zeichenfolgenwert zuzuordnen.

Die JavaScriptTypeResolver -Klasse ist die Basisklasse für die SimpleTypeResolver -Klasse, die eine Implementierung eines Typlösers bereitstellt, der den assemblyqualifizierten Namen des verwalteten Typs verwendet.

Hinweise für Ausführende

Wenn Sie einen Typrelöser implementieren, muss die von der ResolveTypeId(Type) -Methode zurückgegebene Zeichenfolge demselben verwalteten Typ zugeordnet werden, wenn der Zeichenfolgenwert an die ResolveType(String) -Methode übergeben wird.

Konstruktoren

Methoden

Gilt für: