var flag = ReadConfiguration();
if (flag)
{
//...
}
else
{
//...
}
The problem is that the flag variable is set to false but you need to check what would happen if it is set to true. Of course you can easily change the value of this variable in Visual Studio. But what would you do if this kind of code is executed dozens, hundreds... of times and every time the flag variable must be set to true? One solution is to modify a configuration, another might be to change the source code. However, all these things require an additional action. It would be much more better to tell Visual Studio to do it for us. How? In order to achieve desired effect we can utilize breakpoints and custom actions. I'll show how to do it in Visual Studio 2015.
public class Test : IProgrammableDataQuery
{
public object[] EntryQuery(object thisArg, object[] args)
{
return args;
}
public object[] ExitQuery(object returnValue)
{
return new object[] { returnValue };
}
public List<CollectedValueTuple> FormatCollectedValues(object[] results)
{
List<CollectedValueTuple> list = new List<CollectedValueTuple>();
for (int i = 0; i < results.Length; ++i)
{
list.Add(new CollectedValueTuple(
String.Format("Result{0}", i),
String.Format("'{0}'",results[i]),
"string"));
}
return list;
}
public string FormatLongDescription(object[] results)
{
try
{
StringBuilder builder = new StringBuilder();
builder.AppendFormat("Collected objects ({0}): ", results.Length);
bool flag = true;
foreach (var r in results)
{
if (!flag)
{
builder.Append(", ");
}
flag = false;
builder.AppendFormat("'{0}'", r);
}
return builder.ToString();
}
catch (Exception ex)
{
return ex.ToString();
}
}
public string FormatShortDescription(object[] results)
{
return FormatLongDescription(results);
}
public List<Location> GetAlternateLocations(object[] results)
{
return null;
}
}
Implementacja EntryQuery oraz ExitQuery jest trywialna. W żaden sposób nie modyfikuję danych wejściowych i po prostu przekazuje je dalej. FormatLongDescription wykorzystuje te dane do stworzenia opisu zdarzenia po prostu sklejając poszczególne elementy tablicy. Dla zdarzenia przeznaczonego do analizowania danych wejściowych będą to parametry aktualne, a dla zdarzenia przeznaczonego do analizowania danych wyjściowy wynik zwrócony przez metodę. FormatShortDescription po prostu wywołuje FormatLongDescription. Logika FormatCollectedValues też nie jest skomplikowana. Metoda ta po prostu zwraca dane jakie otrzymała na wejściu, dodatkowo nadając im etykiety Result0, Result1 itd.
<DiagnosticEventSpecification xmlns="urn:schemas-microsoft-com:visualstudio:tracelog" enabled="true">
<Bindings>
<Binding onReturn="false">
<ModuleSpecificationId>TestApp.exe</ModuleSpecificationId>
<TypeName>TestApp.A</TypeName>
<MethodName>Fun</MethodName>
<MethodId>TestApp.A.Fun(System.Int32):System.Void</MethodId>
<ShortDescription _locID="shortDescription.TestApp.A.Fun(System.Int32):System.Void"></ShortDescription>
<LongDescription _locID="longDescription.TestApp.A.Fun(System.Int32):System.Void"></LongDescription>
<DataQueries>
</DataQueries>
<ProgrammableDataQuery>
<ModuleName>IntelliTrace.ProgrammableDataQueries.dll</ModuleName>
<TypeName>IntelliTrace.ProgrammableDataQueries.Test</TypeName>
</ProgrammableDataQuery>
</Binding>
</Bindings>
<CategoryId>Test</CategoryId>
<SettingsName _locID="settingsName.TestApp.A.Fun(System.Int32):System.Void">Fun</SettingsName>
<SettingsDescription _locID="settingsDescription.TestApp.A.Fun(System.Int32):System.Void">Fun</SettingsDescription>
</DiagnosticEventSpecification>
Nie będę dokładnie omawiał co oznaczają poszczególne węzły XML ponieważ, ponieważ zrobiłem to we wcześniejszych postach. W skrócie, powyższe zdarzenie zostało zdefiniowane dla metody o sygnaturze void Fun(int), której należy szukać w dll'ce TestApp.exe. Jedyna nowość to użycie węzła ProgrammableDataQuery zamiast DataQueries, który nie robi nic innego jak wskazuje PDQ. Zawiera on dwa podwęzły, których znaczenia łatwo się domyśleć. ModuleName to pełna nazwa dll'ki zawierającej klasę z implementacją interfejsu IProgrammableDataQuery, a TypeName definiuje pełną nazwę tej klasy. 
<DiagnosticEventSpecification enabled="true">
<Bindings>
<Binding>
<ModuleSpecificationId>FibTest.exe</ModuleSpecificationId>
<TypeName>Utilities</TypeName>
<MethodName>Flip</MethodName>
<MethodId>Utilities.Flip(System.String):System.String</MethodId>
<ShortDescription _locID="shortDescription.Utilities.Flip">"{0}" Flip("{1}")</ShortDescription>
<LongDescription _locID="longDescription.Utilities.Flip">"{0}" Flip("{1}")</LongDescription>
<DataQueries>
<DataQuery index="-1" maxSize="100" type="String" query="" />
<DataQuery index="1" maxSize="100" type="String" query="" />
</DataQueries>
<ProgrammableDataQuery>
<ModuleName></ModuleName>
<TypeName></TypeName>
</ProgrammableDataQuery>
</Binding>
</Bindings>
...
</DiagnosticEventSpecification>
Niestety ku moje zdziwieniu to nie zadziałało. Zdarzenie zostało zarejestrowane, ale w oknie IntelliTrace Events View zamiast zobaczyć upragniony wynik otrzymałem komunikat: An error occured while fetching the data for this event. Zajrzałem, więc do wcześniej zdefiniowanych przez siebie zdarzeń i przypomniałem sobie o jednej rzeczy. Aby odwołać się do wartości zwróconej przez metodę należy ustawić atrybut onReturn.
... <Binding onReturn="true"> ...Niestety to też nie pomogło. Ponownie zajrzałem więc do wcześniej przygotowanych zdarzeń i na pierwszy rzut oka wszystko wyglądało tak samo. Po chwili zastanowienia doszedłem do wniosku, że przyczyną kłopotów może być to, że próbuję odwołać się zarówno do wartości argumentów jak i do wartości zwracanej przez metodę. Wcześniej czegoś takiego nie próbowałem. Zamiast jednego przygotowałem więc dwa zdarzenia. W jednym odczytuję wartość argumentu przekazanego do metody, a w drugim wynik zwrócony przez metodę.
...
<Binding onReturn="false">
...
<ShortDescription _locID="shortDescription.Utilities.Flip">Flip("{0}")</ShortDescription>
<LongDescription _locID="longDescription.Utilities.Flip">Flip("{0}")</LongDescription>
<DataQueries>
<DataQuery index="1" maxSize="100" type="String" query="" />
</DataQueries>
...
</Binding>
...
...
<Binding onReturn="true">
...
<ShortDescription _locID="shortDescription.Utilities.Flip">Flip returns "{0}"</ShortDescription>
<LongDescription _locID="longDescription.Utilities.Flip">Flip returns "{0}"</LongDescription>
<DataQueries>
<DataQuery index="-1" maxSize="100" type="String" query="" />
</DataQueries>
...
</Binding>
...
To zadziałało, zostały zarejestrowane dwa zdarzenia, jedno z opisem Flip("Hello"), a drugie z opisem Flip returns "olleh". Moim zdaniem to spore ograniczenie IntelliTrace, ale nie ma rady i trzeba o tym po prostu pamiętać.
... <DiagnosticEventInstrumentation enabled="false"> ...i zamieniamy na:
... <DiagnosticEventInstrumentation enabled="true"> ...
public class Fun
{
private string s = null;
public void Test(string s)
{
Test2();
}
public void Test2()
{
Console.WriteLine(s);
}
}
...
new Fun().Test("Ala ma kota");
Stawiamy pułapkę na początku metody Test oraz Test2 i uruchamiamy program. Po zatrzymaniu programu na pierwszej pułapce sprawdzamy wartość parametru s oraz prywatnej składowej klasy o tej samej nazwie. Otrzymamy taki wynik:
using (IntelliTraceFile file = new IntelliTraceFile(pathToIntelliTraceLog))
{
//Kolekcja procesów będzie miała tylko jedną pozycję
foreach (IntelliTraceProcess process in traceFile.Processes)
{
//Przetworzenie kolejnych wątków
foreach (IntelliTraceThread thread in process.Threads)
{
//Tworzymy strumień ze zdarzeniami. Każde zdarzenie odpowiada np.: wywołaniu metody
Chain chain = thread.CreateThreadChain<ThreadChain>();
EventToken eventToken = chain.FirstValidToken;
//Przetwarzamy zdarzenie po zdarzeniu
while (eventToken != chain.AfterLastToken)
{
//Pobranie zdarzenia
IntelliTraceEvent ev = chain.GetEvent(eventToken);
//To zdarzenie reprezentujące wywołanie metody
if(ev is MethodEnterEvent)
ProcessMethodEnterEvent(ev);
//To zdarzenie reprezentujące zakończenie wywołania metody
else if(ev is MethodExitEvent)
ProcessMethodExitEvent(ev);
eventToken = chain.GetNextToken(eventToken);
}
}
}
}
Powyższy kod zawiera dużo komentarzy dlatego nie powinno być trudności z jego zrozumieniem. Chciałbym zwrócić uwagę tylko na jedną rzecz. Lista zdarzeń jakie możemy obsłużyć zawiera znacznie więcej pozycji niż tylko dwie pokazane powyżej (MethodEnterEvent, MethodExitEvent). Niestety ale nie ma dobrej dokumentacji z pełną listą jaki "łańcuch zdarzeń" jakie zdarzenia udostępnia. Pozostaje droga eksperymentalna oraz przyjrzenie się projektowi iTraceReader, o którym już pisałem w poście Logi IntelliTrace bez tajemnic.
private void ProcessMethodEnterEvent(IntelliTraceEvent ev)
{
ResolvedMethodEnterEvent methodEnterEvent = new ResolvedMethodEnterEvent(CurrentProcess, ev as MethodEnterEvent);
//...
}
Klasy ResolvedMethodEnterEvent oraz ResolvedMethodExitEvent zawierają właściwość Method, która zwraca obiekt klasy ResolvedMethod. Klasa ta reprezentuje wywołaną metodę i udostępnia następujące bardzo intuicyjne właściwości:
using (IntelliTraceFile file = new IntelliTraceFile(pathToIntelliTraceLog))
{
...
}
Klasa ta ma tylko jedną interesującą właściwość o nazwie Processes. Przy jej pomocy uzyskujemy dostęp do listy procesów, dla których log zawiera jakieś zdarzenia. W praktyce lista ta będzie zawierać tylko jedną pozycję. Proces reprezentowany jest przez klasę IntelliTraceProcess, która jest bardziej interesująca. Dzięki niej możemy dowiedzieć się o modułach załadowanych do procesu (właściwość Modules), uruchomionych wątkach (właściwość Threads) czy środowisku w jakim został uruchomiony proces (właściwość SystemInformationEvent). Wątki reprezentowane są przez klasę IntelliTraceThread.
Chain chain = thread.CreateThreadChain<ThreadChain>();Teraz nie pozostaje nic innego jak odczytać i przetworzyć kolejne zdarzenia:
EventToken eventToken = chain.FirstValidToken;
while (eventToken != chain.AfterLastToken)
{
IntelliTraceEvent ev = chain.GetEvent(eventToken);
//...
eventToken = chain.GetNextToken(eventToken);
}
Klasa IntelliTraceEvent jest klasą bazową dla wszystkich typów zdarzeń, a więc aby uzyskać dokładniejsze dane należy wykonać rzutowanie na jeden z wydziedziczonych z niej typów.
namespace SmallTest
{
public class Fun
{
public void Hello(int count, string msg)
{
for (int i = 0; i < count; ++i)
Console.WriteLine(msg);
}
}
}
<ModuleSpecification Id="SmallTest">SmallTest.dll</ModuleSpecification>
<Category Id="my" _locID="category.My">My</Category>
<DiagnosticEventSpecifications>
<DiagnosticEventSpecification>
<CategoryId>my</CategoryId>
<SettingsName _locID="settingsName.Fun.Hello">Fun.Hello</SettingsName>
<SettingsDescription _locID="settingsDescription.Fun.Hello">Fun.Hello</SettingsDescription>
<Bindings>
<Binding>
<ModuleSpecificationId>SmallTest</ModuleSpecificationId>
<TypeName>SmallTest.Fun</TypeName>
<MethodName>Hello</MethodName>
<MethodId>SmallTest.Fun.Hello(System.Int32, System.String):System.Void</MethodId>
<ShortDescription _locID="shortDescription.Fun.Hello">Fun.Hello({0},{1})</ShortDescription>
<LongDescription _locID="longDescription.Fun.Hello">Fun.Hello(count={0},msg={1})</LongDescription>
<DataQueries>
<DataQuery index="1" maxSize="0" type="Int32" _locID="dataquery.Fun.Hello.count" _locAttrData="name" name="count" query="" />
<DataQuery index="2" maxSize="256" type="String" _locID="dataquery.Fun.Hello.msg" _locAttrData="name" name="msg" query=""></DataQuery>
</DataQueries>
</Binding>
</Bindings>
</DiagnosticEventSpecification>
Fun f = new Fun();
f.Hello(2, "Hello world!");
<DiagnosticEventSpecification enabled="false">
<CategoryId>console</CategoryId>
<SettingsName _locID="settingsName.Console.Write">Write (1 args)</SettingsName>
<SettingsDescription _locID="settingsDescription.Console.Write">Console Output with a String passed in.</SettingsDescription>
<Bindings>
<Binding>
<ModuleSpecificationId>mscorlib</ModuleSpecificationId>
<TypeName>System.Console</TypeName>
<MethodName>Write</MethodName>
<MethodId>System.Console.Write(System.String):System.Void</MethodId>
<ShortDescription _locID="shortDescription.Console.Write.String">{0}</ShortDescription>
<LongDescription _locID="longDescription.Console.Write">Console Output "{0}".</LongDescription>
<DataQueries>
<DataQuery index="0" maxSize="256" type="String" name="value" _locID="dataquery.Write.value" _locAttrData="name" query=""></DataQuery>
</DataQueries>
</Binding>
</Bindings>
</DiagnosticEventSpecification>
orcid.org/0000-0002-6838-2135