button1.PerformClick () dans wpf

Pourquoi ce code dans WPF ne fonctionne pas ?

private void button1_Click(object sender, EventArgs e)
    {
        MessageBox.Show("yes");
    }
    private void Form1_Load(object sender, EventArgs e)
    {
        button1.PerformClick();
    }

J'ai besoin de commande.

source d'informationauteur visual2020

c#wpf

À utiliser l'application windows form style, vous devez écrire la suite de l'extension de la méthode:

namespace System.Windows.Controls
{
    public static class MyExt
    {
         public static void PerformClick(this Button btn)
         {
             btn.RaiseEvent(new RoutedEventArgs(Button.ClickEvent));
         }
    }
}

maintenant, vous pouvez l'utiliser pour n'importe quel bouton, en supposant un bouton appelé "btnOK":

btnOK.PerformClick();

9

Attendre.. il y a un moyen simple. si votre nom de bouton est button1 et cliquez sur button1 événement déjà inscrit,il vous suffira d'appeler cet événement comme
```
button1_Click(this,null);
```

Au lieu de PerformClick() utilisation RaiseEvent()

private void button1_Click(object sender, EventArgs e)
{
    MessageBox.Show("yes");
}
private void Form1_Load(object sender, EventArgs e)
{
    RoutedEventArgs newEventArgs = new RoutedEventArgs(Button.ClickEvent);
    button1.RaiseEvent(newEventArgs);         
}

Bonnes pratiques en WPF est à l'aide de commandes. Il améliore la testabilité et la sépare de l'INTERFACE utilisateur et la logique métier.

D'abord, vous pouvez essayer RoutedUICommand.

<Window x:Class="Test.MainWindow"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:self ="clr-namespace:Test"
    Title="MainWindow" 
    Height="350" Width="525">
<Window.CommandBindings>
    <CommandBinding Command="{x:Static self:MainWindow.RoutedClickCommand}"
                    CanExecute="CommandBinding_CanExecute"
                    Executed="CommandBinding_Executed"/>
</Window.CommandBindings>
<Grid>
    <Button Content="Test" Name="Btn1" Command="{x:Static self:MainWindow.RoutedClickCommand}"/>
</Grid>

Dans le fichier code-behind, nous devons définir RoutedClickCommand et Exécuter|CanExecute des gestionnaires:

    public static ICommand RoutedClickCommand = new RoutedUICommand("ClickCommand", "ClickCommand", typeof(MainWindow));

    private void CommandBinding_CanExecute(object sender, CanExecuteRoutedEventArgs e)
    {
        e.CanExecute = true;
    }

    private void CommandBinding_Executed(object sender, ExecutedRoutedEventArgs e)
    {
        MessageBox.Show("ololo");
    }

Donc, quand vous avez besoin le bouton de la logique ("button1.PerformClick();" dans votre exemple), il suffit de mettre la ligne suivante:

MainWindow.RoutedClickCommand.Execute(null);

Quant à moi, j'préférez un autre moyen qui suppose de réaliser la commande dans le modèle de présentation. Bibliothèque d'Applications composites (Prism) m'aide avec son DelegateCommand classe. Puis de définition de commande dans le modèle de présentation ressemble:

    private DelegateCommand<object> _clickCommand;

    public ICommand ClickCommand
    {
        get
        {
            if (this._clickCommand == null)
            {
                this._clickCommand = new DelegateCommand<object>(p =>
                    {
                        //command logic
                    },
                    p =>
                    { 
                        //can execute command logic
                    });
            }
            return this._clickCommand;
        }
    }

Et vue XAML et le code behind:

<Window x:Class="Test.MainWindow"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:self ="clr-namespace:Test"
    Title="MainWindow" 
    Height="350" Width="525">
<Grid>
    <Button Content="Test" Name="Btn1" Command="{Binding ClickCommand}"/>
</Grid>

public partial class MainWindow : Window
{
    public MainWindow()
    {
        InitializeComponent();
        this.Model = new SampleModel();
    }

    protected SampleModel Model
    {
        get
        {
            if (this.Model.ClickCommand.CanExecute())
            {
                this.Model.ClickCommand.Execute();
            }
            return (SampleModel)this.DataContext;   
        }
        set 
        {
            this.DataContext = value;
        }
    }
}

Suivant les appels de code de commande en vue de contourner cliquant sur le bouton:

if (this.Model.ClickCommand.CanExecute())
{
 this.Model.ClickCommand.Execute();
}

Un extrait de Adam Nathans WPF Unleashedrecommandé par ce blog.

À mon humble avis l'un des meilleurs, si pas le meilleur WPF références autour de.

var bap = new System.Windows.Automation.Peers.ButtonAutomationPeer(someButton);
var iip = bap.GetPattern(System.Windows.Automation.Peers.PatternInterface.Invoke)  
                            as System.Windows.Automation.Provider.IInvokeProvider;
iip.Invoke();

2

Je pense que le plus court et le plus efficace de la solution à votre problème est simplement de faire en une seule ligne.
```
button1.RaiseEvent(new RoutedEventArgs(Button.ClickEvent));
```
Qui devrait fonctionner pour WPF C#
1

Parce que PerformClick est une méthode de WindowsForms Bouton de contrôle:

http://msdn.microsoft.com/en-us/library/system.windows.forms.button.performclick.aspx

Pas sur le WPF Bouton de contrôle:

http://msdn.microsoft.com/en-us/library/system.windows.controls.button_methods.aspx

Pour automatiser un clic sur un bouton, vous pouvez prendre un coup d'oeil à l'INTERFACE d'automatisation cadre:

http://msdn.microsoft.com/en-us/library/ms747327.aspx

Vous devez vous connecter pour publier un commentaire.