Skip to content
Bit Quirky Round Trip
Visual Scripting

Search documentation

All topics and APIs

Close returns focus to Search.

What are you looking for?

Try a common topic or a C# feature.

Browse the reference instead

Esc closes · Tab reaches results · Enter opens the focused link

v1.0.0
Menu

Supported C#

Check which C# shapes Round Trip can show and write, which have limits, and which you still edit in C# in 0.92.2.

Roslyn, the C# compiler library, can read far more C# than a visual editor can safely change. A useful diagram needs a narrower promise: Round Trip must show the behavior with meaningful nodes and pins, then write your visual changes without hiding or changing code it does not understand.

This matrix describes package 0.92.2. “Supported” means the parser and graph model have explicit shapes for the construct; it does not mean every variation can be written. “Partial” means tested forms are represented but other forms may still need editing in C#. “Not yet” means Round Trip marks the construct rather than offering visual editing for it.

Construct Status Notes
Method entry, parameters, locals, declarations, assignment, compound assignment, and return Supported Includes ordinary imperative method bodies and multiple declarators when read. Some generated declaration shapes can still be refused when a safe statement cannot be emitted.
Calls and method groups Supported Instance and static calls, arguments, return values, and delegate method-group references have explicit nodes. An out argument is an output pin beside the return value.
Fields, properties, locals, this, and static reads or writes Supported Reads appear as GET pills; writes use SET or assignment shapes.
if, else if, and else Supported Branch arms and their conditions are represented explicitly.
for, foreach, while, and do while Supported Start with the simple From to count; the advanced C-Style view preserves general for headers instead of forcing them into a range. Includes break and continue; authored loops still need valid values and wiring.
switch statements and switch expressions Supported Includes arms, goto case, and goto default.
try, catch, filters, finally, bare rethrow, and throw Supported Handler clauses and exception flow have explicit nodes and paths.
lock scopes Supported The monitor and body have explicit nodes and connections.
using scopes Partial The scope, resource and body are visible. Visual representation alone does not establish write support for every source shape; check the Compile result before relying on a rewrite.
Literals and operators Supported Includes unary and binary operators, comparisons, casts and conversions, plus inline scalar values and explicit conversion nodes.
Conditional and null-aware expressions Supported Includes ?: and null coalescing, along with null-conditional access and related expression nodes.
Arrays and indexed access Supported Includes indexers, from-end indexes, ranges and slices. Common construction and access shapes are represented. Array construction in unsupported positions can be refused during body generation.
Tuples and deconstruction Supported Tuple construction and element access have explicit nodes, as does ordinary deconstruction. Nested deconstruction remains limited.
Struct construction and common composite literals Supported Includes tested Unity value shapes such as vectors.
String interpolation Supported Holes become inputs while format and alignment information remain intact.
nameof and common patterns Partial Covered forms for object creation and type tests have nodes; pattern shapes that cannot be represented remain marked.
LINQ, both method chains and query syntax Partial Common operators have LINQ nodes, with expression-bodied lambdas drawn through their role pins. Block-bodied lambdas fall back to call and lambda nodes. A static expression-bodied lambda can produce a gray Lambda body placeholder that blocks Compile. Edit that lambda in C#.
Async and await Partial Explicit nodes cover await, delay, WhenAll, WhenAny, await foreach, and await using in tested shapes. Other awaitable or nested callable shapes may still need editing in C#.
Unsafe, fixed, pointers, and stack allocation Partial Explicit node kinds exist for tested unsafe scopes, pointer operations, casts, sizeof, and stack allocation. Support depends on the represented shape.
Local function declaration bodies Not yet The declaration can be marked in the outer method’s diagram, but the local function’s own body is not drawn there.
Expression trees Not yet Their expression-building behavior must be edited in C#.
dynamic runtime binding Not yet Resolving members at runtime cannot yet be safely represented for visual editing.
Unknown statement or expression syntax Not yet It becomes a visible placeholder or diagnostic instead of being approximated.

Three concrete support examples

Select a screenshot to enlarge it.

A real BRANCH method shows a comparison, true and false routes, and ordinary calls.
Figure 1. Represented control flow An ordinary conditional has explicit editable nodes and connections. The flow guides teach the shape in detail.
A blue USING node routes its body through ReadLine and Log, with the reader resource wired into ReadLine.
Figure 2. A resource block to edit in C# This using scope shows its resource and body nodes. A visible construct alone does not establish that Compile can rewrite every source shape.
A gray Lambda body placeholder feeds the condition of a green Where node.
Figure 3. A lambda body placeholder The static lambda body is marked instead of being expanded into editable nodes. Edit it in C#.

Anything the parser cannot represent becomes a gray placeholder node. A method containing that placeholder refuses Compile until you fix the unsupported shape in C# and reload the diagram.

  1. Open the method and look for gray placeholder nodes or diagnostics.
  2. Select the placeholder and read the source text and reason when available.
  3. Right-click the placeholder, choose Go to source, and rewrite only that construct into a supported shape.
  4. Return to Round Trip. The diagram is rebuilt from C# when the file is saved; use the reload icon if it has not updated.
  5. Confirm the placeholder is gone before making visual edits and pressing Compile.

If the construct should stay exactly as written, keep editing that method in C#. Round Trip can still help you inspect the represented parts, but it cannot safely rewrite the whole body.

Full-size image