Realtime Data Manipulation
Realtime Graphs & Charts
VisualBug is a simple yet powerful debugging tool. It is no reinvention of debugging but helps testing your applications at runtime. Debugger do help tracking down bugs by step-by-step walkthroughs. But what if you want to monitor your application at runtime? With VisualBug it's an easy task. Just add attributes to the members you want to monitor and VisualBug takes over. With various data types supported you can keep track of data in form of dynamic data fields you can edit at any time to manipulate data during runtime, as well as charts, smart graphs, delta indicators and even more to come.
VisualBug is made for lightweight-deployable debugging. It can be shipped with your product so end-users can re-use it. This is an essential element for moddable games and extensible applications. We ourselves integrate it deeply into our main application TKMap. If you don't want to deploy VisualBug with your application then just don't. VisualBug is being integrated in post-build. By injecting code into your application it will connect to it at runtime.
VisualBug is a completely automatized working system. With a single click it injects neccessary code into your application and launches it. You don't have to do anything except inserting Monitor-attributes where you want to monitor. Another feature is commanding. Mark methods with the Command-attribute and you can invoke it at any time via VisualBug. This way you have full control of you application. Logging can be output in VisualBug as well.
How it works
Just put a Monitor-attribute above every field, property, DependencyProperty or DebugProperty. Set the monitoring type a name and optionally the context. If no context was set, VisualBug automatically uses the parent class name. Future versions will allow to use Tokens which generate a dynamic context-name. Tokens can be used to achieve a name with incremented number per instance, a name based on the parent assembly (for classes which are instantiated once per assembly) and various more.
This system allows developers to keep coding-overhead at a minimum. The actual implementation will be done on-demand by VisualBug.
Start VisualBug, select your target assembly and VisualBug will automatically start scanning your assembly. It detects all member marked with the Monitor-attribute. Once the analysis finished, just press the Inject-button and VisualBug will inject BugSpy instantly. From now on everytime you start your target assembly, it will automatically search for VisualBug as connection-partner and connects to it, registering all monitored members in VisualBug in a matter of seconds.
Monitor and alter values Two-Way
VisualBug monitors all members in realtime. Once a value changed, it will be instantly shown inside VisualBug's Watcher. If you need to quickly change any values of your target application, just enter the new value and press enter. The value will be updated without delay.
Sort by Context
In order to keep things clean, especially when you have lots of monitored targets, you can sort by Context. Just select a context and VisualBug will only show members of that context.
Search by Name
If you have too many members in one Context, you can just type in the name of the searched member and VisualBug shows you only those who match both Context and Name.
Garbage Collector friendly
The BugSpy code is built up in a Garbage Collector friendly way. BugSpy does not block garbage collection in any way. Once the Garbage Collector collects any monitored class, BugSpy will notify VisualBug instantly. Corresponding fields get removed automatically.
VisualBug introduces a new type of dynamic property similiar to DependencyProperties. DebugProperties are field-based properties which accept every data-type. They can be set as read-only and do notify about changes. DebugProperties do, unlike DependencyProperties, not require a counter-piece like DependencyObject to store values. Moreover they are non-static and thus instance-bound.
Allows for easy-to-use implementation of instance-tracking. Using tokenized types you can easily keep an eye on multiple instances of one type inside VisualBug. Moreover it allows for fast and easy implementation of patterns like the Singleton-Pattern.
As of version 1.1 VisualBug's tracking engine BugSpy has been made extremely easy to use without injection. Only few calls are required to be done, calls are very short and most work will be done inside BugSpy to keep overhead at a minimum. Moreover the Tokenized- and Monitor-attributes are supported as well for manual usage. This makes tracking-calls even shorter.
Array data types
Multi-Instance support (Tokens)
Start Arguments for Build Automation
Logging support for NLog and Log4Net
Artificial command invocation
Artificial event invocation
Injection into satellite assemblies