Atur fokus pada TextBox di WPF dari model tampilan

Saya memiliki TextBoxdan Buttondalam pandangan saya.

Sekarang saya memeriksa suatu kondisi pada tombol klik dan jika kondisi ternyata salah, menampilkan pesan kepada pengguna, dan kemudian saya harus mengatur kursor ke TextBoxkontrol.

if (companyref == null)
{
    var cs = new Lipper.Nelson.AdminClient.Main.Views.ContactPanels.CompanyAssociation(); 

    MessageBox.Show("Company does not exist.", "Error", MessageBoxButton.OK,
                    MessageBoxImage.Exclamation);

    cs.txtCompanyID.Focusable = true;

    System.Windows.Input.Keyboard.Focus(cs.txtCompanyID);
}

Kode di atas ada di dalam ViewModel.

The CompanyAssociationadalah nama tampilan.

Tetapi kursor tidak diatur dalam TextBox.

XAML adalah:

<igEditors:XamTextEditor Name="txtCompanyID" 
                         KeyDown="xamTextEditorAllowOnlyNumeric_KeyDown"
                         ValueChanged="txtCompanyID_ValueChanged"
                         Text="{Binding Company.CompanyId,
                                        Mode=TwoWay,
                                        UpdateSourceTrigger=PropertyChanged}"
                         Width="{Binding ActualWidth, ElementName=border}"
                         Grid.Column="1" Grid.Row="0"
                         VerticalAlignment="Top"
                         HorizontalAlignment="Stretch"
                         Margin="0,5,0,0"
                         IsEnabled="{Binding Path=IsEditable}"/>

<Button Template="{StaticResource buttonTemp1}"
        Command="{Binding ContactCommand}"
        CommandParameter="searchCompany"
        Content="Search"
        Width="80"
        Grid.Row="0" Grid.Column="2"
        VerticalAlignment="Top"
        Margin="0"
        HorizontalAlignment="Left"
        IsEnabled="{Binding Path=IsEditable}"/>

Biarkan saya menjawab pertanyaan Anda dalam tiga bagian.

1. Saya bertanya-tanya apa itu "cs.txtCompanyID" dalam contoh Anda? Apakah ini kontrol TextBox? Jika ya, berarti Anda berada di jalan yang salah. Secara umum itu bukan ide yang baik untuk memiliki referensi ke UI di ViewModel Anda. Anda bisa bertanya, "Kenapa?" tapi ini pertanyaan lain untuk dikirim di Stackoverflow :).

2. Cara terbaik untuk melacak masalah dengan Fokus adalah ... men-debug kode sumber .Net. Tidak bercanda. Ini menyelamatkan saya banyak waktu berkali-kali. Untuk mengaktifkan debugging kode sumber .net, lihat blog Shawn Bruke .

3. Akhirnya, pendekatan umum yang saya gunakan untuk mengatur fokus dari ViewModel adalah Properti Terlampir. Saya menulis properti terlampir yang sangat sederhana, yang dapat diset pada UIElement apa pun. Dan itu dapat diikat ke properti ViewModel "IsFocused" misalnya. Ini dia:

   public static class FocusExtension
   {
       public static bool GetIsFocused(DependencyObject obj)
       {
           return (bool) obj.GetValue(IsFocusedProperty);
       }
   
       public static void SetIsFocused(DependencyObject obj, bool value)
       {
           obj.SetValue(IsFocusedProperty, value);
       }
   
       public static readonly DependencyProperty IsFocusedProperty =
           DependencyProperty.RegisterAttached(
               "IsFocused", typeof (bool), typeof (FocusExtension),
               new UIPropertyMetadata(false, OnIsFocusedPropertyChanged));
   
       private static void OnIsFocusedPropertyChanged(
           DependencyObject d, 
           DependencyPropertyChangedEventArgs e)
       {
           var uie = (UIElement) d;
           if ((bool) e.NewValue)
           {
               uie.Focus(); // Don't care about false values.
           }
       }
   }
   

   Sekarang di View Anda (dalam XAML) Anda dapat mengikat properti ini ke ViewModel Anda:

   <TextBox local:FocusExtension.IsFocused="{Binding IsUserNameFocused}" />

Semoga ini membantu :). Jika tidak merujuk ke jawaban # 2.

