OzCode 3.5 EAP released with the amazing new Search

One of the most popular features in OzCode is the ability Search through objects and collections. Search has been with us since the earliest prototypes of OzCode.

The old Search was great and infinitely better than nothing at all- but, we wanted to make the experience more user friendly, feature packed and faster. We realize that developers might work with huge amounts of data. The new Search is about 8 times faster than the old Search!

Well, that is not entirely true. It is 8 times faster than the first search. In the new Search, all additional searches are instant.

To make these huge performance improvements, we had to rewrite the core functionality. I will explain more on that later. First, let’s take a look at all the new features in the new search.

New search Look & Feel

Here is OzCode’s new search window:

As we start typing,  auto-suggestions begin to appear. These are initial suggestions based on a partial search – think Google. We just want to give you feedback as soon as you type. After making the first search, suggestions will improve and cover the entire data-structure.

Let’s do a search by hitting Enter. This is the result:

Here’s what we see here:

    • Result count: Shows “Michael” was found in 3 places and currently 1st hit is selected.
    • Filter: Clicking on the Filter will show only the matches of our search.
    • Search deeper: Initially, OzCode searches through the object graph peering in only 2 levels deep  Clicking on this button starts a new search that goes 2 levels deeper each time you click it.
    • Only fields and auto-properties: When toggled, OzCode ignores regular properties and searches only fields and auto-properties.
      Consider this property for example:
public List<string> Clients
{
    get
    {
        int retries = 0;
        List<string> clients;
        while(retries < 10)
        {
            if (GetClientsFromServer(out clients))
                return clients;
            Thread.Sleep(200);
            retries++;
        }
        return null;
    }
}

Search will evaluate this property and that can slow it down considerably. By checking this button, OzCode knows to evaluate only fields and auto-properties.

public int AutoProp { get; set; }
public int _field;

If you do decide to search on regular properties, some function calls might require all threads to run. We really don’t want that to happen because it can cause timeouts or affect the application state. In that case, we turn on Only fields and auto-properties automatically.

Hit counts while typing

Sometimes, we want to know the amount of results we’ll get for a specific search. For that purpose, the new Search introduces another feature: The immediate hit count.

After the initial search, the number of hits will be displayed while typing, giving you immediate insight!

Search queries

The new search supports StartsWith queries, Camel-case separation, special character separation and complex and queries.
It doesn’t support Contains queries. It’s also case-insensitive.

Let’s take for an example the property “FullName” which equals to “David MacDonald”.

Following searches will result in a Match:

  • david
  • Dav
  • Mac
  • Donald
  • don
  • dav Mac
  • mac david

However, these searches do not result in a match:

  • avid
  • acDonald
  • onald
  • David Smith

OzCode also searches for property names and field names. The property name is “FullName” so the following searches also result in a match.

  • fullname
  • fuLL
  • name

 

Under the hood

OzCode Search works in three steps: Extraction -> Indexing -> Search

Extraction means we extract the entire object graph from the debuggee as fast as we possibly can.

For the Indexing and Search parts, OzCode now works with Lucene.NET, which is an incredibly fast search engine.
Lucene breaks all the fields and properties into terms and essentially pours everything in to a huge hash table.

Let’s take an example field “MacDonalds”. Lucene will break this field into “NGrams”, meaning:

M
Ma
Mac
MacD
MacDo

MacDonalds
D
Do
Don
Dona
Donal
Donald
Donalds

Searching any of these terms will match our field.

Once everything is stored in our big fluffy hash table, the Search part is basically instantaneous.
That means our first search will include Extraction and Indexing, but the second and third search will include only the Searcpart.

All three parts, Serialization, Indexing and Search are performed in a multi threaded manner and fully optimized for speed.


OH MY GOD I WANT THIS RIGHT NOW WHEN CAN I HAVE IT?!!?!?!?!

The Early Access Preview version is now available. It’s pretty stable and we encourage you to download and try.

Download the EAP and enjoy the new search! Here’s the link for VS2017 and here’s the version for VS2012-VS2015.

We are currently fixing minor issues and bugs and an official 3.5 OzCode version will soon be released.

Next up – we’ll take a look at what’s coming in OzCode v4, which is going to be by far our most ambitious endeavor to date.

Michael Shpilt

I am a C# .Net developer living in Israel and working in the OzCode team.
I love rock climbing, coffee and software.
You can view my blog and read some of my rants, on WPF and software in general.

  • Varun Sharma

    Excellent. Performance is my number 1 priority. Good to see that new features are added and at the same time, performance is improved as well.

  • Carsten Schütte

    The EAP build sometimes crashes when data tooltip is showing, also debugging is somewhat slower when OzCode is active. How to report such issues for the EAP build?