DirectSharpDocsGitHub
On this page

Alphabetical syntax and API lookup

Search for the word or symbol you see in a program. A row identifies its role at that occurrence: language syntax, contextual grammar, a compiler-provided name, or an ordinary library API. A compositional form such as is not nothing is not one indivisible keyword. This lookup does not make every word in a clause globally reserved; the vocabulary appendix and each construct's grammar define legal contexts. Use @ to escape an identifier where required.

Capitalization does not select a different source symbol. In the API table, conventional .NET casing identifies the familiar type/method spelling, not a second keyword. A type import, an assembly reference and an optional feature declaration have separate roles.

Words and forms

Search Role Use Exact rules
#define Language form Define a typed compile-time name with = and a value 25
#define override Language form Deliberately replace an existing replaceable definition; not an implicit last-definition rule 25
#elif Language form Continue a compile-time conditional with another condition 25
#else Language form Select the remaining compile-time branch 25
#endif Language form Close a preprocessor conditional 25
#if Language form Select preprocessed source from a compile-time Boolean condition 25
#ifdef Language form Test whether a compile-time name is defined 25
#ifndef Language form Test whether a compile-time name is not defined 25
#include Language form Insert a permitted source fragment while preserving source locations and diagnosing cycles 25
#undef Language form Remove a definition under its source/configuration scope rules 25
__compiler__ Compiler context Deterministic compile-time metadata and naming inputs 26
_case_sensitive Language form Suffix on supported text/pattern predicates; not a standalone statement 16
abstract Language form Require a concrete implementation under the class/member declaration rules 9
action Language form Declare a callable operation, optionally with a logical result 8
add_handler Language form Subscribe a compatible handler to an event 19
alias Language form Bind a visible symbol to a compile-time spelling; aliasing a property does not cache its value 3
all Language form Join every required producer; also appears in distinct service grammar 17
and Language form Evaluate the right Boolean operand only when the left is true 6
another Language form Register an additional service rather than accidentally colliding with an existing identity 20
any Language form Select the first completed producer, including failure, then join; selection alone does not cancel losers 17
arguments Compiler context Select a current parameter statically; not a runtime dictionary 3
as Language form State a type or applicable binding under the enclosing declaration/expression grammar 5
ascii Language form Test the supported text against ASCII constraints 16
assembly Language form Apply attributes to the assembly through project declarations 21
async Declaration modifier Fix the asynchronous contract; explicit async actions supply their standard cancellation context 17
atomic Coordination form Short protected synchronous operation; no suspension, implicit deep copy or transaction 17
attributes Language form Attach CLR attributes at their permitted declaration targets 21
auto_import_directsharp Language form Enable or disable only the automatic DirectSharp root import 3
await Language form Explicitly observe one awaitable result/failure; does not recursively flatten nested tasks 17
block Language form Introduce an explicit lexical block without changing enclosing action return semantics 14
break Control flow Leave the innermost loop, or a named enclosing loop with break identifier; concurrent work already admitted is joined without automatic cancellation 7
call Language form Invoke a callable value under the declared delegate contract 8
calls Language form Bind a feature operation to an ordinary library/adapter member 23
Cancellation Compiler context Recognized cancellation-aware action or owned producer context; inference alone does not grant it 17
captured Language form Mark a feature operand for typed captured-expression binding 23
case Language form Define a select branch; cases do not fall through 7
catch Language form Handle a matching protected failure using its actual exception type 13
checked Language form Select checked arithmetic/conversion behavior in its permitted context 6
class Language form Declare an ordinary reference type with its stated member/access contracts 9
class kind Declaration form Reuse a class header; exposes optionally selects its type-use contract, without a runtime base class 9
clear_flag Language form Clear the selected flag bits without inventing unrelated values 11
collect Language form Supply an iteration-local result for a declared concurrent collection 17
collects Language form Declare a concurrent result collection whose publication preserves source order 17
concurrent Language form Own overlapping branches or loop bodies under a structured lifetime 17
const Language form Declare a value subject to compile-time constant restrictions 5.7
constants Language form Group type-level constants under shared visibility 5.7
constructor Language form Declare construction explicitly; not an ordinary action or an on-create hook 9
consume Acquisition loop Acquire forward-only work until completion; temporary emptiness can mean wait 15
containing Language form Test text containment under the selected comparison policy 16
context Language form Name a feature subject when an implicit dot receiver would be ambiguous 23
continue Control flow Finish the innermost iteration, or the named enclosing iteration with continue identifier; does not return from the containing action 7
conversions Language form Declare supported conversion protocols rather than ad hoc parsing syntax 4
convert Language form Request the applicable conversion contract; failures propagate 4
copy_of Copy expression Make a shallow copy using the supported concrete-type contract; referenced children remain shared 9
creates Language form Declare the effect that creates a feature current value 23
current Feature context Current adapted value within declared feature operations 23
CurrentLoop Compiler context Current loop observation metadata in its supported context 7
data Language form Declare a record-like value with its required construction and stored-state equality rules 9
decimal Language form Recognize a supported decimal text shape after is; distinct from the Decimal type name 16
declares Language form Introduce a typed runtime-bound symbol through a feature operation 23
default Value/declaration form Resolve a typed effective default, or declare one; no universal new-object rule 4
default for Default declaration Supply an external default subject to visibility, locking and ambiguity rules 4
default_wrapper_engine Project setting Select the default wrapper engine under compile-time configuration 24
description Language form Attach structured documentation metadata 21
dispose Authored cleanup Declare a synchronous cleanup route; async dispose declares the asynchronous route explicitly 14
div Language form Divide first, then convert the whole-number quotient toward zero under the numeric rules 6
else Language form Choose the unmatched conditional/select branch 7
elseif Language form Continue conditional selection with a further condition 7
end Language form Close a block; use the construct qualifier, such as end action 14
ending_with Language form Test a text suffix under the selected comparison policy 16
engine Language form Select the wrapper engine within wrapper application grammar 24
ensure Contract Check successful action exit against its logical result and captured entry values 12
enter Language form Acquire a Gate permit before its protected body; failed acquisition enters no body 17
enum Type declaration Declare named enum values with their ordinary CLR-compatible representation 11
eq_case_sensitive Language form Compare supported values with explicit case-sensitive text semantics 6
event Language form Declare an event under its delegate, accessibility and raising rules 19
exit Control flow Bare form equals break; targeted forms require a matching legal enclosing construct 7
exit for Language form Leave the nearest matching for_each loop where the targeted exit is legal 7
exposes Language form Choose the type-use contract of a class kind without creating a runtime kind type 9
expression Language form Type a captured feature expression under its target delegate/expression contract 23
extension Declaration form Declare an extension with an explicit receiver and its normal binding restrictions 22
false Language form Boolean false value 5
feature Language form Declare an optional typed adapter over existing APIs; not unrestricted code generation 23
field Compiler context Stored-property backing storage where the accessor establishes it 9
fields Language form Select supported field representation in construction/member grammar 9
finally Language form Run cleanup when leaving protected work, including return and exceptional exits 13
first Language form Select the first successful producer; request cooperative loser cancellation and still join 17
flags Type declaration Declare a flag enum with the supported bit tests and updates 11
for Contextual target The target in exit for; numeric iteration uses for_each … in range 7
for_each Loop form Visit a source or a numeric range; async enumeration performs generated waits 7
forever Language form Select the unbounded repeat form, subject to explicit control flow 7
from Language form Bind a source in extraction/acquisition or use the declared yield-from form 8
get Accessor grammar Read a declared property; field is available only where its backing-storage context is established 9
Global Compiler namespace root Start qualification at the actual CLR/global namespace root 3
goto Control flow Jump forward or backward to a mark; preserve scope, initialization, cleanup and concurrency boundaries 7
handles_event Language form Declare an event-handler relationship in the supported member context 19
has constructor Generic constraint phrase Require ordinary public parameterless construction for a declared generic parameter; no DI argument completion Generic constraints
has_flag Language form Test flag presence; parenthesized and/or conditions have distinct all/either meanings 11
has_not_flag Language form Negate the complete selected flag condition 11
if Language form Choose a statement branch or evaluate the conditional expression form 7
implements Type relationship Declare interface intent or a generic interface restriction; named blocks scope compatible same-name members 10
implicit Language form Declare only a supported implicit conversion; not a general conversion bypass 4
import Language form Add visible names to lookup; never install a missing package or load an assembly 3
in Language form Bind the visited source in for_each or its numeric range form 15
in_case_sensitive String predicate form Select the supported String-only case-sensitive membership comparison 16
inherits Type relationship Select the accessible compatible base, including an applicable generic base restriction 10
integer Language form Recognize a supported integral text shape after is; distinct from the Integer type 16
interface Type declaration Declare a fixed interface contract; implementations require explicit or scoped named intent 10
internal Language form Restrict declaration visibility to its permitted assembly/compilation scope 9
is Contextual grammar Type relationship or the start of a supported predicate; not interchangeable with value equality 4
is a Language form Test runtime type compatibility 4
is empty Language form Test the applicable empty state, distinct from general actual absence 16
is exactly Language form Test exact runtime type rather than assignable derived types 4
is faulted Language form Inspect cached lazy failure without forcing initialization 16
is in Predicate grammar Test membership; collection comparers retain their own contracts 16
is initialized Language form Inspect successful lazy initialization, including successful nothing, without forcing it 16
is not Language form Negate an applicable is predicate; not a separate equality precedence group 4
is nothing Language form Test actual absence rather than an effective default value 16
is same_as Language form Test reference identity rather than value equality 4
is whitespace Language form Test supported text whitespace under the predicate contract 16
is working Language form Inspect lazy initialization in progress without forcing it 16
iso_date Language form Recognize the selected ISO date text shape, not arbitrary culture-dependent parsing 16
key Language form Supply an exact service identity key under the service contract 20
LastAttempt Compiler context Initialized lexical attempt record; completed try/try_get updates it, including successful absence 13
LastLoop Compiler context Last completed loop observation metadata in its supported context 7
lazy Initializer form Force once on ordinary value use; cache success/absence/failure, with non-forcing state predicates 18
leave Language form End the Gate-protected region and release an acquired permit 17
let Declaration form Initialize a local; let from extracts once from a required present source 5
let_if Declaration form Conditional extraction: missing source assigns nothing to all extracted locals; failures still propagate 5
like Language form Match the supported lightweight pattern syntax 16
limit Language form Bound complete concurrent branches/iterations with a positive integer or shared Gate 17
lock default Default declaration Preserve the type default against external replacement 4
MainServiceProvider Recognized service context Main-provider fallback under the service model; not a wildcard lifetime guarantee 20
mark Control flow Declare a statement destination, without a colon or a new block 7
match Language form Use regex matching with the documented typed capture rules 16
mod Language form Compute the remainder under resolved numeric operand rules 6
namespace Language form Declare a namespace relative to root_namespace unless Global-qualified 3
needs Language form Declare an explicit dependency with constructor/storage and ownership rules 20
new Language form Construct an instance under the selected constructor and initialization contract 9
not Language form Negate a Boolean expression under the declared operator precedence 6
not_eq_case_sensitive Language form Use explicitly case-sensitive inequality 6
nothing Value form Actual absence; distinct from a type-specific effective default 4
numeric Language form Test the supported numeric text shape rather than assume a culture-specific parser 16
of Generic type grammar Supply type parameters or arguments under the applicable generic declaration/call 4
old_value_of Contract expression Capture eligible entry state once, including before body guards; not a later local snapshot 12
one of Type form Declare a selected union of permitted types under its stated constraints 11
operation Language form Declare feature-local vocabulary and explicit effects 23
or Language form Evaluate the right Boolean operand only when the left is false 6
order_by Contextual loop grammar Order loop input; distinct from the ordinary LINQ OrderBy method 7
otherwise Language form Supply a contract message/exception expression; not arbitrary alternative control flow 12
outer Language form Promote the declared local exactly one scope outward; its initializer still runs at the authored statement 5
overridable Language form Permit replacement of an eligible member in a derived type 9
override Indexer modifier Replace an inherited virtual indexer property with a compatible override 9
overrides Language form Implement an inherited overridable contract with a compatible signature 9
parsable_as Language form Test the supported parsability contract for a target type 16
preset Factory/value form Select an explicitly named preset; it does not replace the unnamed effective default 4
private Language form Restrict access to the applicable containing declaration scope 9
project Language form Declare one effective project configuration; its filename alone has no special binding power 3
properties Language form Select the supported property representation for promoted inputs 9
property Member declaration Declare a property; property [parameters] declares an indexer with get/set accessors and end property 9
protected Language form Allow access under the containing/derived-type visibility rules 9
provide Language form Compose an instance through its effective dependency contract 20
public Language form Expose a declaration subject to the accessibility of its full contract 9
raise_event Language form Invoke the declared event under its normal handler contract 19
range Contextual loop grammar Numeric range with to and optional step; not a promise of a standalone Range API 7
readonly Language form Prevent rebinding/writable-reference use, not transitive object mutation 9
remove_handler Language form Unsubscribe the supplied compatible handler from an event 19
repeat Loop form Counted/forever or post-test loop; the closing form follows its header/trailing condition 7
replaceable Language form Permit reassignment of a replaceable need; required-value checks remain and the previous value is not disposed 20
require Contract Fail-fast check at its written position; otherwise selects a message/exception expression 12
result Compiler context Logical action result used by result assignment and successful-exit checks 8
retry Language form Restart the associated try attempt explicitly; application policy must bound repetition 13
return Control flow Exit an action; inside an inline run, complete that branch after its cleanup and owned joins 8
returns Language form Declare a logical action or producer result; fixed CLR signatures still constrain implementation 8
root_namespace Language form Set the project namespace root; assembly name alone does not establish it 3
run Owned producer Invoke or execute a branch inside concurrent all/first/any; not implicit Task.Run 17
scoped Language form Select the service lifetime associated with an owned scope 20
select Language form Choose a statement branch or a scoped expression result 7
self Compiler context Select the current instance or extension receiver 3
services Language form Compose service registrations with explicit identity and lifetime 20
set Accessor grammar Implement a property write using its incoming value; restricted setter access still differs from readonly 9
set_flag Language form Set the selected flag bits 11
sets Language form Declare replacement of a feature current value from an operation result 23
singleton Language form Select the service lifetime shared through the applicable provider 20
skip Contextual loop grammar Loop shaping clause; library Skip/TrySkip have separate contracts 7
starting_with Language form Test a text prefix under the selected comparison policy 16
static Language form Declare a type-level member rather than an instance member 9
step Contextual loop grammar Explicit range increment in a numeric for_each header 7
take Contextual result/loop grammar Produce a scoped value or shape loop input; library Take/TryTake are separate APIs 14
target Language form Declare the source type adapted by a feature 23
task_of Operation/producer query Capture a fresh invocation, or query an owned result/collection producer; neither relaunches work 17
then Language form Separate a condition from its branch 7
throw Language form Raise a failure; contextual ?? throw requires actual absence 13
timeout Language form Set a supported concurrent/acquisition deadline under its separate cause policy 17
times Language form Specify counted repetition under repeat grammar 7
to Language form Separate inclusive numeric range endpoints or appear in a declared conversion form 7
toggle_flag Language form Flip the selected flag bits 11
transient Language form Select a new service instance per applicable resolution 20
true Language form Boolean true value 5
try Language form Protect an attempt in structured or blockless form and update lexical LastAttempt 13
try_get Best-effort computation Normally catchable acquisition failures become nothing; async failure needs await inside the protected work 13
tryconvert Language form Use a real safe conversion protocol, not a blanket catch around convert 4
unchecked Language form Select unchecked behavior only where the numeric contract permits it 6
until Language form Close a post-test repeat and stop scheduling when its condition is true 7
use Receiver scope Evaluate a required receiver once; does not itself acquire disposal ownership 14
use_if Receiver scope Skip the receiver body when its captured receiver is absent; does not catch failures 14
using Owned scope Acquire resources and clean up in reverse order; choose async cleanup from static contracts and context 14
value Compiler context Incoming property setter value where the accessor establishes it 9
virtual Indexer modifier Permit an indexer property to be overridden with runtime dispatch; action syntax remains overridable 9
where Contextual grammar Generic restrictions, loop/discovery filtering or a declared feature operation; ordinary LINQ Where is a library method Generic constraints, 7
while Language form Continue while a condition holds, either as a loop header or post-test repeat closer 7
with Language form Supply the declared initialization/limit/clause grammar; not a universal copy operation 9
with name: Loop clause Name a loop for break identifier and continue identifier; not an ordinary value declaration 7
wrap Language form Apply a declared wrapper engine under its deterministic asset/target rules 24
yield Language form Produce an iterator value; iterator invocation obtains the sequence rather than executing its body 8
yields Language form Declare a synchronous/asynchronous iterator element type 8

