ExtendedSharp.Sdk 0.1.2

ExtendedSharp (E#)

ExtendedSharp is a high-performance, token-based C# code parsing and transformation framework. It allows precise tokenization, formatting, and transformation of C# (and custom syntax) with minimal overhead. Designed for building linters, transpilers, code generators, and other developer tooling.

Performance

Features

• Fast Parsing & Transforming
  Optimized for performance: parsing takes milliseconds even for large files.

• Token-Based Architecture
  Each piece of code is tokenized into objects with metadata (line, column, type) for accurate transformation.

• Custom Token & Character Handlers
  Extend E# with your own token types or character handlers without modifying core logic.

• Flexible Code Transformation
  Use ITokenTransformer implementations to format, rewrite, or transform code efficiently.

• Indentation & Whitespace Management
  Handles indentation, spacing, and newlines automatically with support for block-level constructs ({}, etc.).

• Modular Design
  JSX or other syntax extensions can be added via separate libraries without bloating the core.

Usage

Tokenizing Code

using ExtendedSharp.Sdk;

var code = @"
public class Example {
    public void SayHello() {
        Console.WriteLine(""Hello, World!"");
    }
}";

var tokens = await CodeReader.ReadString(code);

Transforming Code

using ExtendedSharp.Sdk.CodeTransformer;

var formattedCode = Transformer.Transform(tokens);
Console.WriteLine(formattedCode);

Registering a Custom Transformer

Transformer.RegisterCustomTransformer(new MyCustomTransformer());

public class MyCustomTransformer : ITokenTransformer
{
    public bool CanTransform(Token<object> token) => token.TextualValue == "Console";

    public void Transform(Token<object> token, StringBuilder builder)
    {
        builder.Append("System.Console");
    }
}

Extending with Custom Syntax

CodeReader.RegisterCustomCharacterHandler('@', new MyAtSymbolHandler());

public class MyAtSymbolHandler : ICustomTokenCharacterHandler
{
    public bool CanHandle(ref TokenHandlerContext context)
    {
        return context.Source[context.Pointer] == '@';
    }

    public Token<object>? Handle(ref TokenHandlerContext context)
    {
        var token = new Token<object>
        {
            TextualValue = "@custom",
            Type = TokenType.Identifier,
            LineNumber = 0,
            ColumnNumber = 0,
            Index = context.PreviousTokens.Length
        };

        context.Advance(7); // advance pointer past token
        return token;
    }
}