Varneon's UdonSharp Development Practices

• Fundamentals
• Access Modifiers
• Attributes
• Namespaces
• Assembly Definitions
• Optimization
• Patterns
• Observer Pattern

Fundamentals

Access Modifiers

What Are Access Modifiers?

All types and type members in C# have an accessibility level and access modifiers are for controlling where they can be used from.

https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/access-modifiers

What Access Modifiers Should I Use?

UdonSharp 1.x supports all access modifiers for the source C# scripts to allow for better design of larger frameworks, so we can use them all just like we would with native C#.

Rule of thumb: Keep the access modifiers as strict as possible.

Common Mistakes

Creators who may be new to C# development standards often expose everything in their classes by leaving fields and methods on public, which in case of prefab distribution can lead to confusion.

public bool publicField;

[SerializeField]
private bool privateSerializedField;

Attributes

What are attributes?

Attributes are "markers" or "tags" for associating metadata with code in a declarative way. They can be used to tell the Unity Editor, C# compiler, or even our own scripts how to treat certain classes, fields, methods, and so on.

https://docs.unity3d.com/Manual/Attributes.html

Attributes are declared right before their target and are always wrapped in brackets:

using JetBrains.Annotations;
using System.Runtime.CompilerServices;
using UdonSharp;
using UnityEngine;
using UnityEngine.Serialization;
using Varneon.VUdon.Editors;
using Varneon.VUdon.Noclip.Abstract;
using Varneon.VUdon.Noclip.Enums;
using VRC.SDKBase;
using VRC.Udon.Common;

[assembly: InternalsVisibleTo("Varneon.VUdon.Noclip.Editor")]

namespace Varneon.VUdon.Noclip
{
    [SelectionBase]
    [DefaultExecutionOrder(-1000000000)]
    [AddComponentMenu("VUdon/Noclip")]
    [DisallowMultipleComponent]
    [HelpURL("https://github.com/Varneon/VUdon-Noclip/wiki/Settings")]
    [UdonBehaviourSyncMode(BehaviourSyncMode.None)]
    public partial class Noclip : UdonSharpBehaviour
    {
        [FoldoutHeader("Options", "Options that can be edited before build and in-game")]
        [SerializeField]
        [Tooltip("Method for triggering the noclip mode")]
        private NoclipTriggerMethod noclipTriggerMethod = NoclipTriggerMethod.DoubleJump;

        [SerializeField]
        [FieldLabel("Toggle Threshold (s)")]
        [Tooltip("Time in which jump has to be double tapped in order to toggle noclip")]
        [FieldRange(0.1f, 1f)]
        private float toggleThreshold = 0.25f;

        [SerializeField]
        [FieldLabel("Speed (m/s)")]
        [Tooltip("Maximum speed in m/s")]
        [Min(1f)]
        [FormerlySerializedAs("velocity")]
        private float speed = 15f;

        [PublicAPI("Sets noclip enabled")]
        public void _SetNoclipEnabled(bool enabled)
        {
            SetNoclipEnabled(enabled);
        }

#if UNITY_EDITOR && !COMPILER_UDONSHARP
        [UsedImplicitly]
        [UnityEditor.Callbacks.PostProcessScene(-1)]
        private static void InitializeOnBuild() { }
#endif
    }
}

What attributes should I know about?

There are several quality of life attributes that everyone should know and use, and here are most of them:

Field Attributes

These attributes can be used on fields, primarily to alter their appearance in the inspector.

Class Attributes

These attributes can be used on classes.

Method Attributes

These attributes can be used on methods.

Common Attributes

Other Attributes

These attributes don't fall into the categories above, but are extremely useful and commonly used.

[InternalsVisibleTo]

This attribute allows you to make your Runtime assembly's internal members visible to the Editor assembly.

Example of this attribute being used: Udonity's AssemblyInfo.cs

