class Vehicle : MonoBehaviour
{
    // find components attached to the same GameObject
    [Inject]
    Rigidbody rigidbody { get; }

    // find components in child GameObjects (including self)
    [Inject.FromChildren]
    WheelCollider[] colliders { get; }

    // works well with interfaces and base/abstract types
    [Inject]
    IVehiclePilot pilot { get; }

    void OnEnable()
    {
        Debug.Log($"I have a rigidbody: {rigidbody}");
        Debug.Log($"And a couple of wheels: {colliders.Length}");
        Debug.Log($"And a pilot of type: {pilot.GetType()}");
    }
}

class Player : MonoBehaviour
{
    // get reference to singleton objects (marked with the [Register.Single] attribute)
    [Inject.Single]
    LevelManager levelManager { get; } // getter always returns active instance
    
    // get array of all active instances of given script type (marked with the [Register.All] attribute)
    [Inject.All]
    Enemy[] enemies { get; } // getter always returns current set of active objects
    
    void OnEnable()
    {
        Debug.Log($"There's the level manager: {levelManager}");
        Debug.Log($"I'm sensing some enemies lurking nearby: {enemies.Length}");

        foreach (var enemy in enemies)
            Debug.Log($"Here's one: {enemy.name}");
    }
    
    // cleanly access all (active and enabled) scripts implementing some interface
    [Inject.All]
    IPickup[] pickups { get; }
    
    void Update()
    {
        foreach (var pickup in pickups)
            if (pickup.IsInRange(transform.position))
                pickup.Activate(this);
    }
}

// indicates that we want to to be able to inject all active instances of this script using [Inject.All].
// this array is always up-to-date
// (even if you create/destroy registered object instances at runtime!)
[Register.All]
class Enemy : MonoBehaviour { /* implementation goes here */ }

// indicates that there will only ever be one instance of this script active in the game at any given time.
// properties injected with [Inject.Single] are always up-to-date
// (even if you replace your singleton instance at runtime!)
[Register.Single]
class LevelManager : MonoBehaviour { /* implementation goes here */ }

// allows us to obtain all (custom) scripts that implement this interface.
// make sure the scripts are also registered using [Register.All].
// this also works for [Register.Single] and standard inheritance (abstract/derived classes).
[Register.All]
interface IPickup
{ 
    bool IsInRange(Vector3 position);
    void Activate(Player player);
}

class Gun : MonoBehaviour
{
    // thanks to the fact that you're declaring your dependencies ahead of use,
    // your code automatically becomes more readable and maintainable
    [Inject.Single]
    BulletManager bulletManager { get; }

    // script will immediately log an error if the magazine is missing.
    // this indicates that the prefab is critically misconfigured and allows you to notice this early.
    // since the reference is immutable, we don't need to manually check this later in code.
    [Inject]
    Magazine magazine { get; } // immutable property! this is the recommended default because it
                               // promises that we're always referring to the same object
    
    // script will immediately log an error if there are no child Renderers.
    // this indicates to the developer that the prefab is critically misconfigured.
    [Inject.FromChildren]
    Renderer[] renderers { get; }

    // this component is optional. if we don't put at least one DamageModifier component
    // on the GameObject, the reference will be null (you should handle that!)
    [Inject(Optional = true)]
    DamageModifier modifier { get; }

    // no error will be thrown if the collection is empty because of (Optional = true)
    // (an injected array will never be null)
    [Inject.FromChildren(Optional = true)]
    GunMod[] mods { get; }
}

// before
class MyUglyUnreadableBugRiddenMessComponent : MonoBehaviour
{
    Rigidbody rigidbody;
    MeshRenderer[] meshRenderers;

    void Awake()
    {
        rigidbody = GetComponent<Rigidbody>();
        if (rigidbody == null)
            Debug.LogError($"No Rigidbody component attached to {name}!", this);

        meshRenderers = GetComponentsInChildren<MeshRenderer>();
        if (meshRenderers.Length == 0)
            Debug.LogError($"No child MeshRenderer components attached to {name}!", this);
    }
}

// after
class MyElegantSelfDocumentingAutoDebuggingPromotionEarningGDCWorthyComponent : MonoBehaviour
{
    [Inject]
    Rigidbody rigidbody { get; }

    [Inject.FromChildren]
    MeshRenderer[] meshRenderers { get; }
}

class Goose : MonoBehaviour
{
    // easily make references public
    [Inject.FromChildren]
    public GooseNeck Neck { get; } // immutable!

    // simply add a setter if you're planning to pluck some
    [Inject.FromChildren]
    public GooseFeather[] Feathers { get; private set; } // not mutable from outside
}

