c# - password - Restricción de longitud de entrada y caracteres para el campo Entrada en Xamarin.Forms

keypress c# textbox

Question

¿Cómo puedo restringir la longitud y los caracteres ingresados ​​en un control de Entrada en Xamarin.Forms? ¿Necesito crear un control personalizado? ¿Hay alguna manera de derivar de Entry (u otro control) para poder aplicar las limitaciones de entrada necesarias por plataforma?

Un ejemplo sería un campo numérico que está restringido a un máximo de 3 caracteres, solo dígitos.

Al establecer la propiedad Teclado de un control de Entrada en Teclado, Numérico solo establece el teclado para iOS. No restringe la entrada de texto real, es decir, todavía puedo ingresar caracteres sin dígitos. Tampoco veo una manera de limitar la longitud de la entrada.

Answer 1

Defina una nueva entrada personalizada con las propiedades requeridas:

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

Y para usarlo en XAML:

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

NOTA: en lugar de eliminar el último carácter que es el caso en la mayoría de las respuestas, es más seguro configurar el texto al texto antiguo, ya que el usuario puede copiar / pegar más de un carácter en el cuadro de texto.

Answer 2

Definitivamente usaría un comportamiento para esto

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

Entonces úsalo en xaml como este

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

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

Answer 3

Echa un vistazo a los comportamientos de Xamarin. Hay TextChangedBehavior.cs que puede usar una plantilla para desarrollar sus propios comportamientos para atender los campos de entrada de texto enmascarado formateados. He desarrollado FormattedTextChangedBehavior : Behavior<Entry> solo para este propósito.

Answer 4

La mejor manera de implementar esto es usar comportamientos, que limitarán la cantidad de caracteres ingresados ​​en su Entrada al ignorar cualquier otra entrada después de que se haya alcanzado el máximo. Esta publicación explica cómo lograr esto y también cómo agregar un contador que mostrará a los usuarios la cantidad de caracteres que les quedan para ingresar. este contador se actualiza en tiempo real a medida que el usuario ingresa los textos. Compruebe esta publicación para obtener más información y muy detallada sobre esto.

Answer 5

No aparece ninguna propiedad incorporada para restringir el carácter / longitud en el control de Entrada . Puede realizar tanto la limitación de texto como la entrada de caracteres a través de uno de los siguientes dos métodos disponibles:

1) Sí, puede derivar directamente de la Entrada para crear su propia derivación de esto y luego personalizarla más, por ejemplo, enganchando en el controlador de eventos TextChanged . No hay un controlador para una pulsación de tecla, por lo que tendría que hacer su comprobación de validez en los valores completos pasados ​​a e.NewTextValue . Si la nueva entrada no coincide con sus requisitos, puede configurar .Text = e.OldTextValue para volver a la última entrada válida.

2) Si desea conectarse a los controladores de eventos para los controles nativos de cada plataforma, puede escribir sus propios controles de renderizador personalizados para tener un control más preciso.

Answer 6

Puede configurar los filtros como se muestra a continuación en el método OnElementChanged del renderizador personalizado

this.Control.SetFilters(new Android.Text.IInputFilter[] { new Android.Text.InputFilterLengthFilter(MaxLength)});

Answer 7

Puede restringir el número de caracteres en el campo Entrada como se indica a continuación,

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

Answer 8

Solo puedes usar Binding; Por ejemplo, quiero mantener un valor de pago que no puede exceder de 100. Así que escribí una clase

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

Entonces, esta propiedad establecerá el valor de AmountDecimals si el usuario ingresa un valor hasta que no exceda de 100

Luego simplemente establece el enlace a través del código en el constructor de página (o desde 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");            

De modo que el usuario ingresa un valor numérico en la entrada, pero si intenta ingresar un valor mayor a 100, el enlace simplemente lo revierte al valor anterior. Simplemente puede escribir su código en las propiedades de su clase de esta manera (en los configuradores). Así que si quieres que alguna propiedad lleve solo 5 caracteres, puedes escribir algo como esto (los códigos pueden ser incorrectos, no los compilé :))

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

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

Answer 9

Una continuación de la respuesta de Femil :

Aquí hay un control personalizado para limitar el número de caracteres, pero se podría usar para cualquier cosa que desee usar TextChanged para:

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

No intentes usar esto en el XAML, recibirás un error del analizador, en lugar de usarlo en el código:

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

Answer 10

Utilicé un control de entrada personalizado con propiedades de Bindable para mayúsculas y longitud máxima.

Control (MyEntry.cs)

class NewPaymentEntry : Entry
{
   public NewPaymentEntry()
    {
        base.TextChanged += EditText;
    }
    public void EditText(object sender, TextChangedEventArgs args)
    {
        Entry e = sender as Entry;
        String val = e.Text;

        if (string.IsNullOrEmpty(val))
            return;

        if (Uppercase )
            val = val.ToUpper();

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

    }

    public static readonly BindableProperty UppercaseProperty = BindableProperty.Create<MyEntry, bool>(p => p.Uppercase, false);

    public bool Uppercase
    {
        get
        {
            return (bool)GetValue(UppercaseProperty);
        }
        set
        {
            SetValue(UppercaseProperty, value);
        }
    }

    public static readonly BindableProperty MaxLengthProperty = BindableProperty.Create<MyEntry, int>(p => p.MaxLength, 0);

    public int MaxLength
    {
        get
        {
            return (int)GetValue(MaxLengthProperty);
        }
        set
        {
            SetValue(MaxLengthProperty, value);
        }
    }
}

Llámalo desde xaml como

                  <MyEntry  Text="{Binding MyBindingProp}"
                            Uppercase="True"
                            MaxLength="11"/>

Answer 11

Yo usaría comportamientos. Más sobre esto: https://developer.xamarin.com/guides/xamarin-forms/behaviors/creating/

El ejemplo es para la entrada con teclado numérico. Pero se puede utilizar para cualquier teclado.

Uso de XAML:

<ContentPage
   xmlns:behaviors="clr-namespace:myApp.Behaviors;assembly=myApp"

   <Entry
       Keyboard="Numeric"
       Text="{Binding EntryText}" >
       <Entry.Behaviors>
           <behaviors:EntryLengthValidatorBehavior MaxLength="3" />
       </Entry.Behaviors>
   </Entry>

Comportamiento

public class EntryLengthValidatorBehavior : Behavior<Entry>
{
    public int MaxLength { get; set; }

    protected override void OnAttachedTo(Entry bindable)
    {
        base.OnAttachedTo(bindable);
        bindable.TextChanged += OnEntryTextChanged;
    }

    protected override void OnDetachingFrom(Entry bindable)
    {
        base.OnDetachingFrom(bindable);
        bindable.TextChanged -= OnEntryTextChanged;
    }

    void OnEntryTextChanged(object sender, TextChangedEventArgs e)
    {
        var entry = (Entry)sender;

        // if Entry text is longer then valid length
        if (entry.Text.Length > this.MaxLength)
        {
            string entryText = entry.Text;

            entryText = entryText.Remove(entryText.Length - 1); // remove last char

            entry.Text = entryText;
        }
    }
}

Answer 12

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

uso:

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