zagnieżdżona klasa z metodą w innej klasie

Witam,
mam prośbę o wskazówkę, jak wywołać metodę: KosztBenefitPackage z klasy zagnieżdżonej w innej klasie.
Relacja jest typu "ma", tzn. Pracownik ma BenefitPackage. Wiem jak wywołać typ z zagnieżdzonej klasy, ale mam problem z metodą.

w main.:

Pracowni Kazik = new Pracownik("5446846544", "Kazik", 50, 12000, 15, 666);
//ustawienie pakietu dla pracownika OK.
Pracownik.BenefitPackage pakiet = new Pracownik.BenefitPackage(true, true, Kazik);

// i teraz jak wywołać metodę KosztBenefitPackage np. w celu writleline kosztów pakietu, dla określonej instancji obiektu Pracownik.

 public class Pracownik
    {
        private string pracownik_Imie;
        private int pracownik_Wiek;
        private float pracownik_Wynagrodzenie;
        private int pracownik_Id;
        private string pracownik_Pesel;
        //public BenefitPackage BP;

        //**********************zagniezdzona*********************************************
        public class BenefitPackage
        {
            private bool Benefit_sport;
            private bool Benefit_zdrowie;
            public Pracownik emp;

            //konstruktor

            public BenefitPackage(bool BSport, bool BZdrowie, Pracownik pr)

            {
                sport = BSport;
                zdrowie = BZdrowie;
                emp = pr;
            }

            //     public BenefitPackage() { }


            public bool sport
            {
                get { return Benefit_sport; }
                set { Benefit_sport = value; }
            }

            public bool zdrowie
            {
                get { return Benefit_zdrowie; }
                set { Benefit_zdrowie = value; }

            }


            public double KosztBenefitPackage(Pracownik emp)
            {
                if (sport == true && zdrowie == true)
                {
                    return 200.00;
                    
                }

                else if ((sport == true && zdrowie == false) || (sport == false && zdrowie == true))
                {
                    return 150.00;
                
                }


                else
                {
                    return 0.0;
                }


            }



        }

część dalsza klasy Pracownik:

 public Pracownik(string pesel = "brak_numeru_pesel",string imie = "", int wiek = 0, float wynagrodzenie = 0, int id = 0)
        {
            Imie = imie;
            Wiek = wiek;
            Wynagrodzenie = wynagrodzenie;
            ID = id;
            pracownik_Pesel = pesel;
            
        }


      

    

        public string Pesel
        {
            get { return pracownik_Pesel; }
            //set { pracownik_Pesel = value; }
        }

        public string Imie
        {
            get { return pracownik_Imie; }
            set
            {
                if
                  (value.Length > 15)
                {
                    Console.WriteLine("Nazwisko nie może miec więcje niz 15 zankow!!!");
                }
                else
                { pracownik_Imie = value; }
            }
        }

        public int Wiek
        {
            get { return pracownik_Wiek; }
            set { pracownik_Wiek = value; }

        }
        public float Wynagrodzenie
        {
            get { return pracownik_Wynagrodzenie; }
            set { pracownik_Wynagrodzenie = value; }
        }

        public int ID
        {
            get { return pracownik_Id; }
            set { pracownik_Id = value; }
        }

        public float Premia(float podwyzka)
        {
            return Wynagrodzenie = Wynagrodzenie + podwyzka;
        }

    }

Pracowni Kazik = new Pracownik("5446846544", "Kazik", 50, 12000, 15, 666);
//ustawienie pakietu dla pracownika OK.
Pracownik.BenefitPackage pakiet = new Pracownik.BenefitPackage(true, true, Kazik);

na przykład tak

pakiet.KosztBenefitPackage(Kazik);

Jesteś pewny że ci to nie działa? Ja wrzuciłem na szybko w vs'a i twój kod się kompiluje.
pakiet.KosztBenefitPackage(Kazik) działa.
Co do zagnieżdżonej klasy BenefitPackage, poleciłbym użyć interfejsu.

Błękitny Samiec napisał(a):

Pracowni Kazik = new Pracownik("5446846544", "Kazik", 50, 12000, 15, 666);
//ustawienie pakietu dla pracownika OK.
Pracownik.BenefitPackage pakiet = new Pracownik.BenefitPackage(true, true, Kazik);

na przykład tak

pakiet.KosztBenefitPackage(Kazik);

No tak ;-) Racja, dzięki!

egotrip napisał(a):

Jesteś pewny że ci to nie działa? Ja wrzuciłem na szybko w vs'a i twój kod się kompiluje.
pakiet.KosztBenefitPackage(Kazik) działa.
Co do zagnieżdżonej klasy BenefitPackage, poleciłbym użyć interfejsu.
Działa, działa. Problem wynikał tylko z braku wiedzy, jak wywoływać metodę.
To są testy, potem klasa będzie zarządzała kolekcją obiektów, więc się rozbuduje...