Bersulang.

Saya tahu pertanyaan ini telah dijawab ribuan kali sekarang, tetapi saya mengedit kontribusi Anvaka yang saya pikir akan membantu orang lain yang memiliki masalah serupa yang saya miliki.

Pertama, saya mengubah Properti Terlampir di atas seperti:

public static class FocusExtension
{
    public static readonly DependencyProperty IsFocusedProperty = 
        DependencyProperty.RegisterAttached("IsFocused", typeof(bool?), typeof(FocusExtension), new FrameworkPropertyMetadata(IsFocusedChanged){BindsTwoWayByDefault = true});

    public static bool? GetIsFocused(DependencyObject element)
    {
        if (element == null)
        {
            throw new ArgumentNullException("element");
        }

        return (bool?)element.GetValue(IsFocusedProperty);
    }

    public static void SetIsFocused(DependencyObject element, bool? value)
    {
        if (element == null)
        {
            throw new ArgumentNullException("element");
        }

        element.SetValue(IsFocusedProperty, value);
    }

    private static void IsFocusedChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        var fe = (FrameworkElement)d;

        if (e.OldValue == null)
        {
            fe.GotFocus += FrameworkElement_GotFocus;
            fe.LostFocus += FrameworkElement_LostFocus;
        }

        if (!fe.IsVisible)
        {
            fe.IsVisibleChanged += new DependencyPropertyChangedEventHandler(fe_IsVisibleChanged);
        }

        if ((bool)e.NewValue)
        {
            fe.Focus();
        }
    }

    private static void fe_IsVisibleChanged(object sender, DependencyPropertyChangedEventArgs e)
    {
        var fe = (FrameworkElement)sender;
        if (fe.IsVisible && (bool)((FrameworkElement)sender).GetValue(IsFocusedProperty))
        {
            fe.IsVisibleChanged -= fe_IsVisibleChanged;
            fe.Focus();
        }
    }

    private static void FrameworkElement_GotFocus(object sender, RoutedEventArgs e)
    {
        ((FrameworkElement)sender).SetValue(IsFocusedProperty, true);
    }

    private static void FrameworkElement_LostFocus(object sender, RoutedEventArgs e)
    {
        ((FrameworkElement)sender).SetValue(IsFocusedProperty, false);
    }
}

Alasan saya untuk menambahkan referensi visibilitas adalah tab. Tampaknya jika Anda menggunakan properti terlampir pada tab lain di luar tab yang awalnya terlihat, properti terlampir tidak berfungsi sampai Anda memfokuskan kontrol secara manual.

Kendala lain adalah menciptakan cara yang lebih elegan untuk mengatur ulang properti yang mendasarinya menjadi false ketika kehilangan fokus. Di situlah peristiwa fokus yang hilang masuk.

<TextBox            
    Text="{Binding Description}"
    FocusExtension.IsFocused="{Binding IsFocused}"/>

Jika ada cara yang lebih baik untuk menangani masalah visibilitas, beri tahu saya.

Catatan: Terima kasih kepada Apfelkuacha untuk saran menempatkan BindsTwoWayByDefault di DependencyProperty. Saya sudah melakukannya sejak lama di kode saya sendiri, tetapi tidak pernah memperbarui posting ini. Mode = TwoWay tidak lagi diperlukan dalam kode WPF karena perubahan ini.

Saya pikir cara terbaik adalah menjaga prinsip MVVM bersih, jadi pada dasarnya Anda harus menggunakan Kelas Messenger yang disediakan dengan MVVM Light dan di sini adalah bagaimana menggunakannya:

di viewmodel Anda (exampleViewModel.cs): tulis berikut ini

 Messenger.Default.Send<string>("focus", "DoFocus");

sekarang di View.cs Anda (bukan XAML, view.xaml.cs) tulis yang berikut di konstruktor

 public MyView()
        {
            InitializeComponent();

            Messenger.Default.Register<string>(this, "DoFocus", doFocus);
        }
        public void doFocus(string msg)
        {
            if (msg == "focus")
                this.txtcode.Focus();
        }

Metode itu berjalan dengan baik dan dengan kode yang lebih sedikit dan mempertahankan standar MVVM

