C# - obsluga 312 RadioButton - jak połączyć w jedną procedurę?

Witam

Piszę dość specyficzny program. umieściłem w nim 312 RadioButtonów, które zostały podzielone w GroupBoxach (13 RadioButtonów w jednym GroupBoxie). Wciśnięcie któregokolwiek RadioButtona powoduje uruchomienie procedury obsługi tego zdarzenia, która na początku sprawdza czy dany RadioButton jest "Checked" a następnie wypełnia tablice Bajtową odpowiednimi danymi aby na końcu wysłać ciąg stworzonej tablicy na SerialPort.
Każdy RadioButton dokładnie ma robić to samo a różnica polega tylko na tym, ze w zależności, który RadioButton został wciśnięty to tablica jest wypełniana innymi danymi, które na końcu zostają wysłane na SerialPort.

Mam pytanie, jak zrobić, abym nie musiał robić 312 procedur obsługi zdarzenia dla każdego RadioButton, tylko zastąpić ja jedną procedurą, która rozpozna, który RadioButton został wciśnięty i następnie wypełnię sobie tablice wg potrzeb ?

Dodam, ze w zależności, który RadioButton wcisnę i w jakim jest GroupBoxie to odczytuje odpowiednie dane z odpowiedniego GroupBoxa (zawsze jest to ten sam GroupBox co wciśnięty RadioButton.

Ogólnie Mówiąc mam 2 wyjścia:

1. kopiować i modyfikować jedna procedurą obsługi zdarzenia RadioButtona (pewnie gdzieś się pomylę na 100%) i to 312 razy.
2. napisać jedną procedurę obsługi zdarzenia, która na początku rozpozna wciśnięty RadioButton i odpowiednio wypełni tablice.

Proszę o pomoc

Może użyj mechanizmu refleksji który będzie rozpoznawać co zostało wciśnięte i z jakiego groupboxa (a na podstawie tego wypełniał dane)? 312 podobnych procedur to zdecydowanie zaprzeczenie DRY :P

A możesz mi jakoś jaśniej to wyjaśnić ? nie za bardzo rozumiem "mechanizm refleksji" nawet nie wiem co to takiego :(

Ja sugeruje takie rozwiązanie:
Utworzyć jedno metodę która będzie podpinana do wszystkich RadioButtonów.
Przyciski możesz rozrużniać za pomocą obiektu Sender(Każdy przycisk będzie wysyłał, inny obiekt Sender). Jeżeli potrzebujesz dodać jakieś dane do konkretnego pola użyj property Tag. Teoretycznie możesz tam przypisać dowolną wartość referencyjną.

Właśnie myślałam o czymś takim, napisać własną procedurę obsługi, podpinać ją do wszystkich RadioButtonów.
Tylko nie wiem jak mogę ten "senser" obsłużyć ... myślałem ze "object sender" przejmuje wszystkie właściwości Radiobuttona i mogę się do nich odnieść.
Wtedy mógłbym Tabindex sobie odczytać i to by mi wystarczyło, ale cos nie mogę dojść jaka składnia :(

Myślałem, ze mogę zrobić cos takiego (poniżej moja procedura, którą musiałbym kopiować 312 razy zmieniając tylko kilka parametrów w każdej)

private void SD2_K1_F_CheckedChanged(object sender, EventArgs e)
        {
            if (SD2_K1_F.Checked == true)
            {
                int a = SD2_Okt1 + 5;
                int b = 0;

                if (SD2_K1_Szum.Checked == true) b = b + 128;
                if (SD2_K1_Prost.Checked == true) b = b + 64;
                if (SD2_K1_Pila.Checked == true) b = b + 32;
                if (SD2_K1_Trojkat.Checked == true) b = b + 16;
                if (b > 0) b = b + 1;

                USB_CMD_SD[1] = 0x01; 
                USB_CMD_SD[2] = 0x01; 
                USB_CMD_SD[3] = TabLow[a];
                USB_CMD_SD[4] = TabHigh[a];
                USB_CMD_SD[6] = Convert.ToByte(SD2_PW1_Value.Value / 256);
                USB_CMD_SD[5] = Convert.ToByte(SD2_PW1_Value.Value - (USB_CMD_SID[6] * 256));
                USB_CMD_SD[7] = Convert.ToByte(b);
                USB_CMD_SD[8] = Convert.ToByte((SD2_K1A.Value * 16) + SD2_K1D.Value);
                USB_CMD_SD[9] = Convert.ToByte((SD2_K1S.Value * 16) + SD2_K1R.Value);
             
                SerialPort.Write(USB_CMD_SD, 1, USB_CMD_SD[0]);
               
            } 

gdybym mógł się odnieść do Object sender i zrobić cos takiego:

private void RadioBottons_CheckedChanged(object sender, EventArgs e)
        {
            if (sender.Checked == true)
            {
                int a = SD2_Okt1 + sender.Tabindex;
                int b = 0;

                if (SD2_K1_Szum.Checked == true) b = b + 128;
                if (SD2_K1_Prost.Checked == true) b = b + 64;
                if (SD2_K1_Pila.Checked == true) b = b + 32;
                if (SD2_K1_Trojkat.Checked == true) b = b + 16;
                if (b > 0) b = b + 1;

                USB_CMD_SD[1] = 0x01; 
                USB_CMD_SD[2] = 0x01; 
                USB_CMD_SD[3] = TabLow[a];
                USB_CMD_SD[4] = TabHigh[a];
                USB_CMD_SD[6] = Convert.ToByte(SD2_PW1_Value.Value / 256);
                USB_CMD_SD[5] = Convert.ToByte(SD2_PW1_Value.Value - (USB_CMD_SID[6] * 256));
                USB_CMD_SD[7] = Convert.ToByte(b);
                USB_CMD_SD[8] = Convert.ToByte((SD2_K1A.Value * 16) + SD2_K1D.Value);
                USB_CMD_SD[9] = Convert.ToByte((SD2_K1S.Value * 16) + SD2_K1R.Value);
             
                SerialPort.Write(USB_CMD_SD, 1, USB_CMD_SD[0]);
               
            } 

I gdyby to zadziałało to zamiast 312 procedur, mogłybym napisać tylko 24 procedury, różniące się tylko elementem w danym GroupBoxie.
Cos robię źle, nie mogę składni jakoś ułożyć :-(

Sorry za taki banalny błąd dopiero zaczynam przygodę z C#

"sender" to obiekt, który wysłał zdarzenie (np. został kliknięty). zrzutuj go sobie na RadioButton.

RadioButton rb = (RadioButton)sender;

Zawsze możesz rzutować i będziesz miał wszystkie właściwości:

            RadioButton radioButton = (sender as RadioButton); //tu masz RadioButton
            GroupBox groupBox = (radioButton.Parent as GroupBox); //tu masz GroupBox na którym jest RadioButton

super !!!

Dzięki chłopaki o to mi chodziło.

To teraz mam jeszcze jedno pytanie :-D
Czy jest możliwość aby sprawdzić który RadioButton jest wciśnięty w jednym groupboxie ?

Musiałbyś sobie napisać jakąś funkcję np. tak:

        private RadioButton GetRadioButtonChecked(GroupBox groupBox) {
            if (groupBox == null) {
                return null;
            }
            foreach (Control ctrl in groupBox.Controls) {
                if (ctrl is RadioButton) {
                    if ((ctrl as RadioButton).Checked == true) {
                        return (ctrl as RadioButton);
                    }
                }
            }
            return null;
        }

Rozwiązałem to prościej :) dodałem zmienną w której zapamiętuje ostatnio kliknięty RadioButton :)

Napotkałem następny głupawy problem :-D

W moim GroupBoxie mam nie tylko RadioButtony, ale też są NumericUpDown i TrackBar.
Gdy zmieniam wartości tych komponentów to za każdą zmianą występuje zdarzenie ValueChanged i dana wysylana jest na SerialPort, ponieważ nie chcę wysyłać danych w każdej zmianie a tylko gdy już uzyskam daną wartość to postanowiłem zmienić zdarzenie ValueChanged na MouseUp i to działa prawie dobrze :-D
Prawie ponieważ w komponencie NumericUpDown, mogę kliknąć myszką i nie dokonać żadnych zmian i wtedy tez następuje zdarzenie i wysyła się dana na serial port bez żadnych zmian a to nie ma sensu.

Moje pytanie:
Czy można jakoś połączyć zdarzenie MouseUp i w nim sprawdzić czy wystąpiło również zdarzenie ValueChanged?

Na koniec jeszcze banalne pytanie. Jak wyłączyć możliwość edycji NumericUpDown w polu w którym jest wartość (np. przez wpisanie wartości z klawiatury) chcę mieć możliwość zmiany wartości tylko poprzez "strzałki góra/dół)

1. Nie wiem o co chodzi dlaczego nie możesz sprawdzać w ValueChanged czy wartość jest taka jaką chcesz.
2. Aby zablokować wpisywanie z klawiatury wystarczy:

        private void numericUpDown1_KeyPress(object sender, KeyPressEventArgs e)
        {
            e.Handled = true;
        }

Pozostaje jeszcze możliwość wklejenia a to można zablokować np. poprzez zablokowanie wyświetlania ContextMenu przypisując do komponentu puste ContextMenuStrip.

Dobra.... postaram się napisać trochę inaczej problem użycia zdarzenia ValueChanged.

Gdy użyję to zdarzenie na NumericUpDown lub trackball to zdarzenie występuje "co krok"... czyli mam wartość Value = 5 i naciskam strzałkę w NumericUpDown lub przesuwam trackbala aby zmienić wartość przykładowo na 15 to jak zachowa się zdarzenie ValueChanged ?
Otóż, wystąpi gdy Value będzie miało wartość 6 i 7 i 8 i 9 i 10 i 11 i 12 i 13 i 14 i 15 a to oznacza ze wyśle mi na SerialPort 10 razy tablice bajtów. A ja bym chciał aby wysłał tylko wtedy kiedy już będzie wartość 15 a nie wszystkie wartości aż do 15. (Program nie może sprawdzać czy jest już 15, ponieważ ta wartość jest zmienna a to, ze użytkownik chciał 15 czy 10 to tylko wie użytkownik programu) Dlatego używam zdarzenia MouseUP.

Ale MouseUp ma wadę, zdarzenie występuję za każdym razem kiedy "puszcze lewy guzik myszki" niezależnie od tego czy nastąpiła zmiana Value w tych komponentach. Dlatego chciałbym jakoś połączyć zdarzenie MouseUP z ValueChanged.

1. w zdarzeniu MouseUp sprawdzać czy nastąpiła zmiana w Value (gdyby była możliwość sprawdzenia flagi ValueChanged) to by rozwiązało problem.
2. w zdarzeniu ValueChanged sprawdzać stan lewego guzika myszki i jeżeli wciśnięty to opuścić zdarzenie.

Tu to chyba nie nakombinujesz jedynie jakaś zmienna

• na dzień dobry ustawiana na False
  *w MouseDown ustawiana na False
  *w ValueChanged na True
  *w MouseUp sprawdzasz stan zmiennej jeżeli True to ustawiasz ją na False i robisz co masz robisz.