Please stop it with the magic strings

Unity Engine
,
1

Those Q(“magic!”) have been a problem from the start. Same as with getting the serialized property in editor.

I do understand the decoupling, but some don’t like runtime errors. So it would be nice to get rid of the magic strings.

One solution might be to just auto-generate a class with properly typed variables from within the UI Builder which one can then in turn reference. Or give an option to inject the variables into a C# file. Or whatever an architect who cares can come up.

But please stop it with the magic strings. Preferrably everywhere in Unity including the Editor classes. It is possible.

2

It’s definitely possible to use next to none, if not zero, strings with UI Toolkit, at least at runtime.

I pretty much always make custom visual elements, sometimes with the [UxmlElement] if I need to use them in the builder. Then I only need to Q<T>() for it, though the amount of queries I do are generally very few as well.

You can build your UI’s to have a few of these visual elements near the root of the UI that you query, and these can act as your primary API interface to it’s functionality. Works well with UI where most of the visual elements are code generated, which is my general approach to UI Toolkit. Understandably this works better for coders than it does designers.

3

Wouldn’t you need to generate a new type for every query? What if you wanted 2 of the same type?

4

I created a workaround that allows you to assign a ButtonId enum to a custom UI element that derives from button.
Then you can at least tie everything to an enum instead of a magic string. Hope this helps.

using System;
using System.Collections.Generic;
using UnityEngine.UIElements;

[Serializable]
public enum ButtonId
{
   START = 1,
   DEMO = 2,
   TEST = 3,
}


public class CustomButton : Button
{
   public ButtonId ButtonId;

   public new class UxmlTraits : TextElement.UxmlTraits
   {
       UxmlEnumAttributeDescription<ButtonId> _buttonId = new UxmlEnumAttributeDescription<ButtonId> { name = "ButtonId" };

       public override IEnumerable<UxmlChildElementDescription> uxmlChildElementsDescription
       {
           get { yield break; }
       }

       public override void Init(VisualElement ve, IUxmlAttributes bag, CreationContext cc)
       {
           base.Init(ve, bag, cc);
           ((CustomButton)ve).ButtonId = _buttonId.GetValueFromBag(bag, cc);
       }
   }


   [UnityEngine.Scripting.Preserve]
   public new class UxmlFactory : UxmlFactory<CustomButton, UxmlTraits> { }
   public CustomButton()
   {

   }
}
5

The idea is your custom types are the API entry point to some part of your UI, so there should only ever be the need for one.

Ergo if you have a set of buttons and you want a specific one, wrap them up in a custom visual element, and use that to interface with the buttons.

Basic example:

[UxmlElement]
public sealed partial class MainMenuButtonContainer : VisualElement
{
    public MainMenuButtonContainer() : base()
    {
        StartGameButton = AddButton("start-game-button", "START GAME");
        SettingsButton = AddButton("settings-button", "SETTINGS")
        QuitGameButton = AddButton("quit-game-button", "QUIT GAME");
    }
   
    public Button StartGameButton { get; private set; }
   
    public Button SettingsButton { get; private set; }
   
    public Button QuitGameButton { get; private set; }
   
    private Button AddButton(string name, string text)
    {
        var button = new Button()
        {
            name = name,
            text = text
        };
        this.Add(button);
        return button;
    }
}

We’re operating in C# so it should be obvious that encapsulation helps with reusability.

6

I got it working completely without the need to create an additional type for every new button. You create duplicate buttons all of the same type and simply assign different Enums in the inspector instead of magic strings.
On the “view” side, you simply query for type and filter by ButtonId enum to assign. No magic strings anywhere to be found!

_testButton = root.Query<CustomButton>().Where(elem => elem.ButtonId == ButtonId.START);

9527899--1344487--cap.PNG