Este artículo se tradujo automáticamente. Para ver el artículo en inglés, active la casilla Inglés. Además, puede mostrar el texto en inglés en una ventana emergente si mueve el puntero del mouse sobre el texto.
Traducción
Inglés

Clase BufferedWebEventProvider

 

Publicado: octubre de 2016

Proporciona la funcionalidad básica para crear proveedores de eventos que requieren almacenamiento en búfer.

Espacio de nombres:   System.Web.Management
Ensamblado:  System.Web (en System.Web.dll)


public abstract class BufferedWebEventProvider : WebEventProvider

NombreDescripción
System_CAPS_protmethodBufferedWebEventProvider()

Inicializa una nueva instancia de la clase BufferedWebEventProvider.

NombreDescripción
System_CAPS_pubpropertyBufferMode

Obtiene un valor que indica el modo de almacenamiento en búfer utilizado por el proveedor.

System_CAPS_pubpropertyDescription

Obtiene una descripción breve y fácil de comprender apropiada para mostrarla en las herramientas administrativas u otras interfaces de usuario (IU).(Heredado de ProviderBase).

System_CAPS_pubpropertyName

Obtiene el nombre descriptivo que se utiliza para hacer referencia al proveedor durante la configuración.(Heredado de ProviderBase).

System_CAPS_pubpropertyUseBuffering

Obtiene un valor que indica si el proveedor está en modo almacenado en búfer.

NombreDescripción
System_CAPS_pubmethodEquals(Object)

Determina si el objeto especificado es igual al objeto actual.(Heredado de Object).

System_CAPS_protmethodFinalize()

Permite que un objeto intente liberar recursos y realizar otras operaciones de limpieza antes de ser reclamado por el recolector de basura. (Heredado de Object).

System_CAPS_pubmethodFlush()

Pasa los eventos del búfer del proveedor en el registro de eventos.(Invalida WebEventProvider.Flush()).

System_CAPS_pubmethodGetHashCode()

Sirve como la función hash predeterminada.(Heredado de Object).

System_CAPS_pubmethodGetType()

Obtiene el Type de la instancia actual.(Heredado de Object).

System_CAPS_pubmethodInitialize(String, NameValueCollection)

Establece los valores iniciales de este objeto.(Invalida ProviderBase.Initialize(String, NameValueCollection)).

System_CAPS_protmethodMemberwiseClone()

Crea una copia superficial del Object actual.(Heredado de Object).

System_CAPS_pubmethodProcessEvent(WebBaseEvent)

Procesa el evento que se pasa al proveedor.(Invalida WebEventProvider.ProcessEvent(WebBaseEvent)).

System_CAPS_pubmethodProcessEventFlush(WebEventBufferFlushInfo)

Procesa los eventos almacenados en búfer.

System_CAPS_pubmethodShutdown()

Realiza tareas asociadas al cierre del proveedor.(Invalida WebEventProvider.Shutdown()).

System_CAPS_pubmethodToString()

Devuelve una cadena que representa al objeto actual. (Heredado de Object).

Supervisión de estado ASP.NET permite el personal de producción y operaciones administrar aplicaciones Web implementadas. El System.Web.Management espacio de nombres contiene los tipos de evento de estado responsables de empaquetar datos de estado de la aplicación y los tipos de proveedor responsables de procesar estos datos. También contiene los tipos compatibles que ayudan a administrar los eventos de estado.

Si desea personalizar el procesamiento de eventos de estado, puede derivar de la BufferedWebEventProvider clase para crear su propio proveedor personalizado almacenado en búfer.

System_CAPS_noteNota

En la mayoría de los casos, podrá utilizar los tipos de supervisión de estado ASP.NET tal como se implementa y se controlará el sistema de supervisión de estado especificando valores en la healthMonitoring sección de configuración. También se puede derivar de los tipos de supervisión de estado para crear sus propios proveedores y eventos personalizados. Para obtener un ejemplo de cómo crear un proveedor personalizado, consulte How to: Implement the Health Monitoring Custom Provider Example.

