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);
}
}
|