JavaScriptTypeResolver クラス

定義

public ref class JavaScriptTypeResolver abstract

public abstract class JavaScriptTypeResolver

type JavaScriptTypeResolver = class

Public MustInherit Class JavaScriptTypeResolver

継承

Object

JavaScriptTypeResolver

派生

System.Web.Script.Serialization.SimpleTypeResolver

例

次の例は、カスタム JavaScriptTypeResolver を作成する方法と、それを使用してオブジェクトをシリアル化または逆シリアル化する方法を示しています。

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

上記のアプリでは、読みやすく書式設定された次の情報がコンソールに出力されます。

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]

前のサンプルでは、 型は Adult 型を Person サブクラス化します。 カスタム JavaScriptTypeResolver は、生成された JSON ペイロードの一部として型情報を含めるために使用されます。 これにより、JSON ペイロードを .NET オブジェクト グラフに逆シリアル化するときのポリモーフィズムが制限されます。 ペイロードは、ベース Person インスタンスまたは派生 Adult インスタンスを呼び出し元に返すかどうかを制御できます。

このサンプルは、逆シリアル化を制御するメカニズムを allow-list 使用するため、安全です。 コード:

• 許可される型の明示的なリストを使用して を CustomTypeResolver 初期化します。
• 逆シリアル化プロセスを、承認された型の一覧のみに制限します。 この制限により 、逆シリアル化攻撃が防止されます。リモート クライアントは JSON ペイロードで悪意のある __type を指定し、サーバーが危険な型の逆シリアル化を試みます。

アプリでは と インスタンスのみが最上位の配列の一部として逆シリアル化されることを想定PersonAdultしていますが、次の理由から許可リストに を追加Addressする必要があります。

• または Adult をPersonシリアル化すると、 もオブジェクト グラフの一部としてシリアル化Addressされます。
• オブジェクト グラフに存在する可能性があるすべての型は、許可リストで考慮する必要があります。 や string などのintプリミティブを指定する必要はありません。

注釈

クラスは JavaScriptTypeResolver 、次のサービスを提供します。

• メソッドを使用してマネージド型情報を文字列値に ResolveTypeId 変換する。

• メソッドを使用して、文字列値を適切なマネージド型に解決します ResolveType 。

オブジェクトは、カスタム型を JavaScriptSerializer シリアル化するときに、必要に応じて、シリアル化された JavaScript Object Notation (JSON) 文字列に型情報を含む値を含めることができます。 逆シリアル化中に、 JavaScriptSerializer この文字列値を参照して、JSON 文字列の変換先となる適切なマネージド型を決定できます。

インスタンスに型リゾルバーをJavaScriptSerializer指定した場合、シリアライザーは、 メソッドと ResolveType メソッドを使用ResolveTypeIdして、それぞれシリアル化と逆シリアル化の処理中にマネージド型と文字列値の間でマップします。

クラスは JavaScriptTypeResolver 、 クラスの基底クラス SimpleTypeResolver であり、マネージド型アセンブリ修飾名を使用する型リゾルバーの実装を提供します。

注意 (実装者)

型リゾルバーを実装する場合、メソッドによって ResolveTypeId(Type) 返される文字列は、文字列値が メソッドに渡されるときに、同じマネージド型にマップし直す ResolveType(String) 必要があります。

コンストラクター

メソッド

適用対象