Origem de evento BinaryFormatter

A partir do .NET 5, BinaryFormatter inclui um incorporado EventSource que lhe dá visibilidade sobre quando está a ocorrer uma serialização ou serialização de objetos. As aplicações podem utilizar EventListenertipos derivados para escutar estas notificações e regiscá-las.

Esta funcionalidade não substitui um SerializationBinder ou um ISerializationSurrogate e não pode ser utilizada para modificar os dados que estão a ser serializados ou serializados. Em vez disso, este sistema de eventos destina-se a fornecer informações sobre os tipos que estão a ser serializados ou serializados. Também pode ser utilizado para detetar chamadas não intencionais na BinaryFormatter infraestrutura, como chamadas originárias de código de biblioteca de terceiros.

Descrição dos eventos

A origem BinaryFormatter do evento tem o nome System.Runtime.Serialization.Formatters.Binary.BinaryFormatterEventSourcebem conhecido . Os serviços de escuta podem subscrever seis eventos.

SerializationStart event (id = 10)

Gerado quando BinaryFormatter.Serialize foi chamado e iniciou o processo de serialização. Este evento está emparelhado com o SerializationEnd evento. O SerializationStart evento pode ser chamado recursivamente se um objeto chamar BinaryFormatter.Serialize dentro da sua própria rotina de serialização.

Este evento não contém um payload.

SerializationEnd event (id = 11)

Gerado quando BinaryFormatter.Serialize tiver concluído o seu trabalho. Cada ocorrência de SerializationEnd indica a conclusão do último evento não pago SerializationStart .

Este evento não contém um payload.

Evento SerializingObject (id = 12)

Gerado quando BinaryFormatter.Serialize está em processo de serialização de um tipo não primitivo. A BinaryFormatter infraestrutura apresenta casos especiais de determinados tipos (como string e int) e não gera este evento quando estes tipos são encontrados. Este evento é gerado para tipos definidos pelo utilizador e outros tipos que BinaryFormatter não compreendem nativamente.

Este evento pode ser gerado zero ou mais vezes entre SerializationStart eventos e SerializationEnd .

Este evento contém um payload com um argumento:

Evento DeserializationStart (id = 20)

Gerado quando BinaryFormatter.Deserialize foi chamado e iniciou o processo de desserialização. Este evento está emparelhado com o DeserializationEnd evento. O DeserializationStart evento pode ser chamado recursivamente se um objeto chamar BinaryFormatter.Deserialize dentro da sua própria rotina de desserialização.

Este evento não contém um payload.

Evento DeserializationEnd (id = 21)

Gerado quando BinaryFormatter.Deserialize tiver concluído o seu trabalho. Cada ocorrência de DeserializationEnd indica a conclusão do último evento não pago DeserializationStart .

Este evento não contém um payload.

Evento DeserializingObject (id = 22)

Gerado quando BinaryFormatter.Deserialize está em processo de anular a serialização de um tipo não primitivo. A BinaryFormatter infraestrutura apresenta casos especiais de determinados tipos (como string e int) e não gera este evento quando estes tipos são encontrados. Este evento é gerado para tipos definidos pelo utilizador e outros tipos que BinaryFormatter não compreendem nativamente.

Este evento pode ser gerado zero ou mais vezes entre DeserializationStart eventos e DeserializationEnd .

Este evento contém um payload com um argumento.

[Avançadas] Subscrever um subconjunto de notificações

Os serviços de escuta que pretendam subscrever apenas um subconjunto de notificações podem escolher as palavras-chave a ativar.

  • Serialization = (EventKeywords)1: eleva os SerializationStarteventos , SerializationEnde SerializingObject .
  • Deserialization = (EventKeywords)2: eleva os DeserializationStarteventos , DeserializationEnde DeserializingObject .

Se não forem fornecidos filtros de palavra-chave durante EventListener o registo, todos os eventos serão gerados.

Para obter mais informações, consulte System.Diagnostics.Tracing.EventKeywords.

Código de exemplo

O seguinte código:

  • cria um EventListenertipo derivado que escreve em System.Console,
  • subscreve as notificações produzidas pelo serviço de escuta BinaryFormatter,
  • serializa e desserializa um gráfico de objeto simples com BinaryFormatter, e
  • analisa os eventos que foram gerados.
using System;
using System.Diagnostics.Tracing;
using System.IO;
using System.Runtime.Serialization.Formatters.Binary;

namespace BinaryFormatterEventSample
{
    class Program
    {
        static EventListener? _globalListener = null;

