Duża grupa parametrów przekazywana do metody jako kolekcja

Zastanawiam się jak przekazywac parametry w jakiejś kolekcji do pętli, w której będzie wywoływana metoda "MakeSthTricky" z kolejnymi grupami parametrów.

MakeSthTricky(A, C, typ, AAId: "432", sda: 1, date: "2015-05-10 12:12:12")
MakeSthTricky(B, D, typ, sda: 2 AAId: "sda", date: "2012-05-12 12:12:12")
{i tak kilkanascie roznych}

private <TakiTyp>MakeStkTricky(XXX cos, YYY cos, Type typ, string AAId, int sda, string date)
{
[do magic]
return wynik
}

[tutaj propozycja]

foreach (paczka in wiele_paczek)
MakeSthTricky(paczka)

Proszę o propozycje

O co Ci konkretnie chodzi? nie możesz po prostu napisać napisać klasy/struktury i przeciażyć metode i przekazywać te klasę jako parametr?

struct TrickyParam
        {
            XXX cos,
            YYY cos,
            Type typ,
            string AAId,
            int sda, 
            string date
        }

        [...]

        
        ///
        TrickyParam p = new TrickyParam();
        p.cos = asdf;
        p.typ = jakisType ///etc

        ///petla 
        ///
        TrickyParam[] params = new TrickyParam[] { p , p2 ...}

       foreach(var p in params)
            MakeStkTricky(p);

To chyba raczej coś w tym rodzaju

Tylko nie structlecz class. Nie umieszcza się klas w strukturach.

Jezeli liczba parametrów mija liczbe 2,3 to znak ze nalezy rozwazyc czy nie zamknac chocby czesci w osobna klase.
Czasem sie nie da, albo parametry pochodza z wielu roznych kontekstów...ale wtedy zachodzi
podejrzenie ze metoda robi wiecej niz jedna rzecz, co jest nie fajne.

Czasem sie zadarza ze czesc parametrow jest prawie (lub doslownie) taka sama dla wszystkich wywolan.
Warto takze rozwazyc parametry domyslne -> czasem sie przydaja.

Czasem czesc parametrow jest juz zamknieta w innych klasach lub mozna je wyliczyc, zamiast je wyciagac pojedynczo, wystarczy podac 2-3 obiekty oraz zaimplementowac
odpowiednie metody (moze jakis interfejs).

Na koniec niby glupia rada, nic nie wnoszaca (na pozór):
moze warto rozwazyc wprowadzenie krokow/metod posrednich.
To moze ulatwic testowanie, diagnostyke kodu, a takze na noszenie zmian (jak wiemy...wymagania sie zmieniaja ;), niestety :D ).

Pawel

faktycznie dobrym sposobem jest wrzucanie obiektów z kolekcjami czy jak tam sobie chcesz np

Class MyTrick

// Tutaj masz swoją kolekcję nie wnikam
public MyTrick(){} // do stworzenia ręcznie obiektu pomijając wymagane pola
public MyTrick(MyTrickCollection mtrick) // inicjajca kalsy wraz z przesłaniem parametrów
{
this.,,Colection,.Add(mtrick.aaa);
this.,,Colection,.Add(mtrick.yyy);
this.,,Colection,.Add(mtrick.AAid); // czy jakoś tak
Przesyłasz jeden parametr i z niego wyciągasz co chcesz
}

// tutaj masz swoje metody i robione triki tez nie wnikam

MyTrickCollection
{
AAA aaa {getl; set;}
YYY yyy {get; set;}
int AAid what ever
}

Idźmy krok dalej dla sytuacji powiedzmy iż chcesz mieć jeden typ obiektu tak, ale rożnego typu wywołania dziedziczenie i polimorfizm możesz też zastosować ale powiedzmy każda klasa będzie miała jakieś magiczne triki oparte o przestawienie czegoś itp. Tutaj widzę zastosowanie.

Powiedzmy DoTrick będziesz miał w swojej kalsie i z 100 trików Podzielisz je sobie powiedzmy na

DoTrickWhitName - dla przykładu damy 2
DoTrickWhitSurName - dla przykłady damy 2

I teraz chcesz zrobić trick z nazwą poprzez litery, liczby czy datę

Jak to będzie wyglądać w praktyce
var trickObject = new MyTrick{ Aaid = 10, ......}

trickObject.DoTrichWhitName(By.Number(20,100));
trickObject.DoTrichWhitName(By.ListArray(listArray));
trickObject.DoTrichWhitName(By.Date(DateTime.Now));

Takie wywołania

Jak to zrobić. Budujesz klasę By

 
public class By
    {
        public static ByFilter Number(int num1, int num2)
        {
            return new ByIdRange(num1, num2);
        }

        /* jak widać zwracamy inny obiekt ByFilter*/
         public static ByFilter ListArray(List<string> listArray) // tutaj podajesz jakie chcesz mieć wywołanie oraz przyjmować parametry
        {
            return new ByTimeRange(listArray);
        }
    }

abstrakcja klasa, jak chcesz to ją rozwijaj

 
public abstract class ByFilter 
    {
    }

I następnie dla każdego filtru dodzaju wykonania budujesz sobie zwracany obiekt

 
public class Number : ByFilter
    {
        public int Num1;
        public int Num2;

        public ByNumber(int num1, int num2)
        {
            this.Num1 = num1;
            this.Num2 = num2;
        }
    }

Wywołanie już Ci pokazałem teraz tylko to trzeba zainicjować,

public string DoTrichWhitName(ByFilter by)
{
if (by is ByNumber)
{
return DoTrichWhitNameByNumber(by); // <- wywołanie tego pokażę
}
esle if (by is jakiś inny wymyślony typ)
{
}
}

private string DoTrichWhitNameByNumber(Byfilter by)
{
var filterTrick = (by as ByNumber);
filterTrick.Num1; // <- i spokojnie się do zmiennych odwołujesz
filterTrick.Num2;

}