# IPropertyDatabaseView

> Interface of a PropertyDatabase view.

## Definition

* **Type:** Interface
* **Namespace:** [UnityEditor.Search](/engine/6000.6/script-reference/unityeditor/search.md)
* **Assembly:** UnityEditor

```csharp
public interface IPropertyDatabaseView : IDisposable
```

## Remarks

The idea of a [PropertyDatabase](/engine/6000.6/script-reference/unityeditor/search/propertydatabase.md) view is similar to Windows' memory-mapped file views, although much simpler. Each [PropertyDatabase](/engine/6000.6/script-reference/unityeditor/search/propertydatabase.md) view has its own filestream that can access the [PropertyDatabase](/engine/6000.6/script-reference/unityeditor/search/propertydatabase.md) independently from other views. The views of a single [PropertyDatabase](/engine/6000.6/script-reference/unityeditor/search/propertydatabase.md) are synchronized, so concurrent accesses are allowed. However, for concurrent accesses to work properly each thread must have its own instance of a view.

All operations available on the [PropertyDatabase](/engine/6000.6/script-reference/unityeditor/search/propertydatabase.md) class are available on the view itself. When operating directly on the [PropertyDatabase](/engine/6000.6/script-reference/unityeditor/search/propertydatabase.md) instance, an internal view is created to handle all the synchronization. Since we are dealing with files, opening a view has a non-negligible cost. Therefore, it is recommended to open a view once, and use it as long as possible before disposing it.

```csharp
using System.Collections.Generic;
using NUnit.Framework;
using UnityEditor;
using UnityEditor.Search;
using UnityEngine;

static class Example_IPropertyDatabaseView
{
    // Where the property database will be written.
    const string propertyDatabaseFilePath = "Temp/test_ipropertydatabaseview_db";

    static PropertyDatabase propertyDatabase;

    static void InitializePropertyDatabase()
    {
        // Setup the property database. We configure it with automatic flushing so the file store
        // will be updated automatically after an update.
        propertyDatabase = new PropertyDatabase(propertyDatabaseFilePath, true);
    }

    static void ClearPropertyDatabase()
    {
        propertyDatabase.Clear();
        propertyDatabase.Dispose();
    }

    static PropertyDatabaseRecordKey GetPropertyKey(int id, IPropertyDatabaseView view)
    {
        return view.CreateRecordKey((ulong)id / 100, view.CreatePropertyHash((id % 100).ToString()));
    }

    static object LoadPropertyValue(int id, IPropertyDatabaseView view)
    {
        var recordKey = GetPropertyKey(id, view);
        if (view.TryLoad(recordKey, out object value))
            return value;

        // Fetch the value with the time consuming operation and store it for future
        // accesses.
        value = id.ToString();
        view.Store(recordKey, value);
        return value;
    }

    [MenuItem("Examples/IPropertyDatabaseView/Interface")]
    public static void RunExample()
    {
        InitializePropertyDatabase();
        if (!propertyDatabase.valid)
        {
            Debug.LogFormat(LogType.Error, LogOption.NoStacktrace, null, $"PropertyDatabase \"{propertyDatabase.filePath}\" failed to open properly.");
            return;
        }

        // Doing a change on the property database internally opens a view on the actual data,
        // which is non negligible. Therefore, it is advised to open a view once and use it as much as you
        // can.
        // Note: when doing concurrent accesses to the property database, each thread must have its own
        // view instance.
        var allValues = new Dictionary<int, object>();
        using (var view = propertyDatabase.GetView())
        {
            for (var i = 0; i < 1000; ++i)
            {
                var value = LoadPropertyValue(i, view);
                allValues.Add(i, value);
            }
        }

        // Validate everything is in the database
        using (var view = propertyDatabase.GetView())
        {
            for (var i = 0; i < 1000; ++i)
            {
                var key = GetPropertyKey(i, view);
                if (!view.TryLoad(key, out object value))
                    Assert.Fail("Record should be in the database.");
                Assert.AreEqual(i.ToString(), value);
            }
        }

        ClearPropertyDatabase();
    }
}
```

Additional Resources: [PropertyDatabase.GetView](/engine/6000.6/script-reference/unityeditor/search/propertydatabase/getview.md)

## Methods

| Method                                                                                                               | Description                                                                                                                     |
| -------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------- |
| [Clear](/engine/6000.6/script-reference/unityeditor/search/ipropertydatabaseview/clear.md)                           | Clears the entire content of the [PropertyDatabase](/engine/6000.6/script-reference/unityeditor/search/propertydatabase.md).    |
| [CreateDocumentKey](/engine/6000.6/script-reference/unityeditor/search/ipropertydatabaseview/createdocumentkey.md)   | Creates a document key from a document identifier.                                                                              |
| [CreatePropertyHash](/engine/6000.6/script-reference/unityeditor/search/ipropertydatabaseview/createpropertyhash.md) | Creates a property hash from a property path.                                                                                   |
| [CreateRecordKey](/engine/6000.6/script-reference/unityeditor/search/ipropertydatabaseview/createrecordkey.md)       | Creates a record key from a property path.                                                                                      |
| [EnumerateAll](/engine/6000.6/script-reference/unityeditor/search/ipropertydatabaseview/enumerateall.md)             | Enumerates all records stored in the [PropertyDatabase](/engine/6000.6/script-reference/unityeditor/search/propertydatabase.md) |
| [GetValueFromRecord](/engine/6000.6/script-reference/unityeditor/search/ipropertydatabaseview/getvaluefromrecord.md) | Deserialize a record value into its proper type.                                                                                |
| [Invalidate](/engine/6000.6/script-reference/unityeditor/search/ipropertydatabaseview/invalidate.md)                 | Invalidates all the properties stored for an entire document.                                                                   |
| [InvalidateMask](/engine/6000.6/script-reference/unityeditor/search/ipropertydatabaseview/invalidatemask.md)         | Invalidate all properties stored from multiple documents that match a document key mask.                                        |
| [IsPersistableType](/engine/6000.6/script-reference/unityeditor/search/ipropertydatabaseview/ispersistabletype.md)   | Returns a boolean indicating if a type can be persisted into the backing file.                                                  |
| [Store](/engine/6000.6/script-reference/unityeditor/search/ipropertydatabaseview/store.md)                           | Stores a document property.                                                                                                     |
| [Sync](/engine/6000.6/script-reference/unityeditor/search/ipropertydatabaseview/sync.md)                             | Synchronizes the views so they have access to the same content.                                                                 |
| [TryLoad](/engine/6000.6/script-reference/unityeditor/search/ipropertydatabaseview/tryload.md)                       | Loads all the properties of a document, already deseriazed into objects.                                                        |

## Inheritance

**Inherited Members:**

* [IDisposable.Dispose()](https://learn.microsoft.com/dotnet/api/system.idisposable.dispose)