MARKUS

<?xml version="1.0"?>

<doc>

    <assembly>

        <name>EQATEC.Analytics.Monitor</name>

    </assembly>

    <members>

        <member name="T:EQATEC.Analytics.Monitor.AnalyticsMonitor">

            <summary>

            Implementing class for IAnalyticsMonitor. Coordinates the interaction between

            the messaging subsystem, the statistics and the storage

            </summary>

        </member>

        <member name="T:EQATEC.Analytics.Monitor.IAnalyticsMonitor">

            <summary>

            The main interface for the analytics monitor which can be obtained with a call to 

            <see cref="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFactory.CreateMonitor(System.String)"/> or <see cref="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFactory.CreateMonitor(EQATEC.Analytics.Monitor.IAnalyticsMonitorSettings)"/>. The monitor will not collect data before

            a call to <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.Start"/> has been performed.

            </summary>

            <remarks>For more on the features of the EQATEC Analytics service please

            refer to the <a href="http://eqatec.com/analytics">EQATEC Analytics website</a></remarks>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.Start">

            <summary>

            Call to start the monitor. When started the monitor will begin collecting data from the

            calls and send them asynchronously to the EQATEC Analytics servers on background threads

            </summary>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.TrackException(System.Exception)">

            <summary>

            Call to track an exception that occured in the application.

            </summary>

            <param name="exception">the exception to be tracked</param>

            <example>An example of tracking an exception

            <code>

            static class Program 

            {   

              [STAThread]

              static void Main()

              {

                IAnalyticsMonitor monitor = AnalyticsMonitorFactory.CreateMonitor("YOUR-PRODUCT_KEY");

                monitor.Start();

                try 

                {

                   // your application logic here

                }

                catch(Exception exc)

                {

                  // catch-all handle 

                  monitor.TrackException(exc);

                }

                finally

                {

                  monitor.Stop();

                }

              } 

            }

            </code>

            </example>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.TrackException(System.Exception,System.String)">

            <summary>

            Call to track an exception that occured in the application.

            </summary>

            <param name="exception">The exception to be tracked</param>

            <param name="contextMessage">Contextual information about the action being performed when the exception occurred</param>

            <example>An example of tracking an exception

            <code>

            static class Program 

            {   

              [STAThread]

              static void Main(string[] args)

              {

                IAnalyticsMonitor monitor = AnalyticsMonitorFactory.CreateMonitor("YOUR-PRODUCT_KEY");

                monitor.Start();

                try 

                {

                   // your application logic here

                }

                catch(Exception exc)

                {

                  // catch-all handle 

                  monitor.TrackException(exc, "CatchAllHandler");

                }

                finally

                {

                  monitor.Stop();

                }

              } 

            }

            </code>

            </example>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.TrackException(System.Exception,System.String,System.Object[])">

            <summary>

            Call to track an exception that occured in the application.

            </summary>

            <param name="exception">The exception to be tracked</param>

            <param name="contextMessageFormat">A context message string containing the information about the action being performed when the exception occurred</param>

            <param name="args">An object array containing zero or more objects to format the <paramref name="contextMessageFormat"/></param>

            <example>An example of tracking an exception

            <code>

            static class Program 

            {   

              [STAThread]

              static void Main(string[] args)

              {

                IAnalyticsMonitor monitor = AnalyticsMonitorFactory.CreateMonitor("YOUR-PRODUCT_KEY");

                monitor.Start();

                try 

                {

                   // your application logic here

                }

                catch(Exception exc)

                {

                  // catch-all handle 

                  monitor.TrackException(exc, "CatchAllHandler with argument count {0}", args.Length);

                }

                finally

                {

                  monitor.Stop();

                }

              } 

            }

            </code>

            </example>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.TrackFeature(System.String)">

            <summary>

            Register a feature usage. It is recommended that related features are grouped by using simple dot-notation

            in the <paramref name="featureName"/> such as e.g. relating print to pdf and print to file by naming the

            features "print.pdf" and "print.file" respectively

            </summary>

            <param name="featureName">The name of the feature. If it is <c>null</c> or empty the request is ignored.</param>

            <example>The following shows an example of how you can track features in your application

            <code>

            static class Program 

            {   

              [STAThread]

              static void Main(string[] args)

              {

                IAnalyticsMonitor monitor = AnalyticsMonitorFactory.CreateMonitor("YOUR-PRODUCT_KEY");

                monitor.Start();

                try 

                {

                   bool exportToFile = ShouldExportToFile(); //omitted for brevity

                   if (exportToFile)

                     monitor.TrackFeature("export.file");

                }

                finally

                {

                  monitor.Stop();

                }

              } 

            }

            </code>

            </example>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.TrackFeatures(System.String[])">

            <summary>

            Register a number of feature usages. For the individual feature names, it is recommended that related 

            features are grouped by using simple dot-notation such as e.g. relating print to pdf and print to file by naming the

            features "print.pdf" and "print.file" respectively. This allow call is semantically equivalent to

            calling <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.TrackFeature(System.String)"/> multiple times.

            </summary>

            <param name="featureNames">The array of named feature. If it is <c>null</c> or empty the request is ignored.</param>

            <example>The following shows an example of how you can track features in your application

            <code>

            static class Program 

            {   

              [STAThread]

              static void Main(string[] args)

              {

                IAnalyticsMonitor monitor = AnalyticsMonitorFactory.CreateMonitor("YOUR-PRODUCT_KEY");

                monitor.Start();

                try 

                {

                   bool exportToFile = ShouldExportToFile(); //omitted for brevity

                   if (exportToFile)

                     monitor.TrackFeature(new[]{"export.file", "export.byuser"});

                }

                finally

                {

                  monitor.Stop();

                }

              } 

            }

            </code>

            </example>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.TrackFeatureStart(System.String)">

            <summary>

            Register the start of a feature usage. Use this with <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.TrackFeatureStop(System.String)"/> to track

            how long a feature is used.

            </summary>

            <returns>A <see cref="T:EQATEC.Analytics.Monitor.TimingScope"/> instance that can be used for creating more compact timing code.</returns>

            <remarks>There cannot be more then one feature timing running with a given <paramref name="featureName"/> at a time.

            This implies that calling this method multiple times with the same <paramref name="featureName"/> has no effect

            until the existing time has termined by either calling <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.TrackFeatureStop(System.String)"/> or 

            <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.TrackFeatureCancel(System.String)"/> with the same <paramref name="featureName"/>. All features timings

            are implicitly stopped by calling <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.Stop"/>.</remarks>

            <param name="featureName">The name of the feature. If it is <c>null</c> or empty the request is ignored.</param>

            <example>The following shows an example of how you can track feature time in your application

            <code>

            class SomeClass

            {   

              private IAnalyticsMonitor m_monitor;

              public SomeClass(IAnalyticsMonitor monitor)

              {

                m_monitor = monitor;

              }

              public void Process()

              {

                try 

                {

                   m_monitor.TrackFeatureStart("SomeClass.Process");

                   //some process logic to time

                   m_monitor.TrackFeatureStop("SomeClass.Process");

                }

                catch(Exception exc)

                {

                  m_monitor.TrackFeatureCancel("SomeClass.Process");

                  throw;

                }

              } 

            }

            </code>

            </example>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.TrackFeatureStop(System.String)">

            <summary>

            Register the end of a feature usage stared by <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.TrackFeatureStart(System.String)"/> with a similar

            <paramref name="featureName"/>.

            </summary>

            <returns>The total time tracked for this feature or <c>TimeSpan.Zero</c> if timing was not tracked</returns>

            <remarks>Calling this method with a <paramref name="featureName"/> that does not match an already

            started feature timing has no effect. All features timings

            are implicitly stopped by calling <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.Stop"/>.

            </remarks>

            <param name="featureName">The name of the feature. If it is <c>null</c> or empty the request is ignored.</param>

            <example>The following shows an example of how you can track feature time in your application

            <code>

            class SomeClass

            {   

              private IAnalyticsMonitor m_monitor;

              public SomeClass(IAnalyticsMonitor monitor)

              {

                m_monitor = monitor;

              }

              public void Process()

              {

                try 

                {

                   m_monitor.TrackFeatureStart("SomeClass.Process");

                   //some process logic to time

                   TimeSpan timeSpent = m_monitor.TrackFeatureStop("SomeClass.Process");

                }

                catch(Exception exc)

                {

                  m_monitor.TrackFeatureCancel("SomeClass.Process");

                  throw;

                }

              } 

            }

            </code>

            </example>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.TrackFeatureCancel(System.String)">

            <summary>

            Stops an ongoing timing of a feature from any previous call to <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.TrackFeatureStart(System.String)"/> with similar

            <paramref name="featureName"/> without

            registering the time spent. Use this call if the feature being tracked did not complete as expected, e.g.

            was interupted by an exception. The call can safely be made even if no <c>TrackFeatureStart</c> has

            been made.

            </summary>

            <param name="featureName">The name of the feature. If it is <c>null</c> or empty the request is ignored.</param>

            <example>The following shows an example of how you can track feature time in your application

            <code>

            class SomeClass

            {   

              private IAnalyticsMonitor m_monitor;

              public SomeClass(IAnalyticsMonitor monitor)

              {

                m_monitor = monitor;

              }

              public void Process()

              {

                try 

                {

                   m_monitor.TrackFeatureStart("SomeClass.Process");

                   //some process logic to time

                   m_monitor.TrackFeatureStop("SomeClass.Process");

                }

                catch(Exception exc)

                {

                  m_monitor.TrackFeatureCancel("SomeClass.Process");

                  throw;

                }

              } 

            }

            </code>

            </example>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.TrackFeatureValue(System.String,System.Int64)">

            <summary>

            Register a value on a specific feature. 

            </summary>

            <remarks>While calls to <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.TrackFeature(System.String)"/> increments the use of a feature in the session a call to

            this methods will associate a given value with a named feature. Use this method to e.g. track the distribution

            of file sizes imported or the number of results registered. Tracking this distribution across all your application

            usage will give insights to what scenarios your applications are handling</remarks>

            <param name="featureName">The name of the feature. If it is <c>null</c> or empty the request is ignored.</param>

            <param name="trackedValue">The value to track</param>

            <example>The following shows an example of how you can track feature values in your application

            <code>

            class SomeClass

            {   

              private IAnalyticsMonitor m_monitor;

              public SomeClass(IAnalyticsMonitor monitor)

              {

                m_monitor = monitor;

              }

              public void Process()

              {

                int filesProcessed = ProcessFiles();

                m_monitor.TrackFeatureValue("SomeClass.FilesProcessed", filesProcessed);

              } 

            }

            </code>

            </example>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.Stop">

            <summary>

            Call to stop the monitor. Call will attempt to save any pending state

            to the storage and send the final tracking data to the servers. 

            </summary>

            <remarks>This call will attempt to send the final tracking data to the servers on a background thread and

            by wait for completion of this monitor processing for up to 2 seconds. If you do not want to wait for up to 2 seconds

            for the completion of this operation, please consider using the overload to this function(<see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.Stop(System.TimeSpan)"/>.</remarks>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.Stop(System.TimeSpan)">

            <summary>

            Call to stop the monitor. The monitor will attempt to save any pending state

            to the storage and send the final tracking data to the servers. The <paramref name="waitForCompletion"/> can be specified

            to allow for the thread to wait for completion of data persistence and transmission. If the monitor cannot complete

            before the specified time the call will return.

            </summary>

            <param name="waitForCompletion">The time to wait for the stop to complete successfully. Use <see cref="F:System.TimeSpan.Zero"/> to avoid waiting for completion.</param>

            <remarks>This call will attempt to send the final tracking data to the servers on a background thread and

            by providing a <paramref name="waitForCompletion"/> timeout you increase the chance that the monitor is able to

            completion the transmission while the runtime and threadpools are still operational. If no timeout is specified

            the monitors background threads and network connections may be removed as part of the process termination and thereby

            leaving data in the cache to be delivered on the next startup.</remarks>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.ForceSync">

            <summary>

            Explicitly force a synchonization of the current information with the analytics server. 

            </summary>

            <remarks>This call is not expected to be used in a standard setup but may be helpful in occasionally connected 

            scenarios. You can use this method in conjunction with setting <see cref="P:EQATEC.Analytics.Monitor.AnalyticsMonitorSettings.SynchronizeAutomatically"/> to <c>false</c>

            in order to take control of when data is attempted to be delivered to the servers. By default the monitor will

            control the data delivery internally but if you need to decide e.g. when networks can be utilized you

            can use this method to schedule an asynchronous data delivery

            </remarks>

            <seealso cref="T:EQATEC.Analytics.Monitor.AnalyticsMonitorSettings"/>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.SetInstallationInfo(System.String,System.Collections.Generic.IDictionary{System.String,System.String})">

            <summary>

            Associates an installation ID with the current session and optionally a dictionary of

            installation properties that allows you to add additional installation meta data for the session

            </summary>

            <remarks>Use this method to register you installationid on the monitor and optionally associate

            installation properties with this installation id. You can call this method multiple times

            while the monitor is running and thus alter the installation id associated with the session at runtime. Note however

            that changing the installation id will also reset any previous installation properties associated with the previous 

            installation id from the session so you will need to associate them again</remarks>

            <param name="installationId">The installation ID to associate with the current session</param>

            <param name="propertyDictionary">The dictionary containing the key-value pairs for the installation properties of the current session</param>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.SetInstallationInfo(System.String)">

            <summary>

            Associates an installation ID with the current session 

            </summary>

            <remarks>Use this method to register you installationid on the monitor. You can call this method multiple times

            while the monitor is running and thus alter the installation id associated with the session at runtime. Note however

            that changing the installation id will also reset any previous installation properties associated with the previous 

            installation id from the session so you will need to associate them again</remarks>

            <param name="installationId">The installation ID to associate with the current session</param>

        </member>

        <member name="P:EQATEC.Analytics.Monitor.IAnalyticsMonitor.Status">

            <summary>

            Access the current status for the monitor.

            </summary>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitor.Start">

            <summary>

            Initializes the monitor

            </summary>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitor.Stop">

            <summary>

            Stop the Analytics monitor. Will attempt to write any pending

            state to the storage

            </summary>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitor.Stop(System.TimeSpan)">

            <summary>

            Stop the Analytics monitor. Will attempt to write any pending

            state to the storage

            </summary>

            <param name="waitForCompletion">The timeout for any server communication in progress</param>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitor.TrackException(System.Exception)">

            <summary>

            Track exception

            </summary>

            <param name="exception"></param>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitor.TrackException(System.Exception,System.String)">

            <summary>

            Track exception

            </summary>

            <param name="exception"></param>

            <param name="contextMessage"></param>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitor.TrackException(System.Exception,System.String,System.Object[])">

            <summary>

            Track exception

            </summary>

            <param name="exception"></param>

            <param name="contextMessageFormat"></param>

            <param name="args"></param>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitor.TrackFeatureStart(System.String)">

            <summary>

            Tracking a feature start

            </summary>

            <param name="featureName"></param>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitor.TrackFeatureStop(System.String)">

            <summary>

            Tracking a feature stop

            </summary>

            <param name="featureName"></param>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitor.TrackFeatureCancel(System.String)">

            <summary>

            Cancelling a feature timing

            </summary>

            <param name="featureName"></param>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitor.ForceSync">

            <summary>

            Force a synchonization the current information with the analytics server.

            This should not be used in normal situations.

            </summary>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitor.SetInstallationInfo(System.String)">

            <summary>

            Set installationId at the current session

            </summary>

            <param name="installationId">the installation ID</param>

            <returns></returns>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitor.SetInstallationInfo(System.String,System.Collections.Generic.IDictionary{System.String,System.String})">

            <summary>

            Set installationId at the current session and get interface to installation settings

            </summary>

            <param name="installationId">the installation ID</param>

            <param name="installationProperties">the installaion properties</param>

            <returns></returns>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitor.System#IDisposable#Dispose">

            <summary>

            Dispose the monitor

            </summary>

        </member>

        <member name="P:EQATEC.Analytics.Monitor.AnalyticsMonitor.Status">

            <summary>

            Access the current status for the monitor.

            </summary>

        </member>

        <member name="T:EQATEC.Analytics.Monitor.AnalyticsMonitorFacade">

             <summary>

             Represents a simple facade for interacting with the Analytics Monitor. Use this facade interface instead

             of interacting more directly with the <see cref="T:EQATEC.Analytics.Monitor.AnalyticsMonitorFactory"/> and <see cref="T:EQATEC.Analytics.Monitor.IAnalyticsMonitor"/>

             interfaces for a slightly higher level interaction model.

             </summary>

             <remarks>

             The facade will instantiate a single <see cref="T:EQATEC.Analytics.Monitor.IAnalyticsMonitor"/> instance on the Create call and

             the remaining methods on this class mirror the methods found on the <see cref="T:EQATEC.Analytics.Monitor.IAnalyticsMonitor"/> interface. The

             facade can be used by consumers as a simple way of calling the API without worrying about passing the

             <see cref="T:EQATEC.Analytics.Monitor.IAnalyticsMonitor"/> instance around and about the timing issues of when the methods can be 

             called. The facade will encapsulate the created instance, raise an exception for multiple calls

             to the <see cref="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFacade.Create(System.String)"/> methods and will forward the methods on to the instance when it is available.

             If the facade represent too high level control or you would like to control the <see cref="T:EQATEC.Analytics.Monitor.IAnalyticsMonitor"/>

             instance yourself you should look at using the <see cref="T:EQATEC.Analytics.Monitor.AnalyticsMonitorFactory"/> methods.

             Repeated calls to the Create methods will raise exceptions as the intended use of the facade is for simple integration scenarios</remarks>

             <example> This sample shows how to use AnalyticsMonitorFacade.

             <code>

             class MyClass 

             {

               static void Main()

               {

                 //Creating Analytics Monitor

                 AnalyticsMonitorFacade.Create("YOUR_PRODUCT_KEY_HERE");

                 //Start Analytics monitor

                 AnalyticsMonitorFacade.Start();

                 /*Your program here....*/

                 //Stop Analytics monitor

                 AnalyticsMonitorFacade.Stop();

               }

             }

             </code>

             </example>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFacade.Create(System.String)">

            <summary>

            Initializes the facade by creating a monitor with the given product id and the standard

            settings

            </summary>

            <param name="productId">the product id to use</param>

            <exception cref="T:System.InvalidOperationException">if Create has already been called</exception>

            <exception cref="T:System.ArgumentException">if the product id is not correctly formatted</exception>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFacade.Create(EQATEC.Analytics.Monitor.IAnalyticsMonitorSettings)">

            <summary>

            Initializes the facade by creating a monitor with the specified

            settings

            </summary>

            <param name="settings">the product id to use</param>

            <exception cref="T:System.InvalidOperationException">if Create has already been called</exception>

            <exception cref="T:System.ArgumentNullException">if <c>null</c> is passed as settings</exception>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFacade.Start">

            <summary>

            Start the monitor. Mirrors the <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.Start"/> method

            </summary>

            <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.Start"/>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFacade.Stop">

            <summary>

            Stop the monitor. Mirrors the <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.Stop"/> method

            </summary>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFacade.Stop(System.TimeSpan)">

             <summary>

             Stop the monitor. Mirrors the <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.Stop(System.TimeSpan)"/> method

             </summary>

            <param name="waitForCompletion">The wait interval for the monitor to stop correctly</param>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFacade.TrackException(System.Exception)">

            <summary>

            Track an exception. Mirrors the <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.TrackException(System.Exception)"/> method

            </summary>

            <param name="exception">the exception instance</param>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFacade.TrackException(System.Exception,System.String)">

            <summary>

            Track an exception along with a context message. Mirrors the <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.TrackException(System.Exception,System.String)"/> method

            </summary>

            <param name="exception">the exception instance</param>

            <param name="message">an additional context message specifying extra information not captured in the exception</param>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFacade.TrackException(System.Exception,System.String,System.Object[])">

            <summary>

            Track an exception with a formatted context message. Mirrors the <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.TrackException(System.Exception,System.String,System.Object[])"/> method

            </summary>

            <param name="exception">the exception instance</param>

            <param name="format">a format string for specifying extra information not captured in the exception</param>

            <param name="args">arguments to the format string</param>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFacade.TrackFeature(System.String)">

            <summary>

            Register a feature usage. Mirrors the <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.TrackFeature(System.String)"/> method

            </summary>

            <param name="featureName">The name of the feature. If it is <c>null</c> or empty the request is ignored.</param>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFacade.TrackFeatures(System.String[])">

            <summary>

            Register a number of feature usages. Mirrors the <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.TrackFeatures(System.String[])"/> method

            </summary>

            <param name="featureNames">Array of named features. If it is <c>null</c> or empty the request is ignored.</param>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFacade.TrackFeatureStart(System.String)">

            <summary>

            Register the start of a feature usage. Mirrors the <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.TrackFeatureStart(System.String)"/> method

            </summary>

            <param name="featureName">The name of the feature. If it is <c>null</c> or empty the request is ignored.</param>

            <returns>A <see cref="T:EQATEC.Analytics.Monitor.TimingScope"/> instance that can be used for creating more compact timing code.</returns>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFacade.TrackFeatureStop(System.String)">

            <summary>

            Register the end of a feature usage stared by <see cref="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFacade.TrackFeatureStart(System.String)"/>.Mirrors the <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.TrackFeatureStop(System.String)"/> method

            </summary>

            <param name="featureName">The name of the feature. If it is <c>null</c> or empty the request is ignored.</param>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFacade.TrackFeatureCancel(System.String)">

            <summary>

            Cancels an ongoing feature timing tracking. Mirrors the <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.TrackFeatureCancel(System.String)"/> method

            </summary>

            <param name="featureName">The name of the feature. If it is <c>null</c> or empty the request is ignored.</param>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFacade.TrackFeatureValue(System.String,System.Int64)">

            <summary>

            Tracks a value on a named feature. Mirrors the <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.TrackFeatureValue(System.String,System.Int64)"/> method

            </summary>

            <param name="featureName">The name of the feature. If it is <c>null</c> or empty the request is ignored.</param>

            <param name="value">The value to be tracked</param>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFacade.ForceSync">

            <summary>

            Force a sync for manual synchronization. Mirrors the <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.ForceSync"/> call.

            </summary>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFacade.SetInstallationInfo(System.String,System.Collections.Generic.IDictionary{System.String,System.String})">

            <summary>

            Sets the installation id for the current monitor. Mirrors the <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.SetInstallationInfo(System.String,System.Collections.Generic.IDictionary{System.String,System.String})"/> call

            </summary>

            <param name="installationID">The current installation id to assign</param>

            <param name="installationProperties">The key-value pairs for the installation properties</param>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFacade.SetInstallationInfo(System.String)">

            <summary>

            Sets the installation id for the current monitor. Mirrors the <see cref="M:EQATEC.Analytics.Monitor.IAnalyticsMonitor.SetInstallationInfo(System.String)"/> call

            </summary>

            <param name="installationID">The current installation id to assign</param>

        </member>

        <member name="P:EQATEC.Analytics.Monitor.AnalyticsMonitorFacade.Status">

            <summary>

            Get the current capabilities of the wrapped monitor

            </summary>

        </member>

        <member name="T:EQATEC.Analytics.Monitor.AnalyticsMonitorFactory">

            <summary>

            Factory for creating <see cref="T:EQATEC.Analytics.Monitor.IAnalyticsMonitor"/> instances. Call with an instance of 

            <see cref="T:EQATEC.Analytics.Monitor.AnalyticsMonitorSettings"/> to customize behavior of the constructed monitor.

            </summary>

            <remarks>While it is possible to create multiple monitors for the same product id from within

            the same application it is not encouraged as it may lead to inconsistencies in data stored on disk.</remarks>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFactory.CreateMonitor(System.String)">

             <summary>

             Create an <see cref="T:EQATEC.Analytics.Monitor.IAnalyticsMonitor"/> instance using the default settings

             </summary>

             <param name="productId">the product ID</param>

             <returns>an instance of the <see cref="T:EQATEC.Analytics.Monitor.IAnalyticsMonitor"/> interface</returns>

             <exception cref="T:System.ArgumentException">thrown if product id provided have the wrong format (guid format expected)</exception>

             <example> This sample shows how to start the Analytics monitor.

             <code>

             class MyClass 

             {

               static void Main() 

               {

                 //Creating IAnalyticsMonitor

                 IAnalyticsMonitor monitor = AnalyticsMonitorFactory.CreateMonitor("YOUR_PRODUCT_KEY_HERE");

                 //Start Analytics monitor

                 monitor.Start();

                 /*Your program here....*/

                 //Stop Analytics monitor

                 monitor.Stop();

               }

             }

             </code>

             </example>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFactory.Create(EQATEC.Analytics.Monitor.IAnalyticsMonitorSettings)">

             <summary>

             Create an <see cref="T:EQATEC.Analytics.Monitor.IAnalyticsMonitor"/> instance using the customized settings in the

             <see cref="T:EQATEC.Analytics.Monitor.AnalyticsMonitorSettings"/> instance.

             </summary>

             <param name="settings">the settings to use for constructing the instance</param>

             <returns>an instance of the <see cref="T:EQATEC.Analytics.Monitor.IAnalyticsMonitor"/> interface</returns>

             <exception cref="T:System.ArgumentNullException">thrown if the <paramref name="settings"/> is <c>null</c></exception>

             <example> This sample shows how to start the Analytics monitor.

             <code>

             class MyClass 

             {

               static void Main() 

               {

                 //Creating AnalyticsMonitorSettings

                 AnalyticsMonitorSettings settings = new AnalyticsMonitorSettings("YOUR_PRODUCT_KEY_HERE");

                 settings.TestMode = true;

                 //Creating IAnalyticsMonitor

                 IAnalyticsMonitor monitor = AnalyticsMonitorFactory.Create(settings);

                 //Start Analytics monitor

                 monitor.Start();

                 /*Your program here....*/

                 //Stop Analytics monitor

                 monitor.Stop();

               }

             }

             </code>

             </example>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFactory.CreateMonitor(EQATEC.Analytics.Monitor.IAnalyticsMonitorSettings)">

             <summary>

             Create an <see cref="T:EQATEC.Analytics.Monitor.IAnalyticsMonitor"/> instance using the customized settings in the

             <see cref="T:EQATEC.Analytics.Monitor.AnalyticsMonitorSettings"/> instance.

             </summary>

             <param name="settings">the settings to use for constructing the instance</param>

             <returns>an instance of the <see cref="T:EQATEC.Analytics.Monitor.IAnalyticsMonitor"/> interface</returns>

             <exception cref="T:System.ArgumentNullException">thrown if product the <paramref name="settings"/> is <c>null</c></exception>

             <example> This sample shows how to start the Analytics monitor.

             <code>

             class MyClass 

             {

               static void Main() 

               {

                 //Creating AnalyticsMonitorSettings

                 AnalyticsMonitorSettings settings = new AnalyticsMonitorSettings("YOUR_PRODUCT_KEY_HERE");

                 settings.TestMode = true;

                 //Creating IAnalyticsMonitor

                 IAnalyticsMonitor monitor = AnalyticsMonitorFactory.CreateMonitor(settings);

                 //Start Analytics monitor

                 monitor.Start();

                 /*Your program here....*/

                 //Stop Analytics monitor

                 monitor.Stop();

               }

             }

             </code>

             </example>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFactory.CreateStorage(System.String)">

            <summary>

            Creates an <see cref="T:EQATEC.Analytics.Monitor.IStorage"/> which stores the data in given folder. This instance can be

            used when creating the monitor instance by assigning it to the <see cref="P:EQATEC.Analytics.Monitor.AnalyticsMonitorSettings.StorageInterface"/>

            on the <see cref="T:EQATEC.Analytics.Monitor.AnalyticsMonitorSettings"/> instance.

            </summary>

            <remarks>This call will attempt to create the given folder it it does not already exists. If there are no permissions

            or if the folder specifies an invalid folder path the method will raise an exception. </remarks>

            <param name="folder">The path to the folder where the monitor should persist data.</param>

            <returns>An implementation of the <see cref="T:EQATEC.Analytics.Monitor.IStorage"/> interface for use on the file system.</returns>

            <exception cref="T:System.InvalidOperationException">If unable to locate or create the specified folder. See inner exception for details.</exception>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFactory.CreateStorage(System.String,System.String)">

            <summary>

            Creates an <see cref="T:EQATEC.Analytics.Monitor.IStorage"/> which stores the data in given folder and with the given identifier. This instance can be

            used when creating the monitor instance by assigning it to the <see cref="P:EQATEC.Analytics.Monitor.AnalyticsMonitorSettings.StorageInterface"/>

            on the <see cref="T:EQATEC.Analytics.Monitor.AnalyticsMonitorSettings"/> instance. Use this overload to handle e.g. terminal services or shared

            machines where multiple users share the same machine but you need differentiated monitoring by passing e.g. the

            user name as identifier.

            </summary>

            <remarks>This call will attempt to create the given folder it it does not already exists. If there are no permissions

            or if the folder specifies an invalid folder path the method will raise an exception. </remarks>

            <param name="folder">The path to the folder where the monitor should persist data.</param>

            <param name="identifier">The unique identifier to use for differentiating the storage.</param>

            <returns>An implementation of the <see cref="T:EQATEC.Analytics.Monitor.IStorage"/> interface for use on the file system.</returns>

            <exception cref="T:System.InvalidOperationException">If unable to locate or create the specified folder. See inner exception for details.</exception>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFactory.CreateStorage(System.IO.IsolatedStorage.IsolatedStorageScope)">

            <summary>

            Creates an <see cref="T:EQATEC.Analytics.Monitor.IStorage"/> implementation that utilizes the IsolatedStorage

            to store files

            </summary>

            <param name="scope">The specific scope to utilize when determining where to store the data files</param>

            <returns>an implementation of the <see cref="T:EQATEC.Analytics.Monitor.IStorage"/> interface that utilizes the IsolatedStorage</returns>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFactory.CreateStorage">

            <summary>

            Creates an <see cref="T:EQATEC.Analytics.Monitor.IStorage"/> implementation that utilizes the IsolatedStorage

            to store files. 

            </summary>

            <returns>an implementation of the <see cref="T:EQATEC.Analytics.Monitor.IStorage"/> interface that utilizes the IsolatedStorage</returns>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFactory.CreateSettings(System.String)">

            <summary>

            Create an <see cref="T:EQATEC.Analytics.Monitor.IAnalyticsMonitorSettings"/> instance for customizing the

            creation of the <see cref="T:EQATEC.Analytics.Monitor.IAnalyticsMonitor"/>. You can customize this instance

            and pass it to the <see cref="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFactory.CreateMonitor(EQATEC.Analytics.Monitor.IAnalyticsMonitorSettings)"/> to obtain

            the customized

            </summary>

            <param name="productId">The product ID</param>

            <returns>an <see cref="T:EQATEC.Analytics.Monitor.IAnalyticsMonitorSettings"/> instance</returns>

        </member>

        <member name="M:EQATEC.Analytics.Monitor.AnalyticsMonitorFactory.CreateTraceMonitor">

            <summary>

            Creates a simple <see cref="T:EQATEC.Analytics.Monitor.ILogAnalyticsMonitor"/> implementation that logs to the standard <see cref="T:System.Diagnostics.Trace"/>

            output. You can assign this instance to the <see cref="P:EQATEC.Analytics.Monitor.AnalyticsMonitorSettings.LoggingInterface"/> property on the

            <see cref="T:EQATEC.Analytics.Monitor.AnalyticsMonitorSettings"/> instance to have the internal messages from the monitor written to the Trace output.

            </summary>

            <returns>An implementation of the <see cref="T:EQATEC.Analytics.Monitor.ILogAnalyticsMonitor"/> that log messages to <see cref="T:System.Diagnostics.Trace"/></returns>

        </member>

        <member name="T:EQATEC.Analytics.Monitor.AnalyticsMonitorStatus">

            <summary>

            Class encapsulating the current status of an <see cref="T:EQATEC.Analytics.Monitor.IAnalyticsMonitor"/> instance. 

            <remarks>Note that most of these status properties only makes sense if the monitor has been started</remarks>

            </summary>

        </member>

        <member name="P:EQATEC.Analytics.Monitor.AnalyticsMonitorStatus.Capabilities">

            <summary>

            Get the capabilities of the current analytics monitor. The <see cref="T:EQATEC.Analytics.Monitor.AnalyticsMonitorCapabilities"/> instance

            will allow callers to adjust certain call parameters to not violate the limitations

            of the current monitor.

            </summary>

            <seealso cref="T:EQATEC.Analytics.Monitor.AnalyticsMonitorCapabilities"/>

        </member>

        <member name="P:EQATEC.Analytics.Monitor.AnalyticsMonitorStatus.IsStarted">

            <summary>

            Get whether the monitor is currently started

            </summary>

        </member>

        <member name="P:EQATEC.Analytics.Monitor.AnalyticsMonitorStatus.RunTime">

            <summary>

            Get the total runtime for the monitor. Will return <see cref="F:System.TimeSpan.Zero"/> if monitor is not started.

            </summary>

        </member>

        <member name="P:EQATEC.Analytics.Monitor.AnalyticsMonitorStatus.CookieId">

            <summary>

            Get the current value of the cookie identifier for the monitor.

            <remarks>Note that this value may be <c>null</c> if the monitor is not started or if no cookie id has been assigned to this device yet.</remarks>

            </summary>

        </member>

        <member name="P:EQATEC.Analytics.Monitor.AnalyticsMonitorStatus.Connectivity">

            <summary>

            Get the current connectivity status for the monitor. This value will reflect the current internal

            status of the connectivity of the monitor to the server. 

            <remarks>Note that this status is not a snapshot of general connectivity to the server but merely 

            reflects the state of the last data delivery attempt to the server. Also note that if the monitor

            is configured to not synchronize automatically (using the <see cref="P:EQATEC.Analytics.Monitor.AnalyticsMonitorSettings.SynchronizeAutomatically"/> property)