Syntax (Overload - Custom Format Expression): ToString(string valueString, string formatString)

Parameters (Overload):

• valueString - string - The input string to be parsed and converted.
• formatString - string - A formatting expression in the form of "Result = [expression]" that manipulates the output before returning it.

Return:string - The resulting string after parsing the input and reformatting it.

The ToString method is a powerful, type-aware parsing utility. Unlike a typical ToString function that serializes an object's current state, this method takes an external string and interprets it according to the rules of the DataType object it is called on.

This is particularly useful for data normalization and validation, as it can convert a single string representation into the canonical format for a given type.

For example, when called on an unsigned 8-bit integer type, it correctly handles overflow wrapping:

using uCalcSoftware;

var uc = new uCalc();

// The Int8u type interprets -1 as its max value (255)
var dt = uc.DataTypeOf(BuiltInType.Integer_8u);
Console.WriteLine(dt.ToString("-1")); // Output: 255

🎨 Output Formatting

Like other string-returning methods, ToString provides two primary approaches for controlling how the converted result is formatted:

1. FormatStyle Enum & Precision: Pass a FormatStyle enum (such as FormatStyle.Scientific or FormatStyle.Hex) and an optional precision integer to apply standardized numeric formatting. FormatStyle.Default will apply any global rules defined via uCalc.Format().
2. Custom Format Expressions: Pass a formatting expression (e.g., "Result = Format('{:6}', double(Result))") to manipulate the output dynamically.

See also: ToString(pointer), the overload which converts a value directly from a memory address.

ToString vs. EvalStr

It is crucial to distinguish this method from EvalStr:

• DataType.ToString(string): Parses a single literal value. It does not evaluate expressions. For example, uc.DataTypeOf("Int").ToString("1+1") would likely fail to parse "1+1" as a valid integer and return "0".
• uc.EvalStr(string): Parses and evaluates a full expression. For example, uc.EvalStr("1+1") returns "2".

⚖️ Comparative Analysis

In languages like C#, parsing is a static operation tied to a specific type (e.g., int.Parse(), bool.Parse()). This requires compile-time knowledge of the target type.

uCalc's approach is dynamic. You can hold a DataType object in a variable and call ToString on it without knowing at compile time which specific type it represents. This enables the creation of generic, powerful data validation and conversion routines that can be configured at runtime.

See also: ToString(pointer), the overload which converts a value from a memory address.