Eingabedatenlänge und Zeichen für das Eingabefeld in Xamarin.Forms einschränken

Schränken Sie die Anzahl der Charaktere in das Eingabefeld ein, wie nachfolgend beschrieben,

  int restrictCount = <your restriction length> //Enter your number of character restriction
  Entry entry = new Entry();
  entry.TextChanged += OnTextChanged;

  void OnTextChanged(object sender, EventArgs e)
  {
    Entry entry = sender as Entry;
    String val = entry.Text; //Get Current Text

    if(val.Length > restrictCount)//If it is more than your character restriction
    {
     val = val.Remove(val.Length - 1);//Remove Last character 
     entry.Text = val; //Set the Old value
    }
  }

InformationsquelleAutor der Antwort Femil Shajin

Können Sie einfach Binden;
Zum Beispiel ich möchte eine Zahlung, Wert 100 nicht überschreiten. Also schrieb ich eine Klasse

puclic class Payment : INotifyPropertyChanged
{
    private int _amountDecimals;
    public int AmountDecimals
    {
        get
        {
            return _amountDecimals;
        }

        set
        {
            if (value <= 100)
            {
                _amountDecimals = value;
            }
            OnPropertyChanged();
        }
    public event PropertyChangedEventHandler PropertyChanged;

    protected virtual void OnPropertyChanged([CallerMemberName] string propertyName = null)
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }
}

Damit diese Eigenschaft gesetzt AmountDecimals Wert, wenn der Benutzer einen Wert eingibt, bis es nicht mehr als 100

Dann setzen Sie einfach verbindlich per code auf der Seite-Konstruktor(oder vom xaml)

var myPayment =new Payment(); //this will hold page(view) data
BindingContext = myPayment;
var paymentEntry = new Entry();
paymentEntry.Keyboard = Keyboard.Numeric;
paymentEntry.SetBinding(Entry.TextProperty, "AmountDecimals");            

