Mam aplikację Winforms. W głównej formie zakodowałem metodę, która wyczyści wszystkie pola tekstowe w dowolnej formie jest przekazywane jako parametr. Chcę zadzwonić do tej metody z innej formy. Poniższy kod jest tym, co wymyśliłem po wielu próbach / błędach i przeglądając tę stronę. Czy instancja jest instancja nowej wersji głównej formy za każdym razem, gdy wyczyścił przycisk nowej formularza, kliknęło dobrą praktykę? Gdybym miał stworzyć kolejną formę z własnym wyczyść cały przycisk, musiałbym utworzyć nową główną formę przez podobną praktykę (chyba że zrobiłem metodę statyczną)? Czy ktoś może zaproponować alternatywne sposoby dostępu do metody jednej formularza z innej formy? Z góry bardzo dziękuję.

Edytuj: Wiem, że metoda statyczna byłaby prostym i skutecznym rozwiązaniem, ale jestem ciekawa przy użyciu niestatycznego sposobu.

public partial class Form1 : Form
{
    public Form1()
    {
        InitializeComponent();
    }
    public  void ClearAll(Form formToClear) //CLEAR TEXTBOXES
    {
        foreach (var box in formToClear.Controls.OfType<TextBox>())
        {
            box.Text = "";
        }
    }

 }

public partial class NewItemForm : Form
{
    public NewItemForm()
    {

        InitializeComponent();
    }

     private void clearAllButton_Click(object sender, EventArgs e)
    {
        Form1 mainForm=new Form1();
        mainForm.ClearAll(this);
    }
}
0
aGuy 4 czerwiec 2018, 04:30

3 odpowiedzi

Najlepsza odpowiedź

Nie musisz tworzyć metody Wytwarzającej statyczną. Wystarczy, jeśli zachowujesz globalne odniesienie do Twojego głównego formularza. Możesz to zrobić w programie.cs. To nie jest najlepszy sposób.

static class Program {
    public static Form1 TheForm;

    [STAThread]
    static void Main() {
        Application.EnableVisualStyles();
        Application.SetCompatibleTextRenderingDefault(false);
        TheForm = new Form1();
        Application.Run(TheForm);
    }
}

Jeszcze raz! Tylko dlatego, że można to zrobić, nie oznacza to, że zachęciłbym cię robiąc. To nie jest w duchu OOP.

Jeśli jedynym powodem, dla którego chcesz uzyskać dostęp do metody Form1, jest wyczyścić pola tekstowe, a następnie polecam tworzenie klasy pośredniej:

public class InterForm : Form
{
    public void ClearAll() //CLEAR TEXTBOXES
    {
        foreach (var box in this.Controls.OfType<TextBox>())
        {
            box.Text = "";
        }
    }
 }

Cała druga forma powinna dziedziczyć z InterForm.

2
PepitoSh 4 czerwiec 2018, 04:12

Należy prawie na pewno stworzyć statyczną klasę narzędziową z funkcjami statycznymi. Będzie to zachować pamięć, zapobiegając niepotrzebnym {X0}}. W zależności od wielkości klasy swojej klasy, a obiekty / zmienne zawarte wewnątrz, tworząc nową instancję, aby użyć 1 funkcji z tej klasy, może ostatecznie doprowadzić do dużej ilości utraconej pamięci w czasie. Metoda statyczna w klasie statycznej uniemożliwiłaby, że odbywają się, ponieważ metody statyczne są zdefiniowane tylko raz w całym okresie trwania procesu, w porównaniu z pojedynczym razie.

Prawdopodobnie powinieneś iść z czymś takim jak:

internal static class FormUtils
{
    internal static void ClearAllTextBoxes(Form form)
    {
        if (form == null)
            return;
        if (form.Controls.Count <= 0)
            return;
        foreach (var box in form.Controls.OfType<TextBox>())
        {
            box.Clear();
        }
    }
}

Następnie funkcja ta byłaby użyta taka:

public partial class NewItemForm : Form
{
    public NewItemForm()
    {
        InitializeComponent();
    }

    private void clearAllButton_Click(object sender, EventArgs e)
    {
        FormUtils.ClearAllTextBoxes(this);
    }
}
2
Aaron Chapman 4 czerwiec 2018, 02:21

Możesz tutaj użyć koncepcji Event.

Twoja kolejna forma formularza, w której chcesz wywołać metodę głównego formularza, powinno mieć wydarzenie,

Tworząc instancję tego formularza (myślę, że tworzysz instancję tego formularza tylko z głównej formy) Możesz subskrybować zdarzenie tego formularza do docelowej metody.

Więc za każdym razem, gdy musisz zadzwonić do tej metody swojej głównej formy (z innego formularza), możesz podnieść ten wydarzenie.

Patrz poniżej przykładowy kod.

Załóżmy, że Form1 jest twoją główną formą

public partial class Form1 : Form
{
    public Form1()
    {
        InitializeComponent();
    }

    void f2_ClearTextBoxOfForm(Form targetForm)
    {
        foreach (Control control in targetForm.Controls)
        {
            if (control is TextBox)
                ((TextBox)control).Text = string.Empty;
        }
    }

    private void btnShowForm2_Click(object sender, EventArgs e)
    {
        Form2 f2 = new Form2();
        f2.ClearTextBoxOfForm += f2_ClearTextBoxOfForm;
        f2.Show();
    }
}

I Form2 jest Twoją inną formą, z której chcesz usunąć wszystkie pola tekstowe Form1

public delegate void ClearTextBoxEventHandler (Form targetForm);
public partial class Form2 : Form
{
    public event ClearTextBoxEventHandler ClearTextBoxOfForm;
    public Form2()
    {
        InitializeComponent();
    }

    private void btnClearTextBox_Click(object sender, EventArgs e)
    {
        if (ClearTextBoxOfForm != null)
        {
            //here passing 'this' means we want to clear textBoxes of this form (Form2)
            //you can pass any Form's object of which you want to clear Textboxes
            ClearTextBoxOfForm(this);
        }
    }
}
2
Amit 4 czerwiec 2018, 02:52