Пример #1
0
        /// <summary>
        /// Create a new metric object with the provided instance name and add it to the collection
        /// </summary>
        /// <param name="instanceName">The instance name to use, or blank or null for the default metric.</param>
        /// <returns>The new metric object that was added to the collection</returns>
        public EventMetric Add(string instanceName)
        {
            //Create a new metric object with the provided instance name (it will get added to us automatically)
            EventMetric newMetric = new EventMetric(Definition, instanceName);

            //finally, return the newly created metric object to our caller
            return(newMetric);
        }
Пример #2
0
        /// <summary>
        /// Retrieve an item from the collection by its key if present.  If not present, the default value of the object is returned.
        /// </summary>
        /// <param name="key">The metric name to locate in the collection</param>
        /// <param name="value">When this method returns, contains the value associated with the specified key, if the key is found; otherwise, the default value for the type of the value parameter. This parameter is passed uninitialized.</param>
        /// <returns>true if the collection contains an element with the specified key; otherwise false.</returns>
        public bool TryGetValue(string key, out EventMetric value)
        {
            //We are playing a few games to get native typing here.  Because it's an OUt value, we
            //have to swap types around ourselves so we can cast.
            IMetric innerValue;

            //gateway to our inner dictionary try get value
            bool result = base.TryGetValue(key, out innerValue);

            value = innerValue as EventMetric; //No one expects exceptions from try get value, so if it's the wrong type, return null

            return(value != null);
        }
Пример #3
0
        /// <summary>Creates a new metric instance or returns an existing one from the provided definition information, or returns any existing instance if found.</summary>
        /// <remarks>If the metric definition doesn't exist, it will be created.  If the metric doesn't exist, it will be created.
        /// If the metric definition does exist, but is not an Event Metric (or a derived class) an exception will be thrown.</remarks>
        /// <param name="definitions">The definitions dictionary this definition is a part of</param>
        /// <param name="metricTypeName">The unique metric type</param>
        /// <param name="categoryName">The name of the category with which this definition is associated.</param>
        /// <param name="counterName">The name of the definition within the category.</param>
        /// <param name="instanceName">The unique name of this instance within the metric's collection.</param>
        /// <returns>The event metric object for the specified event metric instance.</returns>
        public static EventMetric AddOrGet(MetricDefinitionCollection definitions, string metricTypeName, string categoryName, string counterName, string instanceName)
        {
            //we must have a definitions collection, or we have a problem
            if (definitions == null)
            {
                throw new ArgumentNullException(nameof(definitions));
            }

            //we need to find the definition, adding it if necessary
            string            definitionKey = MetricDefinition.GetKey(metricTypeName, categoryName, counterName);
            IMetricDefinition definition;

            if (definitions.TryGetValue(definitionKey, out definition))
            {
                //if the metric definition exists, but is of the wrong type we have a problem.
                if ((definition is EventMetricDefinition) == false)
                {
                    throw new ArgumentException("A metric already exists with the provided type, category, and counter name but it is not compatible with being an event metric.  Please use a different counter name.", nameof(counterName));
                }
            }
            else
            {
                //we didn't find one, make a new one
                definition = new EventMetricDefinition(definitions, metricTypeName, categoryName, counterName);
                definitions.Add(definition); // Add it to the collection, no longer done in the constructor.
                // ToDo: Reconsider this implementation; putting incomplete event metric definitions in the collection is not ideal,
                // and creating a metric from an empty event metric definition is fairly pointless.
            }

            //now we have our definition, proceed to create a new metric if it doesn't exist
            string  metricKey = MetricDefinition.GetKey(metricTypeName, categoryName, counterName, instanceName);
            IMetric metric;

            //see if we can get the metric already.  If not, we'll create it
            lock (((MetricCollection)definition.Metrics).Lock) //make sure the get & add are atomic
            {
                if (definition.Metrics.TryGetValue(metricKey, out metric) == false)
                {
                    metric = new EventMetric((EventMetricDefinition)definition, instanceName);
                }
            }

            return((EventMetric)metric);
        }
 /// <summary>
 /// Create a new Event metric sample object for the provided metric and raw sample packet.
 /// </summary>
 /// <remarks>The metric sample is automatically added to the samples collection of the provided metric object.</remarks>
 /// <param name="metric">The metric object this sample applies to.</param>
 /// <param name="metricSamplePacket">The raw sample data packet.</param>
 internal EventMetricSample(EventMetric metric, EventMetricSamplePacket metricSamplePacket)
     : base(metric, metricSamplePacket)
 {
     //and now that we've been created, make sure our metric definition set is locked.
     metric.Definition.IsReadOnly = true;
 }
 /// <summary>
 /// Create a new sample collection for the specified metric object
 /// </summary>
 /// <param name="metric"></param>
 public EventMetricSampleCollection(EventMetric metric)
     : base(metric)
 {
     m_EventMetric = metric;
 }
Пример #6
0
 /// <summary>
 /// Determines if the provided object is identical to this object.
 /// </summary>
 /// <param name="other">The object to compare this object to</param>
 /// <returns>True if the objects represent the same data.</returns>
 public bool Equals(EventMetric other)
 {
     //We're really just a type cast, refer to our base object
     return(base.Equals(other));
 }
Пример #7
0
 /// <summary>
 /// Indicates the relative sort order of this object to another of the same type.
 /// </summary>
 /// <param name="other"></param>
 /// <returns></returns>
 public int CompareTo(EventMetric other)
 {
     //we let our base object do the compare, we're really just casting things
     return(base.CompareTo(other));
 }