        static void Main(string[] args)
        {
            // First, set up the event listener.
            // Note: We assign it to a static field so that it doesn't get GCed.
            // We also provide a callback that subscribes this listener to all
            // events produced by the well-known BinaryFormatter source.

            _globalListener = new ConsoleEventListener();
            _globalListener.EventSourceCreated += (sender, args) =>
            {
                if (args.EventSource?.Name ==
                    "System.Runtime.Serialization.Formatters.Binary.BinaryFormatterEventSource")
                {
                    ((EventListener?)sender)?
                        .EnableEvents(args.EventSource, EventLevel.LogAlways);
                }
            };

            // Next, create the Person object and serialize it.

            Person originalPerson = new Person()
            {
                FirstName = "Logan",
                LastName = "Edwards",
                FavoriteBook = new Book()
                {
                    Title = "A Tale of Two Cities",
                    Author = "Charles Dickens",
                    Price = 10.25m
                }
            };

            byte[] serializedPerson = SerializePerson(originalPerson);

            // Finally, deserialize the Person object.

            Person rehydratedPerson = DeserializePerson(serializedPerson);

            Console.WriteLine
                ($"Rehydrated person {rehydratedPerson.FirstName} {rehydratedPerson.LastName}");
            Console.Write
                ($"Favorite book: {rehydratedPerson.FavoriteBook?.Title} ");
            Console.Write
                ($"by {rehydratedPerson.FavoriteBook?.Author}, ");
            Console.WriteLine
                ($"list price {rehydratedPerson.FavoriteBook?.Price}");
        }

        private static byte[] SerializePerson(Person p)
        {
            MemoryStream memStream = new MemoryStream();
            BinaryFormatter formatter = new BinaryFormatter();
#pragma warning disable SYSLIB0011 // BinaryFormatter.Serialize is obsolete
            formatter.Serialize(memStream, p);
#pragma warning restore SYSLIB0011

            return memStream.ToArray();
        }

        private static Person DeserializePerson(byte[] serializedData)
        {
            MemoryStream memStream = new MemoryStream(serializedData);
            BinaryFormatter formatter = new BinaryFormatter();

#pragma warning disable SYSLIB0011 // Danger: BinaryFormatter.Deserialize is insecure for untrusted input
            return (Person)formatter.Deserialize(memStream);
#pragma warning restore SYSLIB0011
        }
    }

    [Serializable]
    public class Person
    {
        public string? FirstName;
        public string? LastName;
        public Book? FavoriteBook;
    }

    [Serializable]
    public class Book
    {
        public string? Title;
        public string? Author;
        public decimal? Price;
    }

    // A sample EventListener that writes data to System.Console.
    public class ConsoleEventListener : EventListener
    {
        protected override void OnEventWritten(EventWrittenEventArgs eventData)
        {
            base.OnEventWritten(eventData);

            Console.WriteLine($"Event {eventData.EventName} (id={eventData.EventId}) received.");
            if (eventData.PayloadNames != null)
            {
                for (int i = 0; i < eventData.PayloadNames.Count; i++)
                {
                    Console.WriteLine($"{eventData.PayloadNames[i]} = {eventData.Payload?[i]}");
                }
            }
        }
    }
}

O código anterior produz um resultado semelhante ao seguinte exemplo:

Event SerializationStart (id=10) received.
Event SerializingObject (id=12) received.
typeName = BinaryFormatterEventSample.Person, BinaryFormatterEventSample, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null
Event SerializingObject (id=12) received.
typeName = BinaryFormatterEventSample.Book, BinaryFormatterEventSample, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null
Event SerializationStop (id=11) received.
Event DeserializationStart (id=20) received.
Event DeserializingObject (id=22) received.
typeName = BinaryFormatterEventSample.Person, BinaryFormatterEventSample, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null
Event DeserializingObject (id=22) received.
typeName = BinaryFormatterEventSample.Book, BinaryFormatterEventSample, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null
Event DeserializationStop (id=21) received.
Rehydrated person Logan Edwards
Favorite book: A Tale of Two Cities by Charles Dickens, list price 10.25

Neste exemplo, os registos baseados na EventListener consola que a serialização inicia, as instâncias de Person e Book são serializadas e, em seguida, a serialização é concluída. Da mesma forma, depois de iniciada a desserialização, as instâncias de Person e Book são desserializadas e, em seguida, a desserialização é concluída.

Em seguida, a aplicação imprime os valores contidos na serialização desserializada Person para demonstrar que o objeto serializou e deserializou corretamente.

Ver também

Para obter mais informações sobre como utilizar EventListener para receber EventSourcenotificações baseadas em , consulte a EventListener classe .

  • Last updated on