Using Attributes for Property Validation

Programmers are always looking for ways to write safer more bullet proof code. For that reason, at work it was a convention for us to use Unity’s OnValidate() callback to validate the public and serialized properties of our MonoBehaviour components. So for example we would typically write code like:

Now, generally speaking, this works great. Essentially, what the above snippet will do is log an error in the Unity console every time the a property of the Monobehaviour is updated, the code is changed (i.e. the scripts reloaded), or until, (the desired goal), the property is set using the Unity Inspector and someTransform is no longer null. This is an excellent way to be sure properties that are meant to be set in the Inspector window are kept to expected parameters (e.g. not null).

Programmers, though, are also very lazy. It wasn’t long before the nice clean assumption above turned into something more like:

Logically speaking, that works just as well and does the basically the same thing and works just as well (sans the nice output), but it wasn’t long before even that condensed version felt like too much boilerplate code to be worth writing. I wanted something which did the same thing, but was quick and easy with no boilerplate. So I turned to looking at attributes. What I really wanted was to be able to write something like what’s below and skip the OnValidate() call altogether.

After a weekend or so of mucking around, I managed to get just that and thought I’d share how here.

The Attributes

We’ll start by creating a base abstract attribute and an abstract subclass attribute that has a Validate() method and an ErrorMessage property to display if the Validate() fails.

The idea being something will call this Validate() method on the attribute, and, if it returns false, will show an error containing the attribute’s ErrorMessage.

Now we’ll create a couple concrete attribute implementations that will cover the two assertions I find myself making the most often – that a property is not null and that an array (or list) property contains x number of elements.

Our NotNull attribute will look like this:

One thing to note here is that we want to error message to be as descriptive as possible. One drawback to using attributes for validation rather than just using assertions in OnValidate() is that when we double click the error in the Unity console, we will no longer open the exact spot of the problem. We can mitigate that issue a little though with (a) a detailed error message and (b) by passing a context argument to the Debug.LogError() call – this will mean when we single click on the error message in the console, the context object will be highlighted temporarily in the editor window.

All that in mind, here is a ContainsAtLeast attribute validator:

Also, since developers are lazy, here’s a quick attribute that’s a shortcut to writing ContainsAtLeast(1):

The Editor

Next we’ll need the editor script that will actually validate our custom attributes. I won’t bother going too deeply into the code, but generally speaking what we want is an editor that will:

• Work on all Unity Objects
• If there are no fields with custom attributes, just do what a default editor will do
• If there are custom attributes on or more fields, it should validate them and display errors

To more closely replicate the replaced OnValidate() call, it should also:

• Validate all fields on script reload
• Display errors (if there are any) when any property is updated in the editor

All that in mind, here is the final editor script I wrote:

Drop that script into a folder named Editor, create a test MonoBehaviour component marking some properties with the NotNull, NotEmpty, ContainsAtLeast attribute and check it out in the inspector.

For example, Add this script to a game object named “Custom Attributes” in the scene and this is what you’ll get in the Inspector Window.

And in the Console Window:

Actually add some items to the component via the Inspector and just watch those errors disappear.

Hope this might help out.

Enjoy the holidays, all!