[WPF系列]-DataBinding 绑定计算表达式

 

 

 

 

Width="{Binding  RelativeSource={RelativeSource Self}, Path=ActualWidth,
Converter={StaticResource MathConverter},
ConverterParameter=(@VALUE-100.0)}"

 

Width="{Binding ElementName=RootWindow, Path=ActualWidth,
Converter={StaticResource MathConverter},
ConverterParameter=((@VALUE-200)*.3)}"

 

 

// Does a math equation on the bound value.
// Use @VALUE in your mathEquation as a substitute for bound value
// Operator order is parenthesis first, then Left-To-Right (no operator precedence)
public class MathConverter : IValueConverter
{
    private static readonly char[] _allOperators = new[] { ‘+‘, ‘-‘, ‘*‘, ‘/‘, ‘%‘, ‘(‘, ‘)‘ };

    private static readonly List<string> _grouping = new List<string> { "(", ")" };
    private static readonly List<string> _operators = new List<string> { "+", "-", "*", "/", "%" };

    #region IValueConverter Members

    public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
    {
        // Parse value into equation and remove spaces
        var mathEquation = parameter as string;
        mathEquation = mathEquation.Replace(" ", "");
        mathEquation = mathEquation.Replace("@VALUE", value.ToString());

        // Validate values and get list of numbers in equation
        var numbers = new List<double>();
        double tmp;

        foreach (string s in mathEquation.Split(_allOperators))
        {
            if (s != string.Empty)
            {
                if (double.TryParse(s, out tmp))
                {
                    numbers.Add(tmp);
                }
                else
                {
                    // Handle Error - Some non-numeric, operator, or grouping character found in string
                    throw new InvalidCastException();
                }
            }
        }

        // Begin parsing method
        EvaluateMathString(ref mathEquation, ref numbers, 0);

        // After parsing the numbers list should only have one value - the total
        return numbers[0];
    }

    public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
    {
        throw new NotImplementedException();
    }

    #endregion

    // Evaluates a mathematical string and keeps track of the results in a List<double> of numbers
    private void EvaluateMathString(ref string mathEquation, ref List<double> numbers, int index)
    {
        // Loop through each mathemtaical token in the equation
        string token = GetNextToken(mathEquation);

        while (token != string.Empty)
        {
            // Remove token from mathEquation
            mathEquation = mathEquation.Remove(0, token.Length);

            // If token is a grouping character, it affects program flow
            if (_grouping.Contains(token))
            {
                switch (token)
                {
                    case "(":
                        EvaluateMathString(ref mathEquation, ref numbers, index);
                        break;

                    case ")":
                        return;
                }
            }

            // If token is an operator, do requested operation
            if (_operators.Contains(token))
            {
                // If next token after operator is a parenthesis, call method recursively
                string nextToken = GetNextToken(mathEquation);
                if (nextToken == "(")
                {
                    EvaluateMathString(ref mathEquation, ref numbers, index + 1);
                }

                // Verify that enough numbers exist in the List<double> to complete the operation
                // and that the next token is either the number expected, or it was a ( meaning
                // that this was called recursively and that the number changed
                if (numbers.Count > (index + 1) &&
                    (double.Parse(nextToken) == numbers[index + 1] || nextToken == "("))
                {
                    switch (token)
                    {
                        case "+":
                            numbers[index] = numbers[index] + numbers[index + 1];
                            break;
                        case "-":
                            numbers[index] = numbers[index] - numbers[index + 1];
                            break;
                        case "*":
                            numbers[index] = numbers[index] * numbers[index + 1];
                            break;
                        case "/":
                            numbers[index] = numbers[index] / numbers[index + 1];
                            break;
                        case "%":
                            numbers[index] = numbers[index] % numbers[index + 1];
                            break;
                    }
                    numbers.RemoveAt(index + 1);
                }
                else
                {
                    // Handle Error - Next token is not the expected number
                    throw new FormatException("Next token is not the expected number");
                }
            }

            token = GetNextToken(mathEquation);
        }
    }

    // Gets the next mathematical token in the equation
    private string GetNextToken(string mathEquation)
    {
        // If we‘re at the end of the equation, return string.empty
        if (mathEquation == string.Empty)
        {
            return string.Empty;
        }

        // Get next operator or numeric value in equation and return it
        string tmp = "";
        foreach (char c in mathEquation)
        {
            if (_allOperators.Contains(c))
            {
                return (tmp == "" ? c.ToString() : tmp);
            }
            else
            {
                tmp += c;
            }
        }

        return tmp;
    }
}

 

参考

 

MathConverter - How to Do Math in XAML