class UsabilityTricks : MonoBehaviour
{
    // easily access child transforms.
    // order of injected components is deterministic and depends on place in hierarchy.
    // (see: https://forum.unity.com/threads/getcomponentsinchildren.4582/#post-33983)
    [Inject.FromChildren]
    Transform[] childTransforms { get; }

    // components on inactive child GameObjects are omitted by default
    // (see: https://docs.unity3d.com/ScriptReference/Component.GetComponentsInChildren.html)
    [Inject.FromChildren(IncludeInactive = true)]
    Collider[] colliders { get; }

    // easily get a reference to a singleton ScriptableObject
    // (you first need to add it to preloaded assets in player settings)
    [Inject.Single]
    MyGameConfiguration gameConfig { get; }
}

class PerformanceTricks : MonoBehaviour
{
    // cache transform reference to avoid extern call overhead
    [Inject]
    new Transform transform { get; }

    // easily refer to the main camera in your scene without additional work
    // (resolves Camera.main and returns a cached reference until the camera is destroyed)
    [Inject.Single]
    Camera camera { get; }
}

class LazyTricks : MonoBehaviour
{
    // when you use "Lazy", the injection result is no longer stored in a local field in Awake().
    // instead, a non-alloc version of GetComponents is used to obtain a temp array of *current* components.
    // useful, but be careful to use the getter sparingly and never store the array anywhere
    // because it will become invalid after next call
    [Inject.FromChildren.Lazy]
    Renderer[] currentRenderers { get; }

    void ShowActiveRenderers() // always up to date
        => Debug.Log($"Number of currently active renderers: {currentRenderers.Length}");

    // because we aren't caching the components in Awake, the code won't break even when
    // we modify the transform hierarchy. hell, it even works in edit mode
    [Inject.FromParents.Lazy]
    Transform[] parentTransforms { get; }

    void WhereAmI() // always up to date
        => Debug.Log(string.Join(" -> ", parentTransforms.Select(x => x.name)));
}

// high performance update manager in <20 lines of code
sealed class UpdateManager : MonoBehaviour
{
    [Inject.All]
    TickableBase[] tickables { get; }

    void Update()
    {
        float dt = Time.deltaTime;

        foreach (var tickable in tickables)
            tickable.Tick(dt);
    }
}
[Register.All]
abstract class TickableBase : MonoBehaviour 
{ 
    public abstract void Tick(float dt); 
}

[Inject] // single (first one found) component on current GameObject
Collider collider { get; } 

[Inject] // all components on current GameObject
Collider[] allColliders { get; }

[Inject.FromChildren] // single (first one found) component on current GameObject or child GameObjects
Collider collider { get; } 

[Inject.FromChildren] // all components on current GameObject or child GameObjects
Collider[] allColliders { get; } 

[Inject.FromChildren(IncludeInactive = true)] // all components, including inactive child GameObjects
Collider[] allCollidersIncludingInactive { get; }

[Inject.FromParents] // single (first one found) component on current GameObject or parent GameObjects
Collider collider { get; } 

[Inject.FromParents] // all components on current GameObject or parent GameObjects
Collider[] allColliders { get; } 

[Register.Single] // ScriptableObject-based singleton.
                  // you need to put it in the "preloaded assets" in Project Settings 
class BulletConfig : ScriptableObject
{
    public float BulletVelocity;
}

[Register.Single] // MonoBehaviour-based singleton.
                  // you should put it in the scene or spawn it however you like
class BulletSpawner : MonoBehaviour
{
    // our BulletConfig instance is automatically available here
    [Inject.Single]
    BulletConfig bulletConfig { get; }

    public GameObject bulletPrefab;

    public void SpawnBullet(Vector3 position, Quaternion rotation, Vector3 direction)
        => Instantiate(bulletPrefab, position, rotation).GetComponent<Rigidbody>().velocity 
            = direction.normalized * bulletConfig.BulletVelocity;
}

class Gun : MonoBehaviour
{
    // our BulletSpawner instance is automatically available here
    [Inject.Single]
    BulletSpawner bulletSpawner { get; }

    // resolves Camera.main and returns a cached reference until the camera is destroyed
    [Inject.Single]
    Camera camera { get; }

    void Fire()
        => bulletSpawner.SpawnBullet(transform.position, transform.rotation, transform.forward);
}

class BulletUpdater : MonoBehaviour
{
    // this property lets you access all active bullets in the game
    [Inject.All]
    public Bullet[] allBullets { get; }

    void Update()
    {
        foreach (var bullet in allBullets)
            /* do something with bullet */
    }
}

[Register.All] // allows this class to be injected using [Inject.All]
class Bullet : MonoBehaviour { }