Przesłanie metody jako argument pomiędzy oknami.

Witam was.

Na projekt na uczelnię piszę pewien programik, i nie jestem pewien poprawności wyboru ścieżki rozwiązania problemu, jaki obrałem.

Potrzebuję w jednym oknie operować danymi, które będą wczytane w drugim oknie, gdy wciśnie się na nim guzik. Rozwiązałem to tak, że przesyłam w konstruktorze funkcję formy głównej, która operuje danymi do formy drugiej, i w chwili kliknięcia przycisku wywołuje się funkcja formy głównej.

W skrócie wygląda to tak:

 
 public partial class FormaDruga: Window
    {

        Delegate funkcja;

        public FormaDruga(Delegate fun)
        {
            InitializeComponent();
            funkcja = fun;        

        private void buttonReady_Click(object sender, RoutedEventArgs e)
        {
            WczytajDane();
        }

       private void WczytajDane()
        {
           //wczytanie danych
           funkcja.DynamicInvoke(dane);
           this.Close();
        }
   }


 public partial class FormaGlowna: Window
    {
        private delegate void funkcja(Dane dane);
        private void OperacjeNaDanych(Dane dane)
        {
           // cos tam sie dzieje
        }

        private void button_Click(object sender, RoutedEventArgs e)
        {
            funkcja wywolywana = OperacjeNaDanych;
            FormaDruga = new FormaDruga(wywolywana);
            hdw.Show();
        }

    }

Wszystko działa, ale na mój gust, to strasznie nieprofesjonalne. Jest na to jakiś lepszy sposób?

edit. Pisane w WPF, ale to chyba różnicy nie robi w tej sprawie.

Jeśli chcesz powiadomić formę pierwszą, że coś stało się na drugiej, podejdź do tego od drugiej strony, mianowicie:
zrób sobie event na formie drugiej, np. OnDataReceived czy coś w tym guście, a potem w formie pierwszej przypisz ten event do jakiejś metody. Będziesz "nasłuchiwał". Jako argument eventu podajesz po prostu dane.

czyli kod którego potrzebujesz:

    class DrugaForma
    {
        public event EventHandler<MyEventArgs> myEvent;

        void DoSth()
        {
            MyEventArgs args = new MyEventArgs()
            {
                // Przypadkowe dane, normalnie wczytujesz je z pól tekstowych etc
                Id = 3,
                Name = "Maciek",
                Description = "jakis opis"
            }
            myEvent(null, args); // Wywołujemy zdarzenie, normalnie robimy to po naciśnięciu przycisku
        }
    }

    class PierwszaForma
    {
        void Start()
        {
            DrugaForma forma = new DrugaForma();
            forma.myEvent += new EventHandler<MyEventArgs>(forma_myEvent); //Zaczynamy nasłuchiwać
        }

        void forma_myEvent(object sender, MyEventArgs e)
        {
            //Jeśli cos się zdarzy (tzn wywołany zostanie myEvent) to tutaj mozesz operować zwróconymi danymi
            //Możesz dowolnie operować danymi, np.
            string fullname = e.Id + "-" + e.Name;
        }
    }

    class MyEventArgs : EventArgs
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public string Description { get; set; }
    }
 

Trochę osobliwe, ale wg mnie nie aż tak żeby ciskać w ciebie gromami. Widziałem tu gorsze wymysły :)

Należałoby określić gdzie mają być przechowywane dane, w którym oknie?
Czy inne okna też będą z nich korzystały?
Dlaczego funkcja znajduje się w oknie głównym? Bo te dane wpływają na jej wyświetlanie?
Czy forma druga na pewno ma być wyświetlana jako okno niemodalne?

Z tego kawałka kodu wydaje mi się że FormaDruga może być pokazywana jako okno modalne. Jeśli jest to prosty dialog do pobrania od użytkownika informacji niezbędnych do wczytania danych lepiej aby tylko do tego służył, a logika wczytania danych i przetwarzania ich była albo w oknie głównym, albo lepiej enkapsulowana w jakiejś klasie reprezentującej dane, czy klasie narzędziowej produkującej obiekt danych.

private MyDataType _data;

private void button_Click(object sender, RoutedEventArgs e)
{
  FormaDruga = new FormaDruga();
  if (hdw.ShowDialog() == DialogResult.OK)
  {
    // FormaDruga udostępnia informacje zebrane od uzytkownika niezbędne do załadowania danych w postaci właściwości
    
    LoadData(hdw.FilePath, ...);
    TransformData1();

    // lub
    _data.Load(hdw.FilePath, ...);
    MyDataTypeToDiasplay data2 = _data.TransformDataToDispaly();
  }
}

private void LoadData(string filePath, ...)
{
  _data = new MyDataType();
  // ładowanie danych do obiektu
}
private void TransformData1()
{
  // operacje na _data
}

private void DisplayData(MyDataTypeToDiasplay data)
{
  textbox1.Text = data.FirstName;
 ...
}

Ogólnie to do FormaDruga w konstruktorze przesyłane są także 2 inty, które określają nam ilość textBoxów, które będą tworzone w oknie drugim. Z nich są brane dane, wkładane do tablicy i przesyłane do FormyGłównej. Sorki za niedopisanie tego, ale myślałem, że bardziej zaciemni niż rozjaśni. FormaDruga wygląda tak:

Sposób ólnie bardzo ciekawy, zobaczę jak będzie wyglądać u mnie.