Research on Number Formatting Methods in WPF Using Styles and Templates

Problem Background and Requirements Analysis

During WPF application development, there is often a need to format number displays based on dynamic precision. Specific scenarios include: 95 textboxes each bound to different numerical data, with each numerical value having independent display precision requirements. For example, the value 99.123 should display as 99.12 when precision is 2, while the value 99 should display as 99.000 when precision is 3.

Core Solution: StringFormat Binding

WPF data binding provides the StringFormat property, which is the preferred method for implementing number formatting. This property supports both standard string formats and custom string formats:

<TextBox Text="{Binding Value, StringFormat=N2}" />
<TextBox Text="{Binding Value, StringFormat={}{0:#,#.00}}" />

It is important to note that StringFormat only works when the target property is of string type. For the Content property (type object), a custom StringFormatConverter is required, with the format string passed through ConverterParameter.

Dynamic Precision Processing Solution

When formatting precision is determined dynamically at runtime, simple StringFormat cannot meet the requirements. In such cases, using MultiBinding combined with a custom IMultiValueConverter is recommended:

public class NumberFormatConverter : IMultiValueConverter
{
    public object Convert(object[] values, Type targetType, object parameter, CultureInfo culture)
    {
        if (values.Length == 2 && values[0] is double value && values[1] is int precision)
        {
            return value.ToString($"F{precision}");
        }
        return values[0];
    }
    
    public object[] ConvertBack(object value, Type[] targetTypes, object parameter, CultureInfo culture)
    {
        throw new NotImplementedException();
    }
}

Usage in XAML:

<TextBox>
    <TextBox.Text>
        <MultiBinding Converter="{StaticResource NumberFormatConverter}">
            <Binding Path="Value" />
            <Binding Path="Resolution" />
        </MultiBinding>
    </TextBox.Text>
</TextBox>

Style-Based Unified Formatting

For controls that support ContentStringFormat (such as ContentControl), unified formatting strategies can be implemented through styles:

<Style TargetType="{x:Type ContentControl}">
    <Setter Property="ContentStringFormat" 
            Value="{Binding Resolution, StringFormat=N{0}}" />
</Style>

This approach is suitable for controls like Label and Button, but unfortunately, TextBox does not support the ContentStringFormat property.

View Model Layer Formatting Solution

Another effective solution is to complete formatting work at the view model layer. This approach encapsulates formatting logic in the business logic layer, keeping XAML concise:

public string FormattedValue
{
    get
    {
        return Math.Round(_signal.DisplayValue, _signal.DisplayResolution)
               .ToString($"F{_signal.DisplayResolution}");
    }
}

Corresponding XAML binding:

<TextBox Text="{Binding FormattedValue}" />

Performance and Maintainability Considerations

When selecting formatting solutions, the following factors should be considered:

• Performance: View model layer formatting avoids runtime converter overhead
• Maintainability: StringFormat solution centralizes formatting logic in XAML
• Flexibility: Multi-value converter solution supports the most complex dynamic formatting requirements
• Consistency: Style solution ensures unified formatting style throughout the application

Practical Application Recommendations

Based on different application scenarios, the following strategies are recommended:

1. For static precision requirements, prioritize using StringFormat
2. For dynamic precision with a small number of controls, use multi-value converters
3. For large-scale applications, consider unified formatting processing in the view model layer
4. For controls supporting ContentStringFormat, use styles to implement unified formatting

By reasonably combining these technical solutions, efficient and flexible number formatting display can be achieved in WPF applications, meeting various complex business requirements.