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

Estructura CounterSample

 

Publicado: octubre de 2016

Define una estructura que contiene los datos sin procesar para un contador de rendimiento.

Espacio de nombres:   System.Diagnostics
Ensamblado:  System (en System.dll)

public value struct CounterSample

NombreDescripción
System_CAPS_pubmethodCounterSample(Int64, Int64, Int64, Int64, Int64, Int64, PerformanceCounterType)

Inicializa una nueva instancia de la CounterSample estructura y establece el CounterTimeStamp propiedad en 0 (cero).

System_CAPS_pubmethodCounterSample(Int64, Int64, Int64, Int64, Int64, Int64, PerformanceCounterType, Int64)

Inicializa una nueva instancia de la CounterSample estructura y establece la CounterTimeStamp valor para la propiedad que se pasa.

NombreDescripción
System_CAPS_pubpropertyBaseValue

Obtiene un valor sin formato opcional para el contador.

System_CAPS_pubpropertyCounterFrequency

Obtiene la frecuencia del contador sin formato.

System_CAPS_pubpropertyCounterTimeStamp

Obtiene la marca de tiempo del contador.

System_CAPS_pubpropertyCounterType

Obtiene el tipo de contador de rendimiento.

System_CAPS_pubpropertyRawValue

Obtiene el valor sin formato del contador.

System_CAPS_pubpropertySystemFrequency

Obtiene la frecuencia del sistema sin formato.

System_CAPS_pubpropertyTimeStamp

Obtiene la marca de hora sin formato.

System_CAPS_pubpropertyTimeStamp100nSec

Obtiene la marca de hora sin formato de alta fidelidad.

NombreDescripción
System_CAPS_pubmethodSystem_CAPS_staticCalculate(CounterSample)

Calcula los datos de rendimiento del contador, mediante un único punto de muestra. Este método se utiliza normalmente para los tipos de contador de rendimiento no calculados.

System_CAPS_pubmethodSystem_CAPS_staticCalculate(CounterSample, CounterSample)

Calcula los datos de rendimiento del contador, con dos puntos de muestra. Este método se utiliza normalmente para los tipos de contador de rendimiento calculados, como los promedios.

System_CAPS_pubmethodEquals(CounterSample)

Indica si el texto especificado CounterSample es igual a la actual estructura CounterSample estructura.

System_CAPS_pubmethodEquals(Object^)

Indica si la estructura especificada es una CounterSample estructura y es idéntico a la actual CounterSample estructura.(Invalida ValueType::Equals(Object^)).

System_CAPS_pubmethodGetHashCode()

Obtiene un código hash para la actual muestra del contador.(Invalida ValueType::GetHashCode()).

System_CAPS_pubmethodGetType()

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

System_CAPS_pubmethodToString()

Devuelve el nombre de tipo completo de esta instancia.(Heredado de ValueType).

NombreDescripción
System_CAPS_pubfieldSystem_CAPS_staticEmpty

Define una muestra de contador de rendimiento sin inicializar, vacía, de tipo NumberOfItems32.

NombreDescripción
System_CAPS_puboperatorSystem_CAPS_staticEquality(CounterSample, CounterSample)

Devuelve un valor que indica si dos CounterSample estructuras son iguales.

System_CAPS_puboperatorSystem_CAPS_staticInequality(CounterSample, CounterSample)

Devuelve un valor que indica si dos CounterSample estructuras no son iguales.

En el ejemplo siguiente se muestra el uso de la CounterSample clase para mostrar datos de un contador de rendimiento.

#using <System.dll>

using namespace System;
using namespace System::Collections;
using namespace System::Collections::Specialized;
using namespace System::Diagnostics;

// Output information about the counter sample.
void OutputSample( CounterSample s )
{
   Console::WriteLine( "\r\n+++++++++++" );
   Console::WriteLine( "Sample values - \r\n" );
   Console::WriteLine( "   BaseValue        = {0}", s.BaseValue );
   Console::WriteLine( "   CounterFrequency = {0}", s.CounterFrequency );
   Console::WriteLine( "   CounterTimeStamp = {0}", s.CounterTimeStamp );
   Console::WriteLine( "   CounterType      = {0}", s.CounterType );
   Console::WriteLine( "   RawValue         = {0}", s.RawValue );
   Console::WriteLine( "   SystemFrequency  = {0}", s.SystemFrequency );
   Console::WriteLine( "   TimeStamp        = {0}", s.TimeStamp );
   Console::WriteLine( "   TimeStamp100nSec = {0}", s.TimeStamp100nSec );
   Console::WriteLine( "++++++++++++++++++++++" );
}