Operators and punctuation

Search Meaning Exact rules
= / <> Equality/inequality in expressions; = assigns in an assignment-statement context Operators
?? / ?? throw Evaluate a fallback or throw only for actual absence; do not force a deferred sequence Coalescing
.Name (read) Ordinary property/field reads propagate absence; reached getter failures propagate Read chains
[index] / [key] Required receiver/location access; not an automatic absent result Indexing
+ / - / * / / / div / mod Typed arithmetic; fractional / differs from quotient-first div Numeric rules
and / or / not Boolean logic; and/or short-circuit Binding
< / <= / > / >= Ordering according to resolved operand contracts Binding
.Name / name: expression Receiver-based or named-parameter callable expression under a target signature Callables
{{expression}} String interpolation; not C# escape/bracing syntax Literals
@identifier Escape a keyword spelling as an identifier; identity still ignores case Names
; Optional statement separator/terminator Statements
// / /// / /* … */ Line/documentation/nested block comments; apostrophe instead opens a String Source

Libraries and recognized API names

Search Role Contract Details
Chars / Unicode DirectSharp library names UTF-16 units and Unicode scalar helpers; neither promises grapheme indexing Reference
ConfigureAwait .NET method Opt out of continuation-context capture for that await; not UI dispatch or forced thread switching Reference
Gate DirectSharp library type Borrowed coordination permits; no reentrancy/fairness guarantee; join users before disposal Reference
IConsumable<T> DirectSharp CLR interface Forward-only acquisition and explicit completion/cancellation contract Reference
MainServiceProvider Recognized service context Main-provider fallback under the service model; not a wildcard lifetime guarantee Reference
RuleFor / NotEmpty / EmailAddress FluentValidation methods Ordinary imported validator APIs; not language statements Reference
ServiceProvider / ServiceScope / ServiceScopeFactory DirectSharp library contracts Service lookup and lifetime ownership; scopes are explicitly owned or borrowed Reference
Skip / TrySkip / TakeLast / TryTakeLast DirectSharp library methods Strict counts versus tolerant selection/remainder with documented timing and zero policies Reference
String / Integer / Decimal Type names CLR-compatible type binding, with documented effective defaults and arithmetic behavior Reference
swap Recognized exchange operation Exchange writable locations; atomic protection is automatic in concurrent bodies, not a general shared-write rule Reference
Take / TryTake DirectSharp library methods Strict deferred selection versus tolerant collected selection; counts and inclusive positions have distinct overload contracts Reference
Task.Run .NET method Explicit thread-pool scheduling; await or retain its operation using ordinary intent rules Reference

For CLR declarations and source member types, use the API catalogue. Feature effects, discovery and wrapper engine selection have a separate declaration reference.

Additional selected API names: Consumables factories, ILiveConsumable producer completion, opt-in SequenceExtensions, static Chars/Unicode exports, and ServiceNotFoundException constructors. None is a new core keyword.

Use the behavior index for surprising results, the guide to learn a construct, and the library plan for the distinction between public contracts and private compiler support. Imported APIs keep their own signatures, comparison and failure behavior.