কেবলমাত্র ডাব্লুপিএফ-তে সংখ্যার ইনপুট গ্রহণ করার জন্য আমি কীভাবে একটি টেক্সটবক্স পাব?


334

আমি অঙ্কগুলি এবং দশমিক পয়েন্টটি মানতে চাইছি, তবে কোনও চিহ্ন নেই।

আমি উইন্ডোজ ফর্মগুলির জন্য নিউমারিকআপডাউন নিয়ন্ত্রণ ব্যবহার করে এবং মাইক্রোসফ্টের একটি নিউমারিকআপডাউন কাস্টম নিয়ন্ত্রণের এই নমুনাটি দেখেছি । তবে এখনও অবধি মনে হচ্ছে নিউমুরিকআপডাউন (ডাব্লুপিএফ দ্বারা সমর্থিত বা না) আমার যে কার্যকারিতাটি চান তা সরবরাহ করে না। আমার অ্যাপ্লিকেশনটি যেভাবে ডিজাইন করা হয়েছে, তাদের সঠিক মনে কেউই তীরগুলি নিয়ে গণ্ডগোল করতে চায় না। তারা আমার প্রয়োগের প্রসঙ্গে, কোনও ব্যবহারিক ধারণা দেয় না।

সুতরাং আমি একটি স্ট্যান্ডার্ড ডাব্লুপিএফ টেক্সটবক্স করার জন্য একটি সহজ উপায় খুঁজছি যা আমি চাই কেবল অক্ষরগুলি গ্রহণ করে। এটা কি সম্ভব? এটা কি ব্যবহারিক?

উত্তর:


417

একটি পূর্বরূপ পাঠ্য ইনপুট ইভেন্ট যুক্ত করুন। যেমন: <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);
}

আপনি আপ ভুল তথ্য হুক এর পেস্ট প্রতিরোধ করতে চান 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();
    }
}

5
আপনার রেজেক্স বৈজ্ঞানিক স্বরলিপি (1e5) মঞ্জুরি দেয় না যদি তা গুরুত্বপূর্ণ হয়।
রন ওয়ারহোলিক

14
মনে রাখবেন যে এই উত্তরটি আপনি যা টাইপ করেন তা যাচাই করে, তাই আপনি 3 -33 এ প্রবেশ করতে পারেন
ডেভিড সাইকস

153
উত্তরের বিষয়টি নিখুঁত রেজেক্স নির্দিষ্ট করা ছিল না, এটি কী কী টাইপ করে তা ফিল্টার করতে ডাব্লুপিএফ ব্যবহার করতে হয় তা দেখানো হয়েছিল।
রায়

27
[স্পেস] প্রিভিউ টেক্সট ইনপুট ইভেন্টটি চালায় না।
পিটারজি

5
এর মতো কিছু double.TryParse()সম্ভবত একই সংখ্যক লাইনের সাথে প্রয়োগ করা হবে এবং আরও নমনীয় হবে।
থমাস ওয়েলার

190

ইভেন্ট হ্যান্ডলার পাঠ্য ইনপুটটির পূর্বরূপ দিচ্ছে। এখানে একটি নিয়মিত প্রকাশটি কেবলমাত্র পাঠ্য ইনপুটটির সাথে মেলে যদি এটি কোনও সংখ্যা না হয় এবং তারপরে এটি পাঠ্যবক্সে প্রবেশের ব্যবস্থা করা হয় না।

আপনি যদি কেবলমাত্র অক্ষর চান তবে নিয়মিত প্রকাশটি হিসাবে প্রতিস্থাপন করুন [^a-zA-Z]

XAML

<TextBox Name="NumberTextBox" PreviewTextInput="NumberValidationTextBox"/>

এক্সএএমএল.সিএস ফাইল

using System.Text.RegularExpressions;
private void NumberValidationTextBox(object sender, TextCompositionEventArgs e)
{
    Regex regex = new Regex("[^0-9]+");
    e.Handled = regex.IsMatch(e.Text);
}

1
ইভেন্ট হ্যান্ডলারটি পূর্বরূপ পাঠ্য ইনপুট। এখানে নিয়মিত ভাবটি কেবল পাঠ্য ইনপুটটির সাথে মিলে যায় যদি এটি কোনও সংখ্যা না হয় তবে তা পাঠ্যবক্সে প্রবেশের জন্য তৈরি করা হয় না। আপনি যদি কেবলমাত্র বর্ণমালা চান তবে নিয়মিত প্রকাশটি [^ a-zA-Z] হিসাবে প্রতিস্থাপন করুন।
কিশোর

সংখ্যা, দশমিক এবং অপারেটর সম্পর্কে কী?
জেসন এবারসী

অন্য কিছু স্ট্যাটিক ক্লাসে ঘোষিত হয়ে পাঠ্যবক্সে প্রয়োগ করার সময় এটি কীভাবে ব্যবহার করবেন তা দয়া করে আমাকে জানান?
শেখর শীট

3
আমি এটির সংক্ষিপ্ত এবং সহজ উত্তরটির চেয়ে আরও বেশি পছন্দ করি। প্রকৃত উত্তরের একই ফল পেতে দুটি পদ্ধতি দরকার।
স্লিভার

1
@ জাগড প্রস্তাবিত উত্তর হ'ল উদ্বেগের আরও ভাল বিভাজন। তবে আপনি এই বৈধতার উপরও অনেকগুলি পাঠ্যবাক্স সেট করতে পারেন। কেবলমাত্র প্রিভিউটেক্সট ইনপুট = "সংখ্যাবিলিডেশন টেক্সটবক্স" যুক্ত করুন। (ঠিক অন্যান্য উত্তরের মতো!)
স্লিভার

84

আমি ইতিমধ্যে এখানে যা ছিল তার কিছু ব্যবহার করেছি এবং একটি আচরণ ব্যবহার করে এটিতে আমার নিজের টুইস্টটি রেখেছি যাতে আমাকে এই কোডটি এক টন ভিউ জুড়ে প্রচার করতে হবে না ...

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>

1
এই দুর্দান্ত সমাধান দ্বারা অনুপ্রাণিত হয়ে আমি কিছু উন্নতি বাস্তবায়ন করেছি। থ্রেডের নীচে এটি পরীক্ষা করে দেখুন।
অ্যালেক্স ক্লাউস

2
ওহে. আমি জানি এটি কিছুটা দেরি হয়ে গেছে তবে আমি এটি বাস্তবায়নের চেষ্টা করছি তবে আমি ত্রুটিগুলি পেতে থাকি। আমি অনুমান করছি আমি কিছু উল্লেখ মিস করছি। আপনার কোনও ক্লাস তৈরির পরে ডিফল্ট ব্যতীত অন্য কোনও টাইপ করা মানে কি?
অফার

1
@ অফার হ্যাঁ, আপনার এক্সএএমএল উইন্ডোর শীর্ষে এক্সএমএলএনস অন্তর্ভুক্ত করার বিষয়টি নিশ্চিত করুন: ইন্টারেক্টিভিটি = " স্কিমাস.মাইক্রোসফট / এক্সপ্রেসন /2010 / ইন্টারেক্টিভিটি" ।
WiteCastle

এক্সপ্রেশন এখন অপ্রচলিত। যদিও এই পদ্ধতিটি পরিষ্কার, এটি এমন কোড ব্যবহার করছে যা আর রক্ষণাবেক্ষণ করা হয় না।
রবার্ট বাকের

1
সুতরাং আপনি যদি ফিরে আসার জন্য ইসভালিড ফাংশনটি সম্পাদনা করেন! অ্যাক্সিডসম্যাক্সেলঙ্কথ (নতুন পাঠ্য, পেস্ট) এবং & রেজিক্স.আইস ম্যাচ (স্ট্রিং.কনক্যাট (এটি.অ্যাসোসিয়েটেডবজেক্ট.টেক্সট, নিউ টেক্সট), রেগুলার এক্সপ্রেসন); তারপরে এটি পুরো স্ট্রিংকে মূল্যায়ন করবে। বিটিডব্লিউ - আচরণগুলির সাথে এই বিকল্পটি পছন্দ করুন !!
Rogala

59

এটি উইলপির উত্তরগুলির একটি উন্নত সমাধান । আমার উন্নতিগুলি হ'ল:

  • ডেল এবং ব্যাকস্পেস বোতামে উন্নত আচরণ
  • যুক্ত 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>

1
এই সমাধানটি বেশ ভাল। তবে আপনি একটি ছোট ভুল করেছেন: নতুন পাঠ্য পরীক্ষা করার সময় সর্বদা MaxLengthআপনার কনডিটন (this.MaxLength == 0 || text.Length <= this.MaxLength)রিটার্ন সেট না করে false(this.MaxLength == int.MinValue || text.Length <= this.MaxLength)আপনি int.MinValueডিফল্ট মান হিসাবে সেট হিসাবে এটি আরও ভাল হওয়া উচিত MaxLength
ক্রিস্টোফ মেইনার

1
আপনাকে ধন্যবাদ ক্রিসটফ, হ্যাঁ, আপনি ঠিক বলেছেন। আমি আমার উত্তরটি পরিবর্তন করেছি।
অ্যালেক্স ক্লাউস

আমি UpdateSourceTrigger=PropertyChangedআবদ্ধ না করা পর্যন্ত @ অ্যালেক্সক্লাউস এটি দুর্দান্ত কাজ করে। এই কোডটি কীভাবে UpdateSourceTriggerসেট করবেন সেটি কীভাবে সেট করবেন সেট করার সাথে সাথে কোনও ধারণা PropertyChanged? এই কোডটি ভাগ করে নেওয়ার জন্য আপনাকে ধন্যবাদ।
জুনিয়র

32

এমভিভিএম ব্যবহার করে এটি করার একটি খুব সহজ এবং সহজ উপায়।

আপনার পাঠ্যবক্সটি ভিউ মডেলটিতে একটি পূর্ণসংখ্যার বৈশিষ্ট্যের সাথে বেঁধে রাখুন এবং এটি একটি রত্নের মতো কাজ করবে ... পাঠ্যবক্সে কোনও অ-পূর্ণসংখ্যা প্রবেশ করার পরে এমনকি এটি বৈধতা প্রদর্শন করবে।

এক্সএএমএল কোড:

<TextBox x:Name="contactNoTxtBox"  Text="{Binding contactNo}" />

মডেল কোড দেখুন:

private long _contactNo;
public long contactNo
{
    get { return _contactNo; }
    set
    {
        if (value == _contactNo)
            return;
        _contactNo = value;
        OnPropertyChanged();
    }
}

তবে প্রশ্নটিতে "আমি অঙ্কগুলি এবং দশমিক পয়েন্টটি গ্রহণ করতে চাইছি" রয়েছে । দশমিক পয়েন্টটি কি এই উত্তরের জন্য গৃহীত?
পিটার মর্টেনসেন

আমি পরিবর্তিত longকরার চেষ্টা করেছি float, তবে তা অবিলম্বে বৈধতার সাথে পুরোপুরি কার্যকর হয়নি। আমি UpdateSourceTrigger="PropertyChanged"বাইন্ডিংয়ে যুক্ত করেছি, সুতরাং প্রতিটি অক্ষর টাইপ করার সাথে সাথে এটি বৈধতা সম্পাদন করবে এবং একটি আর টাইপ করতে পারল না '' টেক্সটবক্সে অবৈধ চরিত্র উপস্থিত না থাকলে ("1x.234" টাইপ করতে হবে তারপর 'x' মুছুন)। এটি এই মোডে কিছুটা স্বচ্ছন্দ বোধ করে। এটি System.Number.ParseSingle()কাজটি করার জন্য ব্যবহার হিসাবে দেখা যায় , তাই এটি বিভিন্ন স্বীকৃতি গ্রহণ করে।
ফেডেন

@ ওলো সম্ভবত ভোট গ্রহণ করছে না কারণ বৈধতা কীভাবে কাজ করে তা ব্যাখ্যা করে না।
পল ম্যাকার্থি

26

একটি ভ্যালিডেশন বিধি যুক্ত করুন যাতে পাঠ্য পরিবর্তিত হয়ে গেলে ডেটা সংখ্যাসূচক হয় কিনা তা নির্ধারণ করে পরীক্ষা করে দেখুন, এবং যদি তা হয়, তবে প্রক্রিয়াটি চালিয়ে যাওয়ার অনুমতি দেয় এবং যদি তা না হয় তবে ব্যবহারকারীকে অনুরোধ করে যে কেবলমাত্র সেই ক্ষেত্রটিতে ডেটা গ্রহণযোগ্য।

উইন্ডোজ উপস্থাপনা ফাউন্ডেশনে বৈধকরণে আরও পড়ুন


6
এটি আসলে এসও স্ট্যান্ডার্ডগুলির জন্য কোনও উত্তর নয়।
রবার্ট বাকের

এটি এটি করার। নেট উপায় বলে মনে হচ্ছে।
টেলিম্যাট

1
হয় সঠিক উত্তর: বৈধতা viene মডেল বা মডেল পর্যায়ে হওয়া উচিত। তদতিরিক্ত আপনি কেবল একটি সংখ্যার ধরণের মতো সহজে বাঁধতে পারেন doubleএবং এটি ইতিমধ্যে আপনাকে একটি মানক বৈধতা সরবরাহ করে।

24

এক্সটেনটেড ডাব্লুপিএফ টুলকিটটিতে একটি রয়েছে: নিউমারিকআপডাউন এখানে চিত্র বর্ণনা লিখুন


আমি এই নিয়ন্ত্রণটি চেষ্টা করেছি তবে আপডেটসোসরট্রিগার = প্রপার্টিচেন্জড সহ স্পিনারটি ব্যবহার করার সময় এটি সমস্যা দেয় এবং ব্যবহারকারীর পক্ষে বৈজ্ঞানিক স্বরলিপি প্রবেশের পক্ষে সাধারণভাবে সমস্যা হয়।
মেন্নো দেইজ - ভ্যান রিজস্বিক

5
দয়া করে লক্ষ্য করুন যে NumericUpDownএটি এখন অপ্রচলিত। আপনি DecimalUpDownআপডেট করা টুলকিট এক্সটেন্ডেড ডাব্লুপিএফ টুলকিট ™ সম্প্রদায় সংস্করণ
এটি

20

এছাড়াও কেবল একটি বৈধতা নিয়ম প্রয়োগ করতে এবং এটি টেক্সটবক্সে প্রয়োগ করতে পারে:

  <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;
    }
}

আপনি যদি দশমিক সংখ্যাকে ইনপুট করতে চান তবে পাঠ্য শেষ হয়ে গেলে "বৈধ" ফিরিয়ে দেবেন না। " পড়ুন দয়া করে stackoverflow.com/a/27838893/417939
YantingChen

14

এখানে আমি রায়ের উত্তর দ্বারা অনুপ্রাণিত একটি সহজ সমাধান আছে । এটি কোনও সংখ্যার ফর্ম সনাক্ত করার জন্য পর্যাপ্ত হওয়া উচিত।

আপনি কেবলমাত্র ইতিবাচক সংখ্যা, পূর্ণসংখ্যার মান বা সর্বাধিক সংখ্যক দশমিক স্থানে মান সঠিক করতে চাইলে এই সমাধানটি সহজেই সংশোধন করা যায় if


রায়ের উত্তরে যেমন পরামর্শ দেওয়া হয়েছে , আপনাকে প্রথমে একটি 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);
}

4
আমি এই উত্তরটি অনেক পছন্দ করি, সহজ এবং কার্যকর +
পুল

godশ্বর এবং সহজ কিন্তু এর কুশ্রী যে এটি স্পেসগুলিকে অনুমতি দেয়
মোমো

2
এটি এখনও কাউকে কেবল টেক্সটবক্সে একটি স্ট্রিং আটকানোর অনুমতি দেয়
এফসিিন

8

আমি সংখ্যার কীপ্যাড নম্বর এবং ব্যাকস্পেসের অনুমতি দিয়েছি:

    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);
    }

8
আমি যাদু নম্বরের পরিবর্তে var keyEnum = (System.Windows.Input.Key) e.Key; e.Handled = !(keyEnum >= System.Windows.Input.Key.D0 && keyEnum <= System.Windows.Input.Key.D9 || keyEnum >= System.Windows.Input.Key.NumPad0 && keyEnum <= System.Windows.Input.Key.NumPad9 || keyEnum == System.Windows.Input.Key.Back);
এনাম

7

আমি ধরে নেব যে:

  1. আপনার পাঠ্যবক্স যার জন্য আপনি সংখ্যাসূচক ইনপুটটিকে অনুমতি দিতে চান কেবল তার পাঠ্য সম্পত্তিটিতে প্রাথমিকভাবে কিছু বৈধ সংখ্যা মান সেট করা থাকে (উদাহরণস্বরূপ, 2.7172)।

  2. আপনার পাঠ্যবক্সটি আপনার মূল উইন্ডোর একটি শিশু

  3. আপনার মূল উইন্ডোটি উইন্ডো 1 শ্রেণীর

  4. আপনার পাঠ্যবক্সের নাম সংখ্যাযুক্তটিবি

মৌলিক ধারণা:

  1. যুক্ত করুন: private string previousText;আপনার মূল উইন্ডো শ্রেণিতে (উইন্ডো 1)

  2. যুক্ত করুন: previousText = numericTB.Text;আপনার মূল উইন্ডো নির্মাণকারী

  3. সংখ্যার জন্য একটি হ্যান্ডলার তৈরি করুন 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;
    }

এটি পূর্ববর্তী পাঠ্যকে সংখ্যাযুক্ত টিবি.সামগ্রী নির্ধারণ করতে থাকবে যতক্ষণ না এটি বৈধ, এবং যদি ব্যবহারকারী আপনার পছন্দ না করে এমন কিছু লিখে থাকে তবে এটির শেষ বৈধ মান হিসাবে সংখ্যার টিবি.সঠন সেট করে। অবশ্যই এটি কেবলমাত্র মৌলিক ধারণা এবং এটি কেবল "ইডিয়ট প্রতিরোধী", "ইডিয়ট প্রুফ" নয়। উদাহরণস্বরূপ, ব্যবহারকারী এমন জায়গাগুলি হ্যান্ডেল করে না যেখানে ব্যবহারকারী ফাঁকে ফাঁকে পড়ে। সুতরাং এখানে একটি সম্পূর্ণ সমাধান যা আমি "বোকামি প্রমাণ" বলে মনে করি, এবং যদি আমার ভুল হয় তবে দয়া করে আমাকে বলুন:

  1. আপনার উইন্ডো 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>
  2. আপনার উইন্ডো। 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;
                    }
                }
            }
        }
    }

এবং এটাই. আপনার যদি অনেকগুলি টেক্সটবক্স থাকে তবে আমি একটি কাস্টমকন্ট্রোল তৈরি করার পরামর্শ দিচ্ছি যা টেক্সটবক্স থেকে উত্তরাধিকার সূত্রে আসে, যাতে আপনি পূর্ববর্তী পাঠ্য এবং সংখ্যাসূচক TB_TextChanged একটি পৃথক ফাইলে আপ করতে পারেন।


বাহ এটা দুর্দান্ত! আমি কীভাবে সামনের দিকে নেতিবাচক প্রতীকটিকে অনুমতি দিতে পারি?
দ্য নুবগুই

6

এটি কেবলমাত্র প্রয়োজনীয় কোড:

void MyTextBox_PreviewTextInput(object sender, TextCompositionEventArgs e)
{
    e.Handled = new Regex("[^0-9]+").IsMatch(e.Text);
}

এটি কেবল সংখ্যাগুলিকে পাঠ্য বাক্সে ইনপুট করার অনুমতি দেয়।

দশমিক বিন্দু বা বিয়োগ চিহ্নকে অনুমতি দেওয়ার জন্য, আপনি নিয়মিত প্রকাশটি এতে পরিবর্তন করতে পারেন [^0-9.-]+


1
একটি ছোটখাটো নিতপিক ব্যতীত খুব ভাল সমাধান: এটি আপনাকে হোয়াইটস্পেসে প্রবেশ করা থেকে বিরত করবে না, যেহেতু প্রিভিউ টেক্সটইনপুট ইভেন্টটি ট্রিগার করে না।
টিম পোহলমান

ব্যাকস্পেস এটিকেও আগুন দেয় না।
উইঙ্গার সেন্ডন

6

আপনি যদি কোনও বেসিক ফাংশন করতে প্রচুর কোড লিখতে না চান (লোকেরা কেন দীর্ঘ পদ্ধতি তৈরি করে তা আমি জানি না) আপনি কেবল এটি করতে পারেন:

  1. নাম স্থান যুক্ত করুন:

    using System.Text.RegularExpressions;
  2. এক্সএএমএল-তে একটি পাঠ্য-পরিবর্তিত সম্পত্তি সেট করুন:

    <TextBox x:Name="txt1" TextChanged="txt1_TextChanged"/>
  3. Txt1_TextChanged পদ্ধতির অধীনে WPF- এ যুক্ত করুন Regex.Replace:

    private void txt1_TextChanged(object sender, TextChangedEventArgs e)
    {
        txt1.Text = Regex.Replace(txt1.Text, "[^0-9]+", "");
    }

2
এটি আচরণ বা একটি সংযুক্তিপ্রোপার্টি ব্যবহার করা অনেক পরিষ্কার। প্রতিটি দর্শনে / প্রতিটি পাঠ্যবক্সের জন্য কোনও কোডের পিছনে ফিডলিং নেই
স্যার

টেক্সটবক্সের সামনে গাজরটি সামনের অবস্থানে লাফিয়ে উঠবে বলে কাজ করতে পারে তবে কুৎসিত
মোমো

6

আর একটি পদ্ধতি সংযুক্ত আচরণ ব্যবহার করবে, আমি আমার কাস্টম পাঠ্যবক্সহেল্পার বাস্তবায়ন করেছি implemented ক্লাসটি , যা আমার সমস্ত প্রকল্পের পাঠ্যবাক্সগুলিতে ব্যবহার করা যেতে পারে। কারণ আমি বুঝতে পেরেছি যে প্রতিটি টেক্সটবক্সগুলির জন্য এবং প্রতিটি স্বতন্ত্র এক্সএএমএল ফাইলের জন্য এই উদ্দেশ্যে সাবস্ক্রাইব করা সময় সাপেক্ষ হতে পারে।

আমি প্রয়োগ করা পাঠ্যবক্সহেল্পার ক্লাসে এই বৈশিষ্ট্যগুলি রয়েছে:

  • ডাবল , ইন্ট , ইউিন্ট এবং প্রাকৃতিক মধ্যে কেবল সংখ্যাগুলি ফিল্টারিং এবং গ্রহণযোগ্য ফর্ম্যাটে
  • ফিল্টারিং এবং শুধুমাত্র গ্রহণ এমনকি বা বিজোড় সংখ্যার
  • পেস্ট ইভেন্ট হ্যান্ডলার পরিচালনা করছেআমাদের সংখ্যার পাঠ্যবক্সগুলিতে অবৈধ পাঠ্য আটকাতে করছে
  • একটি ডিফল্ট মান সেট করতে পারে যা টেক্সটব্যাঞ্জযুক্ত পাঠ্যবক্সগুলিতে সাবস্ক্রাইব করে সর্বশেষ শট হিসাবে অবৈধ ডেটা রোধ করতে ব্যবহৃত হবে

এখানে টেক্সটবক্সহেল্পার শ্রেণি প্রয়োগ করা হচ্ছে:

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"/>

মনে রাখবেন যে আমার পাঠ্যবক্সহেল্পারটি ভিউহেল্পার্স এক্সএমএনএলস অ্যালামে থাকে।

আমি আশা করি যে এই বাস্তবায়নটি অন্য কারও কাজকে সহজ করবে :)


1
ডেটা টেম্প্লেটের ভিতরে একটি পাঠ্যবক্স ব্যবহার করার সময় এটি দুর্দান্ত thanks
NucS

@ নিউস আপনি প্রিয় নুসকে তাই স্বাগত জানাই
আমির মাহদী নাসিরি

3
দুর্দান্ত উত্তর কিন্তু আমি আপনার পদ্ধতিগুলি পড়তে অসুবিধে করেছি। সম্ভবত আপনার এগুলি ছোট আকারে বিভক্ত করা উচিত। দেখুন আপনার জন্য একটি পদ্ধতি আদর্শ দৈর্ঘ্য কত?
অ্যান্থনি

@ অ্যান্টনি
আমির মাহদী নাসিরি

4
e.Handled = (int)e.Key >= 43 || (int)e.Key <= 34;

পাঠ্যবক্সের পূর্বরূপ কীডাউন ইভেন্টে।


3
যদিও ব্যাকস্পেসের অনুমতি দেয় না।
সেভেনটিভিট

2
ব্যাকস্পেস 2, ট্যাবটি 3
ড্যানিয়েল

6
-1 কারণ আমার অভিজ্ঞতায় এই ধরণের স্মার্ট ট্রিকস অবশেষে আপনাকে পাছায় কামড় দেয়, যেমন কিছু অন্যান্য মন্তব্যকারী উল্লেখ করেছেন।
ডনকিমেস্টার

বাম তীর 23, ডানদিকের তীর 25. হয়
হারুন


4

আপনার এক্সএএমএল ফাইলটিতে কেবলমাত্র পূর্ণসংখ্যা এবং দশমিক ব্যবহার করে এই ধরণের সমস্যার জন্য দ্রুত এবং খুব সাধারণ বাস্তবায়ন সন্ধানকারীদের PreviewTextInputজন্য, আপনার একটি সম্পত্তি যুক্ত করুন TextBoxএবং তারপরে আপনার xaml.cs ফাইল ব্যবহার করুন:

private void Text_PreviewTextInput(object sender, TextCompositionEventArgs e)
{
    e.Handled = !char.IsDigit(e.Text.Last()) && !e.Text.Last() == '.';
}

এটি সম্পূর্ণরূপে প্রতিটি বারের স্ট্রিংটি পরীক্ষা করা অব্যাহত রাখে যতক্ষণ না অন্যেরা উল্লেখ করেছেন, আপনি বৈজ্ঞানিক স্বরলিপি দিয়ে কিছু করছেন (তবে আপনি যদি 'ই' এর মতো কিছু নির্দিষ্ট অক্ষর যোগ করেন তবে একটি সাধারণ রেজেক্স প্রতীক / অক্ষর যুক্ত করা হয়) সত্যিই সহজ এবং অন্যান্য উত্তরে চিত্রিত)। তবে সাধারণ ভাসমান পয়েন্টের মানগুলির জন্য, এই সমাধানটি যথেষ্ট।

ল্যাম্বডা এক্সপ্রেশন সহ ওয়ান-লাইনার হিসাবে রচনা:

private void Text_PreviewTextInput(object sender, TextCompositionEventArgs e) => e.Handled = !char.IsDigit(e.Text.Last() && !e.Text.Last() == '.');

3

পাঠ্য বাক্স পরিবর্তিত ইভেন্টে আমরা বৈধতা দিতে পারি। নিম্নলিখিত প্রয়োগটি সংখ্যাসূচক এবং এক দশমিক বিন্দু ব্যতীত কীপ্রেস ইনপুটটিকে বাধা দেয়।

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;     
} 

এটি আমার পক্ষে কার্যকর নয় :)
david2020

3

এ কেমন? আমার জন্য ভাল কাজ করে। আশা করি আমি কোন প্রকার মামলা মিস করিনি ...

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();
    }
});

এই কাজ আপনাকে ধন্যবাদ
Aljohn ইয়ামারো

2

উইন্ডোজ ফর্মগুলিতে এটি সহজ ছিল; আপনি কীপ্রেসের জন্য একটি ইভেন্ট যুক্ত করতে পারেন এবং সবকিছু সহজেই কাজ করে। তবে ডাব্লুপিএফ-তে সেই ইভেন্টটি নেই। তবে এর জন্য আরও অনেক সহজ উপায় রয়েছে।

ডাব্লুপিএফ টেক্সটবক্সে টেক্সট চেঞ্জড ইভেন্ট রয়েছে যা প্রতিটি কিছুর জন্য সাধারণ। এর মধ্যে রয়েছে পেস্টিং, টাইপিং এবং যা যা আপনার মনে আসে।

সুতরাং আপনি এর মতো কিছু করতে পারেন:

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;
}

এটিও গ্রহণ করে ., যদি আপনি এটি না চান তবে কেবল regexবিবৃতিটি থেকে তা সরান @[^\d]

দ্রষ্টব্য : এই ইভেন্টটি অনেক টেক্সটবক্স'এ ব্যবহার করা যেতে পারে কারণ এটি senderঅবজেক্টের পাঠ্য ব্যবহার করে । আপনি কেবল ইভেন্টটি একবার লিখেছেন এবং এটি একাধিক পাঠ্যবক্সের জন্য ব্যবহার করতে পারেন।


2

এখন আমি জানি এই প্রশ্নের একটি স্বীকৃত উত্তর রয়েছে , তবে ব্যক্তিগতভাবে আমি এটিকে কিছুটা বিভ্রান্তি মনে করি এবং আমি বিশ্বাস করি যে এটির চেয়ে সহজ হওয়া উচিত। সুতরাং আমি যেভাবে পারি তার থেকে সর্বোত্তমভাবে কাজ করার জন্য এটি কীভাবে দেখানোর চেষ্টা করব:

ইন উইন্ডোজ ফরম , একটি ঘটনা বলা KeyPressযা টাস্ক এই ধরনের জন্য পুরোপুরি ভাল। তবে ডাব্লুপিএফ-তে এটি বিদ্যমান নেই , সুতরাং পরিবর্তে, আমরা PreviewTextInputইভেন্টটি ব্যবহার করব । এছাড়াও, বৈধতার জন্য, আমি বিশ্বাস করি যে কেউ একটি foreachলুপটি ব্যবহার করতে পারে textbox.Textএবং শর্তটি মেলে কিনা তা পরীক্ষা করতে পারে ;) তবে সত্যই, নিয়মিত প্রকাশের জন্য এটিই ।

পবিত্র কোডটিতে ডুব দেওয়ার আগে আরও একটি জিনিস । ইভেন্টটি বহিস্কারের জন্য, কেউ দুটি জিনিস করতে পারে:

  1. কোন প্রোগ্রামটি কল করতে হবে তা জানানোর জন্য এক্সএএমএল ব্যবহার করুন: <PreviewTextInput="textBox_PreviewTextInput/>
  2. এটা কি Loadedফর্ম (যা পাঠ্যবাক্স হয়) এর ইভেন্ট: 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);
}

2

এটি আমার সংস্করণ এখানে। এটি একটি বেস উপর ভিত্তি করেValidatingTextBox শ্রেণীর যা "বৈধ" না হলে কেবল যা করা হয়েছে তা বাতিল করে দেয়। এটি পেস্ট, কাটা, মোছা, ব্যাকস্পেস, +, - ইত্যাদি সমর্থন করে

32-বিট পূর্ণসংখ্যার জন্য, এখানে একটি ইন্টার 32 টেক্সটবক্স ক্লাস রয়েছে যা কেবলমাত্র একটি ইন্টের সাথে তুলনা করে। আমি ভাসমান পয়েন্ট বৈধকরণের ক্লাসগুলিও যুক্ত করেছি।

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: ডাব্লুপিএফ বাইন্ডিং ব্যবহার করার সময়, আপনাকে অবশ্যই নিশ্চিত করতে হবে যে আপনি শ্রেণিটি সীমাবদ্ধ সম্পত্তির ধরণের সাথে খাপ খায়, তা অদ্ভুত ফলাফলের দিকে নিয়ে যেতে পারে।

দ্রষ্টব্য 2: ডাব্লুপিএফ বাইন্ডিং সহ ভাসমান পয়েন্ট ক্লাসগুলি ব্যবহার করার সময়, নিশ্চিত হয়ে নিন যে আমি ব্যবহৃত ট্রাইপার্স পদ্ধতির সাথে মেলে ধরার জন্য বর্তমান সংস্কৃতিটি ব্যবহার করা হয়েছে।



1

ব্যবহার করুন:

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

একটি ব্যাখ্যা ক্রম হবে।
পিটার মর্টেনসেন

1

আমি যে সরল প্রজেক্টে কাজ করছি তার জন্য আমি আনবাউন্ড বক্সের সাথে কাজ করছিলাম, তাই আমি স্ট্যান্ডার্ড বাইন্ডিং পদ্ধতির ব্যবহার করতে পারিনি। ফলস্বরূপ আমি একটি সাধারণ হ্যাক তৈরি করেছি যা অন্যরা কেবল বিদ্যমান টেক্সটবক্স নিয়ন্ত্রণকে প্রসারিত করে বেশ সহজেই সন্ধান করতে পারে:

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;
            }
        }
    }
}

স্পষ্টতই, একটি ভাসমান প্রকারের জন্য, আপনি এটি একটি ফ্লোট এবং এর মতো হিসাবে পার্স করতে চান। একই নীতি প্রযোজ্য।

তারপরে এক্সএএমএল ফাইলটিতে আপনাকে প্রাসঙ্গিক নেমস্পেস অন্তর্ভুক্ত করতে হবে:

<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" >

1

কিছু সময়ের জন্য এখানে কিছু সমাধান ব্যবহার করার পরে, আমি আমার নিজস্ব তৈরি করেছি যা আমার এমভিভিএম সেটআপের জন্য ভাল কাজ করে। মনে রাখবেন যে এটি ব্যবহারকারীদের ভ্রান্ত চরিত্রগুলিতে প্রবেশের অনুমতি দেওয়ার দিক থেকে অন্য কারও মতো গতিশীল নয়, তবে এটি তাদের বোতামটি টিপানো এবং কিছু করা থেকে বিরত রাখে। ক্রিয়াকলাপ সম্পাদন করা সম্ভব না হলে এটি বোতামগুলি ছাঁটাইয়ের থিমের সাথে ভাল।

আমার একটি রয়েছে 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()তবে এটি এই বিষয়টির জন্য গুরুত্বহীন। এটি আমার ক্ষেত্রে ভাল কাজ করে কারণ আমাকে ভিউ-কোড-পিছনের ফাইলটিতে কোনও কোড যুক্ত করতে হবে না এবং এটি আমাকে Commandসম্পত্তি ব্যবহার করে আচরণ নিয়ন্ত্রণ করতে দেয় ।



1

ডাব্লুপিএফ অ্যাপ্লিকেশনটিতে আপনি TextChangedইভেন্টটি পরিচালনা করে এটি পরিচালনা করতে পারেন :

void arsDigitTextBox_TextChanged(object sender, System.Windows.Controls.TextChangedEventArgs e)
{
    Regex regex = new Regex("[^0-9]+");
    bool handle = regex.IsMatch(this.Text);
    if (handle)
    {
        StringBuilder dd = new StringBuilder();
        int i = -1;
        int cursor = -1;
        foreach (char item in this.Text)
        {
            i++;
            if (char.IsDigit(item))
                dd.Append(item);
            else if(cursor == -1)
                cursor = i;
        }
        this.Text = dd.ToString();

        if (i == -1)
            this.SelectionStart = this.Text.Length;
        else
            this.SelectionStart = cursor;
    }
}

1

বিকাশকারীদের যারা তাদের পাঠ্য ক্ষেত্রগুলি কেবল সকেট পোর্ট এবং এর মতো স্বাক্ষরযুক্ত সংখ্যাগুলি গ্রহণ করতে চান:

WPF

<TextBox PreviewTextInput="Port_PreviewTextInput" MaxLines="1"/>

সি শার্প

private void Port_PreviewTextInput(object sender, TextCompositionEventArgs e)
{
    e.Handled = !int.TryParse(e.Text, out int x);
}

2
মনে রাখবেন যে আপনি যদি সকেট বন্দর ক্ষেত্রের সাথে এই পদ্ধতিটি সত্যিই ব্যবহার করতে চান; পূর্ণসংখ্যাটি তার চেয়ে কম বা সমান কিনা তা আপনাকে পরীক্ষা করতে হবে 65535। যদি এটি আরও বেশি হয় তবে এটি কোনও বৈধ বন্দর নয়। এছাড়াও, সেটিং TextBox.MaxLengthকরতে 5সাহায্য করবে পারেন প্রোগ্রামেটিক্যালি বা XAML মধ্যে
9:30 এ পেরিয়ে

0

আমি ডাব্লুপিএফ পাঠ্যবক্স পেতে এটি ব্যবহার করব যা অঙ্কগুলি এবং দশমিক বিন্দু গ্রহণ করে:

class numericTextBox : TextBox
{
    protected override void OnKeyDown(KeyEventArgs e)
    {
        bool b = false;
        switch (e.Key)
        {
            case Key.Back: b = true; break;
            case Key.D0: b = true; break;
            case Key.D1: b = true; break;
            case Key.D2: b = true; break;
            case Key.D3: b = true; break;
            case Key.D4: b = true; break;
            case Key.D5: b = true; break;
            case Key.D6: b = true; break;
            case Key.D7: b = true; break;
            case Key.D8: b = true; break;
            case Key.D9: b = true; break;
            case Key.OemPeriod: b = true; break;
        }
        if (b == false)
        {
            e.Handled = true;
        }
        base.OnKeyDown(e);
    }
}

কোডটি একটি নতুন শ্রেণীর ফাইলে রাখুন, যোগ করুন

using System.Windows.Controls;
using System.Windows.Input;

ফাইলের শীর্ষে এবং সমাধানটি তৈরি করুন। তারপরে সংখ্যার পাঠ্যবক্স নিয়ন্ত্রণটি টুলবক্সের শীর্ষে উপস্থিত হবে।


1
সংখ্যাভালিডেশন টেক্সটবক্স এবং নিয়মিত এক্সপ্রেশন ব্যবহার করে এর আগের খুব সহজ সমাধানটি দেখুন। এটি হাস্যকর।
স্কট শ-স্মিথ

@ স্কটশো-স্মিথ সম্ভবত গৃহীত সমাধানটি কম কোড, তবে এটি এর চেয়ে দ্রুত নয়। সবসময় এমন কিছু প্রকল্প রয়েছে যার জন্য রেজেক্স ব্যবহারের পরিবর্তে প্রচুর প্রক্রিয়াকরণ শক্তি প্রয়োজন।
Beyondo
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.