1. Create a new C# file called `AssemblyInfo.cs` into your Runtime folder
2. Add the following content inside the file: 

   using System.Runtime.CompilerServices;
   [assembly: InternalsVisibleTo("YOUR_EDITOR_ASSEMBLY_NAME_HERE")]

[CreateAssetMenu]

Mark a ScriptableObject-derived type to be automatically listed in the Assets/Create submenu.

Learn more about ScriptableObjects here.

// menuName: Path to the menu item
// fileName: Default name of the new file
// order: Priority of the menu item (100 is often reasonble)
[CreateAssetMenu(menuName = "VUdon - Vehicles/Data Presets/Car Spec Sheet", fileName = "NewCarSpecSheet.asset", order = 100)]
public class CarSpecSheet : ScriptableObject { }

[InspectorName]

Use this attribute on enum value declarations to change the display name shown in the Inspector.

public enum ColorDisplayMode
{
    [InspectorName("RGB 0-255")]
    RGB255,

    [InspectorName("RGB 0-1.0")]
    RGB1,

    HSV
}

Namespaces

What are namespaces?

Namespaces are a fundamental feature in C# and are used to control the scope of your projects.

When developing anything with UdonSharp, declaring your own namespaces should be one of the first steps of your development process.

If a creator doesn't declare their own namespace for their UdonSharpBehaviours, all of their classes will be exposed to the entire project by default and may cause misunderstandings and confusion, especially amongst beginners.

https://docs.microsoft.com/en-us/dotnet/csharp/fundamentals/types/namespaces

How to declare a namespace in UdonSharp?

In order to declare your own namespace for a project, all you have to do is encapsulate your class in curly brackets, lead by the namespace keyword and your desired namespace.

namespace Varneon.ExamplePrefab
{
	public class ExampleClass : UdonSharpBehaviour
    {
    
    }
}

It is highly recommended to always have the first element of the namespace be your own name (or brand, if you have one).

DO NOT use anyone else's name for the namespace unless you are working on the project for them!

How to access classes in other namespace?

In order to access classes in other namespaces, all you have to do is use the using keyword to extend the scope of your project to that other namespace

using Varneon.ExamplePrefab;

namespace Varneon.OtherExamplePrefab
{
	public class OtherExampleClass : UdonSharpBehaviour
    {
    	private ExampleClass exampleClass;
    }
}

Usage of namespaces makes it clear who is the developer of the project and makes it often easier to find specific project's scope

TLDR - Why use namespaces?

• Define clear scope for your project
• Prevent classes and enums from leaking to the default project scope
  

Assembly Definitions

Assembly Definitions can be overwhelming for beginners, but should be essential knowledge for developers of widely used prefabs made with UdonSharp.

I have just released a new Unity Editor extension for automating assembly definition generation: Experimental Automatic Assembly Definition Generator by Varneon | GitHub

What are assembly definitions?

Assembly Definitions and Assembly References are assets that you can create to organize your scripts into assemblies.

https://docs.unity3d.com/Manual/ScriptCompilationAssemblyDefinitionFiles.html

Why use assembly definitions?

Usage of assembly definitions promotes modularity and assists with declaring a clear scope for the dependencies

Assembly definitions support Define Constraints: only compile the assembly if specific Scripting Define Symbol is present (e.g. if you only want the assembly to compile if the symbol "UDONSHARP" is present, you can add it as a constraint)

How to use assembly definitions with U# 1.x?

U# requires a custom U# Assembly Definition to be present alongside with the main Assembly Definition when U# scripts are in said assembly

Optimization

Patterns

Observer Pattern

Since we don't have access to delegates, how can we effectively implement an observer pattern in UdonSharp?

I currently have 2 stable projects that have an observer pattern in them:

