Domyślna wartość obiektu z metody i zapisywanie do zmiennych.

Chcę stworzyć obiekt klasy Robot który będzie domyślnie pobierał wartości z metod które mu przypisze, oraz jaki sposób będzie najlepszy na sumowanie zmiennych weight z wybranych metod ?

class Program
    {
        static void Main(string[] args)
        {
            Robot r1 = new Robot();
            r1.Engine_great(200, "trlalla", 200);
            r1.Skelly_A(400,300);
            
        }
    }
    class Robot
    {
        public void Engine_medium(int power, string name, int weight)
        {
            power = 100;
            weight = 230;
            name = "ZX:A100 Engine with medium power and medium weight";
        }
        public void Engine_great(int power, string name, int weight)
        {
            power = 130;
            weight = 350;
            name = "ZX:S100 Engine with high power and great weight";
        }

        public void Skelly_A(int weight, int agility)
        {
            weight = 400;
            agility = 10;
        }
        public void Skelly_S(int weight, int agility)
        {
            weight = 550;
            agility = 15;
        }

    }
} 

aleosohozi?

weight = weight + 230;

inaczej

weight += 230;

class Robot
    {
        int MyWeight;
        public void Engine_medium(int power, string name, int weight)
        {
            power = 100;
            weight = 230;
            MyWeight += weight;
            name = "ZX:A100 Engine with medium power and medium weight";
        }
        public void Engine_great(int power, string name, int weight)
        {
            power = 130;
            weight = 350;
            MyWeight += weight;
            name = "ZX:S100 Engine with high power and great weight";
        }
}

Swoją drogą po co przekazujesz na parametrze metody, skoro i tak w środku nadajesz inną wartość?

Nie o to mi chodzilo, gdybym miał wiecej podobnych metod i zsumowal weight tym sposobem, wynik mialbym z wszystkich metod a nie tylko z dwóch wybranych. Czemu w r1 nadałem inne wartości ? bo nie wiem jak zostawić te domyslne z metod.

Tego mi kompilator nie przyjmuje

r1.Engine_great(); 
r1.Skelly_A();

Gdy uda mi się zachować wartości ustalone w metodach, chce sumować to co pogrubiłem.

r1.Engine_great(200, "trlalla", 200);
r1.Skelly_A(400,300);

Przede wszystkim to nie masz tutaj żadnych domyślnych parametrów. Tutaj http://msdn.microsoft.com/en-us/library/dd264739.aspx w sekcji Optional Arguments jest wyjaśnione jak to się robi...

lepiej stwórz osobne klasy Engine, Skelly i klasy pochodne np. GreatEngine, a w klasie robota odpowiednie pola typu Engine, Skelly itd.

 
namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            Robot r1 = new Robot();
           int waga = r1.zliczwage();
            Console.WriteLine(waga);
            Console.ReadLine();
        }
    }
class Skelly
    {

    }
    class Skelly1 : Skelly
    {
        public int skelly1weight()
        {
            return 150;
        }
    }
    public class Engines
    {

    }
    public class Engine1 : Engines
    {
        public int Engine1weight()
        {
            return 100;
        }
        public int Engine1power()
        {
            return 40;
        }
    }
    class Robot
    {
        public int zliczwage()
        {
            Engine1 en1 = new Engine1();
            int x = en1.Engine1weight();
            Skelly1 sk1 = new Skelly1();
            int y = sk1.skelly1weight();
            return x + y;
        }
    }
}

Działa tak jak chciałem, tylko piszcząc to czułem się jakbym szedł w głąb tunelu bez latarki, i teraz gdy się odwrócę.. to nie wiem gdzie jestem.

Da się taki efekt uzyskać prościej ?

 using System;
namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {

            
            Console.WriteLine(Robot.zliczwage());
            Console.ReadLine();
        }
    }
    class Skelly
    {

    }
    class Skelly1 : Skelly
    {
       static public int skelly1weight()
        {
            return 150;
        }
    }
    public class Engines
    {

    }
    public class Engine1 : Engines
    {
       static public int Engine1weight()
        {
            return 100;
        }
     static   public int Engine1power()
        {
            return 40;
        }
    }
    class Robot
    {
        static public int zliczwage()
        {

            return (Skelly1.skelly1weight() + Engine1.Engine1weight());
        }
    }
}

metody weight i power powinny być wirtualne, a w klasach nadrzędnych abstrakcyjne.

class Robot
    {

     static void Main(string[] args)
        {

            Robot r1 = new Robot();
            r1.obliczwage();
            Console.WriteLine(r1.obliczwage());
            Console.ReadLine();
            
        }

     public int obliczwage()
        {
            return (Engine1.Engine1Weight() + Skelly.SkellyWeight());
        }
    }

    struct Engine1
    {
       static public int Engine1Power()
        {
            return 80;
        }
       static public int Engine1Weight()
        {
            return 200;
        }
    }

    struct Skelly
    {
        static public int SkellyWeight()
        {
            return 1300;
        }
    }

Tak chyba wyglada lepiej ?

Abstrakcja i wirtualizm wciąż są mi obce

Wasze komentarze to boost dla mojej wiedzy, niestety mało z nich rozumiem..

Zamieniłem klasy na struktury, bo wyczytałem że lepiej je używać w momentach kiedy class'a nie wymaga jakiejs rozbudowy a przechowuje tylko dane.

Na samym początku myślałem, że jeszcze ładniej będzie jak takie statyczne informacje będe trzymał w plikach XML, niestety jak na razie serializacja mnie przerasta, i odbijam się od łatwiejszych rzeczy.

Hm ja bym podszedł do zagadnienia innaczej.
Stworzyłbym podstawową,wirtualną klasę Device po której dziedziczyły te wszystkie roboty,enginy i insze,a która to posiadałaby pole weight oraz wirtualny akcesor doń.
W klasie robot dałbym List<Device> instaledDevices i przeimplementował ową metodę wirtualną tak,żeby prócz wagi samego korpusu robota leciała po liście i dodawała wagi znalezionych urządzeń.
Alternatywą jest trzymanie tej sumarycznej wagi w jakiejś zmiennej,którą będziesz aktualizował podczas dokładania/wymontowywania urządzenia z robota.