Fehler bei Auslagerung von Klasse in andere Codedatei

  • C#

Es gibt 20 Antworten in diesem Thema. Der letzte Beitrag () ist von ErfinderDesRades.

    Fehler bei Auslagerung von Klasse in andere Codedatei

    Hi,
    ich probiere gerade, eine übersichtliche und vielseitige A*-Lib zu machen, jedoch scheitert VS aus irgendeinem bescheuerten Grund anscheinend daran, dass ich meine Klassen von der Hauptcodedatei in eine andere verschieben möchte. Bisher war alles ein richtiger Bandwurm, hier mal der Code (die eigentlichen Funktionen sind noch nicht implementiert, allerdings die Grundstruktur:
    Original-Code

    C#-Quellcode

    1. using System;
    2. using System.Collections.Generic;
    3. using System.Linq;
    4. using System.Text;
    5. using System.Threading.Tasks;
    6. using System.Drawing;
    8. namespace StefansAStarLibrary
    9. {
    10. public class AStar
    11. {
    12. /// <summary>
    13. /// Sucht mithilfe des A*-Algorhytmus einen möglichen Weg vom Start zum Ziel
    14. /// </summary>
    15. /// <param name="map">Die Map, in der der Weg gesucht werden soll</param>
    16. /// <param name="start">Der Startpunkt (muss sich in der Map befinden)</param>
    17. /// <param name="end">Der Endpunkt (muss sich in der Map befinden)</param>
    18. /// <param name="movableDirections">Die Anzahl der Richtungen, in welche sich der Path bewegen darf</param>
    19. /// <param name="heuristicFunction">Die Heuristik, die eingesetzt werden soll</param>
    20. /// <param name="tieBreaker">Der Wert, mit dem der H-Wert multipliziert wird, falls eine entsprechende Heuristische Funktion ausgewählt wurde</param>
    21. /// <param name="pathOutput">Hier wird das Ergebnis ausgegeben, falls der Lösungsversuch erfolgreich ist</param>
    22. /// <returns>Ob der Lösungsversuch geklappt hat</returns>
    23. public bool TrySolve(Map map, Node start, Node end, DirectionCount movableDirections, HeuristicFunction heuristicFunction, double tieBreaker, out List<Point> pathOutput)
    24. {
    27. //Zu Testzwecken, damit keine unnötigen Fehler geworfen werden
    28. pathOutput = null;
    29. return false;
    30. }
    32. //Die anderen Versionen der Methode, alle verweisen direkt oder indirekt auf die Methode TrySolve(Map, Node, Node, DirectionCount, Heuristic, double, out List<Point>)
    33. #region OtherVersions
    34. /*Aufbau
    35. * Gruppen, immer sortiert nach
    36. * -TrySolve (Node)
    37. * -Solve (Node)
    38. * -TrySolve (Point)
    39. * -Solve (Point)
    40. */
    42. /// <summary>
    43. /// Sucht mithilfe des A*-Algorhytmus einen möglichen Weg vom Start zum Ziel
    44. /// </summary>
    45. /// <param name="map">Die Map, in der der Weg gesucht werden soll</param>
    46. /// <param name="start">Der Startpunkt (muss sich in der Map befinden)</param>
    47. /// <param name="end">Der Endpunkt (muss sich in der Map befinden)</param>
    48. /// <param name="pathOutput">Hier wird das Ergebnis ausgegeben, falls der Lösungsversuch erfolgreich ist</param>
    49. /// <returns>Ob der Lösungsversuch geklappt hat</returns>
    50. public bool TrySolve(Map map, Node start, Node end, out List<Point> pathOutput)
    51. {
    52. return TrySolve(map, start, end, DirectionCount.Four, HeuristicFunction.Manhattan, 1, out pathOutput);
    53. }
    54. /// <summary>
    55. /// Sucht mithilfe des A*-Algorhytmus einen möglichen Weg vom Start zum Ziel
    56. /// </summary>
    57. /// <param name="map">Die Map, in der der Weg gesucht werden soll</param>
    58. /// <param name="start">Der Startpunkt</param>
    59. /// <param name="end">Der Endpunkt</param>
    60. /// <returns>Das Ergebnis der Wegsuche</returns>
    61. public List<Point> Solve(Map map, Node start, Node end)
    62. {
    63. List<Point> Path = new List<Point>();
    64. if (TrySolve(map, start, end, DirectionCount.Four, HeuristicFunction.Manhattan, 1, out Path))
    65. {
    66. return Path;
    67. }
    68. else
    69. {
    70. throw new Exception("Kein Weg gefunden");
    71. }
    72. }
    73. /// <summary>
    74. /// Sucht mithilfe des A*-Algorhytmus einen möglichen Weg vom Start zum Ziel
    75. /// </summary>
    76. /// <param name="map">Die Map, in der der Weg gesucht werden soll</param>
    77. /// <param name="start">Der Startpunkt</param>
    78. /// <param name="end">Der Endpunkt</param>
    79. /// <param name="pathOutput">Hier wird das Ergebnis ausgegeben, falls der Lösungsversuch erfolgreich ist</param>
    80. /// <returns>Ob der Lösungsversuch geklappt hat</returns>
    81. public bool TrySolve(Map map, Point start, Point end, out List<Point> pathOutput)
    82. {
    83. throw new NotImplementedException();
    84. }
    85. /// <summary>
    86. /// Sucht mithilfe des A*-Algorhytmus einen möglichen Weg vom Start zum Ziel
    87. /// </summary>
    88. /// <param name="map">Die Map, in der der Weg gesucht werden soll</param>
    89. /// <param name="start">Der Startpunkt</param>
    90. /// <param name="end">Der Endpunkt</param>
    91. /// <returns>Das Ergebnis der Wegsuche</returns>
    92. public List<Point> Solve(Map map, Point start, Point end)
    93. {
    94. throw new NotImplementedException();
    95. }
    97. /// <summary>
    98. /// Sucht mithilfe des A*-Algorhytmus einen möglichen Weg vom Start zum Ziel
    99. /// </summary>
    100. /// <param name="map">Die Map, in der der Weg gesucht werden soll</param>
    101. /// <param name="start">Der Startpunkt (muss sich in der Map befinden)</param>
    102. /// <param name="end">Der Endpunkt (muss sich in der Map befinden)</param>
    103. /// <param name="movableDirections">Die Anzahl der Richtungen, in welche sich der Path bewegen darf</param>
    104. /// <param name="pathOutput">Hier wird das Ergebnis ausgegeben, falls der Lösungsversuch erfolgreich ist</param>
    105. /// <returns>Ob der Lösungsversuch geklappt hat</returns>
    106. public bool TrySolve(Map map, Node start, Node end, DirectionCount movableDirections, out List<Point> pathOutput)
    107. {
    108. return TrySolve(map, start, end, movableDirections, HeuristicFunction.Manhattan, 1, out pathOutput);
    109. }
    110. /// <summary>
    111. /// Sucht mithilfe des A*-Algorhytmus einen möglichen Weg vom Start zum Ziel
    112. /// </summary>
    113. /// <param name="map">Die Map, in der der Weg gesucht werden soll</param>
    114. /// <param name="start">Der Startpunkt (muss sich in der Map befinden)</param>
    115. /// <param name="end">Der Endpunkt (muss sich in der Map befinden)</param>
    116. /// <param name="movableDirections">Die Anzahl der Richtungen, in welche sich der Path bewegen darf</param>
    117. /// <returns>Das Ergebnis der Wegsuche</returns>
    118. public List<Point> Solve(Map map, Node start, Node end, DirectionCount movableDirections)
    119. {
    120. List<Point> Path = new List<Point>();
    121. if (TrySolve(map, start, end, movableDirections, HeuristicFunction.Manhattan, 1, out Path))
    122. {
    123. return Path;
    124. }
    125. else
    126. {
    127. throw new Exception("Kein Weg gefunden");
    128. }
    129. }
    130. /// <summary>
    131. /// Sucht mithilfe des A*-Algorhytmus einen möglichen Weg vom Start zum Ziel
    132. /// </summary>
    133. /// <param name="map">Die Map, in der der Weg gesucht werden soll</param>
    134. /// <param name="start">Der Startpunkt</param>
    135. /// <param name="end">Der Endpunkt</param>
    136. /// <param name="movableDirections">Die Anzahl der Richtungen, in welche sich der Path bewegen darf</param>
    137. /// <param name="pathOutput">Hier wird das Ergebnis ausgegeben, falls der Lösungsversuch erfolgreich ist</param>
    138. /// <returns>Ob der Lösungsversuch geklappt hat</returns>
    139. public bool TrySolve(Map map, Point start, Point end, DirectionCount movableDirections, out List<Point> pathOutput)
    140. {
    141. throw new NotImplementedException();
    142. }
    143. /// <summary>
    144. /// Sucht mithilfe des A*-Algorhytmus einen möglichen Weg vom Start zum Ziel
    145. /// </summary>
    146. /// <param name="map">Die Map, in der der Weg gesucht werden soll</param>
    147. /// <param name="start">Der Startpunkt</param>
    148. /// <param name="end">Der Endpunkt</param>
    149. /// <param name="movableDirections">Die Anzahl der Richtungen, in welche sich der Path bewegen darf</param>
    150. /// <returns>Das Ergebnis der Wegsuche</returns>
    151. public List<Point> Solve(Map map, Point start, Point end, DirectionCount movableDirections)
    152. {
    153. throw new NotImplementedException();
    154. }
    156. /// <summary>
    157. /// Sucht mithilfe des A*-Algorhytmus einen möglichen Weg vom Start zum Ziel
    158. /// </summary>
    159. /// <param name="map">Die Map, in der der Weg gesucht werden soll</param>
    160. /// <param name="start">Der Startpunkt (muss sich in der Map befinden)</param>
    161. /// <param name="end">Der Endpunkt (muss sich in der Map befinden)</param>
    162. /// <param name="movableDirections">Die Anzahl der Richtungen, in welche sich der Path bewegen darf</param>
    163. /// <param name="heuristicFunction">Die Heuristik, die eingesetzt werden soll</param>
    164. /// <param name="pathOutput">Hier wird das Ergebnis ausgegeben, falls der Lösungsversuch erfolgreich ist</param>
    165. /// <returns>Ob der Lösungsversuch geklappt hat</returns>
    166. public bool TrySolve(Map map, Node start, Node end, DirectionCount movableDirections, HeuristicFunction heuristicFunction, out List<Point> pathOutput)
    167. {
    168. return TrySolve(map, start, end, movableDirections, heuristicFunction, 1, out pathOutput);
    169. }
    170. /// <summary>
    171. /// Sucht mithilfe des A*-Algorhytmus einen möglichen Weg vom Start zum Ziel
    172. /// </summary>
    173. /// <param name="map">Die Map, in der der Weg gesucht werden soll</param>
    174. /// <param name="start">Der Startpunkt (muss sich in der Map befinden)</param>
    175. /// <param name="end">Der Endpunkt (muss sich in der Map befinden)</param>
    176. /// <param name="movableDirections">Die Anzahl der Richtungen, in welche sich der Path bewegen darf</param>
    177. /// <param name="heuristicFunction">Die Heuristik, die eingesetzt werden soll</param>
    178. /// <returns>Das Ergebnis der Wegsuche</returns>
    179. public List<Point> Solve(Map map, Node start, Node end, DirectionCount movableDirections, HeuristicFunction heuristicFunction)
    180. {
    181. List<Point> Path = new List<Point>();
    182. if (TrySolve(map, start, end, movableDirections, heuristicFunction, 1, out Path))
    183. {
    184. return Path;
    185. }
    186. else
    187. {
    188. throw new Exception("Kein Weg gefunden");
    189. }
    190. }
    191. /// <summary>
    192. /// Sucht mithilfe des A*-Algorhytmus einen möglichen Weg vom Start zum Ziel
    193. /// </summary>
    194. /// <param name="map">Die Map, in der der Weg gesucht werden soll</param>
    195. /// <param name="start">Der Startpunkt</param>
    196. /// <param name="end">Der Endpunkt</param>
    197. /// <param name="movableDirections">Die Anzahl der Richtungen, in welche sich der Path bewegen darf</param>
    198. /// <param name="heuristicFunction">Die Heuristik, die eingesetzt werden soll</param>
    199. /// <param name="pathOutput">Hier wird das Ergebnis ausgegeben, falls der Lösungsversuch erfolgreich ist</param>
    200. /// <returns>Ob der Lösungsversuch geklappt hat</returns>
    201. public bool TrySolve(Map map, Point start, Point end, DirectionCount movableDirections, HeuristicFunction heuristicFunction, out List<Point> pathOutput)
    202. {
    203. throw new NotImplementedException();
    204. }
    205. /// <summary>
    206. /// Sucht mithilfe des A*-Algorhytmus einen möglichen Weg vom Start zum Ziel
    207. /// </summary>
    208. /// <param name="map">Die Map, in der der Weg gesucht werden soll</param>
    209. /// <param name="start">Der Startpunkt</param>
    210. /// <param name="end">Der Endpunkt</param>
    211. /// <param name="movableDirections">Die Anzahl der Richtungen, in welche sich der Path bewegen darf</param>
    212. /// <param name="heuristicFunction">Die Heuristik, die eingesetzt werden soll</param>
    213. /// <returns>Das Ergebnis der Wegsuche</returns>
    214. public List<Point> Solve(Map map, Point start, Point end, DirectionCount movableDirections, HeuristicFunction heuristicFunction)
    215. {
    216. throw new NotImplementedException();
    217. }
    219. #endregion
    220. }
    221. /// <summary>
    222. /// Gibt an, wie viele Bewegungsrichtungen erwägt werden
    223. /// </summary>
    224. public enum DirectionCount
    225. {
    226. /// <summary>
    227. /// Stellt 4 Bewegungsrichtungen zur Verfügung
    228. /// </summary>
    229. Four,
    230. /// <summary>
    231. /// Stellt 8 Bewegungsrichtungen zur Verfügung
    232. /// </summary>
    233. Eight
    234. }
    235. /// <summary>
    236. /// Stellt eine Heuristik dar
    237. /// </summary>
    238. public class HeuristicFunction
    239. {
    240. public Func<Point, Point, double> Function { get; private set; }
    242. public bool TieBreak { get; private set; }
    244. /// <summary>
    245. /// Erstellt eine neue HeuristicFunction-Klasse
    246. /// </summary>
    247. /// <param name="functionSource">Die Heuristische Funktion, Form: '(start, end) => H'</param>
    248. /// <param name="tieBreak">Gibt an, ob TieBreaking aktiviert werden soll</param>
    249. public HeuristicFunction(Func<Point, Point, double> function, bool tieBreak)
    250. {
    251. this.Function = function;
    252. this.TieBreak = tieBreak;
    253. }
    255. /// <summary>
    256. /// Erstellt eine neue HeuristicFunction-Klasse aus einer Vorlage
    257. /// </summary>
    258. /// <param name="functionSource">Die Vorlage</param>
    259. /// <param name="tieBreak">Gibt an, ob TieBreaking aktiviert werden soll</param>
    260. public HeuristicFunction(HeuristicFunction functionSource, bool tieBreak)
    261. {
    262. this.Function = functionSource.Function;
    263. this.TieBreak = tieBreak;
    264. }
    266. /// <summary>
    267. /// Die Manhattan-Heuristik
    268. /// </summary>
    269. public static const HeuristicFunction Manhattan =
    270. new HeuristicFunction((start, end) => Math.Abs(start.X - end.X) + Math.Abs(start.Y - end.Y), false);
    271. /// <summary>
    272. /// Die Diagonal-Heuristik
    273. /// </summary>
    274. public static const HeuristicFunction Diagonal =
    275. new HeuristicFunction((start, end) => Math.Max(Math.Abs(start.X - end.X), Math.Abs(start.Y - end.Y)), false);
    276. /// <summary>
    277. /// Die Euclidean-Heuristik
    278. /// </summary>
    279. public static const HeuristicFunction Euclidean =
    280. new HeuristicFunction((start, end) => Math.Sqrt(Math.Pow(start.X - end.X, 2) + Math.Pow(start.Y - end.Y, 2)), false);
    281. /// <summary>
    282. /// Die Euclidean-Sqared-Heuristik
    283. /// </summary>
    284. public static const HeuristicFunction EuclideanSqared =
    285. new HeuristicFunction((start, end) => Math.Pow(start.X - end.X, 2) + Math.Pow(start.Y - end.Y, 2), false);
    286. }
    287. }

    Das habe ich jetzt in 3 Codefiles auseinandergenommen:
    AStar.cs

    C#-Quellcode

    1. using System;
    2. using System.Collections.Generic;
    3. using System.Linq;
    4. using System.Text;
    5. using System.Threading.Tasks;
    6. using System.Drawing;
    8. namespace StefansAStarLibrary
    9. {
    10. public class AStar
    11. {
    12. /// <summary>
    13. /// Sucht mithilfe des A*-Algorhytmus einen möglichen Weg vom Start zum Ziel
    14. /// </summary>
    15. /// <param name="map">Die Map, in der der Weg gesucht werden soll</param>
    16. /// <param name="start">Der Startpunkt (muss sich in der Map befinden)</param>
    17. /// <param name="end">Der Endpunkt (muss sich in der Map befinden)</param>
    18. /// <param name="movableDirections">Die Anzahl der Richtungen, in welche sich der Path bewegen darf</param>
    19. /// <param name="heuristicFunction">Die Heuristik, die eingesetzt werden soll</param>
    20. /// <param name="tieBreaker">Der Wert, mit dem der H-Wert multipliziert wird, falls eine entsprechende Heuristische Funktion ausgewählt wurde</param>
    21. /// <param name="pathOutput">Hier wird das Ergebnis ausgegeben, falls der Lösungsversuch erfolgreich ist</param>
    22. /// <returns>Ob der Lösungsversuch geklappt hat</returns>
    23. public bool TrySolve(Map map, Node start, Node end, DirectionCount movableDirections, HeuristicFunction heuristicFunction, double tieBreaker, out List<Point> pathOutput)
    24. {
    27. //Zu Testzwecken, damit keine unnötigen Fehler geworfen werden
    28. pathOutput = null;
    29. return false;
    30. }
    32. //Die anderen Versionen der Methode, alle verweisen direkt oder indirekt auf die Methode TrySolve(Map, Node, Node, DirectionCount, Heuristic, double, out List<Point>)
    33. #region OtherVersions
    34. /*Aufbau
    35. * Gruppen, immer sortiert nach
    36. * -TrySolve (Node)
    37. * -Solve (Node)
    38. * -TrySolve (Point)
    39. * -Solve (Point)
    40. */
    42. /// <summary>
    43. /// Sucht mithilfe des A*-Algorhytmus einen möglichen Weg vom Start zum Ziel
    44. /// </summary>
    45. /// <param name="map">Die Map, in der der Weg gesucht werden soll</param>
    46. /// <param name="start">Der Startpunkt (muss sich in der Map befinden)</param>
    47. /// <param name="end">Der Endpunkt (muss sich in der Map befinden)</param>
    48. /// <param name="pathOutput">Hier wird das Ergebnis ausgegeben, falls der Lösungsversuch erfolgreich ist</param>
    49. /// <returns>Ob der Lösungsversuch geklappt hat</returns>
    50. public bool TrySolve(Map map, Node start, Node end, out List<Point> pathOutput)
    51. {
    52. return TrySolve(map, start, end, DirectionCount.Four, HeuristicFunction.Manhattan, 1, out pathOutput);
    53. }
    54. /// <summary>
    55. /// Sucht mithilfe des A*-Algorhytmus einen möglichen Weg vom Start zum Ziel
    56. /// </summary>
    57. /// <param name="map">Die Map, in der der Weg gesucht werden soll</param>
    58. /// <param name="start">Der Startpunkt</param>
    59. /// <param name="end">Der Endpunkt</param>
    60. /// <returns>Das Ergebnis der Wegsuche</returns>
    61. public List<Point> Solve(Map map, Node start, Node end)
    62. {
    63. List<Point> Path = new List<Point>();
    64. if (TrySolve(map, start, end, DirectionCount.Four, HeuristicFunction.Manhattan, 1, out Path))
    65. {
    66. return Path;
    67. }
    68. else
    69. {
    70. throw new Exception("Kein Weg gefunden");
    71. }
    72. }
    73. /// <summary>
    74. /// Sucht mithilfe des A*-Algorhytmus einen möglichen Weg vom Start zum Ziel
    75. /// </summary>
    76. /// <param name="map">Die Map, in der der Weg gesucht werden soll</param>
    77. /// <param name="start">Der Startpunkt</param>
    78. /// <param name="end">Der Endpunkt</param>
    79. /// <param name="pathOutput">Hier wird das Ergebnis ausgegeben, falls der Lösungsversuch erfolgreich ist</param>
    80. /// <returns>Ob der Lösungsversuch geklappt hat</returns>
    81. public bool TrySolve(Map map, Point start, Point end, out List<Point> pathOutput)
    82. {
    83. throw new NotImplementedException();
    84. }
    85. /// <summary>
    86. /// Sucht mithilfe des A*-Algorhytmus einen möglichen Weg vom Start zum Ziel
    87. /// </summary>
    88. /// <param name="map">Die Map, in der der Weg gesucht werden soll</param>
    89. /// <param name="start">Der Startpunkt</param>
    90. /// <param name="end">Der Endpunkt</param>
    91. /// <returns>Das Ergebnis der Wegsuche</returns>
    92. public List<Point> Solve(Map map, Point start, Point end)
    93. {
    94. throw new NotImplementedException();
    95. }
    97. /// <summary>
    98. /// Sucht mithilfe des A*-Algorhytmus einen möglichen Weg vom Start zum Ziel
    99. /// </summary>
    100. /// <param name="map">Die Map, in der der Weg gesucht werden soll</param>
    101. /// <param name="start">Der Startpunkt (muss sich in der Map befinden)</param>
    102. /// <param name="end">Der Endpunkt (muss sich in der Map befinden)</param>
    103. /// <param name="movableDirections">Die Anzahl der Richtungen, in welche sich der Path bewegen darf</param>
    104. /// <param name="pathOutput">Hier wird das Ergebnis ausgegeben, falls der Lösungsversuch erfolgreich ist</param>
    105. /// <returns>Ob der Lösungsversuch geklappt hat</returns>
    106. public bool TrySolve(Map map, Node start, Node end, DirectionCount movableDirections, out List<Point> pathOutput)
    107. {
    108. return TrySolve(map, start, end, movableDirections, HeuristicFunction.Manhattan, 1, out pathOutput);
    109. }
    110. /// <summary>
    111. /// Sucht mithilfe des A*-Algorhytmus einen möglichen Weg vom Start zum Ziel
    112. /// </summary>
    113. /// <param name="map">Die Map, in der der Weg gesucht werden soll</param>
    114. /// <param name="start">Der Startpunkt (muss sich in der Map befinden)</param>
    115. /// <param name="end">Der Endpunkt (muss sich in der Map befinden)</param>
    116. /// <param name="movableDirections">Die Anzahl der Richtungen, in welche sich der Path bewegen darf</param>
    117. /// <returns>Das Ergebnis der Wegsuche</returns>
    118. public List<Point> Solve(Map map, Node start, Node end, DirectionCount movableDirections)
    119. {
    120. List<Point> Path = new List<Point>();
    121. if (TrySolve(map, start, end, movableDirections, HeuristicFunction.Manhattan, 1, out Path))
    122. {
    123. return Path;
    124. }
    125. else
    126. {
    127. throw new Exception("Kein Weg gefunden");
    128. }
    129. }
    130. /// <summary>
    131. /// Sucht mithilfe des A*-Algorhytmus einen möglichen Weg vom Start zum Ziel
    132. /// </summary>
    133. /// <param name="map">Die Map, in der der Weg gesucht werden soll</param>
    134. /// <param name="start">Der Startpunkt</param>
    135. /// <param name="end">Der Endpunkt</param>
    136. /// <param name="movableDirections">Die Anzahl der Richtungen, in welche sich der Path bewegen darf</param>
    137. /// <param name="pathOutput">Hier wird das Ergebnis ausgegeben, falls der Lösungsversuch erfolgreich ist</param>
    138. /// <returns>Ob der Lösungsversuch geklappt hat</returns>
    139. public bool TrySolve(Map map, Point start, Point end, DirectionCount movableDirections, out List<Point> pathOutput)
    140. {
    141. throw new NotImplementedException();
    142. }
    143. /// <summary>
    144. /// Sucht mithilfe des A*-Algorhytmus einen möglichen Weg vom Start zum Ziel
    145. /// </summary>
    146. /// <param name="map">Die Map, in der der Weg gesucht werden soll</param>
    147. /// <param name="start">Der Startpunkt</param>
    148. /// <param name="end">Der Endpunkt</param>
    149. /// <param name="movableDirections">Die Anzahl der Richtungen, in welche sich der Path bewegen darf</param>
    150. /// <returns>Das Ergebnis der Wegsuche</returns>
    151. public List<Point> Solve(Map map, Point start, Point end, DirectionCount movableDirections)
    152. {
    153. throw new NotImplementedException();
    154. }
    156. /// <summary>
    157. /// Sucht mithilfe des A*-Algorhytmus einen möglichen Weg vom Start zum Ziel
    158. /// </summary>
    159. /// <param name="map">Die Map, in der der Weg gesucht werden soll</param>
    160. /// <param name="start">Der Startpunkt (muss sich in der Map befinden)</param>
    161. /// <param name="end">Der Endpunkt (muss sich in der Map befinden)</param>
    162. /// <param name="movableDirections">Die Anzahl der Richtungen, in welche sich der Path bewegen darf</param>
    163. /// <param name="heuristicFunction">Die Heuristik, die eingesetzt werden soll</param>
    164. /// <param name="pathOutput">Hier wird das Ergebnis ausgegeben, falls der Lösungsversuch erfolgreich ist</param>
    165. /// <returns>Ob der Lösungsversuch geklappt hat</returns>
    166. public bool TrySolve(Map map, Node start, Node end, DirectionCount movableDirections, HeuristicFunction heuristicFunction, out List<Point> pathOutput)
    167. {
    168. return TrySolve(map, start, end, movableDirections, heuristicFunction, 1, out pathOutput);
    169. }
    170. /// <summary>
    171. /// Sucht mithilfe des A*-Algorhytmus einen möglichen Weg vom Start zum Ziel
    172. /// </summary>
    173. /// <param name="map">Die Map, in der der Weg gesucht werden soll</param>
    174. /// <param name="start">Der Startpunkt (muss sich in der Map befinden)</param>
    175. /// <param name="end">Der Endpunkt (muss sich in der Map befinden)</param>
    176. /// <param name="movableDirections">Die Anzahl der Richtungen, in welche sich der Path bewegen darf</param>
    177. /// <param name="heuristicFunction">Die Heuristik, die eingesetzt werden soll</param>
    178. /// <returns>Das Ergebnis der Wegsuche</returns>
    179. public List<Point> Solve(Map map, Node start, Node end, DirectionCount movableDirections, HeuristicFunction heuristicFunction)
    180. {
    181. List<Point> Path = new List<Point>();
    182. if (TrySolve(map, start, end, movableDirections, heuristicFunction, 1, out Path))
    183. {
    184. return Path;
    185. }
    186. else
    187. {
    188. throw new Exception("Kein Weg gefunden");
    189. }
    190. }
    191. /// <summary>
    192. /// Sucht mithilfe des A*-Algorhytmus einen möglichen Weg vom Start zum Ziel
    193. /// </summary>
    194. /// <param name="map">Die Map, in der der Weg gesucht werden soll</param>
    195. /// <param name="start">Der Startpunkt</param>
    196. /// <param name="end">Der Endpunkt</param>
    197. /// <param name="movableDirections">Die Anzahl der Richtungen, in welche sich der Path bewegen darf</param>
    198. /// <param name="heuristicFunction">Die Heuristik, die eingesetzt werden soll</param>
    199. /// <param name="pathOutput">Hier wird das Ergebnis ausgegeben, falls der Lösungsversuch erfolgreich ist</param>
    200. /// <returns>Ob der Lösungsversuch geklappt hat</returns>
    201. public bool TrySolve(Map map, Point start, Point end, DirectionCount movableDirections, HeuristicFunction heuristicFunction, out List<Point> pathOutput)
    202. {
    203. throw new NotImplementedException();
    204. }
    205. /// <summary>
    206. /// Sucht mithilfe des A*-Algorhytmus einen möglichen Weg vom Start zum Ziel
    207. /// </summary>
    208. /// <param name="map">Die Map, in der der Weg gesucht werden soll</param>
    209. /// <param name="start">Der Startpunkt</param>
    210. /// <param name="end">Der Endpunkt</param>
    211. /// <param name="movableDirections">Die Anzahl der Richtungen, in welche sich der Path bewegen darf</param>
    212. /// <param name="heuristicFunction">Die Heuristik, die eingesetzt werden soll</param>
    213. /// <returns>Das Ergebnis der Wegsuche</returns>
    214. public List<Point> Solve(Map map, Point start, Point end, DirectionCount movableDirections, HeuristicFunction heuristicFunction)
    215. {
    216. throw new NotImplementedException();
    217. }
    219. #endregion
    220. }
    221. }
    HeuristicFunction.cs

    C#-Quellcode

    1. using System;
    2. using System.Collections.Generic;
    3. using System.Linq;
    4. using System.Text;
    5. using System.Threading.Tasks;
    6. using System.Drawing;
    8. namespace StefansAStarLibrary
    9. {
    10. /// <summary>
    11. /// Stellt eine Heuristik dar
    12. /// </summary>
    13. public class HeuristicFunction
    14. {
    15. public Func<Point, Point, double> Function { get; private set; }
    17. public bool TieBreak { get; private set; }
    19. /// <summary>
    20. /// Erstellt eine neue HeuristicFunction-Klasse
    21. /// </summary>
    22. /// <param name="functionSource">Die Heuristische Funktion, Form: '(start, end) => H'</param>
    23. /// <param name="tieBreak">Gibt an, ob TieBreaking aktiviert werden soll</param>
    24. public HeuristicFunction(Func<Point, Point, double> function, bool tieBreak)
    25. {
    26. this.Function = function;
    27. this.TieBreak = tieBreak;
    28. }
    30. /// <summary>
    31. /// Erstellt eine neue HeuristicFunction-Klasse aus einer Vorlage
    32. /// </summary>
    33. /// <param name="functionSource">Die Vorlage</param>
    34. /// <param name="tieBreak">Gibt an, ob TieBreaking aktiviert werden soll</param>
    35. public HeuristicFunction(HeuristicFunction functionSource, bool tieBreak)
    36. {
    37. this.Function = functionSource.Function;
    38. this.TieBreak = tieBreak;
    39. }
    41. /// <summary>
    42. /// Die Manhattan-Heuristik
    43. /// </summary>
    44. public static const HeuristicFunction Manhattan =
    45. new HeuristicFunction((start, end) => Math.Abs(start.X - end.X) + Math.Abs(start.Y - end.Y), false);
    46. /// <summary>
    47. /// Die Diagonal-Heuristik
    48. /// </summary>
    49. public static const HeuristicFunction Diagonal =
    50. new HeuristicFunction((start, end) => Math.Max(Math.Abs(start.X - end.X), Math.Abs(start.Y - end.Y)), false);
    51. /// <summary>
    52. /// Die Euclidean-Heuristik
    53. /// </summary>
    54. public static const HeuristicFunction Euclidean =
    55. new HeuristicFunction((start, end) => Math.Sqrt(Math.Pow(start.X - end.X, 2) + Math.Pow(start.Y - end.Y, 2)), false);
    56. /// <summary>
    57. /// Die Euclidean-Sqared-Heuristik
    58. /// </summary>
    59. public static const HeuristicFunction EuclideanSqared =
    60. new HeuristicFunction((start, end) => Math.Pow(start.X - end.X, 2) + Math.Pow(start.Y - end.Y, 2), false);
    61. }
    62. }
    DirectionCount.cs

    C#-Quellcode

    1. using System;
    3. namespace StefansAStarLibrary
    4. {
    5. /// <summary>
    6. /// Gibt an, wie viele Bewegungsrichtungen erwägt werden
    7. /// </summary>
    8. public enum DirectionCount
    9. {
    10. /// <summary>
    11. /// Stellt 4 Bewegungsrichtungen zur Verfügung
    12. /// </summary>
    13. Four,
    14. /// <summary>
    15. /// Stellt 8 Bewegungsrichtungen zur Verfügung
    16. /// </summary>
    17. Eight
    18. }
    19. }

    Jetzt kriege ich von Visual Studio netterweise dutzende Fehler entgegengeworfen, hier mal alle verschiedenen Fehlertypen:
    Fehler

    Nummer 1: Tritt bei jeder Solve-/TrySolve-Methode auf, die Signatur der bemängelten Funktion variiert natürlich, manchmal wird auch die Map bemängelt:

    Quellcode

    1. Variante 1:
    2. Inkonsistenter Zugriff: Parametertyp 'StefansAStarLibrary.Node' ist weniger zugreifbar als Methode 'StefansAStarLibrary.AStar.TrySolve(StefansAStarLibrary.Map, StefansAStarLibrary.Node, StefansAStarLibrary.Node, StefansAStarLibrary.DirectionCount, StefansAStarLibrary.HeuristicFunction, double, out System.Collections.Generic.List<System.Drawing.Point>)'
    3. Variante 2:
    4. Inkonsistenter Zugriff: Parametertyp 'StefansAStarLibrary.Map' ist weniger zugreifbar als Methode 'StefansAStarLibrary.AStar.TrySolve(StefansAStarLibrary.Map, StefansAStarLibrary.Node, StefansAStarLibrary.Node, StefansAStarLibrary.DirectionCount, StefansAStarLibrary.HeuristicFunction, double, out System.Collections.Generic.List<System.Drawing.Point>)'

    Nummer 2: Tritt bei jeder Konstante in der Klasse HeuristicFunction auf:
    Hier variieren natürlich wieder die Namen:

    Quellcode

    1. Die Konstante 'StefansAStarLibrary.HeuristicFunction.Diagonal' kann nicht als statisch markiert werden.

    Nummer 3-5: Hier wird die Lambda-Funktion bemängelt

    Quellcode

    1. Der Name 'start' ist im aktuellen Kontext nicht vorhanden.

    Quellcode

    1. Der Name 'end' ist im aktuellen Kontext nicht vorhanden.

    Quellcode

    1. 'lambda-Ausdruck' kann nicht in den Typ 'StefansAStarLibrary.HeuristicFunction' konvertiert werden, da dies kein Delegattyp ist.

    Quellcode

    1. Der Ausdruck kann keine anonymen Methoden oder lambda-Ausdrücke enthalten.

    Und als ob das noch nicht genug wäre, ist es mir nichtmal möglich, mit dem Rückgängigmachen der Änderungen die Fehler wegzubekommen :cursing:.
    Kann mir da vielleicht jemand helfen?

    Guck dir mal die Definition von deiner Node- und der Map-Klasse an. Denn Fehler 1 besagt ja, dass die wohl auf private oder internal oder sowas stehen.

    Ich hab den Fehler gefunden :).
    Falls es noch jemanden interessiert, die Lösung war, aus den Konstanten Properties zu machen, dann wirft es keine Fehler mehr.
    Danke, das war der eine Fehler :), ich hatte das public vergessen.
    Zusammengeführt

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „FlashTek“ ()

    Aus Konstanten Properties wegen den Fehlern oben wird wohl kaum die richtige Lösung sein. Vielmehr Konstanten als public deklarieren?


    Opensource Audio-Bibliothek auf github: KLICK, im Showroom oder auf NuGet.

    Die Konstanten verhalten sich dann aber nicht so "static", oder? Ich hatte eigenlch vor, soetwas wie bei der Color-Struktur zu erreichen, dass ich dann vorgefertigte und eigene Typen in einer Klasse bekomme. Im Gründe gekommen verhalten sich die Dinger ja eh gleich.

    Also suchst du eher was wie Enumerationen (in Bezug auf deine Color Aussage)? msdn.microsoft.com/de-de/library/6e3t9w21%28v=vs.90%29.aspx
    Nebenbei, new HeuristicFunction((start, end) => Math.Max(Math.Abs(start.X - end.X), Math.Abs(start.Y - end.Y)), false); sieht mir nicht wirklich Konstant aus ?(

    ich tät sehr empfehlen, dieses ganze schwachsinnige Kommentar-Gelaber erstmal zu entfernen.

    Und dann Kommentare hinmachen, die wirdklich erklären, was man aussm Code nicht direkt versteht.
    Etwa: Was soll die Klasse HeuristicFunctions?

    sowas wäre glaub interessanter, als zu erfahren, dass Euclean eine Eucledean-Heuristik darstellt (letzteres ist nämlich eine Tautologie, und somit keine Erklärung, sondern eine Verarschung)

    Von den ganzen 287 Zeilen blieben vlt. 50 übrig, und das Bandwurm-Problem wäre gelöst.
    Dann kannman noch die ganzen Überladungen entfernen, und sich auf erstmal eine Methode konzentrieren, die auch mal was macht, weil dassis grad was mir fehlt in dem Snippet: Dass iwo mal eine Methode mal wirklich was macht.
    Zur Funktion kannman auch deshalb nix sagn, weil die Map-Klasse uns unbekannt ist.

    @slice
    Stimmt, vielleicht lag es daran. Ich dachte einfach Konstant = nicht veränderbare Variable. Um nochmal auf die Enumeration zurückzukommen, bei der Color-Struktur ist die Property-basiert.
    @ErfinderDesRades
    Was sollte ich denn sonst in die Beschreibungen reinmachen? Jeder, der sich mit dem Thema schon auseinandergesetzt hat, sollte wissen, was das ist.
    Die Map- und Nodeklasse sind bisher übrigens leer, genauso wie die "Original"-Funktion, in der alles zusammenläuft. Das liegt daran, dass ich erstmal die Grundstruktur schaffen will (alle zusätzlichen Methoden Solve/TrySolve verweisen immer auf die nächstumfangreichere, sodass ich den Code der eigentlichen Funktion nur noch einmal schreiben muss und alle Methoden werden damit versorgt.

    Wenn alles eh klar ist, kannste auf Kommentation auch komplett verzichten. Bzw, es ist erforderlich, dann auf Kommentation zu verzichten, denn was selbsterklärender Code selbst erklärt, kann durch Kommentation nur verwässert oder gar verfälscht werden.
    Aber wenn dir bereits klar ist, wie die Heuristics-Klasse zu verwenden ist, und da du das auch bei deinen Lesern vorraussetzst - dann kein Kommentar.
    Ich persönlich hätte eine Erklärung wie "Die Distanz einer Zelle zum Ziel kann auf verschiedene Weisen berechnet werden (etwa Luftlinie, Anzahl der Schritte, weitere) Die hier als Delegat niedergelegten Bewertungs-Funktionen werden dem Lösungs-Algorithmus übergeben und führen zu jeweils unterschiedlichen Ergebniswegen."

    Das wäre eine Erklärung, die man imo nicht so ohne weiteres dem Code ablesen kann, und solch Kommentar hätte dann eine Berechtigung. Bzw. er ist erforderlich (im Gegensatz zu allem anneren, was da derzeit hingeschrieben ist).
    Also wäre dieser Kommentar der einzige im Code, dann wäre dein Code vielfach leserlicher: kürzer, selbsterklärend, und der einzige Kommentar wäre wesentlich, und fände dann auch die nötige Beachtung.

    Also gut, du hast nun die grob Struktur. Dann solltest du wohl jetzt die Map ausprogrammieren - was hast du da bisher?

    ErfinderDesRades schrieb:

    Ich persönlich hätte eine Erklärung wie "Die Distanz einer Zelle zum Ziel kann auf verschiedene Weisen berechnet werden (etwa Luftlinie, Anzahl der Schritte, weitere) Die hier als Delegat niedergelegten Bewertungs-Funktionen werden dem Lösungs-Algorithmus übergeben und führen zu jeweils unterschiedlichen Ergebniswegen."

    Das ist mir klar, dass das besser verständlich ist, jedoch würde das doch eher in die Dokumentation gehören, oder? Ich werde jedenfalls noch mal überlegen, wie ich das mit den Kommentaren besser lösen könnte.

    ErfinderDesRades schrieb:

    Also gut, du hast nun die grob Struktur. Dann solltest du wohl jetzt die Map ausprogrammieren - was hast du da bisher?

    Bisher gar nichts, jedoch habe ich ein grobes Modell schon im Kopf:
    Properties:
    Size: Gibt die Größe der Map an
    Nodes/Default Property: Speichert die einzelnen Nodes

    Methoden:
    GetNode(x, y): Gibt eine Node an einem bestimmten Platz aus
    GetSurroundingNodes(x, y): Gibt die eine Node umgebenden Nodes aus
    GetRow(index): Gibt eine spezifische Reihe aus
    GetColumn(index): Gibt eine spezifische Spalte aus

    SetNode(x, y, node): Setzt den Wert einer Node
    SetRow(index, nodes[]): Setzt eine spezifische Reihe
    SetColumn(index, nodes[]): Setzt eine spezifische Spalte

    AddRow(index): Fügt eine neue Zeile ein
    RemoveRow(index): Löscht eine Zeile
    AddColumn(index): Fügt eine neue Spalte ein
    RemoveColumn(index): Löscht eine Spalte

    Save(path): Speichert die Map
    Load(path): Lädt eine Map

    Technik:
    Als Basis dient ein Jagged Array, damit man auch einzelne Zeilen und Spalten direkt ansprechen kann.

    ...ist mir klar, dass das besser verständlich ist...
    besser verständlcih als was?
    bisher enthält deine Kommentation doch keinerlei Erklärungen - das sind doch alles nur Tautologien.

    Wo das hingehört, ist mir egal. Du hast beim Coden jede Freiheit der Kommetation.
    Ich würde das als Header in die Datei setzen, wo die Heuristiken drinne sind.
    vielleicht auch als Summary der Heuristics-Klasse, vlt. verkürzt: "Enthält Delegaten, die verschiedene Strategien zur Distanz-Berechnung zweier Zellen anwenden. Einer davon wird dem A*-Algorithmus mitgegeben und beeinflusst, was als kürzester Weg betrachtetet wird."

    Jut - haste ein Map-Konzept - im wesentliche ein JaggedArray von Nodes - fehlt noch das Node-Konzept. Als Node täte m.E. ein einfacher Enum reichen, der verschiedene Status' der Zelle aussagt, obs ein Hindernis ist oder frei, ob schon besucht und dergleichen.
    Ich würde auch nicht von Nodes reden, sondern von Zellen. Nodes sind Objekte der Graphen-Theorie, und werden explizit miteinander verknüpft.
    Zellen sind einfach Elemente in einer Matrix, und ihre Nachbarn ergeben sich direkt aus der Zell-Position. Also aus etwas, was streng genommen in der Zelle garnet enthalten ist.
    Der Algo würde dann also nicht mit Nodes oder Zellen arbeiten, sondern mit Positionen, mit Points.


    Edit:
    Was bedeutet eiglich die TieBreak-Property der Heuristics-Klasse? (Siehste, solch Fragen tauchen erst auf, wennich mir das mal rauskopiere, und die Laberkommentare rausschmeisse)

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „ErfinderDesRades“ ()

    dann kann das weg, und du gibst die Konstante halt immer an. Gibst du 1 an, wird halt mit 1 multipliziert.

    Und wenn das weg kann, kannste die Salami wesentlich vereinfachen:

    C#-Quellcode

    1. /// <summary>
    2. /// Enthält Delegaten, die verschiedene Strategien zur Distanz-Berechnung zweier Zellen anwenden. Einer davon wird dem A*-Algorithmus mitgegeben und beeinflusst, was als kürzester Weg betrachtetet wird.
    3. /// </summary>
    4. public static class HeuristicFunctions {
    6. /// <summary> berechnet Anzahl der Schritte unter Vorraussetzung von 4 Nachbarzellen </summary>
    7. public static Func<Point, Point, double> Manhattan =(start, end) => Math.Abs(start.X - end.X) + Math.Abs(start.Y - end.Y);
    9. /// <summary> berechnet Anzahl der Schritte unter Vorraussetzung auch diagonaler Nachbarn </summary>
    10. public static Func<Point, Point, double> Diagonal = (start, end) => Math.Max(Math.Abs(start.X - end.X), Math.Abs(start.Y - end.Y));
    12. /// <summary> berechnet Luftlinie </summary>
    13. public static Func<Point, Point, double> Euclidean = (start, end) => Math.Sqrt(Math.Pow(start.X - end.X, 2) + Math.Pow(start.Y - end.Y, 2));
    15. /// <summary> berechnet quadrierte Luftlinie (etwas schneller als richtige Luftlinie zu berechnen)</summary>
    16. public static Func<Point, Point, double> EuclideanSqared = (start, end) => Math.Pow(start.X - end.X, 2) + Math.Pow(start.Y - end.Y, 2);
    17. }

    Ok, ich habe das jetzt so eingearbeitet:

    C#-Quellcode

    1. /// <summary>
    2. /// Stellt eine Strategie zur Distanzberechnung zwischen zwei Zellen dar.
    3. /// Sie beeinflusst, welcher Weg als der kürzeste beachtet wird.
    4. /// </summary>
    5. public class HeuristicFunction
    6. {
    7. public Func<Point, Point, double> Function { get; set; }
    9. /// <summary>
    10. /// Erstellt eine neue HeuristicFunction-Klasse
    11. /// </summary>
    12. /// <param name="functionSource">Die Heuristische Funktion, Form: '(start, end) => H'</param>
    13. public HeuristicFunction(Func<Point, Point, double> function)
    14. {
    15. this.Function = function;
    16. }
    18. /// <summary>
    19. /// Berechnet die Anzahl der Schritte unter Vorraussetzung von 4 Nachbarzellen
    20. /// </summary>
    21. public static HeuristicFunction Manhattan = new HeuristicFunction((start, end) => Math.Abs(start.X - end.X) + Math.Abs(start.Y - end.Y));
    23. /// <summary>
    24. /// Berechnet die Anzahl der Schritte unter Vorraussetzung auch diagonaler Nachbarzellen
    25. /// </summary>
    26. public static HeuristicFunction Diagonal = new HeuristicFunction((start, end) => Math.Max(Math.Abs(start.X - end.X), Math.Abs(start.Y - end.Y)));
    28. /// <summary>
    29. /// Berechnet die Entfernung per Luftlinie
    30. /// </summary>
    31. public static HeuristicFunction Euclidean = new HeuristicFunction((start, end) => Math.Sqrt(Math.Pow(start.X - end.X, 2) + Math.Pow(start.Y - end.Y, 2)));
    33. /// <summary>
    34. /// Berechnet die quadrierte Entfernung per Luftlinie (etwas schneller als richtige Luftlinie zu berechnen)
    35. /// </summary>
    36. public static HeuristicFunction EuclideanSqared = new HeuristicFunction((start, end) => Math.Pow(start.X - end.X, 2) + Math.Pow(start.Y - end.Y, 2));
    38. }

    Denkst du, das passt?

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „nafets3646“ ()

    wie gesagt: TieBreak kann weg, und die ganze Klasse kann aufgelöst werden, und als Statische Klasse designed - also nurnoch ein Sammelsurium von
    Func(Point, Point, Double)-Delegaten.
    Es ist nicht mehr als ein Sammelsurium solcher Delegaten, und daher solls auch nicht so tun als obs ein Objekt wäre, was man instanzieren müsste.

    Von meinen Vorschlägen scheinst du nur die Kommentation übernommen zu haben - nicht die Vereinfachung des Codes.

    Die eigentlich sinnlose HeuristicFunction-klasse erschwert enorm das Verständnis, weil sinnlosigkeiten sind am schwierigsten zu verstehen von allem (nämlich garnet), und dass etwas einfach sinnlos ist, darauf kommt man meist als letztes.

    Das TieBreak hatte ich entfernt, ich hatte nur zuerst den falschen Code kopiert ;). Und du findest wirklich nicht, dass ich die Klasse behalten soll? Ich persönlich finde die ja eher sogar übersichtlicher, da man nicht einfach irgendeine Function vorgesetzt bekommt, welche man implementieren muss bzw. erstmal die vorgefertigten Varianten finden muss.

    Nein, die Klasse ist von hinten durch die Brust ins Auge.
    Stell dir die Benutzung vor:

    C#-Quellcode

    1. var astar = new Astar();
    2. astar.Heuristic = new Heuristic(Heuristic.Diagonal);
    Wassn Crap!


    C#-Quellcode

    1. astar.Heuristic = Heuristic.Diagonal;
    Einfach anweisen, was zu tun ist, ohne ein sinnloses Heuristic-Objekt drumrum.

    Und derselbe Quatsch dann nochmal im Algo, wo die Benutzung eines Heuristic-Objects allein darin bestünde, dieFunction-Property da rauszuholen und zu nutzen.
    Also da kann man die Function auch direkt übergeben, dann muss der Algo sie nicht erst aus diesem Quatsch-Objekt herausholen.

    Die Benutzung funktioniert ja auch direkt, man muss nicht den Umweg über new gehen :P. So wie ich das konzipiert habe, ist Heuristic im Grunde genommen eine Klasse und gleichzeitig eine Enumeration, da muss man auch nichts mehr instanzieren -> meine Möglichkeit sieht auch wie die, welche du in deinem zweiten Beispiel gezeigt hast, aus.

Facebook
Telefonspende