Post
Ask Question
Kaung Htet Kyaw

Kaung Htet Kyaw

  • NA
  • 66
  • 6.4k

Can someone else fix my problem? Please

Jul 31 2020 9:17 AM
My dearest friends,
 
Please I am facing the System.NullReferenceException in Program.cs. It says that "EventManager.NoArgumentInvoker.get returned null" how should I suppose to do? Please, can someone can else fix my exception. Any help will be very very appreciated. Please fix my error.
 
This is the code of Program.cs:
  1. using System;  
  2. using System.Collections.Generic;  
  3. using System.Diagnostics;  
  4. using System.Linq;  
  5. using System.Text;  
  6. using System.Threading.Tasks;  
  7. using UnityEngine;  
  8. namespace ProgrammingAssignment3  
  9. {  
  10. /// <summary>  
  11. /// Programming Assignment 3  
  12. /// </summary>  
  13. class Program  
  14. {  
  15. // test case to run  
  16. static int testCaseNumber;  
  17. // debug log messages  
  18. static List<string> logMessages = new List<string>();  
  19. /// <summary>  
  20. /// Tests the Programming Assignment 3 classes  
  21. /// </summary>  
  22. /// <param name="args">command-line args</param>  
  23. static void Main(string[] args)  
  24. {  
  25. // listen for Unity debug log events  
  26. UnityEngine.Debug.LogEvent.AddListener(HandleLogEvent);  
  27. // create Invoker and Listener  
  28. Invoker invoker = new Invoker();  
  29. Listener listener = new Listener();  
  30. // Awake is always called before Start  
  31. invoker.Awake();  
  32. // loop while there's more input  
  33. string input = Console.ReadLine();  
  34. while (input[0] != 'q')  
  35. {  
  36. // extract test case number from string  
  37. GetInputValueFromString(input);  
  38. // execute selected test case  
  39. switch (testCaseNumber)  
  40. {  
  41. case 1:  
  42. // invoker added to event manager first for no argument event  
  43. InitializeTestCase(invoker, listener);  
  44. EventManager.NoArgumentInvoker.InvokeNoArgumentEvent();  
  45. if (logMessages[0] == "MessageEvent" &&  
  46. logMessages.Count == 1)  
  47. {  
  48. Console.WriteLine("Passed");  
  49. }  
  50. else  
  51. {  
  52. Console.WriteLine("FAILED");  
  53. }  
  54. break;  
  55. case 2:  
  56. logMessages.Clear();  
  57. EventManager.ClearInvokersAndListeners();  
  58. // listener added to event manager first for no argument event  
  59. listener.Start();  
  60. invoker.Start();  
  61. EventManager.NoArgumentInvoker.InvokeNoArgumentEvent();  
  62. if (logMessages[0] == "MessageEvent" &&  
  63. logMessages.Count == 1)  
  64. {  
  65. Console.WriteLine("Passed");  
  66. }  
  67. else  
  68. {  
  69. Console.WriteLine("FAILED");  
  70. }  
  71. break;  
  72. case 3:  
  73. // invoker added to event manager first for one argument event  
  74. InitializeTestCase(invoker, listener);  
  75. EventManager.IntArgumentInvoker.InvokeOneArgumentEvent(-1);  
  76. if (logMessages[0] == "CountMessageEvent: -1" &&  
  77. logMessages.Count == 1)  
  78. {  
  79. Console.WriteLine("Passed");  
  80. }  
  81. else  
  82. {  
  83. Console.WriteLine("FAILED");  
  84. }  
  85. break;  
  86. case 4:  
  87. logMessages.Clear();  
  88. EventManager.ClearInvokersAndListeners();  
  89. // listener added to event manager first for one argument event  
  90. listener.Start();  
  91. invoker.Start();  
  92. EventManager.IntArgumentInvoker.InvokeOneArgumentEvent(-1);  
  93. if (logMessages[0] == "CountMessageEvent: -1" &&  
  94. logMessages.Count == 1)  
  95. {  
  96. Console.WriteLine("Passed");  
  97. }  
  98. else  
  99. {  
  100. Console.WriteLine("FAILED");  
  101. }  
  102. break;  
  103. case 5:  
  104. InitializeTestCase(invoker, listener);  
  105. // invoke no argument event directly through invoker  
  106. invoker.InvokeNoArgumentEvent();  
  107. if (logMessages[0] == "MessageEvent" &&  
  108. logMessages.Count == 1)  
  109. {  
  110. Console.WriteLine("Passed");  
  111. }  
  112. else  
  113. {  
  114. Console.WriteLine("FAILED");  
  115. }  
  116. break;  
  117. case 6:  
  118. InitializeTestCase(invoker, listener);  
  119. // invoke one argument event directly through invoker  
  120. invoker.InvokeOneArgumentEvent(-1);  
  121. if (logMessages[0] == "CountMessageEvent: -1" &&  
  122. logMessages.Count == 1)  
  123. {  
  124. Console.WriteLine("Passed");  
  125. }  
  126. else  
  127. {  
  128. Console.WriteLine("FAILED");  
  129. }  
  130. break;  
  131. case 7:  
  132. InitializeTestCase(invoker, listener);  
  133. // invoke multiple no argument events directly through invoker  
  134. invoker.InvokeNoArgumentEvent();  
  135. invoker.InvokeNoArgumentEvent();  
  136. invoker.InvokeNoArgumentEvent();  
  137. if (logMessages[0] == "MessageEvent" &&  
  138. logMessages[1] == "MessageEvent" &&  
  139. logMessages[2] == "MessageEvent" &&  
  140. logMessages.Count == 3)  
  141. {  
  142. Console.WriteLine("Passed");  
  143. }  
  144. else  
  145. {  
  146. Console.WriteLine("FAILED");  
  147. }  
  148. break;  
  149. case 8:  
  150. InitializeTestCase(invoker, listener);  
  151. // invoke multiple one argument events directly through invoker  
  152. invoker.InvokeOneArgumentEvent(1);  
  153. invoker.InvokeOneArgumentEvent(2);  
  154. invoker.InvokeOneArgumentEvent(3);  
  155. if (logMessages[0] == "CountMessageEvent: 1" &&  
  156. logMessages[1] == "CountMessageEvent: 2" &&  
  157. logMessages[2] == "CountMessageEvent: 3" &&  
  158. logMessages.Count == 3)  
  159. {  
  160. Console.WriteLine("Passed");  
  161. }  
  162. else  
  163. {  
  164. Console.WriteLine("FAILED");  
  165. }  
  166. break;  
  167. case 9:  
  168. InitializeTestCase(invoker, listener);  
  169. // invoke combination of events directly through invoker  
  170. invoker.InvokeOneArgumentEvent(1);  
  171. invoker.InvokeNoArgumentEvent();  
  172. invoker.InvokeOneArgumentEvent(3);  
  173. if (logMessages[0] == "CountMessageEvent: 1" &&  
  174. logMessages[1] == "MessageEvent" &&  
  175. logMessages[2] == "CountMessageEvent: 3" &&  
  176. logMessages.Count == 3)  
  177. {  
  178. Console.WriteLine("Passed");  
  179. }  
  180. else  
  181. {  
  182. Console.WriteLine("FAILED");  
  183. }  
  184. break;  
  185. case 10:  
  186. InitializeTestCase(invoker, listener);  
  187. // invoke multiple one argument events directly through invoker  
  188. invoker.InvokeNoArgumentEvent();  
  189. invoker.InvokeOneArgumentEvent(2);  
  190. invoker.InvokeNoArgumentEvent();  
  191. if (logMessages[0] == "MessageEvent" &&  
  192. logMessages[1] == "CountMessageEvent: 2" &&  
  193. logMessages[2] == "MessageEvent" &&  
  194. logMessages.Count == 3)  
  195. {  
  196. Console.WriteLine("Passed");  
  197. }  
  198. else  
  199. {  
  200. Console.WriteLine("FAILED");  
  201. }  
  202. break;  
  203. }  
  204. input = Console.ReadLine();  
  205. }  
  206. }  
  207. /// <summary>  
  208. /// Extracts the test case number from the given input string  
  209. /// </summary>  
  210. /// <param name="input">input string</param>  
  211. static void GetInputValueFromString(string input)  
  212. {  
  213. testCaseNumber = int.Parse(input);  
  214. }  
  215. /// <summary>  
  216. /// Handles the log event from the Debug mock  
  217. /// </summary>  
  218. /// <param name="message">message to log</param>  
  219. static void HandleLogEvent(string message)  
  220. {  
  221. logMessages.Add(message);  
  222. }  
  223. /// <summary>  
  224. /// Initializes test case  
  225. /// </summary>  
  226. static void InitializeTestCase(Invoker invoker, Listener listener)  
  227. {  
  228. logMessages.Clear();  
  229. EventManager.ClearInvokersAndListeners();  
  230. invoker.Start();  
  231. listener.Start();  
  232. }  
  233. }  
  234. }