Relacja ma - polega na tym, że obiekt jednej klasy zawiera obiekt innej klasy . To nie ma nic wspólnego z zagnieżdżaniem klas.
Klasę zagnieżdżoną robi się tylko w tedy jeśli jest to klasa pomocnicza klasy głównej i chcemy ją ukryć albo żeby była w jednym miejscu ,
w innym przypadku , jak podają w książkach, lepiej zastosować zagnieżdżone przestrzenie nazw.
Np. generyczna klasa List<T> zawiera zagnieżdżoną klasę Enumerator<T>
Wieczorem przejże twoje dzieło . Pozdrawiam

A może lepiej nie zagnieżdżać w sytuacji, w której to nie ma sensu?

Uczynny Samiec napisał(a):

Relacja ma - polega na tym, że obiekt jednej klasy zawiera obiekt innej klasy . To nie ma nic wspólnego z zagnieżdżaniem klas.
Klasę zagnieżdżoną robi się tylko w tedy jeśli jest to klasa pomocnicza klasy głównej i chcemy ją ukryć albo żeby była w jednym miejscu ,
w innym przypadku , jak podają w książkach, lepiej zastosować zagnieżdżone przestrzenie nazw.
Np. generyczna klasa List<T> zawiera zagnieżdżoną klasę Enumerator<T>
Wieczorem przejże twoje dzieło . Pozdrawiam

Formalnie klasa Pracownik powinna jeszcze mieć składową:
protected BenefitPackage empBenefit = new BenefitPackage();

somekind napisał(a):

A może lepiej nie zagnieżdżać w sytuacji, w której to nie ma sensu?

No właśnie nie jestem pewien, czy w takim wypadku nie lepiej zastosować delegację i nie zagnieżdżać tej klasy.

Teraz piszę pod swoim stałym nickiem . Poprzednim razem zapomniałem się zalogować .i było Uczynny Samiec

Klasa Pracownik powinna zawierać pole BenefitPackage . Dostęp do tego pola zrobiłbym przez właściwość , a klasę BenefitPackage zrobiłbym wewnętrzną i zamkniętą - z modyfikatorem internal
i sealed, żeby była dostępna tylko dla klas z z mojego pakietu . Zagnieżdżanie odpuściłbym sobie, bo nic nie daje

Zimny Krawiec napisał(a):

Teraz piszę pod swoim stałym nickiem . Poprzednim razem zapomniałem się zalogować .i było Uczynny Samiec

Klasa Pracownik powinna zawierać pole BenefitPackage . Dostęp do tego pola zrobiłbym przez właściwość , a klasę BenefitPackage zrobiłbym wewnętrzną - z modyfikatorem internal, żeby była dostępna tylko dla klas z z mojego pakietu . Zagnieżdżanie odpuściłbym sobie, bo nic nie daje

Aha rozumiem, to modyfikator klasy decyduje o tym, czy jest ona wewnętrzna, czy zagnieżdżona. Sorry, do tej pory myślałem, że każda klasa w klasie jest zagnieżdżona :-/

Klasa zagnieżdżona w innej klasie to co innego a klasa wewnętrzna to co innego .
Zanim zdecydujesz się na zagnieżdżoną klasę lub strukturę to lepiej się zapoznaj z jakimi konsekwencjami to się może wiązać

Zimny Krawiec napisał(a):

Klasa zagnieżdżona w innej klasie to co innego a klasa wewnętrzna to co innego .
Zanim zdecydujesz się na zagnieżdżoną klasę lub strukturę to lepiej się zapoznaj z jakimi konsekwencjami to się może wiązać

Rozumiem. Wiem, że zagnieżdżanie jest przydatne przy wątkach. Tutaj pewnie było niepotrzebne. Idę poczytać o tych konsekwencjach ;-)
Dzięki za pomoc.

Ten twój program to przykład z książki Język C# 6.0 i platforma . NET 4.6 albo którejś z wcześniejszych jej wersji .
W tej książce jest napisane że zagnieżdżanie klas jest rodzajem relacji ma .
Ten program to tylko taki prosty przykład na czym to wszystko polega . Nie znaczy to że w praktyce często tak się robi.
https://www.ecma-international.org/publications/files/ECMA-ST/Ecma-334.pdf - strona 276

Wracając do głównego pytania .Jak tworzysz obiekt klasy A to nie tworzysz obiektu klasy A + B ( tak jak to jest w przypadku dziedziczenia A: B ).tylko obiekt klasy A.

Nie dostaniesz się z obiektu ob2 do metody Method2()

        static void Main(string[] args)
        {
            A.B ob1 = new A.B();
            ob1.Method2();

            A ob2 = new A();
            ob2.Method1();
        }


public class A
    {
        public void Method1() { }

        public class B
        {
            public void Method2() { } 
        }
    }