the-math-converter

时间: 2024-11-03 21:42:07

[WPF系列]-DataBinding 绑定计算表达式的相关文章

WPF系列——简单绑定学习

1. 绑定到元素对象.(实际项目中用处不大) 界面上两个关联的控件之间绑定,比如一个TextBlock 的FontSize和一个Slider 的Value绑定: <Slider Name="sliderFontText" Minimum="1" Maximum="100" Value="10"/> <TextBox Name="txtValue" Width="200"

[WPF系列]-DataBinding(数据绑定)

自定义Binding A base class for custom WPF binding markup extensions BindingDecoratorBase Code: public class LookupExtension : BindingDecoratorBase { //A property that can be set in XAML public string LookupKey { get; set; } public override object Provid

DataBinding初探 数据绑定的用法 ,import 集合类型,绑定的表达式,访问集合类型2

数据绑定的用法 import语法 <data> <import type="android.view.view"/> </data> 如果类名相同,可以启用别名 <import type="android.view.view" /> <import type ="com.example.real.estate.View" alias="Vista" /> import

WPF系列之三:实现类型安全的INotifyPropertyChanged接口,可以不用“Magic string” 么?

通常实现INotifyPropertyChanged接口很简单,为你的类只实现一个PropertyChanged 的Event就可以了. 例如实现一个简单的ViewModel1类: public class ViewModel1 : INotifyPropertyChanged { private string _data; public string Data { get { return _data; } set { if (_data == value) return; _data = v

自学WPF系列(1)

介绍 使用WPF工作6个多月了,是时候写一些WPF的基础知识了.在这个主题上我已经写了几篇文章了.他们都是基于处理一些具体的问题而完成的.现在我抛砖引玉,并让您理解如何/为什么WPF作为革命性的UI开发走向了我们. 由于这是一篇适合初学者和中级水平的程序员的文章,我将尽量给出尽可能多的基本的例子. Windows Presectation Foundation 正如名字所示,WPF实际上是.NET Framework3.0引入的几个framework.它实际上是提出了一套新的类和程序集并允许我们

WPF系列之二:解耦View层控件事件与ViewModel层事件的响应

以前的做法: 1.当项目的时间比较紧迫的时候,对UI层中控件的事件的处理,往往采取的是类似Winform中最简单的做法,直接做一个事件的Handler直接去调用VM层的方法. 2.控件只有一个Command属性,其它的事件的处理方法没有办法和ViewModel层进行解耦的时候往往也采取上面提到的方法. 如下图所示: 新的做法: 为了实现事件的处理与View层的解耦,我们可以利用WPF提供的附加属性来为需要的事件添加附加行为.附加属性扮演了一个在View层与Model层牵线的角色. 需要下面三个步

12.6 实现选项的计算表达式

在 12.4 节,我们用选项值作为示例,介绍了用 LINQ 查询和 F# 计算表达式创建非标准计算的概念,处理选项值的代码,有自定义的值绑定读取实际值,如同标准值.既然我们已经知道如何转换计算表达式,也就知道我们的 Bind 成员会接收值和 lambda 函数.因为我们处理的是选项类型计算表达式,只有当值是 Some(x) 而不是 None 时,我们才打算执行 lambda 表达式:后一种情况,我们可以立即返回 None. 要运行前面的例子,我们需要在 C# 中实现 LINQ 查询运算符,在 F

12.7.3 使用计算表达式进行重构

在前一章,我们讨论过重构函数式程序的方法,最后一个主题是延迟性,它变改代码的执行方式,而不影响程序的结果.从某种意义上讲,添加延迟性也可看作是一种重构技术:计算表达式的类似之处在于,增加额外的代码,但不改变核心意思. 提示 在计算表达式和延迟性之间有密切的关系,使用 Lazy<'T> 计算类型,创建能够把代码转换成延迟计算的计算表达式,是有可能的.我们可以尝试实现自定义的计算,唯一的难度在于写 Bind 成员.在这里,我们不进行讨论,在本书的网站上可以找到其他的信息. 重要性在于,把标准的 F

[WPF系列]-数据邦定之DataTemplate 对分层数据的支持

到目前为止,我们仅讨论如何绑定和显示单个集合. 某些时候,您要绑定的集合包含其他集合. HierarchicalDataTemplate 类专用于 HeaderedItemsControl 类型以显示这样的数据. 实例演示 在下面的示例中,ListLeagueList 是 League 对象的列表. 每个 League 对象都有一个 Name 和 Division 对象的集合. 每个 Division 都有一个 Name 和 Team 对象的集合,并且每个 Team 对象都有一个 Name. <