C# Wypisać ciąg instrukcji wykonywnaych po uruchomieniu.

Mam problem z zadaniem:
Wypisz ciąg instrukcji wykonywanych przy uruchomieniu programu...:
Cały program wygląda tak:

 
namespace Egzamin
{
    public delegate void funkcja(double x);
    class Klasa
    {
        public Klasa(funkcja f)
        {
            h = new funkcja(f);
            h(10.5);
        }
        private funkcja h;
    }
    class Program
    {
        private double z;
        public double Zet
        {
            get
            {
                --z; return z;
            }
            set
            {
                z = value - 3.0; --z;
            }
        }
        static Program p = new Program();
        static void Main(string[] args)
        {
            p.Zet = 0.7;
            Klasa c = new Klasa(p.logarytm);
            Console.WriteLine(p.z);
        }
        private void sinus(double x)
        {
            z = ++x - p.Zet;
        }
        private void cosinus(double x)
        {
            z = x-- + p.Zet;
        }
        private void logarytm(double x)
        {
            z = 2.0 * x * p.Zet;
        }
    }
}

Natomiast mam opisać tą część czyli sekcje zaczynającą program:

 
static Program p = new Program();
        static void Main(string[] args)
        {
            p.Zet = 0.7;
            Klasa c = new Klasa(p.logarytm);
            Console.WriteLine(p.z);
        }
        private void sinus(double x)
        {
            z = ++x - p.Zet;
        }
        private void cosinus(double x)
        {
            z = x-- + p.Zet;
        }
        private void logarytm(double x)
        {
            z = 2.0 * x * p.Zet;
        }
    }
}

Opisałem to tak:
Utworzenie nowego obiektu klasy Program
instrukcja przypisania
wywołanie metody Zet obiektu p
wywołanie akcesora Get
dekrementacja wartości z
zwrócenie wartości z
wywołanie akcesora Set
operator przypisania wartość - 3.0
dekrementacja wartości z
Stworzenie nowego obiektu c klasy Klasa
wywołanie konstruktora poprzez funkcje logarytm za pomocą delegacji
Wywołanie funkcji logarytm dla parametru 10.5
Wypisanie na ekran konsoli wartości zmiennej z obiektu p (-90.3)

Tylko że to jest niestety źle i nie mam pojęcia jak to prawidłowo opisać, Prosił bym o pomoc w zrobieniu tego prawidłowo.

pomoże ktoś?

Cześć, wydrukuj tego posta, weź siekierę i idź na uczelnię:

1. Program mówi "chcę wykonać main()", ale przed wykonaniem tej metody inicjalizowane są statyczne pola, czyli wykonuje się new Program().
2. Wykonuje się Main(), w którym tworzymy nowy obiekt Klasy -> wykonuje się konstruktor -> ... który wykonuje przekazaną w parametrze metodę...

... w tym momencie użyj siekiery, trud skończony. Feedback dla nauczycieli jest niezmiernie istotny, to zadanie jest głupie. Dziękuje za uwagę. Pozdrawiam.

Jeśli masz wypisać ciąg instrukcji czyli nazwy metod itd. (SyntaxTree) to możesz skorzystać z Roslyn.NET.

Proszę bardzo, rozkład kodu na czynniki tak jak sobie życzyłeś :P

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Roslyn.Compilers;
using Roslyn.Compilers.CSharp;
using Roslyn.Services;
using Roslyn.Services.CSharp;

namespace _4progRoslyn
{
    class Program
    {
        static void Main(string[] args)
        {
            SyntaxTree tree = SyntaxTree.ParseText(

                @"namespace Egzamin
{
    public delegate void funkcja(double x);
    class Klasa
    {
        public Klasa(funkcja f)
        {
            h = new funkcja(f);
            h(10.5);
        }
        private funkcja h;
    }
    class Program
    {
        private double z;
        public double Zet
        {
            get
            {
                --z; return z;
            }
            set
            {
                z = value - 3.0; --z;
            }
        }
        static Program p = new Program();
        static void Main(string[] args)
        {
            p.Zet = 0.7;
            Klasa c = new Klasa(p.logarytm);
            Console.WriteLine(p.z);
        }
        private void sinus(double x)
        {
            z = ++x - p.Zet;
        }
        private void cosinus(double x)
        {
            z = x-- + p.Zet;
        }
        private void logarytm(double x)
        {
            z = 2.0 * x * p.Zet;
        }
    }
}"

                );

            var root = (CompilationUnitSyntax)tree.GetRoot();

          
            foreach (var n in root.Members)
            {
                if (n is NamespaceDeclarationSyntax)
                {
                    foreach (var t in (n as NamespaceDeclarationSyntax).Members)
                    {
                        if (t is ClassDeclarationSyntax)
                        {
                            foreach (var i in (t as ClassDeclarationSyntax).Members)
                            {
                                if (i is PropertyDeclarationSyntax)
                                    Console.WriteLine("Property:\n\n {0}", i.GetText());
                                if (i is MethodDeclarationSyntax)
                                    Console.WriteLine("Method:\n\n {0}", i.GetText());
                                if (i is FieldDeclarationSyntax)
                                    Console.WriteLine("Field:\n\n {0}", i.GetText());
                            }
                        }
                    }
                }
            }

            Console.ReadLine();
        }
    }
}
 

Tu bardziej chodzi o taki opis PRZYKŁAD:

 
class Pierwsza 					
{ 
int x,y;									
public:						
Pierwsza(int a,int b)				
{
x=a+1;y=b;					
}
void f(void)					
{
cout<<"f z Pierwszej\nx="<<x<<" y="<<y<<"\n";	
}};

class Druga:public Pierwsza			
{
int x,y;					
public:						
Druga(void):Pierwsza(3,5){x=2;y=5;}		
Druga(int a,int b):Pierwsza(a,b) {x=a;y=b;}
void f(void)					
{
cout<<"f z Drugiej\nx"<<x<<" y="<<y<<"\n";	
}
};

int main()					
{
Pierwsza p(4,3);				
Druga d;								
p.f();						
d.f();						
((Pierwsza) d).f();				
return 0;
}

OPIS:

Klasa Pierwsza
Posiadająca prywatne atrybuty x i y
Konstruktor przyjmujący parametry (int a, int b)
Metoda void f()

Klasa Druga – jest rozszerzeniem klasy Pierwsza
Posiada prywatne atrybuty int x,y
Konstruktor bezparametrowy wraz z lista inicjalizacyjna, wywołanie nadrzędnego konstruktora i przekazując parametry 3 i 5 oraz ustawienie wartości domyślnych dla atrybutów x oraz y klasy Druga

Pierwsza p(4,3); //{W tym miejscu tworzony jest obiekt p klasy „Pierwsza” i wywołany konstruktor z parametrami (4,3). W definicji konstruktora jest:
x=a+1;
y=b;
czyli wartości tych atrybutów będą:
x=5; i y=3;

Druga d; //{Tworzony jest obiekt ‘d’ klasy „Druga” nie podając przy tym żadnych parametrów. W tym przypadku zostanie wywołane Druga(void):Pierwsza(3,5){x=2;y=5;}, atrybuty będą miały wartość: x=2; i y=5;}

p.f(); //{wywołanie metody f() typu void klasy Pierwsza, w tym przypadku otrzymamy: f z Pierwszej x=5 y=3}

d.f(); //{ wywołanie metody f() typu void klasy Druga, w tym wypadku otrzymamy: f z Drugiej x=2 y=5}
((Pierwsza) d).f(); //{wymuszenie rzutowania d na typ Pierwsza oraz wywołanie metody f()}

Na takiej zasadzie to ma być opisane.

Napisałeś „wypisz ciąg instrukcji” a nie „opisz” a to różnica.