wpf 如果 XAML 中的条件

If condition in XAML

提问by joedanny

is that possible to implement an if condition via XAML for wpf , if yes please provide the skeleton for if condition for checking .net framework version in xaml.

是否可以通过 XAML 为 wpf 实现 if 条件，如果是，请提供 if 条件的框架，以便在 xaml 中检查 .net 框架版本。

I am sharing xaml for Visual studio 2010 and 2008 , i wanna execute specific code snippet for vs2010 and hide the same for vs2008

我正在为 Visual Studio 2010 和 2008 共享 xaml，我想为 vs2010 执行特定的代码片段并为 vs2008 隐藏相同的代码片段

回答by Sheridan

Yes, they're called Triggers. There are different kinds and they react to changes in values of data that is data bound, events that are fired, or even the state of user interface controls. You can find a good article describing them in the Triggers in WPFpost on Code Project.

是的，他们被称为Triggers。有不同的种类，它们对数据绑定的数据值、触发的事件甚至用户界面控件的状态的变化做出反应。您可以在 Code Project 上的WPF中的触发器帖子中找到一篇很好的文章来描述它们。

EDIT >>>

编辑 >>>

I have just added your comment into your question and I have to say that putting such an important part of your question into a comment was not a good idea... as such, most of the answers so far do not answer your actualquestion. For this reason, I have downvoted your question.

我刚刚将您的评论添加到您的问题中，我不得不说，将您问题的如此重要的部分放入评论中并不是一个好主意……因此，到目前为止，大多数答案都没有回答您的实际问题。出于这个原因，我对你的问题投了反对票。

In response to your actualquestion, no, I do not believe that you can use conditional XAML which can identify the difference between versions of Visual Studio. If you told us what you end goal is, then we maystill be able to help.

针对您的实际问题，不，我不相信您可以使用可以识别 Visual Studio 版本之间差异的条件 XAML。如果你告诉我们，你到底有什么目标的话，我们可能仍然能够帮助。

回答by Jerry

Take a look at using a Converter in your XAML. With a Converter, you can make decisions in your XAML by executing code. For example, this will make my button visible under certain conditions:

看看在 XAML 中使用转换器。使用转换器，您可以通过执行代码在 XAML 中做出决策。例如，这将使我的按钮在某些条件下可见：

XAML

XAML

<Button
    x:Name="btnMyButton"
    Margin="2,0"
    Command="{Binding Model.MyButtonCommand}"
    Content="My Text"
    Visibility="{Binding Model.IsShowMode, Converter={StaticResource BoolToVisibilityConverter}, ConverterParameter=False}"
/>

C# Class

C# 类

public class BoolToVisibilityConverter : IValueConverter
{
    public object Convert(object value, Type targetType, 
    object parameter, CultureInfo culture)
   {
    // Do the conversion 
   }

   public object ConvertBack(object value, Type targetType, 
    object parameter, CultureInfo culture)
      {
      // UnDo conversion
  }
}

回答by sevdalone

maybe you can have a look at this http://josheinstein.com/blog/2010/06/switchconverter-a-switch-statement-for-xaml/

也许你可以看看这个http://josheinstein.com/blog/2010/06/switchconverter-a-switch-statement-for-xaml/

I haven't tried it but it seems that this may suite you.

我还没有尝试过，但似乎这可能适合您。

Edit:

编辑：

Here is code of SwitchConverter as Josh'ssite seems to be down -

这是 SwitchConverter 的代码，因为Josh 的网站似乎已关闭 -

/// <summary>
/// A converter that accepts <see cref="SwitchConverterCase"/>s and converts them to the 
/// Then property of the case.
/// </summary>
[ContentProperty("Cases")]
public class SwitchConverter : IValueConverter
{
    // Converter instances.
    List<SwitchConverterCase> _cases;

    #region Public Properties.
    /// <summary>
    /// Gets or sets an array of <see cref="SwitchConverterCase"/>s that this converter can use to produde values from.
    /// </summary>
    public List<SwitchConverterCase> Cases { get { return _cases; } set { _cases = value; } }
    #endregion
    #region Construction.
    /// <summary>
    /// Initializes a new instance of the <see cref="SwitchConverter"/> class.
    /// </summary>
    public SwitchConverter()
    {
        // Create the cases array.
        _cases = new List<SwitchConverterCase>();
    }
    #endregion

    /// <summary>
    /// Converts a value.
    /// </summary>
    /// <param name="value">The value produced by the binding source.</param>
    /// <param name="targetType">The type of the binding target property.</param>
    /// <param name="parameter">The converter parameter to use.</param>
    /// <param name="culture">The culture to use in the converter.</param>
    /// <returns>
    /// A converted value. If the method returns null, the valid null value is used.
    /// </returns>
    public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
    {
        // This will be the results of the operation.
        object results = null;

        // I'm only willing to convert SwitchConverterCases in this converter and no nulls!
        if (value == null) throw new ArgumentNullException("value");

        // I need to find out if the case that matches this value actually exists in this converters cases collection.
        if (_cases != null && _cases.Count > 0)
            for (int i = 0; i < _cases.Count; i++)
            {
                // Get a reference to this case.
                SwitchConverterCase targetCase = _cases[i];

                // Check to see if the value is the cases When parameter.
                if (value == targetCase || value.ToString().ToUpper() == targetCase.When.ToString().ToUpper())
                {
                    // We've got what we want, the results can now be set to the Then property
                    // of the case we're on.
                    results = targetCase.Then;

                    // All done, get out of the loop.
                    break;
                }
            }

        // return the results.
        return results;
    }

    /// <summary>
    /// Converts a value.
    /// </summary>
    /// <param name="value">The value that is produced by the binding target.</param>
    /// <param name="targetType">The type to convert to.</param>
    /// <param name="parameter">The converter parameter to use.</param>
    /// <param name="culture">The culture to use in the converter.</param>
    /// <returns>
    /// A converted value. If the method returns null, the valid null value is used.
    /// </returns>
    public object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
    {
        throw new NotImplementedException();
    }
}

/// <summary>
/// Represents a case for a switch converter.
/// </summary>
[ContentProperty("Then")]
public class SwitchConverterCase
{
    // case instances.
    string _when;
    object _then;

    #region Public Properties.
    /// <summary>
    /// Gets or sets the condition of the case.
    /// </summary>
    public string When { get { return _when; } set { _when = value; } }
    /// <summary>
    /// Gets or sets the results of this case when run through a <see cref="SwitchConverter"/>
    /// </summary>
    public object Then { get { return _then; } set { _then = value; } }
    #endregion
    #region Construction.
    /// <summary>
    /// Switches the converter.
    /// </summary>
    public SwitchConverterCase()
    {
    }
    /// <summary>
    /// Initializes a new instance of the <see cref="SwitchConverterCase"/> class.
    /// </summary>
    /// <param name="when">The condition of the case.</param>
    /// <param name="then">The results of this case when run through a <see cref="SwitchConverter"/>.</param>
    public SwitchConverterCase(string when, object then)
    {
        // Hook up the instances.
        this._then = then;
        this._when = when;
    }
    #endregion

    /// <summary>
    /// Returns a <see cref="System.String"/> that represents this instance.
    /// </summary>
    /// <returns>
    /// A <see cref="System.String"/> that represents this instance.
    /// </returns>
    public override string ToString()
    {
        return string.Format("When={0}; Then={1}", When.ToString(), Then.ToString());
    }
}