En el ejemplo de código siguiente se muestra cómo derivar de la BufferedWebEventProvider clase para crear un proveedor personalizado que escribe los eventos configurados en un archivo local para el que se deben conceder derechos de acceso adecuados.


using System;
using System.Text;
using System.IO;
using System.Web.Management;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Web;


 namespace Samples.AspNet.Management
 {
    // Implements a custom event provider.
    public class SampleBufferedWebEventProvider :
        BufferedWebEventProvider
    {

        // The local path of the file where
        // to store event information.
        private string logFilePath = string.Empty;

        // Holds custom information.
        private StringBuilder customInfo;

        private FileStream fs;

        private string providerName, 
            buffer, bufferModality;

        public SampleBufferedWebEventProvider()
        {
            // Perform local initializations.

            // Path of local file where to store 
            // event info.
            // Assure that the path works for you and
            // that the right permissions are set.
            logFilePath = "C:/test/log.doc";

            // Instantiate buffer to contain 
            // local data.
            customInfo = new StringBuilder();

        }


        public override void  Flush()
        {
            customInfo.AppendLine("Perform custom flush");
            StoreToFile(customInfo, logFilePath, FileMode.Append);
        }


        // Initializes the provider.
        public override void Initialize(string name,
         NameValueCollection config)
        {
            base.Initialize(name, config);

            // Get the configuration information.
            providerName = name;
            buffer = SampleUseBuffering.ToString();
            bufferModality = SampleBufferMode;

            customInfo.AppendLine(string.Format(
                "Provider name: {0}", providerName));
            customInfo.AppendLine(string.Format(
                "Buffering: {0}", buffer));
            customInfo.AppendLine(string.Format(
                "Buffering modality: {0}", bufferModality));

        }

        public bool SampleUseBuffering
        {
            get { return UseBuffering; }
        }

        public string SampleBufferMode
        {
            get { return BufferMode; }
        }


        // Processes the incoming events.
        // This method performs custom processing and, 
        // if buffering is enabled, it calls the 
        // base.ProcessEvent to buffer the event
        // information.
        public override void ProcessEvent(
            WebBaseEvent eventRaised)
        {

            if (UseBuffering)
                // Buffering enabled, call the 
                // base event to buffer event information.
                base.ProcessEvent(eventRaised);
            else
            {
                // Buffering disabled, store the 
                // current event now.
                customInfo.AppendLine(
                    "*** Buffering disabled ***");
                customInfo.AppendLine(
                    eventRaised.ToString());
                // Store the information in the specified file.
                StoreToFile(customInfo, 
                    logFilePath, FileMode.Append);
            }
        }

        private WebBaseEventCollection GetEvents(
            WebEventBufferFlushInfo flushInfo)
        {
            return flushInfo.Events;
        }


        private int GetEventsDiscardedSinceLastNotification(
            WebEventBufferFlushInfo flushInfo)
        {
            return flushInfo.EventsDiscardedSinceLastNotification;
        }


        private int GetEventsInBuffer(
            WebEventBufferFlushInfo flushInfo)
        {
            return flushInfo.EventsInBuffer;
        }


        private DateTime GetLastNotificationTime(
            WebEventBufferFlushInfo flushInfo)
        {
            return flushInfo.LastNotificationUtc;
        }


        private int GetNotificationSequence(
            WebEventBufferFlushInfo flushInfo)
        {
            return flushInfo.NotificationSequence;
        }


        private EventNotificationType GetNotificationType(
            WebEventBufferFlushInfo flushInfo)
        {
            return flushInfo.NotificationType;
        }



        // Processes the messages that have been buffered.
        // It is called by the ASP.NET when the flushing of 
        // the buffer is required.
        public override void ProcessEventFlush(
            WebEventBufferFlushInfo flushInfo)
        {

            // Customize event information to be sent to 
            // the Windows Event Viewer Application Log.
            customInfo.AppendLine(
                "SampleEventLogWebEventProvider buffer flush.");

            customInfo.AppendLine(
                string.Format("NotificationType: {0}",
                GetNotificationType(flushInfo)));

            customInfo.AppendLine(
                string.Format("EventsInBuffer: {0}",
                GetEventsInBuffer(flushInfo)));

            customInfo.AppendLine(
                string.Format(
                "EventsDiscardedSinceLastNotification: {0}",
                GetEventsDiscardedSinceLastNotification(flushInfo)));


            // Read each buffered event and send it to the
            // Application Log.
            foreach (WebBaseEvent eventRaised in flushInfo.Events)
                customInfo.AppendLine(eventRaised.ToString());

            // Store the information in the specified file.
            StoreToFile(customInfo, logFilePath, FileMode.Append);
        }

        // Performs standard shutdown.
        public override void Shutdown()
        {
            // Here you need the code that performs
            // those tasks required before shutting 
            // down the provider.

            // Flush the buffer, if needed.
            Flush();

        }

        // Store event information in a local file.
        private void StoreToFile(StringBuilder text,
            string filePath, FileMode mode)
        {
            int writeBlock;
            int startIndex;

            try
            {

                writeBlock = 256;
                startIndex = 0;

                // Open or create the local file 
                // to store the event information.
                fs = new FileStream(filePath,
                    mode, FileAccess.Write);

                // Lock the file for writing.
                fs.Lock(startIndex, writeBlock);

                // Create a stream writer
                StreamWriter writer = new StreamWriter(fs);

                // Set the file pointer to the current 
                // position to keep adding data to it. 
                // If you want to rewrite the file use 
                // the following statement instead.
                // writer.BaseStream.Seek (0, SeekOrigin.Begin);
                writer.BaseStream.Seek(0, SeekOrigin.Current);

                //If the file already exists it must not 
                // be write protected otherwise  
                // the following write operation fails silently.
                writer.Write(text.ToString());

                // Update the underlying file
                writer.Flush();

                // Unlock the file for other processes.
                fs.Unlock(startIndex, writeBlock);

                // Close the stream writer and the underlying file     
                writer.Close();

                fs.Close();
            }
            catch (Exception e)
            {
                // Use this for debugging.
                // Never dispaly it!
                string ex = e.ToString();
                throw new Exception(
                    "[SampleEventProvider] StoreToFile: exception." );
            }
        }

    }

}