Tak satu pun dari ini bekerja untuk saya persis, tetapi untuk kepentingan orang lain, inilah yang akhirnya saya tulis berdasarkan beberapa kode yang sudah disediakan di sini.

Penggunaannya adalah sebagai berikut:

<TextBox ... h:FocusBehavior.IsFocused="True"/>

Dan implementasinya adalah sebagai berikut:

/// <summary>
/// Behavior allowing to put focus on element from the view model in a MVVM implementation.
/// </summary>
public static class FocusBehavior
{
    #region Dependency Properties
    /// <summary>
    /// <c>IsFocused</c> dependency property.
    /// </summary>
    public static readonly DependencyProperty IsFocusedProperty =
        DependencyProperty.RegisterAttached("IsFocused", typeof(bool?),
            typeof(FocusBehavior), new FrameworkPropertyMetadata(IsFocusedChanged));
    /// <summary>
    /// Gets the <c>IsFocused</c> property value.
    /// </summary>
    /// <param name="element">The element.</param>
    /// <returns>Value of the <c>IsFocused</c> property or <c>null</c> if not set.</returns>
    public static bool? GetIsFocused(DependencyObject element)
    {
        if (element == null)
        {
            throw new ArgumentNullException("element");
        }
        return (bool?)element.GetValue(IsFocusedProperty);
    }
    /// <summary>
    /// Sets the <c>IsFocused</c> property value.
    /// </summary>
    /// <param name="element">The element.</param>
    /// <param name="value">The value.</param>
    public static void SetIsFocused(DependencyObject element, bool? value)
    {
        if (element == null)
        {
            throw new ArgumentNullException("element");
        }
        element.SetValue(IsFocusedProperty, value);
    }
    #endregion Dependency Properties

    #region Event Handlers
    /// <summary>
    /// Determines whether the value of the dependency property <c>IsFocused</c> has change.
    /// </summary>
    /// <param name="d">The dependency object.</param>
    /// <param name="e">The <see cref="System.Windows.DependencyPropertyChangedEventArgs"/> instance containing the event data.</param>
    private static void IsFocusedChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        // Ensure it is a FrameworkElement instance.
        var fe = d as FrameworkElement;
        if (fe != null && e.OldValue == null && e.NewValue != null && (bool)e.NewValue)
        {
            // Attach to the Loaded event to set the focus there. If we do it here it will
            // be overridden by the view rendering the framework element.
            fe.Loaded += FrameworkElementLoaded;
        }
    }
    /// <summary>
    /// Sets the focus when the framework element is loaded and ready to receive input.
    /// </summary>
    /// <param name="sender">The sender.</param>
    /// <param name="e">The <see cref="System.Windows.RoutedEventArgs"/> instance containing the event data.</param>
    private static void FrameworkElementLoaded(object sender, RoutedEventArgs e)
    {
        // Ensure it is a FrameworkElement instance.
        var fe = sender as FrameworkElement;
        if (fe != null)
        {
            // Remove the event handler registration.
            fe.Loaded -= FrameworkElementLoaded;
            // Set the focus to the given framework element.
            fe.Focus();
            // Determine if it is a text box like element.
            var tb = fe as TextBoxBase;
            if (tb != null)
            {
                // Select all text to be ready for replacement.
                tb.SelectAll();
            }
        }
    }
    #endregion Event Handlers
}

Ini adalah utas lama, tetapi sepertinya tidak ada jawaban dengan kode yang mengatasi masalah dengan jawaban yang diterima Anavanka: tidak berfungsi jika Anda menyetel properti di viewmodel menjadi false, atau jika Anda menyetel properti Anda ke benar, pengguna secara manual mengklik sesuatu yang lain, dan kemudian Anda mengaturnya menjadi benar lagi. Saya juga tidak bisa mendapatkan solusi Zamotic untuk bekerja dengan andal dalam kasus-kasus ini.

Menyatukan beberapa diskusi di atas memberi saya kode di bawah ini yang menangani masalah ini, saya pikir:

public static class FocusExtension
{
    public static bool GetIsFocused(DependencyObject obj)
    {
        return (bool)obj.GetValue(IsFocusedProperty);
    }

    public static void SetIsFocused(DependencyObject obj, bool value)
    {
        obj.SetValue(IsFocusedProperty, value);
    }