[PublicAPI]
public void AddHandler(VRCUpdateEventType eventType, IUdonEventReceiver handler)
{
  switch (eventType)
  {
    case VRCUpdateEventType.FixedUpdate:
      AddFixedUpdateHandler(handler);
      break;
    case VRCUpdateEventType.Update:
      AddUpdateHandler(handler);
      break;
    case VRCUpdateEventType.LateUpdate:
      AddLateUpdateHandler(handler);
      break;
    case VRCUpdateEventType.PostLateUpdate:
      AddPostLateUpdateHandler(handler);
      break;
  }
}

[PublicAPI]
public void RemoveHandler(VRCUpdateEventType eventType, IUdonEventReceiver handler)
{
  switch (eventType)
  {
    case VRCUpdateEventType.FixedUpdate:
      RemoveFixedUpdateHandler(handler);
      break;
    case VRCUpdateEventType.Update:
      RemoveUpdateHandler(handler);
      break;
    case VRCUpdateEventType.LateUpdate:
      RemoveLateUpdateHandler(handler);
      break;
    case VRCUpdateEventType.PostLateUpdate:
      RemovePostLateUpdateHandler(handler);
      break;
  }
}

[PublicAPI]
public void AddFixedUpdateHandler(IUdonEventReceiver handler)
{
  hasFixedUpdateHandlers = (fixedUpdateHandlerCount = (fixedUpdateHandlers = fixedUpdateHandlers.AddUnique(handler)).Length) > 0;
}

[PublicAPI]
public void RemoveFixedUpdateHandler(IUdonEventReceiver handler)
{
  if (fixedUpdateHandlerCount > 0) { hasFixedUpdateHandlers = (fixedUpdateHandlerCount = (fixedUpdateHandlers = fixedUpdateHandlers.Remove(handler)).Length) > 0; }
}

private const string
	FixedUpdateHandlerName = "_FixedUpdateHandler",
	UpdateHandlerName = "_UpdateHandler",
	LateUpdateHandlerName = "_LateUpdateHandler",
	PostLateUpdateHandlerName = "_PostLateUpdateHandler";

private void FixedUpdate()
{
  if (hasFixedUpdateHandlers)
  {
    for (int i = 0; i < fixedUpdateHandlerCount; i++)
    {
      fixedUpdateHandlers[i].SendCustomEvent(FixedUpdateHandlerName);
    }
  }
}

private void Update()
{
  if (hasUpdateHandlers)
  {
    for (int i = 0; i < updateHandlerCount; i++)
    {
      updateHandlers[i].SendCustomEvent(UpdateHandlerName);
    }
  }
}

private void LateUpdate()
{
  if (hasLateUpdateHandlers)
  {
    for (int i = 0; i < lateUpdateHandlerCount; i++)
    {
      lateUpdateHandlers[i].SendCustomEvent(LateUpdateHandlerName);
    }
  }
}

public override void PostLateUpdate()
{
  if (hasPostLateUpdateHandlers)
  {
    for (int i = 0; i < postLateUpdateHandlerCount; i++)
    {
      postLateUpdateHandlers[i].SendCustomEvent(PostLateUpdateHandlerName);
    }
  }
}

[SerializeField, HideInInspector]
private UdonSharpBehaviour valueChangedCallbackReceiver;

[SerializeField, HideInInspector]
private string valueChangedCallbackMethod;

[SerializeField, HideInInspector]
private int fieldId = -1;

public void RegisterValueChangedCallback(UdonSharpBehaviour callbackReceiver, string methodName)
{
  valueChangedCallbackReceiver = callbackReceiver;

  valueChangedCallbackMethod = methodName;
}

public void RegisterValueChangedCallback(UdonSharpBehaviour callbackReceiver, string methodName, int id)
{
  fieldId = id;

  RegisterValueChangedCallback(callbackReceiver, methodName);
}

public void OnValueChanged()
{
  if (valueChangedCallbackReceiver != null)
  {
    if(fieldId >= 0)
    {
      valueChangedCallbackReceiver.SetProgramVariable("activeFieldId", fieldId);
    }

    valueChangedCallbackReceiver.SendCustomEvent(valueChangedCallbackMethod);
  }
}