Extracto de archivo de configuración siguiente muestra un healthMonitoring sección de configuración que permite a ASP.NET utilizar el proveedor personalizado definido anteriormente para procesar todos los eventos de supervisión de estado.

<healthMonitoring  
  heartBeatInterval="0" enabled="true">

  <bufferModes>
    <add name ="Custom Notification"
      maxBufferSize="10"
      maxFlushSize="5"
      urgentFlushThreshold="10"
      regularFlushInterval="Infinite"
      urgentFlushInterval="00:00:30"
      maxBufferThreads="1"
/>
  </bufferModes>

  <providers>
    <clear/>
    <add name="SampleBufferedWebEventProvider" 
      type="SamplesAspNet.SampleBufferedWebEventProvider, bufferedwebeventprovider, Version=1.0.1785.14700, Culture=neutral, PublicKeyToken=d31491bf33b55954, processorArchitecture=MSIL" 
      buffer="true"
      bufferMode="Custom Notification"
/>
  </providers>

  <profiles>
    <add name="Custom" 
      minInstances="1" 
      maxLimit="Infinite" 
      minInterval="00:00:00" />
  </profiles>

  <rules>
    <clear />
      <add name="Custom Buffered Web Event Provider" 
        eventName="All Events"
        provider="SampleBufferedWebEventProvider" 
        profile="Custom" />
  </rules>

</healthMonitoring>

.NET Framework
Disponible desde 2.0

Cualquier miembro ( Compartido en Visual Basic) estático público de este tipo es seguro para subprocesos. No se garantiza que los miembros de instancia sean seguros para subprocesos.

Volver al principio
Mostrar: