반응형
텍스트 상자가 WPF의 숫자 입력만 수락하도록 하려면 어떻게 해야 합니까?
숫자와 소수점을 받으려고 하는데, 표시가 없습니다.
Windows Forms용 NumericUpDown 컨트롤과 Microsoft의 NumericUpDown 사용자 지정 컨트롤을 사용한 샘플을 살펴보았습니다.그러나 아직까지는 NumericUpDown(WPF에서 지원되는지 여부에 관계없이)이 제가 원하는 기능을 제공하지 못하는 것 같습니다.제 애플리케이션이 설계된 방식으로는 아무도 제정신이 아닌 사람이 화살표를 건드리고 싶어하지 않을 것입니다.제 지원서의 맥락에서 볼 때, 그것들은 실질적으로 말이 되지 않습니다.
그래서 저는 표준 WPF TextBox가 제가 원하는 문자만 사용할 수 있도록 하는 간단한 방법을 찾고 있습니다.이것이 가능합니까?실용적입니까?
미리보기 텍스트 입력 이벤트를 추가합니다.이와 같은 경우:<TextBox PreviewTextInput="PreviewTextInput" />.
그리고 그 세트 안에.e.Handled텍스트가 허용되지 않는 경우. e.Handled = !IsTextAllowed(e.Text);
저는 간단한 정규식을 사용합니다.IsTextAllowed내가 그들이 입력한 것을 허용해야 하는지 확인하는 방법.이 경우 숫자, 점 및 대시만 허용합니다.
private static readonly Regex _regex = new Regex("[^0-9.-]+"); //regex that matches disallowed text
private static bool IsTextAllowed(string text)
{
return !_regex.IsMatch(text);
}
것을 는 잘된데를붙것을방연다결니합면려하지는여넣이못터▁▁the▁if다니▁past연▁hook합▁you결▁dataing▁want▁of를 연결합니다.DataObject.Pasting 벤트이DataObject.Pasting="TextBoxPasting"여기에 표시된 것처럼(코드 추출):
// Use the DataObject.Pasting Handler
private void TextBoxPasting(object sender, DataObjectPastingEventArgs e)
{
if (e.DataObject.GetDataPresent(typeof(String)))
{
String text = (String)e.DataObject.GetData(typeof(String));
if (!IsTextAllowed(text))
{
e.CancelCommand();
}
}
else
{
e.CancelCommand();
}
}
이벤트 핸들러가 텍스트 입력을 미리 보는 중입니다.여기서 정규식은 숫자가 아닌 경우에만 텍스트 입력과 일치한 다음 입력란에 입력되지 않습니다.
이 글자만 , 을 " 만원는경정우다규을같바음다꿉니이과식하문자다바니꿉▁the"로 바꾸세요.[^a-zA-Z].
XAML
<TextBox Name="NumberTextBox" PreviewTextInput="NumberValidationTextBox"/>
XAML.CS 파일
using System.Text.RegularExpressions;
private void NumberValidationTextBox(object sender, TextCompositionEventArgs e)
{
Regex regex = new Regex("[^0-9]+");
e.Handled = regex.IsMatch(e.Text);
}
저는 이미 여기에 있는 것들 중 일부를 사용했고 행동을 사용하여 저만의 트위스트를 적용했습니다. 그래서 저는 이 코드를 수많은 뷰를 통해 전파할 필요가 없습니다.
public class AllowableCharactersTextBoxBehavior : Behavior<TextBox>
{
public static readonly DependencyProperty RegularExpressionProperty =
DependencyProperty.Register("RegularExpression", typeof(string), typeof(AllowableCharactersTextBoxBehavior),
new FrameworkPropertyMetadata(".*"));
public string RegularExpression
{
get
{
return (string)base.GetValue(RegularExpressionProperty);
}
set
{
base.SetValue(RegularExpressionProperty, value);
}
}
public static readonly DependencyProperty MaxLengthProperty =
DependencyProperty.Register("MaxLength", typeof(int), typeof(AllowableCharactersTextBoxBehavior),
new FrameworkPropertyMetadata(int.MinValue));
public int MaxLength
{
get
{
return (int)base.GetValue(MaxLengthProperty);
}
set
{
base.SetValue(MaxLengthProperty, value);
}
}
protected override void OnAttached()
{
base.OnAttached();
AssociatedObject.PreviewTextInput += OnPreviewTextInput;
DataObject.AddPastingHandler(AssociatedObject, OnPaste);
}
private void OnPaste(object sender, DataObjectPastingEventArgs e)
{
if (e.DataObject.GetDataPresent(DataFormats.Text))
{
string text = Convert.ToString(e.DataObject.GetData(DataFormats.Text));
if (!IsValid(text, true))
{
e.CancelCommand();
}
}
else
{
e.CancelCommand();
}
}
void OnPreviewTextInput(object sender, System.Windows.Input.TextCompositionEventArgs e)
{
e.Handled = !IsValid(e.Text, false);
}
protected override void OnDetaching()
{
base.OnDetaching();
AssociatedObject.PreviewTextInput -= OnPreviewTextInput;
DataObject.RemovePastingHandler(AssociatedObject, OnPaste);
}
private bool IsValid(string newText, bool paste)
{
return !ExceedsMaxLength(newText, paste) && Regex.IsMatch(newText, RegularExpression);
}
private bool ExceedsMaxLength(string newText, bool paste)
{
if (MaxLength == 0) return false;
return LengthOfModifiedText(newText, paste) > MaxLength;
}
private int LengthOfModifiedText(string newText, bool paste)
{
var countOfSelectedChars = this.AssociatedObject.SelectedText.Length;
var caretIndex = this.AssociatedObject.CaretIndex;
string text = this.AssociatedObject.Text;
if (countOfSelectedChars > 0 || paste)
{
text = text.Remove(caretIndex, countOfSelectedChars);
return text.Length + newText.Length;
}
else
{
var insert = Keyboard.IsKeyToggled(Key.Insert);
return insert && caretIndex < text.Length ? text.Length : text.Length + newText.Length;
}
}
}
다음은 관련 보기 코드입니다.
<TextBox MaxLength="50" TextWrapping="Wrap" MaxWidth="150" Margin="4"
Text="{Binding Path=FileNameToPublish}" >
<interactivity:Interaction.Behaviors>
<v:AllowableCharactersTextBoxBehavior RegularExpression="^[0-9.\-]+$" MaxLength="50" />
</interactivity:Interaction.Behaviors>
</TextBox>
이것은 WillP 답변의 개선된 솔루션입니다.향상된 기능은 다음과 같습니다.
- Del 및 Backspace 버튼의 동작 개선
- 된 된가 추가됨
EmptyValue빈, "는 " " " 입니다. - 일부 사소한 오타 수정
/// <summary>
/// Regular expression for Textbox with properties:
/// <see cref="RegularExpression"/>,
/// <see cref="MaxLength"/>,
/// <see cref="EmptyValue"/>.
/// </summary>
public class TextBoxInputRegExBehaviour : Behavior<TextBox>
{
#region DependencyProperties
public static readonly DependencyProperty RegularExpressionProperty =
DependencyProperty.Register("RegularExpression", typeof(string), typeof(TextBoxInputRegExBehaviour), new FrameworkPropertyMetadata(".*"));
public string RegularExpression
{
get { return (string)GetValue(RegularExpressionProperty); }
set { SetValue(RegularExpressionProperty, value); }
}
public static readonly DependencyProperty MaxLengthProperty =
DependencyProperty.Register("MaxLength", typeof(int), typeof(TextBoxInputRegExBehaviour),
new FrameworkPropertyMetadata(int.MinValue));
public int MaxLength
{
get { return (int)GetValue(MaxLengthProperty); }
set { SetValue(MaxLengthProperty, value); }
}
public static readonly DependencyProperty EmptyValueProperty =
DependencyProperty.Register("EmptyValue", typeof(string), typeof(TextBoxInputRegExBehaviour), null);
public string EmptyValue
{
get { return (string)GetValue(EmptyValueProperty); }
set { SetValue(EmptyValueProperty, value); }
}
#endregion
/// <summary>
/// Attach our behaviour. Add event handlers
/// </summary>
protected override void OnAttached()
{
base.OnAttached();
AssociatedObject.PreviewTextInput += PreviewTextInputHandler;
AssociatedObject.PreviewKeyDown += PreviewKeyDownHandler;
DataObject.AddPastingHandler(AssociatedObject, PastingHandler);
}
/// <summary>
/// Deattach our behaviour. remove event handlers
/// </summary>
protected override void OnDetaching()
{
base.OnDetaching();
AssociatedObject.PreviewTextInput -= PreviewTextInputHandler;
AssociatedObject.PreviewKeyDown -= PreviewKeyDownHandler;
DataObject.RemovePastingHandler(AssociatedObject, PastingHandler);
}
#region Event handlers [PRIVATE] --------------------------------------
void PreviewTextInputHandler(object sender, TextCompositionEventArgs e)
{
string text;
if (this.AssociatedObject.Text.Length < this.AssociatedObject.CaretIndex)
text = this.AssociatedObject.Text;
else
{
// Remaining text after removing selected text.
string remainingTextAfterRemoveSelection;
text = TreatSelectedText(out remainingTextAfterRemoveSelection)
? remainingTextAfterRemoveSelection.Insert(AssociatedObject.SelectionStart, e.Text)
: AssociatedObject.Text.Insert(this.AssociatedObject.CaretIndex, e.Text);
}
e.Handled = !ValidateText(text);
}
/// <summary>
/// PreviewKeyDown event handler
/// </summary>
void PreviewKeyDownHandler(object sender, KeyEventArgs e)
{
if (string.IsNullOrEmpty(this.EmptyValue))
return;
string text = null;
// Handle the Backspace key
if (e.Key == Key.Back)
{
if (!this.TreatSelectedText(out text))
{
if (AssociatedObject.SelectionStart > 0)
text = this.AssociatedObject.Text.Remove(AssociatedObject.SelectionStart - 1, 1);
}
}
// Handle the Delete key
else if (e.Key == Key.Delete)
{
// If text was selected, delete it
if (!this.TreatSelectedText(out text) && this.AssociatedObject.Text.Length > AssociatedObject.SelectionStart)
{
// Otherwise delete next symbol
text = this.AssociatedObject.Text.Remove(AssociatedObject.SelectionStart, 1);
}
}
if (text == string.Empty)
{
this.AssociatedObject.Text = this.EmptyValue;
if (e.Key == Key.Back)
AssociatedObject.SelectionStart++;
e.Handled = true;
}
}
private void PastingHandler(object sender, DataObjectPastingEventArgs e)
{
if (e.DataObject.GetDataPresent(DataFormats.Text))
{
string text = Convert.ToString(e.DataObject.GetData(DataFormats.Text));
if (!ValidateText(text))
e.CancelCommand();
}
else
e.CancelCommand();
}
#endregion Event handlers [PRIVATE] -----------------------------------
#region Auxiliary methods [PRIVATE] -----------------------------------
/// <summary>
/// Validate certain text by our regular expression and text length conditions
/// </summary>
/// <param name="text"> Text for validation </param>
/// <returns> True - valid, False - invalid </returns>
private bool ValidateText(string text)
{
return (new Regex(this.RegularExpression, RegexOptions.IgnoreCase)).IsMatch(text) && (MaxLength == int.MinValue || text.Length <= MaxLength);
}
/// <summary>
/// Handle text selection
/// </summary>
/// <returns>true if the character was successfully removed; otherwise, false. </returns>
private bool TreatSelectedText(out string text)
{
text = null;
if (AssociatedObject.SelectionLength <= 0)
return false;
var length = this.AssociatedObject.Text.Length;
if (AssociatedObject.SelectionStart >= length)
return true;
if (AssociatedObject.SelectionStart + AssociatedObject.SelectionLength >= length)
AssociatedObject.SelectionLength = length - AssociatedObject.SelectionStart;
text = this.AssociatedObject.Text.Remove(AssociatedObject.SelectionStart, AssociatedObject.SelectionLength);
return true;
}
#endregion Auxiliary methods [PRIVATE] --------------------------------
}
사용법은 매우 간단합니다.
<i:Interaction.Behaviors>
<behaviours:TextBoxInputRegExBehaviour RegularExpression="^\d+$" MaxLength="9" EmptyValue="0" />
</i:Interaction.Behaviors>
MVVM을 사용하여 이 작업을 수행하는 매우 간단하고 쉬운 방법은 다음과 같습니다.
뷰 모델의 정수 속성으로 textBox를 바인딩하면 보석처럼 작동합니다...텍스트 상자에 비수술자를 입력하면 유효성 검사도 표시됩니다.
XAML 코드:
<TextBox x:Name="contactNoTxtBox" Text="{Binding contactNo}" />
모델 코드 보기:
private long _contactNo;
public long contactNo
{
get { return _contactNo; }
set
{
if (value == _contactNo)
return;
_contactNo = value;
OnPropertyChanged();
}
}
여기 레이의 대답에서 영감을 얻은 간단한 해결책이 있습니다.이는 모든 형태의 숫자를 식별하기에 충분합니다.
이 솔루션은 양수, 정수 값 또는 소수점 이하의 최대 숫자까지 정확한 값만 원하는 경우에도 쉽게 수정할 수 있습니다.
Ray의 답변에서 제안한 것처럼, 당신은 먼저 추가할 필요가 있습니다.PreviewTextInput 이벤트:
<TextBox PreviewTextInput="TextBox_OnPreviewTextInput"/>
그런 다음 코드 뒤에 다음을 입력합니다.
private void TextBox_OnPreviewTextInput(object sender, TextCompositionEventArgs e)
{
var textBox = sender as TextBox;
// Use SelectionStart property to find the caret position.
// Insert the previewed text into the existing text in the textbox.
var fullText = textBox.Text.Insert(textBox.SelectionStart, e.Text);
double val;
// If parsing is successful, set Handled to false
e.Handled = !double.TryParse(fullText, out val);
}
잘못된 공백에 다음을 추가할 수 있습니다.
using System.Globalization;
private void TextBox_OnPreviewTextInput(object sender, TextCompositionEventArgs e)
{
var textBox = sender as TextBox;
// Use SelectionStart property to find the caret position.
// Insert the previewed text into the existing text in the textbox.
var fullText = textBox.Text.Insert(textBox.SelectionStart, e.Text);
double val;
// If parsing is successful, set Handled to false
e.Handled = !double.TryParse(fullText,
NumberStyles.AllowDecimalPoint | NumberStyles.AllowLeadingSign,
CultureInfo.InvariantCulture,
out val);
}
텍스트가 변경될 때 데이터가 숫자인지 확인하고, 숫자인 경우 계속 처리할 수 있는지 확인하고, 그렇지 않은 경우 해당 필드에서 숫자 데이터만 허용된다는 메시지를 표시하도록 확인 규칙을 추가합니다.
Windows 프레젠테이션 파운데이션의 검증에 대해 자세히 알아보기
Extended WPF 툴킷에는 Numeric UpDown이 있습니다. 
또한 단순히 유효성 검사 규칙을 구현하여 TextBox에 적용할 수도 있습니다.
<TextBox>
<TextBox.Text>
<Binding Path="OnyDigitInput" Mode="TwoWay" UpdateSourceTrigger="PropertyChanged">
<Binding.ValidationRules>
<conv:OnlyDigitsValidationRule />
</Binding.ValidationRules>
</Binding>
</TextBox.Text>
다음과 같은 규칙 구현(다른 답변에서 제안한 것과 동일한 정규식 사용):
public class OnlyDigitsValidationRule : ValidationRule
{
public override ValidationResult Validate(object value, CultureInfo cultureInfo)
{
var validationResult = new ValidationResult(true, null);
if(value != null)
{
if (!string.IsNullOrEmpty(value.ToString()))
{
var regex = new Regex("[^0-9.-]+"); //regex that matches disallowed text
var parsingOk = !regex.IsMatch(value.ToString());
if (!parsingOk)
{
validationResult = new ValidationResult(false, "Illegal Characters, Please Enter Numeric Value");
}
}
}
return validationResult;
}
}
또 다른 접근 방식은 첨부된 동작을 사용하는 것입니다. 프로젝트 전체의 텍스트 상자에서 사용할 수 있는 사용자 지정 TextBoxHelper 클래스를 구현했습니다.이를 위해 모든 텍스트 상자와 모든 개별 XAML 파일의 이벤트를 구독하는 것은 시간이 많이 걸릴 수 있다고 생각했기 때문입니다.
구현한 TextBoxHelper 클래스에는 다음과 같은 기능이 있습니다.
- Double, Int, Uint 및 Natural 형식의 숫자만 필터링 및 허용
- 짝수 또는 홀수 번호만 필터링 및 허용
- 잘못된 텍스트를 숫자 텍스트 상자에 붙여넣지 않도록 이벤트 붙여넣기 처리기 처리
- 텍스트 상자 TextChanged 이벤트에 가입하여 잘못된 데이터를 마지막 샷으로 방지하는 데 사용할 기본값을 설정할 수 있습니다.
TextBoxHelper 클래스의 구현은 다음과 같습니다.
public static class TextBoxHelper
{
#region Enum Declarations
public enum NumericFormat
{
Double,
Int,
Uint,
Natural
}
public enum EvenOddConstraint
{
All,
OnlyEven,
OnlyOdd
}
#endregion
#region Dependency Properties & CLR Wrappers
public static readonly DependencyProperty OnlyNumericProperty =
DependencyProperty.RegisterAttached("OnlyNumeric", typeof(NumericFormat?), typeof(TextBoxHelper),
new PropertyMetadata(null, DependencyPropertiesChanged));
public static void SetOnlyNumeric(TextBox element, NumericFormat value) =>
element.SetValue(OnlyNumericProperty, value);
public static NumericFormat GetOnlyNumeric(TextBox element) =>
(NumericFormat) element.GetValue(OnlyNumericProperty);
public static readonly DependencyProperty DefaultValueProperty =
DependencyProperty.RegisterAttached("DefaultValue", typeof(string), typeof(TextBoxHelper),
new PropertyMetadata(null, DependencyPropertiesChanged));
public static void SetDefaultValue(TextBox element, string value) =>
element.SetValue(DefaultValueProperty, value);
public static string GetDefaultValue(TextBox element) => (string) element.GetValue(DefaultValueProperty);
public static readonly DependencyProperty EvenOddConstraintProperty =
DependencyProperty.RegisterAttached("EvenOddConstraint", typeof(EvenOddConstraint), typeof(TextBoxHelper),
new PropertyMetadata(EvenOddConstraint.All, DependencyPropertiesChanged));
public static void SetEvenOddConstraint(TextBox element, EvenOddConstraint value) =>
element.SetValue(EvenOddConstraintProperty, value);
public static EvenOddConstraint GetEvenOddConstraint(TextBox element) =>
(EvenOddConstraint)element.GetValue(EvenOddConstraintProperty);
#endregion
#region Dependency Properties Methods
private static void DependencyPropertiesChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
if (!(d is TextBox textBox))
throw new Exception("Attached property must be used with TextBox.");
switch (e.Property.Name)
{
case "OnlyNumeric":
{
var castedValue = (NumericFormat?) e.NewValue;
if (castedValue.HasValue)
{
textBox.PreviewTextInput += TextBox_PreviewTextInput;
DataObject.AddPastingHandler(textBox, TextBox_PasteEventHandler);
}
else
{
textBox.PreviewTextInput -= TextBox_PreviewTextInput;
DataObject.RemovePastingHandler(textBox, TextBox_PasteEventHandler);
}
break;
}
case "DefaultValue":
{
var castedValue = (string) e.NewValue;
if (castedValue != null)
{
textBox.TextChanged += TextBox_TextChanged;
}
else
{
textBox.TextChanged -= TextBox_TextChanged;
}
break;
}
}
}
#endregion
private static void TextBox_PreviewTextInput(object sender, TextCompositionEventArgs e)
{
var textBox = (TextBox)sender;
string newText;
if (textBox.SelectionLength == 0)
{
newText = textBox.Text.Insert(textBox.SelectionStart, e.Text);
}
else
{
var textAfterDelete = textBox.Text.Remove(textBox.SelectionStart, textBox.SelectionLength);
newText = textAfterDelete.Insert(textBox.SelectionStart, e.Text);
}
var evenOddConstraint = GetEvenOddConstraint(textBox);
switch (GetOnlyNumeric(textBox))
{
case NumericFormat.Double:
{
if (double.TryParse(newText, out double number))
{
switch (evenOddConstraint)
{
case EvenOddConstraint.OnlyEven:
if (number % 2 != 0)
e.Handled = true;
else
e.Handled = false;
break;
case EvenOddConstraint.OnlyOdd:
if (number % 2 == 0)
e.Handled = true;
else
e.Handled = false;
break;
}
}
else
e.Handled = true;
break;
}
case NumericFormat.Int:
{
if (int.TryParse(newText, out int number))
{
switch (evenOddConstraint)
{
case EvenOddConstraint.OnlyEven:
if (number % 2 != 0)
e.Handled = true;
else
e.Handled = false;
break;
case EvenOddConstraint.OnlyOdd:
if (number % 2 == 0)
e.Handled = true;
else
e.Handled = false;
break;
}
}
else
e.Handled = true;
break;
}
case NumericFormat.Uint:
{
if (uint.TryParse(newText, out uint number))
{
switch (evenOddConstraint)
{
case EvenOddConstraint.OnlyEven:
if (number % 2 != 0)
e.Handled = true;
else
e.Handled = false;
break;
case EvenOddConstraint.OnlyOdd:
if (number % 2 == 0)
e.Handled = true;
else
e.Handled = false;
break;
}
}
else
e.Handled = true;
break;
}
case NumericFormat.Natural:
{
if (uint.TryParse(newText, out uint number))
{
if (number == 0)
e.Handled = true;
else
{
switch (evenOddConstraint)
{
case EvenOddConstraint.OnlyEven:
if (number % 2 != 0)
e.Handled = true;
else
e.Handled = false;
break;
case EvenOddConstraint.OnlyOdd:
if (number % 2 == 0)
e.Handled = true;
else
e.Handled = false;
break;
}
}
}
else
e.Handled = true;
break;
}
}
}
private static void TextBox_PasteEventHandler(object sender, DataObjectPastingEventArgs e)
{
var textBox = (TextBox)sender;
if (e.DataObject.GetDataPresent(typeof(string)))
{
var clipboardText = (string) e.DataObject.GetData(typeof(string));
var newText = textBox.Text.Insert(textBox.SelectionStart, clipboardText);
var evenOddConstraint = GetEvenOddConstraint(textBox);
switch (GetOnlyNumeric(textBox))
{
case NumericFormat.Double:
{
if (double.TryParse(newText, out double number))
{
switch (evenOddConstraint)
{
case EvenOddConstraint.OnlyEven:
if (number % 2 != 0)
e.CancelCommand();
break;
case EvenOddConstraint.OnlyOdd:
if (number % 2 == 0)
e.CancelCommand();
break;
}
}
else
e.CancelCommand();
break;
}
case NumericFormat.Int:
{
if (int.TryParse(newText, out int number))
{
switch (evenOddConstraint)
{
case EvenOddConstraint.OnlyEven:
if (number % 2 != 0)
e.CancelCommand();
break;
case EvenOddConstraint.OnlyOdd:
if (number % 2 == 0)
e.CancelCommand();
break;
}
}
else
e.CancelCommand();
break;
}
case NumericFormat.Uint:
{
if (uint.TryParse(newText, out uint number))
{
switch (evenOddConstraint)
{
case EvenOddConstraint.OnlyEven:
if (number % 2 != 0)
e.CancelCommand();
break;
case EvenOddConstraint.OnlyOdd:
if (number % 2 == 0)
e.CancelCommand();
break;
}
}
else
e.CancelCommand();
break;
}
case NumericFormat.Natural:
{
if (uint.TryParse(newText, out uint number))
{
if (number == 0)
e.CancelCommand();
else
{
switch (evenOddConstraint)
{
case EvenOddConstraint.OnlyEven:
if (number % 2 != 0)
e.CancelCommand();
break;
case EvenOddConstraint.OnlyOdd:
if (number % 2 == 0)
e.CancelCommand();
break;
}
}
}
else
{
e.CancelCommand();
}
break;
}
}
}
else
{
e.CancelCommand();
}
}
private static void TextBox_TextChanged(object sender, TextChangedEventArgs e)
{
var textBox = (TextBox)sender;
var defaultValue = GetDefaultValue(textBox);
var evenOddConstraint = GetEvenOddConstraint(textBox);
switch (GetOnlyNumeric(textBox))
{
case NumericFormat.Double:
{
if (double.TryParse(textBox.Text, out double number))
{
switch (evenOddConstraint)
{
case EvenOddConstraint.OnlyEven:
if (number % 2 != 0)
textBox.Text = defaultValue;
break;
case EvenOddConstraint.OnlyOdd:
if (number % 2 == 0)
textBox.Text = defaultValue;
break;
}
}
else
textBox.Text = defaultValue;
break;
}
case NumericFormat.Int:
{
if (int.TryParse(textBox.Text, out int number))
{
switch (evenOddConstraint)
{
case EvenOddConstraint.OnlyEven:
if (number % 2 != 0)
textBox.Text = defaultValue;
break;
case EvenOddConstraint.OnlyOdd:
if (number % 2 == 0)
textBox.Text = defaultValue;
break;
}
}
else
textBox.Text = defaultValue;
break;
}
case NumericFormat.Uint:
{
if (uint.TryParse(textBox.Text, out uint number))
{
switch (evenOddConstraint)
{
case EvenOddConstraint.OnlyEven:
if (number % 2 != 0)
textBox.Text = defaultValue;
break;
case EvenOddConstraint.OnlyOdd:
if (number % 2 == 0)
textBox.Text = defaultValue;
break;
}
}
else
textBox.Text = defaultValue;
break;
}
case NumericFormat.Natural:
{
if (uint.TryParse(textBox.Text, out uint number))
{
if(number == 0)
textBox.Text = defaultValue;
else
{
switch (evenOddConstraint)
{
case EvenOddConstraint.OnlyEven:
if (number % 2 != 0)
textBox.Text = defaultValue;
break;
case EvenOddConstraint.OnlyOdd:
if (number % 2 == 0)
textBox.Text = defaultValue;
break;
}
}
}
else
{
textBox.Text = defaultValue;
}
break;
}
}
}
}
다음은 간편한 사용의 몇 가지 예입니다.
<TextBox viewHelpers:TextBoxHelper.OnlyNumeric="Double"
viewHelpers:TextBoxHelper.DefaultValue="1"/>
또는
<TextBox viewHelpers:TextBoxHelper.OnlyNumeric="Natural"
viewHelpers:TextBoxHelper.DefaultValue="3"
viewHelpers:TextBoxHelper.EvenOddConstraint="OnlyOdd"/>
내 TextBox 도우미가 보기에 있음도우미 xmlns 별칭입니다.
나는 이 구현이 다른 사람의 일을 쉽게 해주기를 바랍니다 :)
숫자 키패드 번호 및 백스페이스를 허용했습니다.
private void TextBox_PreviewKeyDown(object sender, KeyEventArgs e)
{
int key = (int)e.Key;
e.Handled = !(key >= 34 && key <= 43 ||
key >= 74 && key <= 83 ||
key == 2);
}
필요한 코드는 다음과 같습니다.
void MyTextBox_PreviewTextInput(object sender, TextCompositionEventArgs e)
{
e.Handled = new Regex("[^0-9]+").IsMatch(e.Text);
}
이렇게 하면 텍스트 상자에 숫자만 입력할 수 있습니다.
기호를 을 소점또는빼기기호허를용정면려다변수있다습으로 변경할 수.[^0-9.-]+.
다음과 같이 가정합니다.
숫자 입력만 허용하려는 TextBox의 Text 속성은 처음에 일부 유효한 숫자 값(예: 2.7172)으로 설정됩니다.
텍스트 상자는 기본 창의 하위 항목입니다.
주 창은 클래스 창1입니다.
텍스트 상자 이름은 숫자입니다.TB
기본 아이디어:
추가:
private string previousText;창 에 합니다.추가:
previousText = numericTB.Text;윈도우 생성자에게 ▁to▁your.숫자 TB에 대한 처리기를 만듭니다.TextChanged 이벤트는 다음과 같습니다.
private void numericTB_TextChanged(object sender, TextChangedEventArgs e) { double num = 0; bool success = double.TryParse(((TextBox)sender).Text, out num); if (success & num >= 0) previousText = ((TextBox)sender).Text; else ((TextBox)sender).Text = previousText; }
이전 설정을 계속 유지합니다.텍스트를 숫자 TB로 변환합니다.유효한 길이만큼 텍스트를 입력하고 숫자 TB를 설정합니다.사용자가 마음에 들지 않는 내용을 쓰는 경우 마지막 유효한 값으로 텍스트를 입력합니다.물론, 이것은 기본적인 아이디어일 뿐이며, "바보 증명"이 아니라 "바보 저항"일 뿐입니다.예를 들어 사용자가 공백을 가지고 장난치는 경우는 처리하지 않습니다.그래서 여기 제가 "바보 증명"이라고 생각하는 완전한 해결책이 있습니다. 제가 틀렸다면 다음과 같이 말해주세요.
Windows 1.xaml 파일의 내용:
<Window x:Class="IdiotProofNumericTextBox.Window1" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" Title="Window1" Height="300" Width="300"> <Grid> <TextBox Height="30" Width="100" Name="numericTB" TextChanged="numericTB_TextChanged"/> </Grid> </Window>Window.xaml.cs 파일의 내용:
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Windows; using System.Windows.Controls; using System.Windows.Data; using System.Windows.Documents; using System.Windows.Input; using System.Windows.Media; using System.Windows.Media.Imaging; using System.Windows.Navigation; using System.Windows.Shapes; namespace IdiotProofNumericTextBox { public partial class Window1 : Window { private string previousText; public Window1() { InitializeComponent(); previousText = numericTB.Text; } private void numericTB_TextChanged(object sender, TextChangedEventArgs e) { if (string.IsNullOrEmpty(((TextBox)sender).Text)) previousText = ""; else { double num = 0; bool success = double.TryParse(((TextBox)sender).Text, out num); if (success & num >= 0) { ((TextBox)sender).Text.Trim(); previousText = ((TextBox)sender).Text; } else { ((TextBox)sender).Text = previousText; ((TextBox)sender).SelectionStart = ((TextBox)sender).Text.Length; } } } } }
그리고 이것이 마지막입니다.TextBox가 많은 경우 TextBox에서 상속되는 CustomControl을 생성하여 이전 파일을 랩할 수 있도록 하는 것이 좋습니다.텍스트 및 숫자 TB_텍스트가 별도의 파일로 변경되었습니다.
기본적인 기능을 수행하기 위해 많은 코드를 작성하고 싶지 않다면(왜 사람들이 긴 방법을 만드는지 모르겠다) 다음과 같이 하면 됩니다.
네임스페이스 추가:
using System.Text.RegularExpressions;XAML에서 TextChanged 속성을 설정합니다.
<TextBox x:Name="txt1" TextChanged="txt1_TextChanged"/>Tx1_filename WPF 우 method, Add TextChanged 서추, 가
Regex.Replace:private void txt1_TextChanged(object sender, TextChangedEventArgs e) { txt1.Text = Regex.Replace(txt1.Text, "[^0-9]+", ""); }
PreviewTextInput += (s, e) =>
{
e.Handled = !e.Text.All(char.IsDigit);
};
를 정수와 구현을 에 XAML을 합니다.PreviewTextInput의 신의산의 .TextBox그런 다음 xaml.cs 파일에서 다음을 사용합니다.
private void Text_PreviewTextInput(object sender, TextCompositionEventArgs e)
{
e.Handled = !char.IsDigit(e.Text.Last()) && !e.Text.Last() == '.';
}
다른 사람들이 언급했듯이 과학적 표기법으로 무언가를 하고 있지 않는 한 매번 전체 문자열을 계속 확인하는 것은 다소 불필요합니다('e'와 같은 특정 문자를 추가하는 경우에도 기호/문자를 추가하는 간단한 정규식은 정말 간단하고 다른 답변에 설명되어 있습니다).그러나 간단한 부동 소수점 값의 경우 이 솔루션으로 충분합니다.
람다 식을 가진 1-라이너로 작성됨:
private void Text_PreviewTextInput(object sender, TextCompositionEventArgs e) => e.Handled = !char.IsDigit(e.Text.Last() && !e.Text.Last() == '.');
자신의 텍스트 필드에서 소켓 포트 등과 같은 부호 없는 번호만 허용하려는 개발자의 경우:
WPF
<TextBox PreviewTextInput="Port_PreviewTextInput" MaxLines="1"/>
C#
private void Port_PreviewTextInput(object sender, TextCompositionEventArgs e)
{
e.Handled = !int.TryParse(e.Text, out int x);
}
Windows Forms에서는 KeyPress용 이벤트를 추가할 수 있어 모든 것이 쉽게 작동합니다.그러나 WPF에서는 해당 이벤트가 없습니다.하지만 훨씬 더 쉬운 방법이 있습니다.
WPF TextBox에는 모든 항목에 대해 일반적인 TextChanged 이벤트가 있습니다.붙여넣기, 타이핑, 그리고 여러분이 생각할 수 있는 모든 것을 포함합니다.
따라서 다음과 같은 작업을 수행할 수 있습니다.
XAML:
<TextBox name="txtBox1" ... TextChanged="TextBox_TextChanged"/>
코드 배경:
private void TextBox_TextChanged(object sender, TextChangedEventArgs e) {
string s = Regex.Replace(((TextBox)sender).Text, @"[^\d.]", "");
((TextBox)sender).Text = s;
}
이는또허니다됩용한다▁accepts니를 받아들입니다..그것을 , 그냥 않으면그제거, 하세요.regex은 …이다@[^\d].
참고: 이 이벤트는 다음을 사용하므로 많은 TextBox 요소에서 사용할 수 있습니다.sender개체의 텍스트입니다.이벤트는 한 번만 작성하고 여러 TextBox 요소에 사용할 수 있습니다.
e.Handled = (int)e.Key >= 43 || (int)e.Key <= 34;
텍스트 상자의 미리 보기 키다운 이벤트입니다.
우리는 텍스트 상자 변경 이벤트에 대한 검증을 할 수 있습니다.다음 구현에서는 숫자 및 소수점 하나 이외의 키 누르기 입력을 방지합니다.
private void textBoxNumeric_TextChanged(object sender, TextChangedEventArgs e)
{
TextBox textBox = sender as TextBox;
Int32 selectionStart = textBox.SelectionStart;
Int32 selectionLength = textBox.SelectionLength;
String newText = String.Empty;
int count = 0;
foreach (Char c in textBox.Text.ToCharArray())
{
if (Char.IsDigit(c) || Char.IsControl(c) || (c == '.' && count == 0))
{
newText += c;
if (c == '.')
count += 1;
}
}
textBox.Text = newText;
textBox.SelectionStart = selectionStart <= textBox.Text.Length ? selectionStart : textBox.Text.Length;
}
이건 어때?저한테는 잘 맞습니다.엣지 케이스를 놓치지 않았길...
MyTextBox.PreviewTextInput += (sender, args) =>
{
if (!int.TryParse(args.Text, out _))
{
args.Handled = true;
}
};
DataObject.AddPastingHandler(MyTextBox, (sender, args) =>
{
var isUnicodeText = args.SourceDataObject.GetDataPresent(DataFormats.UnicodeText, true);
if (!isUnicodeText)
{
args.CancelCommand();
}
var data = args.SourceDataObject.GetData(DataFormats.UnicodeText) as string;
if (!int.TryParse(data, out _))
{
args.CancelCommand();
}
});
텍스트 상자에 정수 숫자만 허용하는 가장 좋고 우아한 솔루션은 다음과 같습니다(일부 범위에서도 가능).
XAML:
<TextBox PreviewTextInput="ValidationTextBox" TextChanged="TextBox_TextChanged"/>
C#:
private void ValidationTextBox(object sender, TextCompositionEventArgs e)
{
int max = 100;
//do not allow futher incorrect typing
e.Handled = !(int.TryParse(((TextBox)sender).Text + e.Text, out int i) && i >= 1 && i <= max);
}
private void TextBox_TextChanged(object sender, TextChangedEventArgs e)
{
int max = 100;
if (!int.TryParse(((TextBox)sender).Text, out int j) || j < 1 || j > max)
{
//delete incoret input
((TextBox)sender).Text = "";
}
else
{
//delete leading zeros
((TextBox)sender).Text = j.ToString();
}
}
max (min)을 로 켜면 max 및 할 수 .((TextBox)sender).Name.
이 솔루션에서는 선행 0 또는 복사 붙여넣기 입력을 허용하지 않습니다.모든 시나리오에서 텍스트 상자에 올바른 번호가 표시됩니다.
이제 저는 이 질문이 받아들여지는 답을 가지고 있다는 것을 알지만, 개인적으로, 저는 그것이 약간 혼란스럽고 그것보다 더 쉬워야 한다고 생각합니다.어떻게 하면 가장 효과적으로 작동할 수 있는지 보여드리겠습니다.
Windows Forms에는 다음과 같은 이벤트가 있습니다.KeyPress이런 종류의 작업에 완벽하게 적합합니다.그러나 WPF에는 존재하지 않으므로 대신에, 우리는PreviewTextInput는 할 수 생각합니다. 또한, 검증을 위해, 나는 누군가가 사용할 수 있다고 믿습니다.foreach를 해서 읽다textbox.Text그리고 일치하는지 확인합니다 ;) 조건이지만, 솔직히 이것이 정규 표현의 목적입니다.
성스러운 법전에 들어가기 전에 한 가지 더.이벤트가 실행되는 경우 다음 두 가지 작업을 수행할 수 있습니다.
- . XAML은 다음과 같습니다.
<PreviewTextInput="textBox_PreviewTextInput/> - 에서 .
Loaded:textBox 파일:textBox.PreviewTextInput += onlyNumeric;
더 좋을 것 이런 조건을 입니다. 이런 상황에서는 대부분 같은 조건을 적용해야 할 것이기 때문입니다.regex두 개 의 둘에게이로TextBox그리고 당신은 당신 자신을 반복하고 싶지 않을 것입니다!
마지막으로, 다음과 같은 방법이 있습니다.
private void onlyNumeric(object sender, TextCompositionEventArgs e)
{
string onlyNumeric = @"^([0-9]+(.[0-9]+)?)$";
Regex regex = new Regex(onlyNumeric);
e.Handled = !regex.IsMatch(e.Text);
}
여기 제 버전이 있습니다.베이스를 기반으로 합니다.ValidatingTextBox수행된 작업을 취소하는 클래스입니다.붙여넣기, 잘라내기, 삭제, 백스페이스, +, 등을 지원합니다.
32비트 정수의 경우 Int32가 있습니다.int와 비교하는 TextBox 클래스입니다.부동 소수점 유효성 검사 클래스도 추가했습니다.
public class ValidatingTextBox : TextBox
{
private bool _inEvents;
private string _textBefore;
private int _selectionStart;
private int _selectionLength;
public event EventHandler<ValidateTextEventArgs> ValidateText;
protected override void OnPreviewKeyDown(KeyEventArgs e)
{
if (_inEvents)
return;
_selectionStart = SelectionStart;
_selectionLength = SelectionLength;
_textBefore = Text;
}
protected override void OnTextChanged(TextChangedEventArgs e)
{
if (_inEvents)
return;
_inEvents = true;
var ev = new ValidateTextEventArgs(Text);
OnValidateText(this, ev);
if (ev.Cancel)
{
Text = _textBefore;
SelectionStart = _selectionStart;
SelectionLength = _selectionLength;
}
_inEvents = false;
}
protected virtual void OnValidateText(object sender, ValidateTextEventArgs e) => ValidateText?.Invoke(this, e);
}
public class ValidateTextEventArgs : CancelEventArgs
{
public ValidateTextEventArgs(string text) => Text = text;
public string Text { get; }
}
public class Int32TextBox : ValidatingTextBox
{
protected override void OnValidateText(object sender, ValidateTextEventArgs e) => e.Cancel = !int.TryParse(e.Text, out var value);
}
public class Int64TextBox : ValidatingTextBox
{
protected override void OnValidateText(object sender, ValidateTextEventArgs e) => e.Cancel = !long.TryParse(e.Text, out var value);
}
public class DoubleTextBox : ValidatingTextBox
{
protected override void OnValidateText(object sender, ValidateTextEventArgs e) => e.Cancel = !double.TryParse(e.Text, out var value);
}
public class SingleTextBox : ValidatingTextBox
{
protected override void OnValidateText(object sender, ValidateTextEventArgs e) => e.Cancel = !float.TryParse(e.Text, out var value);
}
public class DecimalTextBox : ValidatingTextBox
{
protected override void OnValidateText(object sender, ValidateTextEventArgs e) => e.Cancel = !decimal.TryParse(e.Text, out var value);
}
참고 1: WPF 바인딩을 사용할 때 바인딩된 속성 유형에 맞는 클래스를 사용해야 합니다. 그렇지 않으면 이상한 결과를 초래할 수 있습니다.
참고 2: WPF 바인딩과 함께 부동소수점 클래스를 사용할 때 바인딩이 현재 문화를 사용하여 내가 사용한 TryParse 메서드와 일치하는지 확인합니다.
정규 표현식을 확인하기 전에 강조 표시된 텍스트를 처리하기 위해 Rays 답변을 수정했습니다.소수점 두 자리(통화)만 허용하도록 정규 표현식도 조정했습니다.
private static readonly Regex _regex = new Regex(@"^[0-9]\d*(\.\d{0,2})?$");
private static bool IsTextAllowed(string text)
{
return _regex.IsMatch(text);
}
private bool IsAllowed(TextBox tb, string text)
{
bool isAllowed = true;
if (tb != null)
{
string currentText = tb.Text;
if (!string.IsNullOrEmpty(tb.SelectedText))
currentText = currentText.Remove(tb.CaretIndex, tb.SelectedText.Length);
isAllowed = IsTextAllowed(currentText.Insert(tb.CaretIndex, text));
}
return isAllowed;
}
private void Txt_PreviewCurrencyTextInput(object sender, TextCompositionEventArgs e)
{
e.Handled = !IsAllowed(sender as TextBox, e.Text);
}
private void TextBoxPasting(object sender, DataObjectPastingEventArgs e)
{
if (e.DataObject.GetDataPresent(typeof(String)))
{
String text = (String)e.DataObject.GetData(typeof(String));
if (!IsAllowed(sender as TextBox, text))
e.CancelCommand();
}
else
e.CancelCommand();
}
그리고 xaml.
<TextBox Name="Txt_Textbox" PreviewTextInput="Txt_PreviewCurrencyTextInput" DataObject.Pasting="TextBoxPasting" />
여기 WPF의 숫자 입력을 위한 라이브러리가 있습니다.
다음과 같은 특성을 가지고 있습니다.NumberStyles그리고.RegexPattern검증을 위하여
클래스 WPF 파일TextBox
사용:
Private Sub DetailTextBox_PreviewTextInput( _
ByVal sender As Object, _
ByVal e As System.Windows.Input.TextCompositionEventArgs) _
Handles DetailTextBox.PreviewTextInput
If _IsANumber Then
If Not Char.IsNumber(e.Text) Then
e.Handled = True
End If
End If
End Sub
저는 제가 작업하던 간단한 프로젝트를 위해 언바운드 박스로 작업하고 있었기 때문에 표준 바인딩 접근법을 사용할 수 없었습니다.결과적으로 저는 기존의 TextBox 컨트롤을 단순히 확장함으로써 다른 사람들이 쉽게 찾을 수 있는 간단한 해킹을 만들었습니다.
namespace MyApplication.InterfaceSupport
{
public class NumericTextBox : TextBox
{
public NumericTextBox() : base()
{
TextChanged += OnTextChanged;
}
public void OnTextChanged(object sender, TextChangedEventArgs changed)
{
if (!String.IsNullOrWhiteSpace(Text))
{
try
{
int value = Convert.ToInt32(Text);
}
catch (Exception e)
{
MessageBox.Show(String.Format("{0} only accepts numeric input.", Name));
Text = "";
}
}
}
public int? Value
{
set
{
if (value != null)
{
this.Text = value.ToString();
}
else
Text = "";
}
get
{
try
{
return Convert.ToInt32(this.Text);
}
catch (Exception ef)
{
// Not numeric.
}
return null;
}
}
}
}
부동 형식의 경우 부동 형식으로 구문 분석할 수 있습니다.동일한 원칙이 적용됩니다.
그런 다음 XAML 파일에 관련 네임스페이스를 포함해야 합니다.
<UserControl x:Class="MyApplication.UserControls.UnParameterisedControl"
[ Snip ]
xmlns:interfaceSupport="clr-namespace:MyApplication.InterfaceSupport"
>
그런 다음 일반 컨트롤로 사용할 수 있습니다.
<interfaceSupport:NumericTextBox Height="23" HorizontalAlignment="Left" Margin="168,51,0,0" x:Name="NumericBox" VerticalAlignment="Top" Width="120" >
한동안 여기에 있는 솔루션 중 일부를 사용한 후 MVVM 설정에 적합한 솔루션을 개발했습니다.사용자가 잘못된 문자를 입력할 수 있다는 점에서 다른 사용자들처럼 동적이지는 않지만 사용자가 버튼을 누르는 것을 차단하여 어떤 작업도 수행할 수 없습니다.이것은 작업을 수행할 수 없을 때 단추를 회색으로 표시하는 제 주제와 잘 어울립니다.
나는 있습니다TextBox사용자가 인쇄할 문서 페이지 수를 입력해야 합니다.
<TextBox Text="{Binding NumberPagesToPrint, UpdateSourceTrigger=PropertyChanged}"/>
...다음 바인딩 속성을 사용합니다.
private string _numberPagesToPrint;
public string NumberPagesToPrint
{
get { return _numberPagesToPrint; }
set
{
if (_numberPagesToPrint == value)
{
return;
}
_numberPagesToPrint = value;
OnPropertyChanged("NumberPagesToPrint");
}
}
단추도 있습니다.
<Button Template="{DynamicResource CustomButton_Flat}" Content="Set"
Command="{Binding SetNumberPagesCommand}"/>
...다음 명령 바인딩 사용:
private RelayCommand _setNumberPagesCommand;
public ICommand SetNumberPagesCommand
{
get
{
if (_setNumberPagesCommand == null)
{
int num;
_setNumberPagesCommand = new RelayCommand(param => SetNumberOfPages(),
() => Int32.TryParse(NumberPagesToPrint, out num));
}
return _setNumberPagesCommand;
}
}
그리고 또 다른 방법이 있습니다.SetNumberOfPages()하지만 이 주제에는 중요하지 않습니다. 경우에는 View의 할 필요가 을 제어할 수 에 잘 합니다.Command소유물.
숫자 값을 확인할 때 Visual Basic을 사용할 수 있습니다.숫자 함수입니다.
언급URL : https://stackoverflow.com/questions/1268552/how-do-i-get-a-textbox-to-only-accept-numeric-input-in-wpf
반응형
'source' 카테고리의 다른 글
| Xcode에서 실제 아이폰 장치로 아이폰 애플리케이션을 배포하려면 어떻게 해야 합니까? (0) | 2023.05.07 |
|---|---|
| Postgre 기록 방법SQL 쿼리? (0) | 2023.05.07 |
| MSYS에서 폴더 찾아보기 (0) | 2023.05.07 |
| WPF의 이미지가 흐려짐 (0) | 2023.05.07 |
| 시스템, 보안보안.이벤트 로그에 쓸 때 예외 발생 (0) | 2023.05.07 |