---
title: TryGetSourceAssetGUID(ContentFileIdentity, out GUID)
product: Unity Editor
version: '7000.0'
latest_version: '7000.0'
status: This page documents version 7000.0. The latest version is 7000.0.
canonical: https://docs.unity.com/en-us/engine/7000.0/script-reference/unityeditor/contentloadeditorutility/trygetsourceassetguid
latest_url: https://docs.unity.com/en-us/engine/7000.0/script-reference/unityeditor/contentloadeditorutility/trygetsourceassetguid.md
last_updated: 2026-11-07
generated_at: 2026-11-08T06:41:56.221Z
locale: en-us
---

# TryGetSourceAssetGUID(ContentFileIdentity, out GUID)

> Gets the GUID of the asset that a content file was built from.

## Definition

* **Type:** Method
* **Namespace:** [UnityEditor](/engine/7000.0/script-reference/unityeditor.md)
* **Assembly:** UnityEditor.ContentLoadModule

## TryGetSourceAssetGUID(ContentFileIdentity, GUID)

```csharp
public static bool TryGetSourceAssetGUID(ContentFileIdentity file, out GUID guid)
```

### Parameters

**** (\[ContentFileIdentity]\(/engine/7000.0/script-reference/unity/loading/contentfileidentity)): The identity of a content file, from [LoadedContentFileInfo.Identity](/engine/7000.0/script-reference/unity/loading/loadedcontentfileinfo/identity.md).**** (GUID): The GUID of the asset, or an empty GUID when the method returns `false`.

### Returns

| Type                                                          | Description                                                                                                                                                           |
| ------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [bool](https://learn.microsoft.com/dotnet/api/system.boolean) | `true` if the file was built from an asset. Returns `false` if it holds the scripts of the build, default resources or built-in resources, or if `file` is not valid. |

### Remarks

Use this to name the entries of [ContentLoadState.Files](/engine/7000.0/script-reference/unity/loading/contentloadstate/files.md) of a state filled in the Editor. Use [AssetDatabase.GUIDToAssetPath](/engine/7000.0/script-reference/unityeditor/assetdatabase/guidtoassetpath.md) to get the current path of the asset. The GUID stays the same when the asset moves. For a state filled in a Player, look up [ContentFileIdentity.ToString](/engine/7000.0/script-reference/unity/loading/contentfileidentity/tostring.md) in the build's `ContentLayout.json` file, as [ContentDirectoryDiagnostics](/engine/7000.0/script-reference/unity/loading/contentdirectorydiagnostics.md) describes.

### Examples

```csharp
using System.Collections.Generic;
using Unity.Loading;
using UnityEditor;
using UnityEngine;

namespace BuildDocExamples
{
    // Example: find what a level loaded and did not release. Count the holds that game code keeps on
    // each content file before the level loads, and again after it unloads. A file that game code
    // holds more often afterwards is held by a Loadable that the level loaded and did not release.
    // The same asset built into two content directories has the same identity in both, so the counts
    // are kept per directory.
    public class ContentDirectoryDiagnostics_GetContentDirectoryLoadInfoExample
    {
        readonly ContentDirectoryLoadInfo m_Info = new ContentDirectoryLoadInfo();
        readonly Dictionary<(ContentDirectoryHandle, ContentFileIdentity), int> m_HoldsBeforeLevel =
            new Dictionary<(ContentDirectoryHandle, ContentFileIdentity), int>();

        public void OnBeforeLevelLoads()
        {
            m_HoldsBeforeLevel.Clear();
            foreach (ContentDirectoryHandle directory in ContentLoadManager.GetContentDirectories())
            {
                ContentDirectoryDiagnostics.GetContentDirectoryLoadInfo(directory, m_Info);
                for (int i = 0; i < m_Info.LoadState.Files.Count; i++)
                    m_HoldsBeforeLevel[(directory, m_Info.LoadState.Files[i].Identity)] = GameCodeHolds(i);
            }
        }

        public void OnAfterLevelUnloads()
        {
            foreach (ContentDirectoryHandle directory in ContentLoadManager.GetContentDirectories())
            {
                ContentDirectoryDiagnostics.GetContentDirectoryLoadInfo(directory, m_Info);
                ContentLoadState state = m_Info.LoadState;
                for (int i = 0; i < state.Files.Count; i++)
                {
                    LoadedContentFileInfo file = state.Files[i];
                    m_HoldsBeforeLevel.TryGetValue((directory, file.Identity), out int holdsBefore);
                    int notReleased = GameCodeHolds(i) - holdsBefore;
                    if (notReleased > 0)
                        Debug.LogWarning($"{notReleased} Loadable(s) not released after the level unloaded, in {NameOf(file.Identity)}");
                }
            }
        }

        // Unity holds the files of root assets for the content directory. The other holds come from game code.
        int GameCodeHolds(int fileIndex)
        {
            return m_Info.LoadState.Files[fileIndex].ReferenceCount - m_Info.RootAssetReferences[fileIndex];
        }

        // In the Editor, name the asset that the file was built from. Elsewhere, the identity is the
        // file's StableId in the ContentLayout.json file of the build that ContentDirectoryLoadInfo.BuildManifestHash names.
        static string NameOf(ContentFileIdentity file)
        {
            return ContentLoadEditorUtility.TryGetSourceAssetGUID(file, out GUID guid)
                ? AssetDatabase.GUIDToAssetPath(guid)
                : file.ToString();
        }
    }
}
```