Damit Benutzer einen numerischen Wert auf den Eintrag, aber wenn er/Sie versucht, geben Sie einen Wert von mehr als 100, - Bindung nur in umgekehrter ihn dem alten Wert. Sie können schreiben Sie einfach Ihren code in Ihre Klasse Eigenschaften wie dieses (über-Setzer). Also, wenn Sie wollen, um eine Eigenschaft zu tragen nur 5 Zeichen, die Sie schreiben können, so etwas wie dieses (codes kann falsch sein, habe ich nicht zusammengestellt Sie 🙂 )

    private string _name;
    public string Name
    {
        get
        {
            return _name;
        }

        set
        {
            if ((value!= null && value.length <= 5) || value == null)
            {
                _name = value;
            }
            OnPropertyChanged();
        }

InformationsquelleAutor der Antwort Umut Bebek

Definition eines neuen, Benutzerdefinierten Eintrag mit den erforderlichen Eigenschaften:

public class CustomEntry : Entry
{
    public int MaxLength { get; set; }
    public bool IsNumeric { get; set; }
    public int MinValue { get; set; }
    public int MaxValue { get; set; }

    public CustomEntry()
    {

        //Initialize properties.
        IsNumeric = false;
        MaxLength = int.MaxValue;
        MinValue = int.MinValue;
        MaxValue = int.MaxValue;

        //Set the events.
        base.TextChanged += OnTextChanged;
    }

   public void OnTextChanged(object sender, TextChangedEventArgs e)
    {
        Entry entry = sender as Entry;

        //If empty, set it to empty string.
        if (string.IsNullOrWhiteSpace(e.NewTextValue))
        {
            entry.Text = string.Empty;
            return;
        }

        //Check if it is numeric.
        if (IsNumeric)
        {
            int value;
            var isValid = int.TryParse(e.NewTextValue, out value);

            if (!isValid)
            {
                entry.Text = e.OldTextValue;
                return;
            }

            //Check the min/max values.
            if (value > MaxValue || value < MinValue)
            {
                entry.Text = e.OldTextValue;
            }
        }

        //If not numeric, check the length.
        if (e.NewTextValue.Length > MaxLength)
            entry.Text = e.OldTextValue;
    }
}

Und Sie in XAML:

   <controls:CustomEntry Text="{Binding months}" Keyboard="Numeric" IsNumeric="true" MaxLength="2" MinValue="1" MaxValue="12"/>

HINWEIS: anstelle der Beseitigung der letzten Zeichen, das der Fall in den meisten Antworten, ist es sicherer, um den text an den alten text, da der Benutzer möglicherweise kopieren/Vergangenheit mehr als ein Zeichen in das Textfeld ein.

InformationsquelleAutor der Antwort A-Sharabiani

Ich würde auf jeden Fall verwenden Sie eine behvaior für diese

public class TextValidationBehavior : Behavior<Entry>
{
 //This can be bound to view model property to be informed
 public static readonly BindableProperty IsValidProperty = IsValidPropertyKey.BindableProperty;
    public bool IsValid
    {
        get { return (bool)base.GetValue(IsValidProperty); }
        private set { base.SetValue(IsValidPropertyKey, value); }
    }

//Attach delegate to text changed event
protected override void OnAttachedTo(Entry entry)
{
    entry.TextChanged += OnEntryTextChanged;
    base.OnAttachedTo(entry);
}
//Detach delegate from text changed event
protected override void OnDetachingFrom(Entry entry)
{
    entry.TextChanged -= OnEntryTextChanged;
    base.OnDetachingFrom(entry);
}

void OnEntryTextChanged(object sender, TextChangedEventArgs e)
{
    var text = e.NewTextValue;
    IsValid = Validate(text); //Implement this as needed
}
}

Verwenden Sie dann in xaml wie diese

 <ContentPage xmlns:local="clr-namespace:Behaviors;assembly=Behaviors" ... >

 <Entry Placeholder="Enter some text">
     <Entry.Behaviors>
        <local:TextValidationBehavior IsValid={Binding IsEntryValid} />
   </Entry.Behaviors>
 </Entry>
 </ContentPage>

InformationsquelleAutor der Antwort joacar

Fortsetzung Femil Antwort:

Hier ist ein benutzerdefiniertes Steuerelement für die Begrenzung der Anzahl von Zeichen, aber es kann für alles verwendet werden, die Sie verwenden möchten TextChanged für:

public class CustomEntry : Entry
{
    private CustomEntryParams parameters { get; set; }

    public CustomEntry(CustomEntryParams customParams)
    {
        if (customParams.MaxLength > 0)
        {
            base.TextChanged += EnforceMaxLength;
            parameters = customParams;
        }
    }

    public void EnforceMaxLength(object sender, TextChangedEventArgs args)
    {
        Entry e = sender as Entry;
        String val = e.Text;

        if (val.Length > parameters.MaxLength)
        {
            val = val.Remove(val.Length - 1);
            e.Text = val;
        }
    }
}

public class CustomEntryParams {
    public int MaxLength { get; set; }
}

Versuchen Sie nicht, verwenden Sie diese im XAML erhalten Sie ein parser-Fehler, sondern nutzen es in der codebehind:

new CustomEntry(new CustomEntryParams { MaxLength = 5 });

InformationsquelleAutor der Antwort Paranoid Coder

public class AppEntry : Entry
{
    public AppEntry()
    {
        TextChanged += _EnforceMaxLength;
    }

    public int? MaxLength { get; set; }

    private void _EnforceMaxLength(object sender, TextChangedEventArgs args)
    {
        if (!MaxLength.HasValue) return;

        var e = sender as Entry;
        if (e == null)
            return;

        var val = e.Text;

        if (!(val.Length > MaxLength)) return;

        val = val.Remove(val.Length - 1);
        e.Text = val;
    }
}

Verwendung:

var element = new AppEntry
{
    HorizontalOptions = LayoutOptions.FillAndExpand,
    ...
    MaxLength = 123,
};

InformationsquelleAutor der Antwort Artūras Paleičikas