Du bist nicht angemeldet.

Stilllegung des Forums
Das Forum wurde am 05.06.2023 nach über 20 Jahren stillgelegt (weitere Informationen und ein kleiner Rückblick).
Registrierungen, Anmeldungen und Postings sind nicht mehr möglich. Öffentliche Inhalte sind weiterhin zugänglich.
Das Team von spieleprogrammierer.de bedankt sich bei der Community für die vielen schönen Jahre.
Wenn du eine deutschsprachige Spieleentwickler-Community suchst, schau doch mal im Discord und auf ZFX vorbei!

Critical Path Method

Werbeanzeige

Garzec

Alter Hase

  • »Garzec« ist der Autor dieses Themas

Beiträge: 693

Wohnort: Gießen

  • Private Nachricht senden

1

31.03.2017, 17:19

Critical Path Method

Guten Tag,
da ich heute ein Projekt abgeben muss, wollte ich mal fragen, ob sich jemand mit der CriticalPathMethod (Netzplan) auskennt. Mir geht es um die Logik eines Prozesses, würde sich jemand finden, der sich bereit erklärt, mal meine Berechnungen der Zeiten etc. zu checken? :)

Es gibt dabei ja dann doch ein paar, wenn auch nicht viele, Sonderbedingungen. Wäre sehr nett.

Hier mal ein einzelner Prozess:

C#-Quelltext

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

internal class Process
    {
        public Process(int id, string name, int duration) // ProzessId, ProzessName, ProzessDauer
        {
            ProcessId = id;
            ProcessName = name;
            ProcessDuration = duration;
        }

        public List<Process> Predecessors { get; set; } = new List<Process>(); // Liste aller Vorgängerprozesse
        public List<Process> Successors { get; set; } = new List<Process>(); // Liste aller Folgeprozesse

        public int ProcessId { get; set; }
        public string ProcessName { get; set; }
        public int ProcessDuration { get; set; }

        public int EarlyStart // Der früheste Startpunkt
        {
            get
            {
                if (Predecessors.Count == 0) // bei keinen Vorgängern ist der Startpunkt 0
                    return 0;

                    int max = 0;
                    foreach (Process val in Predecessors)
                    {
                        if (val.EarlyFinish > max)
                            max = val.EarlyFinish;
                    }
                    return max;
            }
        }

        public int LateStart { get { return LateFinish - ProcessDuration; } } // Spätester Beginn

        public int EarlyFinish { get { return EarlyStart + ProcessDuration; } } // Früheste Fertigstellung

        public int LateFinish // Späteste Fertigstellung
        {
            get
            {
                if (Predecessors.Count == 0) // Ohne Nachfolger ist die Dauer das späteste Ende
                    return ProcessDuration;

                    int min = int.MaxValue;
                    foreach (Process val in Successors)
                    {
                        if (val.EarlyStart < min)
                            min = val.EarlyStart;
                    }
                    return min;
            }
        }

        public int EntireBuffer { get { return LateStart - EarlyStart; } } // Gesamtpuffer

        public int FreeBuffer // Freier Puffer
        {
            get
            {        
                int minStartSuccessor = int.MaxValue;
                foreach (Process val in Successors)
                {
                    if (val.EarlyStart < minStartSuccessor)
                        minStartSuccessor = val.EarlyStart;
                }
                return minStartSuccessor - EarlyFinish;
            }
        }

        public bool IsCritical // Prozess ist kritisch?
        {
            get
            {
                if (LateStart == EarlyStart)
                    return true;
                return false;
            }
        }

        public bool IsStartProcess // Prozess ist Startprozess?
        {
            get
            {
                if (Predecessors.Count == 0)
                    return true;
                return false;
            }
        }

        public bool IsEndProcess // Prozess ist Endprozess?
        {
            get
            {
                if (Successors.Count == 0)
                    return true;
                return false;
            }
        }

        public void AddPredecessor(Process predecessor) // Füge Vorgänger hinzu
        {
            Predecessors.Add(predecessor);
        }

        public void AddSuccessor(Process successor) // Füge Nachfolger hinzu
        {
            if (Predecessors.Count > 0) // Keine Vorgänger vorhanden?
            {
                if (Predecessors[Predecessors.Count - 1] == successor) // Vorgänger darf nicht Nachfolger sein -> Endlosschleife
                    return;
            }

            Successors.Add(successor);
        }
    }

Renegade

Alter Hase

Beiträge: 494

Wohnort: Berlin

Beruf: Certified Unity Developer

  • Private Nachricht senden

2

31.03.2017, 20:45

//Offtopic:
Ich empfinde Getter mit Bedingungen und Verzweigungen nicht mehr als ein simples Get, da sich dahinter unsichtbare Logik verbirgt. Bei simplen Umrechnungen wie von Absolut in Prozent o.ä. ist ein Get völlig legitim, aber eine Get wie EarlyStart ist imo eine CalculateEarlyStart-Methode mit Rückgabewert.
(Sollte darüber Diskussionsbedarf bestehen, können wir gerne einen neuen Thread eröffnen. Das soll Garzec's Thema natürlich nicht überlagern.)

PS:

C#-Quelltext

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

public bool IsCritical // Prozess ist kritisch?
        {
            get
            {
                if (LateStart == EarlyStart)
                    return true;
                return false;
            }
        }

//ist das Gleiche wie...

public bool IsCritical // Prozess ist kritisch?
        {
            get
            {
                return LateStart == EarlyStart;
            }
        }

//Da logische Operatoren ein bool als "Rückgabewert" haben.
Liebe Grüße,
René

Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von »Renegade« (31.03.2017, 20:51)

Garzec

Alter Hase

  • »Garzec« ist der Autor dieses Themas

Beiträge: 693

Wohnort: Gießen

  • Private Nachricht senden

3

31.03.2017, 20:47

Ja, da gebe ich dir Recht, aus zeittechnischen Gründen, habe ich erstmal die gesamte Logik runtergeschrieben

Werbeanzeige

Ähnliche Themen