Absolutely, OzCode works seamlessly with Resharper!

In fact, our team uses both simultaneously all the time while developing OzCode :)

Yes, you can use your personal license for projects at work.


Latest OzCode v2.0 Stable: 2.0.0.1029

Latest OzCode v3.0 Stable: 3.1.0.3913


OzCode v3.0 History:

  • Version 3.1.0.3913: 
      • Many small bug fixes and perf improvements, bumped version to v3.1, see blog post
      • Fixed issue where OzCode sometimes caused VS to hang with "Evaluating expression" dialog
  • Version 3.0.0.3885 (27/5/2017)
      • Added: Support for debugging IQueryables with the full power of the OzCode LINQ Debugging functionality.
      • Added: Support for debugging a partial IQueryable in case input is very long.
      • Fixed: Issues with keyboard focus where using LINQ feature caused keyboard input not to do anything, until you click back inside the code editor. 
      • Fixed: Several cases where LINQ Debugging would fail to show results in Query Comprehension style queries with multiple `from` or `join` clauses
    Version 3.0.0.3597
      • Fixed: Several cases where installing OzCode v3.0 VSIX failed.
      • Fixed: Several cases where LINQ Debugging would fail to show results
      • Fixed: Issue where "Log In" would fail when connecting through some old deprecated transparent proxy software
  • Version: 3.0.0.3494
      • Fixed: Further improved VS2017 startup performance
      • Added: Support for VS2017 RTM
  • OzCode Early Access Preview History:

    The OzCode EAP is now over. Thank you to everyone who participated!


    • Version 2.0.0.3448
      • Fixed: Issue where installing into VS2015 would only install into Administrator account
      • Fixed: Performance issue in Compare QuickAction
    • Version: 2.0.0.3230
      • Fixed: Fixed an issue with VS2017 startup performance
      • Fixed: Some cases where LINQ feature did not work
    • Version: 2.0.0.2629 (16/12/2016)
      • Fixed: LINQ feature not working properly in localized versions of VS
      • Fixed: LINQ feature not working properly in some cases where the query contained the (?.) null propogation operator
      • Fixed: LINQ feature not working properly in some cases where the query uses a mixture of Query Comprehension syntax and Fluent syntax
      • Fixed: Issue where entering one's license key did not work if only VS2017 RC is installed on the machine.
      • Improved: Perf of switching between the different operators in the LINQ feature
    • Version 2.0.0.2467 (29/11/2016)
      • Fixed: LINQ Analysis window sometimes did not render all purple lines correctly
      • Fixed: In some cases, hitting down-arrow to navigate the LINQ DataTip would navigate to the bottom of the list instead of just going to the next item
      • Fixed: IntelliSense did not work in Tracepoint Editor in Design Mode
    • Version 2.0.0.2406 (16/11/2016) - Sim Shipped with VS2017 RC
      • Supports VS2017 RC
      • Fixed New HUD Customization tab does not work well on 4k displays
      • Fixed LINQ feature some times does not play nice with FluentAssertions
      • Fixed some more reliability issues in VS2015 Update 1 with regards to MEF Component Cache failures
      • Improved Text readability in Dark Theme when using the Classic OzCode theme
    • Version 2.0.0.2259 (8/10/2016)
      • Fixed reliability issues in VS2015 Update1 where OzCode would sporadically fail to load due to MEF Component Cache failure.
      • Fixed bug where an OzCode Style affected all TextBlocks in Visual Studio, adversely affecting several other VS extensions
    • Version 2.0.0.2217 (26/9/2016)
      • Added New tab under Options which allows the user to customize the OzCode Heads Up Display UI.
      • Added "minimalistic" UI theme which makes OzCode's UI consistent with the CodeLens UI
      • Added OzCode is now installed as a VSIX extensions into VS2015, meaning you can dynamically Enable/Disable it via Tools->Extensions and Updates
      • Improved Preview thumbnail shown when hovering over a process in QuickAttach window is now more reliable and updates in real time
      • Improved ToolBar icons and all glyphs within the OzCode DataTip/QuickWatch now use CrispImages (vector images) and look sharper on a 4k display
      • Fixed When comparing the same property within different items in a collection, OzCode would display the same object twice.
      • Fixed The "Search Deeper" button is not clickable within the LINQ Analysis ToolWindow
    • Version 2.0.0.1826 (19/7/2016) - for full details, see announcement blog post
      • Added support for debugging Query Comprehension (aka "SQL-style") LINQ queries
      • Fixed many different scenarios where clicking on the LINQ numeric indicator did not do anything
      • Added When the LINQ analysis feature fails, the relevant error message appears in a pop-up
      • Improved Drastically improved the performance of the switching between the breadcrumbs in the LINQ Analysis Tool Window
    • Version 2.0.0.1594 (1/6/2016) - for full details, see announcement blog post
      • Added support for debugging LINQ queries (fluent syntax only)
      • Added ability to Export an object into a textual representation (JSON/XML/C#)
      • Added ability to Export a collection to an Excel worksheet
      • Added When using Compare on two strings, a diff viewer pops up. This can be configured to be either the Visual Studio Diff Viewer, or a 3rd party diff viewer via OzCode->Options.
      • Added You can now customize the colors used in OzCode's UI using the Visual Studio Theme Editor extension
      • Improved Greatly improved the UX of the Compare feature
      • Fixed performance issue where stepping over a Switch statement sometimes caused long delays

    Yes, the OzCode license is per developer, so you are free to install and use OzCode on multiple devices.

    Visual Studio 2010, 2012, 2013, 2015 and 2017 (including Community editions).

    Express editions are not supported.

    At the moment OzCode only works with C#.

    We plan to add support for more languages in the future.

    Investigate

    Debugging complex expressions is never easy. How do you see what was returned by a method call? What did each boolean condition evaluate to in a long convoluted if statement? Without simplifying the code or adding variables to store individual results, answering these questions is difficult. With OzCode’s powerful “Simplify” visualization, you can instantly figure out exactly what is happening in your code! When stepping over an expression, a red/green color coding will tell you exactly which expressions returned false/true, respectively. The red or green indicate the result of the entire expression.

    Simply click the Simplify button and the expression will be visualized instantly, giving you the option to drill down and see individual expression results.

    Explore History

    The nicest thing about Simplify is that you can see a historical view of your code’s execution. Each time you Step Over (F10) a line of code, a new Simplify button will appear, allowing you to look into the past! No longer will you have to restart debugging if you’ve Stepped Over too far!

    Simplify Time Travel Keyboard Shortcuts

    If you’re a keyboard person, we’ve made some useful shortcuts for you to time travel without lifting your palms: Hit + to visualize the current line and then use + to visualize the current line or + to navigate between the different lines of code.You can also hold down the key while debugging and then tap a digit ( - ) to directly pick the statement to visualize.


    Magic Glance

    Click to see a detailed demo of Click to see a detailed demo of Magic Glance


    The Magic Glance, which can be toggled by clicking the Toolbar icon (or by pressing the + + shortcut), gives you amazing insight into your code by showing you a summary of each line of code you stepped through.


    Predict the Future

    Click to see a Detailed Demo of Click to see a Detailed Demo of Predict


    Code v2.0 performs predictive analysis of code execution (or as we like to call it: Fortune telling!). In the following switch statement, OzCode is predicting the future: you can see the arrow pointing to where we’re going to go when we hit F10, and irrelevant code paths are made semi-transparent.


    Live Coding

    Predict brings a new meaning to the term “Living Coding” by giving you instant feedback on changes you make as you’re debugging, allowing you to fix silly little coding mistakes extremely quickly.


    If you’re using VS2015, Predict will even able to predict more complicated expressions, such as LINQ queries:


    OzCode currently only supports C#, and does not work with VB.NET.


    We plan to expand OzCode's capabilities to other languages in the future, and if VB.NET support is something you'd like to see, you can up-vote this request here:

    http://ozcode.userecho.com/topic/90246-add-support-for-visual-basic-net/

    Click on the OzCode menu and select Create a Dump and Open it to create a snapshot while debugging!


    All of OzCode’s major features can be disabled independently by navigating to OzCode’s Menu -> Options



    Yes, you can find a demo project at %AppData%\CodeValue Ltd\OzCode\OzCodeDemo.sln


    Conditional Breakpoints

    Click to see a detailed demo ofConditional Breakpoints


    Conditional Breakpoints can make debugging so much more productive, but without OzCode, using them feels like a chore. OzCode makes adding a Conditional Breakpoint super easy! In just a single click, OzCode will set up a Conditional Breakpoint based on a specific property value, and pre-fill the predicate for you.



    Want to add more predicates to the breakpoint? Take a shortcut! Simply hover over the relevant variable, and click the “Add Condition” button.


    When set... Break

    Click to see a detailed demo of Click to see a detailed demo of When Set...Break


    The toughest bugs to figure out are those that involve mutating state. What do you do if at some point during the program’s execution, the state of some objects becomes invalid, but you have no idea exactly when and where it got that way? While inspecting values in the debugger, when you spot a problematic property value, use the Magic Wand and choose “When Set -> Break”. The next time the property value is changed, OzCode will break into the debugger and allow you to inspect the state of the program and figure exactly how that problematic value got there in the first place! These Setter Breakpoints work on both regular properties and auto-properties, and you can even add a Setter Breakpoint on properties you don’t have the source code to!

    Yes!

    We offer active students in Academic institutions licenses at only 25$.

    Visit the following url to apply: http://www.oz-code.com/Purchase/Academic

    Click to see a detailed demo of Click to see a detailed demo of Reveal


    Objects can have many properties, but when debugging, not all of them are useful to you. You’re usually interested only in a selected few. For a Customer class, it might be the ID and Username properties, for a Point in 3D space, it might be the X, Y, and Z fields. With our “Reveal” feature, you can finally focus on the data that actually matters. Star the properties you are interested in and they will appear right next to the object. If you have, for example, a collection of Customer objects and you are mostly concerned with their first and last names, simply star the FirstName and Surname properties and immediately all the objects in the collection show these properties next to them. Your choices will be persisted across debugging session and across different Visual Studio solution files.


    Click to see a detailed demo of Click to see a detailed demo of Search


    When debugging objects and collections, you are often looking for a specific property or field, or a value held within a property or field. Unfortunately, this usually involves either a lot of clicking and scrolling, or writing custom debug-specific code. Finding items even in simple structures is not easy, not to mention doing so in a complex object graph. With our “Search” feature, this is no longer the case. Quickly and effortlessly search member names and values, no matter the size of the collection or complexity of the object graph!

    Exception Trail

    Click to see a detailed demo of Click to see a detailed demo of Exception Trail


    Without OzCode, investigating an exception is a dreary task - navigating through a trail of inner exceptions, scrolling through lengthy callstacks, and squinting through the exception’s associated data to try to make sense of the error. With OzCode, all the relevant information about the exception is presented in a handy tool-window. You can navigate through each inner-exception with a super- convenient breadcrumb control, and even launch a Google or stackoverflow search right from within Visual Studio!





    Predicting Exceptions

    OzCode’s Predict will alert you of an exception that’s about to happen. But that’s not all – if, for instance, OzCode detects an imminent NullReferenceException, you’ll see a red highlight showing exactly what expression is going to cause the exception!

    OzCode’s predictive exception analysis makes it super-easy to fix an exception before it even happens, with the powerful of Edit & Continue!

    There is currently an issue with Visual Studio 2015 that prevents our Foresee feature from working.

    We are currently working with the team at Microsoft to resolve this issue.

    OzCode’s Quick Actions offer you the most relevant actions, depending on your current context. Want to add a breakpoint to every method in the class? Trace every entry to a particular method? Quickly run forward to a particular line of code? Hit Alt+Shift+D to open up the Quick Actions menu or click the Magic Wand, and do some magic!


    When stepping through a foreach loop during a debug session, you are likely to encounter some common issues such as determining where you are in the loop and navigating to a specific item in the collection. While Visual Studio does offer ways to answer these questions, they are far from easy. With OzCode’s innovative “Foresee” feature, dealing with foreach loops is simple and intuitive. Foresee is a debug visualizer that helps you keep track of where you are in the loop at all times and allows navigation to specific items in the collection. It gives you visual representation of the collection including items already iterated over, the current item and upcoming items. Interested in a particular item in the collection? Just right click on the item and choose ‘Run to item’ and the loop will execute and then break on the desired item. No need to setup and deal with conditional break points!

    When you want to compare files, you use a diff application to spot the differences. Unfortunately, when you need to compare two objects, you have to trust your eyes and memory. With our Compare feature, you can now spend less time squinting and let OzCode Compare objects and collections with a simple click! The results are displayed in a side-by-side view that you can use to drill down deep into the structure.




    What about tracking changes in objects over time? Consider a long and complicated method which takes an instance of your class and performs various mutations on it. What has it actually changed? For a class with many members, which might also contain quite a few members themselves, finding the differences is difficult. With OzCode Compare you can now save an object’s state and later compare the object, during debugging, to its original saved state. After the function is executed, you can choose the “Compare to Snapshot” option to see the differences.


    When debugging, sometimes the information you need is not contained in the fields and properties of an object; rather, it’s a calculation or an expression that is based on your object. You might find yourself wishing you had a different set of properties just for this specific debugging session.


    For example, when you’re looking at a Player object in your game, you might like to see the distance from the nearest enemy without having to add such a property to its interface.

    With our Custom Expression feature, you can create multiple custom expressions on any object type, which will be displayed just like any other member of that type. You can even star the ones that interest you the most.


    For example, if a Customer class has a salary history among its properties, but what you really need to see in order to fix a bug is the customer’s due taxes for a certain year, simply use the “Add Custom Expression” option on the Customer variable, and write the expression that you’d like to see. The expression will be displayed as a property of the Customer class, containing the value of the expression.


    Click to see a detailed demo of Click to see a detailed demo of Trace

    When you’re debugging a tough problem, especially in debugging legacy code or a heavily multi-threaded scenario, stepping through the code to figure out what the system is doing feels like trying to juggle 12 balls in your head at once. With OzCode, when things get hairy, you can easily add dynamic logging on-the-fly at key points during the program’s execution, and then view the output using the fully featured integrated log-viewer that OzCode bakes into Visual Studio. No longer do you need to stop debugging, add logging code and then rebuild each time you want to add a simple trace!


    Simply use the “Create Tracepoint” command on the value you want to trace. A Tracepoint is just like a Breakpoint, except that instead of breaking the program’s execution, it writes a trace message.



    Then, add whatever bits of information you think might be related to the bug with the “Add To Tracepoint” button:



    Finally, watch the trace messages come into the Tracepoints Viewer:




    You can get our End User License Agreement here:


    OzCode EULA

    When debugging huge collections, use OzCode's Filter featurefeature to focus on the interesting items


    With OzCode's Quick Attach, you can bind a key to quickly Attach to Process!



    In many projects you can’t start a debugging session by just hitting F5. Instead, you have to use the “Attach to Process” option, find the correct process in the long list of processes, and finally connect to it. Later on, when you restart your debugging session, you have to do it all over again. And again. And again.


    With QuickAttach, OzCode makes the routine of attaching to a process super-fast. The QuickAttach window shows you the list of processes you attached to most recently. By clicking the Pin button, you can attach a shortcut key to that process:



    And that’s it. From now on, whenever we want to attach to ‘w3wp.exe’, we’ll just hit + + , and that’s it.


    If the process you want to attach to is not in the “Recently Attached” list, you can always search for it, and even see a preview of what its UI looks like:


    OzCode makes attaching to an IIS Application Pool super easy, by showing you exactly what web site you’re attaching to:


    Click to see a detailed demo ofFiltter Collections


    Filtering a collection in code is relatively easy and there are plenty of ways to do it. But how do you filter while debugging? For example, you have a collection of Customer objects and you’d like to filter the ones that are older than 35 years. Visual Studio’s immediate window and watch windows don’t support lambdas. With our Filter Collections feature, you can apply a filter expression to any collection. To solve the customer problem, choose the collection of customers and set its filter to: DateTime.Today.Year – [obj].Birthday.Year > 35, press Enter and see the results right away. Once a collection is filtered, all the other features work on the filtered results as well.



    Click to see a detailed demo of Show All Instances


    OzCode makes it trivial to find specific objects in memory that you want to explore. Just open “Show All Instances of Type” and you’ll be able to see every object of that type that’s currently in memory. Why is that object still in memory? Are there any objects that contain this value? OzCode’s exciting new exploration tool effortlessly and instantly answers these questions and more.



    OzCode's Trace features makes multi-threaded debugging much easier!


    You can remove OzCode by going to Control Panel Uninstall a Program and then choosing OzCode from the list.