public override void AddInterimStep(PerformanceEvent performanceEvent, string stepName)
{
if (!this.IsEnabled(EventTracingLogger.Flags.Performance, EventTracingLogger.Level.Normal))
{
return;
}
int num = (int)EventTracingLogger.EventProvider.TraceEvent(PerformanceEventParser.GetGuidForEvent(performanceEvent), 0U, (object)1, (object)(PerformanceEventParser.GetMessageForEvent(performanceEvent) + " : " + stepName));
}
public static Guid GetGuidForEvent(PerformanceEvent performanceEvent)
{
if (PerformanceEventParser.IdToMessageDictionary.ContainsKey(performanceEvent))
{
return(PerformanceEventParser.IdToGuidDictionary[performanceEvent]);
}
return(EventTracingLogger.InfoEventGuid);
}
public static void LogPerformanceEvent(PerformanceEvent performanceEvent)
{
PerformanceLogger[] loggers = PerformanceUtility.Loggers;
for (int i = 0; i < (int)loggers.Length; i++)
{
loggers[i].AddLogEvent(performanceEvent);
}
}
public override void AddEndEvent(PerformanceEvent performanceEvent, string additionalInformation)
{
if (!this.IsEnabled(EventTracingLogger.Flags.Performance, EventTracingLogger.Level.Normal))
{
return;
}
int num = (int)EventTracingLogger.EventProvider.TraceEvent(PerformanceEventParser.GetGuidForEvent(performanceEvent), 2U, (object)1, (object)(PerformanceEventParser.GetMessageForEvent(performanceEvent) + ":" + additionalInformation));
}
public static void StartPerformanceSequence(PerformanceEvent performanceEvent)
{
PerformanceLogger[] loggers = PerformanceUtility.Loggers;
for (int i = 0; i < (int)loggers.Length; i++)
{
loggers[i].AddStartEvent(performanceEvent);
}
}
public static void MarkInterimStep(PerformanceEvent performanceEvent, string stepName)
{
PerformanceLogger[] loggers = PerformanceUtility.Loggers;
for (int i = 0; i < (int)loggers.Length; i++)
{
loggers[i].AddInterimStep(performanceEvent, stepName);
}
}
public static void EndPerformanceSequence(PerformanceEvent performanceEvent, string additionalInformation)
{
PerformanceLogger[] loggers = PerformanceUtility.Loggers;
for (int i = 0; i < (int)loggers.Length; i++)
{
loggers[i].AddEndEvent(performanceEvent, additionalInformation);
}
}
public static string GetMessageForEvent(PerformanceEvent performanceEvent)
{
if (PerformanceEventParser.IdToMessageDictionary.ContainsKey(performanceEvent))
{
return(PerformanceEventParser.IdToMessageDictionary[performanceEvent]);
}
return(performanceEvent.ToString());
}
public override void AddLogEvent(PerformanceEvent performanceEvent)
{
if (!this.IsEnabled(EventTracingLogger.Flags.Performance, EventTracingLogger.Level.Normal))
{
return;
}
int num = (int)EventTracingLogger.EventProvider.TraceEvent(PerformanceEventParser.GetGuidForEvent(performanceEvent), 0U, (object)1, (object)PerformanceEventParser.GetMessageForEvent(performanceEvent));
}
public static void MeasurePerformanceUntilIdle(PerformanceEvent performanceEvent)
{
PerformanceLogger[] loggers = PerformanceUtility.Loggers;
for (int i = 0; i < (int)loggers.Length; i++)
{
loggers[i].AddStartEvent(performanceEvent);
}
PerformanceUtility.EndPerformanceSequenceOnIdle(performanceEvent);
}
public static void MeasurePerformanceUntilRender(PerformanceEvent performanceEvent, string additionalInformation)
{
PerformanceLogger[] loggers = PerformanceUtility.Loggers;
for (int i = 0; i < (int)loggers.Length; i++)
{
loggers[i].AddStartEvent(performanceEvent, additionalInformation);
}
PerformanceUtility.EndPerformanceSequenceAfterRender(performanceEvent, additionalInformation);
}
public void Track(string eventName, TimeSpan time)
{
var e = new PerformanceEvent
{
UserId = Utils.Helpers.Settings.UserId,
EventName = eventName,
Elapsed = time.TotalMilliseconds
};
performanceStore.InsertAsync(e);
}
public static void EndPerformanceSequenceAfterRender(PerformanceEvent performanceEvent, string additionalInformation)
{
if (Application.Current != null)
{
Application.Current.Dispatcher.BeginInvoke(DispatcherPriority.Loaded, new DispatcherOperationCallback((object arg) =>
{
PerformanceUtility.EndPerformanceSequence(performanceEvent, additionalInformation);
return(null);
}), null);
}
}
public static void EndPerformanceSequenceOnIdle(PerformanceEvent performanceEvent)
{
if (Application.Current != null)
{
Application.Current.Dispatcher.BeginInvoke(DispatcherPriority.ApplicationIdle, new DispatcherOperationCallback((object arg) =>
{
PerformanceUtility.EndPerformanceSequence(performanceEvent);
return(null);
}), null);
}
}
public static void StartEvent(string name)
{
var e = new PerformanceEvent()
{
EventName = name
};
e.Start();
// If we have not loaded the Cache yet, then temporary store the EventPattern.
Model.Items.Add(e);
}
public override void AddEndEvent(PerformanceEvent performanceEvent)
{
if (!this.profileOpened || !this.enabled)
{
return;
}
if (this.targetEvent != performanceEvent)
{
return;
}
try
{
OfficeProfiler.StopNow();
}
catch (DllNotFoundException ex)
{
}
}
static PerformanceEventParser()
{
if (!PathHelper.FileExists(PerformanceEventParser.EventTableLocation))
{
return;
}
XmlDocument xmlDocument = new XmlDocument();
using (XmlReader reader = XmlReader.Create(PerformanceEventParser.EventTableLocation))
xmlDocument.Load(reader);
foreach (XmlNode xmlNode in xmlDocument.ChildNodes[0])
{
string str = xmlNode.Attributes["message"].Value;
Guid guid = new Guid(xmlNode.Attributes["guid"].Value);
PerformanceEvent key = (PerformanceEvent)Enum.Parse(typeof(PerformanceEvent), xmlNode.Attributes["ID"].Value);
PerformanceEventParser.IdToMessageDictionary.Add(key, str);
PerformanceEventParser.IdToGuidDictionary.Add(key, guid);
}
}
public abstract void AddLogEvent(PerformanceEvent performanceEvent);
public override void AddLogEvent(PerformanceEvent performanceEvent)
{
}
public override void AddEndEvent(PerformanceEvent performanceEvent)
{
this.statistics[performanceEvent].Stop();
}
public override void AddInterimStep(PerformanceEvent performanceEvent, string stepName)
{
}
public PerformanceSequenceToken(PerformanceEvent performanceEvent)
{
this.performanceEvent = performanceEvent;
PerformanceUtility.StartPerformanceSequence(this.performanceEvent);
}
public static void EnableEventProfile(PerformanceEvent targetEvent)
{
PerformanceUtility.profileLogger.EnableEvent(targetEvent);
}
public static IDisposable PerformanceSequence(PerformanceEvent performanceEvent)
{
return(new PerformanceUtility.PerformanceSequenceToken(performanceEvent));
}
public override void AddEndEvent(PerformanceEvent performanceEvent, string additionalInformation)
{
this.statistics[performanceEvent].Stop();
}
public static void MeasurePerformanceUntilPipelinePostSceneUpdate(SelectionManager selectionManager, PerformanceEvent performanceEvent)
{
if (!PerformanceUtility.LoggingEnabled)
{
return;
}
PerformanceUtility.StartPerformanceSequence(performanceEvent);
EventHandler listenAndUnhookEvent = (EventHandler)null;
listenAndUnhookEvent = (EventHandler) delegate
{
PerformanceUtility.EndPerformanceSequence(performanceEvent);
selectionManager.PostSceneUpdatePhase -= listenAndUnhookEvent;
};
selectionManager.PostSceneUpdatePhase += listenAndUnhookEvent;
}
public abstract void AddStartEvent(PerformanceEvent performanceEvent);
public abstract void AddInterimStep(PerformanceEvent performanceEvent, string stepName);
public abstract void AddEndEvent(PerformanceEvent performanceEvent, string additionalInformation);
public PerformanceEventStatistics(PerformanceEvent performanceEvent)
{
this.performanceEvent = performanceEvent;
}
