StringName

public StringName();

Creates a distinct managed object holding an empty name. IsEmpty is true and ToString() returns an empty string. The object exists and is not null.

public StringName(string name);

Creates a managed wrapper for an interned name. Case and character sequence are preserved; no Unicode normalization is applied. Equal names can have distinct managed wrappers: compare values with == or Equals rather than ReferenceEquals. An empty string and, in the current SDK, null produce an empty name. Pass a non-null string in ordinary code.

The example returns true. Each locally created object has its own using lifetime; C# has no &"player" literal.

using System;
using Reckfell;

public static class StringNameExamples
{
    public static bool SameName()
    {
        using StringName first = "player";
        using var second = new StringName("player");
        return first == second && !ReferenceEquals(first, second)
            && first.ToString() == "player";
    }
}

public bool IsEmpty { get; }

Checks whether the native name is empty. A new StringName() and a name created from an empty string have IsEmpty == true. This does not check the managed reference: first test name is not null. It does not test for whitespace or replace resource lifetime management.

public void Dispose();

Releases the wrapper’s owned reference to the native name, unregisters the resource and suppresses finalization. The managed reference does not become null; other independently created wrappers for the same name remain valid.

Dispose an owned object exactly once, normally with using. In the current SDK, repeating Dispose() on a previously registered nonempty wrapper throws ArgumentException ("Disposable not registered"); idempotence is not guaranteed. Do not call Dispose() manually inside using or dispose borrowed names, including shared API constants. Do not use the object after disposal or leave it as a dictionary key: its native identity and hash change.

public void Dispose(bool disposing);

Low-level disposal overload. In the current implementation, both disposing values release the native name and unregister the resource. This method does not call GC.SuppressFinalize itself. Application code should use parameterless Dispose() or using; a direct call can leave finalization scheduled for an already released resource. Repeated unregistration can throw ArgumentException.

public bool Equals(in Reckfell.NativeInterop.reckfell_string_name other);

Native interop overload: compares the name’s internal identity with a valid reckfell_string_name. An empty wrapper equals an empty native name. This method neither transfers ownership nor releases the argument. Ordinary game code should use Equals(StringName).

public bool Equals(StringName? other);

Compares the interned name value with another managed wrapper. Comparison is case-sensitive; distinct wrappers of identical text are equal. null differs even from an existing empty StringName.

public override bool Equals(object? obj);

Returns true for the same reference or another StringName with the same value. This overload does not convert string to StringName: a string passed as object is not equal to the name, even with identical text.

public override int GetHashCode();

Returns a hash of the name’s internal native pointer. Equal live names have equal hashes and work as Dictionary<StringName, T> keys. Different names may share a hash. Do not persist the result or use it as a network or stable identifier: it is not a portable text hash. Disposing the object changes its hash.

public override string ToString();

Returns the name text as a managed string, preserving case and Unicode. Returns string.Empty for an empty name. Does not dispose the StringName. Obtain a string before applying System.String operations.

public static bool operator ==(in Reckfell.NativeInterop.reckfell_string_name left, StringName? right);

Native interop overload comparing internal name identities. Here a managed null equals an empty native name, unlike managed-wrapper comparison where null differs from an empty wrapper. Operand order does not change the result. Neither argument is disposed.

public static bool operator ==(StringName? left, in Reckfell.NativeInterop.reckfell_string_name right);

Native interop overload comparing internal name identities. Here a managed null equals an empty native name, unlike managed-wrapper comparison where null differs from an empty wrapper. Operand order does not change the result. Neither argument is disposed.

public static bool operator ==(StringName? left, StringName? right);

Compares the case-sensitive values of two managed wrappers. Two null references are equal; null and an existing empty wrapper differ. ReferenceEquals instead checks whether the wrappers themselves are the same object.

public static implicit operator string(StringName? from);

Calls ToString() for an existing wrapper and returns null for null. Distinguish a null reference from an empty name: an empty StringName converts to "", while an absent reference converts to null. Does not transfer ownership of the wrapper.

public static implicit operator StringName(string from);

Creates a new managed wrapper, equivalent to new StringName(from). Even when the text is already interned, the wrapper is a distinct object with its own lifetime. Use using when the conversion creates your local resource; do not dispose someone else’s shared wrapper.

public static bool operator !=(in Reckfell.NativeInterop.reckfell_string_name left, StringName? right);

Negates the corresponding ==. Native interop overload comparing internal name identities. Here a managed null equals an empty native name, unlike managed-wrapper comparison where null differs from an empty wrapper. Operand order does not change the result. Neither argument is disposed.

public static bool operator !=(StringName? left, in Reckfell.NativeInterop.reckfell_string_name right);

Negates the corresponding ==. Native interop overload comparing internal name identities. Here a managed null equals an empty native name, unlike managed-wrapper comparison where null differs from an empty wrapper. Operand order does not change the result. Neither argument is disposed.

public static bool operator !=(StringName? left, StringName? right);

Negates ==. Compares the case-sensitive values of two managed wrappers. Two null references are equal; null and an existing empty wrapper differ. ReferenceEquals instead checks whether the wrappers themselves are the same object.