Programming in Microsoft C# - Exam 70-483

Explore Visual Studio as the integrated development environment for C# development, compare editions from Express Edition to Community Edition, and learn how extensions and licensing shape learning and collaboration.

Download Visual Studio Community Edition from visualstudio.com, choosing the free developer tools option, and prepare your system by reviewing the supported Windows versions and hardware requirements before installation.

Install Visual Studio Community Edition from the ISO, review license terms and optional features, and prepare for first-use startup after a typical one-to-two hour install.

Explore Visual Studio 2013 basics, including navigating the dynamic interface, using toolbars, the toolbox, and properties window, and learn the reset window layout to recover a clean workspace.

Explore the demo code in the working files folder, copy the project, and open the solution in Visual Studio to run hands-on examples on garbage collection and delegates.

Explore Visual Studio features that boost coding efficiency, including toolbars, coding assistance tools, and IntelliSense snippets, demonstrated in a Windows forms application.

Discover code regions in visual studio, collapse and expand blocks with region keywords, and navigate using go to definition and pick definition in a Windows Forms app.

Learn to tailor the Visual Studio environment with tools options, enabling line numbers, fonts and colors, dark themes, and project properties for efficient C-Sharp development.

Discover why C# is the natural choice for Microsoft shops, its high demand, ease of learning, extensive documentation, portability across Windows and mobile platforms, and open source future.

Explore how C-sharp blends features from C++, Java, and other languages to be simple, modern, and object-oriented, with typesafe design, encapsulation, garbage collection, and CLR compatibility.

Discover how object oriented programming in c# uses classes to create reusable objects, reduce complexity through decoupling, and enable easy extensibility for maintainable applications.

Explore the three core object oriented programming concepts—encapsulation, inheritance, and polymorphism—and see how they enable secure, reusable, and flexible code in practical C# 70-483 contexts.

Understand how classes serve as templates and blueprints to create in-memory objects, define properties and actions, and instantiate multiple objects with shared structure but different values.

Learn how objects are instantiated from a class, with unique properties and methods, stored in memory, and how changes to the class affect all objects through encapsulation.

Learn to build a class and instantiate an object in a C# Windows Forms app, creating employee class with first name, last name, seniority, plus promote and annual review methods.

In this part, instantiate an employee object from the employee class on a button click, set properties, call promote, and display the result to illustrate object oriented programming basics.

C# types enforce strong typing, guiding memory usage and value ranges for variables. Learn value types vs reference types, compile-time rules, and how built-in and user-defined types shape code.

Explain value types versus reference types in C#: value types reside on the stack with independent copies, while reference types reside on the heap with shared objects via pointers.

Discover the difference between arrays and collections in C# by building a string list, iterating with foreach, and printing items in a Visual Studio console project.

Explore collections and arrays in C# by working with zero-based indexing, for each loop, and building integer arrays to organize and display data.

Master exception handling in C# by using the try, catch, and optional finally blocks to gracefully handle errors, prevent crashes, and keep the program running.

Explore try catch finally in C# with a divide by zero example, handle exceptions using the exception class, display error messages, and show how protected code avoids unhandled errors.

This lecture explains how the string builder class improves string manipulation by using a buffer instead of creating new strings on each change, contrasting with immutable string operations and concatenation.

examine how strings are treated as immutable versus a string builder, then create and use a string builder to append a line and replace text, and view the output.

Part 1 introduces string writer and string reader, using a string builder in a visual C# console app to write data and read data.

Explore string writer and string reader with a string builder to write and read data, loop through lines, and display results for log files and data parsing.

Explore how properties and fields differ, and how encapsulation uses accessors to protect private data while exposing public access. See how fields store data privately, properties validate and manage changes.

Demonstrate implementing a private age field with a public property and get/set accessors that validate input (1–64) and throw an exception for invalid values in Visual Studio.

Explore how properties manage access to private fields in C#, using get and set accessors, enforce age cannot exceed 65, and use Visual Studio snippets like propfull.

Explore how methods in C-sharp encapsulate blocks of code with parameters, return types, and access modifiers, and learn to call them with arguments, understand signatures, overloads, and delegates.

Explore the five C# access modifiers—public, private, protected, internal, and protected internal—and how they control accessibility for types and members across assemblies.

Master named and optional arguments in C# by using positional and named calls, and by understanding optional parameters with default values at the end of the parameter list.

