/// <summary>
/// Remueve la instancia <paramref name="instanceName"/> de la lista de instancias
/// </summary>
/// <param name="categoryName">Nombre el contador que contiene la instancia</param>
/// <param name="counterName">Nombre el contador que contiene la instancia</param>
/// <param name="instanceName">Nombre de la instancia a quitar</param>
public static void RemoveCounterInstance(string categoryName, string counterName, string instanceName)
{
if (!isInitialized)
{
PerformanceCounterContainer.RemoveCounterInstance(categoryName, counterName, instanceName);
}
}
/// <summary>
/// Instala los contadores de performance activos de la lista de contadores en el sistema,
/// o los desinstala en caso de no estar activos
/// </summary>
private static void InstallPerformanceCounters()
{
try
{
foreach (CounterCategoryData category in
PerformanceCounterContainer.GetAllCategories())
{
if (!PerformanceCounterCategory.Exists(category.Name))
{
if (category.IsActive)
{
InstallPerformanceCounterCategory(category);
}
}
else
{
if (!category.IsActive)
{
UninstallPerformanceCounterCategory(category);
}
}
}
}
catch (UnauthorizedAccessException uex)
{
throw new InstrumentationException(Messages.InsufficientPermissionsForCounterReading, uex);
}
}
/// <summary>
/// Desinstala todos los contadores de la aplicación
/// </summary>
public static void UninstallAllApplicationCounters()
{
foreach (CounterCategoryData category in PerformanceCounterContainer.GetAllCategories())
{
UninstallPerformanceCounterCategory(category);
}
}
/// <summary>
/// Carga la configuración por defecto
/// </summary>
private static void LoadConfigurationFromDefaultConfiguration()
{
string defaultCategoryName = "Alemana";
string defaultCategoryDescription = "Contadores de Alemana";
PerformanceCounterContainer.AddPerformanceCounterCategory(defaultCategoryName,
defaultCategoryDescription, true,
PerformanceCounterCategoryType.MultiInstance);
}
/// <summary>
/// Quita el contador <paramref name="counterName"/> de la categoría <paramref name="categoryName"/>
/// </summary>
/// <param name="categoryName">Nombre de la categoría</param>
/// <param name="counterName">Nombre del contador</param>
public static void RemoveCounter(string categoryName, string counterName)
{
if (!isInitialized)
{
PerformanceCounterContainer.RemoveCounter(categoryName, counterName);
}
else
{
throw new InstrumentationException(
"El InstrumentationProvider ya está inicializado. Debe llamar a este método antes de llamar a Initialize()");
}
}
/// <summary>
/// Incrementa en 1 la instancia del contador especificado
/// </summary>
/// <param name="categoryName">Nombre de la categoría del contador</param>
/// <param name="counterName">Nombre del contador</param>
/// <param name="instanceName">Nombre de la instancia del contador</param>
public static void IncreaseCounter(string categoryName, string counterName,
string instanceName)
{
if (isInitialized)
{
CounterInstanceData instanceData =
PerformanceCounterContainer.GetPerformanceCounterInstance(categoryName, counterName, instanceName);
if (instanceData != null)
{
instanceData.IncreaseCounter();
}
}
}
/// <summary>
/// Carga la configuración a partir de <paramref name="section"/>
/// </summary>
/// <param name="section">Sección de configuración del archivo de configuración</param>
private static void LoadConfigurationFromConfigurationSection(
InstrumentationSection section)
{
foreach (PerformanceCounterCategoryElement categoryElement in section.CategoryCollection)
{
PerformanceCounterContainer.AddPerformanceCounterCategory(categoryElement.Name,
categoryElement.Description, categoryElement.IsActive, categoryElement.Type);
foreach (PerformanceCounterElement counterElement in categoryElement.PerformanceCounterCollection)
{
PerformanceCounterContainer.AddCounter(categoryElement.Name,
counterElement.Name, counterElement.Description, counterElement.Type);
foreach (PerformanceCounterInstanceElement instanceElement in counterElement.InstanceCollection)
{
PerformanceCounterContainer.AddCounterInstance(categoryElement.Name, counterElement.Name,
instanceElement.Name, instanceElement.IsActive);
}
}
}
}
/// <summary>
/// Registra la diferencia de tiempo entre <paramref name="startTime"/> y el momento en que
/// se llama a la operación. El contador debe ser de tipo Average.
/// </summary>
/// <param name="categoryName">Nombre de la categoría del contador</param>
/// <param name="counterName">Nombre del contador</param>
/// <param name="instanceName">Nombre de la instancia del contador</param>
/// <param name="startTime">Instante inicial que se usará para comparar con el momento
/// actual para calcular la diferencia entre ambos e incrementar el contador acorde</param>
public static void RegisterTime(string categoryName, string counterName,
string instanceName, DateTime startTime)
{
if (isInitialized)
{
CounterData counterData =
PerformanceCounterContainer.GetCounter(categoryName, counterName);
if (counterData != null)
{
if (!counterData.HasBaseCounter)
{
throw new InstrumentationException(Messages.InvalidCounterForOperation);
}
if (counterData.HasInstance(instanceName))
{
counterData.GetInstance(instanceName).RegisterTime(startTime);
}
}
}
}
/// <summary>
/// Crea las instancias de contadores
/// </summary>
private static void InitializeCounters()
{
foreach (CounterCategoryData category in PerformanceCounterContainer.GetAllCategories())
{
if (category.IsActive)
{
foreach (CounterData counterData in category.GetAllCounters())
{
foreach (CounterInstanceData instanceData in counterData.GetAllInstances())
{
using (PerformanceCounter counter = new PerformanceCounter(category.Name, counterData.Name, instanceData.Name, false))
{
instanceData.RealCounter = counter;
if (!instanceData.IsActive)
{
counter.RemoveInstance();
}
if (counterData.HasBaseCounter)
{
using (PerformanceCounter baseCounter = new PerformanceCounter(category.Name, counterData.BaseName, instanceData.Name, false))
{
instanceData.RealCounterBase = baseCounter;
if (!instanceData.IsActive)
{
baseCounter.RemoveInstance();
}
}
}
}
}
}
}
}
}
/// <summary>
/// Indica si se tiene la instancia especificada
/// </summary>
/// <param name="categoryName">Nombre de la categoría</param>
/// <param name="counterName">Nombre del contador</param>
/// <param name="instanceName">Nombre de la instancia</param>
/// <returns>Si contiene o no la intancia</returns>
public static bool HasCounterInstance(string categoryName, string counterName, string instanceName)
{
return(PerformanceCounterContainer.HasCounterInstance(categoryName, counterName, instanceName));
}
