static void Main(string[] args) { GradeBook book = new GradeBook(); book.AddGrade(91); book.AddGrade(89.5f); book.AddGrade(75); GradeStatistics stats = book.ComputeStatistics(); Console.WriteLine(stats.AverageGrade); Console.WriteLine(stats.HighestGrade); Console.WriteLine(stats.LowestGrade); }
private static void CreateBookAndGetStatistics() { // The reference to this assembly allows me to use this class to introduce // speech into my program. It is loaded by the dynamic language runtime // when the class is requested //SpeechSynthesizer speech = new SpeechSynthesizer(); //speech.Speak("Hello, welcome to this stupid gradebook program"); GradeBook book = new GradeBook(); try { Console.Write("Enter a name: "); // Ideally, you should not set the Name property until after you know you have // a valid value. You could do this by using a combination of a variable // and a loop which keeps prompting the user until they enter a valid value // and then, once they do, you are good to store the value of that variable // into the Name property book.Name = Console.ReadLine(); } // Catch blocks can be chained and the first one to match will be the one that // executes and all the others will be skipped. Thus, include the most specific // exception blocks first. catch (ArgumentException ex) { Console.WriteLine(ex.Message); Console.WriteLine(ex.StackTrace); } // The Exception type is the most general, from which most others inherit, so it // comes last. There are only a few which it cannot catch. These are the ones // that are guaranteed to crash your program. Catching one this general could // be dangerous since you don't know what kind of exception it is. catch (Exception ex) { Console.WriteLine(ex.Message); } // Finally is good to add at the end to clean up any resources, regardless // of wheather or not there is an exception thrown. book.NameChanged = new NameChangedDelegate(OnNameChanged); //book.NameChanged = OnNameChanged; // sugar! // This is legal for delegates. But, if it were an event, you couldn't do this. // Usually, you should prefer events to provide encapsulation. Events bascially // translate into a private delegate behind the scenes which only publiclly expose // subscribe (+=) and unsubscripe (-=) methods. //book.NameChanged = OnNameChanged2; This will overwrite the delegate, effectively removing all subscribers. //book.NameChanged("Hehehehe", "I'm invoking the delegate directly from outside the class"); book.NameChanged += OnNameChanged2; // This creates a multicast delegate. book.NameChanged -= OnNameChanged2; // Removes it from the multicast delegate // Events: book.NameChangedEvent += OnNameChanged; // You can only subscribe and unsubscribe from events. you cannot // invoke or assign to them directly but only from within the methods // of the class. //book.NameChangedEvent("This is no longer legal", "Compile Error!!!!"); //book.NameChangedEvent = null; // Compile error!! // Events using convention with the title. book.TitleChanged += OnTitleChanged; book.Title = "Title"; // This will invoke the set method on the Name property, passing in // "Jeff's Grade Book" as the "value". book.Name = "Jeff's Grade Book"; book.AddGrade(81); // 81 is converted to a float book.AddGrade(75); book.AddGrade(91.5f); // book.AddGrade(53.4); // Compile error, cannot convert double to float. GradeStatistics stats = book.ComputeStatistics(); WriteResult("Average", stats.AverageGrade); // calls the one with a float result WriteResult("Highest", (int)stats.HighestGrade); // calls the one with a int result (it truncates) WriteResult("Lowest", stats.LowestGrade); // You can't do this because you are in a static method. Non-static fields // and methods are implicitly passed 'this', which is a reference to the // object calling the method, which you don't have in a static method and // therefore cannot pass to the non-static method or field. In short, if you // are in a static method, you can only access other static methods/properties. //MyProperty = 3; }