This is the CountMessageEvent.cs
  1. using System;  
  2. using System.Collections.Generic;  
  3. using System.Linq;  
  4. using System.Text;  
  5. using System.Threading.Tasks;  
  6. using UnityEngine.Events;  
  7. namespace ProgrammingAssignment3  
  8. {  
  9. public class CountMessageEvent : UnityEvent <int>  
  10. {  
  11. }  
  12. }  
This is the listener.cs
  1. using System.Collections;  
  2. using System.Collections.Generic;  
  3. using UnityEngine;  
  4. /// <summary>  
  5. /// An event listener  
  6. /// </summary>  
  7. public class Listener : MonoBehaviour  
  8. {  
  9. /// <summary>  
  10. /// Use this for initialization  
  11. /// </summary>  
  12. public void Start()  
  13. {  
  14. // add your code here  
  15. Invoker invoker = new Invoker();  
  16. invoker.AddNoArgumentListener(HandleMessageEvent);  
  17. invoker.AddOneArgumentListener(HandleCountMessageEvent);  
  18. }  
  19. /// <summary>  
  20. /// Handles the no argument event  
  21. /// </summary>  
  22. void HandleMessageEvent()  
  23. {  
  24. print("MessageEvent");  
  25. }  
  26. /// <summary>  
  27. /// Handles the one argument event  
  28. /// </summary>  
  29. /// <param name="number">number</number>  
  30. void HandleCountMessageEvent(int number)  
  31. {  
  32. print("CountMessageEvent: " + number);  
  33. }  
  34. }
This is the Invoker.cs
  1. using ProgrammingAssignment3;  
  2. using System.Collections;  
  3. using System.Collections.Generic;  
  4. using UnityEngine;  
  5. using UnityEngine.Events;  
  6. /// <summary>  
  7. /// An event invoker  
  8. /// </summary>  
  9. public class Invoker : MonoBehaviour  
  10. {  
  11. // add your fields for your message event support here  
  12. Timer MessageTimer;  
  13. MessageEvent messageEvent;  
  14. // add your fields for your count message event support here  
  15. int count;  
  16. Timer CountMessageTimer;  
  17. CountMessageEvent countMessageEvent = new CountMessageEvent();  
  18. /// <summary>  
  19. /// Awake is called before Start  
  20. /// </summary>  
  21. public void Awake()  
  22. {  
  23. // add your code here  
  24. messageEvent = new MessageEvent();  
  25. }  
  26. /// <summary>  
  27. /// Use this for initialization  
  28. /// </summary>  
  29. public void Start()  
  30. {  
  31. // add your code here  
  32. MessageTimer = gameObject.AddComponent<Timer>();  
  33. MessageTimer.Duration = 1;  
  34. MessageTimer.Run();  
  35. }  
  36. /// <summary>  
  37. /// Update is called once per frame  
  38. /// </summary>  
  39. void Update()  
  40. {  
  41. // add your code here  
  42. if (MessageTimer.Finished)  
  43. {  
  44. messageEvent.Invoke();  
  45. MessageTimer.Run();  
  46. }  
  47. }  
  48. /// <summary>  
  49. /// Adds the given listener to the no argument event  
  50. /// </summary>  
  51. /// <param name="listener">listener</param>  
  52. public void AddNoArgumentListener(UnityAction listener)  
  53. {  
  54. // add your code here to add the given listener for  
  55. // the message event  
  56. //MessageEvent messageEvent = new MessageEvent();  
  57. messageEvent = new MessageEvent();  
  58. messageEvent.AddListener(listener);  
  59. }  
  60. /// <summary>  
  61. /// Adds the given listener to the one argument event  
  62. /// </summary>  
  63. /// <param name="listener">listener</param>  
  64. public void AddOneArgumentListener(UnityAction<int> listener)  
  65. {  
  66. // add your code here to add the given listener for  
  67. // the count message event  
  68. countMessageEvent.AddListener(listener);  
  69. }  
  70. /// <summary>  
  71. /// Removes the given listener to the no argument event  
  72. /// </summary>  
  73. /// <param name="listener">listener</param>  
  74. public void RemoveNoArgumentListener(UnityAction listener)  
  75. {  
  76. // add your code here to remove the given listener from the  
  77. // message event  
  78. messageEvent.RemoveListener(listener);  
  79. }  
  80. /// <summary>  
  81. /// Removes the given listener to the one argument event  
  82. /// </summary>  
  83. /// <param name="listener">listener</param>  
  84. public void RemoveOneArgumentListener(UnityAction<int> listener)  
  85. {  
  86. // add your code here to remove the given listener from the  
  87. // count message event  
  88. countMessageEvent.RemoveListener(listener);  
  89. }  
  90. /// <summary>  
  91. /// Invokes the no argument event  
  92. ///  
  93. /// NOTE: We need this public method for the autograder to work  
  94. /// </summary>  
  95. public void InvokeNoArgumentEvent()  
  96. {  
  97. // add your code here to invoke the message event  
  98. messageEvent.Invoke();  
  99. }  
  100. /// <summary>  
  101. /// Invokes the one argument event  
  102. ///  
  103. /// NOTE: We need this public method for the autograder to work  
  104. /// </summary>  
  105. /// <param name="argument">argument to use for the Invoke</param>  
  106. public void InvokeOneArgumentEvent(int argument)  
  107. {  
  108. // add your code here to invoke the count message event  
  109. // with the given argument  
  110. countMessageEvent.Invoke(argument);  
  111. }  
  112. }
This is the EventManager.cs
  1. using System.Collections;  
  2. using System.Collections.Generic;  
  3. using UnityEngine;  
  4. using UnityEngine.Events;  
  5. /// <summary>  
  6. /// The event manager  
  7. /// </summary>  
  8. public static class EventManager  
  9. {  
  10. // DON'T change the fields, properties, or ClearInvokersAndListeners  
  11. // method; if you do, you'll break the autograder!  
  12. // All your work in this class is in the last 4 methods  
  13. #region Fields  
  14. // no argument event support  
  15. static Invoker noArgumentInvoker;  
  16. static UnityAction noArgumentListener;  
  17. // int argument event support  
  18. static Invoker intArgumentInvoker;  
  19. static UnityAction<int> intArgumentListener;  
  20. #endregion  
  21. #region Properties (for autograder use only)  
  22. /// <summary>  
  23. /// Gets the no argument invoker  
  24. /// </summary>  
  25. public static Invoker NoArgumentInvoker  
  26. {  
  27. get { return noArgumentInvoker; }  
  28. }  
  29. /// <summary>  
  30. /// Gets the no argument listener  
  31. /// </summary>  
  32. public static UnityAction NoArgumentListener  
  33. {  
  34. get { return noArgumentListener; }  
  35. }  
  36. /// <summary>  
  37. /// Gets the int argument invoker  
  38. /// </summary>  
  39. public static Invoker IntArgumentInvoker  
  40. {  
  41. get { return intArgumentInvoker; }  
  42. }  
  43. /// <summary>  
  44. /// Gets the int argument listener  
  45. /// </summary>  
  46. public static UnityAction<int> IntArgumentListener  
  47. {  
  48. get { return intArgumentListener; }  
  49. }  
  50. #endregion  
  51. #region Public methods  
  52. /// <summary>  
  53. /// Clears all the invokers and listeners from the event manager.  
  54. ///  
  55. /// Note: We need this functionality so the autograder can start with  
  56. /// a "clean" event manager at the start of each test case  
  57. /// </summary>  
  58. public static void ClearInvokersAndListeners()  
  59. {  
  60. // no argument invoker and listener  
  61. if (noArgumentInvoker != null)  
  62. {  
  63. if (noArgumentListener != null)  
  64. {  
  65. noArgumentInvoker.RemoveNoArgumentListener(noArgumentListener);  
  66. noArgumentListener = null;  
  67. }  
  68. noArgumentInvoker = null;  
  69. }  
  70. // int argument invoker and listener  
  71. if (intArgumentInvoker != null)  
  72. {  
  73. if (intArgumentListener != null)  
  74. {  
  75. intArgumentInvoker.RemoveOneArgumentListener(intArgumentListener);  
  76. intArgumentListener = null;  
  77. }  
  78. intArgumentInvoker = null;  
  79. }  
  80. }  
  81. /// <summary>  
  82. /// Adds the invoker for the no argument event  
  83. /// </summary>  
  84. /// <param name="invoker">invoker</param>  
  85. public static void AddNoArgumentInvoker(Invoker invoker)  
  86. {  
  87. // add your code here  
  88. noArgumentInvoker = invoker;  
  89. }  
  90. /// <summary>  
  91. /// Adds the listener for the no argument event  
  92. /// </summary>  
  93. /// <param name="listener">listener</param>  
  94. public static void AddNoArgumentListener(UnityAction listener)  
  95. {  
  96. // add your code here  
  97. listener= noArgumentListener;  
  98. }  
  99. /// <summary>  
  100. /// Adds the invoker for the int argument event  
  101. /// </summary>  
  102. /// <param name="invoker">invoker</param>  
  103. public static void AddIntArgumentInvoker(Invoker invoker)  
  104. {  
  105. // add your code here  
  106. invoker= intArgumentInvoker;  
  107. }  
  108. /// <summary>  
  109. /// Adds the listener for the int argument event  
  110. /// </summary>  
  111. /// <param name="listener">listener</param>  
  112. public static void AddIntArgumentListener(UnityAction<int> listener)  
  113. {  
  114. // add your code here  
  115. intArgumentListener = listener;  
  116. }  
  117. #endregion  
  118. }
This is the code of MessageEvent.cs
  1. using System;  
  2. using System.Collections.Generic;  
  3. using System.Linq;  
  4. using System.Text;  
  5. using System.Threading.Tasks;  
  6. using UnityEngine.Events;  
  7. namespace ProgrammingAssignment3  
  8. {  
  9. public class MessageEvent : UnityEvent  
  10. {  
  11. }  
  12. }  
After implementing that, I faced this exception...
 
 
 
Please fix my error hurry. My work will be dued in Aug 3. Please help and fix my error and I will appreciate for your fix...
 
I also uploaded the zip file to see my full code...

Answers (6)