    public static readonly DependencyProperty IsFocusedProperty =
        DependencyProperty.RegisterAttached(
         "IsFocused", typeof(bool), typeof(FocusExtension),
         new UIPropertyMetadata(false, null, OnCoerceValue));

    private static object OnCoerceValue(DependencyObject d, object baseValue)
    {
        if ((bool)baseValue)
            ((UIElement)d).Focus();
        else if (((UIElement) d).IsFocused)
            Keyboard.ClearFocus();
        return ((bool)baseValue);
    }
}

Karena itu, ini masih kompleks untuk sesuatu yang dapat dilakukan dalam satu baris dalam codebehind, dan CoerceValue tidak benar-benar dimaksudkan untuk digunakan dengan cara ini, jadi mungkin codebehind adalah cara untuk pergi.

Dalam kasus saya, FocusExtension tidak berfungsi sampai saya mengubah metode OnIsFocusedPropertyChanged. Yang asli hanya berfungsi di debug ketika break point menghentikan proses. Saat runtime, prosesnya terlalu cepat dan tidak ada yang terjadi. Dengan sedikit modifikasi ini dan bantuan Tugas teman kita, ini berfungsi dengan baik di kedua skenario.

private static void OnIsFocusedPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
  var uie = (UIElement)d;
  if ((bool)e.NewValue)
  {
    var action = new Action(() => uie.Dispatcher.BeginInvoke((Action)(() => uie.Focus())));
    Task.Factory.StartNew(action);
  }
}

Masalahnya adalah begitu IsUserNameFocused disetel ke true, itu tidak akan pernah salah. Ini menyelesaikannya dengan menangani GotFocus dan LostFocus untuk FrameworkElement.

Saya mengalami masalah dengan pemformatan kode sumber jadi di sini ada tautan

Kode brilian Anvakas adalah untuk aplikasi Windows Desktop. Jika Anda seperti saya dan membutuhkan solusi yang sama untuk aplikasi Windows Store, kode ini mungkin berguna:

public static class FocusExtension
{
    public static bool GetIsFocused(DependencyObject obj)
    {
        return (bool)obj.GetValue(IsFocusedProperty);
    }


    public static void SetIsFocused(DependencyObject obj, bool value)
    {
        obj.SetValue(IsFocusedProperty, value);
    }


    public static readonly DependencyProperty IsFocusedProperty =
        DependencyProperty.RegisterAttached(
         "IsFocused", typeof(bool), typeof(FocusExtension),
         new PropertyMetadata(false, OnIsFocusedPropertyChanged));


    private static void OnIsFocusedPropertyChanged(DependencyObject d,
        DependencyPropertyChangedEventArgs e)
    {
        if ((bool)e.NewValue)
        {
            var uie = d as Windows.UI.Xaml.Controls.Control;

            if( uie != null )
            {
                uie.Focus(FocusState.Programmatic);
            }
        }
    }
}

Bagi mereka yang mencoba menggunakan solusi Anvaka di atas, saya mengalami masalah dengan pengikatan hanya berfungsi pertama kali, karena kehilanganfokus tidak akan memperbarui properti ke false. Anda dapat secara manual mengatur properti menjadi false dan kemudian benar setiap kali, tetapi solusi yang lebih baik bisa dengan melakukan sesuatu seperti ini di properti Anda:

bool _isFocused = false;
    public bool IsFocused 
    {
        get { return _isFocused ; }
        set
        {
            _isFocused = false;
            _isFocused = value;
            base.OnPropertyChanged("IsFocused ");
        }
    }

Dengan cara ini Anda hanya perlu mengaturnya menjadi benar, dan itu akan mendapatkan fokus.

Saya menggunakan WPF / Caliburn Micro dan menemukan bahwa "dfaivre" telah membuat solusi umum dan dapat diterapkan di sini: http://caliburnmicro.codeplex.com/discussions/222892

Saya telah menemukan solusi dengan mengedit kode sebagai berikut. Tidak perlu mengatur properti Binding terlebih dahulu False lalu True.

public static class FocusExtension
{

    public static bool GetIsFocused(DependencyObject obj)
    {
        return (bool)obj.GetValue(IsFocusedProperty);
    }


    public static void SetIsFocused(DependencyObject obj, bool value)
    {
        obj.SetValue(IsFocusedProperty, value);
    }


    public static readonly DependencyProperty IsFocusedProperty =
        DependencyProperty.RegisterAttached(
         "IsFocused", typeof(bool), typeof(FocusExtension),
         new UIPropertyMetadata(false, OnIsFocusedPropertyChanged));


    private static void OnIsFocusedPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        if (d != null && d is Control)
        {
            var _Control = d as Control;
            if ((bool)e.NewValue)
            {
                // To set false value to get focus on control. if we don't set value to False then we have to set all binding
                //property to first False then True to set focus on control.
                OnLostFocus(_Control, null);
                _Control.Focus(); // Don't care about false values.
            }
        }
    }

    private static void OnLostFocus(object sender, RoutedEventArgs e)
    {
        if (sender != null && sender is Control)
        {
            (sender as Control).SetValue(IsFocusedProperty, false);
        }
    }
}

Untuk Silverlight:

using System.Windows;
using System.Windows.Controls;
using System.Windows.Interactivity;

namespace MyProject.Behaviors
{
    public class FocusBehavior : Behavior<Control>
    {
        protected override void OnAttached()
        {
            this.AssociatedObject.Loaded += AssociatedObject_Loaded;
            base.OnAttached();
        }

        private void AssociatedObject_Loaded(object sender, RoutedEventArgs e)
        {
            this.AssociatedObject.Loaded -= AssociatedObject_Loaded;
            if (this.HasInitialFocus || this.IsFocused)
            {
                this.GotFocus();
            }
        }

        private void GotFocus()
        {
            this.AssociatedObject.Focus();
            if (this.IsSelectAll)
            {
                if (this.AssociatedObject is TextBox)
                {
                    (this.AssociatedObject as TextBox).SelectAll();
                }
                else if (this.AssociatedObject is PasswordBox)
                {
                    (this.AssociatedObject as PasswordBox).SelectAll();
                }
                else if (this.AssociatedObject is RichTextBox)
                {
                    (this.AssociatedObject as RichTextBox).SelectAll();
                }
            }
        }

        public static readonly DependencyProperty IsFocusedProperty =
            DependencyProperty.Register(
                "IsFocused",
                typeof(bool),
                typeof(FocusBehavior),
                new PropertyMetadata(false, 
                    (d, e) => 
                    {
                        if ((bool)e.NewValue)
                        {
                            ((FocusBehavior)d).GotFocus();
                        }
                    }));

        public bool IsFocused
        {
            get { return (bool)GetValue(IsFocusedProperty); }
            set { SetValue(IsFocusedProperty, value); }
        }

        public static readonly DependencyProperty HasInitialFocusProperty =
            DependencyProperty.Register(
                "HasInitialFocus",
                typeof(bool),
                typeof(FocusBehavior),
                new PropertyMetadata(false, null));

        public bool HasInitialFocus
        {
            get { return (bool)GetValue(HasInitialFocusProperty); }
            set { SetValue(HasInitialFocusProperty, value); }
        }

        public static readonly DependencyProperty IsSelectAllProperty =
            DependencyProperty.Register(
                "IsSelectAll",
                typeof(bool),
                typeof(FocusBehavior),
                new PropertyMetadata(false, null));

        public bool IsSelectAll
        {
            get { return (bool)GetValue(IsSelectAllProperty); }
            set { SetValue(IsSelectAllProperty, value); }
        }

    }
}

LoginViewModel.cs:

    public class LoginModel : ViewModelBase
    {
        ....

        private bool _EmailFocus = false;
        public bool EmailFocus
        {
            get
            {
                return _EmailFocus;
            }
            set
            {
                if (value)
                {
                    _EmailFocus = false;
                    RaisePropertyChanged("EmailFocus");
                }
                _EmailFocus = value;
                RaisePropertyChanged("EmailFocus");
            }
        }
       ...
   }

Login.xaml:

xmlns:i="http://schemas.microsoft.com/expression/2010/interactivity"
xmlns:beh="clr-namespace:MyProject.Behaviors"

<TextBox Text="{Binding Email, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}">
    <i:Interaction.Behaviors>
        <beh:FocusBehavior IsFocused="{Binding EmailFocus}" IsSelectAll="True"/>
    </i:Interaction.Behaviors>
</TextBox>

ATAU

<TextBox Text="{Binding Email, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}">
    <i:Interaction.Behaviors>
        <beh:FocusBehavior HasInitialFocus="True" IsSelectAll="True"/>
    </i:Interaction.Behaviors>
</TextBox>

Untuk mengatur fokus, lakukan saja dalam kode:

EmailFocus = true;

Ingat bahwa plugin ini adalah bagian dari halaman html, jadi kontrol lain di halaman tersebut mungkin memiliki fokus

if (!Application.Current.IsRunningOutOfBrowser)
{
    System.Windows.Browser.HtmlPage.Plugin.Focus();
}

Anda bisa menggunakan pola desain ViewCommand . Ini menjelaskan metode untuk pola desain MVVM untuk mengontrol tampilan dari ViewModel dengan perintah.

Saya sudah mengimplementasikannya berdasarkan saran Raja A.Majid untuk menggunakan kelas MVVM Light Messenger. Kelas ViewCommandManager menangani perintah pemanggilan dalam tampilan yang terhubung. Ini pada dasarnya adalah arah lain dari Perintah reguler, untuk kasus-kasus ini ketika ViewModel perlu melakukan beberapa tindakan dalam Tampilannya. Ini menggunakan refleksi seperti perintah terikat data dan Referensi Lemah untuk menghindari kebocoran memori.

http://dev.unclassified.de/source/viewcommand (juga dipublikasikan di CodeProject)

Sepertinya tidak ada yang memasukkan langkah terakhir untuk memudahkan memperbarui atribut melalui variabel terikat. Inilah yang saya pikirkan. Beri tahu saya jika ada cara yang lebih baik untuk melakukan ini.

XAML

    <TextBox x:Name="txtLabel"
      Text="{Binding Label}"
      local:FocusExtension.IsFocused="{Binding txtLabel_IsFocused, Mode=TwoWay}" 
     />

    <Button x:Name="butEdit" Content="Edit"
        Height="40"  
        IsEnabled="{Binding butEdit_IsEnabled}"                        
        Command="{Binding cmdCapsuleEdit.Command}"                            
     />   

ViewModel

    public class LoginModel : ViewModelBase
    {

    public string txtLabel_IsFocused { get; set; }                 
    public string butEdit_IsEnabled { get; set; }                


    public void SetProperty(string PropertyName, string value)
    {
        System.Reflection.PropertyInfo propertyInfo = this.GetType().GetProperty(PropertyName);
        propertyInfo.SetValue(this, Convert.ChangeType(value, propertyInfo.PropertyType), null);
        OnPropertyChanged(PropertyName);
    }                


    private void Example_function(){

        SetProperty("butEdit_IsEnabled", "False");
        SetProperty("txtLabel_IsFocused", "True");        
    }

    }

Pertama-tama saya ingin mengucapkan terima kasih kepada Avanka karena telah membantu saya memecahkan masalah fokus saya. Namun ada bug dalam kode yang dia posting, yaitu di baris: if (e.OldValue == null)

Masalah yang saya miliki adalah bahwa jika Anda pertama kali mengklik pada tampilan Anda dan memfokuskan kontrol, e.oldValue tidak lagi nol. Kemudian ketika Anda mengatur variabel untuk memfokuskan kontrol untuk pertama kalinya, ini menghasilkan fokus yang hilang dan penangan fokus yang tidak ditetapkan. Solusi saya untuk ini adalah sebagai berikut:

public static class ExtensionFocus
    {
    static ExtensionFocus()
        {
        BoundElements = new List<string>();
        }

    public static readonly DependencyProperty IsFocusedProperty =
        DependencyProperty.RegisterAttached("IsFocused", typeof(bool?),
        typeof(ExtensionFocus), new FrameworkPropertyMetadata(false, IsFocusedChanged));

    private static List<string> BoundElements;

    public static bool? GetIsFocused(DependencyObject element)
        {
        if (element == null)
            {
            throw new ArgumentNullException("ExtensionFocus GetIsFocused called with null element");
            }
        return (bool?)element.GetValue(IsFocusedProperty);
        }

    public static void SetIsFocused(DependencyObject element, bool? value)
        {
        if (element == null)
            {
            throw new ArgumentNullException("ExtensionFocus SetIsFocused called with null element");
            }
        element.SetValue(IsFocusedProperty, value);
        }

    private static void IsFocusedChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
        var fe = (FrameworkElement)d;

        // OLD LINE:
        // if (e.OldValue == null)
        // TWO NEW LINES:
        if (BoundElements.Contains(fe.Name) == false)
            {
            BoundElements.Add(fe.Name);
            fe.LostFocus += OnLostFocus;
            fe.GotFocus += OnGotFocus;
            }           


        if (!fe.IsVisible)
            {
            fe.IsVisibleChanged += new DependencyPropertyChangedEventHandler(fe_IsVisibleChanged);
            }

        if ((bool)e.NewValue)
            {
            fe.Focus();             
            }
        }

    private static void fe_IsVisibleChanged(object sender, DependencyPropertyChangedEventArgs e)
        {
        var fe = (FrameworkElement)sender;

        if (fe.IsVisible && (bool)((FrameworkElement)sender).GetValue(IsFocusedProperty))
            {
            fe.IsVisibleChanged -= fe_IsVisibleChanged;
            fe.Focus();
            }
        }

    private static void OnLostFocus(object sender, RoutedEventArgs e)
        {
        if (sender != null && sender is Control s)
            {
            s.SetValue(IsFocusedProperty, false);
            }
        }

    private static void OnGotFocus(object sender, RoutedEventArgs e)
        {
        if (sender != null && sender is Control s)
            {
            s.SetValue(IsFocusedProperty, true);
            }
        }
    }

Lakukan saja ini:

<Window x:class...
   ...
   ...
   FocusManager.FocusedElement="{Binding ElementName=myTextBox}"
>
<Grid>
<TextBox Name="myTextBox"/>
...

Setelah menerapkan jawaban yang diterima, saya menemukan masalah yang saat menavigasi tampilan dengan Prism TextBox masih tidak akan mendapatkan fokus. Perubahan kecil ke penangan PropertyChanged menyelesaikannya

    private static void OnIsFocusedPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        var uie = (UIElement)d;
        if ((bool)e.NewValue)
        {
            uie.Dispatcher.BeginInvoke(DispatcherPriority.Input, new Action(() =>
            {
                uie.Focus();
            }));
        }
    }

Pendekatan alternatif berdasarkan jawaban @Sheridan di sini

 <TextBox Text="{Binding SomeText, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}">
        <TextBox.Style>
            <Style>
                <Style.Triggers>
                    <DataTrigger Binding="{Binding SomeTextIsFocused, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}" Value="True">
                        <Setter Property="FocusManager.FocusedElement" Value="{Binding RelativeSource={RelativeSource Self}}" />
                    </DataTrigger>
                </Style.Triggers>
            </Style>
        </TextBox.Style>
    </TextBox>

Dalam model tampilan Anda, atur ikatan Anda dengan cara biasa dan kemudian atur SomeTextIsFocused menjadi true untuk mengatur fokus pada kotak teks Anda

Saya menemukan solusi Krusial untuk masalah IsVisible sangat berguna. Itu tidak sepenuhnya menyelesaikan masalah saya, tetapi beberapa kode tambahan mengikuti pola yang sama untuk pola IsEnabled.

Ke metode IsFocusedChanged saya menambahkan:

    if (!fe.IsEnabled)
    {
        fe.IsEnabledChanged += fe_IsEnabledChanged;
    }

Dan ini dia:

private static void fe_IsEnabledChanged(object sender, DependencyPropertyChangedEventArgs e)
{
    var fe = (FrameworkElement)sender;
    if (fe.IsEnabled && (bool)((FrameworkElement)sender).GetValue(IsFocusedProperty))
    {
        fe.IsEnabledChanged -= fe_IsEnabledChanged;
        fe.Focus();
    }
}

public class DummyViewModel : ViewModelBase
    {
        private bool isfocused= false;
        public bool IsFocused
        {
            get
            {
                return isfocused;
            }
            set
            {
                isfocused= value;
                OnPropertyChanged("IsFocused");
            }
        }
    }

System.Windows.Forms.Application.DoEvents();
Keyboard.Focus(tbxLastName);