Access a Private GameObject in Unity

Question

Hope you bear with me, I'm a beginner! Maybe I should've paid better attention to the tutorials but they all seem to use public variables/game objects that we can then drag into using the Unity Editor. However, if I have a private Game Object, how can I reference that programatically? I have the following:

private GameObject menuCanvas;

void Start()
{
menuCanvas = GameObject.Find("menuCanvas");
menuCanvas.SetActive(false);
}

Where the menuCanvas is named such in the Unity editor. However, I usually get the following error:

"The variable menuCanvas of myScript has not been assigned."

myScript is attached to a different GameObject in the scene, but not attached to menuCanvas. What am I doing wrong? Thanks for the help!

Edit: another question - which is generally better to use?

Edit 2: Hi guys, I figured it out. I had to move some code around to the Awake() function, so it looked like this:

private GameObject menuCanvas;

void Awake()
{
menuCanvas = GameObject.Find("menuCanvas");
}

void Start()
{
menuCanvas.SetActive(false);
}

And that worked. I realized that myScript was attached to multiple objects, which would cause the menuCanvas to be set inactive more than once (but it could not be referenced inactive).

S. Tarık Çetin's answer worked just as well! Thanks for the help

Edit 3: As Jesse Williams answered, an internal definition keeps the variable hidden from the editor, but it can still be assigned via code.

Answer 1

Normally Unity serializes only public fields, to prevent confusion in inspector. But you can force Unity to serialize private fields by adding [SerializeField] before the decleration.

So this should do the trick:

[SerializeField] private GameObject menuCanvas;

Then you can assign it in inspector.

---

For the question in your edit: It is always better to use private variables unless you have a reason to do otherwise. If you want to expose something to public use, best option is to use properties.

Answer 2

If you want to have Unity serialize your data you can use the approach in S. Tarık Çetin answer and mark private members with [SerializeField].

EDIT: Actually this really exposes the variable as S. Tarık Çetin said. So you are good with this approach. But I think this was not your main concern.

What you are trying can not work that way because the command GameObject.Find(string name) finds a game object with this name and returns it (see Unity Documentation for GameObject.Find). So you have to set the name via the inspector or the "name" variable that every GameObject has.

EDIT: Not relevant anymore, but this approach gives you the ability to use properties instead of variables in the inspector. A long with a lot more like custom user interfaces (buttons etc.).

If you want to access a private variable via the inspector you have to write a separate editor class: Unity Documentation for Custom Editors.

For your example:

using UnityEngine;

public class ExampleClass : MonoBehaviour
{
     [SerializeField]
     private GameObject menuCanvas;

     public GameObject MenuCanvas
     {
         get { return menuCanvas; }
         set { menuCanvas = value; }
     }

     ...
}

And then your second class:

using UnityEngine;
using UnityEditor;

[CustomEditor(typeof(ExampleClass))]
public class ExampleClassEditor : Editor
{
    public override void OnInspectorGUI()
    {
        // render the rest of the GUI
        base.OnInspectorGUI();

        // cast the internal reference
        var obj = (ExampleClass)target;

        // create an entry in the inspector
        obj.MenuCanvas = (GameObject)EditorGUILayout.ObjectField("Menu Canvas", obj.MenuCanvas, typeof(GameObject), true);
}

The editor class has to be in a subfolder namend "Editor".

In tutorials you usually just want to get something going so this dual-class approach is dropped for just a public.

Answer 3

I may be missing the point of the question, but if scope is an issue, and you need to access the variable from another script or another scope, but don't want the inspector objects visible, you can initialize it as internal rather than public. It will behave as a public variable, but not show in the inspector.