JavaScriptTypeResolver 클래스

정의

네임스페이스:

System.Web.Script.Serialization

어셈블리:

System.Web.Extensions.dll

사용자 지정 형식 확인자를 구현하기 위한 추상 기본 클래스를 제공합니다.

public ref class JavaScriptTypeResolver abstract

public abstract class JavaScriptTypeResolver

type JavaScriptTypeResolver = class

Public MustInherit Class JavaScriptTypeResolver

상속

Object

JavaScriptTypeResolver

파생

System.Web.Script.Serialization.SimpleTypeResolver

예제

다음 예제에서는 사용자 지정을 만드는 방법과이를 사용 하 여 JavaScriptTypeResolver 개체를 serialize 또는 deserialize 하는 방법을 보여 줍니다.

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 개체 그래프로 deserialize 할 때 제한 된 다형성을 사용할 수 있습니다. 페이로드는 기본 Person 인스턴스나 파생 Adult 인스턴스를 호출자에 게 다시 반환할지 여부를 제어할 수 있습니다.

이 샘플은 allow-list deserialization을 제어 하는 메커니즘을 사용 하기 때문에 안전 합니다. 코드:

• 명시적으로 CustomTypeResolver 허용 되는 형식 목록을 사용 하 여를 초기화 합니다.
• Deserialization 프로세스를 승인 된 형식 목록 으로만 제한 합니다. 이 제한은 원격 클라이언트가 JSON 페이로드의 악성을 지정 하 고 서버에서 위험한 형식을 deserialize 하는 것을 트릭 하는 deserialization 공격을 방지 합니다 __type .

앱은 Person Adult 최상위 배열의 일부로만 및 인스턴스를 deserialize 해야 하는 경우 Address 에도 다음과 같은 이유로 허용 목록에 추가 해야 합니다.

• 를 serialize Person 하거나 Adult Address 개체 그래프의 일부로를 serialize 합니다.
• 개체 그래프에 있을 수 있는 모든 형식은 허용 목록에서에 대해 고려해 야 합니다. 및와 같은 기본 형식을 int string 지정할 필요가 없습니다.

경고

Type.GetType(id)메서드 내에서를 호출 하지 마세요 ResolveType . 이로 인해 앱에 보안 vunerability가 발생할 수 있습니다. 대신, 앞의 샘플과 같이 허용 되는 형식 목록을 반복 하 고 해당 속성을 들어오는와 비교 Type.FullName id 합니다.

설명

JavaScriptTypeResolver 클래스에 대 한 서비스를 제공 합니다.

• 관리 되는 변환 형식 정보를 통해 문자열 값으로는 ResolveTypeId 메서드.

• 형식을 통해 관리 되는 문자열 값을 적절 한 해결을 ResolveType 메서드.

경우는 JavaScriptSerializer 개체 사용자 지정 형식을 serialize를 포함할 수 있습니다 필요에 따라 직렬화 된 개체 JSON (JavaScript Notation) 문자열에 형식 정보를 포함 하는 값입니다. Deserialization 도중 JavaScriptSerializer JSON 문자열로 변환 될 수 있습니다 다음 적절 한 결정을 문자열 값이 관리 되는 참조 형식입니다.

형식 확인자를 제공 하는 경우는 JavaScriptSerializer 직렬 변환기를 사용할 경우 합니다 ResolveTypeId 및 ResolveType 각각 serialization 및 deserialization 프로세스 동안 관리 되는 형식 및 문자열 값 간의 매핑 방법입니다.

JavaScriptTypeResolver 클래스에 대 한 기본 클래스인는 SimpleTypeResolver 관리 되는 형식의 정규화 된 어셈블리 이름을 사용 하는 형식 확인자 구현을 제공 하는 클래스입니다.

참고

을 사용 하는 경우 JavaScriptTypeResolver 결과 JSON 페이로드에는 특별 한 __type 속성이 포함 됩니다. 이 속성에는 대상 형식의 전체 형식 이름 (네임 스페이스 포함)이 포함 됩니다. 사용자 지정 해결 프로그램을 사용 하기 전에 대상 형식의 전체 이름에 중요 한 정보나 권한 있는 정보가 포함 되어 있지 않은지 확인 합니다.

구현자 참고

반환 되는 문자열 형식 확인자를 구현 하는 경우는 ResolveTypeId(Type) 문자열 값을 전달 될 때 메서드가 동일한 관리 되는 형식으로 다시 매핑해야 합니다 ResolveType(String) 메서드.

생성자

JavaScriptTypeResolver()

JavaScriptTypeResolver 클래스의 새 인스턴스를 초기화합니다.

메서드

Equals(Object)	지정된 개체가 현재 개체와 같은지 확인합니다. (다음에서 상속됨 Object)
GetHashCode()	기본 해시 함수로 작동합니다. (다음에서 상속됨 Object)
GetType()	현재 인스턴스의 Type을 가져옵니다. (다음에서 상속됨 Object)
MemberwiseClone()	현재 Object의 단순 복사본을 만듭니다. (다음에서 상속됨 Object)
ResolveType(String)	파생 클래스에서 재정의되는 경우 지정된 형식 이름과 관련된 Type 개체를 반환합니다.
ResolveTypeId(Type)	파생 클래스에서 재정의된 경우 지정된 Type 개체의 형식 이름을 반환합니다.
ToString()	현재 개체를 나타내는 문자열을 반환합니다. (다음에서 상속됨 Object)