Visible en ligne de compte d'un TextBlock

Une chose à propos de WPF, c'est très agréable, c'est que tous les contrôles sont très lookless. De ce fait, nous pouvons faire usage de Zone de texte, qui a un LineCount propriété (Pourquoi ce n'est pas une DependencyProperty ou pourquoi TextBlock ne pas le faire, je ne sais pas). Avec la zone de texte, nous pouvons tout simplement ré-modèle de sorte qu'il se comporte et ressemble plus à un TextBlock. Dans notre Style personnalisé/Modèle, nous allons définir IsEnabled à Faux, et il suffit de créer une base de la re-création de modèles de contrôle, de sorte que les personnes handicapées look n'est plus présent. On peut aussi lier les propriétés que nous voulons conserver, comme arrière-plan, grâce à l'utilisation de TemplateBindings.

<Style x:Key="Local_TextBox"
    TargetType="{x:Type TextBoxBase}">
    <Setter Property="IsEnabled"
            Value="False" />
    <Setter Property="Template">
        <Setter.Value>
            <ControlTemplate TargetType="{x:Type TextBoxBase}">
                <Border Name="Border"
                    Background="{TemplateBinding Background}">
                    <ScrollViewer x:Name="PART_ContentHost" />
                </Border>
            </ControlTemplate>
        </Setter.Value>
</Setter>
</Style>

Maintenant, qui va prendre soin de notre zone de texte rechercher et de se comporter comme un TextBlock, mais comment pouvons-nous obtenir le nombre de lignes?

Bien, si nous voulons accéder directement dans le code-behind, alors nous pouvons nous inscrire dans la zone de texte du SizeChanged Événement.

public partial class MainWindow : Window
{
    public MainWindow()
    {
        InitializeComponent();

        LongText = "This is a long line that has lots of text in it.  Because it is a long line, if a TextBlock's TextWrapping property is set to wrap then the text will wrap onto new lines. However, we can also use wrapping on a TextBox, that has some diffrent properties availible and then re-template it to look just like a TextBlock!";

        uiTextBox.SizeChanged += new SizeChangedEventHandler(uiTextBox_SizeChanged);

        this.DataContext = this;
    }

    void uiTextBox_SizeChanged(object sender, SizeChangedEventArgs e)
    {
        Lines = uiTextBox.LineCount;
    }

    public string LongText { get; set; }

    public int Lines
    {
        get { return (int)GetValue(LinesProperty); }
        set { SetValue(LinesProperty, value); }
    }

    //Using a DependencyProperty as the backing store for Lines.  This enables animation, styling, binding, etc...
    public static readonly DependencyProperty LinesProperty =
        DependencyProperty.Register("Lines", typeof(int), typeof(MainWindow), new UIPropertyMetadata(-1));
}

Cependant, comme j'ai tendance à avoir besoin d'utiliser les propriétés comme ça dans des endroits autres que la fenêtre en cours, et/ou que je suis en utilisant MVVM et ne veulent pas prendre cette approche, nous pouvons créer des AttachedProperties pour gérer la récupération et le réglage de la LineCount. Nous allons utiliser la AttachedProperties de faire la même chose, mais maintenant, nous allons être en mesure de l'utiliser avec n'importe quel zone de texte n'importe où, et se lier à elle à travers cette zone de texte au lieu de la Fenêtre du DataContext.

public class AttachedProperties
{
#region BindableLineCount AttachedProperty
public static int GetBindableLineCount(DependencyObject obj)
{
return (int)obj.GetValue(BindableLineCountProperty);
}
public static void SetBindableLineCount(DependencyObject obj, int value)
{
obj.SetValue(BindableLineCountProperty, value);
}
//Using a DependencyProperty as the backing store for BindableLineCount.  This enables animation, styling, binding, etc...
public static readonly DependencyProperty BindableLineCountProperty =
DependencyProperty.RegisterAttached(
"BindableLineCount",
typeof(int),
typeof(MainWindow),
new UIPropertyMetadata(-1));
#endregion //BindableLineCount AttachedProperty
#region HasBindableLineCount AttachedProperty
public static bool GetHasBindableLineCount(DependencyObject obj)
{
return (bool)obj.GetValue(HasBindableLineCountProperty);
}
public static void SetHasBindableLineCount(DependencyObject obj, bool value)
{
obj.SetValue(HasBindableLineCountProperty, value);
}
//Using a DependencyProperty as the backing store for HasBindableLineCount.  This enables animation, styling, binding, etc...
public static readonly DependencyProperty HasBindableLineCountProperty =
DependencyProperty.RegisterAttached(
"HasBindableLineCount",
typeof(bool),
typeof(MainWindow),
new UIPropertyMetadata(
false,
new PropertyChangedCallback(OnHasBindableLineCountChanged)));
private static void OnHasBindableLineCountChanged(DependencyObject o, DependencyPropertyChangedEventArgs e)
{
var textBox = (TextBox)o;
if ((e.NewValue as bool?) == true)
{
textBox.SetValue(BindableLineCountProperty, textBox.LineCount);
textBox.SizeChanged += new SizeChangedEventHandler(box_SizeChanged);
}
else
{
textBox.SizeChanged -= new SizeChangedEventHandler(box_SizeChanged);
}
}
static void box_SizeChanged(object sender, SizeChangedEventArgs e)
{
var textBox = (TextBox)sender;
(textBox).SetValue(BindableLineCountProperty, (textBox).LineCount);
}
#endregion //HasBindableLineCount AttachedProperty
}

Maintenant, il est facile de trouver les LineCount:

<StackPanel>
<TextBox x:Name="uiTextBox"
TextWrapping="Wrap"
local:AttachedProperties.HasBindableLineCount="True"
Text="{Binding LongText}"
Style="{StaticResource Local_TextBox}" />
<TextBlock Text="{Binding Lines, StringFormat=Binding through the code behind: {0}}" />
<TextBlock Text="{Binding ElementName=uiTextBox, Path=(local:AttachedProperties.BindableLineCount), StringFormat=Binding through AttachedProperties: {0}}" />
</StackPanel>

OriginalL'auteur rmoore

J'ai vu que cette question est déjà 7 ans, mais je suis juste venu avec une solution:

TextBlock ont une propriété privée appelée LineCount. J'ai créé une méthode d'extension de lire cette valeur:

public static class TextBlockExtension
{
public static int GetLineCount(this TextBlock tb)
{
var propertyInfo = GetPrivatePropertyInfo(typeof(TextBlock), "LineCount");
var result = (int)propertyInfo.GetValue(tb);
return result;
}
private static PropertyInfo GetPrivatePropertyInfo(Type type, string propertyName)
{
var props = type.GetProperties(BindingFlags.Instance | BindingFlags.GetProperty | BindingFlags.NonPublic);
return props.FirstOrDefault(propInfo => propInfo.Name == propertyName);
}
}

OriginalL'auteur jannagy02