JavaScriptTypeResolver Sınıf

Tanım

public ref class JavaScriptTypeResolver abstract

public abstract class JavaScriptTypeResolver

type JavaScriptTypeResolver = class

Public MustInherit Class JavaScriptTypeResolver

Devralma

Object

JavaScriptTypeResolver

Türetilmiş

System.Web.Script.Serialization.SimpleTypeResolver

Örnekler

Aşağıdaki örnekte özel JavaScriptTypeResolver oluşturma ve bir nesneyi seri hale getirmek veya seri durumdan çıkarmak için nasıl kullanılacağı gösterilmektedir.

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

Yukarıdaki uygulama, okunabilirlik için biçimlendirilmiş olarak konsola aşağıdakini gönderir.

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]

Yukarıdaki örnekte, Adult tür türü alt sınıflarına ekler Person . JavaScriptTypeResolver Özel, tür bilgilerini oluşturulan JSON yükünün bir parçası olarak eklemek için kullanılır. Bu, JSON yükünü bir .NET nesne grafiğine geri seri durumdan çıkarırken sınırlı polimorfizme olanak tanır. Yük, bir temel Person örneğin mi yoksa türetilmiş Adult bir örneğin mi çağırana geri döndürülmeyeceğini denetleyebilir.

Seri durumdan çıkarmayı denetlemek için bir allow-list mekanizma kullandığından bu örnek güvenlidir. Kod:

• CustomTypeResolver öğesini izin verilen türlerin açık bir listesiyle başlatır.
• Seri durumdan çıkarma işlemini yalnızca onaylanan tür listesiyle kısıtlar. Kısıtlama, uzak istemcinin JSON yükünde kötü amaçlı bir şey __type belirttiği ve sunucuyu tehlikeli bir türü seri durumdan çıkarma konusunda kandırdığı seri durumdan çıkarma saldırılarını önler.

Uygulama yalnızca ve Adult örneklerinin en üst düzey dizinin bir parçası olarak seri durumdan çıkarılmalarını beklese Person de, yine de izin listesine eklemek Address gerekir çünkü:

• Veya PersonAdult seri hale getirerek nesne grafının bir parçası olarak da seri Address hale gelir.
• Nesne grafında bulunabilecek tüm türlerin izin listesinde hesaba alınması gerekir. ve string gibi int ilkellerin belirtilmesi gerekmez.

Açıklamalar

JavaScriptTypeResolver sınıfı aşağıdakiler için hizmetleri sağlar:

• Yöntemi aracılığıyla ResolveTypeId yönetilen tür bilgilerini dize değerine dönüştürme.

• Bir dize değerini yöntemi aracılığıyla ResolveType uygun yönetilen türe geri çözümleme.

JavaScriptSerializer Nesne özel türleri serileştirdiğinde, isteğe bağlı olarak serileştirilmiş JavaScript Nesne Gösterimi (JSON) dizesine tür bilgilerini içeren bir değer ekleyebilir. Seri durumdan çıkarma sırasında, JavaScriptSerializer JSON dizesinin dönüştürüleceği uygun yönetilen türü belirlemek için bu dize değerine başvurabilir.

Örneğe bir tür çözümleyici JavaScriptSerializer sağlarsanız, seri hale getirici sırasıyla seri hale getirme ve ResolveType seri durumdan çıkarma işlemi sırasında yönetilen tür ve dize değeri arasında eşlemek için ve yöntemlerini kullanırResolveTypeId.

JavaScriptTypeResolver sınıfı, yönetilen tür derleme nitelikli adını kullanan bir tür çözümleyicinin uygulamasını sağlayan sınıfın temel sınıfıdırSimpleTypeResolver.

Uygulayanlara Notlar

Bir tür çözümleyici uyguladığınızda, dize değeri yöntemine ResolveTypeId(Type) geçirildiğinde yöntemi tarafından döndürülen dizenin aynı yönetilen türe ResolveType(String) geri eşlenmesi gerekir.

Oluşturucular

Yöntemler

Şunlara uygulanır