//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
//    Description - This counter type shows how many items are processed, on average,
//        during an operation. Counters of this type display a ratio of the items 
//        processed (such as bytes sent) to the number of operations completed. The  
//        ratio is calculated by comparing the number of items processed during the 
//        last interval to the number of operations completed during the last interval. 
// Generic type - Average
//      Formula - (N1 - N0) / (D1 - D0), where the numerator (N) represents the number 
//        of items processed during the last sample interval and the denominator (D) 
//        represents the number of operations completed during the last two sample 
//        intervals. 
//    Average (Nx - N0) / (Dx - D0)  
//    Example PhysicalDisk\ Avg. Disk Bytes/Transfer 
//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
float MyComputeCounterValue( CounterSample s0, CounterSample s1 )
{
   float numerator = (float)s1.RawValue - (float)s0.RawValue;
   float denomenator = (float)s1.BaseValue - (float)s0.BaseValue;
   float counterValue = numerator / denomenator;
   return counterValue;
}

bool SetupCategory()
{
   if (  !PerformanceCounterCategory::Exists( "AverageCounter64SampleCategory" ) )
   {
      CounterCreationDataCollection^ CCDC = gcnew CounterCreationDataCollection;

      // Add the counter.
      CounterCreationData^ averageCount64 = gcnew CounterCreationData;
      averageCount64->CounterType = PerformanceCounterType::AverageCount64;
      averageCount64->CounterName = "AverageCounter64Sample";
      CCDC->Add( averageCount64 );

      // Add the base counter.
      CounterCreationData^ averageCount64Base = gcnew CounterCreationData;
      averageCount64Base->CounterType = PerformanceCounterType::AverageBase;
      averageCount64Base->CounterName = "AverageCounter64SampleBase";
      CCDC->Add( averageCount64Base );

      // Create the category.
      PerformanceCounterCategory::Create( "AverageCounter64SampleCategory", "Demonstrates usage of the AverageCounter64 performance counter type.", CCDC );
      return (true);
   }
   else
   {
      Console::WriteLine( "Category exists - AverageCounter64SampleCategory" );
      return (false);
   }
}

void CreateCounters( PerformanceCounter^% PC, PerformanceCounter^% BPC )
{

   // Create the counters.
   PC = gcnew PerformanceCounter( "AverageCounter64SampleCategory","AverageCounter64Sample",false );

   BPC = gcnew PerformanceCounter( "AverageCounter64SampleCategory","AverageCounter64SampleBase",false );
   PC->RawValue = 0;
   BPC->RawValue = 0;
}
void CollectSamples( ArrayList^ samplesList, PerformanceCounter^ PC, PerformanceCounter^ BPC )
{
   Random^ r = gcnew Random( DateTime::Now.Millisecond );

   // Loop for the samples.
   for ( int j = 0; j < 100; j++ )
   {
      int value = r->Next( 1, 10 );
      Console::Write( "{0} = {1}", j, value );
      PC->IncrementBy( value );
      BPC->Increment();
      if ( (j % 10) == 9 )
      {
         OutputSample( PC->NextSample() );
         samplesList->Add( PC->NextSample() );
      }
      else
            Console::WriteLine();
      System::Threading::Thread::Sleep( 50 );
   }
}

void CalculateResults( ArrayList^ samplesList )
{
   for ( int i = 0; i < (samplesList->Count - 1); i++ )
   {
      // Output the sample.
      OutputSample(  *safe_cast<CounterSample^>(samplesList[ i ]) );
      OutputSample(  *safe_cast<CounterSample^>(samplesList[ i + 1 ]) );

      // Use .NET to calculate the counter value.
      Console::WriteLine( ".NET computed counter value = {0}", CounterSampleCalculator::ComputeCounterValue(  *safe_cast<CounterSample^>(samplesList[ i ]),  *safe_cast<CounterSample^>(samplesList[ i + 1 ]) ) );

      // Calculate the counter value manually.
      Console::WriteLine( "My computed counter value = {0}", MyComputeCounterValue(  *safe_cast<CounterSample^>(samplesList[ i ]),  *safe_cast<CounterSample^>(samplesList[ i + 1 ]) ) );
   }
}

int main()
{
   ArrayList^ samplesList = gcnew ArrayList;
   PerformanceCounter^ PC;
   PerformanceCounter^ BPC;
   SetupCategory();
   CreateCounters( PC, BPC );
   CollectSamples( samplesList, PC, BPC );
   CalculateResults( samplesList );
}

.NET Framework
Disponible desde 1.1

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: