ParagonSubsystem

Abstract component container that manages a Dictionary<Type, IParagonComponent> collection. Provides add, get, remove, and query operations for components, and initializes all components when Initialize() is called. The sealed generic variant ParagonSubsystem<TSystem> provides type-safe ownership.

Definition

Namespace: Paragon Assembly: Paragon.dll

Abstract Base

[Serializable]
public abstract class ParagonSubsystem : ParagonObject, IEnumerable<IParagonComponent>

Inherits: ParagonObject Implements: IEnumerable<IParagonComponent>

Generic Variant

public sealed class ParagonSubsystem<TSystem> : ParagonSubsystem
    where TSystem : class, IParagonSubsystem<TSystem>

Inherits: ParagonSubsystem

Remarks

ParagonSubsystem implements the composition-over-inheritance pattern for Paragon behaviours. Instead of building complex inheritance hierarchies, behaviours can attach modular components to a subsystem.

Components are stored in a Dictionary<Type, IParagonComponent>, keyed by the component's concrete type. This means:

• Each component type can only exist once per subsystem

• Component lookup is O(1) by type

• Components are iterable via IEnumerable<IParagonComponent>

The generic variant ParagonSubsystem<TSystem> constrains the owner type using the curiously recurring template pattern (CRTP): TSystem : class, IParagonSubsystem<TSystem>. This ensures type-safe ownership — components know their owner's exact type.

Quick Lookup

Goal	How
Create a subsystem	new ParagonSubsystem<MyBehaviour>(owner)
Add a component	subsystem.AddComponent(component)
Get a component	subsystem.GetComponent<MyComponent>()
Try-get a component	subsystem.TryGetComponent<MyComponent>(out var c)
Check for component	subsystem.HasComponent<MyComponent>()
Remove a component	subsystem.RemoveComponent<MyComponent>(out var c)
Initialize all	subsystem.Initialize()
Iterate components	foreach (var c in subsystem) { ... }
Clear all components	subsystem.Clear()

Properties

Owner

The IParagonBehaviour that owns this subsystem.

public IParagonBehaviour Owner { get; }

Constructor

ParagonSubsystem (abstract base)

protected ParagonSubsystem(IParagonBehaviour owner)

Parameter	Type	Description
owner	IParagonBehaviour	The behaviour that owns this subsystem

ParagonSubsystem<TSystem>

public ParagonSubsystem(TSystem owner) : base(owner)

Parameter	Type	Description
owner	TSystem	The strongly-typed behaviour that owns this subsystem

Methods

Initialize

Initializes all components in the subsystem by calling Initialize() on each one.

public override void Initialize()

Does not call base.Initialize() from ParagonObject. The subsystem overrides Initialize() to iterate components instead of registering with the debug system. Each component's own Initialize() handles its debug registration.

AddComponent

Adds a component to the subsystem, keyed by its concrete type. Calls OnAdded() on the component.

public void AddComponent(IParagonComponent component)

Parameter	Type	Description
component	IParagonComponent	The component to add

Throws ArgumentException if a component of the same type already exists (dictionary Add behavior).

GetComponent (by Type)

Returns the component of the specified type, or null if not found.

public IParagonComponent GetComponent(Type type)

GetComponent<TComponent>

Returns the component of the specified type, or null if not found.

public TComponent GetComponent<TComponent>() where TComponent : class, IParagonComponent

TryGetComponent (by Type)

Attempts to retrieve a component by type.

public bool TryGetComponent(Type type, out IParagonComponent component)

Returns: true if the component exists.

TryGetComponent<TComponent>

Attempts to retrieve a strongly-typed component.

public bool TryGetComponent<TComponent>(out TComponent component) where TComponent : class, IParagonComponent

Returns: true if the component exists and is of the correct type.

RemoveComponent (by Type)

Removes a component by type. Calls OnRemoved() on the component.

public bool RemoveComponent(Type type, out IParagonComponent component)

Returns: true if the component was found and removed.

RemoveComponent<TComponent>

Removes a strongly-typed component. Calls OnRemoved() on the component.

public bool RemoveComponent<TComponent>(out TComponent component) where TComponent : class, IParagonComponent

Returns: true if the component was found and removed.

HasComponent (by Type)

Checks whether a component of the given type exists.

public bool HasComponent(Type type)

HasComponent<TComponent>

Checks whether a component of the given type exists.

public bool HasComponent<TComponent>() where TComponent : IParagonComponent

Clear

Removes all components from the subsystem without calling OnRemoved().

public void Clear()

Clear() does not call OnRemoved() on components. For proper lifecycle cleanup, use RemoveComponent() individually before clearing.

GetEnumerator

Enumerates all components in the subsystem.

public IEnumerator<IParagonComponent> GetEnumerator()

Common Pitfalls

One component per type The dictionary is keyed by component.GetType(). Adding two components of the same type throws ArgumentException. Use different subclass types for distinct instances.

Clear does not notify Clear() removes all components silently — OnRemoved() is not called. Use RemoveComponent() for each component if lifecycle cleanup is needed.

Initialize iterates existing components only Initialize() calls Initialize() on all components currently in the dictionary. Components added after Initialize() must be initialized individually.

Examples

Setting up a subsystem

using System;
using Paragon;

[Serializable]
public class Enemy : ParagonBehaviour, IParagonSubsystem<Enemy>
{
    public ParagonSubsystem<Enemy> Subsystem { get; private set; }

    protected override void OnEnable()
    {
        base.OnEnable();
        Subsystem = new ParagonSubsystem<Enemy>(this);
        Subsystem.AddComponent(new HealthComponent());
        Subsystem.AddComponent(new AIComponent());
        Subsystem.Initialize();
    }
}

Querying components

// Direct get (null if missing)
var health = subsystem.GetComponent<HealthComponent>();

// Safe get with null check
if (subsystem.TryGetComponent<AIComponent>(out var ai))
{
    ai.SetTarget(player);
}

// Existence check
if (subsystem.HasComponent<ShieldComponent>())
{
    // ...
}

See Also

• ParagonComponent<TBehaviour> — abstract base for components in this subsystem

• ParagonBehaviour — behaviour base that owns subsystems

• ParagonObject — base class this inherits from