Learn how constructors execute automatically when you instantiate a class, initialize default values, and use the default, instance, private, and static constructors. Explore overloading to create objects with varying parameters.

Explore how constructors work in C# by creating classes in Visual Studio, instantiating objects, and observing default and overloaded constructors executing along with console output.

Discover how the static keyword and static modifier change how types and members behave in C#. Access static class members without instances, and distinguish them from non-static members.

Explore structs in C#, distinguishing them as value types that resemble classes but allocate on the stack, with limitations on constructors, inheritance, and initialization, and compare to reference types.

learn how to define a C# struct, create a public struct Mark with fields x and y, and use a parameterized constructor to initialize them, noting no default parameterless constructor.

Explore generics in C# as type-safe, compile-time collections that outperform non-generic array lists, avoiding boxing and runtime casts, and see a hands-on example of using a generic list.

Explore generics by building a generic list of integers, adding values, and iterating with foreach to print items, while showing compile-time type safety and prevention of incorrect types.

Explore casting and converting in C# and how compile-time checks guard statically typed variables. Compare implicit and explicit conversions and learn when to use cast versus Convert class for strings.

Explore casting and converting in C# by implicitly converting an int to a long, then explicitly casting a double to an int, noting data loss in Visual Studio 2013.

Explore casting and converting in C#: casting a double to int truncates the fractional part, while Convert rounds when parsing strings to integers, highlighting testing to prevent bugs.

Explore boxing and unboxing in C#, showing how value types on the stack become heap-allocated objects and how implicit and explicit conversions impact performance.

Explore indexers in C# by building a car class with a string array backing and an indexer that supports array-like access, overloading with different parameter types, and safe bounds checking.

Explore indexers with properties by building a car maker collection, handling out-of-range checks, and iterating through the collection to access elements like Mercedes and Dodge.

Explore how inheritance, a core pillar of object oriented programming, enables new classes to reuse and extend behavior, illustrated by adult and child classes and reduced duplication.

Learn how inheritance structures a base patient class and adult and child subclasses, sharing name, gender, age, weight, and examen method, with insurance verification and billing.

Explore how inheritance structures application classes in C#, using base and derived classes and the subclass relationship, with a doctor office example illustrating patient, adult, over 50, and transitive inheritance.

Build a patient class with properties and methods, create a simple child class with an inoculate method, and prepare for inheritance in Visual Studio.

Explore inheritance from patient to child to under-five, enabling access to patient methods such as examine and billing, and child methods like inoculate, with under-five inheriting through the chain.

Understand method overloading by using unique signatures to call the correct add record variant, even when the name is the same but parameters differ, such as int and string.

Explore method overloading in C# by examining multiple check billing overloads, including no-argument, two-integer, and string-and-integer variants, plus inheritance to a child class.

Discover how method overriding lets the adult class replace the patient’s examined method using base virtual and subclass override. Learn to manage inheritance to reuse code while maintaining polymorphism.

Demonstrates overriding a base class method in a derived class using virtual and override, showing how patient and adult examine methods behave.

Discover how extension methods add behavior to existing types via a static class and static method using this on string, enabling capitalized checks without inheritance or modifying original types.

Understand interfaces as software contracts that guarantee consistent functionality and support polymorphism across objects; a common interface lets you call the same method name to control different devices.

Understand how an interface acts as a contract defining methods, properties, events, and indexers a class must implement. See how binding to the contract simplifies start and startup in code.

Define an interface called controls to enforce a start and stop contract across machines. Implement the interface in machine classes, enabling consistent start and stop behavior and simplifying cross-machine usage.

Explore explicit interface implementation in C#, showing how a class can implement multiple interfaces with identical method names and resolve collisions using fully qualified method calls.

Explore explicit interface implementation by showing how a class implements multiple interfaces, accesses specific interface methods via casting or interface-typed variables, and resolves name collisions.

Explore the IEnumerable interface and its enumerator, and see how foreach uses move next and yield return to traverse collections in the dot net framework.

Explore implementing IEnumerable to enable foreach iteration by building an enumerator with yield return, understanding how GetEnumerator creates a hidden enumerator class, and testing with a string list of cars.

Learn how to make a car collection enumerable by implementing IEnumerable, adding a GetEnumerator method, and using yield return to enable foreach iteration over the three items.

Learn how to implement IEnumerable in a custom collection using an iterator and yield return, enabling foreach iteration and showcasing a simple, practical approach.

Explore how delegates act as type-safe function pointers in dot net, defining a method signature with return type and parameters, and calling any matching method.

Create and use a delegate in a C# console app with Visual Studio, wire add numbers and multiply numbers to a delegate, and define its signature for methods with integers.

Use a delegate to point to methods with the same signature, invoke with two integers, and switch between add and multiply to demonstrate event handling in the dot net framework.

Discover how delegates support multicast in C#, letting a single delegate reference multiple methods. Learn to add or remove targets with plus equal and minus equal and observe invocation order.

Explore multicast delegates by creating a void-returning delegate that accepts two ints, then chain add, multiply, and subtract methods using += and -= to demonstrate multi-method invocation.

Explore how a publisher raises events to multiple subscribers, with delegates and event handlers that each respond to events from various publishers using the event args base class.

Explore a basic event example that shows a publisher raising an event via a delegate and a subscriber handling it with a string message, defined by the delegate type.

Continue exploring the basic event example by wiring a subscriber to a publisher using a delegate, subscribing the event handler, and observing balance thresholds trigger the event.

Adopt the dot net standard event handling by using the EventHandler delegate, wiring events to a prewired delegate, and aligning publishers and subscribers with object sender and EventArgs.

Learn to raise events with custom event arguments in c#, using a generic handler and a custom event args class. Pass a message when balance exceeds 250.

Learn to use a generic event handler with a custom event args class in C# to pass messages when a balance exceeds 250, via publisher-subscriber patterns.

Master garbage collection basics in the .NET framework by understanding how automatic memory management frees unused managed objects, when GC runs, not immediate, and why GC.Collect is discouraged.

Explain how disposal complements garbage collection by explicitly releasing unmanaged resources, using IDisposable, the using statement, and try/finally to ensure connections and streams close.

grasp how finalizers interact with garbage collection, including their placement in a queue and execution by the finalizers thread as a final chance to clean up memory, used when necessary.

Explore how the IDisposable interface enables explicit cleanup of resources, distinguishing managed and unmanaged objects, and laying groundwork for implementing dispose with the finalizer.

Learn how to implement the IDisposable interface using the basic dispose pattern to manage unmanaged resources, avoid finalizer pitfalls, and prevent double disposal.

Highlight how concurrency uses multi-threading to run multiple execution paths within a single process. See main and new threads switch rapidly, potentially running in parallel on multi-core processors.

Introduce multi-threading in C# by creating a new thread using the Thread class and Start method, compare it with the main thread, and show interleaving of output.

Manage multiple threads by using is alive, name, and current thread; control execution with sleep and join, and distinguish foreground from background threads.

Learn how the thread pool reduces overhead by reusing background threads and how Task.Run uses pool threads. See foreground vs background threads and their behavior in code.

Demonstrate foreground and background threads in thread pool by running a count loop that prints F and G with delays, and observe how background threads terminate when the foreground ends.

Explore the difference between synchronous and asynchronous processing and learn how C# 5 introduces the async and await keywords to run tasks on separate threads, improving UI responsiveness.

Explore a simple async/await example in a C# console app, creating a do stuff task that runs in the background and counts to 50, with nonblocking execution.

Learn how async and await coordinate a background task with the main thread, showing interleaving execution, a count to 50, and the impact of removing await.

Explain how assemblies function as the basic deployment unit in dot net, detailing manifests, compiled types with intermediate language code, and resources.

Understand the global assembly cache (gac) basics, including strongly named assemblies, installation methods (installer or gacutil), location changes since net 4.0, and considerations for versioning, testing, and deployment.

Discover how the dot net framework secures files with file.encrypt and file.decrypt, with background key creation and a practical code example in a Visual Studio console app.

Learn to encrypt and decrypt a user file using the .NET File class, with a read-file workflow and path handling on an NTFS disk for exam readiness.

Explore hashing as a one-way encryption technique that turns input into a fixed-length fingerprint, enabling secure password storage and verification with salt to resist cracking.

Learn to hash data in a C# console app using SHA-256 from system security cryptography, compute a password hash, and convert it to base64.

Learn how to hash data with a hash data class and create hash method, hash user input, compare hashes to verify passwords without exposing them in clear text.