You Are in Your Musical 60s |
 You love music for what it says as well as for how it sounds. You are big on music with a deeper meaning. For you, there is little better than a talented singer-songwriter. And you always listen to the lyrics for every song. You are open to today's music as long as it comes from a genuine place. You don't like mass marketed music. You believe that every artist needs a strong voice. Generic music doesn't appeal to you at all! |
Friday, January 23, 2015
You Value Benevolence |
 You are a very generous person, and you feel like you get a lot from giving to others. You like to help. You worry about the world, and you do your best to improve things - especially on a community level. You nurture the people around you, whether they ask for your assistance or not. You quietly lend a hand in whatever way you can. You hate to see misery or suffering. You are an empathetic person, and you tend to take on the burdens of those you care about. |
You Are an Observer |
 You are a well-liked person, and you have many good friends. You are enjoyable to be around. You are a good listener and easy to get along with. You understand every friend you have well. At work, you keep the peace and make sure everyone is on the same page. You are good at coming up with compromises. At home, you put your family first. You always have time for the people you love and are patient with them. |
You Are the Upper Left Quadrant |
 You are logical and analytical. You truly enjoy learning how things work, and you want to know every detail. Complexity doesn't put you off; it thrills you. You like to delve deep into a subject, even if it takes years to master. You are very realistic. You are neither unduly optimistic nor unduly pessimistic - you see risk clearly. Some may think that you are too critical, but you are good at anticipating (and solving) problems before they become serious. |
You Are Fresh |
 You have green yin. You are balanced and in tune with what you need most in life. You don't sit by passively. You enjoy uncertainty and are the first to admit that you don't have it all figured out. You embrace personal growth. You have white yang. You have a pure view of the world, and you rarely let those around you influence you. You are a bit of a blank canvas when it comes to life, and you are ready to create. You believe in new beginnings. |
Your Writing Strength is Wordsmanship |
 You are a master when it comes to words. Everything you write ends up very lyrical but readable. You tend to think in phrases, and it's important for you to jot them down as soon as they come. You can fill in the rest later. You're the type of writer who can struggle for hours to find the exact right word. And your readers appreciate how well you hone your craft. For you, how you write is as important as what you write about. You may still be very concise, but every word is carefully chosen. |
You Should Live in Tokyo |
 You are a very modern person, at least most of the time. You are fascinated by modern technology and culture. Tokyo is the perfect city for you to get your techie fix, while exploring all the interesting subcultures and pop cultures the city offers. Tokyo is also the perfect place for you to reflect and develop your next great idea. You can find your oasis to get away from it all. However, you'll often love the overwhelming amount of stimulation that Tokyo offers. You're ready to be right in the mix with it all! |
You Are a Blue Piggy Bank |
 You are excellent at stretching money, and you consider yourself a smart shopper. You are savvy. You save naturally because you don't need a lot to live off of. You find good deals and make use of what you already own. Because you are a wise consumer, you also may be a wise investor - especially when it comes to retail stocks. You know a good value when you see it, and you are ready to jump on a true bargain. |
You Are Chives |
 You are a complex person, and you are more versatile than others expect. You do a lot of things well. There are two sides to your personality: one is all about art and color, while the other is all business. You are very resilient. It is hard to keep you down, and you know how to overcome almost any obstacle. You are balanced and understated. You have a compelling depth, but you don't broadcast it to the world. |
You Are a Country Chair |
 You are down to earth and very practical. You like things that last, and you always look for craftsmanship. Some may call you old fashioned, and it's true that many of your favorite things come from deep in the past. You like to slow down and live life right. You believe that mistakes get made when we rush. You believe that most things in life are a waste of time. You focus your attention on what truly matters. |
You Are a Spatula |
 You enjoy cooking, but you like the results of your cooking even more. You cook your favorites dishes a lot. You prefer to whip up food that others enjoy eating as well. You have a strong repertoire of crowd pleasers. You feel at peace in the kitchen, and you generally like to be left alone to do your thing. You offer up lots of tastes while you're cooking though. You love sweet food, and desserts are one of your specialties. You don't feel like it's a celebration unless a dessert comes at the end. |
You Have Systematic Toes |
 Your feet always know where they are going. You are an organized and efficient person. You get a lot more done than most people, and you are good at being self-directed. You don't lose sight of your goals. You have the unique skill set needed to be successful. And you have probably already achieved your own measure of personal success. You prefer to plan because it enables you to get as much done as possible. You deliberately chart your course. |
Your Style is West Coast |
 Your style is bohemian, carefree, and very California inspired. You never look like you try too hard. While your look is casual, it is carefully put together. You give off an air of whimsy and creativity. You are good at mixing and matching different looks without going overboard. You rock layers well. It's likely that nothing in your closet every really goes out of style. You know how to revamp pieces in order to give them a whole new life. |
You Are Sneakers |
 You are super casual and sporty every season of the year, and this is especially true for summer. You know how to rock a lot of modern looks, and you never shy away from accessories that are a bit bolder. You are active, free spirited, and ready for an adventure at a moment's notice. You love to be spontaneous. You aren't afraid to break the rules, and you like a good challenge. You are even a bit of a daredevil. |
You Are Realistic |
 More than anything else, you are a doer. You like to make a tangible difference at work and school. You are proactive and even a bit competitive - at least with yourself. You are proud of your skills, and you want to be the best at your job. You are the type of person who can solve problems by getting in there and tinkering. You are a very hands on learner. You like to think concretely. Either something works or it doesn't; you're very practical that way. |
Blue Motivates You |
 You are motivated by relationships. It's not enough to do something for yourself; you are driven to make others happy. You have high standards for yourself, but you are easy on those around you. You don't ever want to let anyone down. You are quite passionate and have many thing that you love. You tend to be broadminded and cultured. You are committed to your friends and family. You are loyal to those you care about, and you have deep personal connections. |
You Are Japan |
 You are harmonious and concerned with how you fit into your community. You don't like to make waves unnecessarily. You are traditional and even a bit old fashioned in your values. However, you also embrace the future, especially new trends and technologies. You have a rich and interesting inner world, but you rarely express it with others. You are reserved and keep to yourself. You are driven to be a good person, and you have a good sense of how others see you. You are very dependable and kind-hearted. |
You Are The Creation of Adam |
 You are hard-working and very conscientious. You have an appreciation for detail - both in your own work and the work of others. You are highly visual, and you can see most things in your mind. You can even imagine things you have never seen before well. You are a traditionalist, and you prefer to perfect what you have than to go looking for new ways of being. You see the past as rich. You are quite deep and very philosophical. You value spirituality and doing what is right for its own sake. |
You Are Real |
 You are the type of person who is ageless and timeless. You know who you are, and you never try to be anyone else. You are very uncomplicated and natural. You don't hide behind a facade, and you are very straightforward with people. You are at ease with yourself and your place in the world. Others find you to be refreshing company. You are sincere, honest, and genuine. You don't give a complement unless you mean it, and people take you at your word. |
You Are Stripes |
 You are quietly patriotic, and you like to engage in your country's traditions. You take your duties seriously. You try to be a good ambassador of your country. You are tidy, organized, punctual, and always good mannered. You are highly conscientious and responsible. What others think of you matters, and you try to do your best. You get a lot done and rarely rest - even during the holidays. You think that being productive is part of being a good person. |
You Are Caesar Dressing |
 You are quite easygoing and as much of a minimalist as you can get away with. You like simple things. You are straightforward and honest in your approach to life. You value transparency, both in yourself and in others. You may keep things low key, but you are also quite sophisticated. Strength never intimidates you. In life, you are always looking for a balance. You can take a little of anything but never too much of it. |
You Are Pieris Echidna |
 You are a big thinker and an even bigger idea person. You love to sketch out new concepts. You tend to speculate and theorize. You don't believe that anything is set in stone, and you dig intellectual exploration. You are reserved but never misanthropic. You love the world, but you tend to love it from a distance. You are very precise in your thinking, but you are also very flexible. You never quite know where a train of thought will lead you. |
Thursday, January 22, 2015
C# Essential Training
C# Essential Training
Introduction
Welcome
00:04 Hi! I am Joe Marini, and I'd like to welcome you to C# Essential Training.
00:08 I've been working with C# since its initial release back in 2001.
00:12 C# is a great choice for applications that run on a wide variety of
00:17 Microsoft platforms.
00:18 We will start off with the basics:
00:20 installing the free C# development tools from Microsoft, understanding the basic
00:25 structure of a C# program, and getting your first program up and running.
00:30 Then we'll move on to more advanced concepts, like defining your own C# classes.
00:35 I will also cover subjects like automatic memory management and reading and
00:39 writing data files, and we'll see how to do all of this while using the free
00:44 Visual C# Express development tools to build and debug your C# applications.
00:50 So if you're ready to take a look at the foundation language for targeting
00:53 Microsoft platforms then let's get started with C# Essential Training.
Collapse this transcript
What you should know
00:00 In this course, I am going to make a couple of assumptions.
00:03 First, I am going to assume you have some experience working with
00:06 Windows-based computers.
00:08 Second, I'm going to assume that you have some amount of prior programming
00:12 experience--not necessarily a lot of experience, and I don't expect that you've
00:16 ever even seen C# before.
00:19 But you do need to at least know what things like variables, functions,
00:23 loops, et cetera, are.
00:24 These are the basic fundamentals of any programming language, not just C#.
00:29 Just to be clear, this course is not an introduction to the fundamentals of programming.
00:33 What we are going to be focusing on are the fundamentals of the C# language itself.
00:39 Along the way, we will do some work with the .NET framework, which is
00:42 Microsoft's runtime and class library that C# uses to build and run programs,
00:47 but we will mainly focus on learning the C# language.
00:51 If you already know a programming language, like C or Java or Objective-C or
00:57 JavaScript, then many of the C# constructs will look very familiar to you,
01:02 but don't be fooled;
01:02 C# is its own language with its own way of doing some things some of which are
01:07 different from all the other languages out there.
01:10 Of course, if you're coming from a very different language, like Ruby or Python
01:15 or Perl, that's fine too;
01:17 you won't have any problem following along with this course.
Collapse this transcript
Using the exercise files
00:00 If you are a Premium member of the lynda.com Online Training Library, or if
00:04 you're watching this tutorial on a DVD-ROM, you have access to the exercise
00:09 files used throughout this title.
00:11 If you look inside the exercise files, you'll find folders that contain all the
00:16 various exercises that I'm going to use in this title.
00:19 The way that they're organized is, each one of the chapters has its own set of example files.
00:24 So for example, if I look inside the folder for Chapter 5, you will notice that
00:28 there are bunch of subfolders that are named according to the particular section
00:32 that's being described in that particular chapter.
00:35 If you look inside these folders, you will notice that there is a C# Express
00:40 project file, along with a folder that contains the code for that exercise.
00:45 When you have installed the Visual C# Express developer tools from Microsoft,
00:50 you'll be able to just simply double- click on the name of the project file,
00:54 which will then bring up the coding environment and the code that's in that file,
00:59 and you can start working right away on it.
01:01 Let me take a look back in the Exercise Files folder. You'll also notice that
01:06 there is a FinishedExamples folder.
01:09 In this folder, you will see the same folder structure, but what I've done here
01:13 is finished off each one of these examples in the finished state.
01:17 So here in the upper part of the folder, these are all the examples in the start state.
01:22 These are so that you can follow along with me as you take the course.
01:25 If you would rather just jump ahead and see how a finished example works, you
01:28 can go inside the FinishedExamples files folder and then just choose which
01:32 chapter you want to the finished example for and then go ahead and examine that code.
01:36 The last thing I want to point out is that I have included a file here
01:39 called ExampleSnippets.
01:41 If we open this text file up, you will notice that this is just a collection of
01:45 code snippets that I'm going to use in each one of these examples throughout the
01:49 title, and I have organized them in various chapters.
01:52 Here are the snippets for Chapter 3,
01:54 here are the snippets for Chapter 4, and so on.
01:57 This is so you don't have to sit and watch me type each example out.
02:01 I'm going to just simply copy and paste the code that's in these snippets files.
02:05 Now if you're a Monthly member or Annual member of lynda.com, you don't have
02:10 access to the exercise files, but you will have access to this ExampleSnippets
02:13 file because it will be made available as a free download.
02:16 So you can either follow along from scratch with your own assets, or you can use the snippets.
02:21 Let's go ahead and get started.
Collapse this transcript
1. Getting Started with C#
Installing the Visual C# Express IDE
00:00 Okay, so we are ready to start writing our C# code, but before we can do that,
00:03 we have to go get our development environment.
00:05 So to do that, we are going to go to the Microsoft web site and download the C#
00:10 Express development environment. So let's do that and go to the browser.
00:13 In the browser, I am going to type in microsoft.com/express.
00:19 This will take me to the download page for the various versions of Express
00:25 products that Microsoft makes available for free.
00:27 And this page might look a little bit different for you when you get here, but
00:31 there should be a link to download the Express products for Visual Studio, and
00:36 that's this link right here that says, "Get free Visual Studio Express products."
00:39 So I am going to click on that.
00:40 This will take me to a download page for all of the Visual Studio Express products.
00:46 And as I scroll down the list, you can see that there's one for Windows Phone.
00:49 There's Visual Web Developer. And I am just going to scroll down until I get to
00:52 this link right here, and that is Visual C# 2010 Express.
00:57 And again, when you get here, this may be newer. The point, though, is that
01:00 you want to get the most recent version of the Visual C# Express IDE.
01:04 So I am going to click on that link.
01:06 This will take me to the download page for that particular version of Visual C# Express.
01:11 So I can click on the Install Now link.
01:14 Now depending on what browser you're using, you're going to be prompted to
01:17 download and run the installer, and you can see here in IE I have got this
01:21 little download bar, but this is going to look different for you if you're using
01:24 a different browser.
01:25 Now I have already done this.
01:27 So once you have run the installer and Visual C# Express is installed, you will
01:32 find it in your Programs menu.
01:34 So if I go to the Start menu, you will see I have got Microsoft Visual C# 2010
01:39 Express, or something like it for you. And I am going to go ahead and click on the
01:42 link to make sure it's installed correctly. And you can see that Visual C#
01:46 Express fires up, and it looks like we are ready to go.
01:48 Now there is one other thing I wan to show you before we actually get started
01:51 writing some code, and that is the Microsoft Developer Network Library.
01:54 So let's jump back to the browser and head over there.
01:57 So back here in the browser, I am going to make a new tab, and I am going to
02:00 type msdn.microsoft.com.
02:04 This is the online library for the Microsoft Developer Network, and it contains
02:09 all the documentation that you'll need to build your C# and .NET programs.
02:15 And you can see when I come here it's placed me on one of these four categories.
02:18 In this case it's Tasks.
02:20 Let me click on the Platforms link.
02:21 And under Platforms, you can see that there are categories for desktop and web
02:26 and cloud and phone. And if we scroll down a little bit, there is a whole bunch
02:30 of content on here that's focused on building applications for the various
02:34 Microsoft platforms.
02:35 Let's scroll back up.
02:36 I am going to click on Tasks again.
02:39 You can see it takes me to a different pivot on the information here in the MSDN Library.
02:44 There is a section for creating code.
02:46 There is a section for testing.
02:47 There is a section for understanding code.
02:49 Let's go ahead and click on one of these links for understanding code.
02:51 You can see here, as I scroll down, there is a whole bunch of overview material
02:55 for understanding how to build .NET applications using a variety of languages.
03:00 We are going to be referring back to the MSDN Library throughout the course to
03:04 see documentation for the various kinds of code and objects we will be using.
03:08 In fact, if I click on the Library link up here, the Library link takes me
03:12 directly to the documentation for the various parts of C# and .NET. And you
03:18 can see over here under the MSDN Library section, there is links for all kinds of categories:
03:23 Development tools and Languages, .NET Development, and so on.
03:26 This is the web site that we will be referring to for Microsoft's canonical
03:30 documentation for various parts of C#.
03:33 Okay, so now that we have got the IDE installed and we know MSDN is, we are
03:37 ready to start building our first C# application.
Collapse this transcript
Creating your first C# application
00:00 Now that we have got the IDE installed and we've seen MSDN,
00:04 let's go ahead and fire up C# Express and build our first application.
00:09 So I am going to go ahead and launch C# Express. And when C# Express comes up,
00:17 you will see a start page and the application window frame.
00:22 So this right here is the start page. Over here is something called the Solution
00:25 Explorer, and we will look at that a little bit later.
00:27 What I am going to do, just really quickly, is get our feet wet by writing a C# application.
00:33 I don't expect that you're going to understand everything that I'm going to show you right
00:35 away, but I know you're probably anxious to get started.
00:38 So let's just go ahead and build a simple application. And once we've done that,
00:41 we'll take a quick look at how we did it, and then we will have an introduction
00:45 to C# Express that explains the various parts of the program that we will be
00:48 using throughout the course to build our applications.
00:52 I am going to go ahead and click on the New Project link right here. And when I
00:56 click on the New Project link, you'll notice that a dialog comes up asking me,
00:59 well, what kind of application do you want to build?
01:01 You can see there is a whole bunch of built-in ones that we can choose from:
01:05 there is Windows Forms Applications, there is WPF, there is something called a
01:09 Console Application, there's Class Library, and there is a whole bunch of other
01:12 things that we can choose from.
01:14 To keep things simple, we are going to build what's called a console application
01:17 and you may have heard this referred to in the past as something like a command-
01:22 line app, or something like that.
01:24 The point here is that we are not going to be focusing too much on fancy user
01:28 interface or anything like that.
01:29 We are going to build console applications to keep us focused on the C# language.
01:34 I could name it down here something else, but this is just an example.
01:37 So let's go and click on Console Application, and you can see that C# Express has
01:43 created a sample application for me.
01:46 It's opened up a file here called Program.cs--that's this tab right over here.
01:51 If we take a look now at the Solution Explorer, we can see the Solution Explorer
01:54 has now been filled out with a bunch of things:
01:57 There is the name of the application that we are building right here.
01:59 There is a couple of folders called Properties and References, and we will see
02:02 those in depth a little bit later.
02:04 And then this file right here called Program.cs.
02:07 Program.cs is the C# file that contains the code for our program, and it happens
02:12 to be opened in the window right here.
02:14 I am going to go ahead and just type a couple of things, and again, I don't
02:18 expect you to know this right away, but just follow along with me.
02:22 Inside the function for Main, I am going to type Console.WriteLine.
02:31 It's a bit of a tradition in programming courses that the first application you
02:36 write basically does nothing more than print "Hello World" out to whatever output
02:40 device you're using,
02:41 so I am going to type in here "Hello World," and I am going to save it.
02:49 Now what I am going to do is run it, and I can run it a couple of different ways.
02:53 What I am going to do is go up to the Debug menu.
02:56 You can see that I have got an option here for Start Debugging and I have got
03:00 something called Build Solution.
03:01 I will just quickly choose Build Solution to make sure that everything is right,
03:06 and you can see down here in the status bar there is a little piece of text
03:08 that says, "Build succeeded."
03:10 So everything looks okay.
03:12 Now I am going to run it.
03:13 And instead of going back to the Debug menu, I am going to click on this little
03:16 green arrow right here that says Start Debugging.
03:18 So I am going to click on that and you can see that some window came up very
03:22 quickly and went away, and that's because the Console Application came up, the
03:28 text was written out, and then the program ended.
03:30 The .NET Library said, "Oh, I guess we don't need the console window anymore.
03:33 Might as well send it away."
03:34 So to keep that from happening, I am going to add one more piece of code down
03:38 here, Console.ReadLine, and now I am going to save that.
03:45 Now this is going to have the console window wait for us to give it a line of text.
03:49 This is just a way for me to keep the console window from going away as I show
03:54 how this program works.
03:55 So let's try it one more time.
03:56 Let's go ahead and click on Run. All right!
03:59 You can see that the console window comes up, the words "Hello World" got printed
04:03 out, and now it's waiting for me to give it a line of input, and it's going to sit
04:07 there until I do that.
04:08 You can see in the background the UI for C# Express has changed somewhat.
04:14 The Program.cs window has been expanded, and we've got these two other windows
04:18 down here called Locals and Call Stack-- and we'll get into this later on when
04:22 we look at debugging.
04:23 This is C#'s way of showing me what the program is doing while it's running.
04:27 So let's bring this back up here, and you can see now that when I give it a line
04:31 of text and the ReadLine function completes, the Console window goes away and C#
04:36 Express goes back to the state where it first launched.
04:40 That's how we build our first C# program and to get further into the course, we
04:44 will explain how all of these things work.
Collapse this transcript
Introduction to Visual C# Express
00:00 Since we're going to be spending a lot of time using C# Express to build our
00:03 applications, we should probably take a few moments and get familiar with the
00:06 IDE and see how it works.
00:08 So I'm going to go ahead and launch the C# 2010 Express,
00:14 and you'll see that when the application comes up, it's a very simple UI.
00:17 There's the start page right here on the left-hand side,
00:20 and then over here there's something called the Solution Explorer.
00:24 A couple things you need to know about C# right upfront.
00:26 C# Express organizes everything into projects.
00:31 Projects are what applications are made from.
00:33 And you might sometimes hear the word project interspersed or interchanged
00:37 with the word solution.
00:39 That's not completely true.
00:40 Solutions are basically top-level projects that can contain other projects.
00:45 When we build a project, it will appear in the Solution Explorer here on the
00:49 right-hand side of the screen.
00:51 So let's go ahead and create a new project,
00:54 and we can do that one of two ways:
00:55 we can click on the New Project link here in start page, or we can go up to the
01:01 File menu and choose New Project.
01:03 So I'm going to choose New Project,
01:06 and the New Project dialog launches and we can choose what kind of project we want to build.
01:11 Throughout this course we'll be working with console applications, because
01:15 it gets the user interface out of the way and just let's us concentrate on the language.
01:19 So I'm going to go ahead and click on the Console Application to select it.
01:23 If it's not already done so, you should do the same thing.
01:25 Down here in the bottom of the dialog, there is a place where we can enter the
01:29 name of the project.
01:31 And I'll just type in something;
01:32 I'll just call it MyProject.
01:34 And I'm going to click the OK button.
01:37 This is going to create the project for us. All right!
01:41 Now that we have the project built, let's take a look at C# Express and see
01:46 what's going on here in the UI.
01:48 So over here in the Solution Explorer you'll notice that the window has been
01:52 filled out with some information, and we will get back to that in just a moment.
01:56 The project code is over here opened in the editor.
02:00 And the new project isn't actually saved yet.
02:02 It is fully functional. You can go ahead and run it. You can edit it.
02:05 You can do all kinds of things.
02:06 But it's sitting out in temporary space right now.
02:09 If we wanted to actually put all this work onto disk, we would go the File menu
02:13 and we would choose Save MyProject or Save All.
02:17 And when I choose Save All, you'll see that I get a dialog that says hey, here's the name.
02:21 Here's where it's going to be saved.
02:22 Here's what the solution name is.
02:24 I have the option to create a directory for the solution.
02:26 And at this point I can choose to name it something else if I don't like the
02:30 name that I originally came up with.
02:32 And I'm just going to go ahead and choose Save.
02:35 That will put the project on disk for me in the Documents folder, or whatever
02:39 path I selected in the Save dialog.
02:42 Let's go ahead and take a look at the project files over here in the Solution Explorer.
02:46 You'll see that underneath the top-level MyProject heading there are a couple of folders.
02:51 There's the Properties folder and References.
02:53 Let's go ahead and expand those.
02:56 Underneath Properties there's a file called AssemblyInfo.cs.
03:00 Now I'm just going to quickly open this up so you can see what's inside it.
03:02 We won't be going through this in this course, because this is a little bit of
03:05 advanced information.
03:06 But this is the information that C# Express will save, along with your
03:10 application, that describes to the .NET Framework what the application is, how
03:14 it works, various pieces of information that .NET needs to know about the
03:18 program in order to run it.
03:20 So let me go ahead and close that.
03:22 Under the References folder you'll see a whole bunch of things, like Microsoft
03:25 and System and so on.
03:27 These are the actual .NET Framework libraries that get associated with your
03:31 project when you make a new one.
03:33 These will change based upon what kind of project you're creating.
03:37 In this case, we've built a console application, so these are the .NET libraries
03:41 that the console application needs to run.
03:44 Some of them are optional; some of them are not.
03:46 The .NET Framework just goes ahead and includes them in case you need to use them later.
03:51 So let's go ahead and close those folders up.
03:53 The Program.cs file,
03:55 this is the default file that gets created, along with your application, that
03:59 contains your main code for the application.
04:02 And you can choose to add new C# files as you go along, depending on how complex
04:06 your application is.
04:07 We're not going to do that right now.
04:09 Let's just take a trip through the user interface of C# Express, so we can see how it works.
04:14 I've already shown you the File menu.
04:16 That's up over here.
04:17 This is where we create projects and save things.
04:19 Pretty standard file-menu stuff.
04:21 Let's move over to the View menu.
04:23 In the View menu, you'll see it's pretty simple.
04:25 I can choose to view the start page again.
04:27 There's other windows that we'll be looking at.
04:29 I'll just go ahead and choose one right now.
04:31 This one is the Error List.
04:32 This window down here shows you if there are any errors or warnings or
04:36 anything else in your code.
04:37 And we'll get back to that later, so let's go ahead and close that.
04:40 Also under the menu, there are toolbars, and you can see that I've got
04:43 some toolbars showing.
04:45 The Project menu is where we control what's in our project.
04:48 So we can add items to the project, we can add references, and so on.
04:52 We're not going to do that right now, but we'll probably do it later.
04:54 Under the Debug menu, this is how we run the application in order to test it out.
04:59 We can also build our solution right here.
05:02 This will build the program without actually running it.
05:04 I'm going to skip over the Data menu and go to Tools.
05:08 Under the Tools menu, I'm going to show you a couple of things.
05:10 First, under Settings, there's a couple of ways that you can use C# Express.
05:14 There's Basic Settings and there's Expert Settings.
05:17 I've left it on Basic Settings right now because we are not going to be using
05:20 any of the Expert Settings for now in our application.
05:23 What I'm going to do, though, is show you under Options.
05:25 Now under the Options dialog, there are a couple things I've changed that
05:29 you might want to change along with me to make some of the examples a little
05:32 bit easy to follow.
05:33 You can see that under Fonts and Colors I've changed the Size and the Font to
05:37 make things readable.
05:38 Now there's a check box down here that says Show all settings.
05:42 So I'm going to check that for a moment.
05:44 You can see that when I do that, a whole bunch of other settings show up.
05:46 What I'm going to do is, under Text Editor, I'm going to choose C#.
05:51 And you can see that there's an option under Display for Line numbers.
05:54 Now that's not there if I turn off the Show all settings function.
05:58 So turn on Show all settings and then go down to the C# option here and check
06:04 the Line numbers option to show line numbers in your code. Click OK.
06:09 And that pretty much completes our tour through the UI for using C# Express.
06:14 We'll see more of this as we go throughout the course,
06:17 but for now that should be a nice overview introduction to the application
06:20 and how it works.
Collapse this transcript
2. C# Language Fundamentals
Overview of the C# language
00:00 C# is a language that was built by Microsoft for working with Microsoft's .NET
00:06 application platforms.
00:08 It is a language that's very similar to other languages you may have seen, such
00:12 as JavaScript or Java or C, C++, Objective-C.
00:17 If you've used any of these languages in the past, you're going to feel right at
00:21 home pretty much in C#.
00:23 Syntactically, the language is very similar.
00:26 C# is what's called a managed-code environment.
00:29 Memory management is automatic.
00:32 So if you've worked with other languages, like C or Objective-C, then you've
00:37 probably come across situations where you have to create and destroy objects on your own.
00:43 C# does all of that for you.
00:45 When you create an object, the C# interpreter, or compiler, actually takes care of
00:50 making sure that that memory is returned to the system at some point, and you
00:54 don't have to worry about it.
00:55 C# is a compiled language.
00:58 Unlike some other languages you may be familiar with, like JavaScript or Perl,
01:01 you must first build a C# program before you can run it,
01:05 and this step is called compiling the application.
01:09 JavaScript and Perl are interpretive languages.
01:12 In other words, the execution engine-- in the case of JavaScript, for example,
01:16 that would be the browser--actually interprets the language line by line, as it
01:20 goes through the program and runs it as it discovers new statements and other
01:25 things in the language.
01:26 C# isn't like that.
01:27 In C#, you write your code, then you have to go through the compilation step,
01:31 and then you can run the application.
01:34 Now at its heart, C# is an object-oriented programming language.
01:38 In C# pretty much almost everything can be treated as an object.
01:42 I've underlined the word "almost" there, because there are a couple of esoteric
01:46 cases where not everything is an object.
01:48 But for our purposes in this course, you can pretty much think that everything
01:52 in C# is an object and can be treated that way.
01:56 In fact, in C# there are no global functions or variables;
01:59 everything is in classes.
02:01 And that might be different from other languages you might be familiar with, like
02:04 JavaScript or like C. But in C# everything has to be inside of a class, and
02:09 we'll come across that as we go further into the language.
02:12 Now as I mentioned earlier, C# is a foundation for working with many different
02:17 Microsoft platform technologies.
02:20 At the bottom of the stack is something called the Common Language Runtime.
02:24 This is the execution engine, or virtual machine, or whatever you want to call it,
02:28 that actually interprets all the various bytes that the program gets compiled
02:33 down to and is what runs your code.
02:36 On top of that are the Microsoft .NET Framework Libraries.
02:40 This is the code that is provided to you by .NET that performs a whole bunch of
02:45 common things that applications have to do, such as reading and writing from
02:48 files, working with the web, and all that kind of stuff.
02:51 That's all contained in the .NET Framework Libraries.
02:55 On top of that is the C# language, which we will be working with today.
02:59 But the thing about .NET is that it was designed to work with lots of languages.
03:03 There are other languages like VB.NET, such as Visual Basic, or Python, and so on.
03:08 But we're not going to concentrate on those;
03:09 we're going to be using C# throughout this course.
03:12 What this allows you to do is use one language to target many
03:16 different platforms.
03:17 So using C# and .NET, you can build applications that will run on Windows,
03:22 Windows Phone, Silverlight, SharePoint, ASP.NET, Xbox, and a whole bunch of others.
03:29 So just by learning this one language, you can build applications that run in
03:32 many, many different places.
03:34 C# got its start way back in 2001.
03:38 This was when Microsoft released the first version of .NET--that was .NET 1.0.
03:43 That was where C# burst on to the scene, and it continued along for a couple
03:48 of happy years, until 2003 came along, which was when Microsoft released .NET version 1.1,
03:54 and that was when C# 1.2 was released.
03:57 Not a whole lot of different changes between the initial C# release and 1.2--
04:01 a couple of cleaning up things they did in the language.
04:03 But 2005 was when things began to get interesting.
04:06 That was when .NET 2.0 came out.
04:08 And .NET 2.0 introduced some neat little things into C#,
04:13 things like generics and anonymous methods and iterators and nullable types.
04:17 Some of these things are advanced and we won't be covering them in this course,
04:21 but we will be looking at things like nullable types a little bit later on.
04:24 In 2007, that was when .NET 3.0 was released.
04:28 And in .NET 3.0 along came C# 3.0, which introduced concepts such as object
04:34 initializers, anonymous types, and so on.
04:37 Again, some of these are advanced, like lambda expressions--
04:40 we won't be looking at those--but we will be using things like object
04:43 initializers later on.
04:44 And then that brings us to 2010, which was when the .NET 4.0 Framework was released,
04:50 and along came C# 4.0, with things like dynamic binding and named and
04:55 optional arguments.
04:56 And we'll be again--as you may have detected by now, a bit of a pattern--
05:00 we will be looking at some of those later on in the course.
05:03 Now as I mentioned earlier, C# is a compiled language, and that means a couple of things.
05:08 In C#, you have to declare your variables before you use them.
05:12 There's no way around this.
05:14 You have to actually say here's the variable I'm going to use and I have to
05:17 say what type it is.
05:18 Now if you're used to a language like JavaScript, you simply use the keyword var
05:22 to declare a variable in JavaScript.
05:24 And you can also do that in the newer versions of C#.
05:28 But we're not going to be doing that now;
05:29 we're going to see how typing actually works.
05:31 So when you declare a variable, you have to supply a type and supply a name.
05:36 So, for example, I would say int myCounter or string message.
05:40 In this case, myCounter is an integer variable for integer numbers and the
05:45 message variable is a string.
05:47 The reason you have to do this is because it helps the C# compiler optimize the
05:51 program for knowing what kinds of data it's going to work with.
05:54 It doesn't have to figure it out on the fly.
05:56 You can also initialize variables when you first declare them.
06:00 I could've written, for example, "int myCounter = 200," or "string message = "Hello World!""
06:07 And this assigns an initial value to the variable when it is declared.
06:12 The other thing you need to know about C# is the concept of namespaces.
06:16 Again, other languages have something like this.
06:19 In Java you may have seen something like packages.
06:22 JavaScript doesn't really have something like this.
06:25 There are some efforts to kind of fake it up using things called modules.
06:29 But a namespace is basically just a way to organize a bunch of information into classes,
06:36 and .NET uses namespace to organize all the classes that it provides for you.
06:41 Essentially, it's a way of naming related classes and other namespaces within the
06:46 namespace such that you can group them together into logical formations that
06:50 make sense for various pieces of functionality.
06:53 And to take an example, .NET provides a namespace called System, which we will
06:58 be using a lot in this course.
07:00 And inside System, there will be classes, so just Console and Environment
07:04 and Math, and so on.
07:05 So each of those little boxes there represents classes and the keyword System
07:09 represents the namespace.
07:11 And in fact, you and your applications can create their own namespaces, and
07:15 we'll see that a little bit later in the course when we start creating our own applications.
07:18 But this is an important concept to understand.
07:20 C# and .NET in general uses namespaces to organize classes.
07:25 And this is how applications get organized and it makes things a lot easier when
07:29 you're writing your code in C#.
Collapse this transcript
Understanding the structure of a C# program
00:00 Let's take a look at the basic structure of a C# program.
00:04 Now, I've gone and fired up the C# Express development tool.
00:07 I'm going to create a new project by clicking the New Project link here on
00:11 the left-hand side.
00:13 The New Project dialog comes up.
00:14 Throughout this course, we're going to be using console applications to build
00:19 our examples, because they are one of the simplest applications to create and
00:23 they allow us to focus on just the C# language without having to worry about all
00:28 the user-interface-related code that other projects require.
00:32 I'm going to select the Console Application option, and I'm going to give it a name.
00:36 I'll just call this one StructureCSharp, and I'm going to click OK.
00:45 At this point, C# Express will create a new project and open it for me, and it
00:50 will drop me in the editor, into a file called Program.cs.
00:53 C# code is stored in files that have the .CS file extension. And right now, we
00:59 only have one of these, but your application can use as many of these files as you like.
01:04 And in fact, as you build your programs, you'll probably create many different
01:09 .CS files to group related classes and pieces of your code, together rather than
01:14 just type thousands of lines into one file.
01:16 For now we've only got one, so let's go through this file line by line.
01:21 Right at the top here we have a bunch of using statements.
01:26 These statements tell the C# compiler which pieces of the .NET Framework that my
01:31 project will be using, and they allow me to write my code using a bit of a
01:36 shorthand notation that we'll see more of in a few minutes.
01:41 Now, if you're familiar with other languages, like, say, Java or C or C++, these
01:48 using statements are sort of analogous to things like import statements or
01:54 include statements, and so on.
01:56 But in C#, we use the using statement to indicate which pieces of the .NET
02:01 namespaces I'm using in my program.
02:04 The next line down is the namespace declaration for this project.
02:09 That's here on line 6.
02:10 Now, I mentioned earlier that C# uses something called namespaces to organize
02:15 code into related groups, or modules, and your program is no different.
02:20 Namespaces are basically just an organizational tool.
02:24 They keep related code together, and they prevent certain kinds of problems.
02:29 For example, if your program were to define a class that has the same name as a
02:34 class in some other .NET library, either from Microsoft or some other third
02:39 party, your program's namespace would keep those two classes from colliding with
02:44 each other and causing a whole bunch of compile problems.
02:47 Now, the C# editor creates the namespace for you when you create your project,
02:52 and it defaults to the name of the project, and we're just going to leave this as it is now.
02:57 Next, we have something called a class definition.
03:00 You can see that here on line 8.
03:02 It's the keyword "class" followed here by the word "Program."
03:07 Again, I mentioned earlier that in C#, almost everything is an object, and
03:10 again, your program is no exception.
03:12 In C#, the way that you define and create objects is by using the "class" keyword,
03:18 which we'll see more of later in the course.
03:20 And again, we're just going to leave this as it is for now.
03:24 Inside the class definition is the most important part of our C# program, the Main function.
03:30 You can see that here on line 10.
03:32 Now if you're already familiar with languages like C, Java, Objective-C, and so
03:37 on, then this will look familiar to you.
03:40 If not, let me explain.
03:41 When .NET goes to run your C# program, it needs to know where to start.
03:46 The Main function is that starting point.
03:49 It doesn't matter how many functions or lines of code your application contains;
03:53 somewhere in your program .NET expects to find one special function called Main,
03:58 and that's where it begins running your program.
04:01 It has to be written as you see it here.
04:03 It needs to be called Main, and the first letter must be uppercase because C# is
04:08 a case-sensitive language.
04:10 Case does matter here, because if you try to ignore case in C#, whether it's
04:14 for function names or variable names or anything else, you are in for a bunch of problems.
04:19 Now, it's important to note that not all C# project types have a Main function,
04:25 for example ASP.NET pages, but many of them do.
04:29 This isn't something that you'll ever have to worry about though, because when
04:32 you're using the visual C# programming tools to create projects, it will create
04:37 the Main function for you if it's needed.
04:40 Don't worry for now what the words "static" or "void" mean, or the stuff that's
04:45 inside the parentheses;
04:47 we're going to cover those later.
04:49 Let's take a look at some of the syntax rules of C#.
04:51 Now first, notice these curly braces on line 7, and 9, 11, 12, 13, and 14.
04:59 These braces are used to group related lines of code together in what are called
05:05 statement blocks of code.
05:06 You can see that they come in pairs.
05:08 There's an opening brace and there's a closing brace, and they must match up.
05:12 Now, they define starting and ending points for things like functions and
05:17 classes and loops, all of which we will see later in the course.
05:22 If you have experience in languages like JavaScript or C or Java, then
05:26 you've seen these before.
05:27 And if not, then all you need to know is that they group lines of code together.
05:32 Now, you'll notice that the Main function is empty, and that's okay, because
05:35 technically, this is a complete C# program.
05:38 But let's look at some basic examples of C# statement syntax.
05:43 To declare a variable, I need to specify a type and a name.
05:48 So for example, I can type "int" and then "myVariable."
05:54 This is different from languages like JavaScript where you don't need to specify
05:59 a type for your variable.
06:01 Now note, also, that every statement in C# must end with a semicolon, as I've done here.
06:08 Some other languages, like JavaScript for example, don't require this, but C# does.
06:13 Every time you type a statement, whether it's a variable declaration or you
06:16 call a function or any kind of statement that you write in the code, it has to end with a semicolon.
06:23 That's a really great practice because it really makes it clear where statements end.
06:28 Now, in C#, I can use some of the built-in .NET objects, since I've included
06:33 them in those namespaces using the using statements--for example, the Console object.
06:39 So let me just show you a quick example.
06:41 I'm going to start typing the word "Console," and you can see that as I'm typing,
06:45 the Visual C# Express development tool is helping me out here by trying to guess
06:50 what it is I'm going to type, and you can see it's centered on the word "Console"
06:53 there in the little pop-up.
06:54 So if I hit Return, it'll put the word "Console" for me.
06:58 Console is one of the built-in objects in .NET when you're using
07:02 console applications.
07:03 For example, to write something out to the console, I can use the WriteLine
07:07 function. So I'm going to type dot, and once again that little code hinter comes
07:12 up, and I'm going to start using word Write.
07:14 You can see that it zeros in on some of the functions available to me.
07:19 I'll just choose the WriteLine function.
07:23 I will just simply write out something like this.
07:26 Once again, notice that I've got a semicolon at the end of my statement.
07:30 The other thing that you should notice is that in C#, strings are contained
07:35 within two double quotes.
07:37 We'll cover a lot of this a little bit later in the course.
07:39 But if you're coming from languages where strings can be specified using either
07:43 single or double quotes, that's not the case in C#;
07:46 you have to use double quotes.
07:46 Now, notice how the word Console is in light blue.
07:50 That's because the Compiler notices that I'm using a built-in object in C#.
07:55 The Console object is contained within the System namespace.
07:59 Watch what happens when I go up here and I comment out the using System
08:04 statement up here on line 1.
08:05 Notice now I've got a little red squiggle down here on my Console object.
08:11 It says, "The name 'Console' does not exist in the current context," when I mouse over it.
08:16 So now I've gone from being able to use this object to not being able to use this object.
08:21 The reason for this is, when I commented out the System namespace, if I want to
08:25 be able to use that object now, I have to write what's called a fully
08:28 qualified path name.
08:30 So I would have to write out "System.Console.WriteLine" if I wanted to use this
08:36 now. And you can see that when I put the word "System" in front of the word
08:39 "Console," now it goes back to being light blue because the compiler recognizes it again.
08:43 So by using these using statements, I can write my code using shorthand, rather
08:49 than having to write out these big, long, fully qualified paths to all the objects in .NET.
08:55 So it makes writing your code a lot easier.
08:57 So I'll go back up to the top here and uncomment that line.
09:03 You notice even when I have it uncommented, I can leave it fully qualified if I want to.
09:07 But now, I have the ability to take out that System statement and now Console
09:11 goes back to being recognized.
09:14 White space doesn't really matter in C#.
09:16 Now, some languages consider the indentation level of lines of code to be
09:20 important, but C# does not.
09:22 You can put as much or as little white space in your program statements as you like.
09:27 For example, I could put this statement all the way over here, and I can just
09:31 put this statement all the way back over here.
09:33 It doesn't really matter; this is all good.
09:35 Obviously, there are places where white space is going to matter.
09:38 So for example, inside of a string, if I do this, well, that's
09:41 pretty significant.
09:42 That's going to affect the way that that string is written out.
09:44 But within lines of code, white space does not matter.
09:49 So if you're coming from a language where white space matters, you don't have to
09:52 worry about that here.
09:53 Indentation in C# is just used for maintaining readability.
09:58 So we've seen enough C# where we can now start writing our programs, and we can
10:02 go on to the next part of the course.
Collapse this transcript
Compiling and running your code
00:00 One last thing that we need to look at before we jump in and start writing our
00:04 C# code and learning how to do all kinds of great things, like writing programs
00:08 and using variables and objects and so on, and that is compiling and running the code.
00:14 I realized I've done this a couple of times so far, but I want to get a little
00:17 bit deeper into this.
00:18 That way, as you're working through the course, you can see how the building
00:22 process works and the various tools that you'll need for when errors happen in
00:27 your code. And I say when and not if because errors are going to happen and you
00:31 need to be prepared for that and to see how to recover from these situations and
00:35 how to build your code correctly.
00:38 So as I said earlier, C# is a compiled language.
00:41 You have to compile it before you can run it, so we're going to cover some
00:45 tips on how to do this.
00:47 Now, the term for compiling and creating your finished application is "build."
00:52 So let's just make a new project, and we're going to call it BuildAndRun and make
00:59 sure it's a console application.
01:01 I'm going to click OK.
01:03 Now, what I'm going to do first is I'm going to click the Save All icon here.
01:09 I can also just choose Save All from the menu here.
01:12 I'm going to save this application in my Documents folder.
01:16 Now, this folder will be different for you based upon the computer that you're
01:20 using and where your Documents folder is, but I'm going to save it in the
01:23 default location, which is the visual studio 2010/Projects folder, and we'll go
01:28 out to the file system and see this in just a minute.
01:30 But I'm going to save.
01:33 Now that I've saved it, I've actually put the project onto a physical
01:38 location on my disk.
01:39 It's no longer sitting out there in temporary space.
01:42 So recall that the way that we build that application is by using either F6, or
01:46 up here in the Debug menu, we can choose Build Solution.
01:50 So I'm going to choose Build Solution and you can see down here in the toolbar,
01:54 there's a little message that says "Build succeeded."
01:57 So let's go out to the file system and see where the application is actually built to.
02:03 I'm here in my Documents folder, and you can see that there's a folder here
02:07 called Visual Studio 2010.
02:09 This might be slightly different based upon which version you're using.
02:12 But I'm going to go into Visual Studio 2010.
02:15 There's a folder called Projects.
02:17 Here's the project that I just built called BuildAndRun.
02:20 So let's take a look in there.
02:21 You'll see that inside BuildAndRun, this is the solution, the top-level project
02:25 for our code, and then there's a folder that goes along with it.
02:29 And inside the folder, there's the Program.cs file.
02:32 This is where our code is kept.
02:34 This is the project file.
02:35 There's also a folder in here called bin.
02:38 bin is short for binary.
02:40 This is where the application is kept.
02:42 Inside there, there are two folders:
02:43 there's Debug, and there's Release.
02:46 If we look in the Debug folder, you'll see that there's some information here
02:50 about the application's debug information.
02:53 If we go into the Release folder, you'll see that there's a couple of things in here.
02:57 First, there is BuildAndRun, and you can see that that's an application.
03:00 This is the actual finished application that gets built when you create the
03:05 application using Build inside the C# Express environment.
03:08 So this is the finished application.
03:10 That little PDB file is called the program database.
03:14 It contains some information that .NET needs to use in order to debug and run
03:18 the application that we've built.
03:20 But for now, all you need to know is that when you build an application, this is
03:24 where it actually gets placed.
03:25 When you create a project and you save it in whatever folder you save it in, the
03:29 C# IDE will build this subfolder structure for you.
03:34 Let's go back to the IDE.
03:36 Now, we're going to take a look at how we can build errors and warnings and fix
03:42 things and so on like that.
03:43 Here in my Main function, what I'm going to do is write some code.
03:48 I'm going to say int myInt = 50.
03:55 Don't worry too much about following along with this code.
03:58 We're going to cover variables and stuff later.
04:00 I'm going to make one more line.
04:08 This is code that we've been working with in a couple of examples now. Let me save this.
04:14 Now, I'm going to hit F6, and you can see that everything built just fine.
04:18 However, you can see that there's a little squiggle here under myInt.
04:21 What I'm going to do is go up to the View menu, and in Other Windows, I'm going
04:29 to choose Error List.
04:31 When I choose the Error List, you can see here that there is a warning, and the
04:35 warning is that the variable myInt is assigned, but its value is never used.
04:40 Warnings are not necessarily as bad as errors; your application will still run
04:44 just fine without it.
04:46 And just to show it to you, let me you put one more line of code in here.
04:54 Now, when I press F5 to run the application, or if I choose this little
04:58 triangle up here, or if I go to the Debug menu > Start Debugging--that's
05:03 where I run the program; I'll just use F5--
05:06 you can see that the program ran just fine, even though I had a warning there.
05:09 But that's no excuse for having warnings.
05:12 If you've got a warning somewhere in your code, you should really pay attention
05:15 to it because the compiler is trying to tell you something.
05:18 And in this case, the warning is a little bit benign.
05:19 I just created a variable that I never used.
05:22 But warnings can actually be pretty serious, and they usually indicate something
05:25 is wrong with your code.
05:26 So if you get warnings in your code, go look them up in the error list here and go fix them.
05:30 The next thing I want to do is make an error.
05:34 So what I'm going to is I'm going to remove the double quotes from the end
05:38 of that line there.
05:40 You can see that when I do that, I get a red squiggle which says that there's
05:44 some kind of error going on.
05:45 And if I try to hit F6, there's a whole bunch of build errors.
05:50 You can see down in the error list,
05:53 there are now three errors and the warning for the variable that I had before.
05:57 You can see that the errors are hey!
05:59 There's a new line in the constant. There is no semicolon.
06:01 There is no closing parenthesis.
06:04 All of these errors are occurring because I left off that closing quote.
06:08 When you get an error like this and the error list pops up, you can just
06:11 double-click on any one of these guys, and it will take you right to the line
06:15 where the error occurs.
06:17 Now, in this case to fix this, I just need to put the double quotes back.
06:21 But if I don't do that and I leave it and I ignore these warnings and I try to
06:25 run, by pressing F5, you'll see that there are build errors.
06:29 And C# is telling me, hey!
06:30 There were build errors, but if you like, you can continue and run the last time
06:35 that this was successful.
06:36 But I'm not going to do that.
06:37 What I'm going to do is click No and I'm going to say, okay, let's go ahead and
06:40 fix that problem, so I'll put the quotes back in.
06:42 Now everything is fine.
06:45 Once I press F5, you can see that the code is now working again.
06:49 The next thing I want to do is see away that I can get more information about my build.
06:55 Under the Tools menu, I'm going to switch over to Expert Settings.
07:00 Don't be intimidated; this really isn't a very big deal.
07:03 What I'm going to do is choose the View menu.
07:07 I have the Error List still, but now I have a new window here under Expert
07:11 mode called Output.
07:12 You can see that when I choose it, there it is right there.
07:15 So the Output window shows me a lot more detailed information about the
07:18 build-and-run process.
07:20 So, for example, if I now hit F6, you'll see that the output window is giving me
07:24 a whole bunch of information about the files that got compiled, any warnings or
07:28 errors that popped up.
07:29 You can see that whether the build succeeded or not.
07:32 You can see that where the output of the application was built.
07:36 You can see that BuildAndRun.exe was placed in this path down here at the bottom.
07:40 By using the Output window, you can get more information about where the build
07:44 process is and what it's doing and what the results are.
07:48 The last thing I want to do is show you how you can find out more
07:51 properties about your project.
07:54 Under the Project menu, I'm going to choose BuildAndRun Properties.
07:58 This menu item will change based upon whatever your project is called.
08:02 It'll be project name and then the word Properties here.
08:05 When I choose this, I get a whole bunch of properties about what my program is
08:09 and how it's being built.
08:11 So here under the Application tab, I can see that this is what my Assembly name is.
08:16 An assembly is basically just a generic term that says this is some physical
08:20 piece of code on the disk somewhere and it's the name of my project.
08:23 Same thing for the namespace.
08:25 I can also see what target framework I'm going after.
08:28 In this case, I'm using the .NET Framework 4.
08:31 But if I click on this, you can see I can build my application to target other
08:34 versions of the .NET Framework, all the way from 2.0 up through 3 and through 4,
08:39 and there are other frameworks I can install as well.
08:42 Under the Output type dropdown, this controls what kind of application I'm building.
08:46 Now, it's currently set to be a console application, but I can change it to be a
08:49 Windows app or a class library, and so on.
08:52 The last thing I want to show you is under Build, there are ways that I can
08:57 control how the application is built.
09:00 We'll see a little bit of these later on, but I can change how the errors and
09:04 warnings are reported.
09:05 I can say what the warning level is and there are four warning levels, all the
09:09 way up from very verbose down to not very detailed at all. So I can choose what
09:13 warning level I want.
09:14 I'm going to leave it on 4.
09:15 I can also suppress individual warnings that I don't want to know about.
09:19 Now, I don't suggest that you do this, because it's really good idea to know
09:23 about all the warnings in your code, but it is possible to do this.
09:27 You can also set a little preference over here that says Treat warnings as errors.
09:31 I can say None or All or Specific warnings.
09:34 If I changed this to All, for example, and then went back to my application,
09:40 you can see that when I hit up 6, now the warning that was hey!
09:44 The variable 'myInt' is assigned, but its value is never used, it's an error now.
09:48 It's no longer a warning.
09:50 So I'm going to go back and change that back to the way it was.
09:55 Now, I'm going to hit F6, and you can see that we're back to being a warning.
10:00 This is how you can control how your application is built, and it's how you get
10:04 more information about the process by which Visual C# Express builds your
10:08 application and runs it and fixes errors.
10:11 Now that you know how applications are actually built, we can dive right in and
10:15 start doing some more interesting stuff.
Collapse this transcript
3. Program Flow
Reading and writing from and to the Console
00:00 So now that we've got the foundational stuff out of the way, we can dive in and
00:03 start writing some real C# code. And what we're going to do in this particular
00:07 example is see how to read information from, and write information to, the console window.
00:14 And this is important to know how to do because for the rest of the course
00:17 we're basically going to be building examples that use the console as the place
00:21 where we write information to and read information from.
00:24 So we need to get a fundamental understanding of how the console works in order to do that.
00:28 So I've opened up, under Chapter 3, the HelloWorldProject in the example files
00:33 folder. And if you don't have that, you can just simply create a new project and follow along.
00:38 The other thing I've opened up is the ExampleSnippets.txt file, and this contains
00:44 the code that I'm going to be copying and pasting from so that you don't have to
00:47 sit there watch me type.
00:49 So let's go back to the program. You can see that we have our HelloWorldProject,
00:54 and down here in our Main function, this is where we're going to be filling the code in.
00:58 So let's go ahead and do something really simple, which we've already done a
01:02 couple of times, but just for refresher, let's write some information out to the console.
01:05 So I'm going to copy this line right here that says Console.WriteLine. I'm going to paste that in.
01:12 So the console object has a series of functions that read and write data, and the
01:17 most common ones are WriteLine and ReadLine. And you can guess what they do.
01:21 WriteLine writes out a string of text followed by a carriage return, which takes
01:26 the cursor back to the new line.
01:28 Now we could use Write which writes out the string and does not put a carriage
01:31 return on there, but for readability, we'll just WriteLine. And then there is the
01:35 ReadLine function which reads a string of text.
01:39 In this case, I'm using it just to keep the console window up, so you can see
01:42 the example working, but it will return a string if we want it to.
01:46 So let's just go ahead and save this, build it--
01:49 you see the Build succeeded--and run it, and no surprise, the string "Hello World!"
01:55 gets written out to the console.
01:56 So let's go ahead and make a couple of changes here.
01:59 What I'm going to do now is go back to the Snippets, and this time we're going to
02:03 read information from the console window and then write it out.
02:08 So I'm going to copy these three lines, paste them in.
02:13 So now what we're going to do is write out a string that says, "What is your name?"
02:18 And then we're going to use the ReadLine function to read a string of data from
02:22 the console and then write out a message that says, "Hello there" plus whatever
02:27 name the person gave us.
02:28 So you can see here that we've got a string variable that is being assigned to
02:32 the result of the ReadLine function.
02:35 Down here, we're just not using the result, which is why the window is
02:38 staying up. But here we're actually going to read the result and use it in the next string.
02:43 So I'm going to save, I'll build, and we'll run.
02:47 You can see it says, "Hello World! What is your name?"
02:49 And I'm going to type in "joe," hit Return and it says, "Why, hello there joe."
02:54 Let's go take and look at the code and see why that works.
02:56 You can see that the string variable here that gets returned from ReadLine
02:59 contains my name, and then in the WriteLine statement we're writing out the
03:04 string "Why, hello there" and then plus the string here.
03:09 Writing strings out to the console window takes many forms.
03:12 It's something that you'll probably do a bunch.
03:14 And although you can use the plus operator, there is actually other ways
03:17 to write strings out.
03:18 So let's take a look at how those work.
03:21 To build strings in C# for the purposes of displaying to the user or formatting
03:26 them for output, there is a couple of ways you can do this.
03:28 Now you've already seen the example where we use the plus operator.
03:31 This is something that you're probably familiar with if you done this in JavaScript.
03:35 It works in JavaScript and as you've seen,
03:36 it works in C# too.
03:38 However, it's not the most efficient way to build strings in C#, for
03:42 reasons we'll see later on.
03:43 There are other ways to format strings for display to the user, and the way that
03:48 we do that is by using the String.Format method.
03:52 And that method takes an argument, which is the string you want to write out
03:55 along with data that you want to put into that string.
03:59 So for example, if we wrote String.Format,
04:02 "There are," and then some code that we'll get back to in a second, "seconds in a
04:07 year" and then an argument, which is probably a number.
04:11 The way that you format a string is by using those curly braces with an integer
04:15 number in there that serves as a placeholder for data that's going to be
04:19 inserted into the string for you.
04:21 And as you might have guessed, if you had more than one piece of data you wanted
04:24 to do this with, you would use more than one curly brace.
04:28 So in this example, it says String.Format.
04:30 There are something seconds in a year, and that little i is going to be
04:34 substituted where the 0 is in those curly braces--and in fact, it
04:38 substitutes entire thing.
04:39 The curly braces and the 0 don't appear in the finished string;
04:42 it gets substituted with the value of the data.
04:45 If you had more than one, you'd simply use more than one curly brace, and you'd
04:48 increment the number for each one of the variables.
04:51 So in this case, if I had two arguments that I wanted to format into the string,
04:55 I would simply supply those as arguments and use two sets of curly braces in the
04:59 String.Format argument.
05:01 So let's go back to the code and see how this works.
05:03 So I want to go back to my Snippets, and I'm going to copy this line right here.
05:07 Now I'll paste it in.
05:12 So now we have a variable called mySeconds, which we are calculating.
05:15 So there is 60 seconds in a minute, times 60 minutes in an hour, times 24
05:20 hours in a day, times 365 days in a year, and that gives us the number of
05:25 seconds in one year.
05:26 So you can see here that we have our Console.WriteLine, and we have our string
05:31 with the curly brace.
05:32 Now notice we're not using the String.Format method, and that's because the
05:35 WriteLine method of the console object knows how to use the String.Format method internally.
05:41 So we pass it what is called a format string, which has this little escape
05:45 sequence, or code sequence in it. And we're passing in the mySeconds variable and
05:50 when we run this, if everything goes well, then we should have the number that's
05:53 calculated inserted into the string.
05:55 So let me go up here and just comment out the code that we're not using, and we'll save.
06:03 This time I am also not going to use F6;
06:05 I'm just going to hit F5, which builds the program for me and runs it.
06:11 So I'm going to collapse two steps down to one and press F5 and you can see
06:16 that the number of seconds in one year has been substituted where those curly
06:20 braces were in the string.
06:22 We were going to be using Console.WriteLine and Console.ReadLine to write and
06:27 read information to the console throughout this course.
06:30 And after following the example here, you can see how to do it for yourself.
Collapse this transcript
Writing conditional statements
00:00 One of the things that any application has to be able to do is make decisions.
00:05 Decisions are inescapable.
00:07 They are an important part of pretty much any nontrivial program that
00:11 you're ever going to make.
00:12 Decisions are made when your program flow is chugging along nicely and suddenly
00:16 you come into a situation where you have to make a decision, and there is also
00:19 the decision of either true or false.
00:22 And this is, of course, built in classical programming using the if statement.
00:26 The if statement takes a Boolean condition and if that condition is true then
00:31 the code that is inside the if statement is executed.
00:35 Now, of course, there is a case for when the condition is not met, and that is the else case.
00:40 If the condition is not met and you have an else case on your if statement,
00:43 because they are after all optional, then the code for the condition where the
00:48 condition is not met is run instead.
00:50 In C# you can also have the else if statement, so we could replace that else
00:55 with an else if on another condition.
00:57 And in fact we can chain a bunch of these together to make a whole bunch of if,
01:01 else if, else if, else if, and so on. And if you want, you can have a trailing
01:06 else condition to handle everything else.
01:08 So let's jump over the code and see this in action.
01:11 Here in the code, I've opened up my ConditionalCode example file, and I've got my
01:16 Program.cs code open.
01:18 I've also got the ExampleSnippets file open right here. And I'm going to scroll
01:22 down to the Conditional Statements section, because these are the statements
01:25 that we're going to be using.
01:27 So back over here in the code, let's put together an if statement and see how it works.
01:32 So I'm going to copy these lines right here in my variable declaration, along
01:38 with the if statement. I'll copy and we'll just paste that in.
01:44 And you can see here that we have a variable, named theVal, which is initialized
01:48 to be 50, and then we have an if statement, which tests the condition to see if
01:53 (theVal == 50) then run some code.
01:57 Notice that there is two equal signs in here.
02:00 If I just tried to put one equal sign in here, I would get an error.
02:04 You can see the little red squiggle shows up, and it says, hey, you can't do a
02:07 conversion. And it's not important what that error means;
02:10 the point is that you can't do that.
02:12 So to test for equality it's two equal signs.
02:15 One equal sign does assignment; two equal signs tests for equality.
02:20 So if (theVal == 50) then we'll write out this data, so it's firstVar is 50.
02:27 And actually, let me change that because it's misspelled. There we go; theVal is 50.
02:32 So we'll save this, and we'll run it.
02:34 I'll use F5 to do that. And you can see that "theVal is 50" is being written out.
02:40 So let's go back to the code and change the value.
02:43 Let's make it 51, and we'll save and run it again.
02:47 And you can see this time nothing is being written out because the
02:50 condition is not being met.
02:51 Let's go back to the code.
02:53 Let's change this back to 50.
02:54 The other thing I want to point out on the if statement is you'll notice that
02:58 I'm using these curly braces to contain the code that's being executed in the
03:02 case of the if condition.
03:04 If all you have is one line of code for your if condition, you actually can
03:09 technically leave these braces out and that will work just fine.
03:13 However, for the sake of readability, and because if statements are very rarely
03:19 limited to one line, I always use the braces.
03:21 I always put them in there. it's a good idea to do so.
03:24 It helps readability of code.
03:25 It helps keeping your statements together.
03:27 So my suggestion is to always use the curly braces, even if you only have one line.
03:32 Let's go back to the Snippets, and let's bring a couple of other lines in here now.
03:38 We're going to try the else if condition this time.
03:42 So I'll copy this, and we'll paste it in below the if.
03:46 So now we have a condition that says if (theVal == 50) then write out this
03:50 statement; otherwise else if it's 51, write out something else. And once again,
03:54 I'll just change that.
03:56 Okay, so let's run this.
03:57 Okay, so you can see that the first condition is being met.
04:02 Now let's change it to 51, save and run, using F5.
04:09 And you can see that this time the else if condition ran, because the value was
04:14 51 instead of the 50. So this time, this condition was executed instead.
04:18 One more test to try.
04:20 Let's go back and copy this code over.
04:23 I'll now copy this and paste at the bottom of my else. And in this case, this
04:32 code is going to run when none of the conditions are met.
04:36 So we have if (theVal == 50), else if (theVal == 51), and the last else condition
04:41 catches everything else.
04:43 So let's just change this to, I don't know, something like 75.
04:46 We'll save and hit F5.
04:49 And you can see that in this case "theVal is something else" is being written
04:52 out, because the last else condition is triggering because the value was not
04:56 equal to 50 or not equal to 51.
04:58 So none of these if conditions right here fired.
05:02 You can have more than one condition in the if statement.
05:06 So for example, if I wanted to have this if condition execute if theVal was
05:11 equal to 50, or something else, I would simply put this one in parentheses,
05:17 and then I would use the OR operator, which is the two vertical bars--and we'll learn
05:24 about this a little bit later, but just bear with me for now.
05:27 So if ((theVal == 50) or (theVal == 49)) then you can write out "theVal is 50 or 49."
05:39 We'll save and now this if condition will execute if theVal is equal to one
05:45 of those two numbers.
05:46 So we'll change it to 49, hit F5, and you can see that the first if condition is
05:51 now being set, so that code is executing.
05:55 Let's go back. If we wanted to change it to AND instead of OR, I am going to
05:58 just use two ampersands.
06:00 Again, we'll learn about that in a little bit. But just for sake of example, I
06:03 want to show you how this works.
06:05 Now in this case, theVal is something else. Why?
06:08 Because here theVal is 49, but for this entire condition right here to be
06:12 true, both of those statements have to be true: theVal has to be 49 and theVal has to be 50.
06:19 And since that's clearly impossible, that first statement is not going to execute.
06:23 So you can see here that we're using if statements to create tests for
06:27 conditions in our code, and we can chain a whole bunch of these things together
06:31 using if, else if, and else. But if you find yourself running into situations
06:36 where you have a lot of different conditions to test for, using the whole bunch
06:39 of ifs and else ifs gets really hard to read and really hard to manage, and
06:44 there's a structure for doing that which we'll take a look at in a little bit.
Collapse this transcript
Using the switch statement
00:00 For cases where your code has to check a lot of different conditions in order to
00:05 execute different parts of your code, it's usually not very efficient to have a
00:08 whole lot of if and else if statements.
00:11 It makes the code harder to read, and in that particular case
00:14 it's usually better to use something called the switch statement.
00:17 And the switch statement can be thought of as a whole bunch of if and else if
00:21 statements, but with a slightly different way of writing it.
00:25 The way you use a switch statement is you write the word "switch" and there is a
00:29 value that you pass to the switch statement, and then inside the switch
00:34 statement, you use a whole bunch of cases.
00:36 So you have a case for some value, which will then run some code, and you have a
00:41 break statement which says okay that's the end of this case. And then you can do
00:45 this as many times as you need it.
00:46 So you can have a case for a whole bunch of different values that all
00:49 run different code.
00:50 Now in the case where none of the values map to a particular case, you can
00:55 have a default case, which will run some code, or do nothing--
00:59 it's up to you. But the default case will be executed when none of the
01:03 other values match.
01:04 Now if you're coming from some other languages like C or Objective-C, for
01:08 example, they let you do things like this.
01:10 You can take that break statement out, in which case, when value1 or valueN are
01:16 met, the code will run.
01:18 And in the case of value1, the code for value1 will run as well as the code for
01:23 valueN, because there is no break statement in there to stop it.
01:26 Now, this is not legal in C#.
01:29 In C#, every case has to have a break command at the end.
01:33 Your code can't fall through to next case like in some other languages.
01:38 And the reason for this is because the designers of C# did a whole bunch of
01:42 studying of where bugs come from in programming logic.
01:45 And it turns out that a lot of bugs can be traced back to developers mistakenly
01:49 leaving out break statements in their switch cases when they probably shouldn't have.
01:54 So the C# language enforces this.
01:56 You have to have a break at the end of each one of your cases.
02:00 There is ways to get around this, but they're kind of esoteric, and I'm not
02:02 going to show you how to do them in this course, because they're not good
02:04 programming practices.
02:05 Just suffice it to say that you have to have a break at each one of your cases.
02:10 So let's go ahead over to the code and see how a switch statement works.
02:12 Here I have my SwitchStatement project open, and in my ExampleSnippets, I've
02:18 scrolled down to my Switch area.
02:20 So what I'm going to do is copy some code. I'll just copy the first part of the
02:25 switch case here, and I'll paste it in, and I'll close off the switch right
02:32 there, and I'll save.
02:33 So in this case, what we're going to do is write some code that does pretty much
02:37 the same thing that a whole bunch of if else statements would do, but using
02:41 switch case instead.
02:43 So here you can see I've got an integer variable called theVal, and it's being
02:47 set to a value of 50. And then the switch statement says hey what's the value of
02:52 theVal? And for case of 50, the Console will write line, The value is 50.
02:59 So let's save this and run it, and you can see, sure enough, "The value is 50"
03:03 is being written out.
03:04 So if we go back and change it to, say, something like 51 and we save that and run it,
03:08 well, now nothing is happening.
03:10 Okay, let's go back to the code and make some changes.
03:13 Go back to my Snippets, and I'm going to copy the rest of the cases in.
03:17 I'll save that, and now you can see that we have a whole bunch of cases:
03:24 there is 50, 51, 52, and a default case.
03:28 So in the case where I change theVal to be 52, then I save it, and then I run it,
03:34 in that case, the case for 52 is being run.
03:37 If I change it to something else, say 99 in this case, none of these cases is
03:43 going to match, so the default case should be run instead. And sure enough, that's
03:47 exactly what's happening.
03:49 So let's see what happens when you try to take out this break right here.
03:52 And you can see that when I take out the break, the little red error squiggle
03:57 appears under this case. And specifically, it says, "Control cannot fall through
04:01 from one case label to another."
04:03 So you can see here that C# is explicitly enforcing the rule that you have to
04:08 have breaks in your cases.
04:09 So let me just undo that, and we'll save, and we'll run it again, and you can see
04:14 that everything is working just fine.
04:16 So the switch statement provides a pretty handy replacement for a whole bunch
04:21 of nested if else, and I think you can agree with me that reading code that
04:25 looks like this with a whole bunch of cases is a lot nicer than reading a whole
04:29 bunch of ifs and elses.
Collapse this transcript
Using operators and expressions
00:00 Any nontrivial program that you write is going to be full of calculations.
00:04 You are going to be calculating things like scores and prices and all kinds of things.
00:08 And in order to do that, you need expressions, and you need operators to
00:12 build those expressions.
00:14 An expression is essentially just a collection of operators and operands, which
00:19 are the things that operators work on, that produce a result.
00:23 So for example, if we had an expression like this, we had 5 + 2 * the absolute
00:29 value of x, that is an expression.
00:32 And the plus and the star, those are operators.
00:37 Operators are simply symbols and functions that determine how expressions are evaluated.
00:43 So for example, we of course have the arithmetic operators.
00:47 These are pretty common in almost every programming language.
00:49 There's addition, subtraction, division, multiplication, and the percent sign--
00:54 maybe something you have not seen before,
00:55 but it exists in a lot of other languages, like C and JavaScript and
00:59 Objective-C and C++.
01:01 It's the remainder, or modulus, operator.
01:04 Basically it gives you the leftover results of a division operation.
01:10 So for example, 5 modulus 2 would be 5 divided by 2 but what's left over, so it would be 1.
01:16 There's also the assignment operator.
01:19 The assignment operator is the equals sign.
01:21 So take an example: if we had two variables, x and y, and we wanted to add them
01:26 together using the plus operator, or the addition operator,
01:29 we can then take the result of that expression and assign it to a third variable
01:33 called result, using the equal sign.
01:36 If we had a variable named distance and we wanted to add a number to it, we
01:40 could do distance = distance + 10.
01:43 This takes the existing variable, adds 10 to it, puts the result back in the same variable.
01:49 In fact, this is so common that there is a shorthand notation for doing this.
01:53 You can write distance = distance + 10 the same way by just doing distance += 10.
01:59 And in C# that means, take the variable and add to itself the number on
02:04 the right-hand side.
02:05 It also works of course for the minus, the multiplication, the divide, and the
02:10 modulus operators as well.
02:11 In addition to the math operators, there are also comparison operators.
02:16 So for example, we can check to see if things are equal to or not equal to each
02:21 other by using the equality check operators.
02:23 The two equal signs together say, hey, is a equal to b?
02:27 Do they have the same value?
02:29 We can check for things that are not equal by replacing the first equal sign
02:33 with an exclamation point.
02:34 In this case, this says a not equal to b. And as you might expect, there are also
02:39 operators for comparison testing to see if there are a larger or smaller numbers.
02:44 We can do things like a > b, a < b, a >= b, and a <= b.
02:54 The logical operators, such as AND and OR, allow you to combine more than
02:55 one condition.
03:01 So, for example, the AND operator, we can use to see if a=b and c=d. We use
03:09 two ampersands together.
03:10 There is no space in there.
03:11 We just put them next to each other and that is a logical AND operator.
03:15 We can do the same thing for OR.
03:17 The OR operator is just two vertical bars.
03:20 So in this case, if a=b or c=d, then the code inside those curly
03:26 braces would execute.
03:27 We can also do a NOT operator.
03:30 The NOT operator you can place in front of any Boolean expression to produce
03:35 the opposite of what that value evaluates to.
03:38 So for example, in this case, we are saying if not some Boolean value.
03:43 So if we set a to true for a certain Boolean value, then if we use bool b = !a,
03:50 that gives us the inverse value of a. So b is now false.
03:54 That's what the NOT operator does.
03:56 There are also operators for incrementing and decrementing, because again, this
03:59 happens a lot in programming.
04:01 The increment operators are, as you might expect, the addition operator, where you
04:05 simply take a and add 1 to itself.
04:07 We've already seen how to reduce that down using shorthand notation, to take the
04:11 value of a variable and add a value to itself.
04:14 But there's even a shorter hand way of doing this, because this is so common.
04:18 So there's the ++, and the ++ operator, postfix and prefix.
04:24 So when the ++ comes after the variable, that's postfix; and when ++ comes
04:29 before the variable, that's prefix.
04:31 They both do the same thing:
04:33 they both add 1 to whatever the variable is. But they do it in a certain way
04:38 that's slightly different from each other, and we'll see why in just a moment.
04:41 As you might expect, there's also decrement operators.
04:44 So for a + 1, we also have a = a - 1.
04:48 And we've already talked about how we can do the -= operator.
04:51 But there's also post and prefix versions of decrement as well, where you
04:55 simply put two minus signs next to the variable rather than two plus signs.
04:59 So what's the difference there?
05:01 The difference is this:
05:02 Suppose we had a variable whose value is 10.
05:04 If we use this statement, Console.WriteLine ("The value of a is:
05:08 and using our string formatting, we put the value of a into that replacement
05:13 curly braces expression there, the ++ prefix notation would execute first before
05:20 putting the value into the string.
05:22 So in this case, the output would be 11, because a gets incremented before it
05:27 gets put into the value of those curly braces.
05:30 If we use the postfix notation, that increment would get done after the
05:35 substitution took place.
05:37 So in that case, the output would be 10, even though a would then be incremented
05:42 and would be equal to 11.
05:44 So that's the main difference between prefix and postfix increment.
05:47 There's also type testing operators.
05:49 There's the is operator and the as operator.
05:53 And we'll learn more about these as we go through the object-oriented part of the course.
05:57 But essentially, what happens here is the is operator returns true if a given
06:02 object is a certain type.
06:04 The as operator takes a given object and converts it to another type if
06:09 it's possible to do so.
06:10 So let's just take a quick example--and I understand if you don't follow along
06:14 right away with this, but as we get to the chapter on object orientation, this
06:17 will become more clear.
06:19 So suppose we had a function that takes an object,
06:21 a generic object type.
06:23 We can say something like if obj is the type of Employee object.
06:29 So the is operator will return true if the object is of type Employee.
06:34 And if that's the case, we can then use the as operator, which will convert the
06:39 object to the type that we give it.
06:41 And if it can't be done, it will return null.
06:44 So in this case, we are taking the Employee emp and we are saying obj as Employee.
06:50 So it's converting the obj to an employee object which we can then operate on.
06:55 There's also an operator called the ternary operator.
06:57 Now most operators we have seen so far are binary operators.
07:00 So for addition, for example, you have two operands.
07:03 You have the two operands that are being added together.
07:05 The ternary operator works a little bit differently.
07:08 It actually has three operands, and it's written using the question mark and the colon.
07:13 It operates as if it were a very compact if else statement.
07:18 So it works like this:
07:19 You have a condition which evaluates to true or false just like any other statement.
07:24 You then put the question mark next to it and then the value that you want to
07:29 be assigned in the case that the condition is true, and then a colon, and the
07:33 value that you want to be assigned in case the condition is false.
07:36 So let's take a real example.
07:37 Suppose we had a couple of prices and we wanted to find out which of price1 and
07:42 price2 was the low price.
07:44 Now we could write it like this:
07:45 we could say if price 1 < price2 then the lowPrice = price1; otherwise
07:51 lowPrice is price2.
07:52 Or we could write it like this:
07:54 we could say lowPrice = and then the condition.
07:57 The condition here is price1 < price2.
08:01 Now if that evaluates to true--we put the question mark there--price1 would be the low price.
08:06 That's the true case. And then a colon
08:09 and then the value for the false case.
08:10 In this case, it will be price2.
08:11 So you can see we've taken the if statement and compacted it down to just one line of code.
08:17 Finally, there is operator precedence.
08:20 Most programming languages have the notion of operator precedence.
08:23 Operators are operated on in a particular order, based upon what the operator is.
08:28 So let's take a look at an example.
08:30 Suppose I had this expression.
08:32 I have an integer variable named result, and there's a whole bunch of numbers
08:36 being operated on, 2 + 3 * 6 / 2.
08:40 The temptation of course is to execute this expression going from the left and
08:43 traveling to the right, just like you probably learned in school.
08:46 And if you did that, you probably say, okay, well 2 + 3 is 5 and then 5 * 6 is
08:51 30 and then 30 / 2 is 15, so hey, the answer must be 15, right? Well, wrong.
08:56 And the reason it's wrong is because those operators are executed in order based
09:01 upon what the operator is.
09:03 This is what operator precedence means.
09:05 So that's actually wrong.
09:07 What happens is the multiplication operator gets executed first, because that
09:11 comes first in the precedence order.
09:14 So 3 * 6 would be 18.
09:16 Then the division operator would execute, and 18 * 2 would be 9.
09:22 Then we would go back and we would do the addition, because 9 + 2 is now 11.
09:27 So the real result would be 11.
09:29 Now you can change the order of precedence by using parentheses.
09:33 So if we put parentheses around the 2 and the 3 then things would execute in
09:37 the order that you thought they would.
09:38 In this case, the (2 + 3) would be executed first because it's in parentheses.
09:42 Then *6 is 30, divided by 2 is 15,
09:44 so the answer in that case would be 15.
09:47 So how do you know which operators come first?
09:49 Well, let's take a look.
09:50 The operator precedence operates in a very predictable order.
09:53 First, there is the Multiplicative operators, which are things like
09:57 multiplication, division, and the modulus operator.
10:00 Next comes the Additive operators, which in this case are + and -.
10:04 Then there is the Comparison and Type Testing, so things like >, <, >=, <=, the
10:11 is, the as operators.
10:13 Then the Equality tests come, so == and !=.
10:17 That's followed by a Conditional AND, which is followed by Conditional OR.
10:21 Then the Ternary operator comes.
10:23 And then finally, the last operator to execute is the Assignment operator.
10:27 Keep these rules in mind, because this is the source of a lot of bugs in programs
10:32 of beginning developers.
10:34 And once you realize that the operators execute in an order of precedence, this
10:38 will save you a lot of headaches down the road.
Collapse this transcript
Using constants and enumerations
00:00 In this example, we are going to look at using constants and enumerations.
00:04 Constants and enumerations are basically C# programming constructs that make
00:09 your code easier to understand and easier to maintain.
00:13 So let's take a look at what we mean by that.
00:16 Suppose we had some code that looked like this.
00:19 So we have some if statement and we've got some variable, and we are comparing it
00:23 to the constant number 32.
00:26 And if that condition evaluates to true then some code is going to run.
00:30 The problem is this is a bad practice. First of all, what does 32 even mean?
00:33 I mean if I am a programmer, I am writing the code,
00:35 I might know what it means, but two years from now, I might not know what it means.
00:39 Somebody goes to look at my code, but has no idea what that means.
00:42 Worse yet, what if it changes in the future?
00:44 If I am using this 32 value all over my program, I am going to have to change it
00:48 if for some reason in the future that 32 is no longer applicable and the test
00:53 needs to test for some other number.
00:55 Well, the way that we fix this problem is by using constants and enumerations.
01:00 So we can write the same thing by writing if (someVar == FREEZING), then the code runs.
01:07 That's much better.
01:08 It's clear what the code is trying to do.
01:10 It's testing for some freezing value of some liquid.
01:14 And if we ever decide to switch it, we just change the constant definition in one place.
01:19 And the way you define that constant freezing is by using the const structure.
01:24 So here I am saying const and then the int, and then the name of the constant
01:29 that I want to use is equal to some number.
01:33 So constants are used for numbers whose value is not going to change over the
01:38 life of the program.
01:40 So here you can see I have got a definition for const int FREEZING = 32.
01:45 That's the freezing point of water.
01:47 The freezing point of water is very unlikely to change in the future,
01:50 so therefore, I define a constant for it.
01:53 So if I want to change this constant to something else in the future, or change
01:57 it to some other definition, I just do it in one place and the rest of my code
02:01 just picks up the change,
02:03 and people reading my code in the future know what that means.
02:06 Enumerations are a close cousin to constants.
02:09 And what you'll probably find in many situations is that you'll use a whole
02:14 bunch of constants that are related to each other.
02:16 For example, if we had a constant for the freezing point of water, we might have
02:20 a whole bunch of other constants that go along with it.
02:22 There might be one for LUKEWARM and for HOT and for BOILING.
02:25 Well, it seems kind of silly to have all these separate constants defined for
02:30 different values that are really all related.
02:32 So the way you solve that problem is using what's called an enumeration.
02:37 In this case, we can build what's called an enumeration for temperatures, and
02:41 we just simply group them altogether.
02:43 So, for example, we would group the value of FREEZING and LUKEWARM and HOT and
02:48 BOILING all into one enumeration.
02:51 This way if we wanted to add a new one in the future--like say we want to add
02:54 one for ROOMTEMP--all we would do is make room for it in the enumeration, add
02:59 the value for it, and then we are done.
03:01 So now we have a whole bunch of temperatures that are grouped together logically,
03:05 instead of having a whole bunch of different const int definitions.
03:08 Enumerations start off at 0 by default if there is no value assignment.
03:13 So for example, if we have our temperatures enumeration and we put something at
03:17 the front of it, like, say, REALLYCOLD, that's going to default to the value of
03:21 0, unless you explicitly assign a value to it.
03:24 So to build an enumeration, you simply have the values that you want to assign
03:28 to words which are easy to read.
03:30 And if you don't assign it, then it defaults to 0.
03:34 If you also don't make a definition after one that's already been defined, then
03:38 that defaults to one more than whatever the previous definition was.
03:42 So for example, if we were to put another definition in here right after
03:46 FREEZING which would be, say, JUSTBARELYABOVEFREEZING and we didn't put an
03:50 equal sign, then it would default to the value of 33 in this case.
03:54 Now enumerations by default are integer types, but you can specify other
04:00 types if you want to.
04:01 Now we'll learn a little bit more about types in the next section, but just bear
04:05 with me here for a second.
04:06 So if we have temperatures and we have all of these values assigned to our
04:11 temperature enumeration, those default to integers.
04:14 But if I wanted to, say, assign them to the value of a byte in order to save space
04:18 in my program for some reason, then I could put a colon there and the name of
04:22 the type that I want the temperature enumeration to be.
04:25 So for example, in this case, if I know the value is never going to go above
04:27 255, which is the maximum value that one byte can hold, I can just define this to be a byte.
04:34 To define enumerations, you can use types that are numeric in nature, such as
04:38 byte and shorts and ints and longs.
04:41 And again, we'll learn what these are a little bit later in the course.
04:44 But I just wanted to point this out here, that you can define enumerations
04:48 that are not integers by using a colon and then the type that you want the enumeration to be.
04:53 So let's go ahead and jump over to the code and see some constants and
04:56 enumerations in action.
04:57 Here I have got my ConstAndEnums project open in my editor, and I've got
05:03 my Snippets.txt file.
05:05 And I've scrolled down to the Constants and Enumerations section.
05:08 So let's go ahead and copy some code over and see how things work.
05:11 So I am going to start with these lines right here, copy those, and put them in
05:17 my program, right here in Main.
05:20 So I have now defined constants for the freezing point of water and the
05:24 boiling point of water.
05:25 You can see I am getting a little warning that says, hey, you've defined this
05:28 constant, but you've never used it, so let's go ahead and fix that.
05:31 I am going to save, go back over to my Snippets, and I am going to copy
05:36 this code right here.
05:37 So now I have copied in some code that's going to use those constants.
05:47 So here, let's go down a little bit.
05:49 I've got an integer variable named myTemp, and I am setting it to be 65.
05:53 And then I have an if else condition for if myTemp is greater than freezing
05:58 point and it's less than the boiling point, then we write out, hey, at this
06:02 temperature, water was liquid;
06:04 otherwise we write out, hey, water is not liquid at this temperature.
06:07 So let's save and let's run it,
06:11 and we can see that at 65 degrees, water is a liquid.
06:14 And if we change this to, say, 30 and run it, then we say, aah!
06:20 At this temperature, water is not a liquid.
06:24 So let's do the same thing now, only using an enumeration, because you can see
06:27 here, I've got two different constants for freezing and boiling.
06:30 Let's go back to my Snippets.
06:31 What I am going to do is up here I have an enumeration for my temperature,
06:36 so I am going to copy that back over to my program.
06:42 Now I am going to put this definition outside the Main function.
06:45 I am going to put it in my class definition up here.
06:48 Paste that in, so now I have an enumeration for my temperatures. So you can see
06:51 here that the syntax highlighting is showing me that everything looks right.
06:55 So I have enumeration for FREEZING, LUKEWARM, ROOMTEMP, HOT, and BOILING.
06:59 Go back to my snippets. And now I am going to use these two lines down here instead.
07:07 Copy. And we'll go back to Main. And what we'll do is we'll get rid of these
07:14 guys, and we'll paste these in.
07:17 So now you can see I am using temperatures enumeration instead of the constants
07:21 that I've got defined here.
07:22 And in fact, since I am not using them anymore, let's just get rid of them.
07:25 The nice thing about enumerations is that, because they are part of your program
07:29 and the C# interpreter can look at them and see what they are,
07:32 when you type, it will actually help you type the value out.
07:36 So for example, suppose this piece of code wasn't there.
07:41 I can start writing the word Temperatures,
07:43 and you can see that the Temperatures IntelliSense is showing up right there.
07:46 So I am going to double-click that and it's going to get inserted.
07:48 Then when I hit the period, you can see that it's introspecting the
07:52 enumeration for me.
07:53 So I can scroll down to the one that I want, and that's FREEZING.
07:58 So I am going to have to just do this. Bear with me for a second while I do this,
08:03 because we'll learn about conversion in the future, but I have to tell the
08:07 interpreter that the Temperatures enumeration is an integer.
08:11 And now I can say okay, if the temperature is greater than FREEZING and is less
08:16 than BOILING, then we are doing the same thing.
08:18 At this temperature, water is a liquid or it's not.
08:21 So let's change this to 65 and run it,
08:24 and you can see that water is a liquid at 65.
08:28 The nice thing about this is that the code here is much easier to read than
08:31 having some numerical value that you don't know what it is.
08:35 And in the future, if I ever wanted to, I could change these numbers up here,
08:39 and I would not have to change them all over my program wherever they are being used.
08:43 Just make the change in one place.
08:45 So that's the argument for using constants and enumerations to make your code a
08:49 lot easier to read and a lot easier to maintain.
Collapse this transcript
Using loops
00:00 Along with some pretty basic stuff, like constants and enumerations and
00:05 conditional statements and operators and expressions, loops are one of the most
00:09 basic building blocks of any kind of programming language.
00:13 Loops are essentially blocks of code that execute over and over again.
00:18 And there are two different basic kinds of loops:
00:22 there are loops that execute while a condition is met and there are loops that
00:26 execute a set number of times.
00:29 So for example, you might have a loop that's running some piece of code for as
00:33 long as a certain condition is true, like the user has not logged out, or the end
00:38 of a file has not yet been reached, or something like that.
00:41 You might also have a loop that runs a set number of times: the number of people
00:45 attending a concert or something like that.
00:48 The way that you write loops is by using a couple of different constructs.
00:52 For loops that execute while a condition is met, you have a while loop,
00:57 and the while loop is written as you see it there.
00:59 It can have the keyword while.
01:01 And then inside some parentheses, you have a condition that is true.
01:05 And then inside the curly braces, you've got some code that's going to execute
01:09 as long as that condition is true.
01:10 There's also a close cousin of the while loop, which is the do-while loop.
01:15 And in this case, the while goes at the bottom of the loop instead of the top.
01:20 And the main difference here is that the while loop is only going to execute
01:25 when that condition is met.
01:27 If that condition test is not met, nothing inside the while loop is going to
01:31 run and that condition is evaluated before the while loop ever even gets a chance to run.
01:36 The do-while loop is a little bit different.
01:38 The code that is inside that loop is going to execute at least one time.
01:43 And that's because it executes once-- then the while is executed at the end of
01:48 the loop to see if things should keep going.
01:51 So in the case where you want to have a loop that runs only while a condition is
01:55 met and no other times, use the while loop.
01:57 If you have a condition where you want to execute some code just one time and
02:02 then check to see if you should keep going, that's the do-while loop.
02:05 For the set number of times case, there is the for loop.
02:10 And the for loop executes a given number of times and it runs the code that's
02:15 inside the curly braces.
02:16 A close relative of the for loop is the for-each loop,
02:21 but we're not going to cover that one in this particular movie because it has to
02:25 do with something called enumeration.
02:27 And we'll look at it a little bit later in the course.
02:30 For now we're going to concentrate on the while, do-while, and for loops.
02:35 Let's take a look at the code to see how this works.
02:38 I've got my example here opened.
02:41 This is my Loops project.
02:43 And over in my Snippets, I've got my code, and I'm scrolled down to the Loops section.
02:49 So let's take a look at how the basic while loop works.
02:52 So I am going to copy these lines of code here.
02:54 I am going to copy that, and I'm going to paste into my Main.
03:01 So I've got here an integer variable named myVal, and we have a basic while loop.
03:07 We're first going to write out a string of text that says Basic while() loop.
03:11 And then you see here, here's the while definition:
03:14 so while (myVal < 20). We're going to write myVal is currently and we're going
03:21 to use the console's WriteLine method with some string formatting here to write
03:25 out what the current value of myVal is.
03:28 As always with loops, you want to make sure that the loop has some way to exit;
03:32 otherwise, you'll end up with what's known as an infinite loop.
03:36 An infinite loop is a loop of code that just keeps going and going and going and
03:39 going and never has any way to get out of it.
03:42 So you want to make sure that you've got some code inside your loop, such that at some point
03:47 this condition up here is going to become false, and therefore your loop can
03:50 terminate, and your program can continue on its merry way.
03:54 So what we're doing here is, at the bottom of this loop, we're taking myVal and
03:59 we're adding 3 to it each time.
04:01 And recall that the += notation there means myVal = myVal + 3.
04:07 So when myVal becomes greater than 20, that condition will no longer be true if
04:11 they're in the while loop, and the loop should stop.
04:13 So let's save this, and we're going to go ahead and run it.
04:17 And you can see that the string gets written out, Basic while() loop, and myVal is
04:23 15, and then we add 3, so myVal is currently 18.
04:27 And then we add 3 and myVal becomes 21.
04:30 So when the code executes and goes back to the top of the loop, that test is no
04:35 longer true, and the loop stops.
04:38 So right here. So the code executes in this line, from top to bottom. The last
04:43 statement is the myVal += 3 right here.
04:46 When that executes, it gets to this curly brace,
04:49 it will go back up to the top of the loop, and then this condition gets tested, and it fails the test.
04:54 And that's what terminates the loop. Okay.
04:56 Let's take a look at another example.
04:59 In this case, we're going to look at the do-while loop. And I am going to copy
05:05 these lines of code right here.
05:07 Okay, let's get rid of this one. And paste.
05:19 In this case, we have a do-while loop, and remember that in the case of
05:22 the do-while loop, the code inside the braces gets executed once before
05:26 this condition gets met.
05:28 So in this case we have pretty much the same code.
05:30 We're writing out the Console.WriteLine value there.
05:33 We're adding 3 each time.
05:34 But let's see what happens.
05:36 So this time we're going to save, and we're going to run it.
05:40 You can see here that the do-while() loop, myVal is currently 15, myVal is
05:44 currently 18, and then we add 3 and then myVal is 21, and the condition no longer
05:50 is true and therefore the loop executes right here.
05:53 So right here when we add the myVal += 3. This is no longer running.
05:57 But let's watch what happens when I set this up at 20 to begin with.
06:02 I am going to save it.
06:03 I am going to run it.
06:05 And you see even though myVal is not less than 20,
06:08 it still goes through the loop at least one time.
06:12 So that code is going to get executed once before the while condition has a
06:15 chance to be evaluated.
06:17 So even though the condition is false, the code got executed one time.
06:22 So that's the do-while loop.
06:23 Let's take a look at our friend, the for loop.
06:25 Here's the code for the for loop right here.
06:31 I am going to copy that, and we're going to paste it.
06:37 A for loop is set up using three compact statements within the for statement itself.
06:43 So here's the for right here.
06:46 And then the first statement is the initialization of the counter variable.
06:51 In fact, I could expand that out and do something like this, where I say int i,
06:57 and then I wouldn't need to do this here.
06:59 I would simply say for (i = 0).
07:01 What I was doing there was just concatenating one with the other.
07:05 So this is the initialization, or setup, of the counter variable.
07:08 Then we have the test to see if i is less than myVal.
07:12 This is the condition that gets evaluated each time.
07:15 And then this is the statement that gets evaluated when the loop is complete. So this is setup,
07:20 this is the condition, and then this is what happens each time through the loop.
07:24 So i is going to start out at 0.
07:26 We're going to test to see if it's less than myVal, which is 20 right here, and
07:30 we're going to add 5 each time.
07:32 And each time through the loop we're going to write out i is currently
07:35 whatever its value is.
07:36 So I am going to save and we run it.
07:38 And you can see that i starts out at 0, then it's 5, then it's 10, then it's 15,
07:44 and then it gets to be 20, and that condition no longer needs to be true.
07:49 So 20 is not less than 20.
07:52 If we change this to be less than or equal to, then 20 will actually match the condition.
07:57 So if we run it again, you'll see that in this case i is less than or equal to
08:02 myVal, because 20 matches the less than or equal to part of the condition.
08:08 So that's the for loop, and that's how you get a loop to execute a certain number of times.
08:13 Let's take a look at some other keywords we can use with loops.
08:15 There are two special keywords that can be used with loops.
08:18 There's the break keyword, which breaks out of the loop at the current point,
08:23 regardless of whether the test condition has been met or not.
08:27 And there's the continue keyword, which basically says, hey, skip the rest of the
08:32 code in the loop and then just jump back to the top of the loop code as if you
08:37 had it completed one of the loops.
08:39 So let's take a look at how these work.
08:41 So I am going to erase the code from my previous example, and we're going to
08:45 go back to the Snippets, and I am going to copy over the last part of the
08:49 example right here.
08:50 I am going to copy, and I am going to paste.
08:56 So in this case, we're going to use the continue and break keywords.
09:00 So here I have a for loop that's starting off at 0, and it's going to run until i
09:06 is less than 10, and we're going to increment i by 1 each time.
09:10 We're using the postfix increment operator here.
09:13 Now, there are two special conditions in here.
09:16 When i is equal to 5, I am going to use the continue keyword.
09:21 continue basically says, hey, skip everything from here on down, go down to the
09:25 last brace, and then go back to the top again and execute whatever the third
09:29 statement over here is--
09:31 this part of the increment loop right here.
09:33 And then in the case where i is equal to 9, I am going to use the break keyword,
09:38 which basically means, hey, you know what?
09:40 Just stop the loop.
09:41 It doesn't really matter where we are.
09:43 It doesn't matter what the condition test up here. Just stop.
09:46 So let's save and we will run it.
09:49 Let's take a look at the output.
09:50 So you can see that i starts off at 0, Then it goes to 1, then 2, then 3, then 4.
09:56 But remember, for the 5 case, we use the continue keyword.
10:01 So we skipped over the line of code that said Console.WriteLine, so that line of
10:05 code never got executed.
10:07 The loop just continued as if it had run, but it skipped passed all the logic
10:11 that put where the continue keyword was.
10:14 And then we continue incrementing, so i is now 6, then 7, and then 8.
10:19 And then remember, when we got to the 9 case, we used the break keyword, which
10:24 stops the loop in its tracks, as if the condition had failed.
10:28 So let's go back to the code, and let's take this statement out.
10:32 I am going to comment this out and run it again.
10:37 And you can see, in this case, the loop does make it to 9, and then the value of i
10:41 becomes 10, which is where it triggers the condition, and the condition is no
10:45 longer met and the loop stops.
10:47 So if we go back to the code and we uncomment this, put the code back in, if I
10:52 change this to say 7 and save and then run, you'll see that in this case, the
10:57 loop only makes it as far as 6 because as soon as i gets to be 7, we're calling
11:02 the break command, which stops the loop.
11:05 Loops are a very powerful part of programming, and you can see that C# loops are
11:10 pretty versatile and pretty powerful in their own right.
Collapse this transcript
Using functions and methods
00:00 The last major piece of program flow that we're going to take a look at in this
00:03 section are functions.
00:05 Functions are a nice mechanism for breaking up large sections of code into
00:12 smaller pieces that are reusable, and make your programs easier to understand and
00:17 maintain. And one of the things you'll find when you're doing your C#
00:21 development, or development in any language, really, you'll find that any
00:24 nontrivial program that consists of many lines of code starts to get really
00:29 unwieldy and is really hard to change and maintain, and functions really make
00:33 that process a lot easier.
00:35 Now the reason why I included the word "methods" is because C# is an
00:40 object-oriented language and in object-oriented parlance, functions are
00:44 typically called methods, because in C# a function has to be part of an object.
00:50 There are no global functions, which I covered a little bit earlier.
00:53 So the word function and method are pretty much interchangeable in this context.
00:59 So anywhere you see me use the word functions, you can just mentally hear me
01:03 using the word methods, and/or vice versa.
01:06 To define a function, it's a pretty straightforward process.
01:11 We start off by giving it a name.
01:14 So to create a function, the function has to have a name, and you can use
01:17 whatever uppercase, lowercase rules you want to use. In this case, I am starting
01:20 off with a lowercase letter and I am using what's called CamelCase, and I am
01:24 capitalizing the interior words of the function.
01:28 But that's up to you.
01:29 You can use letters.
01:30 You can't use special symbols, like dollar signs or parentheses or anything like that;
01:34 it's got to be alphanumeric.
01:35 So here I have a function and I have given it a name.
01:38 Then I have to give it what's called a parameter list.
01:41 There are two parentheses and inside those parentheses, these are the arguments
01:47 that the function takes.
01:49 This is the data that the function is going to operate on. And inside the
01:53 function, I have the code of the function.
01:56 This is the stuff that the function does.
01:59 In this case, the function is simply calling Console.WriteLine.
02:03 In the parameter list, where the arguments go, I can supply one or more arguments,
02:09 or parameters, to the function.
02:11 So for example, if I want to pass in an integer, I would pass in int x. In
02:16 some other languages, like JavaScript, you don't have to declare the type in
02:20 front of the argument.
02:21 You simply give the argument a name, and you pass it into the function, and C# doesn't work like that.
02:27 In C# you have to tell the function, here's the kind of argument that's going to be coming in.
02:32 In this case, it's an integer.
02:34 If I wanted to pass in more than one, I would use a comma to separate them.
02:38 And in this case I am passing in an integer named X and a date argument named D.
02:44 Now in addition to the name of the function and the arguments, I have to say
02:49 what the return type of the function is. What kind of value does the function pass back?
02:55 I can say, for example, that the function passes back an integer.
02:58 Now, notice I don't name what the function is passing back.
03:01 I am just simply saying here that the function returns an integer. And it
03:04 can return an integer; it can return a string;
03:07 it can return any other kind of data type. And we'll learn a little bit more
03:10 about data types later on in the course.
03:11 But for now, just follow along with me here. I am saying that this function
03:15 returns an integer, and it takes an integer and a date as an argument.
03:20 If I didn't want to pass in any argument, I can simply leave the area inside the
03:24 parentheses blank and not pass in any arguments at all. But in this case, I've
03:29 got a couple of arguments.
03:30 And then finally, there is the code inside the curly braces for the function, and
03:34 that's what the function actually does.
03:36 In cases where functions return a value--in this case, this function is
03:40 returning an integer--
03:41 I have to make sure that the function actually does that, and I do that by using
03:44 the return statement.
03:46 In this case, I am returning a variable named someValue, which is probably
03:52 defined somewhere in this function as an integer.
03:55 The value that I am returning has to match the type of the return value for the function.
04:01 So if I declare this someValue variable in my function somewhere, it would have
04:05 to be an integer just like the return type of the function.
04:08 Functions don't have to return values.
04:10 I could just simply say void, in which case I've defined a function that takes a
04:14 couple of arguments but doesn't return anything. And in that case I don't need a
04:19 return statement at all.
04:20 I can just simply get rid of that, because there is no return value for the function.
04:25 I can also just simply use the word return with a semicolon by itself, but in
04:29 this case I've just got rid of it because it doesn't return anything.
04:32 So let's actually jump over to the code and see how to write a function that
04:36 does what we have described here.
04:38 So in my FuncsAndMethods project I've also got my Snippets file open, and I have
04:44 scrolled down to the Functions and Methods part.
04:46 So let's go ahead and copy some of this code and paste it in.
04:49 I am going to copy these three lines.
04:52 I will paste that, and let's take a look at what I've pasted in.
04:58 I have got an integer variable named result1, and then I am assigning
05:02 result1 the result of a formula function. And you can see here there are some
05:08 red squiggles there.
05:09 It says, "The name 'formula' does not exist in the current context."
05:12 That's a function that apparently takes an integer argument which I have not defined yet.
05:18 So let me go get the code for the formula function, and that's it right here.
05:24 I am going to copy that, and I am going to paste it.
05:30 So now, I have defined a function named formula which takes an integer argument
05:35 and returns an integer.
05:36 For the moment, you've probably noticed this word static right here. Just bear
05:40 with me about why we need that.
05:42 I am not going to cover it right now.
05:43 We'll get to that when we get to the section on object-oriented programming
05:46 a little bit later. It's just something we need right now for the function to work.
05:50 So don't worry about that right now. Let's pretend it's not there.
05:53 What's important is the return type right here of int, and the argument it takes
05:57 is an int, and this is the name of the function right here.
06:01 In some languages, for example C or Objective-C, the order in which you define
06:06 your functions is somewhat important.
06:08 So for example, if this were C and I put the definition of this function down
06:13 below where I am calling it up here,
06:15 I would have to have some type of code statement up here that says, "Hey!
06:20 program, there is going to be this function called formula that you're going to come across.
06:23 Don't worry about it."
06:24 I am just telling you about it now.
06:26 In C# you don't need to do that.
06:28 In C# you can just declare this function wherever you like and you can call it
06:31 from over here, and the C# interpreter is smart enough to realize oh, okay,
06:35 well, there must be a function named formula coming down, so I will just wait till I see it.
06:39 So here's what we're going to do.
06:40 We're going to call the formula function with an argument--in this case, it's
06:44 14. The function is going to do its work.
06:46 It's going to return an integer value and that value is going to be set into
06:50 result1, and then this statement right here Console.WriteLine is going to write
06:55 out whatever the result is.
06:56 So let's go ahead and save that, and let's run it. And you can see that the
07:02 result being written out is 24.
07:05 So the result of the formula inside the function evaluated to be 24.
07:10 So I'll say, okay. Let's go back up here.
07:12 Let's change this to something else.
07:13 I am going to type a new variable, and I am going to call it arg1. And I am going
07:22 to give it a value of 25. And now instead of passing in the hard-coded value of
07:32 14, I am going to copy arg1 and I am going to paste it in the calling place
07:38 where I am calling formula.
07:39 I am going to save it, I am going to run it, and you can see that now we've
07:43 produced a different result.
07:45 So that pretty much brings us to the close of this section.
07:48 In this section we've seen how program flow works.
07:50 We've covered things like functions, and we've seen constants and enumerations.
07:53 We learned how to write conditional statements, and we have learned about
07:56 operators and expressions.
07:58 We've got to the point now where we continue on and learn more about C# and
08:01 learn how to do things like declare variables and use objects and so on.
08:05 But this chapter should have given you a good foundation for a lot of the
08:08 basic parts of C# that you're going to come across in any program that you
08:12 decide to write, or work on.
Collapse this transcript
4. Variables
Understanding data types
00:00 Earlier in one of the course, I mentioned that C# was a strongly typed
00:04 language, meaning that you can't just simply declare variables and not tell the
00:10 system what the types are.
00:11 You'll find that as you build your C# programs, this actually becomes quite an
00:15 advantage, rather than the encumbrance that it sounds like.
00:19 Program store and keep track of all kinds of data.
00:23 They keep track of numbers and prices and names and email addresses and dates,
00:28 and these pieces of data are stored in memory locations called variables, and
00:32 each piece of data can have a type, which is used to declare a variable.
00:39 In some languages, such as JavaScript, you can declare variables and you can
00:44 change their types around.
00:45 You can do all kinds of great stuff. And you can't do that with C#.
00:50 So for example, in JavaScript you can just do this.
00:52 You can say myData = true; that's okay in JavaScript.
00:56 You can't do that and C#; you have to actually declare the variable.
01:00 In JavaScript if you just use a variable about declaring it, JavaScript
01:03 assumes it's a global variable. Well, C# doesn't have a global variables, so this wouldn't work.
01:08 You have to actually declare it, so you declare it.
01:11 In JavaScript you can do things like var myData = 123456.
01:13 And in fact, you can do this in to C# too.
01:18 C# does support the var keyword, but it's a little bit advanced for C#, and we're
01:23 not going to cover it in this course.
01:25 However, in JavaScript you can do things like this: once you declare the
01:28 variable and you've assigned it a number, later on in life you can say, hey, you
01:32 know what, myData is a text string now.
01:34 Again, that's okay in JavaScript, but you can't do that in C#.
01:38 Your variable can't change type once you've declared it and once
01:42 you've initialized it.
01:44 So that's an example of things that work in some other languages
01:47 that don't work in C#.
01:49 So how do you declare and name a variable in C#?
01:52 Well, let's take a look at that.
01:53 To declare variable, you simply indicate a type and then you give it a name, and
01:59 optionally you can give the variable an initial value.
02:03 So all of these are valid ways of declaring, and in some cases initializing, C# variables.
02:10 C# variable names can start with a letter or an underscore. And after that, you
02:16 can have letters, numbers, and underscores up to 255 characters.
02:22 Now you can't start a variable name with a number.
02:25 It has to be a letter or underscore, and the letter can be upper- or lowercase.
02:28 Remember that C# is case sensitive.
02:31 So, uppercase and lowercase variable names are different, so you have to keep that in mind.
02:36 This will sometimes lead to bugs for newer C# developers who've come from
02:40 languages where things are not case sensitive.
02:43 They're case insensitive.
02:44 That's not the case here with C#.
02:45 You do have to remember that.
02:46 C# has a number of primitive data types that are built into the language, and the
02:53 reason they're called primitive data types is because they are the basic
02:57 building blocks that you use to build other data types.
03:00 For example--and you've probably seen me using some of these throughout the
03:04 course so far, as we built some of our examples--
03:06 there is the int data type, which is an integer.
03:09 That's 4 bytes. And it holds numbers from about -2.1 billion up to about +2.1 billion.
03:18 There are date data types. The date is 8 bytes, and it represents January 1st
03:24 from the year one, up through midnight on December 31st of the year 9999, which
03:30 is a very long time.
03:31 There's also a char data type, which is a single character, and that's 2 bytes,
03:35 because it's Unicode.
03:36 Unlike other languages where character is 1 byte, in C#, it's 2 bytes.
03:40 There are strings. Strings can hold from about 0 to 2 billion characters.
03:45 That's a very, very long string.
03:47 There is also an object type. And in this case the object is actually defined by
03:52 your program, although C# and .NET does provide a base object definition for
03:58 you. And it takes up as much memory as its structure and as memory allows.
04:03 So you can have all kinds of data fields inside your objects.
04:06 And then rounding out the primitive data types are a whole bunch of other types
04:10 like Boolean and bytes and decimals and doubles, and all kinds of other numeric
04:16 data types and Boolean other non numeric data types.
04:19 There is also a special kind of data type in C# called a nullable type.
04:24 A nullable type can represent the full range of values of the normal underlying
04:29 data type, along with the additional value of null.
04:35 And normally when you declare a variable, like an integer, it has to be a number;
04:38 you can't set that variable to null like you can in JavaScript.
04:42 In C#, if you want to be able to do that, you have to declare what's called a nullable type.
04:47 This is a little bit advanced, and we won't see very much of it in the course,
04:50 but I wanted to point it out to you, because you will occasionally run cross
04:53 it in your C# travels, so I wanted make sure that you know what it is.
04:57 So, a nullable type, like I can said, it can be null along with whatever its
05:01 normal data type is.
05:02 So for example, if we declared a Boolean variable with the name of B, that can
05:07 be either true or false.
05:09 If you try to do this, however, set it to null, that's an error.
05:12 You can't set B to null.
05:13 If you want to do that, you'll have to declare the Boolean variable as a
05:18 nullable type, and the way you do that is you declare as a bool with a question mark
05:22 at the end.
05:23 And that tells the compiler, hey, this is a variable that can be either true or false or null.
05:29 You can do the same thing with integers.
05:31 If I put question mark on the end of the integer,
05:33 it can be an integer value or it can be null.
05:37 Using these kinds of primitive data types, you can build all kinds of C#
05:42 variables and higher-order objects which we will see a little bit later in the course.
05:46 For now though, now that we've seen primitive data types, there is one other
05:49 thing we just need to look at and understand, and that is how C# deals with
05:52 the notion of objects.
Collapse this transcript
(Almost) everything is an object
00:00 One of the things that I said earlier on in one of the course is that almost
00:02 everything is an object in .NET and in C#. And the way that that works is that
00:08 at the base level of the .NET library is a base type called System.Object.
00:14 All of the other types that we talked about so far, such as ints and doubles and
00:18 characters and bytes and so on, all of these are primitive types, but C#
00:22 actually derives all of these base primitive types from System.Object.
00:28 What's interesting about this is that even though the int data type is built
00:32 into .NET and C#, int actually maps to a System.Int32. int is just a shorthand
00:40 way of saying, use the class System.Int32. The same thing goes for char.
00:45 A char data type is actually a System.Char object.
00:49 Same thing with strings; strings are System.String objects.
00:52 These all derive from System.Object, and the same is true for all the other
00:56 objects that you see listed here, and all the primitive data types.
00:58 Date, bytes, doubles, all of those are actually objects.
01:02 They derive from System.Object.
01:04 So why is this important?
01:05 Well, it lets you do some pretty neat things.
01:07 If I were to declare a variable int i = 0,
01:11 I could do the same thing by saying int i = new int.
01:15 Other languages don't let you do this because they don't understand it, but in
01:18 C# and .NET, because pretty much everything is an object, you can do this.
01:22 These are functionally equivalent to each other. Declaring the variable as an
01:26 integer, initializing it to 0, and saying new is pretty much the same thing.
01:32 It also means that the built-in objects have some pretty cool features.
01:36 So for example, this integer is really an object, and it has functions that
01:40 I can call on it. So I can do things like i.GetType, and that will return System.In32.
01:46 That's the kind of object that it is.
01:48 I could say, i.ToString, and that would return a string.
01:51 Now remember, I'm doing all this on a basic integer.
01:53 I can do things like i.Equals, and give it an argument, and that returns whether
01:58 two objects are equal.
01:59 So once you get around the idea that everything pretty much in .NET and C# is an object,
02:05 it gives you a certain amount of freedom in your programs and some really great
02:09 functionality that other languages don't provide.
02:11 Let's take a look at an example.
02:13 Let's return to our old friend, the is operator.
02:16 Now I briefly talked about the is operator earlier on in the course, but now
02:20 let's take a look at how you might use it.
02:21 Suppose I had a function that took an object as an argument. And again, remember
02:27 here that that word "object" is really an alias.
02:30 It is a shorthand way of saying System.Object.
02:33 So here I have a function that's taking an object as an argument and it returns
02:37 an integer data type.
02:39 Inside this function I would be able to do things like say, hey, if the obj
02:43 argument that I'm being given is an int, and then I can convert that object to
02:48 an integer and then operate on the argument as if it were an integer. Or I could
02:52 say, hey, if the obj is a string, then convert the object to a string and then
02:57 operate on it as if it were a string.
02:59 This gives me a lot of flexibility in the way that I write my code.
03:02 I can write some C# code that's very flexible,
03:04 takes different kinds of arguments in one large container, and then convert
03:09 between them as I need them.
03:11 So what's so great about this?
03:12 Well, first, the fact that pretty much everything is an object provides a
03:16 unified way of working with all the variable types. You don't have to
03:21 treat primitive types one way and objects another way like you do in other languages.
03:26 Basic variable types in C# have some pretty cool automatic features built in,
03:31 and we'll see more of this as we work with each one of the other data types in depth.
03:35 All the C# types can be converted to and from objects, so they can be passed to
03:40 functions that take objects as parameters, as you saw it earlier.
03:44 So now you can write code that's very flexible.
03:46 You can write functions that take objects and take variables of different types
03:50 and work on them as if they were each with their own types.
03:54 So for example, I can write a function that takes an object or a series of
03:57 objects, pass them all kinds of variables, like strings and integers and doubles
04:01 and floats, find out what kinds they are, and then work on them as I would in
04:05 ordinary variable of that type.
04:07 And will see examples of this as we move through the course.
Collapse this transcript
Working with numbers
00:00 Let's talk a little bit about working with integer numbers in C#.
00:03 Up until now you've been seeing me use the int data type throughout all the
00:07 examples that we've encountered up until now, but there are plenty of other
00:10 ways of working with integer numbers. And the only real difference between the
00:14 various data types for working with integers is the size of the variable
00:19 container, which basically dictates the range of numbers that that variable can hold.
00:23 For example, there is bytes, which are 8 bits in size, and they are unsigned by default.
00:31 They are 0 to 255.
00:34 That's just 8 bits, and 255 is the largest number that you can hold inside of a byte.
00:40 Along with a byte is the sbyte, which means signed byte, that's also 8 bits, and
00:46 it can hold the number from -128 to 127.
00:51 So byte and sbyte are both the same size.
00:53 It's just a question of which one you want to use when you know that the number
00:56 is only going to be positive, or if the number might be signed.
00:59 Similarly, there is a data type called the short. The short is 16 bits, or 2 bytes,
01:04 and that can hold -32,768 up to 32,767.
01:10 Now notice unlike byte, shorts are signed by default.
01:14 So if you want to use an unsigned version of this, you have to use the ushort,
01:18 which stands for unsigned short. It's also 16 bits, and it can hold the
01:22 number from 0 to 65,535.
01:24 The next step off from there is of course the int, which is what you've been
01:29 seeing we use all this time.
01:30 It's 32 bits, and it can hold from -2.1 billion to 2.1 billion. And there is of
01:36 course an unsigned version of it, which is uint, for unsigned integer. It's also
01:40 32 bits, and since it's unsigned, it can hold from 0 up to about 4.3 billion.
01:48 That's a pretty good range of data, but suppose we want to handle numbers that
01:52 are larger than 4.3 billion.
01:54 Well, no, we are not out of luck.
01:55 There are other data types that we can use.
01:58 There is of course the long, which is 64 bits, and it has a range of well really,
02:04 really, really, really big.
02:06 You can see those numbers right there.
02:08 It goes from that -9 up to the 9, whatever that number even is.
02:11 I have no idea what the name of that number is, but it's really, really huge.
02:15 In addition to the long, there is the unsigned version of this, which is the ulong.
02:21 It's also 64 bits, and it can handle from 0 to well, even really, really bigger.
02:27 But of course there's also floating point numbers, not just integers. Usually we
02:31 use floating-point numbers for things like decimals and other kinds of
02:35 fractional numbers. And to do that there is a float number type and when you
02:39 declare a float number, you have to put a lowercase f on the end. And you can
02:43 see here I am declaring a floating point number of 123.45, and it has 7 digits
02:48 of precision from the range that I have shown there.
02:50 There is also a double, which is another type of floating-point number, but it
02:55 has 15 to 16 digits of precision. And you can see that when you declare it you
02:59 have to put a little d on the end to distinguish it from the float. Floats have
03:02 fs; doubles have d. So in this case I've got a double number which has much
03:08 higher precision than the floating-point.
03:10 And then finally there's the decimal number.
03:13 The decimal number is an interesting beast because it actually works in base 10
03:18 and not base 2, like the other kinds of floating-point number types that C# works with.
03:24 And to declare a decimal number, you simply say decimal and then the name of the
03:27 variable. And here I've got 123.45, and you put the little lowercase m on the end
03:33 which indicates that it is a decimal number.
03:35 Decimal numbers have 28 to 29 digits of precision, making them very, very
03:40 highly accurate numbers.
03:42 In addition to these data types, there are some special floating-point values that
03:47 you should be aware of.
03:48 The first of these is NaN, which means Not a Number. If a floating-point
03:53 variable gets into a state where you either try to divide by 0, or some other
03:56 kind of error happens, then the variable is set to NaN which means not a number.
04:02 There is also a PositiveInfinity and a NegativeInfinity setting.
04:06 For example, if you have a variable f defined to be of type float, you can do
04:11 things like say, hey, if f is less than float.PositiveInfinity. You can also
04:16 check to see if float is equal to not a number.
04:19 You can do things like float is PositiveInfinity, or is NegativeInfinity, and
04:24 these are useful for things like sorting algorithms.
04:26 You can also check to see if the float is not a number. Again because these
04:30 floating-point data types, along with all the other primitive data types, derive
04:33 from System.Object they have all these great methods and properties built into the language.
04:39 Okay, let's talk a little about why you'd use floating points, such as floats or
04:44 doubles, versus something like decimal, because one of the things you will find
04:47 is that with floating point numbers-- and I am not going to go too deep into
04:51 this because it's a bit of a advanced subject--but because of the way computers
04:54 work, computers calculate values using base 2 notation rather than base 10 like we humans do,
05:01 and that can lead to a loss of precision for certain kinds of transactions.
05:06 So let's take a look at a piece of code that explains how that happens.
05:10 So I have got my DoubleVsDecimal project open here, and here's the program file,
05:16 and I've got my snippets open as well.
05:18 So what I am going to do is copy these lines of code over to my main function.
05:25 So what we are going to do in this example is compare how double precision works
05:30 with decimal precision. And like I said earlier, internally, computers represent
05:35 numbers having to do with base 2 notation.
05:39 This is the famed 0s and 1s you've probably heard about if you've ever worked
05:43 with software before.
05:44 But what it essentially means is that because of the way numbers are calculated
05:47 on a microprocessor, you can sometimes lose precision when working with certain
05:51 data types. And I am going to show you a difference of how decimals are handled
05:56 versus how doubles are handled.
05:58 So right here at the top of my function I have got two variables, twentieth and
06:02 one. And you can see that I defined twentieth and one to be types double and
06:07 so I have got 0.2f and 1.0f. And what I am going to do is write out what one - twentieth is.
06:16 So 1.0 - 0.2, you would expect that to be equal to 0.8, right?
06:21 So let's see how the double data type and decimal data type compare when doing the
06:26 same kind of option, because down here, I have got two variables, decimals, which
06:30 are one twentieth and the real one.
06:33 So now I have got the same kind of calculation.
06:35 I have got 1.0, subtracting tracking off 0.2 each time.
06:38 The only thing that's different is in one case they are doubles; in one
06:41 case they are decimals.
06:43 So let's save this, and let's run it. And you can see that in the first case the
06:48 1.0 - 0.2 when using a double results in 0.799999...whatever, a whole bunch of,
06:56 like, you know high-precision numbers here. But obviously there is a loss of
07:01 precision when using a double number, whereas in the case of the decimal the 1.0
07:07 - 0.2 did fact result in 0.8, as you would expect.
07:13 And again, that's because the decimal data type works with base 10 numbers
07:17 naturally, whereas doubles work with base 2 numbers.
07:20 Now you might be saying to yourself, oh my God!
07:22 Is this some kind of a bug in .NET?
07:23 Is this a huge shortcoming of C#? It's not.
07:26 You will find this in lots of different computer languages that work with
07:29 floating-point numbers. Whether it's C or Objective-C or Java, it doesn't really matter.
07:33 This is just one of the ways that computers keep track of numbers internally.
07:37 So let's go back and take a look at the chart of when you want to use double
07:39 versus when you want to use decimal.
07:41 Let's take a look at why double and decimal are different from each other.
07:44 First, in the nature of precision, doubles are 15 to 16 figures of precision,
07:49 where decimals are 28 to 29 figures, so you've got double the amount of
07:52 precision in a decimal number as you do a double.
07:55 In internal format, in other words how the microprocessor on the computer
07:58 works with the number, in doubles it's base 2; in decimals it's base 10.
08:04 So, so far it's looking like you might never want to use a double, right?
08:07 After all you've got higher precision using base 10.
08:10 Speed, however, is a important factor to consider.
08:13 Because doubles are native to the CPU-- in other words they are native in the
08:17 fact that they use base 2 notation--the speed when using doubles is very, very, very fast.
08:22 Decimals, on the other hand, because they work in base 10 and have to be
08:26 conferred to and from the native processor format, can be up to 10 times slower
08:30 than using doubles.
08:32 So what are they good for?
08:33 Well, scientific calculations can usually be executed quite accurately and quite
08:37 fast using doubles, so they're good for scientific calculations, whereas decimal
08:42 numbers are good for financial calculations.
08:45 When you're dealing with hundreds of millions or billions of dollars, or even
08:48 small amounts but many, many, many times, these differences in precision and
08:52 accuracy on the CPU can add up to real money.
08:56 So because decimals work in base 10 and are very highly accurate when
08:59 working with floating-point numbers, they are ideal for being used in
09:03 financial calculations.
09:05 You can use doubles and other floating-point numbers for
09:07 scientific calculations.
Collapse this transcript
Working with characters and strings
00:00 C# also has built-in data types for working with characters and strings.
00:05 They're the char and string data types, not surprisingly.
00:08 The character data type, or char, in C# represents a single Unicode character, and
00:13 that's 16 bits or 2 bytes.
00:15 So the way we declare is char
00:18 and then the name that you want to give the variable, and you can initialize if you want to.
00:23 And it's important in C# to recognize that, unlike languages like JavaScript,
00:26 when you declare characters you have to use a single quotes, and for strings
00:31 you use double quotes. And in JavaScript you can use either single or double
00:35 quotes for the characters or full strings,
00:36 it doesn't matter; in C# it does matter.
00:39 So, for the character data type use single quotes; for strings use double quotes.
00:42 If you're not familiar with Unicode, don't worry too much about it.
00:45 It's basically an international standard for representing a wide variety of
00:49 characters from a wide variety of languages, and it supersedes the old ASCII
00:53 data set that were used in computers up until just recently.
00:57 So here we have an example of a character being declared, and this is a
00:59 lowercase letter a. And as I mentioned it's 16 bits, or 2 bytes, but you are not
01:04 limited to lowercase letters.
01:05 You can use things like numbers.
01:07 You can even use punctuation. All of these are legitimate characters.
01:11 For strings, you use the string data type, and a string is a series of
01:17 Unicode characters.
01:18 And unlike other languages, like, say, C or languages based on it, like
01:22 Objective-C, C# provides a native built-in data type for working with strings
01:28 and it's just called the string.
01:29 So to declare a string, you use the string data type, again the name of the
01:33 variable that you want, and you can initialize it, and you can see I'm using
01:36 double quotes to initialize my string, which is part of the C# syntax rules.
01:42 strings can also have escape characters in them. In this case, for example, \n
01:47 represents a new line character, and these are handled automatically for you by C#.
01:52 If you make a string that has an escape sequence, which is basically a backslash
01:56 followed by a special character code, such as a T for tab or an R for a
02:01 carriage return or N for a new line, C# will simply convert that for you.
02:05 Now this provides some rather interesting side effects for working with things
02:09 like directory paths.
02:10 So for example, if I wanted to make a string that contained a directory path,
02:15 I'd have to escape out the backslashes by putting a backslash in front of them.
02:20 And this can get a little cumbersome and tiresome to read,
02:23 so C# provides a special way for telling the compiler, hey, don't worry
02:28 about escape characters.
02:29 I just want every character that's in the string to be what it really is.
02:32 And the way you do that is you put an @ symbol in the front of the string.
02:36 So in the case of declaring the myDirectory variable, in the first case I had
02:40 to escape out the backslashes; in the second case, by putting that little @
02:43 symbol in front of the string, I'm telling the compiler, hey, those backslashes
02:46 aren't escape characters;
02:47 they are just real backslashes-- please treat them as such.
02:50 But the fun doesn't stop there.
02:52 Remember that characters and strings are objects.
02:55 The character data type is really a system.char object, and the string data type
03:00 is really a system.string object, which basically means that each one of these
03:05 data types has some really cool features and methods built in.
03:09 So for example, if I define a character variable as the lowercase letter a
03:13 right here, I can do some really cool things on it.
03:15 I can ask the character, hey, is it an uppercase letter, or it is it a digit, or
03:20 is it a letter? Is it punctuation or a white space?
03:24 I can do things like convert the character to uppercase or to lowercase.
03:29 The same is true of things like strings.
03:31 If I declare a variable that holds a string, I can do some really
03:35 interesting things on it, because remember, it's an object, and the objects
03:38 have built-in methods.
03:39 So for example, I can do things like convert the string to upper- or lowercase.
03:44 I can search the string to see where a substring appears in the string.
03:49 I can do that searching forward or searching backwards.
03:52 I can take strings and trim white space off of them.
03:55 We already saw how to do things like string.formatting using
03:57 the Console.WriteLine.
03:59 You can see if a string is null or is empty. And all of these features come built in
04:06 to the language, simply because these data types, even though they're primitives,
04:10 derive from System.Object.
04:12 One of the things to keep in mind is that strings are what's called immutable.
04:17 They can't be changed once they are created.
04:20 Now you might be saying, well, wait a second Joe.
04:21 I've seen you change strings throughout this course so far. What you're talking about?
04:25 Well, the thing is that operations that appear to change a string actually
04:29 create a new string, and the thing is, this can cause a pretty significant
04:34 performance penalty if you're not careful.
04:37 So let's take an example. Suppose we had a string variable called Result and we
04:42 initialize it to be an empty string, and then we have a loop that executes, say, a
04:46 thousand times, and then inside that loop we're saying, result += "some other
04:49 strings", you know some kind of thing that we calculated.
04:54 Well, even though that += appears to be modifying the string, what's really
05:00 happening is, each time this loop executes, a new string is being created that
05:06 holds the temporary results of concatenating the string on the end, and then
05:10 that new string is assigned to the result variable, and then the old string that
05:16 used to be there is just simply discarded.
05:18 Now, if you do this a lot in your programs, you're going to hit a pretty
05:22 significant performance penalty.
05:23 So if you're doing a whole a lot of string manipulation, sometimes it's better
05:27 to use some of the built-in classes to do this.
05:29 C# provides one of these called the stringBuilder. So what you do is you would
05:33 instead of just declaring a variable named result,
05:36 you'd build a stringBuilder object.
05:39 In this case, I'm using the stringBuilder class to declare a variable called sb.
05:43 And then instead of doing a concatenation in the loop, like you see there, I'll
05:46 simply use the stringBuilder's Append method. And we will cover objects such
05:50 as this later on, but the point here is that I'm not just using a straight string to do this.
05:55 At the end, if I wanted to get the whole result of the stringBuilder as one long
05:59 string, I'd simply call the Tostring method on it and assign it to a string
06:03 variable that called result.
06:05 Let's take a look at some examples of using some of the features that we've seen
06:08 here for characters and strings in real code.
06:10 So I'm over here in my code, and I've got my charsAndstrings project open, and
06:16 I've also got my ExamplesSnippets open. Over here in the ExampleSnippets, you
06:21 can see that I've scrolled down to the chars and strings sections.
06:25 So let's go ahead and copy some of this, so I'm going to copy these lines
06:27 right here. Paste those in. So I'm going to save, and don't worry about the little warning.
06:36 I am not using the string.
06:37 We'll get to that in a second.
06:39 So you can see here that I've declared a variable called mychar, which is a char
06:43 type, and it's a lowercase letter a. And essentially what I'm doing is
06:47 exercising some of the methods that the character class provides for me.
06:50 So I'm going to do a whole bunch of WriteLines and write out the results of a
06:55 whole bunch of these methods, things like IsUpper, IsDigit, and so on.
06:58 So it starts off as the lowercase letter a. So let's go ahead and run the code
07:03 and see what happens.
07:05 So you can see that the results for these tests are, well, is lowercase letter
07:10 a upper? No, that's false.
07:11 It's obviously not a digit. It is a letter.
07:14 It's not white space or punctuation. And you can see here the results of calling
07:18 ToUpper and ToLower on it.
07:20 Okay, so let's change it.
07:23 Let's change it to say the number 8, and we will save and we will rerun it.
07:27 Well, in this case you can see that ToUpper and ToLower have the same result,
07:32 because there is no such thing as an upper- and lowercase 8, but in this case the
07:35 IsDigit function returned as true.
07:37 And I'll leave this as an exercise for you to play with.
07:40 What I'm going to now, though, is go back to the Snippets.
07:41 I'm going to copy those string tests.
07:48 Let's just do some of the string tests.
07:54 So in this case you can see I've got my string variable.
07:57 It says, "This is a message with a new line," and you can see it's got some leading
08:00 and trailing spaces on the front and back. And we are going to do things like
08:04 call Trim and ToUpper and ToLower and IndexOf and LastIndexOf.
08:09 So let's go ahead and save this and run it. And you can see here that this is a
08:17 string with a message and new line and spaces in it.
08:19 You can see that the spaces have been cut off. Here the result of ToUpper is
08:24 that all the letters have been converted to uppercase.
08:27 Here they've all been converted to lowercase, and then we found the indexes of
08:31 the letter a and the substring end.
08:32 So you can see that even though we've got primitive data types for characters
08:36 and strings, they're really pretty powerful, just again, because they derive
08:40 from the base System.Object class in C#. And because they are objects, they have
08:45 a whole bunch of really useful features that just come built in.
Collapse this transcript
Understanding variable scope
00:00 One of the other common "gotchas" that you have to watch out for when you're using
00:04 languages like C# or Objective-C or Java or anything else that's a compiled
00:08 language is the notion of variable scope.
00:11 All variables have what's called a scope.
00:13 This is where the variable is visible to the code and can be used.
00:18 So let's take a look at an example, and then I'll explain it.
00:21 So suppose I had a function named myFunction and inside that function I had a
00:25 variable called X, and I've declared the variable X and I've assigned it a value of 10.
00:29 And suppose I also have a for loop and inside the for loop I've got a variable
00:34 named Y which I'm declaring inside the for loop and the value of Y is being set
00:38 to the value of X+20.
00:41 That's okay because I can refer to the value of X inside the for loop.
00:44 I can declare the Y variable inside the for loop as well.
00:48 Now I can also refer to the X variable here if I wanted to use the increment
00:53 operator on X outside the for loop; that's fine. And I can also increment X
00:59 outside the for loop after the for loop; that's fine too.
01:02 What I can't do, however, is refer to the Y variable outside of the for loop. Why?
01:08 Because it's not available there.
01:09 I've declared it inside the for loop. And in this case when you declare
01:14 the variable inside those curly braces, that variable is only valid inside
01:20 those curly braces.
01:21 That's because in languages like C# variables have what's called a block scope.
01:28 Those curly braces define a block of code the same way that the curly braces
01:33 near the function define a block of code.
01:35 This is not the case in a language like JavaScript, and the reason is because in
01:40 languages like JavaScript variables have function-level scope.
01:45 When the JavaScript interpreter goes to interpret the function, it first looks
01:49 through the function to find variable declarations, and then it lifts them to
01:54 the top of the function.
01:56 It does that internally;
01:57 it doesn't modify your script code.
01:58 But it gives all the variables inside the function the same function-level scope.
02:03 That is not true in a language like C#.
02:07 In a language like C# or language like C or Objective-C or Java, the variable
02:12 is only available to you in the block where it is declared.
02:16 So let's take a look at this in action, and we can see how it works.
02:21 Over here in the code I've got my VariableScope project open, and here in the
02:24 Snippets I've scrolled down to the Variable Scope. And I'm going to copy these lines.
02:29 I'm going to paste it in right here.
02:32 So here I have my loop, and you can see inside the loop I'm declaring a
02:38 variable named int var1.
02:41 So when I run this program--let's just write it really click--you can see that what's
02:44 going to happen is I'm going to WriteLine, the value of var1 at pass whatever I
02:49 is is whatever the value of var1 is.
02:51 So I'm going to run it, and you can see that it's staying the value of 20 all the
02:55 way through the loop.
02:56 So now let's take a look at what happens when I try to uncomment this line of code here.
03:00 I'm going to try to WriteLine the last value of var1, but I'm going to do it
03:05 outside the for loop.
03:07 I am going to save, and you can see that I'm getting a little red
03:11 squiggle there which basically says, hey, the name var1 does not exist in
03:15 the current context.
03:16 That's because it's declared inside this for loop.
03:19 So if I wanted to do this, I would have to cut that and move it up here and save,
03:25 and now everything works fine.
03:27 So let's go ahead and undo that. Put it back where it was.
03:30 You might be wondering, hey, you know, in other languages I can re-declare
03:35 variables in different scopes and they're just given different meanings.
03:38 So for example, the C and Objective-C languages let you do something like this.
03:47 And what I've done here is I've declared the variable var1 in a separate scope
03:51 than the other var1 that's inside the for scope.
03:55 Inside the for loop you'd think that this variable would have its own scope and
03:59 this will have a different one, but that's not the way C# works.
04:03 This can be very confusing to someone who's reading code, and it's also the
04:07 source of a lot of bugs in other languages.
04:10 So the designers of C# explicitly don't allow variables to be declared in
04:15 separate scopes with the same name.
04:17 You can see that when I try to do this there is a little squiggle down here
04:20 that says, hey, a local variable named var1 cannot be declared in this scope,
04:24 because it would give a different meaning to var1, which is already used in a
04:28 parent or current scope to denote something else.
04:31 So these two variables conflict with each other,
04:33 so I can't do this.
04:36 It's important to note that this kind of scope-level referencing only works
04:41 from the inside out.
04:43 So if I declare the variable var1 in here, I can refer to it within the scope;
04:48 but if I declared it out here then I would be able to refer to it in this
04:54 current function-level scope, as well as all the other scopes that are contained
04:58 within the function.
04:59 So for example, I could do something like this, and that works just fine
05:06 because the for loop scope is contained within the scope for the Main function.
05:12 So in fact if I save this and I run it, you'll see that var1 is getting
05:17 incremented by 10 each time and now that last little console, that WriteLine that
05:21 I've got that says, what the last value of var1 was, is working just fine.
05:26 Understanding variable scope is a pretty important part of writing good C#
05:31 code, and it's something that you should pay close attention to, especially if
05:34 you're coming from a language like JavaScript that does not enforce these kinds of rules.
05:38 This kind of thing can bite you, so pay attention to it.
Collapse this transcript
Understanding type conversion
00:00 There is one more important concept that we have to understand in working with
00:04 C#, and that is understanding type conversion.
00:07 If you've come from a language like C or C++ or Java, you've seen this before.
00:12 Converting one type of variable to another is called casting, and this is the
00:17 kind of thing that pops up in languages that require you to give types to your variables.
00:22 You're probably wondering, or at least you soon would be, well, how do I share
00:26 data between variables that are different types?
00:29 The way that you do this is by casting one type of variable to another.
00:34 It's how you convert data types among different kinds of data-type variables.
00:39 So for example, suppose I had an integer named i and it is set to the value of
00:44 10, and I also had a float and that was set to the value of 20.0.
00:50 Suppose I wanted to set f to the value of i. I can just do f=i, and that's okay,
00:57 because that's an implicit cast, or a conversion from an int to a float.
01:03 Since an int is 4 bytes and a float is larger, there is no risk of data loss here.
01:08 The integer can simply be converted into a float and all is well.
01:12 The reverse is not true.
01:14 If I said i is equal to f, that causes an error, because you need to explicitly
01:20 cast from the float to the int, because data might be lost.
01:25 You can't fit all the precision of a float into an integer automatically.
01:30 However, if I did this, if I said i is equal to, and then in parentheses I put
01:35 the word int in front of the variable that I'm casting from, that's now okay.
01:41 I've explicitly cast, or converted, from the floating-point value to the integer value.
01:48 You'll see this all over languages like C and C++ and Objective-C and Java, and now in C#.
01:55 So let's go over to the code and actually see it in action. So here I am!
01:57 I've got my Conversion project open, and I'm going to open up my Snippets file.
02:03 That's right there.
02:04 So let's go ahead and scroll down to the Conversion section, and that's right
02:10 here, Type Conversion.
02:12 So I'm going to copy those lines, and I'm going to paste them in here. A couple of things.
02:20 You can see that I've got an integer, a short, and a float.
02:24 So in this case, the integer starts out as 10 and the short starts out as 5.
02:31 Now, you'll notice that I can simply assign the value of x to the value of i. Why?
02:36 Because x is a short. It's 16 bits, whereas the int is 32 bits, so there is
02:41 no loss of data here.
02:42 That's okay; the complier doesn't complain.
02:44 However, if I try to go the other way, if I try to set the value of i into x,
02:51 well, there is data loss here, or there's potential data loss here.
02:54 What's going to happen is I've got 32 bits trying to go into a 16-bit bucket, and
02:58 you can see that little squiggle is saying, hey!
03:00 Error, cannot implicitly convert type 'int' to 'short', are you missing a cast? Well, yes, I am.
03:05 All I'm going to do is say--if I put the word short in front of the i variable
03:13 inside parentheses, that says to the compiler, hey,
03:16 compiler, take the value of i and explicitly convert it into a short.
03:21 Now, you notice that that little red squiggle has gone away, and everything is just fine.
03:26 So let's go ahead and put a Console.WriteLine in here.
03:36 We'll write value x, and we'll write out x. So let's put a Console.ReadLine at
03:49 the bottom, and let's also comment out that error for the moment.
03:56 So let's save it and run it.
03:58 You can see that the value of x is 5. Why?
04:01 Because here we put x into i, and then we just put i back into x, and since x
04:07 started out as 5, that's what's happened, so now x is back to being 5.
04:11 So let's suppose we comment this line out and we make i something that a
04:18 short can't handle,
04:20 so something like 800,000.
04:23 So now when we run this, you'll see that the value of x is 13,568. Why?
04:30 Because some of the bits of the integer got stripped off.
04:34 Remember, the integer is 32 bits, but the short is 16 bits.
04:38 So 16 bits of information got stripped off, and what was left over was what could
04:43 fit in those 16 bits, and that worked out to be 13,568.
04:48 So that's the kind of thing you need to watch out for when you're working with
04:51 type conversion because some types of containers are larger than others.
04:55 Let's go back to the code here.
04:57 Let's go ahead and get rid of these two lines. And let's look at the floating-
05:02 point versions instead.
05:04 So here you can see I have the floating-point number f, which is equal to 20,
05:11 and here I've got the i, which is now 800,000.
05:14 Again, I can assign the value of i into the value of f. Why?
05:18 Because floats are larger than integers; that works just fine.
05:21 Same story down here.
05:22 I'd have to actually cast the float to be an integer, and in order for that
05:29 to work, I simply put the word int inside parentheses, and now that converts
05:34 the value of the float into an integer, which can be stored inside the integer variable.
05:39 You'll see this kind of thing all over C# code, and you'll see it in
05:43 other languages as well.
05:44 It's important to understand how conversion and casting works because you'll be
05:47 using it in your own code.
Collapse this transcript
5. Custom Classes and Objects
Object orientation refresher
00:00 Up until now, I have been talking how C# is an object-oriented language, and
00:05 you've been seeing me use objects throughout some of the previous examples.
00:08 And we've reached the point now in the course where we actually need to learn how to
00:11 define and use our own objects in C#.
00:13 If you are going to be a C# programmer, there's no getting around the
00:16 object-orientedness of the language, and now is as good a time as any to take
00:20 a look at how to get started with the object orientation in C#.
00:24 So as I have mentioned many times C# is of course an inherently object-oriented
00:28 language. There's no getting around this, and in fact, everything that we have
00:31 been doing up until now has involved objects in one way or another.
00:35 The variables that we've been defining, those are objects--those integers and
00:38 strings and everything else.
00:40 We have been using the console object to write output to the console window, and
00:45 even the program itself that we've been using is itself an object.
00:49 So objects are everywhere in C#, and your programs will not be any different.
00:54 Programs are basically collections of objects.
00:56 So objects contain data, and they contain the logic that operates on that data.
01:01 It's a way of keeping related data and logic in the same place.
01:05 And of course objects can communicate with each other, because if they didn't
01:08 communicate with each other, not a whole lot of useful work would get done. And of
01:11 course not only do the objects communicate with each other, they communicate with
01:15 the program that hosts them, because the program itself is an object, and this is
01:19 how your programs communicate with the .NET framework as well.
01:22 In C# there are three main terms
01:24 you are going to have to keep track of:
01:25 there is class, there's interface, and there is object.
01:29 Interface is a little bit advanced, so we are not going to focus on that right now.
01:33 We are just going to focus on the class and object terms for the remainder of
01:37 this section, and we'll see a little bit about interfaces later on.
01:41 Classes in C# are one of the most common type that you will come across, and a
01:45 class essentially provides a blueprint, or a description, of what an object looks
01:51 like and what it does.
01:52 The blueprint, or description if you will, defines things like what kinds of data
01:57 that an object of a certain type holds, and it also defines what kinds of things
02:01 that an object can do.
02:03 It's important to keep in mind, however, that a class is just a definition.
02:06 It's a description.
02:07 It's not the actual object itself. For example, when you have a blueprint of a
02:11 house, the blueprint you can think of as being a class, but it's not the actual house.
02:16 When you build the actual house, that's the object; the blueprint just provides a
02:20 description of how to do that.
02:22 In your C# programs, you'll usually defined your own classes to do whatever
02:27 custom work you need to get done, as well as using the classes that are provided
02:32 by the .NET framework.
02:33 The .NET framework is pretty full featured.
02:35 It provides hundreds of classes for doing all different kinds of things, and
02:39 you'll take advantage of these classes as you build your own applications. For example,
02:43 suppose we were building an application that managed the list of to-do items.
02:48 You can imagine that we would have a class to handle the to-do items;
02:51 we would probably have another class to group all of those to-do items in a to-do list.
02:56 And these are classes that your program would define. But there's a whole bunch
03:00 of other classes that the .NET framework would provide for you, things like
03:03 dates and times and array lists and classes for working with strings and
03:07 communicating with the Internet.
03:09 These are all provided by the .NET framework, and as you build your applications
03:13 and learn more about C# and .NET, you'll use more and more of the .NET classes to
03:18 round out your applications' functionality.
03:20 So what do classes define?
03:22 Classes essentially define two major things, and these are called the members.
03:27 The first set of things is fields and properties and the second set of things are
03:32 methods or functions.
03:34 Nowfunctions and methods are pretty much the same thing, but the word method
03:38 is what's commonly used in object-oriented terminology, so that's what I am going to use here.
03:42 The fields and properties are the kinds of data that the object holds and works with.
03:47 The methods are what the object can do;
03:50 this is their logic, the functionality that contains in the object.
03:54 Again, if you go back to our to-do list item example, you can imagine that a
03:57 to-do item might have a name, a description and a priority, then something
04:02 like a due date, and then we would need to have methods to operate on that
04:05 data--for example, setting the description and changing the priority, and marking items complete.
04:10 These are what classes defined and as you build your own classes, you will define
04:14 your own fields and properties, and you will write your own methods to work on
04:17 those pieces of data.
04:19 Classes can also inherit attributes and methods from other classes, and this is
04:26 a very important concept in object-oriented programming, so it's important that you understand this.
04:31 For example, let's imagine that I have a class that I want to define called class A, and class
04:36 A contains a couple of fields like name and age and it has a function in it--in
04:41 this case it called sayHello().
04:42 Now you've probably already seen examples like this, and in C# you would refer to
04:47 these fields and functions by using the dot notation. So you would say A.name,
04:51 A.age for the fields, and A.sayHello() to call the method.
04:56 I can also define a class that inherits from class A, and in object-oriented
05:01 terminology this is called creating a subclass.
05:04 So if I want to create a class B that inherits from class A, I would define
05:09 class B, put a colon after its name, and then put the name of the class that the
05:15 class inherits from.
05:16 So here you can see the class B with the colon and the A means this class B and
05:21 it inherits from class A. And in class B, I've defined a couple of things. I've
05:25 got another property called address and a function called sayGoodbye.
05:29 So again you would refer to this using standard.notation for the class B, like
05:34 B.address and B. sayGoodbye. But because the class B inherits from class A, it
05:39 also has all of the fields and properties that class A has.
05:42 So class B also has a sayHello function and the name property, even though I
05:46 haven't defined it in class B; it just gets all those things because it
05:50 inherits from class A.
05:52 So in object-oriented terminology, we say that class B is a subclass of class A,
05:58 and class A is class B's superclass.
06:02 You'll see these terms used throughout object-oriented documentation whenever
06:06 you read documentation on web. Especially in MSDN, you'll see terms like that.
06:11 You can think of C# objects as being a kind of stamping machine.
06:17 So classes, as I mentioned earlier, are used to create individual objects, and each
06:22 object that is created from a class is called an instance.
06:25 So you can think of this as some kind of machine that stamps out physical parts.
06:28 Suppose I had a class definition called person and the Person class had the name and age
06:33 and SayHello function.
06:35 Each time I made an object, that's called creating an instance of class person.
06:41 So here I've got three instances of the Person class.
06:44 I have got person A, B, and C, and each one of these real objects has actual data
06:49 that's filling out the class.
06:51 So we're using the class definition, or the blueprint, to actually make
06:55 instances of that class.
06:57 So why would you use classes and objects?
06:59 Well, using classes and objects, especially in C#, which is objected-oriented
07:03 language, really makes it easier to maintain and build applications.
07:07 First, it helps abstract ideas away from a specific implementation, which allows
07:12 you to focus on the core parts of the program.
07:15 Since the .NET framework provides a whole bunch of classes that cover common
07:19 areas of functionality that you don't have to write yourself, you can focus
07:22 on building the specific parts of your program that are only pertinent to
07:26 your business logic.
07:27 You can then reuse all the classes that .NET provides for you, which really makes
07:31 developing applications a lot faster and a lot easier.
07:34 Using classes and objects also helps encapsulate the programs functionality
07:38 into understandable pieces, because each object has its related data and logic
07:43 all kept in one place.
07:45 To go back to want to-do list item example, each to-do item would have not only
07:49 the information about that particular to-do item, but the logic that operates on it.
07:53 So you wouldn't have different pieces of logic scattered all over the place in
07:56 different locations without knowing where each one is.
07:59 It just makes it easy to understand the way that an application works.
08:03 It also helps organize a program into natural parts that could be easily
08:06 extended, and this is sometimes referred to in the object-oriented world as factoring.
08:11 Once you have factored your application into its natural parts, the object
08:15 itself and the program comes to mirror real-world constructs and ideas.
08:19 Again, taking a page from out to-do list example from earlier, when you make
08:23 objects that mirror real-world constructs like a to-do item and the to-do list and so on,
08:29 that makes the program a lot easier to understand and go back in and
08:31 maintain years later.
08:33 So using classes and objects is a really fast and easy way to build applications
08:38 that you can maintain in the future and other people can work on as well and get
08:41 up to speed on quickly.
08:43 So we reach the point now where we've completed our refresher into the world of
08:47 object-oriented programming, and we are going to spend the rest of this section
08:50 seeing how to define classes in C# and build our own object-oriented programs
08:56 in .NET and C#.
Collapse this transcript
Defining a class
00:00 Probably the best place to start when we define our own classes in C# is to see
00:04 how we define a class before we can start using them.
00:07 So we are going to take a look here at how to define a class using C#, and
00:11 then we are going to take a look at how to use it as we move through the rest of the section.
00:16 So to define a class in C# you use, surprise, the class keyword.
00:21 So you say the word class, and then you have to give it a name. In this case, I
00:25 am going to use myClass. And you can use whatever combination of letters and
00:30 numbers you want, as long as it starts with a letter and is a valid C# class
00:33 name--you can have special characters or anything like that.
00:36 So I've got class myClass, and then I am going to define some curly braces, which
00:41 are going to define the code for this class.
00:44 Once we have got the class definition laid out here, we can start adding some
00:49 fields and some methods.
00:51 You can add fields and methods in whatever order you like.
00:54 You can define field and then method and then field and then method if you want to.
00:58 My practice that I use is and I define all the fields upfront near the top, and
01:03 then I put all the methods at the bottom.
01:06 So let's define some fields.
01:07 I have got two fields here:
01:08 one is called myInteger; one is called myMessage.
01:11 We have got an integer and a string.
01:13 We could use whatever data types we'd like.
01:15 In this case, I have just got a couple for examples.
01:18 Then I am going to define a method.
01:20 And here I have defined a function called myFunction, or method--whatever word
01:25 you want to use--and it returns an integer.
01:28 In this case, it returns the myInteger field. So when the code that uses this
01:33 class calls myFunction, it will simply return the value of myInteger.
01:37 For the moment, don't pay too much attention to that word "public" that's in
01:41 front of the word "int."
01:42 We are going to get into what that means a little bit later in this section.
01:46 For now, just assume that the word public means we have to put it there so that
01:50 the rest of the world can see this function.
01:53 This is pretty much a complete class definition;
01:55 we could just stop here if we wanted to. But it's customary in C# to define
02:00 what's called a constructor.
02:01 A constructor function has the same name as the class.
02:06 So to define the constructor-- you can see I have done that here--
02:09 I've got a method call myClass, and in this case is this method is taking a
02:13 string argument which uses the value of the argument to set the initial value of
02:17 the myMessage member field. And again,
02:21 I have got the work public in front of it, and I don't want to pay too much
02:23 attention on that right now--we will get into that.
02:25 But what I have done here is defined what's called a constructor, and the
02:29 constructor takes the same name as the class itself. And you can give it however
02:34 many arguments you want, or you can give it no arguments at all.
02:37 Now, if you don't define a constructor, the C# .NET framework will automatically
02:42 put one in for you. But it is customary to define one, because you use
02:46 constructors all the time to initialize the value of class fields.
02:50 So now that we've done that, we can go ahead and take a look at how we might
02:54 create and use an object using a class that we've defined.
02:58 So in C#, the way that you create, or to use object-oriented terms instantiate, an
03:05 object is to use the keyword "new." And it's an operator,
03:08 so the way that you do this is use you use the type of myClass, and that's the
03:12 class that we defined earlier.
03:14 Then you give it a variable name, myObj.
03:16 So here instead of saying int and then some myInteger, which is a built-in C#
03:21 .NET type, we are using the type that we've defined called myClass. And we have
03:25 got a variable called myObj, and then we simply say = new myClass.
03:30 And in this case we're passing in a string to the constructor function--
03:34 this is how the constructor gets called-- so that string will become the initial
03:38 value of that myMessage field.
03:41 To use the fields and methods of a class that you have instantiated, you use the dot operator.
03:46 And again, we've seen this throughout the course so far, but let's just make it official.
03:49 So let's imagine I have an integer called myResults and this is some variable I have created.
03:54 I can then refer to the methods or fields of the object by using the dot notation.
04:00 So in this case, I'm calling some imaginary function called AddNumbers on my object.
04:04 We haven't defined it yet, but we could. And you can see it takes two
04:07 arguments, and then it returns an integer result.
04:10 So use the dot operator to reference the fields and methods of the class.
04:14 Classes can also have special members called static members.
04:19 Static members don't require you to create, or instantiate, an object's instance
04:24 in order to use them.
04:26 That may sound kind of weird, but we've actually seen this throughout the course so far.
04:30 Every time we've used the console object, for example, you notice that we
04:34 haven't had to say "new console."
04:37 We simply use the name of the class, which is console, and then dot and then
04:41 the word WriteLine.
04:42 So we are calling what's called a static, in this case, a member method, called
04:47 WriteLine, and it belongs to the entire class.
04:50 You don't have to have it be part of a specific instance of that class.
04:55 So let's take a look at the difference between instance members and static members.
04:59 Instance members of a class--
05:01 whether it's a field or a method--get copied each time a new object is created.
05:07 Static members, however, belong to the entire class, and there is only one of them.
05:11 So let's take a look at an example.
05:13 Let's imagine we have a class that defines the notion of a bottle of wine.
05:17 For each bottle of wine, you are going to have something like a year and name
05:21 to go along with it, and you would have a constructor function that looks
05:25 something like this, where when you create a new instance of the wine bottle.
05:29 you will pass in the name and the year. But suppose we wanted to keep track of
05:33 how many bottles we had in our cellar.
05:35 Well, it seems a little silly for each instance of the wine class to keep track of
05:38 its own bottle count; we only need one variable to do that.
05:41 So we would have a static member called bottleCount. And in this case,
05:46 bottleCount belongs to the entire wine class, and each instance of the wine
05:50 bottle will be able to reference this member, but it doesn't belong to any one of them;
05:54 it belongs to the entire class.
05:56 So here in the constructor, we don't need to refer it to using the class name,
05:59 because we are in the constructor for the class. But if we're using code that
06:03 was outside the class--again, think back to the Console.WriteLine example--
06:08 we would simply put the name of the class in front of the function, and that
06:11 says to the C# compiler, hey, I'm calling the static member called this
06:15 function, or whatever it is--
06:17 in this case, its not a function at all; it's a member of variable--
06:20 and I am referring to the variable that belongs to the entire class.
06:24 So let's take a look at some code that makes all this work, and then it will
06:28 become a little bit clearer.
06:30 So over here in C# Express, I've got my DefiningAClass example open. I have
06:35 also got my ExampleSnippets.txt file open, and I've scroll down to the
06:39 DefiningAClass section.
06:40 So I am going to start off by copying some of this code over.
06:43 So we will copy over the class definitions, just a few of these lines right here.
06:48 And the nice thing about C# is you can put the code anywhere in the class file.
06:51 Now I could make a separate file to contain the wine class, but we will do that
06:55 a little bit later. For now in this example, I am going to have the two classes
06:58 be in the same file.
07:00 So now we have defined the class called myClass and we've got a couple of members here.
07:04 We have an integer and a string member, and you can see that we have declared
07:07 a static integer called myStaticInt. And again, don't worry about that public keyword for now;
07:12 we'll just get to that a little bit later.
07:14 Okay, let's go back over here, and let's copy over the functions, and we'll put those in the class.
07:27 So now we have a complete class definition.
07:30 We have our member variables;
07:32 we have a function called myFunction, which returns an integer--in this case,
07:36 it's the myInteger member; and we have the myClass Constructor.
07:40 When we call the myClass constructor, we're initializing the values of myInteger
07:44 and myMessage to some initial values.
07:47 And we also have the myStaticInt, which is being initialized to the value of 100.
07:52 So now let's copy some code over that actually exercises the class and see what happens.
07:58 I will just copy these lines right here, scroll down to the main function and put them in.
08:11 So let's take a look at the code and see what's happening.
08:16 The first thing that we are doing right here on line 30 is we are instantiating
08:20 a new instance of the myClass object, and once we've done that, we can then use
08:26 the various members of the class.
08:29 So on line 32, you can see that we are using the console to write out the
08:33 results of myFunction. And in this case, we are using the instance, which is the
08:38 myC variable, to call the myFunction member function. And in the next line, line
08:43 33, we are going to use the static member. But instead of using the myC
08:47 variable, we are going to use the myClass name, because it's a static member, and
08:52 we need to refer to it on the class name itself.
08:55 So we are going to go ahead and build and run this, and what we should see is the
08:59 result of calling myFunction. Let's just scroll back up here.
09:03 So myFunction is going to return myInteger, which you can see on line 21 is being
09:08 initialized to 50, and then we have the value of myStaticInt, which is 100.
09:12 So let's go ahead and run this, and you can see that the results of calling
09:16 myFunction is 50 and using the static member is 100.
09:20 Let's go back to the code.
09:22 Using this example, you can see how we have defined member variables which are
09:27 both local to the instance of an object and the static member which belongs to
09:31 the entire class, and we've seen how to define and instantiate a new class
09:36 using the new operator.
09:37 As we move through the rest of the course, we will be doing a lot more of this.
Collapse this transcript
Using access modifiers
00:00 The C# language provides a feature called access modifiers, which allow you to
00:05 control how the member variables and methods of your classes are seen by the
00:10 outside world--in others words code that uses your objects.
00:14 And if you're coming for the language, like Java or C++, you've probably
00:18 seen something similar.
00:19 JavaScript does not have this kind of idea in it, so if you're coming from
00:24 JavaScript, you might want to pay attention to this.
00:26 So by default when you define data and methods in your class, those data fields
00:32 and methods can only be used inside of that class itself.
00:36 You have to choose to expose them to other code that's going to consume your classes,
00:42 and this is what access modifiers let you do.
00:44 They let you specify how programs-- including your own--that use your classes can
00:49 access their data and their methods.
00:52 So let's take a look at how this works.
00:54 Suppose we had a class and I have a class here called myClassName, and we've
00:59 got some fields in it.
01:00 So we have got an integer, and we've got a string, and we have some method called myFunction.
01:05 By default, all of these are what's called private. Only the class that
01:10 defines these can use it.
01:13 We need to change that in order for code that wants to consume our class to be
01:17 able to access the members of this class.
01:21 The way that we do that is by using what's called access modifiers.
01:24 And if you watch the preceding the movie, you'll have probably noticed me
01:28 using the word "public."
01:29 Well, there are a couple of different ways to expose members of the class to
01:33 code that wants to use them.
01:34 So let's take a look. The first one is called the private modifier.
01:39 When you use the private access modifier, it means that the member of the class
01:44 who is marked as private can only be accessed within the class itself.
01:48 Now this is the default setting, so if you don't specify private, the C# compiler
01:54 defaults to making a member variable or a member method as private.
02:01 The next one is public. A public class member can be accessed by any other
02:07 object that uses the class, and this is why I was using the public keyword in
02:11 the previous examples so that our code can consume that particular member of the class.
02:17 The next one is called protected.
02:20 A protected class member can only be accessed within this class or any subclass--
02:26 in other words a class that inherits from this class.
02:30 So we have got private, we have got public, and we have got protected.
02:33 So there is one more, and it's called internal, and this is a class member that
02:37 could be accessed by any class in what's called a same assembly. An assembly
02:42 is a package of code, like a library or another program, but this is an advanced feature of
02:47 C#. I am not going to cover it here in this course. Just know that you might see
02:51 the word "internal" every now and then.
02:53 It's sort of like protected, but it means that only a group of related code
02:57 can use it. But for the purpose of this course we are going to use private,
03:00 public, and protected.
03:02 So in order to see how his work, let's jump over to the code and define a class
03:07 that uses these, and you can see what happens when you try to use code that uses
03:10 each one of these access modifiers.
03:12 So over here in the code I have got my ExampleSnippets open for the
03:16 access modifiers example, and over here I have got my program file.
03:21 So here is what we are going to do. First, we are going to define a new class, and
03:24 in this case we are going to put the class in a separate file.
03:27 So what I am going to do over here is I am going to right-click on the project
03:31 name called AccessModifiers, and I am going to go down to the Add submenu, and you
03:36 can see that I can add items to my project.
03:38 What I am going to do is I am going to add a class, and the Add class
03:42 dialog comes up. And you can see there is a whole bunch of things that we can
03:45 add, all kinds of classes.
03:46 What I am going to do is just make sure that the default one here in the list
03:49 called Class is selected, and then I am going to give my class a name. And in
03:53 this case I am going to call it my Wine class. I'm going to click Add,
03:59 and you can see that the file for Wine.cs got added, and you can see that the C#
04:07 Express application has done a whole bunch to work for us. First of all, it's
04:10 automatically put the Wine class into the same namespace as our example.
04:13 It's included the using statements for the .NET framework that we are going be
04:17 using. And right here you can see it has provide a definition for class Wine.
04:21 So let's go back to Snippets.
04:22 What we are going to do now is fill out that wine class with some default code.
04:29 So I am going to copy these lines here.
04:31 I will go back to my Wine class, and I am going to paste them in.
04:35 So now in our Wine class we have a couple of different members.
04:38 We have the wine name,
04:40 we have the wine price, and we have the wine description. And you can see that all
04:43 of those are public,
04:44 so any code that wants to use this Wine class will have access to those member variables.
04:50 We have a decimal variable here called discount, and that's marked as private.
04:56 So nobody outside this class can see what that is. And then we have a public
05:00 constructor, which takes a wine name and a price. And inside the constructor you
05:05 can see that we've got the name and price public variables that are being set to
05:10 the arguments that are being passed to the constructor, and then we give the
05:13 discount variable and initial value as well.
05:16 And we can do that here because this is our class and we can refer to our own
05:21 private members within our own class.
05:23 So let me save this, and let's go back to the snippets.
05:28 Now let's go ahead and copy over some code.
05:30 I want to copy these two lines first, and we are going to go to the main function,
05:33 and I am going to paste tem in.
05:35 So here you can see that I have got two instances of the Wine class being
05:40 created, and I am passing in some default values for names and prices.
05:44 So let's write some code now that exercises some of the fields of the class.
05:48 So for example, if I wanted to refer it to the name of one of the wines, I
05:52 could simply write string and give it a variable name, =, and I could say w1.
05:57 And now watch what happens when I press dot.
05:59 Now when I press the dot, C# Express is looking at the class description and
06:03 saying, okay, what can the code in this particular area see inside that class?
06:08 And we have got a couple of default things, because we always derive from the
06:11 base system object, but here's the name and the price fields that I've defined.
06:16 Here is the description field, because those were all public, and you can see that
06:19 this is an alphabetized list. What's missing? Well, the discount field is missing. Why?
06:24 Because it's private, and because it's private, my code can't see it.
06:28 So I can go ahead and refer it w1.Name all I want to, but if I try to refer to
06:33 the discount field--let me make a decimal and we'll call it dsc--
06:38 if I say w2.discount, now watch what happens. I am going to save this. See, that
06:45 little red squiggle showed up and if we mouse over that little squiggle, we say
06:49 error. It says the AccessModifiers. Wine.discount is inaccessible due to its
06:54 protection level. Go back over to the wine code.
06:57 You can see that this is private, so private members can't be referred to
07:01 outside of the class that defines them.
07:04 Now we could also have made it protected, and protected would also result in an
07:08 error, so let's just change that.
07:09 Let's just make this private and make this protected, and we will save, and we
07:14 will go back over to the program, save and compile. And you can see that we still
07:19 have that same error there, right, even though we made it protected, because in
07:22 this case we don't have a class that descends from wine, so it's not inheriting
07:28 the discount field, and because its protected, only subclasses can see it.
07:32 So this is how you use the various access modifiers of C# to selectively expose
07:39 member variables and member functions to code that's going to consume their
07:42 objects. And the reason you want to do this is because in good programming
07:46 practices, you don't want to just make everything public.
07:48 You want choose how you expose your code to consumers of your code. That way you
07:53 can change the way things are implemented inside your class without breaking
07:57 people that are consuming the class in other programs.
08:00 So using access modifiers, you can selectively expose parts of your program
08:05 to other consumers.
Collapse this transcript
Defining properties
00:00 Okay, I promised you we would get to some really cool features of C#, and we're
00:04 about to do that right here with defining properties.
00:05 Properties are a really neat feature of the C# language, and I really like using them.
00:11 In this section, we're going to explore what they are and how they work.
00:13 Properties are essentially like data fields, but they have logic behind them.
00:18 And from the outside, they look like any other member variable, but they act
00:23 like a member function.
00:25 They actually have code behind them.
00:26 Now you define them like you would a member variable, but they have a get and a
00:32 set section of code added.
00:34 And they can use access modifiers just like member fields and member methods can,
00:40 and we explored those earlier.
00:43 Let's take a look at an example of what a property looks like.
00:47 So let's imagine we had a class called myExample and we had some private member
00:50 variable called someValue.
00:52 Now because this is private, there is no way for someone who's consuming this
00:57 class to get at that data.
00:59 Now we could make it public, which exposes the implementation of the class to the
01:04 outside world, which is not a very good programming practice.
01:06 You really want to keep the inner workings of your class private and then choose
01:10 to selectively expose data.
01:12 We could also just make a member function, which would allow an external consumer
01:17 of this class to get the value and set the value.
01:19 Or we could make what's called a property.
01:22 A property is defined like this. I'm making a public integer property called
01:28 CurrentValue, and instead of making it look like a member of function with
01:33 parentheses and arguments and so on, all I have to do is define the name of
01:38 the property with two curly braces and inside I put the word get. And
01:43 the word get here is essentially going to return the value of that private
01:48 integer that I have.
01:49 And then to set this value, I have the word set.
01:53 And in the set code, I'm setting the internal someVal property to this word value.
02:00 And value is implicit.
02:01 C# just simply generates that for you.
02:03 Let's see how this actually works when you consume this.
02:06 So to do this, I would define myEX variable, which is an instance of the
02:11 myExample class. And I'm creating a new myExample object there.
02:15 If I wanted to get the value, I would just do this.
02:17 I have an integer i, and I say myEX.CurrentValue.
02:22 That will trigger the get logic.
02:24 And in this case, the get logic is pretty simple.
02:26 It's returning the value of that internal private variable.
02:29 And if I wanted to set it, I would do this:
02:31 myEX.CurrentValue = 5, and that will trigger the set logic.
02:35 And the value of that special value keyword there in the set logic would be set
02:40 to an integer whose value is 5.
02:43 The C# language and .NET just takes care of all that for you.
02:46 You don't have to declare some argument called value;
02:48 it just magically shows up.
02:51 So you can have automatic properties.
02:54 Let's suppose, for example, I had my class, which I declared up above in the
02:58 previous example. So I've got myExample class here with my private someVal int,
03:02 and I've got the get and the set.
03:04 Since all that this example is doing is getting and setting the value of that
03:09 private internal variable,
03:10 I can rewrite this very simply, just like this.
03:14 I have my class, and then I have my property, and all I do is have the words get
03:19 and set, and that's all I need to do.
03:21 This is called an automatic property.
03:25 You can also have read-only properties, and you can have write-only properties.
03:29 Read-only properties and write-only properties are properties that can only be
03:31 read and can only be written.
03:33 So let's take a look at an example.
03:35 Using the same example we've been using up until now, I have my example class
03:38 with my private variable. And inside my public int CurrentValue, I have get
03:44 and return someVal.
03:45 Now if I don't define a set, then the property is read-only because there is no way to set it.
03:50 All I can do is get the property.
03:52 Alternately, I can define just a set.
03:55 If I don't define a get, then the property is write-only.
03:59 You'll very rarely see write-only properties.
04:01 Properties are pretty useless
04:02 if you can't actually get their value.
04:04 But you can do this.
04:05 So if you don't define a get, or you don't define a set, then the property is
04:09 either read-only or write-only.
04:12 All of this is pretty fun, but why would you use properties? A couple of reasons.
04:16 First, properties can be calculated on the fly.
04:19 So if you wanted to expose a property that looks like a member variable but has
04:24 some logic behind it that actually gets calculated on the fly whenever it gets
04:27 accessed, read, or set, then you can use a property for that.
04:31 Properties also provide complete control over the data field access, because the
04:35 logic is hidden from the object's consumer.
04:38 The consumer of the object's property doesn't need to know how it's calculated,
04:41 or what's being calculated.
04:42 And if later on down the line you go back and you change the way this object
04:46 works and the way that that property is calculated changes, then the people who
04:51 are consuming your object don't need to worry about that.
04:52 They just simply go ahead and keep on referring to that property, but the logic can change.
04:58 Properties also promote the idea of encapsulation.
05:01 We've talked about this a couple times before in this course.
05:03 What you're doing is you're taking the logic that implements that property and
05:06 you're hiding it from the consumer.
05:08 So they don't need to worry about how it works.
05:11 Let's take a look at an example of how you'd have a property whose value is
05:14 calculated on the fly.
05:16 Let's imagine I had a class that represented a wine, and in that class, I have a price.
05:23 I could define the price as just a public member variable, like I've done here.
05:28 And I've got some private ones, like say that there is a wholesalePrice and
05:32 there is a retailMarkup.
05:33 So when a wine store buys wine, they don't pay the retail.
05:36 There is a wholesale price they pay, and then there is a markup that they apply
05:40 to the wholesale price which is what the real price is.
05:43 So rather than having a public member variable, I could expose a public property.
05:48 And you can see here I've only defined a get;
05:51 there is no set here.
05:53 And when the consumer of this Wine object wants to know what the price of the
05:56 wine is, you can see that the logic inside the getter is simply multiplying the
06:01 wholesalePrice times whatever the retailMarkup is.
06:04 So I can have some code that goes out and figures out what my retail markup is
06:08 based on some other parameters I've got in my business,
06:10 and the consumer of this Wine class has no idea how or why I'm doing that.
06:15 They just simply ask what the retail price is by accessing the property and it's
06:19 calculated for them on the fly.
06:21 Let's jump over to the code and define some properties in one of our classes
06:24 and see how this works.
06:26 I'm here in my DefiningProperties example, and I've got my ExampleSnippets open
06:32 right here. And I've scrolled down to the Properties section, and I've got a Wine class here.
06:38 So what I'm going to do is go back over to the program code, and I'm going to
06:42 make a separate class file for my Wine class. And this just promotes the idea of
06:46 encapsulation. And we've already done this once before, but if you skipped over
06:49 that part, or you need a refresher, just follow along.
06:51 So I'm going to right-click on the project name, and I'm going to click Add, and
06:56 then at the bottom of the Add menu, I'm going to add a class. And I'm going to
06:59 call this my Wine class.
07:00 First, I'm going to make sure that the Class option is selected there,
07:04 and then I'm going to come down here and type in Wine.cs, and I'm going to add that.
07:11 Visual C# Express has made a new Wine class for me.
07:14 Let's go back over to the Snippets, and let's just copy this class in its entirety over.
07:23 Copy this into the Wine class, and let's save that.
07:29 So now we have our Wine class defined.
07:31 Let's go back over to the program, and let's copy in some other code from the
07:35 Snippets, which is right here.
07:43 First, let's just copy these few lines, and we can explain what's going on.
07:51 Let's take a look at the Wine class to see what we've done, before we go any further.
07:56 Here is my custom-built object.
07:57 It's a class that encapsulates the notion of a wine bottle. And you can see I've
08:02 got several private members here.
08:05 And because they're private, code that is not inside this class can't see them. So I have a Name.
08:10 I have a Year.
08:11 I have an appellation, which in the wine world is where the wine comes from.
08:15 I have a wholesalePrice, and then I have a retailMarkup of 1.35, so I've got 35%
08:20 markup on whatever wine I buy.
08:23 Then I've got a property called Price, and you can see that the price is
08:27 being calculated on the fly by multiplying whatever the wholesalePrice is
08:30 times the retailMarkup. And in the setter case, I'm setting the
08:34 wholesalePrice to the value.
08:36 So I'm not actually setting an internal price variable;
08:39 I'm just setting the wholesalePrice which would have been calculated by the retailMarkup.
08:44 I also have a property which is a string called the menuDescription.
08:47 And if you've ever been in a restaurant, you've probably seen this. Wines are
08:50 usually described on wine lists as having the year, followed by the name, and
08:54 sometimes where they've come from.
08:56 So I've got a string property that's being built up on the fly right here from
09:00 the private internal properties that I have.
09:02 And then I have my public constructor, and the constructor is what creates a new
09:07 instance of the Wine object.
09:09 And it's just taking a bunch of arguments and setting them into the private
09:13 internal member variables.
09:14 So let's go back over to the program, and you can see here that I'm instantiating
09:19 a couple of instances of the Wine class.
09:21 I've got a year for each one, I've got a name, and then I've got a string that
09:25 explains what the origin is, and then I have a wholesale price which is going to
09:30 be used to calculate the retail price.
09:32 So let's go back over to the Snippets.
09:34 Let's do some exercising here.
09:35 We're going to write out some of these property values.
09:37 I'm going to just copy these lines of code right here.
09:39 I'm going to go back over and paste them in.
09:44 In the first case, I'm going to write out the menuDescription and the Price of the two wines.
09:52 So I've got Wine 1 and Wine 2.
09:53 And remember, back in the Wine class, each one of these properties is
09:57 being built on the fly.
09:58 So I'm going to save, I'm going to build, and I'm going to run this.
10:04 And you can see that I've got Wine 1 is a 2003 Chateau Ste.
10:07 Michelle Merlot, from Seven Hills, and it's $31.72. And then I've got a
10:12 Mark Ryan Dissident that's from Ciel du Cheval, and that's $54.
10:16 But remember, those aren't the numbers that I put into the constructor.
10:19 If you look at the constructor, I've got 23.50 and 40.
10:22 The reason why those numbers are coming back differently is because--let's go
10:25 back over to the Wine class--is because of this logic right here on line 20.
10:31 On line 20, I'm taking the retailMarkup and multiplying it by
10:34 the wholesalePrice.
10:35 But from the point of view of the code's consumer--let's go back to the program--
10:39 you can see all I'm doing is accessing this Price property.
10:41 I don't have any knowledge of how that's being generated behind the scenes.
10:45 Let's go ahead and change the wholesalePrice of one of the wines using the
10:48 setter, and then we'll write out the new price. Paste that in here.
10:57 What we're doing now is using the setter logic of the Price property.
11:01 Here I'm changing the wholesalePrice of Wine 2 to $45,
11:06 and then I'm going to write out the wine description, and notice how the retail
11:10 price has automatically changed because of that calculation logic.
11:14 So I'm going to just run this.
11:16 And you can see that in the first case
11:18 it's $54, but because of the price that I set here in the setter, the new retail
11:24 price is being calculated as $60.75.
11:26 Okay, let's go back to the code.
11:29 The reason why I use properties is because you want to encapsulate some logic
11:33 inside your class, give it the appearance of a member variable, but it has logic
11:38 behind it that determines how that property is calculated on the fly.
11:42 And you can use this technique to expose private internal data in your class in
11:46 a controlled fashion, and you can get really creative with this.
11:50 Suppose, for example, I wanted to log every time somebody changed the
11:54 wholesale price of a wine.
11:56 Well, here in the setter logic, I could just simply add some code that would
12:00 write out to a log file when the price was changed. Or let's suppose I wanted
12:04 to use my debugger to set a breakpoint on whenever a value of the property was changed.
12:10 You can't do that on a private internal variable, but you can do it on a property.
12:14 So properties are really versatile, and they make your code a lot easier to
12:17 encapsulate and expose and make consumers use the classes in a way you feel best
12:21 they should be used.
Collapse this transcript
Understanding value and reference types
00:00 Now that we've learned how to create our own classes in C#, we've come to an
00:04 important point in the course where we need to learn the difference between
00:07 value types and reference types.
00:09 C# has two main types:
00:11 there's value types and there's reference types.
00:14 Value types are all of the primitive types that we've learned about so far,
00:19 things like integers and longs and shorts and decimals and chars and
00:23 booleans and so on.
00:24 And there's also a thing called struct, which we haven't covered yet, but we
00:28 will cover later on in the course.
00:30 Anyway, those are the value types.
00:32 Reference types are classes, arrays, and a couple of things called delegates and
00:37 interfaces which, again, we haven't yet covered, but we will cover later.
00:41 So why is there this difference, and what's so important about it?
00:45 The main difference between value types and reference types is how they
00:49 are handled in memory.
00:51 And the best way to learn this is to see an example.
00:54 So we're going to compare the value types with the reference types.
00:57 Now, for a value type, let's take a really simple example.
01:00 Let's suppose I have a variable i and I declare it as an integer and I set its value to 5.
01:06 Now, when I do that, the C# compiler goes out in memory and makes a little box
01:09 called i and it puts the value 5 in it.
01:12 If I declare another variable called j and I set it equal to i, then the
01:17 compiler sets aside another little box, and this little box is called j, and it
01:20 also gets the same value as i, which is 5.
01:24 Now, the important thing to remember here is that j is a copy of the value
01:28 that's stored in i right now.
01:30 So if I go back and change the value of i to 3, the value of i gets changed,
01:35 but the value of j does not get changed, because these are different memory locations.
01:39 Now, let's compare that with how reference types works.
01:42 So suppose I made a class called Point,
01:45 and inside my Point class I had two integer member variables
01:49 X and Y, which represent the coordinates of the point.
01:53 To create a new Point, I would declare a Point class variable named P1, and I
01:59 would use the new operator to create a new instance of the Point object.
02:03 Then I could do something.
02:04 Now since these are public member variables, I could say P1.X and P1.Y are equal to 10.
02:11 Let's watch what happens in memory.
02:12 Well, in memory, that little location called P1 for the variable gets created,
02:17 but what also gets created is a set of bytes somewhere else in memory that
02:21 actually hold the member variables.
02:23 And P1 is not actually containing that data.
02:27 It contains a reference to that data.
02:30 There's this little reference that goes out into memory and knows where X and Y are stored.
02:35 So let's suppose I made another variable called point P2.
02:39 And rather than doing new Point, I say point P2 = P1.
02:44 Well, that creates a little local variable there called P2.
02:47 But watch what happens.
02:48 The reference gets set to the same reference as P1.
02:52 They're sharing the same reference to the same location in memory, because I
02:57 didn't make a new instance of Point; I simply set P2 to be equal to P1.
03:02 And when you do that with a reference type, you're sharing the same reference.
03:05 What does that mean?
03:06 Well, if I then do something like this where I set P1.X =20, it changes for the both of them.
03:12 So even though I didn't do anything to mess with P2, P2.X is now having the
03:17 value of 20, the same way that P1.X is.
03:20 This is an interesting side effect of how reference types works, and you need to
03:24 watch out for it in your code.
03:25 Let's go over to the code environment and take a deeper look at this.
03:29 So I'm here in my ValAndRefTypes example file, and I've got the Program.cs file
03:35 open, and I've got my Snippets here.
03:37 So what I'm going to do is back here in my code, I'm going to put some code in
03:41 here that exercises both the reference and value types that we saw earlier.
03:47 So let's go back over here.
03:48 What I'm going to do is copy this line right here, which is the Point
03:51 definition, put it into my file over here.
03:54 I'll just put right in front of the Program class. I'll save that.
03:57 And then I'm going to copy over this function right here called testFunc1.
04:03 And this is the first test that we'll run. So I'm going to copy that.
04:06 I'm going to put that in my program down here.
04:10 So now let's copy over some of the logic to see what's happening.
04:13 Go back to my Snippets.
04:15 I'm going to scroll down a little bit, copy these few lines right here, starting
04:20 with this variable and down through this WriteLine.
04:22 I'm going to copy that and paste it into my Main.
04:27 So let's take a look at the code that we have here.
04:30 We'll use point a little bit.
04:31 I just want to make sure we have it in place.
04:32 For now, I'm just going to concentrate on this code right here.
04:35 In my Main function I've got a variable called i, and I'm setting it to be the value of 10.
04:40 And then I call this function, testFunc1, with the i variable.
04:43 So let's scroll down and see what testFunc1 is.
04:47 You can see it takes an integer argument.
04:49 And the first thing it does is it adds 10 to the argument that's passed into the function.
04:56 When this Console.WriteLine gets executed, it's going to write out the value
05:00 of whatever arg1 is.
05:02 And then when the function completes and goes back up, we're going to write out
05:05 whatever the value of i is.
05:07 Go ahead and place your wagers and let's see what happens.
05:11 Build this, and we're going to run it.
05:13 So you can see that what happened was we passed the 10 into the function, and
05:19 arg1 was set to 10, but then we added 10 to it, so now it's 20.
05:23 But when we come back out of the function, the original variable i is unchanged.
05:27 It's still 10, even though we added 10 to it inside the function.
05:31 So let's go back and take a look at the code.
05:33 The reason why this works is because for primitive value types, like
05:36 integers, when you call a function and you pass in the value as an argument to the function,
05:42 it is passed as a copy.
05:44 When you pass value types, you pass a copy of their original values.
05:50 So even though we changed the value in here on line 29, since we're passing in
05:54 a copy of the local i variable from Main, we're not actually changing the i variable;
06:00 we're only changing the local copy that testFunc1 is working with.
06:04 Let's go back and copy in the rest of our code.
06:09 And I'm going to copy in these lines here, put them in my Main function.
06:19 And I need to copy over my other test function, which is this one right over here.
06:27 And I'll put that down below here, and now we'll save everything.
06:33 Now, let's go ahead and run our next test. And for this I'm going to get rid of
06:36 these lines of code because we don't need them.
06:39 So here I'm using the Point class, which I've defined up above my Main.
06:43 Here's the Point class. It's got an x and a y value.
06:46 So on line 19, I'm creating a new point, and I set p.x and p.y to both be 10.
06:52 Then here on line 22 I write out the value of the X property. Then I call this
06:58 testFunc2 with p--that's the point-- and then I write out p.x again.
07:04 Let's see what testFunc2 is doing.
07:06 Well, testFunc2 takes a Point argument, as you'd expect,
07:10 it writes out the value of pt.x, then it adds 10 to the value, and then it
07:14 writes out pt.x again.
07:16 So we're going to write out four things here.
07:19 We're going to write out the value of the Point's x field, both inside the test
07:22 function and outside the test function.
07:24 So let's go ahead and compile this and run it.
07:27 And you can see that before we call the function, the value of p.x is 10.
07:32 Then we go into the function and pt-- that's the local variable inside
07:36 that function--is 10.
07:38 Then we add 10 to it, which gives us the value of 20, and we write that out.
07:41 So inside the function, pt.x has been changed to 20.
07:44 Then we exit the function and go back into Main and you can see that the value
07:48 of p.x has been changed to 20.
07:50 So in this case the value was changed. Let's go see why.
07:55 Remember that Point is a class,
07:59 and the class was one of those things that we looked at earlier was a reference type.
08:04 So when you make a new point like this here on line 19, and then you pass
08:08 it into a function,
08:09 you're not passing a copy; you're now passing it by reference.
08:14 And because testFunc2 has a reference to the original point, if you change it
08:19 inside the function, it will change outside the function as well.
08:23 This is the fundamental difference between value types and reference types, and
08:27 it's something you'll come across in C# on a regular basis.
Collapse this transcript
6. Collections
Working with arrays
00:01 In this section, we're going to cover some of the data structures that .NET
00:06 provides for you, and specifically we're going to focus on collections.
00:10 Collections are essentially classes that help you keep track of and manage a
00:14 whole bunch of data, and since a lot of programming involves keeping track and
00:19 managing data, it seems like this is a pretty good place to start.
00:23 We're going to start off by looking at C# arrays.
00:26 Now in C#, arrays hold a fixed number of elements, all of the same type.
00:32 An array is basically just a list of items and values.
00:37 So for example, if I declared an integer variable called oneValue and set it to
00:42 be equal to 100, we've already seen this. Somewhere out in memory the C# compiler
00:47 and the .NET framework creates a little box called oneValue and puts the value
00:52 inside that little variable box.
00:54 Now an array is a little bit different than that, and the way you declare them as a
00:58 variable is also a little bit different.
01:00 When you declare an array you specify the type that you want the array to hold,
01:05 so here it's an integer just like always, but then you put these two square
01:08 little brackets next to the type definition.
01:11 So you have the opening square bracket and the closing square bracket with
01:15 nothing in it, and then you give it the variable name, just as you always would.
01:19 And this just tells the Compiler, hey,
01:20 we're not declaring one integer.
01:22 We're declaring a whole bunch of integers.
01:24 And then you complete the sentence by saying = new and then the type that
01:29 you're creating, in this case an integer, and then inside the square brackets you
01:33 put the number of slots that you want to create.
01:36 So this line of code right here int, square brackets, manyValues creates a variable called
01:42 manyValues, which is an array of, in this case, four integers.
01:46 And out in memory what's going to happen is the .NET framework is going to
01:50 create some space and it's going to create a variable called manyValues and
01:53 there will be four little boxes all initialized to 0.
01:57 The .NET framework takes care of initializing the array for you so that they are all 0.
02:01 Now arrays are zero-based indexes. So that first element in the array there is not element 1;
02:07 it's actually element 0, and it counts up from 0 up to 3.
02:10 So there are four elements, but it goes from 0-3.
02:13 So if I wanted to reference one of the elements in the array, I would simply
02:17 use manyValues and then inside the square brackets the index number of the one I want to change.
02:22 So if I wanted to change the first element in the array to a value of 100, I
02:25 would say manyValues, subzero, =100, and lo and behold, the value changes.
02:30 If I wanted to change the last one, I would do manyValues and then 3 in the
02:34 square brackets and that works.
02:37 Just like other variables in C#, I can also initialize array variables just like
02:42 I can initialize other variable types.
02:44 So in this case, I'm declaring an integer array called manyValues and rather
02:49 than creating the new memory using the new operator, I'm using curly braces and
02:53 then just putting the array values inside the curly braces, separated by commas.
02:57 This will create an array of four integers, just like we saw in the previous example.
03:02 And of course, I can do this with strings too.
03:04 I can say string array myStrings = and then inside the curly braces just four strings.
03:09 One of the cool things about C# is that unlike other languages, like say
03:12 Objective-C, C# provides what's called automatic bounds checking for arrays.
03:17 So in programming, if you try to reference an array index that's outside of the
03:22 bounds, or the size of the array, some languages don't check that for you and it
03:26 can lead to code problems and bugs down the road.
03:29 But in C# if I tried to do this, manyValues and then 100 inside the little
03:34 brackets as an index, if I try to set that value, that's going to cause an error. Why?
03:38 Because there is only four elements inside the manyValues array, so there is no
03:43 element 100, and that's going to cause a problem.
03:45 The good news is, C# catches that for you.
03:48 Now arrays are fixed in size.
03:50 Once you declare them, that's just how big they are.
03:52 There are other data structures that we'll get to that allow you to change
03:56 the size of the array, but when you declare arrays like this, that's just how big they are.
04:00 Why? Because this allows them to be contiguous somewhere in the computer's memory,
04:04 which is very efficient for the processor to access and change them.
04:09 The other thing you need to realize is that array elements are all the same type,
04:12 so you can't have an array to clear like you see it here that has numbers and
04:16 strings and floats and different data types.
04:18 When you declare an array using either int brackets or string brackets or float brackets or whatever,
04:24 choose your data type brackets, they're all going to be the same type.
04:28 Arrays can also be multidimensional.
04:31 Now in the previous example we saw a single dimensional array.
04:34 It was just one list of numbers. But you can make arrays multidimensional, and
04:38 the way that you do that is you declare the type, so for this case, integer.
04:41 Then inside the brackets you put a little comma.
04:43 This is going to have two dimensions.
04:45 It'll have the name of the variable called multiDimArray. Inn this case I'm saying new int and 3,3.
04:50 So that's going to make a 3x3 matrix of memory locations somewhere out in the
04:56 computer's memory, and it's going to initialize them all to 0.
04:59 And then to round out the picture here, the first number in the index there is
05:04 going to represent the row number, and the second number in the index
05:07 represents the column number.
05:08 So if I wanted to refer to a specific box inside the memory of the array here, I
05:14 would say something like multiDimArray, 0,1, = 10.
05:18 That means row 0, column 1 and that's the one that gets changed to a 10;
05:22 and just like other arrays, you can initialize these too.
05:25 So to do that, I would have the int, the type declaration, along with my little
05:30 brackets with the comma inside, and then I would just give the variable a name.
05:33 And in this case I have new int, comma, withinside the curly braces a set of curly
05:39 braces, each one representing a row of data.
05:42 This would create a 3x3 array with all of the boxes set to (0,1,2), (3,4,5), (6,7,8).
05:50 So you can initialize them and you can make multidimensional arrays with set values.
05:56 Now arrays, of course, are, just like everything else in C#, objects.
06:00 So, for example, if I had this declaration here for int manyValues = 100, 200
06:06 and so on, that gives me an array object with four entries in it.
06:11 So I can then do something like this.
06:13 I can say manyValues.
06:15 and then call a function called GetLength(), and that will come back with a
06:18 number four, because how many there are.
06:20 I can also call some static member functions. Remember, we talked about
06:23 static items earlier on.
06:25 I can do Array.Clear and then give it the name of the array and a couple of indexes.
06:30 Then starting at 0, it'll clear out the four elements.
06:33 I can do Array.Sort.
06:35 It will sort the given array, assuming that the members of the array are sortable.
06:39 Same thing with Reverse.
06:41 I can just reverse the given array.
06:43 Because arrays are objects, you get access to a whole bunch of built-in features.
06:47 So let's exercise some of these features.
06:48 Okay, here in the code I've got my Arrays example open, and I've got my Snippets
06:54 here. Scroll down to Arrays, and here's my program code.
06:57 So let's just go ahead and copy some of these over.
06:59 I'm going to do the first couple of lines right here, and we'll paste that in.
07:04 And here what we're doing is we're just declaring an array called manyValues
07:07 that has a whole bunch of values in it, and then we're going to write out the
07:10 value of the fourth number.
07:12 And remember, to do that, since this is the fourth number and it's a 0-based index,
07:15 we use the number 3, and set right here on line 13.
07:18 So let's hit F5 to run this, and the fourth number is 34.
07:22 Okay, that's pretty simple and straightforward. Let's keep on going.
07:25 In this case, we'll do the same thing with strings.
07:29 So here I have an array of strings.
07:31 I've got four strings: Joe, Marini, Teaches, C#.
07:34 And what I'm going to do here is use a for loop to write out the values of each
07:38 one of the elements.
07:39 So I have a for loop going from 0, and notice I'm using <4 here, not < or =,
07:45 because it has to stop at 3.
07:46 I'm going to write out each one of the strings using the i variable here to
07:52 index into the array.
07:53 So once again I'll hit F5, and you can see that works just fine.
07:57 Okay, so let's keep on going because this is getting interesting.
08:00 Let's go back over here.
08:02 We'll copy and paste this and put that down here.
08:06 So here you can see that I've created an integer array called otherValues and
08:10 I've set it equal to manyValues, and now I'm changing the last item in the
08:16 otherValues array to 0.
08:17 But what I'm writing out over here is the manyValues array, or at least the last
08:23 element of the manyValues array.
08:25 Now see if you can guess what's going to happen.
08:28 If we look at the item here, you can see that manyValues(3) is 0, 1, 2,
08:31 3; it's currently 34.
08:34 Let's see what happens when we change the otherValues array or sub three to zero.
08:38 I get it set to 0. Why?
08:40 Because remember arrays are reference types.
08:43 We passed in a reference to the array; therefore we actually changed the value of
08:48 both manyValues and otherValues.
08:50 And if you skipped the section earlier on value types versus reference types,
08:54 you should go back and review it now.
08:55 Let's try something else. Let's try some sorting.
08:57 I am going to copy this.
08:58 I'm going to paste it over here.
09:02 So now I'm calling the array class's Sort static member function on
09:08 my manyValues array.
09:09 And when I do that, we're going to write out what the fourth number is.
09:12 So let's go ahead and build that, and you can see that the fourth number is 16.
09:18 So we sorted the array going from smallest to largest, and that's a
09:22 built-in feature of .NET.
09:24 Arrays are really useful collection objects to use in C#.
09:27 You will find yourself using arrays for all kinds of things.
09:30 Arrays are used for processing lists of information and so on. What we'll take a
09:34 look at next is a collection type called ArrayList, which has some added
09:37 benefits on top of arrays themselves.
Collapse this transcript
Using array lists
00:00 All right. The next collection class that I am going to cover here is ArrayLists.
00:05 Now ArrayLists are like arrays, but there are a couple of unique features to them.
00:10 First, they can be dynamically resized as needed.
00:13 Recall from the previous movie that arrays are set in size once you create them;
00:18 ArrayLists aren't like that.
00:19 Now the way you create an ArrayList is by using the ArrayList class. And here
00:25 I've got an ArrayList with a variable named myAL, and I just say new ArrayList.
00:31 And we'll see how to do this in a bit in the code.
00:34 You have to include another namespace in order to use these, but the class name is ArrayList.
00:39 And in this case, I'm just calling the constructor that doesn't take any
00:43 arguments, but there is a version that does take an argument.
00:45 I could also just declare this variable by saying new ArrayList and then give it
00:49 some number, which is the capacity that I wanted to start off with.
00:52 If you don't do this, it starts off with some default capacity, and I don't
00:56 remember what is on the top of my head. I think it's like 10 or 50 or
00:58 something like that.
00:59 But you can say new ArrayList with a hundred or a thousand if you know you're
01:02 going to start off with a number that's that large.
01:05 So to add and remove items from the ArrayList, you use the functions that go
01:11 along with the ArrayList class.
01:13 So for example, to add an object to the ArrayList, you would simply call myAL.Add.
01:19 And notice that items get added as objects.
01:22 It takes an object as its argument.
01:24 But remember, everything in C# is an object--
01:27 well, almost everything anyway. Certainly all of the primitive data types and
01:31 any of the classes that you're going to come up with.
01:33 So you can add objects into your ArrayList.
01:36 Now you can add, which puts them at the bottom, or you can use the Insert method,
01:40 which takes an object and puts it in at a specific index. And then to remove
01:44 things you can use the Remove and RemoveAt.
01:46 So the Remove function takes the object that you're passing as an argument,
01:50 finds it in the ArrayList, and removes it.
01:52 RemoveAt removes the object that is at the index that you pass in, and remember
01:57 indexes here are zero-based.
01:58 There is also an easy way to find out how many things there are in the ArrayList.
02:03 There is the myAL.Count, which is a property on the ArrayList that tells you how
02:08 many items are currently in the ArrayList.
02:11 You can also do indexing with ArrayLists the same way that you would do them
02:14 with regular arrays. You can do things like myAL subzero.
02:16 You can even set values this way, which I guess is okay to do, but my preference
02:23 is to use the functions that come with the class.
02:25 Okay, let's take a look at ArrayLists and loops.
02:29 So suppose we had an ArrayList that we declared like this and we added a whole
02:34 bunch of items, items 1, 2, 3 and 4.
02:36 Out in memory this goes ahead and creates an ArrayList with four items in it.
02:41 Now if we want it to loop over the contents of this array, there is a couple
02:45 ways we could do it.
02:46 We could use the for loop, which we've seen in the past. And in this case, we
02:50 would have an integer variable named i and we would loop i up to being less than
02:55 the count of the items in the array, and we would increment the loop counter.
02:59 Now this is a perfectly valid way of doing this;
03:01 however, there is another way to do this.
03:04 And of course we could operate on the contents of the ArrayList.
03:06 We could write things out.
03:07 But my preference when working with things like this is to use the foreach loop.
03:13 Now we didn't talk about this earlier in the course, but I'm going to introduce it now.
03:16 The foreach loop construct loops over all of the elements in a collection, and
03:21 you can use it with arrays and other things throughout C#.
03:24 We're going to do it with ArrayList right here.
03:27 So foreach doesn't take a loop counter. What you do is you declare a variable
03:31 inside those parentheses; in this case it's an object because ArrayLists contain objects.
03:36 So you would say foreach (object obj in, and then the name of the collection.
03:41 In this case it's myAL. That's my ArrayList.
03:44 And then we can go ahead and operate on each object inside the loop.
03:47 So rather than doing the myAL sub-I that you see there in the loop, we would change
03:52 that to Console.WriteLine and then obj, because obj is going to be set to a
03:57 different object each time through the loop.
03:59 That's basically how foreach works.
04:01 It's really nice because there's no loop counters to keep track of.
04:04 There is no comparisons to make. The foreach construct just knows how to loop
04:09 over all the elements of a collection and put it into an object's variable
04:14 that you declare here.
04:15 Well, in this case it's an object; it could be other things too.
04:18 But in this case it's an object because ArrayLists keep track of objects.
04:21 ArrayLists can also have mixed content, unlike arrays. So if we declare an
04:27 ArrayList that looks like this, and then we go and add content to it using the
04:32 Add, remember each one of these is added as an object.
04:36 So I've got strings. I've got numbers.
04:38 I can put anything I want in here, as long as it derives from system.object,
04:42 which all the primitive value types do and all the reference types that we've
04:46 talked about, they do as well.
04:48 So I can do things then like this.
04:49 I can have an integer variable named result, and once again, I'm going to use my
04:53 foreach construct. And in this case, remember they are all objects,
04:57 so for each object in the ArrayList, I can then do something like this.
05:02 If the object is an integer--remember the is operator from earlier on in the course--
05:09 I can then say result +=, and then I cast, or convert, the object to an integer by
05:15 putting the word int in parentheses in front of it.
05:18 So this is going to loop over each object in the ArrayList,
05:21 see if it's an integer, and if it is an integer, add it to a running total.
05:25 So ArrayLists are really nice and flexible.
05:27 Let's go ahead over to the code and see some of this in real action.
05:30 Okay, here in the code I've got my ArrayLists example open, and I've got my
05:35 ExampleSnippets file. I'll scroll down to the ArrayLists section, and I'm going to copy
05:39 these lines right here, and I'm going to paste them into my program.
05:44 Put those into Main.
05:45 All right, so let's go ahead and take a look at the lines of code and see what they are doing.
05:50 Here on line 13 I'm declaring a new ArrayList object, then putting it into the
05:55 myAL variable, and then I add some stuff to the ArrayList.
05:59 I've got a string, integer, another string, another integer, and then a
06:02 floating-point number.
06:04 Then I have my foreach construct right here on line 20, and I've got my object o
06:10 variable, and that's going to be set to whatever the current object is each time
06:15 through the loop. And then I'm checking to see if o is an integer, and if it is
06:19 an integer, I write out the value of o using the Console.WriteLine construct.
06:25 So let's run this, and you can see that 2 and 4 are being written out.
06:30 Okay, let's go back and make a quick modification.
06:33 Let's say for each object, if o is an integer or o is a float, then we'll write it out.
06:45 In this case, we'll run it again,
06:47 you can see that the floating-point number as well as the integers are being written out.
06:51 So ArrayLists are really nice flexible alternative to using arrays in C#.
06:56 If you find yourself needing an array construct that is flexible, can contain
07:01 mixed content, and so on, consider using ArrayLists rather than just fixed-
07:05 sized arrays.
Collapse this transcript
Working with stacks
00:00 The next collection class that we are going to look at is called the stack.
00:05 Stacks maintain a list of items just like arrays and ArrayLists do, but they
00:10 operate on a slightly different paradigm called push-on and pop-off, and you can
00:15 think of a stack as, like, in fast food restaurants they have those cup stacks
00:20 where they push all the cups into the holder and then each time a person takes a
00:24 cup, it pops off the top.
00:26 Stacks are pretty much the same way.
00:28 Stacks are declared by using the stack class.
00:31 So to declare a stack, I will use the stack class, and then mystack is the
00:34 variable name. This is probably familiar by now. I say new stack.
00:38 That will create a stack object out in memory.
00:41 To put data on the stack, I use the push method to push data on the stack.
00:47 Remember, these are objects,
00:48 so I can pass any primitive type or any reference type, anything I can come up with.
00:54 In this case, I will just push a string called a string 1.
00:56 What that will do is that will put string 1 onto the top of the stack.
01:01 If I then push another piece of data, say string 2, what will happen is string 1
01:05 will slight down and string 2 will now be the new top.
01:08 And I can keep on doing this with successive pieces of data.
01:11 I can have strings 3, 4, 5, and so on.
01:14 To get the data off the stack, instead of using push, I use pop.
01:18 So I would declare an object variable.
01:22 In this case, it's called o, and then I would call mystack.Pop.
01:25 This would get the top value on the stack.
01:28 So after calling pop, string 2 pops off and then string 1 slides back on up and
01:33 now the value of o is the string 2.
01:36 If I wanted to just see what was on top of the stack without changing it, I
01:40 would use the Peek method.
01:42 This looks at the top value, but doesn't actually pop it off.
01:47 Then finally I can see how many things there are on the stack by asking the
01:50 stack's count property how many things there are.
01:53 In this case, it will tell me that there is one item on the stack.
01:56 Stacks are commonly referred to as LIFO,
01:59 Last In, First Out, data structures, because the things that you push onto
02:04 the stack earlier get pushed down towards the bottom and later elements are nearer the top.
02:09 So as you pop them off, those items are going to come out first.
02:12 So it's Last In and First Out.
02:14 Again, stacks are one of the common data structures you will find throughout
02:17 programs for various purposes.
02:19 Let's go ahead and jump over to the coding environment and actually exercise
02:23 this to see how it works.
02:25 So here in the code I have scrolled down to my Stacks section in my
02:29 ExampleSnippets, and I have got my Stacks project open over here with my Main function.
02:36 Let's go ahead and copy some code over.
02:38 So the first thing I am going to copy over is this setup code right here, and I
02:42 am going to paste that in.
02:45 Right there on line 13 you can see that I am declaring a new stack variable, and
02:50 then I am pushing some data on the stack.
02:51 I am Pushing strings, items 1, 2, and 3.
02:54 Then I am just going to write out how many items there are on the stack by using
02:57 the mystack.Count property.
03:00 So we are going to run this, and you can see that sure enough, there are
03:03 three items on the stack. So far so good.
03:06 Let's go back over to the code.
03:08 Now let's have a peek at what the top item is.
03:11 So we are going copy that, and we will paste that below here.
03:16 Now remember Peek is non-destructive.
03:19 In other words, it doesn't actually change the stack;
03:21 it just shows me what's on the top.
03:22 So we will run this and you can see that items 3 in on the top. Why?
03:26 Because item 3 was the last item pushed on; therefore, it will be at the top of the stack.
03:33 So far, things are operating the way they are supposed to.
03:35 Let's go ahead and try popping something.
03:37 I will go ahead and paste that code in down here.
03:44 So now here on line 23 you can see I am calling the Pop function, which is
03:48 going to pop item 3 off the top of the stack, which means that item 2 will now be the top item.
03:54 So when I write this out, it should say item 2. So let's run this.
03:57 Yeah, sure enough item 2 is now on the top of the stack.
04:00 Let's go back to the Snippets over here. One more thing.
04:04 We'll paste that code in here.
04:11 So now I am going to call these stacks Clear function right here on line 27, and
04:15 that will get rid of everything on the stack here.
04:17 It will clear out the contents and then when I call mystack.Count, I should have the value 0.
04:23 So let's press F5 and sure enough, I have got 0 items on the stack.
04:30 You will find stacks used throughout C# programs and other programming
04:33 languages in general.
04:34 They are pretty useful for keeping tracks of certain kinds of data structures,
04:37 mathematical expressions, evaluations, and so on.
04:40 There are a couple of great examples.
04:41 So that's how you use stacks.
Collapse this transcript
Working with queues
00:00 Well, continuing on with the cavalcade of collection data structures, we are now
00:04 going to look at queues.
00:06 Queues maintain a list of items kind of like stacks do, but they are different
00:10 than stacks in that they're FIFO, or First In, First Out--kind of like a line of
00:15 people waiting at a counter.
00:16 In fact, if you've ever spent any time in UK, you will probably hear lines
00:19 referred to as queues, and queues in programming work pretty much the same way.
00:25 Something enters the queue, and it's the first one in. It's also the first one out.
00:28 And items move in the queue in an orderly fashion, or at least they should.
00:33 Using queues in C# is similar to using stacks, only instead of having Last In,
00:39 First Out, it's going to be First In, First Out.
00:42 To declare a queue, you use the Queue class name and here I have got a queue
00:47 named myQ and I create a new queue.
00:49 Then to put things on the queue, instead of using push and pop, we are going to
00:52 use Enqueue and Dequeue.
00:55 So in this case, I am going to create my new myQ variable.
00:58 I will call Enqueue. And in this case I am passing a string, but it's an object,
01:02 so it can be anything; it could be a number or whatever.
01:04 So I am passing in a string.
01:05 When I do that, string 1 will be placed in the queue.
01:08 If I then Enqueue string 2, string 1 will move down and then string 2 will now
01:12 be at the back of the queue.
01:15 Instead of using Pop, I am going to use Dequeue.
01:18 So when I say Dequeue, the first item will come off of the queue like this.
01:24 That leaves string 2 as the current first item.
01:28 Just like using stacks I can do things like Peek, and Peek is non-destructive.
01:32 In other words, it's does not take things off the queue;
01:34 it just shows me what's at the front of the queue.
01:36 In this case, it's now string 2. And also like stacks, I can use the Count
01:40 property to see how many items are actually on the queue.
01:44 So since this is so similar to stacks, let's just go ahead and waste no time and
01:47 get over to the code so we can see this working in action.
01:50 Here we are in the code.
01:52 One of the things that I haven't pointed out up until now, which you
01:55 probably have noticed, is that you need to include a name space in order to
01:58 use the collection classes.
02:00 Up until now we've had a Collections.Generic which has been included for us by
02:04 default, but in order to use things like stacks and queues and ArrayLists, you
02:08 need to include this guy right here using System.Collections.
02:11 This is the namespace you need to include in order to use the classes we have
02:15 been talking about so far.
02:17 So to use queues and stacks and ArrayList and so on, just make sure you have that included.
02:21 So let's jump over to the Snippets, and you can see I have scrolled down to the
02:25 queue section. And I am going to go ahead and copy these lines and this is the
02:30 setup code right here.
02:31 I'll just paste this in.
02:36 So right there on line 13, creating a new queue, and then I am Enqueuing four
02:40 items. And I am going to write out how many items there are in the queue and sure
02:44 enough, there four items, just like you would expect there to be.
02:48 Now let's go back to the Snippets.
02:50 Just to show you that you can use other kinds of loop constructs with these
02:54 collection classes, I am going to use a while loop.
02:57 And if you have been watching along with me so far, you've probably noticed
03:00 I've used for loops.
03:01 I have used for each loops.
03:03 It's time to give the while loop its turn.
03:05 So here I am going to say while myQ.Count > 0 we are going to Dequeue items--
03:13 you can see they're on line 23--and then in the following line 24 we are just
03:15 going to say Dequeuing object whatever and write it out to the console.
03:21 Each time we Dequeue something the Count property is going to automatically
03:25 be decremented for us.
03:26 We don't have to worry about taking care of that.
03:28 The class keeps track of how many items there are in the queue. And since Dequeue
03:32 takes things off of the queue, the Count will change for us.
03:35 So I am going to go ahead and compile this and build this, make sure it works, and it did.
03:38 Now let's just go ahead and run this.
03:42 You can see that we are Dequeuing items in the same order that they were put o to the queue.
03:47 So item 1 was the first one in, and it's the first one out, followed by items 2, 3, and 4.
03:52 So queue is similar to stacks, only they operate more like a Line.
03:55 If you find yourself in need of a collection class where the order is
03:58 important and you need to process things in the same order that they come in,
04:02 use queues instead of Stacks.
Collapse this transcript
Using dictionaries
00:00 The last example of a collection class that we are going to look at is the dictionary.
00:05 And dictionaries are used to associate a particular key with a given value,
00:11 and you can think of them as lookup tables. Essentially, you use a key to look up a value.
00:16 So if I have a dictionary object then I essentially have a key that's associated
00:21 with a value inside that dictionary.
00:24 And some examples of that might be a product ID with a product name, or I could
00:28 associate say an abbreviation for a state name with its full name.
00:32 But really I can associate any object with any other object.
00:37 This is what hashtables are essentially used for.
00:40 They are probably one of the most useful collection classes out of all of them.
00:44 Keys have to be unique.
00:46 You can't have duplicate keys, and dictionaries don't have any sense of order.
00:52 So unlike other collection classes, like stacks or queues or arrays, there is no
00:57 sense of order here.
00:58 You simply put in keys, associate them with values, and there's no notion of who
01:04 is first or who is last.
01:06 Probably the most common example of a dictionary is the hashtable
01:11 or associative array.
01:13 You probably heard it called many different names depending on what other
01:16 programming language you may have come from.
01:18 If you've never heard of it before then I will introduce it to you now.
01:22 The hashtable is an example of a dictionary, and the Hashtable class in C# is
01:28 declared the same way you declare any other collection class;
01:30 you simply have the Hashtable class, and in this case I'm declaring a variable
01:34 named myHT, which is of type Hashtable, and then you just use the new operator
01:39 like you would in any other class.
01:41 So this will create a new hashtable named myHT, and then we can start adding
01:46 things to the hashtable. And the way you do that, well, there are a couple ways
01:49 to do it, but the first way to do it is to use the Add function.
01:52 When you add something to a hashtable you give it the key that you want.
01:56 So for example, I could give a three-letter airport code, like SEA, and then I
02:01 give it the value, which might be something like Seattle Tacoma Airport.
02:05 Then over in a hashtable I would have a little key named SEA and would be
02:08 associated with a value.
02:10 And I could do the same thing for say SFO, and that associates it with
02:14 San Francisco Airport.
02:15 I can also use bracket notation.
02:18 For example, I can say myHT, and then in brackets I can have the three-letter
02:22 code for IAD, which is Washington's Dulles Airport. And using the bracket
02:28 notation, I will simply use the equals, or assignment operator, to say myHT sub
02:33 ID is Washington Dulles Airport, and that would also put something into the hashtable.
02:38 That's how you get data into the hashtable.
02:41 The way that you get data out of the hashtable is to use the Remove function.
02:45 In this case, I would call myHT.Remove, and then I give it the name of the key
02:49 that I want to be removed.
02:50 So if I want to remove San Francisco Airport, I would simply say Remove SFO and
02:54 that will cause SFO to be removed from the hashtable.
02:58 Just like other collection classes, there are a couple of utility
03:01 properties and so on.
03:02 For example, I can see how many things there are in the hashtable by using the
03:06 by now ubiquitous Count property.
03:07 This will tell me in this particular case there are two things in the hashtable.
03:11 I can also see if hashtables contains certain values by using a test.
03:15 I can, for example, declare a Boolean variable name b and call the ContainsKey
03:21 function on a given hashtable. And I can pass in a key name, in this case SFO,
03:26 which will return false now, because it's gone. Or I can also use the
03:30 ContainsValue version as well.
03:32 So I can say, hey, hashtable, do you contain the value San Francisco Airport?
03:36 In this case, it's now false, but if it was still there, it would be true.
03:39 So let's just jump over to the code and make ourselves a hashtable and exercise this.
03:45 So here I am in code.
03:47 Once again you'll notice I am using the System.Collections using statement up
03:51 here that includes the name space for the collections class, which includes
03:56 things like dictionaries and hashtables and queues and stacks and all the
04:00 examples we have been using so far.
04:02 So jumping over to the Snippets code, you can see I have scrolled down to the
04:05 Dictionary section, and I am going to copy the setup codes over here.
04:08 I am going copy that and it will paste it into the Main.
04:17 You can see on line 13 I have created a new hashtable, and then I've added some
04:21 data to the hashtable.
04:22 I have added airport codes SFO, SEA, and IAD, and I have set their associated
04:28 values to the full names of their airports.
04:31 Then we can test this out by saying, hey, let's do a Console.WriteLine to see
04:35 the value for key, whatever is this.
04:39 And we are going to pass in the name of that key. In this case I will look
04:42 up the value by using the bracket notation.
04:44 So you can see here on line 16 I use the bracket notation to set the value.
04:48 I can also look up the value by using the bracket notation, but without an
04:52 assignment operator.
04:54 So I am going to do a build.
04:55 You could see the build succeeded, and we are going to run it.
04:59 And you can see it worked fine.
05:02 The value for key SEA is Seattle Tacoma Airport. That's great.
05:07 Let's continue on with the exercise.
05:09 I am going to copy this line here, which simply tells me how many items there
05:14 are in the hashtable.
05:15 So I'll save that and run it.
05:18 And as you expect, there are 3 items in the hashtable. So far so good.
05:24 Let's do our last exercise right here.
05:27 Copy and we'll paste this in.
05:31 In this case, we are going to exercise the Remove functionality, but before I
05:35 uncomment that Remove line--let's just go ahead and write it out that right now--
05:41 you can see that the value for key SFO is San Francisco Airport.
05:45 That's because SFO is still in the table;
05:47 I haven't removed it yet. But if I uncomment this line right here, I'm going to
05:53 remove the SFO key, and then the next line is the if statement on line 22 that
05:58 says, hey, if myHT contains the key SFO then write it out.
06:03 Now that condition is going to be false, because we've moved it.
06:05 So let's run it again, and you can see that this time there was no WriteLine for
06:11 the SFO key, because it's not there anymore.
06:14 Hashtables are probably one of the most useful of the collection classes, and if
06:19 you're coming from a language like JavaScript you've probably used these a lot.
06:23 In fact, they are used all over the world of programming, and in C# it's no different.
06:27 You can use hashtables to associate keys with objects, or any other kind of data
06:32 that you can think of.
06:33 They're pretty useful.
06:34 They are also pretty efficient.
06:36 If you find yourself in need of having a lookup mechanism, a hashtable
06:39 usually fits the bill.
Collapse this transcript
7. More Complex Classes
Overloading methods
00:00 We have reached the section of the course now where we are going to start
00:02 learning about some of the more advanced object-oriented features of C#.
00:07 The information in this part of the course is going to build on the
00:11 information that we learned about earlier in the chapter on creating custom
00:15 classes and objects.
00:17 Go ahead and watch that content if you haven't already, and then pick it up here.
00:21 We are going to start with method overloading, and method overloading is when
00:25 you define methods that have the same name but different ways of calling them.
00:30 So let's look at a real example.
00:32 Let's go back to our ubiquitous Wine class example, and you can remember from
00:37 earlier examples I've got a class here called Wine. And I can declare some
00:42 member variables like Year, Name and Price, as I have done in the past. And you
00:45 have probably seen me do something like this where I declare a constructor
00:49 function called Wine, which is the same name of the class, and in this case it
00:54 takes a string argument and it sets the value of the Name variable to whatever
00:59 argument was passed in.
01:00 That's great, but what if I also wanted to give people that are using this
01:03 class a way to initialize the class, or construct the class, with both a name and a year?
01:11 Well, I could simply just define another Wine constructor function like this,
01:16 and in this case I have got a Wine constructor which takes a string and takes a Year.
01:20 You might be saying, well, wait a minute.
01:21 You have already got a constructor function called Wine.
01:24 Isn't this a problem? Aren't you redefining something? No, not really.
01:27 What I am doing here is I'm overloading the Wine constructor, and this doesn't
01:33 just work with constructors.
01:34 You can do this with any function.
01:35 I just happened to be doing with the constructor function here.
01:38 And the reason this works is because the signatures of the two methods are different.
01:44 In other words, the parameters that each one of these constructor takes is unique.
01:49 So for consumers who wanted to call the constructor for the Wine class using
01:54 just a name, they can do that.
01:56 If they want to use both the name and a year in their code, they can do that too.
02:00 As long as you define the function with the same name and a different set of
02:05 parameter lists, that's fine. That's legal C#.
02:08 Let's take a look at an example that doesn't work.
02:12 If I have a class and I wanted to provide two functions of the same name, here I
02:17 have got a function that takes an integer and returns an integer and I've got
02:21 another function that takes an integer but returns a float.
02:23 The problem is this is an error.
02:26 The return type of the function is not part of the signature.
02:29 It's the parameter list.
02:31 These methods are not considered different by the compiler. And you can imagine
02:36 in the code I would call out a function with an integer argument,
02:39 the compiler wouldn't know which one to call. So you can't do this.
02:43 You can't have functions that defer only by the return type.
02:46 The parameter list has to be different.
02:49 So let's take a look at some real code to see how this works.
02:52 So in the MethodOverloading example I've got my program, opened and here's my
02:57 Snippets code, and I've scroll down to the overloading methods section.
03:01 So I am just going to go ahead and copy this entire class right here for Wine.
03:07 And we are going to need this to set up the example, so I will just copy this in,
03:10 and I will put it above the program class.
03:15 Before I copy the rest of the code, let's take a look at what's going on here.
03:18 I have my Wine class and I have got my member variables here, and then I've got
03:23 a set of constructors.
03:24 You can see that I've got a constructor for the Wine class that takes just a string,
03:28 I have got one that takes a string and a year, and I've got one that takes a
03:32 string, a price and a year.
03:36 So I have got three different constructor functions, so I am overloading this
03:39 function three times.
03:40 Okay, now let's go back to the Snippets and let's copy in some code that
03:45 actually exercises this.
03:47 I will copy that and put it into the Main function, and we will just put it in right there.
03:56 You can see here, starting on line 35, I am creating three Wine objects, w1, w2
04:03 and w3, and I am calling the constructor in a different way each time.
04:07 For w1 I am just passing in a string by putting in a name, for w2 I have got a
04:11 name and a year, and for w3 I've got the name, the price and the year, and
04:17 then I've got three lines here that's going to write out the various parts of the objects.
04:23 So for Wine 1 I am going to write the name, and so on.
04:25 Let's go ahead and try this code out and see what happens.
04:29 So you can see that when I run the code for w1, I am writing out just the name;
04:33 for w2 I have the year and the name; and for w3 I have got the year, the name, and the price.
04:41 Now, because I've overloaded these functions, I can call them with different
04:46 values and different parameters.
04:47 So, for example, I have given the consumers of this class three different ways
04:51 to build their Wine class objects:
04:54 so just the name, the name and the year, and the name and the year and the price.
04:58 I want to go back and change the way that I constructed w1,
05:02 I can put my cursor in here and type comma. And you can see that when I type the
05:07 comma, C# Express gives me a little pop-up that says hey, there are three
05:12 different ways you can call this function.
05:14 You can see right here it's on 2 of 3, but I can cycle through all of these.
05:18 1 of 3 is to call the Wine constructor with just a string.
05:22 Here is the version with just a string and an integer. And you can see, since I
05:27 have put the comma in there, it's highlighting the integer in bold saying, hey,
05:30 that's where I think you are going to type next. Or in the third case,
05:35 I've got the string, the price, and the year. And again I am on parameter number
05:39 two right now so it assumes I am going to type a price in here.
05:42 But the point is that C# Express is looking at my constructor list and helping
05:47 me choose the one that I want, and it's showing me what's available.
05:50 I can choose to use either this version or this version.
05:53 So let's go ahead and use the second version.
05:55 I am going to just type in 2007. I need to change the Console.WriteLine as well.
06:04 So I will put this in here w1.Name, and now I will do w1.Year. And when I save
06:15 and I rerun this, you can see I have got the name and the year that's being written out.
06:21 Just to recap, overloading a method is when you declare a method with the same
06:27 name but with a parameter list that's different each time.
06:30 In this example I showed you how to do it with the constructor, but you can do
06:34 this with any method. It doesn't have to be the constructor.
06:37 You can't do this with properties. You can't do this with fields.
06:39 You can do this with methods.
Collapse this transcript
Overriding methods
00:00 A very close cousin of overloading methods is called overriding methods.
00:05 In overriding methods, you basically get to change or augment the behavior of
00:10 methods and classes, and this is called overriding their logic.
00:14 It's one of the most powerful things of object-oriented programming and it
00:18 really, really helps you when you want to encapsulate your logic in your objects
00:22 and separate the behaviors of different objects from each other.
00:26 Let's suppose you have a phone. And a phone knows how to do something, like ring,
00:32 but of course you just have a phone.
00:35 You have a particular type of phone.
00:36 You might have a landline.
00:38 You might have a cellular.
00:39 You might have a satellite phone.
00:40 Well, each of those knows how to ring as well.
00:43 In fact, they have got their own custom ways of ringing.
00:46 Now when you get a phone call the person calling you doesn't necessarily know
00:50 what kind of phone you have; all they know is that you have got a phone.
00:54 When they make a phone call the system looks up your phone and tells your phone
00:57 to ring. And when the phone is told to ring it figures out what kind of phone
01:02 you have, and it tells that particular kind of phone to go ahead and do its
01:06 ringing. And this is the same kind of concept that we will do in object-oriented programming.
01:12 You will have a class, a subClass, and the baseClass, or the superClass, to use
01:18 object-oriented terminology,
01:20 will have some method in it, and you want to either completely replace the
01:24 logic that's in that method, or you want to augment it somehow.
01:29 You use overriding in order to do this.
01:31 Now there are three important things you have to understand.
01:34 There are three keywords in C#.
01:36 The first one is virtual.
01:38 The virtual keyword tells the compiler that it can be overridden.
01:43 The override keyword is another important one, and then there's the base keyword.
01:48 To use the overriding mechanism, there are three things you have to do.
01:51 First, you have to mark a method as being virtual.
01:55 This tells the compiler that this particular method can be overridden by derived classes.
02:00 If you're coming from other languages like JavaScript or C++, this may look
02:05 somewhat familiar, but it's a little bit different.
02:08 You have to specifically mark a function as being over overridable.
02:12 So here you can see I have got a function called myFunction.
02:14 It returns an integer. And I have got the public keyword in front of it, but I
02:19 have inserted the word virtual between the public and the return type.
02:24 This tells the compiler, hey, somebody might want to override this.
02:27 Now they don't have to, but they might want to.
02:29 To actually override the method, in the subClass, I tell the compiler that a
02:35 particular method is going to override the same method in the baseClass by using
02:39 the override keyword.
02:41 So in this case instead of virtual, I use override.
02:44 You can see I have done the same thing here: between the return type and the word
02:47 public, I've used the word override.
02:51 And these two go hand in hand when you want to override methods.
02:55 Then finally, there is the base keyword, and you can use this in your subClass to
02:59 call the baseClass's method. And you use this because you don't necessarily
03:04 always know what the name of the baseClass is.
03:07 Instead of you actually using the name of the baseClass, you simply say base, dot,
03:11 whatever the function is. And this will call into the code in the superClass
03:16 instead of your subClass.
03:18 Now there is a little bit complex.
03:21 It's probably helpful to see an example of this in action,
03:24 so let's jump over the code and see it work.
03:29 So here I am in my example.
03:31 This is for method overriding. And I am going to go over to my Snippets, and you
03:35 can see in my Snippets I have scrolled down to the Overriding Methods section.
03:39 The first thing I am going to do is copy over my class definitions.
03:42 I have two classes:
03:43 I have one that's a baseClass and I have one that is a subClass of that baseClass.
03:47 Let's go ahead and copy these over, and I will put these in my program definition here.
03:56 So now I am going to scroll back over here down a little bit. I'm going to copy this
04:02 code and put it into my program.
04:08 Before we run this, let's take a look at the class definitions, so we can
04:13 see what's going on.
04:16 In my baseClass, you can see here on line 10 I have got a function called
04:21 doSomething. And it doesn't return anything, so it's a void return type and it's
04:26 public. And I have declared it as a virtual method.
04:29 What that means is when I create a subClass that descends from this baseClass
04:34 the subClass has the opportunity, if it wants to, to override this method.
04:38 Now the baseClass method for doSomething just simply writes something out to the
04:42 console. It says, hey, this is the baseClass saying "hi."
04:44 Go down to the subClass. On line 18 you can see that I've got the same
04:49 method, doSomething.
04:51 In this case I've got the override keyword.
04:54 So this tells the compiler, hey, I'm overriding whatever the baseClass does.
04:59 In the doSomething method for the baseClass I am calling the baseClass's version
05:03 of doSomething, which will call the Console.WriteLine method. And then I can put
05:08 on whatever additional programming logic I want to.
05:12 I can do another Console.WriteLine.
05:14 I can put it before or after the baseClass call.
05:18 I can put it here if I want to.
05:19 I will just leave it there for now.
05:22 So let's go back down to the program. And you can see that what I am doing is I
05:25 am creating an object.
05:27 I have got a subClass object.
05:31 I have created a new subClass object called obj1, and I am going to call doSomething.
05:35 So let's see what happens when I run this.
05:39 Two things get written out:
05:41 "This is the baseClass saying hi!"
05:43 and "This is the subClass saying hi!"
05:45 So why did that happen?
05:46 Well, in obj1 we called doSomething.
05:48 obj1 is a subClass, so we will look in the subClass. And you can see that in
05:55 doSomething the first thing we do is call the baseClass's version of doSomething,
06:01 which will be this right here.
06:02 The baseClass saying hi!
06:04 gets called first, and then that returns and then the subClass gets called.
06:08 We can reverse that order.
06:10 We can cut this line and put it up here, and let's run it again, and now you can
06:14 see that the subClass says hi first instead of the baseClass.
06:18 Let's go back to the code.
06:19 We can actually just take this call out.
06:21 We don't have to call the baseClass if we don't want to.
06:23 Now we've completely replaced the functionality that the baseClass provides, and
06:28 we are only doing what the subClass says to do.
06:31 So we are going to save this and run it and now you can see that only the
06:34 subClass's version of that function is running; the baseClass's version is not
06:38 getting a chance to run. Hit Return.
06:41 Let's try something else.
06:44 Since subClass is a version of the baseClass object, I can do something like this.
06:52 I can say baseClass obj1 = new subClass.
07:00 Now that may seem strange at first, because wait a second. Shouldn't I be
07:03 creating a new subClass?
07:05 No, I'm actually going to create a baseClass object.
07:07 Let's see what happens here. Ah!
07:10 "This is the subClass saying hi!"
07:12 Why did that happen?
07:13 Why is it that when I created an object of type baseClass, or I gave it a
07:18 name of baseClass, and I created a new type of subClass, why did it not call
07:23 the baseClass's version? Why?
07:25 Because when you create a virtual function C# is actually going to look up what
07:29 the lowest descendent is and call that version of the function.
07:33 Since I actually created a new instance of subClass, even though I arranged it to
07:38 be assigned to a variable named baseClass type, it's still going to look down in
07:42 the functions and say, oh, you know what?
07:44 That subClass object is actually overriding this function,
07:46 so I am going to call that version instead.
07:48 Let's change this so that instead of creating a new subClass type, I am creating
07:53 a new baseClass type.
07:55 Now let's see what happens.
07:57 I am going to run it.
07:59 Now it's the baseClass's version saying hi. Why?
08:01 Because it's not a subClass anymore;
08:03 it's a baseClass now.
08:05 That's how you override methods.
08:07 You use the keyword "virtual" to indicate that a method can be overridden and then
08:12 use the "override" keyword to indicate that you are overriding it in a baseClass.
08:17 And you can use this to augment the functionality provided by baseClasses in
08:22 your own programs, as well as other programs that you might be adding on to.
08:26 It's a really great way of segmenting your program so that pieces of
08:31 functionality don't have to be changed in baseClasses in order to provide new
08:35 pieces of functionality in classes that derive from them.
Collapse this transcript
Creating abstract classes and methods
00:00 All right, in this section we are going to talk about abstract classes, and
00:04 abstract classes tend to be one of those subjects that trip people up who
00:06 are learning object-oriented programming for the first time, so I'll try to make this easy.
00:11 Essentially, an abstract class can't be instantiated by itself.
00:14 You have to create a subclass, and you have to instantiate that instead.
00:18 In other words you've got to derive a class from an abstract class and make
00:22 that class instead;
00:23 you can't instantiate an abstract class.
00:25 abstract classes have abstract members and these are members that have to be
00:30 overridden by subclasses in order to provide functionality.
00:34 So, okay, why would you do this?
00:36 Well, there are going to be times in programming where you define a class that
00:39 describes an abstract idea, but it doesn't make sense by itself.
00:43 It has to have an actual physical implementation, and that physical
00:46 implementation is going to change among different versions of that class.
00:50 And we'll take a closer look at that in a moment.
00:52 First, let's see how to actually describe an abstract class.
00:55 Abstract classes are indicated by putting the word abstract in the class definition.
01:00 So if I normally describe a class like this using public class, myClass, and then
01:06 declare the class normally like you see me do throughout the course,
01:09 what I would do here instead is put the word abstract inside the class definition.
01:13 That tells the compiler that this is an abstract class.
01:16 Then once I've done that, I can declare an abstract member function, like you see here.
01:22 Now I don't provide an implementation for this function here.
01:26 Remember, I'm forcing the subclass to do that.
01:29 The subclass has to provide an implementation.
01:33 So let's take a look at a real-world scenario where you would do something
01:38 with abstract classes.
01:39 Consider an example where you've got a car dealership or some kind of dealership
01:43 where you sell different types of vehicles.
01:46 Now vehicles, depending on what they are, have unique characteristics, but some of
01:51 them might be common among all different kinds of vehicles. For example, they
01:55 might have properties like what kind of fuels they use and what their licensing
01:59 code number is, right?
02:01 But you don't actually go down to the dealership to buy a vehicle.
02:05 What you do is you buy something like a motorcycle or a car or a truck or a boat.
02:10 These are real-world implementations of this abstract notion of a vehicle.
02:16 Even though they may all share some of the same characteristics, there is no
02:20 such thing as actually making a vehicle. So in this case if the vehicle, the
02:25 class you see in the dotted line there, is an abstract class and the classes you
02:29 see in the thick lines are real subclasses that derive from the vehicle
02:35 subclass, you could do something like this.
02:37 I could say class Car c = new Car. That works great.
02:41 It's a real class that derives from the abstract class.
02:44 What I can't do is this:
02:45 I can't actually instantiate the abstract class, because the rules of object-
02:51 oriented programming in C# is that abstract classes have to be derived from.
02:55 So I would have to instantiate one of the real classes, the motorcycle, the car,
02:58 the truck, the boat.
02:59 And I could add more real classes as time goes on.
03:03 So let's just go over to the code and see this in action.
03:06 Okay, I've got my abstract classes example opened.
03:11 Let's go over to the snippets.
03:13 You can see I've scrolled down to my Abstract Classes and Methods section. And I
03:16 am just going to copy these two class definitions and I am going to paste them
03:20 in my program over here.
03:23 So now I have my abstract class, which is myBaseClass, and in there you see I've
03:28 got my abstract method called myMethod.
03:31 And then if we scroll down a little bit, you'll see here starting on line 13,
03:34 I have a derived class which inherits from myBaseClass. And it overrides--again I
03:42 am using the word override here to override the abstract member function called
03:47 myMethod--and in this case it just takes two arguments and returns the sum of
03:51 those two arguments.
03:53 So if we go down into the Main function, I could do something like this.
03:57 I can say myDerivedClass = new myDerivedClass, and then I can say int result =.
04:09 Actually, I have to make it a variable there. I can say mdc.
04:15 and then I can call myMethod right here. And I'll just give it two numbers, 5 and 6.
04:23 And then we'll just write out the result there, and then we'll have the program
04:31 wait for us so we can see the results.
04:34 So let's save this, and let's run it.
04:36 And you can see that the results here is 11. Why? Because 5+6 equals 11.
04:42 So we can see that the real derived class from the abstract class provides
04:47 implementation and actually works.
04:49 Let's comment this code out so that we don't have to deal with any errors in it.
04:54 Okay, let's see what happens when we take the myMethod implementation out of
05:01 the derived class. I am just going to cut this code and save it, and now I am
05:05 going to hit F6 to build.
05:07 And you can see that we get an error.
05:09 There is little blue squiggle underneath myDerivedClass, and if you look down
05:13 here in the error list, it says "abstractClasses.myDerivedClass does not implement
05:19 inherited abstract member myMethod."
05:22 So you can see that because I declared myMethod to be an abstract method, I have
05:27 to override it in my base class.
05:30 So let's undo that. Put that back in, and the error goes away.
05:34 Let's try another little experiment. Let's do this.
05:37 Let's say myBaseClass mbc = new myBaseClass, and we'll save and we'll build, but another error.
05:49 What's the error this time?
05:50 It says, "Cannot create an instance of the abstract class or
05:55 interface myBaseClass."
05:57 Abstract classes, as you can see, cannot be instantiated by themselves, and this
06:01 is enforced by the C# compiler.
06:05 So let's go ahead and delete that code.
06:09 So abstract classes are a way of defining abstract ideas that group together
06:15 some common properties and functionality of real instances of that class,
06:21 but it's just abstract.
06:22 You can't actually instantiate that class.
06:24 That's a way for you to write your programs such that you can group together the
06:29 related pieces of functionality
06:30 but force people who want to use your classes to override them and make real
06:35 physical instances of them.
Collapse this transcript
Using sealed classes
00:00 The next somewhat advanced and somewhat esoteric subject we're going to look at
00:05 in advanced C# is sealed classes and methods.
00:08 Now sealed classes and methods are essentially the opposite of abstract classes.
00:13 Whereas abstract classes force you to derive a subclass in order to use them,
00:19 sealed classes actually prevent you from deriving from them.
00:22 So there is no way to make a subclass from a class that has been sealed.
00:27 It's also possible to mark individual methods in classes as being sealed, which
00:32 prevents them from being overwritten in some classes. But it is far more common
00:37 to seal entire classes than methods.
00:40 And the way that you create sealed class is by using the sealed keyword.
00:44 So if I define a class like this, I have a public class myClass.
00:47 If I wanted to seal this class, I'd just simply put the word sealed inside
00:51 myClass, and then at this point I can no longer create a subclass.
00:56 So before the sealed keyword was in there I can make my subclass off of myClass,
01:00 but now that the sealed keyword is in there, this is an error;
01:02 I can't derive from myClass anymore.
01:05 So let's actually see this in action.
01:07 I'm actually going to go over to my Snippets here in my SealedClasses example,
01:12 and I'm going to copy these lines of code right here, and I'll paste them in.
01:20 So here I have my class, and let me just take this guy out for a moment.
01:25 So I have a class called myExampleClass and I have my subclass which derives
01:31 from myExampleClass. And if I hit F6, you can see that everything works fine;
01:36 the Build succeeds.
01:37 Let's put the sealed keyword back in there. Save.
01:41 Now let's try to build. Oh!
01:42 We get an error, and it says that the subclass right here cannot derive from
01:47 sealed type myExampleClass.
01:50 So by sealing this class, I prevent any further subclasses from being created.
01:55 You'll do this when you create classes that you don't want people messing with.
01:59 It's not a particularly common thing that you'll see a lot of.
02:02 The .NET Framework does this in a couple of places where it doesn't want you
02:05 messing with things like the Math class or other things.
02:09 Basically, if you create a class where you want it to behave a certain way and
02:13 you don't want authors to be able to override methods in your class, you can
02:17 create a sealed class.
02:19 So pretty quick simple example of how you can create classes in C# that cannot
02:23 be derived from or sub-classed.
Collapse this transcript
Defining structs
00:00 If you're coming from a language such as C or C++, you're probably familiar with
00:05 the notion of a struct.
00:08 If you're not, don't worry about it. I'll explain it here.
00:10 But structs essentially are similar to classes, but there are some important
00:15 differences that you're going to find.
00:17 First, structs don't support inheritance.
00:19 When you define a struct you define its members and its data types and so on,
00:24 but you can't derive one struct from another.
00:28 Structs are also value types, while classes are reference types. And if you
00:32 haven't yet watched the movie where I explain the difference between value
00:35 types and reference types, you should probably go watch that, because it'll make a lot more sense.
00:40 You also can't initialize the fields of a struct inside the definition.
00:44 So, for example, when you have a member variable inside of a struct, you can't
00:49 put a little equal sign after it and initialize it to a value.
00:52 You have to do that outside the definition.
00:54 Structs are usually used when you just want some small and simple data
00:58 structure to represent some piece of information and you don't want all the
01:02 overhead of a class.
01:04 Now structs can have properties and methods just like a class can.
01:08 You just have to remember that they're not really classes.
01:10 You can't have inheritance.
01:12 There are all kinds of things you can't do.
01:14 So let's take a look at real example.
01:15 Suppose we wanted to define a data type for representing a point on a
01:20 two-dimensional surface.
01:21 Well, we could do that with a class.
01:23 We'd say public class Point and we would have an X coordinate and we would have a Y coordinate.
01:27 We could also have a constructive function.
01:31 So when someone said new point, they could pass in a value for the X and the Y,
01:36 and that would set the X coordinate and Y coordinate to whatever the values are.
01:39 We could also just simply declare this to be a struct, in which case it's not a
01:44 class anymore, but everything still works.
01:46 We've got member variables, we have a constructor function, and everything is fine.
01:51 So let's go jump over to the code and exercise this.
01:55 Right, here I'm in my structs example, and I've got my Snippets scrolled down to
01:59 the part on Defining Structs.
02:01 So over here in the code I'm going to just copy these lines right here.
02:05 I am going to copy this structure definition, copy that, and I want to paste it over here.
02:13 So now I've got my struct which defines a point, and it's got these two private
02:19 number variables for X coordinate and for the Y coordinate.
02:23 Then you can also see that just with the class, I've got my constructor
02:27 function for the Point, and I've also got a property for setting X and a
02:32 property for setting Y.
02:34 So let's go back over here and copy some code.
02:37 So the first thing I am going to copy is this one right here.
02:41 I'll scroll down to my main function and paste that in. And what I'm doing here
02:45 is I'm creating a point, and the variable name is p1, and I'm creating new point
02:50 with an X coordinate and a Y coordinate both equal to 100.
02:55 From the outside looking in, this doesn't look any different than creating a class.
02:59 It's so happens that this is a struct.
03:02 So let's go back, get some more code.
03:07 I can also do the same thing this way.
03:09 Point p2 is s new point, and then I can set p2.x to 50 and p2.y, and this will
03:16 invoke the getters and setters the same way that I'd with the class.
03:20 Let's go ahead and hit F6, and you can see that the Build succeeded.
03:25 So if we scroll back up, you notice that pretty much the only thing is
03:28 different here is that I'm using the keyword struct instead of using the keyword
03:32 class right there on line 8.
03:34 So then you are probably asking yourself, okay, well, why would I want to use a
03:36 struct versus using a class?
03:38 Well, the main reason is because you've got some small data type.
03:41 In this case, I've got a point which only contains really two properties that I
03:44 really care about setting.
03:45 So if you got something small and you don't want all the overhead of a class, or
03:50 you don't have to worry about things like inheritance and overwriting stuff,
03:54 you can define a struct.
03:55 You can also use a struct when you don't want to have to worry about things
03:58 being passed by value or passed by reference.
04:02 Again, I explained that earlier in the section on value types versus reference types.
04:07 Structs are value types,
04:08 so you can pass these around as value types, and the values will be copied, and
04:12 you don't have to worry about references being changed without you knowing about it.
04:15 So anyway, that's a quick lesson on using structs.
04:18 You'll find that in many cases if you're define a small data structure, you
04:22 can use a struct in places where you would normally use a class.
Collapse this transcript
Using interfaces
00:00 The last subject that we are going cover in this section on building some more
00:04 advanced classes in C# is using interfaces.
00:09 Interfaces are a really neat little feature of C#.
00:12 They essentially provide a way for grouping a set of common behaviors in a
00:18 single place where more than one class can use them.
00:22 Now an interface is sort of like a class, but it provides a specification, or
00:28 you might think of it as a contract, rather than an implementation.
00:33 You can think of interfaces as an alternative to using abstract classes.
00:40 One of the nice things about interfaces is that classes can implement
00:44 multiple interfaces.
00:46 Now C# doesn't have the notion of multiple inheritance, like some other
00:50 languages do, but classes in C# can implement multiple interfaces.
00:57 One of the best ways of thinking about interfaces as opposed to classes is that
01:00 classes tend to be things, whereas interfaces tend to be behaviors.
01:07 So what I can do is I can group a whole bunch of functionality into an interface
01:11 and then that sort of becomes a contract.
01:14 If my class says that it implements an interface, then that class has to go
01:20 ahead and providing implementations for all of the functions that the
01:23 interface contains.
01:25 The nice thing about that is that my class can then advertise to the world,
01:30 hey, these are the interfaces that I implement and then in code that use my
01:35 class, the code can check my class to say, hey, are you able to implement this kind of interface?
01:41 And if it is, then the code that's using my interface can just say, hey, I know
01:45 that you know how to do this,
01:47 so I'm going to go ahead and call that method.
01:49 So let's take a look at how using interfaces makes grouping behavior more easy
01:55 to understand and implement.
01:56 So let's imagine I had a few classes.
01:58 I've got class A, B, and C. Now let's imagine further that these classes
02:03 all knew how to do something, like save their data out to some persistent storage place.
02:10 Well, they could all just implement a function name SaveData.
02:15 The problem is, without some interface to enforce this, class A might call it
02:20 SaveData, class B might call it something else, class C might call it something
02:24 else, but by grouping the notion of saving data into an interface called
02:30 ISaveable--and interfaces don't have to begin with a capital letter I, but it's
02:35 a nice convention that Microsoft has come up with for interfaces;
02:38 That way when you see it in a class definition you know that it's an
02:42 interface rather than class.
02:43 If I said, hey, I'm going to make an interface called ISaveable and anybody who
02:48 implements the interface called ISaveable has to have a function in their class
02:52 somewhere that's called SaveData.
02:55 So then I could do something like this.
02:57 I could say, you know what? Each one my classes, class A, B, and C, all implement
03:01 an interface called ISaveable.
03:03 Well, that enforces what's called a code contract.
03:07 So now everybody has to name their function that saves the data the same
03:12 thing, because they're all implementing from the same interface.
03:16 Now if I wanted to go a step further and say, you know what, not only do my
03:19 objects know how to save their data, they also know how to do something like
03:23 compress their data,
03:25 well, I could implement an interface called IShrinkable. And inside IShrinkable,
03:30 I might have a function called CompressedData.
03:34 Now notice in the interface there's no implementation of this function.
03:38 All that the interface says is, hey, if you implement me, you've got to have a
03:42 function named this. And the implementation is actually saved for the classes that
03:47 choose to implement it.
03:48 So if classes A, B, and C decided to implement both the ISaveable and
03:54 IShrinkable interfaces-- you separate them with a comma--
03:58 well, now each one of these classes has to have a function named SaveData, and
04:03 they all have to have a function named CompressData as well.
04:06 Now if one of these classes decided not to have shrinkable or saved or whatever,
04:10 they could choose not to implement the function. But if you say that you
04:14 implement an interface, you have to implement the members of that interface.
04:19 So let's take a look at this working in real code.
04:22 So here in the code I've got my UsingInterfaces example open, and I've got my
04:27 ExampleSnippets open and scrolled down to the Interfaces section.
04:31 So let's go ahead and copy over this line of code right here and paste
04:37 it into my program.
04:39 Now to declare an interface, you use the word interface and then you give
04:44 your interface a name.
04:45 It's kind of like declaring a class, although you'll notice that inside my
04:48 interface definition, I am not providing any implementation for these methods.
04:52 I am just saying that this interface contains two functions: one is called
04:55 SayHello, one is called SayGoodBye. And anybody who chooses to say that
04:59 they support the ITalkative interface has to provide implications for those two methods.
05:06 So let's go back over to the Snippets, and let's copy over this example
05:09 class right here called myExampleClass, and we'll paste that into my program over here.
05:16 So now I've declared a class called myExampleClass, and it says, yes, I am using
05:22 the ITalkative interface.
05:24 So here's the constructor for myExampleClass starting on line 16. And you'll see
05:28 that on lines 20 and lines 25, I've got implementations for the SayHello and
05:34 SayGoodBye functions.
05:36 Let's watch what happens really quickly if I take these out.
05:39 So I am going to cut this and save it and then build using F6.
05:44 You will see that if I try to build this, I'm now getting an error, why?
05:47 Because the errors say, hey, my example class does not implement interface
05:51 members SayGoodBye and does not implement interface member ITalkative.SayHello.
05:57 Well, that's because my class claims to implement ITalkative, but it's not
06:02 actually doing that.
06:03 There's no implications for the SayHello and SayGoodBye functions.
06:06 So let me just go ahead and paste those back in and save, and then we will hit
06:10 Build again using F6, and now everything is fine.
06:14 So let's go ahead and exercise this code, and we'll do that by copying these
06:20 lines of code right here and we'll paste them in there.
06:26 So now in my Main function I am declaring a variable, myEC, which is of type of
06:33 myExampleClass, and I am using the new operator to create that object. And once
06:37 I've created that object, I can say, all right, well, since you are a
06:41 myExampleClass and myExampleClass implements the ITalkative interface, I know
06:47 that you've got functions called SayHello and SayGoodBye.
06:50 So I can call each one of those.
06:52 So let's build and run.
06:54 We are going to hit F5 here, and you can see that sure enough, when we run the
06:58 program the functions for SayHello and SayGoodBye get executed and produce their output.
07:05 Let's go back to the Program here.
07:07 So once again, interfaces are a way of grouping together common points of functionality.
07:14 The interfaces are not things.
07:16 You don't instantiate an interface necessarily, although in certain esoteric
07:21 circumstances you can do that in C#, but we are not going to get to that in this course.
07:25 It's a little bit advanced.
07:26 What you do here is you simply create a class that says, I implement this
07:30 interface. And if you find yourself building classes that all have similar
07:34 behavior, it's probably a sign that you might want to make an interface that
07:38 groups that behavior into a common place and then have each one of those classes
07:43 implement that interface.
07:45 That way you can be sure that they're all getting the same behavior and that the
07:48 consumers of your class know that
07:50 that behavior can be counted on.
Collapse this transcript
8. Exceptions
Understanding exceptions
00:00 At some point in your C# coding experience you're going to have to learn how to
00:04 deal with error conditions.
00:06 Yes, I know, shock of all shocks.
00:08 Sometimes your code isn't going to work the way you thought that it would, or
00:11 something is going to happen to cause a problem in your program.
00:15 The way that we deal with that in C# and .NET is through the use of
00:19 exceptions, and that's what we are going to see how to use in this
00:22 particular section.
00:24 An exception is basically an error that happens during your program's execution,
00:29 whether it's because the user put in some data value that you weren't expecting
00:34 or the system runs out of memory or something else that happens.
00:38 So let's take a look at an example of an exception, and then we will learn about
00:43 how to handle exceptions in your code.
00:47 Let's imagine I have two variables, x and y.
00:49 They're both integers and I declared them as you see here.
00:53 Then I declare another variable called result, and I divide x by y. Well,
00:57 dividing 10 by 5, that's okay.
00:59 The result is 2. But what happens if I set y to 0, and then I try to divide x by
01:05 y, and oh, that's a problem: I'm dividing by 0.
01:09 What happens here is the .NET Framework raises what's called an exception.
01:14 In this case, it's a DivideByZero exception, and we'll learn about these terms
01:19 a little bit later, but the point is that an exception, just generically,
01:23 speaking is a problem in the code or somewhere in the system that you have to
01:29 anticipate and handle.
01:31 So before we go any further, let's learn about some exception terminology.
01:36 Exceptions are raised--or using object-oriented nomenclature,
01:42 they are thrown--when an error is encountered. When an exception happens the
01:48 normal flow of the program is interrupted, and the control is transferred to the
01:55 nearest exception handler.
01:57 You might say that the handler catches the exception.
01:59 So, the exception is thrown somewhere, and then it is caught somewhere else.
02:05 Now if there is no exception handler to process that exception and the exception
02:11 happens to be a fatal one, then the program just terminates with an error code.
02:16 Now not all exceptions are fatal, but some of them are and if the exception that
02:20 gets raised is fatal, then your program is going to stop working.
02:24 Now, exceptions don't just come from the .NET Framework.
02:27 You can build your own exceptions and then raise them yourself.
02:31 In other words, you throw your own exceptions using the throw instruction, and we
02:36 will see how to do that.
02:38 Let's take a look at an example of how exceptions are handled in code.
02:43 Now there are three main keywords you're going to have to learn about when
02:47 you're working with exceptions.
02:49 The first one is try.
02:51 Code that is placed inside the try block. Inside those curly braces is a bunch
02:57 of code that attempts to do something.
02:59 It doesn't matter how many lines you have in there. It could be one, it could five,
03:02 it could be 25,000; it doesn't matter.
03:04 The point is that inside that try block you're going to do a whole bunch of code.
03:08 You're going to assign a catch block.
03:12 Now this is actually optional, but you assign a catch block where you think an
03:16 exception might happen.
03:18 So if the code inside the try block might cause a problem then you assign a
03:22 catch block, and this is where exceptions are handled.
03:25 So if something goes wrong inside the code that's inside the try then the code
03:29 that's inside the catch is going to happen.
03:31 Then last, there is finally keyword.
03:34 And this code is always run.
03:36 It doesn't matter if things were great or things were bad,
03:39 if the code in the try section is completely just fine or if there was a problem
03:43 and the code in the catch section had to run, the code in the finally section is
03:47 always going to run.
03:49 So let's take a look at an example.
03:50 Suppose we had our example from earlier.
03:53 We have those two integers, one is 10, one is 0, and we have the result.
03:57 Well, if we try to divide x by y-- in this case we got 10 divide by 0--
04:01 that's going to cause an exception, in which case the program flow will be
04:06 transferred to the catch block. And here we are going to just write out, hey,
04:11 look at error happened, and we do a whole bunch of things in here. In
04:14 this case, we are writing out an error message, but there is other code that we
04:17 could've written here to try to handle the exception.
04:19 Maybe we could ask the user to try putting a different value, or we can just
04:22 try something else.
04:24 The point is that the code in the catch block is going run when the problem happens.
04:28 So let's take a look at some real code to see how to write this.
04:31 So I am in my UsingExceptions example, and in my Snippets you see I've scrolled
04:38 down to the Exceptions section.
04:41 So let me copy the setup code, and we'll paste it here into main. And we'll go
04:49 back to the sample, and we'll scroll down a little bit, and we'll take this entire
04:54 piece of try, catch, and finally, and we will paste that in as well.
05:01 So what I've done here is I've defined three different blocks of code:
05:05 one is called try, one is called catch, one is called finally.
05:09 Now if I run this code in its current state, I've got 10 being divided by 5
05:15 on line 18 right here, and that should just be fine.
05:19 What should happen is the Console.WriteLine for The result is, is going to be
05:23 executed, and it will show me the result.
05:24 So let's go ahead and run this and see what happens. And you can see that the
05:28 result is 2, and you can also see that a line is being written out there that
05:31 says, "Just proving that this code always runs."
05:34 And if we go back to the code, you'll see that
05:35 that's in the finally section down here.
05:37 Remember earlier I said that the code in the finally section always gets run;
05:41 it doesn't matter what happens in the try or the catch block.
05:44 So now let's change the code so that we have an error happen. So let's do this.
05:48 We are going to change y to 0.
05:51 So now we are going to 10 divided by 0, and that's going to cause a problem.
05:56 So we are going to get to line 18.
05:57 We are going to try to divide 10 by 0, and an exception is going to happen.
06:01 What that means that the code at line 19, this Console.WriteLine statement, is
06:06 never going to get run.
06:08 What's going to happen is the code is going to be transferred, the program flow
06:12 is going to be interrupted, and we are going to jump down here into this catch
06:15 block where this line of code, the An error occurred!
06:19 Better check the code line, is going to be run.
06:21 So now let's try this.
06:24 You can see that what happened was we tried to divide 10 by 0, which is a math
06:28 error, and you can see the Console. WriteLine inside the catch block is writing
06:33 out An error occurred!
06:34 Better check the code. And also we can see that the code in the finally block
06:39 always runs, because that Console.WriteLine also got executed.
06:44 So that's a quick introduction on how to use exceptions and as we move through
06:47 the rest of this section, we will learn more about how to create our own
06:51 exceptions and work with exceptions in a more advanced fashion.
Collapse this transcript
Introducing the Exception object
00:00 Exceptions are in fact objects, and in fact the exception object is defined and
00:06 derived from System.Exception.
00:09 That is the base class for all the exception objects in .NET. And the .NET
00:14 Framework actually defines a pretty large number of exception classes.
00:19 For proof of that, let's just quickly jump over to the MSDN web site and you can
00:22 see what I am talking about.
00:24 This is the Exception Class definition here on msdn.microsoft.com. And if you do
00:30 a search for System.Exception or if you go to the URL up there in the URL bar,
00:34 you'll see the exception class.
00:35 Now as we scroll down a little bit, you'll see that just like other objects,
00:40 there are constructors.
00:42 In this case, we've got four different constructors and there are some properties.
00:47 So these are the properties that exceptions make available.
00:50 There's Data and HelpLink and Message, and we'll explore some on these later on
00:53 as we through the exceptions, but what I really want to point out is as we
00:56 scroll all the way down, you'll see that System.Exception is the base class for a
01:02 pretty large number of exceptions throughout .NET.
01:05 Look at how large this list is.
01:07 This isn't even a complete list.
01:08 This is a list of a lot of the exceptions that descend directly from
01:12 System.Exception, but the one that we're most interested in is right here,
01:17 System.ApplicationException.
01:19 This is probably one of the most common exceptions that you will come in contact
01:23 with as a C# developer. And in fact, I've opened that window right over here.
01:28 So this is the ApplicationException class, and this class encapsulates all the
01:33 exceptions that are thrown when non-fatal application errors happen.
01:38 So once again, we can scroll down.
01:41 You can see that there is Properties, and there are all kinds of ways you can
01:44 create application exceptions. But once again we get down to the Instance
01:48 Hierarchy or the Inheritance Hierarchy.
01:50 You can see that a lot of other exceptions happen to descend from
01:54 ApplicationException. And this is true throughout .NET.
01:57 You've got exceptions that are descendents of other exceptions. And you might be
02:02 wondering, well, with all these different types of exceptions is it possible to
02:07 write catch handlers that only catch certain kinds of exceptions?
02:12 So to catch specific exceptions, you can put inside parentheses for each one of
02:16 the catch handlers the kind of exception that you're looking for.
02:20 So in the case that you see here, I've got a try block where I'm going to try a
02:25 whole bunch of code and then I have several catch handlers all in a row.
02:29 So I've got a catch handler for an exception that's DivideByZero.
02:32 I've got a catch handler for ArithmeticException.
02:34 I've got a catch handler in case we run OutOfMemory.
02:37 There are all kinds of stuff that I can put here, and I can put a generic catch
02:41 at the bottom of all these too that catches exceptions that don't get caught by these.
02:45 So let's jump over to the code and see how we can handle catching specific
02:50 types of exceptions.
02:51 So here we are in the example.
02:52 This is the ExceptionObject example.
02:54 I've got my program file open, and down in the Snippets I scroll to the
02:57 Exception Object section.
02:59 So let's go ahead and copy the set of code, and we'll paste that it into Main.
03:04 All right, now let's copy the try and catch, all the way down to the finally,
03:10 okay, and we'll paste that in.
03:13 You know what? Since we already know that the finally always runs, I am just
03:17 going to comment this line out.
03:18 We don't really need it for this example.
03:20 So let's comment it out.
03:22 All right, so this is pretty much the same example as I showed previously.
03:26 We've got two numbers.
03:27 We've got x here which is 10.
03:28 We've got y which is 0.
03:30 We have an integer for holding the result. And you can see here that we are
03:33 going to try to divide by zero.
03:35 The only difference from the previous example is that here I am now catching a
03:39 DivideByZeroException, and this is an arithmetic exception. And since I know that
03:46 it's a DivideByZeroException I can say, hey, you tried to divide by zero.
03:52 I can also write out members of the exception object that's passed in.
03:57 So when you catch a specific exception, you get an argument;
04:00 in this case I've named it e, but you can name it whatever you want to.
04:03 This will be passed into your catch handler, and this is the exception object
04:07 that caused the exception.
04:09 So we can do things like introspect that object and see things like what the
04:13 message that goes along with it is and so on and so forth.
04:16 So let's save this and let's build. Build succeeded.
04:20 All right, let's go ahead and run it and try to divide by 0 and see what happens.
04:24 Sure enough, you can see that You try to divide by zero.
04:27 Now that first sentence there, "Whoops!
04:28 You tried to divide by zero!"
04:30 is what I'm writing out, and the "Attempted to divide by zero!"
04:33 string is being written out from the message property of the exception object.
04:38 All right, let's go back to the code, and let's try something else.
04:43 Let's copy this catch handler and paste it down here.
04:47 Now what I am going to do is instead of looking for a
04:51 System.DivideByZeroException, I'm going to look for an ArithmeticException.
04:55 So I am going to hit dot and scroll down here, and I've got an
05:01 ArithmeticException right here.
05:03 So now I'm going to save, and I am going to build, and you can see that the build
05:08 succeeded. And what I am going to do is run this.
05:13 Now because I have the DivideByZero handler already in place, that's the first
05:17 one it's going to jump to.
05:19 The exception is going to jump to the first catch handler that makes the most sense.
05:22 So even though this is an ArithmeticException, it's going to jump to the
05:26 DivideByZero version, because that's more specific to the kind of exception I am seeing.
05:31 Let's try something else.
05:33 Let's take the ArithmeticException and cut it and put it in front of the
05:37 DivideByZeroException.
05:39 Now you'll notice that when I do that I get a little red squiggle on the
05:41 DivideByZeroException.
05:44 Let's see what that error is saying. It says, "Error:
05:48 A previous catch clause already catches all exceptions of this or of a super type."
05:54 What this basically means is because DivideByZeroException is a subclass of the
06:01 ArithmeticException object, this is never going to be called.
06:05 What's going to happen is a DivideByZeroException is going be thrown, but since
06:10 it's a subclass of this guy right here, this catch block is going to catch all
06:15 the math problems that might come up, including DivideByZero. And since it
06:20 occurs first, this code will never get executed.
06:23 So the C# compiler is catching that situation for me and saying, hey, you sure
06:28 you want to do this?
06:29 Why would you put in a catch handler that's never going to be called? So let's do this.
06:33 Let's take that WriteLine out, cut that line.
06:36 Let's put that in there instead. Let's see what the message is for
06:39 ArithmeticException, and let's just take out the DivideByZeroException.
06:43 So now I am catching the more general case.
06:46 I'm catching the ArithmeticException now, not just specifically the
06:49 DivideByZero, although DivideByZero is an ArithmeticException.
06:54 So let's run this, and you can see that we're getting the same message in this case.
06:58 So even though we got an ArithmeticException, it knows specifically what
07:01 happened, and the message in this case is an "Attempted to divide by zero."
07:05 So by using the ExceptionObject, your code can look for and catch specific
07:10 exceptions. And if you don't want to catch a specific exception, you can use the
07:15 catch handler. That just catches any exception that comes its way.
07:19 This is way for your code to be on the lookout for specific kinds of exceptions
07:23 so that it can take corrective action and try to prevent the user from having a
07:26 bad experience while using a program.
Collapse this transcript
Creating your own exceptions
00:00 Now I mentioned earlier that exceptions don't just simply come from .NET;
00:04 you can create your own custom exceptions--and in this movie we are going to
00:08 see how to do that.
00:09 Essentially, by sub-classing the exception object from the system namespace you
00:15 can create your own exceptions.
00:17 And then when you're ready to raise an exception, you use the throw instruction.
00:22 So for example, you can do things like throw a new System.Exception, or you can
00:27 throw a new MyCustomException.
00:28 You have to have the new in there because you've got to create the exception object
00:33 that you are going to throw, and then the throw keyword will cause the exception
00:36 to be thrown, and then the catch mechanism will go into effect.
00:41 So let's go over to some live code to see how we define our own exceptions and
00:45 then throw and catch them.
00:47 So I have my Custom Exceptions example here, and here is my Snippets. I've
00:51 scrolled down so they are creating exceptions section.
00:54 What I am going to first is just scroll down here and I am going to copy some of
00:58 the setup code, copy this, and I am going to paste this in my program. And then
01:05 I'm going to go back and I am going to ignore the catch section for a moment;
01:08 I'm just going to get the finally section, put that in here.
01:12 Now one of the first things you realize is that you don't actually need to have
01:16 a catch section at all.
01:17 You can just have try and finally if you want to.
01:20 So what I've got here is some code. I've got a string variable called the name,
01:24 and then in my try block I've got a function called getName.
01:28 Well, actually, I haven't defined it yet. That's why there is a little squiggle there.
01:31 But the getName function is going to ask the user to input a name, and it's
01:35 going to return it in the form of a string. And then I've got code on line 17
01:40 which simply writes out "Hello" and then whatever the name that you put in. And
01:44 then in the finally block, which remember always runs, we have a string that says, "Have a nice day!"
01:48 So let's go back to the snippets and get that getName function. And what I am
01:53 going to do is get this right here, copy that, and I am going to paste that
01:59 function in right up here. And for the moment I am going to just take this part out of it.
02:05 So what we are going to do in getName is use the Console.ReadLine function to
02:10 read a string, and then we are going to return that string.
02:14 So let's go ahead and run the code that we have and see how well it works.
02:18 So I am going to just build. It ran.
02:21 So now it's waiting for me to enter a name, and I am just going to type in the name scott.
02:26 It says, "Hello scott. Have a nice day!"
02:27 Great, okay everything is working fine.
02:29 Let's suppose we wanted to catch a certain name though and have that cause an exception.
02:35 So let's go back to the getName function, and what we are going to do is we are
02:41 going to say you know, if the string that was entered equals Joe, we're not going
02:45 to allow the word Joe to be put in.
02:47 So we are going to throw an exception called the NoJoesException.
02:50 Now we have to define the NoJoesException, which you see right here on line 14.
02:56 So let's go back to the Snippets and scroll up.
03:00 Here we have our definition for the NoJoesException.
03:03 Let's copy that, and we'll paste it in. And it's a class,
03:07 so I am going to paste it outside my program class.
03:10 So you can see on line 8, I've got a definition here for public class
03:14 NoJoesException, and there's the colon, which means it inherits from the exception
03:19 class, which is contained in the system namespace.
03:22 And remember, since I'm using the system namespace up here, I don't have to write
03:26 out System.Exception.
03:27 I can just use the word exception here.
03:29 So inside my NoJoesException, I've got my constructor, and my constructor is a
03:34 public NoJoesException constructor. And what I'm doing here is I'm calling the
03:40 base exception constructor with a string.
03:44 So before I go any further, let's just jump back over to the MSDN documentation
03:48 to see what the system exception looks like.
03:52 So here we are, in the documentation for the exception class.
03:55 Let's scroll down, and you can see that there are four different ways I can
03:59 construct an exception class.
04:02 There is a constructor that takes no arguments.
04:05 There is a constructor that takes an argument that's a string, and it says
04:08 here, "Initializes a new instance of the exception class where they specified error message."
04:14 Well, that sounds pretty much like the one I want. Let's just make sure.
04:18 Next one is exception with serialization and info and streaming context,
04:22 whatever that is, because it's obviously wrong.
04:24 And there's the exception here with a specified error message and a reference to
04:28 the inner exception. Okay, that's pretty advanced. I am not going to use that one.
04:32 Looks like number two is the one I want.
04:34 So I have to initialize a new instance of the exception class with the
04:37 specified error message.
04:39 Okay, that sounds great. Let's go back to the code.
04:41 Well, the way that I do that in C#--
04:43 well, there is a couple of ways I can do it.
04:45 First, I am just going to call the base-level constructor with the string here.
04:49 Now you might be wondering, why am I not just simply inside my constructor doing
04:53 something like this?
04:54 this.Message = No Joes allowed.
05:00 I am going to save that and I am going to build. Wait, we've got an error.
05:04 It says, "Property or indexer System.Exception. Message cannot be assigned to--it is read only."
05:10 Oh! So I can't actually make an assignment to that.
05:13 Looks like the only way to do it in this case is through the constructor. Okay,
05:17 well, I guess I won't do that then.
05:20 So it looks like this base method is the only way to do that.
05:22 So I'm passing in an error message to initialize the exception with "We don't
05:25 allow No Joes in here!"
05:27 However, I can give the user some help . And there is a field, or a property in
05:33 this case, called HelpLink. Again let's just jump over to the documentation very quick.
05:38 So if we scroll down, you'll see there is a property called HelpLink, and it
05:42 says, "Gets or sets a link to the help file associated with this exception." Oh cool!
05:48 Okay, so I can tell the user what to do in case an exception like this happens.
05:53 Let's go back to the code.
05:55 So what I am going to do is initialize my HelpLink here on line 13 to be a
05:59 link to my web site.
06:01 So back down here in the program--let me close this error window so we have more space--
06:06 you can see that when we get the input from the user, we are going to see if the
06:11 string is equal to Joe and if it is, we are going to throw the NoJoesException.
06:16 Now there's one more thing we have to do:
06:18 we have to implement the catch block for the NoJoesException. So let's go back
06:21 to the code, and down here in the Snippets we've got my catch handler.
06:26 I am going to copy that,
06:28 go back over here, and in between try and the finally, I am going to paste that in.
06:31 So you can see here what I am doing is I'm going to catch specifically a
06:36 NoJoesException, and I've named the variable nje.
06:40 So what I am going to do is write out the message, which is what I initialized
06:44 it with up in the constructor, and then another line I am going to write out "For
06:48 help, visit," and then I am going to write out the HelpLink field that's in my NoJoesException.
06:52 All right, it looks like everything is ready to go.
06:57 Let's hit F6. Okay, the build succeeded.
06:59 Let's hit F5 to run it.
07:01 All right, so I am going to type in "scott," "Hello scott Have a nice day!"
07:06 That seems to work okay.
07:07 Let's try it one more time with Joe. Oh!
07:10 Now, we get an error. It says "We don't allow no Joes in here! For help, visit:"
07:14 and then use the help link that I put into my help message for the user.
07:19 And of course in the finally block it says, "Have a nice day!"
07:22 All right, so this is how you can create your own exceptions, throw your own
07:26 exceptions, and use some of the fields provided by the base system exception
07:31 object to give your users some help and some detailed messages for when
07:34 those errors occur.
Collapse this transcript
Re-throwing exceptions
00:00 The last subject that we're going to examine in the area of exceptions is
00:05 that of rethrowing exceptions. And what that means is when an exception happens
00:10 inside your catch handler, you can do some processing, but if you handle the
00:15 exception, the exception pretty much stops with you.
00:18 You can keep it going by throwing it again, or hence the term 'rethrowing' the exception.
00:24 Now, why would you want to do this?
00:25 Let's take a look at an example, and hopefully that will make it a little bit more clear.
00:29 So here in my RethrowingExceptions example what I am going to do is go to my
00:32 Snippets and I am going to copy some code in over here.
00:37 So first, I am going to start with these lines down here, and I am going to copy
00:41 those and paste them into my Main function.
00:46 So I've got some code that calls a function called DoSomeMath, and it catches an
00:53 ArithmeticException and writes out a message that says hey!
00:56 Look, something went wrong in there.
00:58 You might want to be careful, or something like that. All right!
01:00 Now let's go back to the Snippets.
01:04 Let's copy the DoSomeMath function. All right and that's going to go up here.
01:11 So starting here on line 10 I've got my DoSomeMath function, and this is the
01:16 example that we've been working with up until now.
01:18 So what DoSomeMath is going to do is the same thing we've seen up until now,
01:22 which is try to divide by 0.
01:24 So here I've got my two variables on line 12.
01:26 I've got my result on line 13.
01:27 Here on line 15 I've got my try block, and I am going to try to divide 10 by 0.
01:33 Now, of course, what's going to happen is that's going to cause an exception.
01:37 So the catch handler will execute here, and I will write out something like hey!
01:43 You know, there is an error in DoSomeMath.
01:45 But I don't want the exception to just die here with me;
01:48 I want the exception to continue on and have other exception handlers do their
01:54 thing, because there might be some additional work that needs to be done.
01:58 So inside my catch handler, I am going to throw a new ArithmeticException.
02:04 Now, if I want to just rethrow the same exception, I wouldn't do this.
02:07 What I would do is I would just simply do this;
02:09 I would take out this new and just say throw.
02:12 What that means is, take the same exception that I am currently handling and
02:16 just rethrow it again. And that would be the same exception objects. Things
02:21 would just continue on as they were, and my catch handler would just be one and
02:25 a line of catch handlers.
02:27 But what I am going to do here is--let me put that code back in--I am actually
02:30 going to throw an entirely new exception called an ArithmeticException, because
02:35 remember, what I am catching here is a divide-by-0 exception.
02:38 So let's go ahead and save, and I am going to run this.
02:41 So you can see that what happened here is both catch handlers executed.
02:46 There's the catch handler inside the DoSomeMath function, and then there was the
02:51 catch handler that was in my Main program.
02:54 So let's go back and take a look.
02:57 You can see that this catch handler executed and this catch handler executed.
03:02 If I didn't have this line of code in here--and let me just comment it out, now
03:07 let's try rerunning it again--
03:09 you can see that in that case, only my catch handler executed.
03:12 So the other catch handler doesn't get a chance to run. The exception just gets
03:17 handled and dies in the DoSomeMath function and doesn't get a chance to continue on.
03:22 So by rethrowing the exception, or in this case throwing the new one, we give the
03:27 other exception handler a chance to do its stuff.
03:30 So why would you do this?
03:31 Well, suppose you've got an exception handler whose job is to just log out
03:36 whenever a particular exception happens.
03:39 You don't want that catch handler to be the be-all and the end-all.
03:42 You just want to insert it in the handling process so that that way your log
03:46 file shows that an exception happened. And then once that exception handler is
03:49 done logging out whatever information it needs to log out, it can continue on and
03:54 rethrow that exception so that the other real exception handlers in the process
03:59 somewhere get a chance to do their work.
04:01 So let's take a look at what happens when I take out the new ArithmeticException.
04:07 And I am not going to change the catch section right here.
04:10 I am just going to leave it alone.
04:11 So I am going to run it, and you can see that now both catch handlers are being
04:15 handled again. And because a divide by 0 is an ArithmeticException, the other
04:21 exception handler is being executed.
04:23 So this is a really great way to segment out your catch handlers so that each one
04:28 does its own little piece of work and they don't interfere with each other and
04:32 they are able to pass the exception on down the chain so that all the exception
04:36 handlers have the chance to do whatever it is that they need to do.
04:39 Just make sure that the last exception handler in the line is the last exception
04:43 handler in the line.
04:44 It doesn't pass the error up through to the user.
04:47 At some point, the error needs to be handled and not shown to the user--well, at
04:51 least in most cases.
04:52 So you're going to want to make sure that at least one of your catch handlers is
04:55 where the exception eventually stops.
Collapse this transcript
9. File Management
Introducing streams and files
00:00 We've reached the point now where we've seen enough C# to start doing some real
00:04 stuff, and one of the more common "real stuffs" that you'll probably do when
00:09 working with C# is moving information into and out of files. And the .NET
00:14 Framework provides some really great utilities for working with files and
00:17 information in files, and that's what we're going to cover in this section.
00:21 We're going to start off with an introduction to streams and files.
00:26 So let's start talking about that right off.
00:28 When you want to move the data into or out of a file or across the network or
00:32 over the Internet or some block of memory or some other location, the data has
00:38 to be what's called streamed.
00:40 You can think of a stream as an analogue to its real-world counterpart.
00:44 Think of water moving between two bodies of water in the form of a stream
00:50 or river or whatever.
00:51 In this case, however, the stream data is a bunch of 1s and 0s that represent
00:57 the information of a file, and the body of water is called the backing store.
01:03 Now the backing store can be anything. It can be a file.
01:06 It can be someplace on the network.
01:10 It can be some place out over the Internet;
01:12 it doesn't really matter what it is.
01:13 The point is the backing store is where the information goes to or comes from.
01:19 Streams have certain properties:
01:20 they can be readable, they can be writable, or they can be both.
01:25 Streams can also be what's called seekable.
01:28 In other words, some kinds of streams have this notion where there is a position
01:32 that you can look at and modify.
01:35 Sometimes this is called a random access stream.
01:38 Streams descend from the System.IO.Stream abstract base class.
01:45 Now we're not going to work too deeply with streams themselves in this section;
01:49 we're going to stick to the higher-level classes and utilities for working with files.
01:53 But it's important to have an understanding of what they are, and it's useful to
01:57 have this background so that later on, when you want to go and work a little bit
02:00 more deeply with files, you'll understand what a stream is.
02:03 So at the top, we have the stream class and again, this is an abstract
02:06 base class. And we looked at abstract base classes a little bit earlier in the course;
02:10 if you haven't watched that section, you should go do that now.
02:13 This is a class that forces you to create a subclass in order to provide an implementation.
02:19 So these stream abstract base class provides a whole bunch of abstract, or
02:23 theoretical, things that streams need to be able to do, and then the real stream
02:27 classes you work with descend from streams, such as the FileStream.
02:31 This is a class for working with physical files on the disk.
02:35 There is also the MemoryStream, which is locations located somewhere in
02:39 the computer's memory.
02:40 There is the NetworkStream.
02:42 This is used to move information across the network.
02:45 So actually, let's take a quick look over at MSDN so you can see what the stream
02:49 base class looks like.
02:50 All right, so this is the stream class documentation here on msdn.microsoft.com.
02:55 You can see the URL up there in the browser if you want to go and look at it for yourself.
03:00 The stream class--let's just scroll through this--
03:02 you can see that there's a constructor which makes a new stream, and there
03:06 are some properties, things like CanRead, and CanSeek, CanTimeout, CanWrite,
03:10 that kind of thing.
03:11 And if we scroll down a little bit further, there are methods,
03:14 methods for reading and writing information, for copying information, so on and so forth.
03:18 These are all the base-level functionality features that a stream has to
03:23 provide to its users.
03:24 Now remember, this is an abstract base class, so you won't actually instantiate a stream class;
03:30 what you'll use is one of the subclasses. And if you continue scroll down,
03:34 you'll see that underneath the System IO Stream, there is a whole bunch of other streams.
03:38 There's BufferedStream, there is FileStream, there is MemoryStream, and here is
03:42 the NetworkStream I talked about earlier.
03:43 These are the actual stream classes that you will use.
03:46 But we're not going to cover that right now;
03:48 what I'm going to do is talk about the file and directory higher-level classes
03:52 that we're going to use in this section.
03:55 .NET provides a collection of useful classes for working with files and
04:00 directories, so let's go over those right now.
04:03 One is called the File class, and this provides a very simplified high-level set
04:07 of functions for working with files.
04:09 In fact, this is mostly a static class where you call the methods of this class
04:14 using the file.notation. And if you haven't watched the section on classes, you
04:19 should go do that to understand what a static class is.
04:22 So file is probably the highest level example of working with files.
04:26 The next one down is the FileInfo class.
04:28 This provides more detailed lower-level functions that provide a little bit more
04:32 control over working with files.
04:34 Then there is the FileStream class, which I briefly talked about just a few moments ago.
04:38 This exposes a stream object around a file, which provides very detailed
04:42 control over how information gets written to and read from the file.
04:47 For directories, there is a sirectory class and this is sort of the analogue to
04:51 the file class. It provides very simple high-level functions for working with
04:55 directories, or folders. And then there's the DirectoryInfo class which provides
04:59 some more detailed lower-level functions that provide a bit more control over
05:04 working with directories.
05:05 So we're going to use some of these classes in the rest of the section to work
05:08 with files and directories.
Collapse this transcript
Working with existing files
00:00 Let's begin with something simple.
00:01 We are going to see how to work with existing files.
00:04 Now, the file class provides some features for working with files. And as I
00:08 mentioned earlier, most of the methods in this class are static.
00:11 You call them directly on the file object. And if you're not familiar with
00:15 static classes, you should go back and watch the section on classes to find out
00:19 what a static class is.
00:21 So the file object provides some really simple functions.
00:24 I am going to go over some of them here, not all of them, because it's quite a few.
00:27 But, for example, there is an exists method that checks to see if a file at a
00:31 given path exists or not and if a file does not exist, you can call a method
00:36 called create, which, surprisingly, creates the file at the specified path.
00:40 There are also functions for copying and moving and deleting files.
00:45 There is File.Copy, which copies a file to another location.
00:48 There is a Move function, which as the name indicates, moves a file, and there is a
00:53 delete function which deletes a file at a specified path.
00:57 So let's jump over to the code and exercise some of these functions and see how they work.
01:02 Okay, so I'm here in my existing project with my program file open, and here is
01:09 my Snippets. And I've scrolled down to the Existing Files section.
01:13 So let's begin by just checking to see if a file exists. And what I am going
01:18 to do is use a couple of other utilities to get a path to a special location
01:24 here on my computer.
01:25 So we're going be working with files in the My Documents folder, and I am going
01:29 to copy these first few lines right here.
01:34 So let's take a quick review of these lines of code before we do anything else.
01:38 So the first few lines, I have a Boolean variable called fileExists and I
01:42 initialize it to false because we are going to assume that the file doesn't exist.
01:46 Then we need to build up a file path, and the path just basically specifies where
01:51 on the computer the file exists or not.
01:54 So here I am going to say I have string called the path, and I am going to use a
01:59 special .NET class called the environment class.
02:03 The environment class gives me some utilities for working with the
02:06 Windows environment.
02:08 So I am going to ask the environment to get me a folder path, and the
02:11 GetFolderPath function can take a couple of different arguments.
02:14 I'm going to use the Environment.SpecialFolder.MyDocuments property, and this
02:20 will get me a path to the My Documents folder on this computer.
02:25 Now I could have just hard coded this by typing in C:\users\Joe Marini, so on and so forth.
02:33 That's really not a very good practice.
02:35 You don't want to hard code things into your applications if you can avoid it.
02:39 And windows, and in this case .NET, provides a bunch of utilities for working with
02:43 special document folders. Not just My Documents, but things like the temporary
02:47 directory and the trash or the recycle bin, that kind of thing.
02:51 So I am using this environment class right here to get the path to the My Documents folder.
02:56 So once I have the path to the My Documents folder, I'm then going to add on to
03:03 the end this string right here, which is testfile.txt. And recall I put the @
03:10 sign at the front of the string to prevent this \t here from being treated as a tab character.
03:17 I want the backlash to be treated as a path separator.
03:21 So at the end of all this I'll have a full path to a file named testfile.txt.
03:26 All right, let's go bring up my, My Documents folder, so
03:29 you can see what's in it.
03:31 Okay this is the My Documents folder, and you can see that right now there is
03:34 no file named test file.txt in here, so we're going to create it if it doesn't exist.
03:39 Let's go back to code.
03:41 We start off by using the File.Exists function here on line 17.
03:46 So we call File.Exists. That returns a Boolean result indicating whether the file
03:50 exists. And then I have an if statement and my if statement says if the file
03:55 exists. Then just write out to the console that the file exists.
03:59 Otherwise write out that the file does not exist and we are going to create it.
04:02 Then we call the File.Create function with the path, and this will create the file for us.
04:08 So let's go ahead and see what happens when we build and run this.
04:13 The code compiles and runs, and you can see that we're getting a message out to
04:16 the console that says, "The file does not exist. creating it."
04:19 So let's go back for our My Documents folder, and you can see now that the
04:23 test file has been created. And in this case, I am hiding known file extensions, so
04:29 you don't see that.txt on the end there, but it is there.
04:32 Okay, so test file has now been created. Let's go back and do some more work with it.
04:37 Let's go back to Snippets, and we'll copy this over, copy, and we'll paste this in.
04:52 Okay, so I am going to comment out these last two lines, just for a moment.
04:57 So once we've determined that the file exists, we can then get some
05:00 information about it.
05:01 In this particular section of code here I'm saying if the file exists then let's
05:06 figure out when it was created. And we are going to use the Files.GetCreationTime
05:11 method and the GetLastAccessTime method for the file, and we passed in the file
05:17 path both times to get information about the file.
05:20 And this will tell us when the file was created and when it was last accessed.
05:23 Okay, so now when I run the program again the file already exists,
05:28 so this part of the If statement should execute and we shouldn't have to re-create it.
05:32 So I am going to save, and I am going to run, and sure
05:36 enough, you can see that I am getting the message, "The file exists."
05:39 So we didn't have to re-create it, and you can see it was created on such and
05:42 such a date at such and such a time, and it was last accessed on such and such a
05:46 date and such and such a time.
05:48 Let's finish up our exercise by moving the file to a new location.
05:51 So I am going to hit return and exit on that.
05:53 Now I am going to uncomment these last two lines here, and we are going to move
05:57 the file somewhere else using the File.Move function.
06:01 And what we are going to do is move the file from its existing path--that's the
06:05 first argument--to the path, but we are just going to give it a new name.
06:09 So it's going to stay in the same folder, but it's going to be renamed to newfile.txt.
06:14 So we are going to save, and we are going to run, and you can see that we are
06:20 still getting the original message that it exists and the creation and access times.
06:24 And now we are moving the file.
06:26 So let's go back to the My Documents folder, and you can see, that test file is no longer there.
06:31 It is now called newfile.
06:33 So you can use these functions to operate on files that are existing or create
06:37 new ones on your file system.
06:40 And if you feel like getting a little bit more advanced, go take a look at the
06:42 file class. There is a whole bunch of other useful methods in there that you can
06:46 experiment with for working with existing files.
Collapse this transcript
Working with directory and disk information
00:00 As you might have guessed, just as there are ways for working with existing
00:03 files, there are ways to work with existing directories. And whether you called
00:07 them directories or folders, it doesn't really matter; they're the same thing.
00:11 But in the .NET Framework the class is called a directory.
00:15 Now working with directories is pretty similar to working with files, except that
00:20 directories can also contain other files and directories, whereas files just
00:25 contain information.
00:26 But there are classes for working with directories.
00:28 There is of course the Directory.Exists function which tells you whether a
00:32 directory exist or not.
00:33 You can also create and delete directories the same way you can with files.
00:38 You can figure out what the current directory is for the application.
00:41 This is the directory that the application is currently looking at, what it
00:45 thinks is the current one, where information will be written to or read from.
00:50 And just like in the other directories, they contain other things. You can get the
00:54 files and get the directories that are contained within a directory. And just
00:58 like files, you can move directories around.
01:00 So let's jump over to the code and exercise some of these functions so we
01:04 can see how they work.
01:05 Here I am in my ExistingDir project, and once again I've got my Snippets file open.
01:10 So I've scrolled it down to the Existing Directories part, and I'm going to just
01:15 copy these first few lines right here.
01:21 So this example, so far, isn't too different than the example we saw for the files case.
01:27 Right here at the top, I've got the string variable called the path, which I'm
01:31 using to figure out where the MyDocuments folder is.
01:35 Once again, I'm using the Special Environment class, and I'm calling the
01:40 GetFolderPath, which will tell me where the MyDocuments folder is. And just to
01:46 show you there are lots of features on here, I'm going to just hit little
01:49 dot here on special folder, and you can see there is a whole bunch of special
01:53 folder I can get paths to.
01:54 There is the Admintools.
01:55 There is CommonDocuments.
01:56 There's things like Music and Pictures.
01:59 There's the Startup directory.
02:01 There is the Desktop.
02:02 There is a whole bunch of special paths that you can get access to.
02:06 I'm just going to go ahead and leave it as MyDocuments.
02:08 This will get me the path to the MyDocuments folder.
02:11 Then we're going to call the Directory.Exists function right here on line 1,6 to
02:16 see if that directory actually exists or not.
02:19 Since it's the MyDocuments folder, I'm pretty sure it's going to exist.
02:24 So we have an if clause here that says if the directory exists then write out to
02:29 the console that it does; otherwise write out that it doesn't.
02:32 So this is a pretty good place to start.
02:34 Just go ahead and save and run this in its current form.
02:38 And you can see that the result is that the directory exists. So far so good.
02:42 Let's continue on.
02:44 Let's go back to the Snippets and get some more code.
02:47 What we're going to do now is use the GetFiles function on the directory class
02:53 to write out the names of the files that are in that directory.
02:56 So we are going to copy, and we are going to paste that down here.
03:05 So let's save, and let's take look.
03:07 So the GetFiles function that you see here on line 24 returns a string array,
03:13 which is why I'm declaring this string array variable called files, which will
03:18 hold the results of the GetFiles function. And I pass in the path which is now
03:24 the MyDocuments folder.
03:25 Then below that I'm using our newly discovered foreach loop construct, and so I'm
03:32 going to loop over all the strings in that files array.
03:35 So for each string--and I'm going to call each one of that S--that's in the files array,
03:40 I'm going to write out to the console I found a file plus whatever the file
03:44 name is right here.
03:46 Now I could use the Formatting String function, but I just chose not to
03:49 for simplicity here.
03:50 So let's go ahead and build this, and we can see the build succeeded, and let's run it.
03:54 It looks like we found a couple of files in there.
03:57 We've got a couple of contents of the directory,
04:00 so that seems to be working.
04:02 Let's hit Return and go back to the code. Let's move on.
04:08 Now we are going to do a little bit of extra credit.
04:10 It turns out that there is a class called Drive Info, and I'm going to leave that
04:15 up to you as an exercise to go onto MSDN and look up this class to see what it
04:20 does. But I'm just going to do a really quick simple experiment here. I want
04:23 to copy the code, and then we'll explain what it does.
04:28 So just like you can work with files and directories, you can also work with
04:33 disks or other storage devices that are attached to your computer.
04:38 So what we're going to do here is get information about each one of the disk
04:41 drives on the computer, as long as it is a fixed drive. You'll notice that there are
04:47 different kinds of drives when you look up information about this class.
04:51 There are things like removable drives and so on and so forth.
04:53 So what we're going to do is write out that we're getting the drive information.
04:57 You can see that up here on line 32.
04:58 Then we're going to call here on line 33 the GetDrives function, and as a
05:05 shorthand we're just going to loop this inside a foreach loop.
05:08 So we're going to get each DriveInfo, because the GetDrives function comes back
05:14 with an array of DriveInfo structures.
05:17 So we're going to say for each DriveInfo D which is in the array that comes
05:22 back from GetDrives,
05:24 we're going to execute the code in this loop. And we're going to ask the
05:27 DriveInfo if the DriveType is equal to the DriveType.Fixed.
05:33 Like I said earlier, there are all kinds of examples here.
05:36 If I hit the period, you'll see that there is CDRom and Fixed and Network and
05:39 so on and so forth.
05:40 So we're just going to stick with Fixed, and we're going to write out the
05:43 information about each one of the fixed drives.
05:44 We'll write out its name, how much free space it has, what type it is, and so on.
05:49 So let's go ahead and save. Let's build.
05:51 It works, and now let's run it.
05:55 You can see now that we're writing out some information about not just the
05:58 files, but the drive information.
05:59 So we seem to have too fixed drives: one is called C:, one is called D:.
06:04 They're both fixed and they both have a lot of free space. That's how many bytes
06:08 are free in each one.
06:09 That's a quick example for working with directories and drives.
06:12 Now let's move on and look at some more file information.
Collapse this transcript
Using the Path class
00:00 One of the things that you're going to find yourself doing over and over again
00:03 as you work with files and directories and so on is that there's a lot of
00:07 information contained in paths, and you'll find yourself having to parse out
00:12 paths to extract file names, or just the path portion, or just the directory name,
00:17 or just the file name without the extension. And it turns out that the .NET
00:21 Framework provides a helper class called the path class that makes a lot of
00:25 these operations really simple.
00:27 So if you look at the way a typical path is built, it has a predictable
00:32 structure. And here's a sample path, and this may look different based upon the
00:37 files you work with, but this is just a sample.
00:39 So right at the front, there's the drive name, and it can be a letter followed by
00:44 a colon, followed by a backslash.
00:46 The drive name is the root level of the path, and it's the disk or the
00:51 location where a file is.
00:53 That's followed by the path.
00:55 This is the directory structure that specifies where a file is located. And this
01:00 is usually a nested set of directories, or folders, whatever you want to call, them
01:05 that leads down to the actual file name itself, which is right here,
01:09 somefilename, which is usually followed by an extension.
01:14 Now not all file systems do this, but some do.
01:17 Windows, for example, does, and this also works on the Mac.
01:20 But since we're working here on Windows, we can pretty much be sure that most
01:24 files will have extensions.
01:25 So file extensions are usually a period followed by some amount of characters,
01:30 usually between three and five.
01:32 So let's take a look at the path helper class to see how we can use it to
01:37 help us work with paths.
01:40 In the Path Operations example, I've got my snippets file open, and I've scrolled
01:45 down to the Path Operations section. So let's go ahead and copy over the setup
01:50 code, and we'll paste it over here.
01:55 Now I'm going to be working with a path to the testfile.txt file which we
02:02 created in an earlier example.
02:03 So if you have deleted it, you can go just make a new file called testfile.txt
02:08 in the My Documents folder. And you can see here that I'm using the code I used
02:13 in the earlier examples to get a path to the MyDocument special folder here on my Windows system.
02:19 Let me make this a little bit wider, so you can see that.
02:21 So right here, this is the MyDocuments path, and then we're going to put the
02:25 testfile.txt on the end of it.
02:27 So this is the example file we'll be working with.
02:29 If you don't have that already on your My Documents folder, you should just go make one.
02:33 So what we're going to is save this, and I'm going to go back over to the Snippets and
02:37 start copying over some of the exercises.
02:40 So I'll start with this one, and I'll copy that and paste this over.
02:47 So the first thing we're going to do is extract the directory name from the
02:52 path information, and to do that, we're going to use the Path class. And again
02:56 this is a static class.
02:57 You are going to call most of these methods using the class name followed by
03:01 the function name--in this case it's GetDirectoryName. And you pass in thePath as the argument.
03:07 This will parse out all of the information that's not relative to the directory
03:11 name and then just return the name of the directory that's inside the path.
03:15 So let's save this, and let's hit F5 to run it.
03:21 And you can see here that in this case the directory name is C:\Users\Joe
03:25 Marini\Documents, and it's parsed out the part that is the file name.
03:29 It's giving me just the directory name. And you can see here it is a
03:32 fully qualified path.
03:34 What I mean by fully qualified is it starts at the drive, which is the root, and
03:38 goes all the way down to where the document is.
03:42 So it gives me the entire, full directory structure that leads to that file.
03:46 Okay, let's go back and do some more experiments.
03:50 The next one I'm going to do is get the example that extracts just the file
03:55 name, so this is the opposite of the example we just showed.
03:57 In this case, we're only going to ask for the file name. And in this case, we're
04:00 going to use the GetFileName function on the path class, and this will give me
04:04 the name of the file without the directory information.
04:07 So I'll save that and run it, and you can see here that now I've got the
04:13 directory name, and the file name is testfile.txt.
04:17 So that function parsed out all the information that was not relative to the
04:21 file name and just returned the full file name with the extension.
04:24 Okay, let's go back, and let's do another one.
04:30 We'll copy and paste this one.
04:31 In this case, we're going to get the file name without the extension.
04:36 So let's scroll down here.
04:38 You can see that the path class provides a function called
04:41 GetFileNameWithoutExtension, and again, it takes thePath as an argument.
04:46 So we'll save and we'll run, and in that case, I get just the file name without
04:52 the directory and without the three-letter extension on the end.
04:55 Okay, let's go back.
04:57 It looks like we have one more.
04:59 We're going to copy and we're going to paste and paste this in, okay.
05:07 In this case, the path class is going to give us a random file name.
05:13 Now you might be asking yourself, why would I ever need to get a random file name?
05:17 What this is going to do is ask .NET to generate some random file name for us.
05:22 It's going to consists of a certain number of characters, followed by a period,
05:25 followed by three characters.
05:28 The reason you might want to do this is because sometimes in your applications
05:30 you'll need to save out temporary data and rather than going through the
05:34 exercise of trying to figure out what file name you can come up with that
05:38 doesn't conflict with a file that's already existing in a particular directory,
05:43 you can just call GetRandomFileName.
05:46 .NET will then figure out what file name you can use that doesn't conflict with
05:50 a file that's already in the directory.
05:52 You can then use that file to save out whatever temporary data you have and then
05:56 get rid of the file. And this is the nice little utility to save you all the
05:59 trouble of having to figure out,
06:00 well, can I use this file name or can I use that file name, without conflicting
06:03 with an existing file.
06:05 So let's just go ahead in exercise and see what it does.
06:07 I going to run this, and you can see that the random file name for the current
06:12 path is this sequence of characters right here.
06:16 Now if I exit the program and run it again, you can see that it come up with
06:20 another set of characters here. And it will keep on doing that each time I run this.
06:24 So that's a nice handy little utility for creating random file names that you
06:29 know aren't going to conflict with existing file names in the current directory.
06:34 So that's a quick introduction to the path class.
06:36 I highly recommend you go look it up on MSDN and try some more examples on
06:40 your own.
Collapse this transcript
Reading and writing files
00:00 The last example that we're going to look at in this section is probably the
00:03 one you've been waiting for, and that is actually writing and reading data to and from files.
00:08 Now, there's lots of ways to do this in the .NET Framework.
00:11 The .NET Framework provides a whole bunch of ways for writing data to
00:14 and reading from files.
00:16 There's probably more ways to do this than there are ways to order sushi.
00:19 But we're only going to look at some of the more simple ways of doing this.
00:22 I mentioned earlier that we're not going to get deep into streams;
00:24 you can feel free to go do that as an extra credit exercise.
00:27 What we're going to look at is the higher level order functions for reading and writing data.
00:33 So for writing data, there are some really simple functions.
00:35 There's File.AppendAllText, which simply takes a bunch of text content and
00:40 appends it to the end of an existing file.
00:43 There's the WriteAllBytes and WriteAllLines, which, as their name implies, for
00:49 WriteAllBytes you can just give it an array of bytes; for WriteAllLines, you
00:53 give it an array of strings. They will write out the content to the file.
00:56 And then there's File.WriteAllText.
00:59 Now, unlike AppendAllText, WriteAllText will replace the existing contents of the file.
01:05 So if you want to just replace the content, use WriteAllText.
01:08 If you want to add to the existing content, use AppendAllText.
01:13 Not surprisingly, there are some counterparts for reading data.
01:16 There is ReadAllBytes, and as you might have guessed, this will read all the
01:21 content of a file as a bunch of binary bytes.
01:25 But for the purposes of our exercise, we're going to be working with text, so
01:29 we'll probably use things like ReadLines and ReadAllLines and ReadAllText.
01:33 This will actually read the contents of a file as text content.
01:38 So let's just jump over to the code and actually start exercising some of this,
01:42 so that you can see how it works. Okay.
01:44 In my ReadingWritingData example, I have got my Snippets opened, and I
01:48 have scrolled down to the Reading and Writing Files section.
01:51 So I am going to start off by copying over the setup code, which are these lines right here.
01:57 So I will copy those and paste them in.
02:00 I'll put them in my main function. All right!
02:03 So before we go any further, let's take a look at what's going on here.
02:07 So if you've been following the examples up until now, you're probably familiar
02:10 with the first line here on line 14.
02:12 This is the filePath.
02:14 We're going to be using the environment class to get the path to the
02:18 My Documents folder.
02:20 But we're going to be doing something a little bit different this time.
02:22 If you watched the section on the path helper class, which is previous,
02:26 you will probably notice that they are using a path helper section here.
02:31 Instead of using the backslash character hard coded into my examplefile.txt file
02:37 name, I am using the Path.DirectorySeparatorChar constant, which tells me what
02:44 the separate character for this file system happens to be.
02:47 Now, here on this version of Windows and .NET, it will be a backslash, but it
02:51 might be different based upon what platform you happen to be running on.
02:54 So I am going to just use this constant right here so that I don't have to hard
02:58 code a directory separator into my code, which is never a good idea.
03:04 So I am taking steps here to make my code work cross-platform. All right!
03:07 So now that we've got the path built up, we're going to see if the file exists.
03:13 And if you watched that particular example, you will know that we use the
03:16 File.Exists function do that, here on line 18.
03:20 So we'll see if the file does not exist, so we'll put that little not operator
03:25 right here in front of the File.Exists call.
03:29 So if the file does not exist then we're going to create it by using the
03:33 WriteAllText function.
03:35 So we'll have a string variable here on line 20, which will be the contents of
03:40 the file. And the content is going to be a string called, "This is a text file,"
03:43 And once again, I am using my environment class to figure out what the new line
03:48 character is for this particular platform.
03:50 So once again, rather than hard coding in a /r or /n, or whatever a state
03:55 sequence happens to be the NewLine character on this particular file system, I
04:00 will just use the NewLine constant for this particular environment.
04:04 Then I am going to write out the console that we're creating the file, and then
04:08 I'll use the File.WriteAllText method. And WriteAllText takes two arguments:
04:13 the first is the path to write to, the second is the text content that we are writing out.
04:18 So I am going to build this, and I am going to run it. And you can see that
04:25 the Creating the file... string got written out, because the file did not
04:28 exist in the My Documents folder. So now we've created it, and if you want to
04:33 go ahead and check your My Documents folder to see if it exists, you can go ahead and do that.
04:37 I am just going to keep on moving on here. All right!
04:41 So let's go back to the Snippets.
04:43 Now, let's use the AppendAllText method to add content to the file.
04:49 We'll copy, and we'll paste, and we'll save.
04:54 Okay, so I am going to build this, and now I am going to run it.
05:00 Okay, now you can see that I am adding content to the file.
05:04 Let's go back and look at the code and see what happened here.
05:07 The file already exists, so the if statement here on lines 18 through 23 did
05:12 not need to execute.
05:13 The file's content is getting appended,
05:16 so this line right here, Adding content to the file... got written out, then we
05:21 use the AppendAllText to add the added text string, which I am building up right
05:28 here into the file, and that writes the content out to the file.
05:32 So just to make sure that things are working okay, let's go ahead and open the
05:35 file up so we can look at the contents.
05:37 So here I am in my documents folder.
05:40 Let's open up examplefile, and you can see, here is, "This is a text file" and this
05:44 is "Text added to the file."
05:46 Well, that's great, but I would rather not have to open up Notepad to make sure
05:49 that the content is getting added correctly.
05:51 So let's see if we can read the contents and display the contents into the console.
05:54 All right, so back here in the code, let's scroll down. All right!
06:02 Now, we're going to read the contents of the file. So I am going to copy these
06:06 lines right here and back in my code,
06:11 I am going to paste them in.
06:13 So we're going to write out to the console that we are reading the file, and you
06:17 can see right here we're writing out that The current contents of the file are:,
06:21 and then it will separate a line, to separate the content.
06:23 Then we're going to use the ReadAllText static method on the file class to get
06:27 the current content.
06:28 The current content will come back as a string.
06:30 So we've got a string variable right here on line 35, which will hold the
06:34 results of the ReadAllText function on the filePath.
06:38 Once we have the current content, we will write out the current content to
06:42 the console, and then we'll put a little line separator to increase
06:46 readability right here.
06:47 So I am going to build. Okay, the build succeeds.
06:51 We run it, and you can see that we've now added content to the file and The
06:56 current contents of the file are:.
06:58 And we've got a couple of lines, "This is a text file," and then we've got "Text
07:01 added to the file" twice.
07:03 So I am going to hit Return.
07:04 I am going to run it one more time, because each time we run it, this line right
07:08 here, the "Text added to the file" is going to get added.
07:10 So I am going to run it again, and you can see that now that there are three;
07:14 and then I'll run it again and you can see that now there are four.
07:18 Okay, let's go back to the code.
07:21 One more thing I want to do here.
07:22 I want to show you how to read the contents of the lines of the file using the
07:27 ReadAllLines function.
07:29 I want to copy this, and I am going to paste it in over here.
07:34 This is just another way of reading the contents of the file, so I am going to
07:37 paste that in here. And for now, I am just going to comment out these lines,
07:42 and I am going to uncomment these lines, so that we can actually run the code.
07:52 So whereas the ReadAllText function on the file class will read all the content,
07:58 the ReadAllLines will read the lines and return an array of strings.
08:04 So ReadAllText comes back with one string; ReadAllLines comes back with an array
08:09 of strings, and that's this right here on line 40.
08:12 So I am declaring an array of strings-- that's this contents variable right
08:17 here. Then I call the ReadAllLines function, which will return an array, and
08:21 then here's our old friend the foreach function.
08:24 So I am going to loop over each string that is in the contents array, and I am
08:29 going to call each one of those strings the variable S. And inside my loop, I am
08:34 going to just write out whatever that S string is.
08:38 So let's build, and I am going to run, and you can see that we get the same
08:44 results, only this time, instead of reading the content as one long string, we
08:49 read the contents as an array of strings. All right!
08:54 That bring us to the close of this example and this chapter, so I highly
08:57 encourage you to go explore the file class and do some of your own experiments
09:01 working with reading and writing data to files.
Collapse this transcript
10. Some Advanced C#
Using variable parameter lists
00:00 Up until now we've been working with some of the more basic features of C#, and in
00:05 this section we're going to start looking at some of the more advanced features
00:08 of C# that were added in some of the more recent versions.
00:11 Now most of the stuff that you've seen so far you'll see in C# applications
00:16 all over the place,
00:17 but the ones that we're going to look at now are going to enable you to write
00:20 applications that are more advanced and have more concise code in them.
00:24 And we're going to start off by looking at something called variable parameter lists.
00:27 Variable parameter lists are useful because there's going to be times when you
00:31 want to create functions that take a number of arguments that you don't know in advance.
00:36 The way that you do this is by using the params keyword.
00:40 The params keyword allows you to define a parameter list for function that takes
00:44 a variable number of parameters, and it looks something like this.
00:49 Suppose I have a function that added a bunch of numbers together.
00:51 Now, I could add a whole bunch of numbers, but the problem is, without using
00:55 variable parameter list, I'd have to have a fixed number of parameters.
00:59 So for example, I could supply two integers, in this case, a and b.
01:03 But what if I wanted to add three integers or four integers or some
01:07 unknown number of integers?
01:08 Well, I could go the route of overloading methods, if you watched the movie on
01:13 that section, in which case, I would just define a whole bunch of addNumbers
01:18 functions and define a version of addNumbers that takes two arguments and then
01:22 one that takes three arguments and then one that takes arguments.
01:25 The problem is that gets really tedious really quickly and really bloats the
01:28 code. Or I could just simply use the params keyword and tell my function that it
01:34 takes an array of arguments.
01:36 So, for example, rather than just adding two numbers, I would do something like this.
01:41 And here I've used the params keyword and following the params keyword, I say int
01:47 with square brackets.
01:48 So this tells the C# compiler, hey, compiler, this function is going to take
01:52 an array of arguments.
01:54 And we don't know how long that array is going to be.
01:57 So the params keyword says, just be ready for a whole bunch of arguments.
02:01 Now once I've done that, I can rewrite the body of this function from just adding
02:05 two numbers to adding a whole bunch of numbers. And I'll use the foreach
02:09 construct to loop over each one of the integers in the nums argument that you
02:14 see there in the parameter list, and just keep a running total.
02:18 So let's jump over to the code and actually write this example and see it work.
02:22 Here in my variable params example, I've scrolled down to the Variable
02:26 Parameter Lists sections of my ExampleSnippets, and the first thing we're going to do
02:30 is copy over the function.
02:32 So this is the function that's going to add a whole bunch of numbers.
02:35 So I'll just copy this and go over to the program code, and I'm going to paste it in.
02:40 I'll paste it down here.
02:43 So now I have my addNumbers function, and you can see I'm using the params
02:46 keyword that takes an integer array of arguments.
02:51 So let's exercise this.
02:52 Let's go back up to the code. And I'm going to copy over this code here, which I'm
02:56 going to paste in the Main function.
03:00 So let's paste this in.
03:03 So let's take a look at what's happening here.
03:04 First, you'll notice that we have two different calls to addNumbers.
03:08 There is one here on line 14. There is one here on line 17.
03:11 The one on line 14 is passing in three arguments, 4, 6, and 8, and then the one
03:16 here on 17 is passing in a whole bunch of arguments.
03:18 So what's going to happen is each one of these calls to the addNumbers function
03:22 is going to generate an array of integers, and then inside my addNumbers, I'm
03:26 just going to loop over each one of the integers, add it to my running total,
03:30 and then return the total back to the caller, which will be stored in this
03:34 result variable right here.
03:36 So let's just build this and run it, and you can see that in the first case the
03:42 result is 18, and in the second case the result is 84.
03:45 So I've been able to now define a function that takes a variable number of
03:49 parameters so that I can write my code using this function and not know how many
03:54 arguments I'm going to have in advance.
03:56 Now there are a couple of things you need to keep in mind about the
03:58 parameters function.
03:59 One of the most important ones is that if you're going to use the params keyword,
04:03 that has to be the last argument to the function.
04:05 What I can't do is something like this.
04:09 You'll see that when I try to do that I get some errors, and if I mouse over it,
04:13 you'll see, "A parameter array must be the last parameter in a formal parameter list."
04:19 The reason for this is because since this is variable, the compiler has no way of
04:23 knowing how many arguments are in the array, and therefore, which argument goes
04:28 in the array and which integer is the last one.
04:30 So if I wanted to do something like this, I'd have to make sure that any other
04:36 arguments, whether they be strings or integers or objects, all of those have to
04:45 come before the params array.
04:48 So now we see that there is no error. Well, there is an error up here because I'm
04:51 not passing in the string integer object.
04:54 But anyway, that's how you use variable parameters in your functions.
04:59 So using the params keyword you can define functions that take a variable number
05:03 of parameters which greatly simplifies code that has to work on an unknown
05:08 number of arguments.
Collapse this transcript
Using function parameter modifiers
00:00 Earlier on in the course I talked about the difference between calling functions
00:04 and passing parameters by value and passing parameters by reference.
00:08 So if you haven't watched that movie, now is probably a good time to go watch
00:11 it, so you'll understand what's going on here, because I am going to be talking
00:13 about function parameter modifiers which allow you to change the way that
00:18 parameters are passed to and from functions.
00:22 So let's just take a quick recap to see how things normally work.
00:27 Suppose I had a function that takes an integer parameter, and it looks like
00:31 this, and inside that function, I have a piece of code that adds the number 10
00:36 to whatever that integer parameter was passed.
00:39 Now, if I call it from another function that looks like this, and I have an
00:42 integer named x and I initialize it to the value of 10, and then I call my
00:47 function, the code that's inside my function does not change the value of the x
00:53 variable in the test function down there below.
00:57 However, I can use a keyword in the parameter list for the function called ref.
01:03 This causes a parameter to be passed by reference, instead of having a copy of
01:08 its value passed in, which is what the normal case is in C#.
01:13 Now what I'd do here is I would declare my function as normal.
01:16 I'd have an integer parameter named param1, but I would put the ref keyword in front
01:21 of the type name--in this case integer.
01:24 This causes the param1 parameter to be passed by reference.
01:29 So now here I have my test function, and I've got my integer variable named x.
01:34 Now, when I call the function, I also have to put the ref keyword in front of
01:39 the parameter that I'm passing to the function.
01:42 When I do this param1 is now a reference to the x variable and not a copy of
01:49 its existing value.
01:51 This line of code here, param1 += 10, will in fact change the value of x down in
01:58 the calling function.
01:59 X will now be equal to 20 when this function returns.
02:04 The reason why I need the ref keyword in both places is so that it's really
02:07 clear what's going on in the code.
02:10 So you can deliberately do this when you want to be able to change the value of
02:13 parameters that are passed to functions.
02:16 So let's take a look at one more example.
02:19 There's the out keyword.
02:21 Now, normally functions return values through their return type, but the out
02:27 keyword allows a return value to be passed back via a parameter, and you would
02:33 use this in cases where you wanted a function to be able to pass back more than one result.
02:39 So let's take a look at an admittedly contrived example.
02:43 Suppose I had a function named SqrAndRoot, and SqrAndRoot takes a number as its
02:49 first parameter, and I want it to return both the square of that number and the
02:54 square root of that number.
02:56 I could pass in a parameter named sq, which would be the square, and I put the out
03:01 keyword in front of it.
03:03 I do the same thing for another parameter named sqrt, and I also put the out
03:08 keyword in front of that type named for that parameter.
03:12 Now, inside the body of the function, I would simply assign values to the square
03:17 and square root results.
03:19 So for sq I'd simply multiply num by itself, and that's the square of the number,
03:24 and then for sqrt I'm using the .NET Framework's math library to calculate the
03:29 square root of that number.
03:31 When I call this from a function, say, named test and I pass in the parameters,
03:36 you'll notice that I've to put the out keyword in front of the parameters
03:40 that I'm passing in.
03:41 So when I call SqrAndRoot, I pass in the first parameter, which is x. That's the
03:45 number I want to have the square and square root of.
03:48 Now when this function completes, theSquare and theRoot are going to have the
03:52 values that were calculated by the square and root function.
03:56 You notice I don't have to actually initialize those values, because those values
04:00 are going to be calculated for me by the function.
04:03 So I don't have to assign initial values to them.
04:06 Now, it's one thing to hear me yammer on about it;
04:08 let's actually go over to the code and actually watch it work.
04:10 Okay, so here I'm in my FuncParamModifiers project.
04:13 I've got my Snippets open to the code for this example.
04:17 So first, I'm going to copy this function, which is the SquareAndRoot function,
04:21 copy that and put it over in my code.
04:25 That's the function that we're going to call.
04:27 You can see I'm using the out keyword right here on line 10 to indicate to the
04:32 compiler that sq and sqrt are going to be out parameters.
04:37 I'm going to copy the code, going to call it with, and we'll put that down here
04:44 in the Main function.
04:45 Okay, I am going to put a line there.
04:47 So what we're starting off with here is a number,
04:50 in this case 9.0, and it's a double, and I've got variables named theSquare and
04:56 theRoot which are going to hold the results, and now I just simply call square and root.
05:00 I pass in 9 and I've got my out keyword in front of each one of the parameters
05:04 that are going to hold the output.
05:06 Then I've got Console.WriteLine call that says, hey!
05:09 The square of this number is this, and its square root is this, and I'm just
05:14 passing in those results to the WriteLine function.
05:17 So, everything looks good.
05:19 I hit F6, and it builds just fine.
05:22 Now let's run it, and you can see that the square of 9 is 81 and its square root is 3.
05:30 So it works just as we expected it to, and you can use the out keyword and the
05:34 ref keywords to change the way that parameters are passed to and from functions.
Collapse this transcript
Using optional and named function parameters
00:00 Okay, the next advanced C # feature we are going to take a look at are optional
00:04 and named parameters.
00:05 Now up until now when we've been calling functions with parameters we have been
00:08 supplying values for those parameters, because if we don't, then the C# compiler
00:13 complains that we left a parameter out of the function call.
00:16 Optional parameters allow you to define default values for parameters so that if
00:20 you don't feel like passing in a value for that parameter, you don't have to.
00:24 And the way that you do that looks a little bit like this.
00:27 So I can define a function, and you can see that I define the function normally
00:30 with two integer parameters. But I've got equals and then values after each one
00:35 of those parameters.
00:36 So here for my function, I don't have to supply values for a or for b, because
00:41 if I don't, then a will default to 0 and b will default to 1.
00:45 So, for example, it's just as valid for you call the function like this, where I
00:49 have got a just defaulting to 0 and b to 1, as it is to call it like this, where
00:54 a is now 10, but b retains its default value.
00:58 The other feature is named parameters.
01:00 Now up until the version of C#, I think it was 3.0, you had to call parameters in
01:05 the order in which they were declared in the function declaration; named
01:09 parameters, however, changed that.
01:11 Suppose, for example, that I have a function that looks like this.
01:14 I have got two integer arguments: one named a and one named b.
01:18 I can actually just simply call the function by passing in the name of the
01:22 parameter, a colon, and then the value, and it looks like this.
01:26 So if I wanted to call this function with parameters that are out of order, I
01:29 would simply say b:5 and a:3. And this would call the function normally.
01:35 And you notice I don't have to do anything special to the to the function declaration.
01:38 This just automatically works in C#.
01:40 So I can call the functions with the parameters that are out of order.
01:44 If I wanted to call the function otherwise, I could do it like this.
01:47 I can call the function with just the value 3, which is now a is 3 in that case,
01:52 and I'll put the name of b:7, although in this case I wouldn't have to do that.
01:57 Now notice that if you don't supply a named parameter, then they have to go first.
02:02 So, for example, if I wanted to this b:7 and then 3, that would cause an error,
02:07 because the C# compiler would say well, wait a second. You are not supplying a
02:11 name for a, and therefore I don't know which parameter you are talking about.
02:14 So you have to put the non-named parameters first.
02:18 Let's go over to the code and actually exercise this.
02:21 So here I am in my NamedOptionalParams exercise, and in the Snippets, under the
02:26 Named and Optional Parameters section, I am going to copy over the two functions
02:30 I am going to be using to exercise this.
02:33 So let's just copy these guys first and paste them into the code, and I will
02:38 put them below the Main function here.
02:39 So I have got two functions.
02:41 I have got one called myoptionalParamFunc, and you can see here that I've got a param here
02:48 that's -- param1, this is not optional because it doesn't have a default value.
02:52 This one here is optional because it's being supplied with a default value for
02:57 param2 and then for the third one, which is a string, I've also got a default
03:01 value which is a string value.
03:03 And it's worth pointing out here that you can provide default values for pretty
03:07 much just about any parameter type you can come up with.
03:10 Inside the function all we are doing is writing out what the function was called
03:15 with, and we will write out the values for param0, param1, and param2.
03:20 And you will notice here that I am using some escape sequences.
03:23 I have a \n and \t. That basically means, do a new line and then tab in, which
03:30 will make the results a little bit easier to read. All right!
03:33 Next, I have mynamedParamExample, in which case I'm going to call this function
03:38 with named parameters in the code from the Main function.
03:42 And again, you will notice, I don't have to do anything special to the
03:45 function declaration.
03:46 This just works with normal C# functions.
03:48 So let's go back and copy over the code that actually exercises these.
03:53 Let's start with the named parameters example.
03:56 So I will copy those lines and I will paste them into Main. All right!
03:59 So the first thing we are going to do is call the named parameter example, and
04:05 you can see I have got cityName, stateName, and zipCode.
04:08 I am just going to call them in different orders.
04:10 So the first example is going to call it with state, zip, and then city; the
04:14 second is going to call with city then zip and then state; and then the last one
04:17 is going to do zip, city, and then state.
04:20 So let's go ahead and exercise that.
04:22 We will build it and run it.
04:26 And you can see that in each one of the cases the arguments were passed in
04:30 different orders, but the output is in the right order.
04:33 So each one got its city name correctly, the state name is correct, and the
04:37 zip code is correct.
04:39 Okay, so let's do this.
04:40 Let's go back to the Snippets, and let's pass in the optional parameters example.
04:47 Copy this, paste it over here.
04:50 So now we are going to call the optionalParam function, and in each one of these
04:56 cases we are going to pass in a different set of values.
04:59 This one is going to pass in just one parameter.
05:01 This one will pass in two, and this one will do three, and then we will get to
05:05 this one in just a moment.
05:06 So let's save and build, and now we are going to run it, and you can see that now,
05:13 on the lower part of the output here, I have got Called with.
05:16 In the first case, you can see that the first parameter was 15 and then this two
05:20 second parameters were the default values.
05:22 In the second case, I passed in two parameters, so the first two parameters
05:26 are different, but the placeholder string is still the same. And in third case
05:30 I passed in three parameters which are different values and all of the default ones.
05:34 So let's go back to the code and see what happens when I uncomment this one right here.
05:39 Actually, before I do that, let me comment these guys out to make the output a
05:41 little more readable. All right!
05:42 So I am going to save. And you'll see that I am getting an error here, and the
05:48 reason I am getting an error is because the best overloaded method match for
05:53 blah, blah, blah has some invalid arguments.
05:55 What that basically means is, because I'm using optional parameters here,
06:01 you'll see that there is no version of myoptionalParamFunc that takes an
06:07 integer and then a string.
06:10 So this is a problem here.
06:11 If I'm going to pass in parameters that are being supplied instead of the
06:15 defaults, I have to supply values for all the optional parameters leading up to that point.
06:21 So I can't leave out the middle parameter here, because it thinks I am trying to
06:25 pass in a string value to this double right here, which is not correct.
06:29 So if you are going to use optional parameters and you want to supply values for
06:33 parameters in different orders, you will probably have to use the
06:36 named parameters and optional parameters in the same function call, which is
06:40 what we are going to do right now.
06:41 So let me comment that back out to get rid of the error. Now do both.
06:49 So to fix the error that I had above, what I am going to do pass in the value
06:55 for the first parameter, because it's mandatory.
06:58 There is no default value here, so I have got to supply a value to that, but
07:01 I want to skip over the middle parameter and just provide a string for the last one.
07:05 So to do that, I'm combining the named parameter feature with the optional
07:11 parameter feature. And now the compiler is like, oh, I see, you're trying to
07:14 supply a string for param3, which is over here, and not for param2.
07:21 Okay, well, that's fine with me.
07:23 So let's go ahead and build, and let's run it, and you can see now that all the
07:28 cases work. And this is the most recent case we just added.
07:31 So we have got the mandatory value here,
07:34 the default value is now being passed in for param2, and in the last case we have
07:38 a different string being passed in for param3.
07:41 So optional and named parameters really allow you some great flexibility in how
07:45 you define your functions.
07:46 They allow you to define default values for parameters that you don't want to
07:51 make mandatory for the caller, and named parameters allow you to call functions
07:55 with parameters in different orders.
Collapse this transcript
Using the C# preprocessor
00:00 During your C# coding travels, you're probably going to come across C#
00:04 preprocessor directives, and that's we are going to cover in this particular movie.
00:08 The preprocessor is what its name implies.
00:11 It does some pre-processing of the files before the compiler actually goes and
00:17 looks at all the code and compiles the application.
00:20 The preprocessor directives simply give instructions to the compiler
00:24 which help the compiler do its job before the compilation process actually runs.
00:29 Preprocessor directives are preceded by a hash character, or a pound character, or
00:35 whatever you want to call it.
00:36 So we'll take a look at some of those here.
00:38 The first two are define and undef, and you can see that they have got that
00:42 little--I guess you can call it sharp character, if you want to, whatever is it,
00:45 it has a word preceded by that little character.
00:49 In this case, define and undef allow you to define or undefine a symbol.
00:55 Now, why would you want to do that?
00:56 Well, we will take a look at an example that explains why you would want to
00:59 do that in just a moment, but there are a few other directives we want to look at first.
01:03 Using preprocessor directives, you can also do things like logic.
01:06 You can use #if, #else, #elif, or #andif, and these allow you to use logic to see
01:13 if a certain symbol is defined.
01:15 Now if the light bulb hasn't gone off yet, don't worry; it will in just a moment,
01:18 but there are two more directives we want to take look at.
01:20 They are region and nregion, and these are used for documenting your code, so that
01:27 the C# Express development environment allows you to do things like label
01:31 regions and collapse regions and so on.
01:34 But rather than just talk about them, let's actually see them in action, because
01:37 slides just don't do it justice.
01:39 Let's jump over to the code.
01:40 I have got my preprocessor example open here, and here is my program file.
01:46 The first thing I am going to do is this:
01:48 I am going to do a couple of defines.
01:51 Now, if you're going to define symbols, you need to do it before any other line
01:56 of code in the file.
01:57 So I need to put these defines up here above the using statements; otherwise, this
02:01 will cause problems.
02:02 So if I try to take these out and put them down here and save, you'll see
02:07 that these little red squiggles show up, and that's because the compiler is complaining.
02:11 It says hey, you cannot define or undefine preprocessor symbols after the
02:15 first token in the file. And that's just a fancy way of saying, these got to come first.
02:20 So let's go ahead and cut those and put them back up there.
02:25 So now I have defined some symbols, but what exactly does that mean. Why am I
02:28 defining symbols in the first place?
02:30 Well, the reason for doing this will become clearer when we paste in the rest of
02:34 the example. And I am going to go ahead and paste these guys in down here, copy,
02:39 and I'll put these in the Main part of my program.
02:43 So what you'll do here is you will notice that when I've got these #if and #else
02:48 and #endif, they are checking to see if a particular symbol has been defined.
02:53 So let's imagine that you're building a version of your application where you
02:56 only want to include some code if it, say, in a debug configuration, or if
03:03 it's in a demo mode.
03:04 Suppose I wanted to have this code right here only included in my application
03:10 if I'm shipping a demo version of my application, versus a fully released, fully
03:15 functional version.
03:16 Well, in that case I can simply change this from the DEBUGCODE to DEMOMODE or
03:21 whatever it is that I want.
03:22 You can see I have also defined a JOE symbol here.
03:26 I can make up whatever symbol I name I want.
03:27 Now, what's going to happen is the compiler is going to come across this logic
03:30 and say #if DEBUGCODE. Okay, well, if there's a symbol name DEBUGCODE then the
03:36 code that's in between this #if and #else is going to be included in the
03:42 compilation process and code that does not meet that logic test is not going to be included.
03:47 You can see here on line 18 that this code is in gray.
03:51 That's because the compiler is going to ignore it.
03:53 I can just write things that's not even code in here. Watch!
03:56 No red squiggles, right? Why?
03:58 Because the compiler is completely ignoring this code; it's not meeting the
04:02 logical test to see if the DEBUGCODE symbol is present.
04:05 Let me go ahead and delete that.
04:08 So now if we build and run--let's just do that really quickly, build and run;
04:12 we will hit F5--you'll see that the lines of code that met the logical tests of
04:18 those preprocessors was included in the application and they are executing.
04:22 So let me hit Return and get out of here.
04:24 Now let's go back up to the top.
04:26 What I am going to do is I am going to take out this #define for JOE, and we'll save.
04:31 Now watch, notice how the line of code that's inside this #if, #endif section
04:37 for the JOE symbol went and turned gray.
04:40 That's because I've gotten rid of the JOE symbol and this line of code is no
04:44 longer relevant, because this logical test on line 20 no longer evaluates to true.
04:49 Similarly, I can get rid of the #define DEBUGCODE, and you'll notice that the
04:54 line of code that used to be included in the compilation process when DEBUGCODE
04:59 was defined is now gray and the else condition is now being included.
05:03 So this bright line right here, it says:
05:06 "This only gets written out in non- debug code" is going to execute.
05:09 So if I run this now, you will see that that line of code is getting executed
05:13 where the other lines of code are not getting executed.
05:15 In fact, they are not even included in the program.
05:17 If you were to disassemble this code using a disassembler, you'd notice that
05:21 those lines of code aren't even present in the final application. Okay.
05:25 So let's take a look at one more preprocessor directive, and that is the region directive.
05:30 What I am going to do is copy this right here, #region.
05:33 I am going to put that in front of the Main, and then I am going to copy the
05:40 endregion. And I am going to put that below the Main function right here.
05:48 Now when I save, what that does is it tells the C# compiler that this is a region of code.
05:53 Now, this doesn't affect compilation.
05:55 It's really just for documentation, because watch what I can do now.
05:58 Over here in the C# Express IDE, I can click on this little collapse button and
06:04 you can see that it collapses down, and the text that I've included after the
06:07 region declaration here on line 10 is what gets included in that little label.
06:12 So I can collapse that down and you can see now that all that code is hidden.
06:16 So if I wanted to just collapse my code down to make it easier to read, I can
06:20 separate my code into different regions and then expand and then collapse them as I see fit.
06:25 Now if you're coming from other languages, such as C or C++ or Objective-C,
06:31 you'll probably see sometimes these preprocessor directives used to define
06:36 constants, and you'll see the #define directive used to define numbers and so on.
06:43 That's not the way things are done in C#.
06:46 In C# we have the const keyword, which we discussed earlier in the course
06:50 for defining constants.
06:52 So if you're coming from a language like C where you're used to using the
06:55 #define preprocessor directive to define constant values, you are not going to do that here.
07:00 You can use the const keyword instead.
07:02 Here, we are going to use the #define and #undef and so on, just to affect the
07:07 way that compilation happens.
Collapse this transcript
Working with delegates
00:00 Next couple of subjects that we are going to take a look at are fairly advanced,
00:04 and they are delegates and events.
00:07 I am going to start off by taking a look at C# delegates.
00:10 C# delegates are sort of like callbacks that you may have seen in other languages.
00:14 If you're familiar with programming languages such as JavaScript or Java or C or
00:20 C++, then you're probably familiar with the notion of a callback function.
00:25 A callback function is assigned at runtime and you can change callback functions
00:29 while the program is running. And the callback function is simply a way for you
00:33 to provide a piece of functionality that can be switched in and out as it is
00:37 needed. And delegates provide that functionality in C#.
00:40 Essentially, a C# delegate decouples the caller of a function from the call
00:46 function, which is essentially the same thing that callbacks do.
00:49 So to declare a delegate use the delegate keyword, and you're essentially
00:53 defining a type of function that is going to be called.
00:57 So I use the delegate function. Then I provide the type that the delegate
01:02 is going to return.
01:03 So in this case I'm declaring a delegate that returns an integer. Then I need to
01:08 provide a name for the delegate, and I can make it up as much as I want to.
01:12 I can use whatever a legal function name would be.
01:15 In this case I am just using the generic term delegateName, but you can use
01:18 whatever name you want. And then you have to provide any parameters that the
01:22 delegate is going to handle.
01:23 In this case I'm declaring a delegate that returns an integer and takes two parameters:
01:27 there is an integer and a string.
01:30 Then when I want to use the delegate, I use it like any other kind of type name.
01:34 So in this case I'm declaring a variable named func, which is of type
01:40 delegateName, and I'm assigning it to be someFunction.
01:43 So as long as I declare someFunction to be the same format as the delegate that
01:48 I have declared above, I can switch that function in and out as much as I like.
01:52 Then I just call the function like I would any other function.
01:55 In this case I've got an integer result which is being assigned
01:59 to the result that comes back from the func variable, which is now pointing at
02:03 the someFunction function, and it takes the integer argument 3 and the string argument "hello."
02:09 Then all we have to do is actually write the someFunction callback. And you can
02:14 see here that I've got a function named someFunction, which returns an integer
02:18 and takes two parameters--an integer and a string--and it has the same format as
02:23 the delegate that I declared at the top of the slide there.
02:27 So let's jump over to the C# code and actually implement this and see how it works.
02:32 Okay, so I am here in my delegate example, and I've got the UsingDelegates
02:37 project open, and I have also got the ExampleSnippets file open, and I've scrolled
02:42 down to the section on using delegates.
02:45 So the first thing I am going to do is copy my delegate declaration.
02:49 That's this line right here, so I will copy that and I will paste it into
02:52 the Main program here.
02:55 Now I am going to paste this inside the namespace but outside of my program class.
03:00 So I will just put it up here. And this basically says to the C# compiler, hey
03:04 compiler, there's going to be this thing called a function that has the format
03:08 of returning an integer and taking an integer argument, so be on the lookout for it.
03:14 So I am going to save that, go back to the snippets.
03:17 Now I am going to scroll down here and copy these two functions,
03:21 the functions Square and Cube.
03:24 So let's copy these guys, and we'll put them in the code outside of the Main function.
03:31 Now notice how each one of these functions returns an integer and takes an
03:36 integer argument, just like the delegate is declared up here.
03:41 So this delegate returns an integer and takes an integer argument. All right!
03:45 Now we can write the code that actually uses the delegate.
03:48 Here is what we are going to do. To do that, we are going to go back over to
03:52 Snippets and we are going to copy this piece of code right here.
03:57 Let's put this in our Main function.
04:00 Let me explain what's going on here.
04:02 Now that I've defined my delegate as a NumberFunction--that's this guy right
04:07 here--I can now declare that as a variable.
04:10 So on line 15 I am creating a variable named f which is of type NumberFunction,
04:16 and remember, that's a delegate.
04:17 So I can assign to f the name of a function that matches the same description as the delegate.
04:24 In this case, it's the Square function.
04:27 So down here is the Square function.
04:29 It takes an integer argument, and it just simply returns the square of that number.
04:32 It takes that number and multiplies it by itself.
04:36 So, on the next line, on line 16, I am doing a Console.WriteLine that says. the
04:41 result of the delegate is. and then the result number is going to go in here, and
04:45 then I simply call the function f with the number 5.
04:48 So f is now pointing at the Square function, because I assigned it to that up here on line 15.
04:52 So, I am going to call the function f with 5, and that's going to square the number.
04:58 That's going to write out the number 25.
05:01 So let's go ahead and run that. But before we run, that let's comment out these
05:04 two lines, so we can isolate the results for the moment. All right!
05:07 So we will save and we will run, and you can see that the string that's being
05:12 written out is the "result of the delegate is 25," just as we expected.
05:16 Okay, so far so good.
05:17 Now what we're going to do is uncomment these lines. And notice I'm changing
05:21 the delegate on the fly.
05:23 So now, instead of the f variable pointing at the Square function, it's going to
05:28 point at the Cube function.
05:30 So, while the program is running, I'm changing what the function that's going to
05:34 be called is, by changing the value of the f variable from Square to Cube.
05:39 So now this f variable right here on line 19 is going to be pointing at this
05:44 function down here to Cube.
05:45 And Cube takes the number and multiplies it by itself three times, which is how
05:50 you arrive at the cube of a number.
05:53 So on line 20, I am going to write out the result of the delegate is, and then the result.
05:58 I am going to call the function the same way.
06:00 I am going to call the function f with the value of 5, but in this case the
06:04 result is going to be very different.
06:06 So we should see two things written out.
06:08 We should see this line written out here, when f is pointing at the Square
06:12 function, and then we should see a different value written out here, when f is
06:17 pointing at the Cube function.
06:19 So let's build, and we can see the Build succeeded.
06:21 Okay, let's run it.
06:24 And you can see that the result of the delegate is 25, and then the result of
06:29 the delegate is 125, which is what we would expect, because we changed the
06:34 delegate to point from Square function to the Cube function.
06:38 Delegates are a really powerful and flexible programming construct in C#.
06:43 They do the same thing as callback functions, but they do it in a more modular way.
06:48 If your code calls for such flexibility, such that you need to be able
06:51 to provide callback functions, the way that you accomplish that in C# is by
06:55 using delegates.
Collapse this transcript
Handling events
00:00 In this example we're going to see how to use C# events, and specifically we're
00:04 going to create our own events and our own event handler.
00:08 Now the work in this particular movie is based on the delegates movie.
00:12 So if you haven't watched that one, you go back and watch it now because events
00:16 need delegates to work, and it's important that you understand delegates before
00:20 you attempt this movie.
00:21 So there are four steps involved in declaring and triggering C# events.
00:27 The first is that we have to create a delegate which is the event handler.
00:30 And just like we did in the previous section, we do that by using the delegate
00:34 keyword and then we declare the delegate named. In this case have got an
00:39 EventHandler which returns a void value.
00:42 So there's no return value from this function.
00:44 And then I declare the parameter list.
00:47 In this case, there is an integer parameter and a string parameter.
00:51 Now inside the class that's going to implement this event, I need to use the event keyword.
00:55 So what I do is I define a my class, and I do that normally with my class
01:00 definition. And then somewhere in my class I do something like this.
01:03 I say public and then the word event in front of the EventHandler delegate name,
01:10 and then I give it a name which is going to be used by the consumer of this
01:14 class to hook onto my event.
01:17 So somewhere else in the code someone who is using this class is going to write
01:21 something like this.
01:22 They'll write myClass and then some variable name, in this case object
01:25 equals new my class.
01:27 So now they've created an instance of this class.
01:30 Now what they want to do is listen for, or sometimes the word subscribe is
01:34 used, to this event.
01:36 To do that, they'll use the myEvent property which I've declared up there in myClass.
01:42 They'll use the += operator to specify a handler function that will be used
01:49 to handle that event.
01:51 This is called subscribing to an event, and it adds the handler function to the
01:55 list of functions that the myEvent is going to broadcast to.
01:58 Then what all I have to do is declare that function.
02:01 Here I've got a handler function, and notice that it matches the same format as
02:05 the delegate that I declared in the first line up there.
02:08 It say void function, and it takes two parameters, an integer and a string, and
02:13 then it implements whatever code there is.
02:15 Now this is the function that's going to be called whenever that event happens.
02:20 And you can see that there's the += operator. That subscribes to the event.
02:24 If you wanted to have your code to stop listening to an event, you would simply
02:28 use the -= operator and the same name of the function that you used to subscribe with.
02:34 So let's take a look at this in action in real code.
02:37 All right, so I've got my UsingEvents example open, and here is the
02:42 program code, and over in my snippets I've scrolled down to the using the events section.
02:46 So let's just take this one step at a time.
02:48 I'm going to first copy over the delegate declaration for myEventHandler.
02:52 So I am going to copy that and paste it inside my namespace here, outside my
02:57 program class. And this basically tells the C# compiler, hey there's going to be
03:02 this thing called a delegate which is an event handler and it takes a string
03:05 argument, and I'll supply that later. Don't you worry about it, but it's going
03:08 to be coming along.
03:09 Okay, now let's go ahead and declare a class, and this as an example class that's
03:15 just going to raise an event that other people can listen to. And I'll put that
03:20 class declaration up here above my program.
03:22 So let's take a look at the class declaration, and then we'll go further.
03:26 Here in my class I've got a member variable for this class on line 13, and
03:30 it's called theValue.
03:31 I've also got an event handler for valueChanged here on line 14.
03:37 So whenever this string value here called the value changes I'm going to
03:42 raise an event so that people who are using this class can listen for it and
03:46 say, oh, the value changed.
03:48 Then I've got a property right here starting on line 16. And if you are not
03:53 familiar with properties, you can go back and watch the section of this course on properties.
03:58 But I am exposing a public string property named val, and you'll notice that I am
04:02 only supplying a setter which starts here on line 18.
04:06 So the setter does two things.
04:07 First, it sets the value of theValue member variable to whatever the value
04:13 supplied to the property was.
04:15 And then it calls the value change event here on line 21.
04:20 So anyone who is subscribed to listening to this event is going to get notified
04:25 that the value has changed.
04:27 And it passes in the value of this private--the value member right here as
04:33 the first argument.
04:35 All right, so all that's left to do now is go back over to the Snippets and copy
04:41 over the code here that listens for the event, and I will put that in my Main.
04:50 So let's go through this line by line.
04:53 Here on line 30 I am creating a new instance of my event example class, and
04:59 that's this class right here-- the one that implements the event.
05:02 And I have got a variable called myEvt.
05:06 Then on line 32 I say myEvt.valueChanged, which is the name of the event.
05:11 All right scroll back up.
05:13 You can see there on line 14, that's the value changed event, +=new
05:19 myEventHandler, which is the name of the delegate. And then I need to supply the
05:25 name of the function that's going to handle that event. And the reason there is
05:28 a red squiggle there right now is because I haven't declared the my Evt_value changed function.
05:34 So let's go do that right now. Back over in the snippets I'm going to copy this
05:39 function right here.
05:40 This is my Evt value changed, and I am going to copy that and paste it, and I am
05:46 going to paste it below the Main function.
05:49 So now you can see the little red squiggle error has gone away, because now I
05:52 have a function which is going to handle the event.
05:55 And let's just take a quick look at the event handler.
05:57 So here on line 46, you can see that in the function all we do is just write out
06:02 the value of that argument that was passed to us.
06:06 And if we scroll back up to the class, remember that when we call this event
06:10 we are going to pass in the string that is represented by the private, the value
06:15 member of my class here.
06:17 So now we're pretty much about done; all we need to do is take a look at
06:21 what lines 34 through 41 are doing.
06:23 What I've got here is a string variable, and then I have a dowhile loop. And what's
06:29 going to happen is I'm going to read a line of text from the console, and if that
06:34 string is not equal to the value of exit, I'm going to set the public property of
06:40 the myEvt object to that string.
06:43 Let's scroll back up.
06:45 That's going to cause the setter of this property to trigger.
06:48 It's going to set the value of the theValue member variable to that string, and
06:54 then it's going to trigger the event.
06:56 And so this loop is going to just keep right on executing until I type in the word exit.
07:02 And when the word exit gets entered, the program will terminate, because there's
07:05 no more code after this in the Main function.
07:07 All right, so let's actually run this.
07:10 Okay, so now the program is waiting for me to put in the string, and I am
07:14 going to put in the word Joe. And you can see that when I set the value of that
07:19 string, the event handler gets triggered.
07:22 My event handler gets called.
07:24 The string gets passed in as the argument and we are just writing out that string.
07:28 I can type in anotherstring.
07:32 And once again, the event handler gets called. I can yet another string, and I can
07:37 go on and on like this, but now I am just going to change the value to exit, and
07:43 then the program terminates.
07:45 So that's how you declare an event handler and an event in C# using
07:50 delegates and the event keyword.
Collapse this transcript
11. Garbage Collection
How garbage collection works
00:00 Earlier in the course, you may have heard me refer to C# and .NET as a
00:04 managed-code environment.
00:05 What that basically means is that the .NET Framework provides automatic
00:09 memory management for you.
00:10 You as the programmer are not responsible for freeing up the memory that your
00:15 program's objects use during the course of the running of your program.
00:20 Now, this is not like other languages.
00:22 In languages like C and C++ and Objective-C, you as the programmer, when you
00:28 create objects that take up memory, you are responsible for making sure that
00:31 that memory gets returned to the system at some point.
00:35 But languages like .NET and other language like JavaScript in Java and so on,
00:39 those are managed-code environments.
00:41 There are ways that the system figures out that memory is no longer being used
00:45 by your program and reclaims it automatically.
00:48 Now, to take a simple example, when you do something like this in your C#
00:52 program, you have some object type definition, maybe you've made a new class,
00:56 and you use the new operator to create a new instance of that object,
01:00 that allocates memory somewhere in the system. That tells .NET, hey, you've got
01:05 to go find some memory to hold my object.
01:08 And the Framework will take care of figuring out when this object is no longer being used.
01:12 You don't have to do anything special. .NET will just figure out that you're
01:16 done using this object, and it will put the memory back in the system for you.
01:20 So let's take a look at conceptually how this works.
01:23 There is a big pool of memory available to the system, and we can think of it as
01:27 this big purple box you see right here.
01:30 Now, your program is going to use this memory during the course of its
01:34 operation. And as your program runs, it's going to allocate blocks of memory and
01:39 when it does that those blocks of memory are going to be taken out of the system
01:43 memory pool and assigned to your program. And then in your program will do
01:46 whatever it does with that memory and all these objects.
01:49 At some point there is a special class in the .NET Framework called the
01:53 Garbage Collector, and garbage collection is the process by which .NET figures
01:58 out that memory is no longer being used by your program and can take it back into the system.
02:04 So the Garbage Collector has a way of keeping track of the objects that you have
02:07 allocated, and when it figures out that these objects are no longer being used,
02:11 it simply puts them back in the system memory pool.
02:14 This process is completely invisible to your program.
02:17 You don't have to worry about doing this at all.
02:18 It all just happens for you.
02:20 So let's take a look at how garbage collection works.
02:23 Suppose we have a function, looks like this.
02:26 It's called myFunction. And inside myFunction I've got this new MyObject.
02:32 Well, out in the system memory pool when I do that, a block of memory is going
02:35 to be allocated that holds MyObject.
02:37 That creates what's called a reference.
02:40 That myObj variable that you created inside your function is now going to hold a
02:44 reference to that memory location.
02:47 Now, you can go and do a bunch of things:
02:49 you can call a method, you can set a property, you can call SomeOtherMethod.
02:54 But when that function ends, that myObj variable is going to go out of scope.
02:59 And at that point there are no more references to MyObject. Because that
03:03 variable is gone now, that little reference line disappears. And the Garbage
03:07 Collector comes along and says, hey, no one is using that thing anymore.
03:10 I can just return that object back to the memory pool.
03:14 So what are some important things to know about garbage collection?
03:17 First, your program does not need to initiate this process; the Garbage
03:21 Collector figures out when it needs to run and reclaim memory.
03:25 Now, there is a way for your program to initiate garbage collection, and we'll
03:28 actually take a look at that in an example in just a bit.
03:31 The Garbage Collector balances between performance and app memory usage, and the
03:38 objects are not necessarily reclaimed right away.
03:41 So these two things mean that you, A, don't know when Garbage Collection
03:47 is going to happen.
03:48 The Garbage Collector tries to figure out how your program is doing its work and
03:52 how much memory is being used, and it tries to strike a balance between making
03:57 sure that your application doesn't take a performance hit while figuring out how
04:02 much memory is being used and trying to say, okay, well, memory use is getting
04:05 kind high, maybe I should go take some of that memory back.
04:08 The other thing you need to realize that when you're finished with an object,
04:11 it might stick around for a while until the Garbage Collector figures out that it needs to run.
04:15 Now, objects can detect that they are about to be released from memory, so
04:20 when you create an object in a class, you can actually write a method called the finalizer.
04:25 Now, this is rather advanced.
04:27 I'm not going to cover it in this course. But you can just be aware that there
04:31 are ways for your objects to figure out that they're about to be released back
04:35 into the system memory pool.
Collapse this transcript
The Garbage Collector object
00:00 Let's take a look at a real example to see how garbage collection actually works.
00:04 So I've got my Garbagecollection project open up here, and in my Snippets file I
00:09 have scrolled down to the Garbage Collection section.
00:11 So let's go ahead and take a look at some of the garbage-collection routines
00:16 that are available to us.
00:18 So first I'm going to copy these three lines and paste them into my application.
00:24 Now there is a global object in .NET called GC.
00:29 You can see I'm using that right here on line 12.
00:32 The GC object is the Garbage Collector, and I'm going to call a function on the
00:38 GC object which is a static function here called GetTotalMemory. And it takes a
00:43 parameter--I'm not going too deeply into this. Don't worry about what this does.
00:46 Basically I'm saying to Garbage Collector, hey, tell me how much total memory is
00:50 currently allocated to my application.
00:52 So this is a pretty simple place to start.
00:54 Let's just build this and run it and see what happens.
00:56 So I'm going to run it, and the console is going to write out how much allocated
01:00 memory there is to my app. And you can see that when I run this the amount of
01:05 memory that's allocated to my application right now is 186,836 bytes.
01:10 Now don't worry if this number looks different for you and your example. This is
01:14 going to different for everyone's system.
01:16 This is basically how much memory is currently allocated to my app.
01:20 So let me hit Return, and we'll exit the app.
01:23 Okay, let's go back to the snippets and paste in some more information.
01:26 So the next few lines I am going to copy right here, and I'm going to paste
01:29 those below these lines.
01:32 So starting on line 16, I'm going to allocate 100,000 bytes in an array that holds bytes.
01:40 So this is 100K of memory that I'm going to allocate, and then I'm going to
01:44 basically do the same thing here on lines 18 through 20 that I do at the
01:49 beginning of program. And we'll see if this makes a difference in how much memory
01:52 that Garbage Collector thinks is allocated to my programs.
01:55 So let's run, and you'll see that we start off with 186,000 bytes.
01:59 Now let me hit Return, and this is going to cause the allocation to happen.
02:03 And now you can see that the amount of memory allocated to my app is 295,060 bytes.
02:09 Now notice it's not exactly 100,000 bytes more than the original size. Again,
02:15 don't worry too much about that, and don't worry too much if this number looks
02:19 different for you on your system.
02:21 The .NET Framework keeps track of a whole bunch of overhead internally, so when
02:26 I allocated those 100,000 bytes, a lot of other things happened under the hood.
02:31 So it looks like more memory got allocated then I asked for, but that's just the
02:35 .NET Framework doing its work.
02:36 So let's go back to the application.
02:40 Now what we're going to do is actually trigger the garbage-collection process,
02:44 so I am going to copy these lines here, and I'm going to paste them in here.
02:49 And you'll notice that on line 22 I'm calling the Garbage Collector's collect method.
02:54 This will actually trigger the garbage-collection process.
02:58 So we're going to start off by seeing how much memory my application gets when
03:02 it starts. Then we're going to allocate a whole bunch of memory and see how much
03:06 that changes things.
03:07 Then we're going to call the Garbage Collector's collect function which will
03:11 cause the Garbage Collector to go out and look at memory and say, hey, how much
03:14 memory isn't being used and how much can I reclaim? And that's going to be this
03:19 line right out here. We're going to write out what the results of that are, so
03:22 let's save this and run it.
03:25 Okay so we start with 186k. It goes up to 295k. Now let's watch what happens
03:32 when the Garbage Collector runs and we call that collect function.
03:34 Okay, it looks like the allocated memory dropped back down to about 210,000,
03:40 almost 211,000 bytes.
03:42 Again, I didn't get all hundred thousand bytes back, and that's because, as I said,
03:48 earlier the .NET Framework has some overhead that it's working on. So it did
03:52 figure out, however, that those bytes actually aren't being used by anybody.
03:56 So I was able to reclaim those bytes by running the garbage-collection process.
04:01 Now again, I want to emphasize that this is just an academic exercise here and
04:05 shows you how the Garbage Collector works.
04:07 There are going to be very few instances in your C# career when you're going to
04:11 have to actually care about running the Garbage Collector, if ever.
04:15 I've been working with C# for a long time.
04:17 I've never actually had to do this. But it interesting to see how the Garbage
04:20 Collector works and what you can do with the Garbage Collector to figure out how
04:24 much memory your application is consuming.
Collapse this transcript
12. Debugging
Common compilation issues
00:00 In the long, and no doubt illustrious, C# coding career that lies before you, you
00:06 are going to have to deal with compiler issues and bugs, and that's what we're
00:10 going to talk about in this section, debugging, and we're going to start off with
00:14 dealing with common compilation issues.
00:17 Now, many of these are fairly common, and they tend to trip up new C# developers.
00:22 Don't feel bad if this happens to you.
00:24 I personally assure you that I myself have committed every single one of the
00:28 issues I am about to show you.
00:30 So I've got my CompileIssues sample project opened, and what I am going to do is
00:33 walk through each one of these issues and show you why each one is a problem.
00:38 So I am going to start with issue number one.
00:40 Let me uncomment this line of code, and we'll save. And we've got a problem.
00:45 In fact, let me hit the F6 button to try to build, so we can see what the
00:48 problem exactly is, and I will scroll that code into view.
00:52 We can see here down in the error list it, says, ah!
00:54 There is a semicolon expected.
00:57 Well, a semicolon is expected at the end of every line of C# code.
01:02 If you're coming from a language like JavaScript where semicolons are optional,
01:06 you need to realize that in C#, that's not the case.
01:08 You do have to have a semicolon that terminates every single one of your statements.
01:13 Double-click on the error, and it takes us right to that point in the code.
01:17 We can put in our semicolon, and save, and then we can build, and now everything
01:21 is all right again.
01:22 Now we're getting a bit of a warning here that says that the myString variable
01:26 is assigned, but it's never used, but let's just ignore that for the moment.
01:30 Go down to issue number two.
01:32 So issue number two, I am going to uncomment this line of code, and once again we
01:35 get a whole bunch of errors.
01:38 Sometimes it's tempting to try to look for the error that's the simplest to fix
01:42 and try to fix it that way.
01:43 In fact, if you look in the error list, you'll see that there's a bunch of errors.
01:46 One of them says "; expected," One of them says ") expected."
01:50 So you might be tempted to just jump to that line and try to like put a
01:53 semicolon in to fix things;
01:55 that's actually the wrong thing to do here.
01:57 What I suggest you do is start with the topmost error, because sometimes when
02:01 you fix the topmost error, that will fix all the errors below it. And if you
02:06 look really closely at this line, you'll notice that the problem is that I
02:10 didn't close off the string using double quotes. And sure enough, once I do that,
02:16 all the other errors go away.
02:18 Before you try to figure out which is the easiest problem to solve, try to
02:22 figure out what the actual error is, because now you can see that the compiler
02:25 is saying, oh yeah, there is a semicolon, and oh yeah, there's the parentheses.
02:29 It just couldn't see them before, because it thought they were part of the
02:32 string, Hello World.
02:35 In the next issue, I'm going to use an ArrayList.
02:37 If you watched the section on collections, you know what ArrayLists are.
02:41 They are a type of collection that works like an array.
02:44 I am going to uncomment this line, and sure enough, we've got problems.
02:48 If we look in the error list, it says, "The type or namespace name
02:53 ArrayList could not be found (are you missing a using directive or an
02:57 assembly reference?)."
02:58 That's just a very long-winded way of the C# compiler saying, I don't know what that is.
03:03 And there's also a visual cue.
03:05 You'll notice that objects that are recognized by the C# compiler are
03:09 highlighted in a certain color, like the console object right here.
03:13 Now ordinarily, ArrayList would be highlighted as well, and it's not, and that's
03:17 your first clue that something is wrong, along with this giant red squiggle
03:20 underneath it that gives you the error.
03:23 It turns out that the problem is I have not included the right namespace in
03:27 order to use ArrayLists.
03:29 So I have to scroll to the top of the file, and sure enough, I'm using the
03:34 System.Collections.Generic namespace, but ArrayLists are contained in the
03:39 System.Collections namespace.
03:42 So I have to say using System.Collections. And when I put that using statement
03:49 in, you can see that the problem goes away.
03:53 Let's scroll back down to where that code is, and you'll see now that the
03:57 ArrayList object is highlighted in light blue the same way that the console is,
04:02 which means that the C# compiler is recognizing it. All right!
04:06 Let's move on down to the next issue.
04:08 I am going to uncomment these lines of code right here.
04:12 I am going to save, and you see that we're getting a complaint that a
04:22 curly brace is expected.
04:24 The curly brace is actually expected way down at the end of the program. Well,
04:28 clearly something is pretty wrong here.
04:31 And if we scroll back up to where the error actually is, you'll notice that
04:36 I've got my open curly brace here and a closing curly brace here, and those seem to match up.
04:42 You can see that when I put the cursor next to the curly brace, the IDE
04:46 highlights the two braces to show me they match.
04:48 But the problem is that I have actually got an extra one all the way over
04:51 here on the end of the for statement, and that's causing the compiler to
04:56 think that all the rest of the code following that line is contained in an
05:01 unclosed curly brace block.
05:03 Once I get rid of that extra curly brace and I save and I hit F6, you can see
05:09 that that error goes away.
05:11 So the lesson here is, indentation does not necessarily mean what blocks are.
05:17 You have to put braces so they match each other.
05:20 Just because you put one brace up here and another brace in another line down
05:23 there, does not mean that those make a block.
05:26 You have to make sure that you have the same number of closing braces as you
05:30 have opening braces; otherwise, you're going to get weird errors like that.
05:35 Let's move on to issue number five.
05:37 I am going to uncomment this string right here, I am going to save, and I am
05:41 going to get a nice big red squiggle.
05:43 It says down here in the error list:
05:45 "Too many characters in character literal" and "Cannot implicitly convert
05:50 type 'char' to 'string'."
05:53 What's going on here?
05:54 I've got my quotes.
05:55 I've got the string defined. The problem here is that you can't use single
06:00 quotes to define a string in C#;
06:03 you must use double quotes.
06:05 The single quotes are for individual characters. And so you see that when I put
06:12 the single quotes into double quotes, the error goes away.
06:16 Now, I am getting another warning that says that that string is not used, but
06:18 don't worry about that for now.
06:20 Scroll down to the next issue.
06:21 I'm going to uncomment these two lines.
06:29 So I have an integer array of values and it's called myarray = 0, 1, 2, 3, 4,
06:36 so we've got 5 items in the array, and then I am trying to set the array item at
06:41 index 2 to be 10, and I am getting an error.
06:44 It says "'myarray' is a 'variable', but it is used like a 'method'" and the
06:49 problem here is that you don't use parentheses to index into arrays; you
06:54 use square brackets.
06:58 Parentheses are used for calling function; brackets are used to index into arrays.
07:05 You can see that once I change the brackets, everything is fine. All right!
07:08 Let's go on to the next issue.
07:10 I am going to uncomment this call to Console.WriteLine, and then I get an error.
07:15 It says, "'System.Console' does not contain definition for 'Writeline'."
07:19 What are you talking about? Sure it does.
07:20 I've been using Writeline throughout this course.
07:23 There's a function there called Writeline.
07:24 I know that there is. In fact, I used it probably up here earlier. See, there it is!
07:28 And then I realized, oh, wait a minute!
07:29 No, there is a capitalization problem in there.
07:33 That actually has to be a capital L. That's because C# is a case-sensitive
07:39 language; case matters.
07:41 This is something you'll run into probably at least once when you're
07:44 writing your C# code.
07:45 You need to make sure that the cases match. That's true of variables.
07:49 It's true of function names.
07:50 It's true of almost any type of declaration that you make in C#.
07:55 Let's move on to issue number 8.
07:58 In issue number 8 I have got three lines of code.
08:01 I've got an integer variable that's set to 2,500,
08:04 I've got a floating-point variable that's set to 35.895, and then I'm trying
08:12 to set the value of f into the value of i. Now, I've got two different
08:18 problems going on here.
08:19 First, "A local variable named 'i' cannot be declared in this scope, because it
08:23 would give a different meaning to 'i', which is already used in a 'child' scope
08:26 to denote something else."
08:28 That's a very, very long-winded way of saying, you know what, I've already used
08:32 i somewhere else in this code block.
08:34 So if I scroll back up, there it is.
08:37 I've already used the i variable in this for loop.
08:41 So it's not going to let me use it again down here.
08:44 No problem. I will just simply call this i1, and I will call that one i1.
08:51 I've got another problem. The problem here is-- let's look at the error list--"Cannot
08:55 implicitly convert type 'float' to 'int'.
08:58 An explicit conversion exists (are you missing a cast?)." Yes, I am.
09:04 Remember, you can't implicitly cast a variable that is of a larger size into a smaller size.
09:11 You have to explicitly tell the compiler that you're doing that.
09:14 So what I need to do to convert a float into an int, I have to put the word int
09:19 in parentheses. And what this tells the compiler is, hey compiler!
09:23 Treat that floating-point number as if it were an integer, which will let me
09:27 assign it to another variable that is of that same type--in this case integer.
09:32 And you can see when I put that cast in front of the F, everything goes away, and we're fine.
09:37 Next issue, issue number 9, I am going to uncomment these lines.
09:41 I've got two integer variables: one named a, one named b. And then I've got an
09:45 if statement, if (a = b) then we're going to write out, yup!
09:49 They're equal numbers, and no sooner do I do that, then oops!
09:52 I get an error, and it says, "Cannot implicitly convert type 'int' to 'bool'."
09:57 What's the problem here?
09:58 I am not trying to convert anything to anything.
10:01 Well, remember that inside if statements what you're checking for is a Boolean condition.
10:06 That's how the if statement knows to execute. And the problem here is that I'm
10:10 not using double equals signs.
10:12 I'm using the assignment operator, not the equality check operator.
10:16 So once I change this to the equality check operator, the error goes away,
10:20 and everything is fine.
10:22 One more issue that I want to show you, and you'll run into this, and sometimes
10:27 it can be pretty confusing as to what's going on.
10:29 I am going to uncomment this entire function.
10:31 I've got a function here called func, and it takes an integer variable and if
10:38 that integer parameter is greater than 0, then it returns 0.
10:43 If that parameter is less than 0, it returns -1.
10:46 But I'm getting an error.
10:48 It says, "CompileIssues.Program.func: not all code paths return a value."
10:55 The problem here is that I've declared this function to return an integer value,
11:00 and I am returning an integer value here and returning an integer value here.
11:05 But what happens if the parameter a is equal to 0?
11:08 Well, there's no path in here that returns a number.
11:12 I have to make sure that if my function is going to return a value, then all of
11:16 the possible code paths that it can take have a return statement in there.
11:20 There's a couple of ways I can fix this.
11:22 I could put in an if case for a is double equal to 0, but since that's
11:27 the only case left, and the function would have returned by now if any other
11:31 case have been encountered, I can just simply say return whatever else.
11:35 I can say return 100, or I can return 1,000, or I can return whatever I want as
11:40 long as it is a valid return type.
11:44 Those are 10 of the most common compilation issues that you'll probably run
11:48 across in your C# coding.
11:50 Next, we're going to take a look at how to use the debugger to look at
11:53 code while it's running.
Collapse this transcript
Setting breakpoints and examining code
00:00 As useful as it is to be using the console and the Console.WriteLine methods to
00:06 see what's going on inside our application while it's running,
00:09 there's really no good substitute for using a good debugger which you can use to
00:14 examine the code while it's actually running. And the debugger allows you to do
00:18 things like place breakpoints in your code, examine the code, examine variables,
00:23 change things while it's running, and so on.
00:26 If you've done any kind of programming in other environments, like, say,
00:29 JavaScript using either Firebug or the WebKit Developer tools or coding
00:34 environments like C++ or Java, you might be familiar with using a debugger.
00:39 If not, don't worry about it.
00:40 I am going to show you how to use the debugger that's contained here in the free
00:44 version of Visual C# Express.
00:47 I am just going to use the existing example that we've already got from the
00:51 section that we did on reading and writing file data, so I've got that example
00:57 back open in my editor here.
01:00 Take a quick look. Under the Debug menu,
01:03 you'll see that there are a couple of options related to debugging.
01:07 There's the Start Debugging option, which is this option right here on F5,
01:10 and that's actually how I've been running our examples each time we've tried them out.
01:14 I just hit F5 and that starts the debugging process.
01:18 You can also start an application without debugging by doing the Ctrl+F5. But if
01:22 you want to actually have debugging information, you'd use the F5 version.
01:25 There are also things like Step Into and Step Over, and things like Toggle
01:30 Breakpoint, and we are going to see how each one of these works.
01:33 So let me close this menu. And the first thing I am going to do is show you how
01:38 to place a breakpoint.
01:40 Here we have our Main function, and the Main function is going to be the entry
01:45 point into our application from the .NET Framework.
01:48 The .NET Framework is going to find this function and then call it to start our program up.
01:51 So the first thing I am going to do is find the first place where I can put a
01:56 breakpoint. And it looks like this line right here, line 14 is where our program
02:00 actually does something.
02:02 So way over here in the left-hand side of the gutter, next to the line numbers, I
02:06 am going to click, and you see that when I click, a couple of things happen.
02:10 First, this little red circle shows up.
02:13 That little red circle indicates that it is a breakpoint, and you'll notice that
02:17 when I place that breakpoint, all the executable code that gets associated with
02:22 that line--in this case, it's line 14 and 15, because I have one statement
02:27 that's spanning multiple lines--gets outlined in red. And it indicates to me
02:32 that that is a breakpoint.
02:34 A breakpoint is a point in the program where when you're running the
02:37 application, the debugger will stop execution right before it's about to
02:42 execute that statement.
02:44 So let's go ahead and start debugging the program.
02:47 Open the Debug menu. I am going to choose Start Debugging, or you can just press F5.
02:54 Now when I do that, you saw the Console window kind of momentarily come up there
02:58 and then disappear behind the IDE. And now you can see this little yellow arrow
03:03 inside that little breakpoint there, and it shows me where the current statement is.
03:08 The breakpoint that was red is now outlined in yellow, and you can see that
03:13 we've got a couple of other windows that have shown up.
03:15 Down here in the bottom, on the left- hand side, we have the Locals window.
03:21 We also have something called the Watch window.
03:24 The Locals window shows me all of the local variables that are currently
03:29 within the current scope.
03:31 So inside the Main function, I can see all the local variables that I can
03:35 currently have access to.
03:37 Over here in the Call Stack, this shows me all of the functions that have been
03:41 called leading up to this point.
03:43 Now right now we are in the main function.
03:46 I have only got two items on the Call Stack.
03:48 I have got External Code which is the .NET Framework's execution engine, and
03:52 then I've got the ReadingWritingData. exe!ReadingWritingData.Program.Main, so
03:58 that's the function that I'm in.
04:00 so ReadingWritingData.exe! that's my program.
04:03 ReadingWritingData is my namespace. Program is the class.
04:06 That's this program right up here.
04:08 Main is the function, and it says I am on line 14. And sure enough, if I look
04:13 over at the little arrow, yes, I am on line 14.
04:17 The other thing that happens is that this little Debug toolbar showed up in my
04:21 toolbars up here. And I have got buttons for Continuing, so if I hit F5 right
04:25 now, the program will just continue to run until it reaches the next breakpoint.
04:29 Or I can stop debugging which will stop the application, or I can restart.
04:34 I can have the program go back to the beginning.
04:36 I can click on this little yellow arrow here to show me what the next statement
04:39 is going to be, and that's where the yellow arrow right over here is.
04:42 I've also got these three icons for Step Into, Step Over, and Step Out, and we'll
04:49 take a look at what each one of these is.
04:51 To step over this code, I can simply choose the Step Over function.
04:56 That will cause the current statement, the one that's highlighted right here, to
04:59 execute. And if you look down here in the Locals window, you will notice the
05:03 filePath variable right now is null.
05:07 There is no value assigned to it.
05:09 Watch what happens when we step over that line.
05:13 First, the little yellow arrow goes to line 18, because that's where the next
05:18 line of executable code is.
05:20 The second thing that happens is, if you look down in the Locals window, the
05:24 filePath variable now has this string in it, and it has a path to the example
05:30 file.txt. And you notice also it's red, and the reason it's red is because the C#
05:36 debugger is highlighting the local variable that changed.
05:41 After I step again, it's going to stop being red, because it's not going to
05:45 change after that point.
05:46 I can scroll down a little bit here.
05:49 Now if I wanted to, I actually could just simply change the value that's in
05:53 this local variable.
05:54 I can just double-click on it and say, you know what?
05:56 I don't want it to be called examplefile.txt; I want it to be
05:59 called joesfile.txt.
06:05 I just changed the contents of that variable while the application is still running.
06:10 So now this line of code right here is going to check to see if the file exists,
06:14 and it does not. So when I step over that statement, we'll see that the brace
06:20 gets highlighted, and I step again, and now we step into the if statement.
06:25 So now we are going to create that file and set its contents.
06:30 And once again, I can step over this, and you can see now that this content
06:34 variable has changed.
06:36 So I can also do things like hover over using the mouse.
06:40 I can hover over things that are in the code.
06:42 For example, if I hover over the Environment.NewLine statement right here, you
06:46 will see I get this little pop-up window that says what the new line's value is.
06:50 And you can see that it's \r\n. Or I can hover over this local variable, and it
06:55 shows me what the contents of that local variable is.
06:58 I can also hover over things that are built into the .NET Framework.
07:01 I can hover over the file class, for example.
07:03 When I hover over the file class it shows me that it's of type System.I/O.File,
07:09 and I can click on this little expander here, and it shows me all the things
07:13 that are inside that file class.
07:16 Now, it's a built-in class, so it's not going to show me very much, because
07:19 it's in native code.
07:20 But I can now just use my debugger to step through this code, and I can watch
07:25 the application as it runs.
07:27 You will see that variables are changing.
07:30 I can change the value of variables and so on.
07:33 If I've gotten tired of just stepping through this, I can just go ahead and hit
07:37 the little green arrow, which will cause the application to run, and we can see
07:42 that the application is now running.
07:43 And if I go ahead and hit the Return button, the application will stop, the
07:48 debugger stops, and I am dumped back into my text editor.
07:51 Let's make a slight modification to this application.
07:54 What I'm going to do is make a function, and I am going to make a function down
07:59 here called static void ReadAndListContents(). And it's going to read and list
08:13 all the contents of the file. So basically, I am going to copy these lines of
08:17 code right here, take them out of the Main function, and put them into a
08:22 function And I am doing this because I want to show you how the Step Into
08:26 functionality works.
08:27 I'll just get rid of that comment right there.
08:30 I need to pass in the filePath, and I also need to call that function,
08:37 so we'll call ReadAndListContents with the filePath. And just to isolate this,
08:47 we'll take out this code right here, so that we only have one piece of code,
08:52 that's ReadingAndListingTheFileContents.
08:55 What I am going to do is run the application again, and it's going to stop at
09:00 this breakpoint right away.
09:02 This time I am going to start at using this little green arrow right here.
09:06 You can see that the breakpoint got hit.
09:08 What I am going to do now is scroll down and I am going to place a breakpoint
09:12 on this function call.
09:13 So I just click there to place another breakpoint, and now I'm going to hit the
09:18 little green arrow again, which is going to continue on to the next breakpoint.
09:22 The application ran until it got to this breakpoint.
09:25 Now I can use the Step Into function, and that's this icon right here.
09:31 If I wanted to just simply execute this function without stepping into it, I
09:34 could use the Step Over.
09:35 That doesn't mean skip over the function;
09:38 it means execute it but don't go inside. Just do whatever the work it does, and
09:43 then go on to the statement at the level where I currently am.
09:46 So if I stepped right now, the next statement would be this Console.ReadLine.
09:49 But if I do a Step In, I will actually step into that function.
09:55 And now I can do Step Over and Step Over again, and you can see now that the
10:00 current line, as indicated with this little yellow arrow right here, is inside the
10:04 ReadAndListContents.
10:06 I could just simply keep on stepping and stepping and stepping and
10:09 going through these foreach statements and so on, or I could use the Step Out function.
10:15 If I click on Step Out, the execution is going to continue to the end of this
10:19 function and it's going to put me back into where the calling context was.
10:23 If I click Step Out, now I'm back out here where ReadAndListContents was called,
10:30 but now the function has finished executing and if I step again, I'll go on to
10:34 the next statement, which is the Console.ReadLine.
10:38 That's a pretty quick introduction to using the debugger.
10:41 The nice thing about the debugger is that it allows you to slow down the
10:44 program's execution so that you can see things as they are happening.
10:47 And as you saw, we were able to place breakpoints and examine variables.
10:51 We were able to change the contents of variables.
10:54 We were able to step into and out of functions.
10:56 The debugger really will become your best friend as you're writing your code
11:00 because it makes debugging of your applications so much easier.
Collapse this transcript
Using the Debug class
00:00 Throughout this course I've been using the console window to write out
00:03 debugging and other diagnostic information so that we can see what's going on
00:08 inside the application.
00:09 For examples like this, that's all well and good, but when you write your real
00:12 applications, if you're writing a console application, you probably don't want
00:15 to have it littered with debugging information that your users are going to see.
00:19 Or if you're writing an application that doesn't use the console window at all,
00:22 you're going to need to have some other way to get that output visible to you
00:26 while you're debugging your app.
00:28 The way that we are going to do this in this particular example is by using
00:31 the System.Diagnostics namespace, which gives us access to something called the debug class.
00:38 The debug class gives us a way for logging debugging information in a way that
00:42 we can see it which doesn't interfere with the actual output of the program.
00:48 To use the debug class, I am going to do a couple of things.
00:51 See, on line 16 the System. Diagnostics namespace. This gives me access to
00:57 something called the debug class, which gives us a bunch of features that are
01:00 similar to what we've been using the console window for--
01:03 WriteLine statement and a few other things that we'll take a closer look at.
01:07 The debug class is going to log all this information to a place called the
01:11 output window, and the output window is going to show up here in the IDE
01:15 when we make it visible.
01:17 To use the output window, there is a couple of things you are going to have to do.
01:20 First, under the Tools menu, go down to the Settings submenu and make sure that
01:25 the Expert Settings option is checked.
01:27 Once you've done that, under the View menu, there will be an option for Output,
01:32 and when you choose Output this little output window will show up here in your IDE.
01:37 Don't worry about the Show output from option just yet. Tight now it's empty,
01:40 but that will be filled in for us.
01:43 If you are a sharp-eyed reader, you'll notice that I'm using pretty much the
01:46 same code that we used in the Reading and Writing Data Files example, although
01:51 I've re-organized it a little bit to use functions and so on.
01:55 What we are going to do now is first build the application, so hit F6.
02:01 And you'll see that down in the output window, a whole bunch of information was
02:05 logged for us by the IDE.
02:07 It says that the build was started, and then there is a line that says,
02:09 hey, Build 1 succeeded.
02:11 So everything looks pretty good.
02:13 Our code can also use this same output window to log debugging information, and
02:18 the way that we are going to do that is by using the debug class.
02:21 Go ahead and scroll down and see how the debug class works.
02:25 This code probably looks familiar to you if you watched the earlier example on using files.
02:30 I'm not going to focus too much on that.
02:32 What I am going to focus on instead is the information that I've put into the
02:35 file to help with debugging.
02:37 Here's a debug class call. And you will notice that the debug object has a
02:42 function called WriteLine, which works pretty much the same way that the
02:47 console's WriteLine object works as well.
02:50 Only instead of sending output to the Console window, this is going to write
02:54 information out into this output window down here.
02:58 Here I am write-lining out some piece of information that the file was created,
03:02 and so on and so forth, and we do the same thing down here.
03:06 A couple of other features, though.
03:07 There is a assert function call, and assert basically makes sure that the
03:13 Boolean condition supplied in here is true.
03:17 If it ever evaluates to false, the debugger is going to pop up and say, hey,
03:21 something went horribly wrong in your program.
03:23 You might want to take a look at it. And we'll see an example of that in a little bit.
03:26 We also have this here, Debug Indent and Debug Unindent, and that will help us
03:32 make our debug log output more visible in the output window below, which we'll
03:37 see in just a moment.
03:39 Let's go ahead and run this program, and we'll see what happens.
03:43 Let's just take a quick refresher of the code.
03:46 You can see that when the code starts
03:47 we have a string variable that holds a filePath, and we are going to create a data file.
03:52 We are going to write some information out to it,
03:54 and then I am going to read the contents back in. And all that's going to be
03:58 happening in these functions down here.
04:00 We have a function for creating the file, we have a function for writing the
04:03 file content out, and then we have a function for reading the content back in.
04:09 So the last thing I want to point out before we run this is that unlike the
04:12 console window, the debug object has a special version of WriteLine.
04:17 It's called WriteLineIf.
04:19 What you do here is you supply a Boolean expression. If this expression
04:24 evaluates to true, then the WriteLine happens; otherwise the WriteLine doesn't happen.
04:29 In this particular case, we are saying Debug.WriteLineIf the contents array
04:34 length is greater than 2.
04:37 Well, if that length of that array is more than 2, then this particular
04:41 WriteLine will happen; otherwise it won't. So let's go ahead and run this example.
04:49 We ran the file, and we added a whole bunch of content to the file, so let's
04:53 go ahead and hit Return to exit, and let's go examine the output in the output window.
05:00 The first thing you will notice is there is a whole bunch of output messages
05:03 that were put here by the .NET Framework.
05:06 You don't really need to pay attention to any of these.
05:08 These are messages that the debug version of .NET Framework is sending out for
05:13 you to look at as a programmer, but for now, we are just going to ignore that.
05:16 What we are going to do is look for our first examples of debug output, and
05:20 they are right here.
05:21 For example, we have Writing File Data, File Data Written,
05:26 The file has more than two lines.
05:28 Well, where did those come from?
05:29 Well, if we scroll down in our content, we can see right here, this did not
05:35 execute, because the file already exists, but if the file hadn't existed,
05:39 we would have called the WriteLine function for creating the file with content whatever.
05:43 However, when we write the file data out, you'll notice that the WritingFile
05:48 Data string got written out, and because it's indented, right here you can see
05:53 that there is a little bit of a tab space in here, which makes the debug
05:56 information a little bit easier to read.
05:59 Down here we do the same thing. After the file's data has been written, we have
06:03 a debug output statement that says the file data has been written, and that's
06:07 also indented. And because the contents of that file had more than two lines,
06:13 you can see that this WriteLineIf statement executed.
06:17 Let's do one more example.
06:20 Let's see if we can get this assert to trigger right here.
06:26 What we are going to do is pass in an empty string content to write to the file.
06:32 I've decided that here in my application that anyone who calls this function has
06:37 to provide string content that's not empty.
06:41 If I pass in an empty string, I want my program to raise a warning message and
06:46 say that someone has tried to do something that I don't approve of. And the
06:50 great thing about these debug messages is that when you build the release
06:54 version of your code, none of this stuff gets included;
06:57 only the debug version of your application will contain these debug calls.
07:04 So let's go back up into the code here.
07:05 I'm going to uncomment this call to WriteFileData, and I am going to pass in an
07:13 empty string. And that's going to cause that assert to pop up.
07:18 Let's see what happens when I try this.
07:20 I am going to run this.
07:22 When I ran this, the Assertion Failed dialog message comes up.
07:27 So here the title says Assertion Failed, and then I have some options. Do I want
07:30 to abort or retry or ignore?
07:33 Now this is a non-fatal assert, so I can just go ahead and ignore it if I want to.
07:38 But for now what I am going to do is click Abort, which will cause the
07:42 application to stop.
07:43 I can see where that assert was. It's down in here.
07:47 You notice that there wasn't a whole lot of helpful information that came up in
07:51 that Assert box, just a big stack of messages that says, hey, here's the
07:55 function where things went wrong.
07:57 So I can include a message in this assert.
08:01 I can say, "Tried to call WriteFileData with an empty string."
08:10 This version of the Assert function will not only pop up the dialog;
08:15 it will give me a nice easy-to-understand message, so I can see what's going wrong.
08:19 Let's try that one more time. And you can see that this time, next to that
08:24 little red error message that says, Tried to call WriteFileData with an empty string,
08:28 that's the message that I put into my Assert box, and it shows me all the
08:32 functions that got me to the current place.
08:35 So right here at the top it says, at Program.WriteFileData.
08:38 That's where the assertion happened. And you can see that we got there by
08:42 calling through Main, and then we came in via the .NET Framework.
08:46 These are all the .NET Framework functions right here. Bt it shows me how we
08:49 got to where the assert is.
08:51 So I am going to click Abort. And then at this point I would go back and I would
08:56 try to figure out, okay, who is calling WriteFileData, who is doing it with an
09:00 empty string, and so on?
09:02 This is how you can use the debug class to add some extra debugging information
09:08 right into the IDE while you are debugging your application.
Collapse this transcript
Conclusion
Goodbye
00:00 Well, that brings us to the end of C# Essential Training, and I want to thank
00:04 you for joining me as we explored the basic concepts of the C# language.
00:08 You are probably wondering where you should go next, and I have a few
00:11 recommendations for you.
00:12 Spend some time exploring the online documentation for the C# language and .NET
00:17 Framework on the Microsoft Development Network web site at msdn.microsoft.com.
00:23 This is a very good reference resource for learning more about many of
00:26 the objects, classes, and language features that we were introduced to in this course.
00:31 Since C# is the foundational language for other Microsoft frameworks, such as
00:36 Silverlight, Windows Phone, and ASP.NET,
00:39 take a look at some of the other programming resources in the lynda.com Online
00:44 Training Library, such as Objective-C or JavaScript Essential Training.
00:48 Seeing how other languages approach similar problems and situations can
00:53 significantly increase your understanding of how each language has its own
00:56 benefits and drawbacks, and will broaden your understanding of the discipline of programming.
01:01 Finally, go back to some of the examples in this course and try some experiments.
01:05 The more practice you have with the language, the better a C# programmer you will be.
01:09 Good luck with your C# coding!
Collapse this transcript
Introduction
Welcome
00:04 Hi! I am Joe Marini, and I'd like to welcome you to C# Essential Training.
00:08 I've been working with C# since its initial release back in 2001.
00:12 C# is a great choice for applications that run on a wide variety of
00:17 Microsoft platforms.
00:18 We will start off with the basics:
00:20 installing the free C# development tools from Microsoft, understanding the basic
00:25 structure of a C# program, and getting your first program up and running.
00:30 Then we'll move on to more advanced concepts, like defining your own C# classes.
00:35 I will also cover subjects like automatic memory management and reading and
00:39 writing data files, and we'll see how to do all of this while using the free
00:44 Visual C# Express development tools to build and debug your C# applications.
00:50 So if you're ready to take a look at the foundation language for targeting
00:53 Microsoft platforms then let's get started with C# Essential Training.
Collapse this transcript
What you should know
00:00 In this course, I am going to make a couple of assumptions.
00:03 First, I am going to assume you have some experience working with
00:06 Windows-based computers.
00:08 Second, I'm going to assume that you have some amount of prior programming
00:12 experience--not necessarily a lot of experience, and I don't expect that you've
00:16 ever even seen C# before.
00:19 But you do need to at least know what things like variables, functions,
00:23 loops, et cetera, are.
00:24 These are the basic fundamentals of any programming language, not just C#.
00:29 Just to be clear, this course is not an introduction to the fundamentals of programming.
00:33 What we are going to be focusing on are the fundamentals of the C# language itself.
00:39 Along the way, we will do some work with the .NET framework, which is
00:42 Microsoft's runtime and class library that C# uses to build and run programs,
00:47 but we will mainly focus on learning the C# language.
00:51 If you already know a programming language, like C or Java or Objective-C or
00:57 JavaScript, then many of the C# constructs will look very familiar to you,
01:02 but don't be fooled;
01:02 C# is its own language with its own way of doing some things some of which are
01:07 different from all the other languages out there.
01:10 Of course, if you're coming from a very different language, like Ruby or Python
01:15 or Perl, that's fine too;
01:17 you won't have any problem following along with this course.
Collapse this transcript
Using the exercise files
00:00 If you are a Premium member of the lynda.com Online Training Library, or if
00:04 you're watching this tutorial on a DVD-ROM, you have access to the exercise
00:09 files used throughout this title.
00:11 If you look inside the exercise files, you'll find folders that contain all the
00:16 various exercises that I'm going to use in this title.
00:19 The way that they're organized is, each one of the chapters has its own set of example files.
00:24 So for example, if I look inside the folder for Chapter 5, you will notice that
00:28 there are bunch of subfolders that are named according to the particular section
00:32 that's being described in that particular chapter.
00:35 If you look inside these folders, you will notice that there is a C# Express
00:40 project file, along with a folder that contains the code for that exercise.
00:45 When you have installed the Visual C# Express developer tools from Microsoft,
00:50 you'll be able to just simply double- click on the name of the project file,
00:54 which will then bring up the coding environment and the code that's in that file,
00:59 and you can start working right away on it.
01:01 Let me take a look back in the Exercise Files folder. You'll also notice that
01:06 there is a FinishedExamples folder.
01:09 In this folder, you will see the same folder structure, but what I've done here
01:13 is finished off each one of these examples in the finished state.
01:17 So here in the upper part of the folder, these are all the examples in the start state.
01:22 These are so that you can follow along with me as you take the course.
01:25 If you would rather just jump ahead and see how a finished example works, you
01:28 can go inside the FinishedExamples files folder and then just choose which
01:32 chapter you want to the finished example for and then go ahead and examine that code.
01:36 The last thing I want to point out is that I have included a file here
01:39 called ExampleSnippets.
01:41 If we open this text file up, you will notice that this is just a collection of
01:45 code snippets that I'm going to use in each one of these examples throughout the
01:49 title, and I have organized them in various chapters.
01:52 Here are the snippets for Chapter 3,
01:54 here are the snippets for Chapter 4, and so on.
01:57 This is so you don't have to sit and watch me type each example out.
02:01 I'm going to just simply copy and paste the code that's in these snippets files.
02:05 Now if you're a Monthly member or Annual member of lynda.com, you don't have
02:10 access to the exercise files, but you will have access to this ExampleSnippets
02:13 file because it will be made available as a free download.
02:16 So you can either follow along from scratch with your own assets, or you can use the snippets.
02:21 Let's go ahead and get started.
Collapse this transcript
1. Getting Started with C#
Installing the Visual C# Express IDE
00:00 Okay, so we are ready to start writing our C# code, but before we can do that,
00:03 we have to go get our development environment.
00:05 So to do that, we are going to go to the Microsoft web site and download the C#
00:10 Express development environment. So let's do that and go to the browser.
00:13 In the browser, I am going to type in microsoft.com/express.
00:19 This will take me to the download page for the various versions of Express
00:25 products that Microsoft makes available for free.
00:27 And this page might look a little bit different for you when you get here, but
00:31 there should be a link to download the Express products for Visual Studio, and
00:36 that's this link right here that says, "Get free Visual Studio Express products."
00:39 So I am going to click on that.
00:40 This will take me to a download page for all of the Visual Studio Express products.
00:46 And as I scroll down the list, you can see that there's one for Windows Phone.
00:49 There's Visual Web Developer. And I am just going to scroll down until I get to
00:52 this link right here, and that is Visual C# 2010 Express.
00:57 And again, when you get here, this may be newer. The point, though, is that
01:00 you want to get the most recent version of the Visual C# Express IDE.
01:04 So I am going to click on that link.
01:06 This will take me to the download page for that particular version of Visual C# Express.
01:11 So I can click on the Install Now link.
01:14 Now depending on what browser you're using, you're going to be prompted to
01:17 download and run the installer, and you can see here in IE I have got this
01:21 little download bar, but this is going to look different for you if you're using
01:24 a different browser.
01:25 Now I have already done this.
01:27 So once you have run the installer and Visual C# Express is installed, you will
01:32 find it in your Programs menu.
01:34 So if I go to the Start menu, you will see I have got Microsoft Visual C# 2010
01:39 Express, or something like it for you. And I am going to go ahead and click on the
01:42 link to make sure it's installed correctly. And you can see that Visual C#
01:46 Express fires up, and it looks like we are ready to go.
01:48 Now there is one other thing I wan to show you before we actually get started
01:51 writing some code, and that is the Microsoft Developer Network Library.
01:54 So let's jump back to the browser and head over there.
01:57 So back here in the browser, I am going to make a new tab, and I am going to
02:00 type msdn.microsoft.com.
02:04 This is the online library for the Microsoft Developer Network, and it contains
02:09 all the documentation that you'll need to build your C# and .NET programs.
02:15 And you can see when I come here it's placed me on one of these four categories.
02:18 In this case it's Tasks.
02:20 Let me click on the Platforms link.
02:21 And under Platforms, you can see that there are categories for desktop and web
02:26 and cloud and phone. And if we scroll down a little bit, there is a whole bunch
02:30 of content on here that's focused on building applications for the various
02:34 Microsoft platforms.
02:35 Let's scroll back up.
02:36 I am going to click on Tasks again.
02:39 You can see it takes me to a different pivot on the information here in the MSDN Library.
02:44 There is a section for creating code.
02:46 There is a section for testing.
02:47 There is a section for understanding code.
02:49 Let's go ahead and click on one of these links for understanding code.
02:51 You can see here, as I scroll down, there is a whole bunch of overview material
02:55 for understanding how to build .NET applications using a variety of languages.
03:00 We are going to be referring back to the MSDN Library throughout the course to
03:04 see documentation for the various kinds of code and objects we will be using.
03:08 In fact, if I click on the Library link up here, the Library link takes me
03:12 directly to the documentation for the various parts of C# and .NET. And you
03:18 can see over here under the MSDN Library section, there is links for all kinds of categories:
03:23 Development tools and Languages, .NET Development, and so on.
03:26 This is the web site that we will be referring to for Microsoft's canonical
03:30 documentation for various parts of C#.
03:33 Okay, so now that we have got the IDE installed and we know MSDN is, we are
03:37 ready to start building our first C# application.
Collapse this transcript
Creating your first C# application
00:00 Now that we have got the IDE installed and we've seen MSDN,
00:04 let's go ahead and fire up C# Express and build our first application.
00:09 So I am going to go ahead and launch C# Express. And when C# Express comes up,
00:17 you will see a start page and the application window frame.
00:22 So this right here is the start page. Over here is something called the Solution
00:25 Explorer, and we will look at that a little bit later.
00:27 What I am going to do, just really quickly, is get our feet wet by writing a C# application.
00:33 I don't expect that you're going to understand everything that I'm going to show you right
00:35 away, but I know you're probably anxious to get started.
00:38 So let's just go ahead and build a simple application. And once we've done that,
00:41 we'll take a quick look at how we did it, and then we will have an introduction
00:45 to C# Express that explains the various parts of the program that we will be
00:48 using throughout the course to build our applications.
00:52 I am going to go ahead and click on the New Project link right here. And when I
00:56 click on the New Project link, you'll notice that a dialog comes up asking me,
00:59 well, what kind of application do you want to build?
01:01 You can see there is a whole bunch of built-in ones that we can choose from:
01:05 there is Windows Forms Applications, there is WPF, there is something called a
01:09 Console Application, there's Class Library, and there is a whole bunch of other
01:12 things that we can choose from.
01:14 To keep things simple, we are going to build what's called a console application
01:17 and you may have heard this referred to in the past as something like a command-
01:22 line app, or something like that.
01:24 The point here is that we are not going to be focusing too much on fancy user
01:28 interface or anything like that.
01:29 We are going to build console applications to keep us focused on the C# language.
01:34 I could name it down here something else, but this is just an example.
01:37 So let's go and click on Console Application, and you can see that C# Express has
01:43 created a sample application for me.
01:46 It's opened up a file here called Program.cs--that's this tab right over here.
01:51 If we take a look now at the Solution Explorer, we can see the Solution Explorer
01:54 has now been filled out with a bunch of things:
01:57 There is the name of the application that we are building right here.
01:59 There is a couple of folders called Properties and References, and we will see
02:02 those in depth a little bit later.
02:04 And then this file right here called Program.cs.
02:07 Program.cs is the C# file that contains the code for our program, and it happens
02:12 to be opened in the window right here.
02:14 I am going to go ahead and just type a couple of things, and again, I don't
02:18 expect you to know this right away, but just follow along with me.
02:22 Inside the function for Main, I am going to type Console.WriteLine.
02:31 It's a bit of a tradition in programming courses that the first application you
02:36 write basically does nothing more than print "Hello World" out to whatever output
02:40 device you're using,
02:41 so I am going to type in here "Hello World," and I am going to save it.
02:49 Now what I am going to do is run it, and I can run it a couple of different ways.
02:53 What I am going to do is go up to the Debug menu.
02:56 You can see that I have got an option here for Start Debugging and I have got
03:00 something called Build Solution.
03:01 I will just quickly choose Build Solution to make sure that everything is right,
03:06 and you can see down here in the status bar there is a little piece of text
03:08 that says, "Build succeeded."
03:10 So everything looks okay.
03:12 Now I am going to run it.
03:13 And instead of going back to the Debug menu, I am going to click on this little
03:16 green arrow right here that says Start Debugging.
03:18 So I am going to click on that and you can see that some window came up very
03:22 quickly and went away, and that's because the Console Application came up, the
03:28 text was written out, and then the program ended.
03:30 The .NET Library said, "Oh, I guess we don't need the console window anymore.
03:33 Might as well send it away."
03:34 So to keep that from happening, I am going to add one more piece of code down
03:38 here, Console.ReadLine, and now I am going to save that.
03:45 Now this is going to have the console window wait for us to give it a line of text.
03:49 This is just a way for me to keep the console window from going away as I show
03:54 how this program works.
03:55 So let's try it one more time.
03:56 Let's go ahead and click on Run. All right!
03:59 You can see that the console window comes up, the words "Hello World" got printed
04:03 out, and now it's waiting for me to give it a line of input, and it's going to sit
04:07 there until I do that.
04:08 You can see in the background the UI for C# Express has changed somewhat.
04:14 The Program.cs window has been expanded, and we've got these two other windows
04:18 down here called Locals and Call Stack-- and we'll get into this later on when
04:22 we look at debugging.
04:23 This is C#'s way of showing me what the program is doing while it's running.
04:27 So let's bring this back up here, and you can see now that when I give it a line
04:31 of text and the ReadLine function completes, the Console window goes away and C#
04:36 Express goes back to the state where it first launched.
04:40 That's how we build our first C# program and to get further into the course, we
04:44 will explain how all of these things work.
Collapse this transcript
Introduction to Visual C# Express
00:00 Since we're going to be spending a lot of time using C# Express to build our
00:03 applications, we should probably take a few moments and get familiar with the
00:06 IDE and see how it works.
00:08 So I'm going to go ahead and launch the C# 2010 Express,
00:14 and you'll see that when the application comes up, it's a very simple UI.
00:17 There's the start page right here on the left-hand side,
00:20 and then over here there's something called the Solution Explorer.
00:24 A couple things you need to know about C# right upfront.
00:26 C# Express organizes everything into projects.
00:31 Projects are what applications are made from.
00:33 And you might sometimes hear the word project interspersed or interchanged
00:37 with the word solution.
00:39 That's not completely true.
00:40 Solutions are basically top-level projects that can contain other projects.
00:45 When we build a project, it will appear in the Solution Explorer here on the
00:49 right-hand side of the screen.
00:51 So let's go ahead and create a new project,
00:54 and we can do that one of two ways:
00:55 we can click on the New Project link here in start page, or we can go up to the
01:01 File menu and choose New Project.
01:03 So I'm going to choose New Project,
01:06 and the New Project dialog launches and we can choose what kind of project we want to build.
01:11 Throughout this course we'll be working with console applications, because
01:15 it gets the user interface out of the way and just let's us concentrate on the language.
01:19 So I'm going to go ahead and click on the Console Application to select it.
01:23 If it's not already done so, you should do the same thing.
01:25 Down here in the bottom of the dialog, there is a place where we can enter the
01:29 name of the project.
01:31 And I'll just type in something;
01:32 I'll just call it MyProject.
01:34 And I'm going to click the OK button.
01:37 This is going to create the project for us. All right!
01:41 Now that we have the project built, let's take a look at C# Express and see
01:46 what's going on here in the UI.
01:48 So over here in the Solution Explorer you'll notice that the window has been
01:52 filled out with some information, and we will get back to that in just a moment.
01:56 The project code is over here opened in the editor.
02:00 And the new project isn't actually saved yet.
02:02 It is fully functional. You can go ahead and run it. You can edit it.
02:05 You can do all kinds of things.
02:06 But it's sitting out in temporary space right now.
02:09 If we wanted to actually put all this work onto disk, we would go the File menu
02:13 and we would choose Save MyProject or Save All.
02:17 And when I choose Save All, you'll see that I get a dialog that says hey, here's the name.
02:21 Here's where it's going to be saved.
02:22 Here's what the solution name is.
02:24 I have the option to create a directory for the solution.
02:26 And at this point I can choose to name it something else if I don't like the
02:30 name that I originally came up with.
02:32 And I'm just going to go ahead and choose Save.
02:35 That will put the project on disk for me in the Documents folder, or whatever
02:39 path I selected in the Save dialog.
02:42 Let's go ahead and take a look at the project files over here in the Solution Explorer.
02:46 You'll see that underneath the top-level MyProject heading there are a couple of folders.
02:51 There's the Properties folder and References.
02:53 Let's go ahead and expand those.
02:56 Underneath Properties there's a file called AssemblyInfo.cs.
03:00 Now I'm just going to quickly open this up so you can see what's inside it.
03:02 We won't be going through this in this course, because this is a little bit of
03:05 advanced information.
03:06 But this is the information that C# Express will save, along with your
03:10 application, that describes to the .NET Framework what the application is, how
03:14 it works, various pieces of information that .NET needs to know about the
03:18 program in order to run it.
03:20 So let me go ahead and close that.
03:22 Under the References folder you'll see a whole bunch of things, like Microsoft
03:25 and System and so on.
03:27 These are the actual .NET Framework libraries that get associated with your
03:31 project when you make a new one.
03:33 These will change based upon what kind of project you're creating.
03:37 In this case, we've built a console application, so these are the .NET libraries
03:41 that the console application needs to run.
03:44 Some of them are optional; some of them are not.
03:46 The .NET Framework just goes ahead and includes them in case you need to use them later.
03:51 So let's go ahead and close those folders up.
03:53 The Program.cs file,
03:55 this is the default file that gets created, along with your application, that
03:59 contains your main code for the application.
04:02 And you can choose to add new C# files as you go along, depending on how complex
04:06 your application is.
04:07 We're not going to do that right now.
04:09 Let's just take a trip through the user interface of C# Express, so we can see how it works.
04:14 I've already shown you the File menu.
04:16 That's up over here.
04:17 This is where we create projects and save things.
04:19 Pretty standard file-menu stuff.
04:21 Let's move over to the View menu.
04:23 In the View menu, you'll see it's pretty simple.
04:25 I can choose to view the start page again.
04:27 There's other windows that we'll be looking at.
04:29 I'll just go ahead and choose one right now.
04:31 This one is the Error List.
04:32 This window down here shows you if there are any errors or warnings or
04:36 anything else in your code.
04:37 And we'll get back to that later, so let's go ahead and close that.
04:40 Also under the menu, there are toolbars, and you can see that I've got
04:43 some toolbars showing.
04:45 The Project menu is where we control what's in our project.
04:48 So we can add items to the project, we can add references, and so on.
04:52 We're not going to do that right now, but we'll probably do it later.
04:54 Under the Debug menu, this is how we run the application in order to test it out.
04:59 We can also build our solution right here.
05:02 This will build the program without actually running it.
05:04 I'm going to skip over the Data menu and go to Tools.
05:08 Under the Tools menu, I'm going to show you a couple of things.
05:10 First, under Settings, there's a couple of ways that you can use C# Express.
05:14 There's Basic Settings and there's Expert Settings.
05:17 I've left it on Basic Settings right now because we are not going to be using
05:20 any of the Expert Settings for now in our application.
05:23 What I'm going to do, though, is show you under Options.
05:25 Now under the Options dialog, there are a couple things I've changed that
05:29 you might want to change along with me to make some of the examples a little
05:32 bit easy to follow.
05:33 You can see that under Fonts and Colors I've changed the Size and the Font to
05:37 make things readable.
05:38 Now there's a check box down here that says Show all settings.
05:42 So I'm going to check that for a moment.
05:44 You can see that when I do that, a whole bunch of other settings show up.
05:46 What I'm going to do is, under Text Editor, I'm going to choose C#.
05:51 And you can see that there's an option under Display for Line numbers.
05:54 Now that's not there if I turn off the Show all settings function.
05:58 So turn on Show all settings and then go down to the C# option here and check
06:04 the Line numbers option to show line numbers in your code. Click OK.
06:09 And that pretty much completes our tour through the UI for using C# Express.
06:14 We'll see more of this as we go throughout the course,
06:17 but for now that should be a nice overview introduction to the application
06:20 and how it works.
Collapse this transcript
2. C# Language Fundamentals
Overview of the C# language
00:00 C# is a language that was built by Microsoft for working with Microsoft's .NET
00:06 application platforms.
00:08 It is a language that's very similar to other languages you may have seen, such
00:12 as JavaScript or Java or C, C++, Objective-C.
00:17 If you've used any of these languages in the past, you're going to feel right at
00:21 home pretty much in C#.
00:23 Syntactically, the language is very similar.
00:26 C# is what's called a managed-code environment.
00:29 Memory management is automatic.
00:32 So if you've worked with other languages, like C or Objective-C, then you've
00:37 probably come across situations where you have to create and destroy objects on your own.
00:43 C# does all of that for you.
00:45 When you create an object, the C# interpreter, or compiler, actually takes care of
00:50 making sure that that memory is returned to the system at some point, and you
00:54 don't have to worry about it.
00:55 C# is a compiled language.
00:58 Unlike some other languages you may be familiar with, like JavaScript or Perl,
01:01 you must first build a C# program before you can run it,
01:05 and this step is called compiling the application.
01:09 JavaScript and Perl are interpretive languages.
01:12 In other words, the execution engine-- in the case of JavaScript, for example,
01:16 that would be the browser--actually interprets the language line by line, as it
01:20 goes through the program and runs it as it discovers new statements and other
01:25 things in the language.
01:26 C# isn't like that.
01:27 In C#, you write your code, then you have to go through the compilation step,
01:31 and then you can run the application.
01:34 Now at its heart, C# is an object-oriented programming language.
01:38 In C# pretty much almost everything can be treated as an object.
01:42 I've underlined the word "almost" there, because there are a couple of esoteric
01:46 cases where not everything is an object.
01:48 But for our purposes in this course, you can pretty much think that everything
01:52 in C# is an object and can be treated that way.
01:56 In fact, in C# there are no global functions or variables;
01:59 everything is in classes.
02:01 And that might be different from other languages you might be familiar with, like
02:04 JavaScript or like C. But in C# everything has to be inside of a class, and
02:09 we'll come across that as we go further into the language.
02:12 Now as I mentioned earlier, C# is a foundation for working with many different
02:17 Microsoft platform technologies.
02:20 At the bottom of the stack is something called the Common Language Runtime.
02:24 This is the execution engine, or virtual machine, or whatever you want to call it,
02:28 that actually interprets all the various bytes that the program gets compiled
02:33 down to and is what runs your code.
02:36 On top of that are the Microsoft .NET Framework Libraries.
02:40 This is the code that is provided to you by .NET that performs a whole bunch of
02:45 common things that applications have to do, such as reading and writing from
02:48 files, working with the web, and all that kind of stuff.
02:51 That's all contained in the .NET Framework Libraries.
02:55 On top of that is the C# language, which we will be working with today.
02:59 But the thing about .NET is that it was designed to work with lots of languages.
03:03 There are other languages like VB.NET, such as Visual Basic, or Python, and so on.
03:08 But we're not going to concentrate on those;
03:09 we're going to be using C# throughout this course.
03:12 What this allows you to do is use one language to target many
03:16 different platforms.
03:17 So using C# and .NET, you can build applications that will run on Windows,
03:22 Windows Phone, Silverlight, SharePoint, ASP.NET, Xbox, and a whole bunch of others.
03:29 So just by learning this one language, you can build applications that run in
03:32 many, many different places.
03:34 C# got its start way back in 2001.
03:38 This was when Microsoft released the first version of .NET--that was .NET 1.0.
03:43 That was where C# burst on to the scene, and it continued along for a couple
03:48 of happy years, until 2003 came along, which was when Microsoft released .NET version 1.1,
03:54 and that was when C# 1.2 was released.
03:57 Not a whole lot of different changes between the initial C# release and 1.2--
04:01 a couple of cleaning up things they did in the language.
04:03 But 2005 was when things began to get interesting.
04:06 That was when .NET 2.0 came out.
04:08 And .NET 2.0 introduced some neat little things into C#,
04:13 things like generics and anonymous methods and iterators and nullable types.
04:17 Some of these things are advanced and we won't be covering them in this course,
04:21 but we will be looking at things like nullable types a little bit later on.
04:24 In 2007, that was when .NET 3.0 was released.
04:28 And in .NET 3.0 along came C# 3.0, which introduced concepts such as object
04:34 initializers, anonymous types, and so on.
04:37 Again, some of these are advanced, like lambda expressions--
04:40 we won't be looking at those--but we will be using things like object
04:43 initializers later on.
04:44 And then that brings us to 2010, which was when the .NET 4.0 Framework was released,
04:50 and along came C# 4.0, with things like dynamic binding and named and
04:55 optional arguments.
04:56 And we'll be again--as you may have detected by now, a bit of a pattern--
05:00 we will be looking at some of those later on in the course.
05:03 Now as I mentioned earlier, C# is a compiled language, and that means a couple of things.
05:08 In C#, you have to declare your variables before you use them.
05:12 There's no way around this.
05:14 You have to actually say here's the variable I'm going to use and I have to
05:17 say what type it is.
05:18 Now if you're used to a language like JavaScript, you simply use the keyword var
05:22 to declare a variable in JavaScript.
05:24 And you can also do that in the newer versions of C#.
05:28 But we're not going to be doing that now;
05:29 we're going to see how typing actually works.
05:31 So when you declare a variable, you have to supply a type and supply a name.
05:36 So, for example, I would say int myCounter or string message.
05:40 In this case, myCounter is an integer variable for integer numbers and the
05:45 message variable is a string.
05:47 The reason you have to do this is because it helps the C# compiler optimize the
05:51 program for knowing what kinds of data it's going to work with.
05:54 It doesn't have to figure it out on the fly.
05:56 You can also initialize variables when you first declare them.
06:00 I could've written, for example, "int myCounter = 200," or "string message = "Hello World!""
06:07 And this assigns an initial value to the variable when it is declared.
06:12 The other thing you need to know about C# is the concept of namespaces.
06:16 Again, other languages have something like this.
06:19 In Java you may have seen something like packages.
06:22 JavaScript doesn't really have something like this.
06:25 There are some efforts to kind of fake it up using things called modules.
06:29 But a namespace is basically just a way to organize a bunch of information into classes,
06:36 and .NET uses namespace to organize all the classes that it provides for you.
06:41 Essentially, it's a way of naming related classes and other namespaces within the
06:46 namespace such that you can group them together into logical formations that
06:50 make sense for various pieces of functionality.
06:53 And to take an example, .NET provides a namespace called System, which we will
06:58 be using a lot in this course.
07:00 And inside System, there will be classes, so just Console and Environment
07:04 and Math, and so on.
07:05 So each of those little boxes there represents classes and the keyword System
07:09 represents the namespace.
07:11 And in fact, you and your applications can create their own namespaces, and
07:15 we'll see that a little bit later in the course when we start creating our own applications.
07:18 But this is an important concept to understand.
07:20 C# and .NET in general uses namespaces to organize classes.
07:25 And this is how applications get organized and it makes things a lot easier when
07:29 you're writing your code in C#.
Collapse this transcript
Understanding the structure of a C# program
00:00 Let's take a look at the basic structure of a C# program.
00:04 Now, I've gone and fired up the C# Express development tool.
00:07 I'm going to create a new project by clicking the New Project link here on
00:11 the left-hand side.
00:13 The New Project dialog comes up.
00:14 Throughout this course, we're going to be using console applications to build
00:19 our examples, because they are one of the simplest applications to create and
00:23 they allow us to focus on just the C# language without having to worry about all
00:28 the user-interface-related code that other projects require.
00:32 I'm going to select the Console Application option, and I'm going to give it a name.
00:36 I'll just call this one StructureCSharp, and I'm going to click OK.
00:45 At this point, C# Express will create a new project and open it for me, and it
00:50 will drop me in the editor, into a file called Program.cs.
00:53 C# code is stored in files that have the .CS file extension. And right now, we
00:59 only have one of these, but your application can use as many of these files as you like.
01:04 And in fact, as you build your programs, you'll probably create many different
01:09 .CS files to group related classes and pieces of your code, together rather than
01:14 just type thousands of lines into one file.
01:16 For now we've only got one, so let's go through this file line by line.
01:21 Right at the top here we have a bunch of using statements.
01:26 These statements tell the C# compiler which pieces of the .NET Framework that my
01:31 project will be using, and they allow me to write my code using a bit of a
01:36 shorthand notation that we'll see more of in a few minutes.
01:41 Now, if you're familiar with other languages, like, say, Java or C or C++, these
01:48 using statements are sort of analogous to things like import statements or
01:54 include statements, and so on.
01:56 But in C#, we use the using statement to indicate which pieces of the .NET
02:01 namespaces I'm using in my program.
02:04 The next line down is the namespace declaration for this project.
02:09 That's here on line 6.
02:10 Now, I mentioned earlier that C# uses something called namespaces to organize
02:15 code into related groups, or modules, and your program is no different.
02:20 Namespaces are basically just an organizational tool.
02:24 They keep related code together, and they prevent certain kinds of problems.
02:29 For example, if your program were to define a class that has the same name as a
02:34 class in some other .NET library, either from Microsoft or some other third
02:39 party, your program's namespace would keep those two classes from colliding with
02:44 each other and causing a whole bunch of compile problems.
02:47 Now, the C# editor creates the namespace for you when you create your project,
02:52 and it defaults to the name of the project, and we're just going to leave this as it is now.
02:57 Next, we have something called a class definition.
03:00 You can see that here on line 8.
03:02 It's the keyword "class" followed here by the word "Program."
03:07 Again, I mentioned earlier that in C#, almost everything is an object, and
03:10 again, your program is no exception.
03:12 In C#, the way that you define and create objects is by using the "class" keyword,
03:18 which we'll see more of later in the course.
03:20 And again, we're just going to leave this as it is for now.
03:24 Inside the class definition is the most important part of our C# program, the Main function.
03:30 You can see that here on line 10.
03:32 Now if you're already familiar with languages like C, Java, Objective-C, and so
03:37 on, then this will look familiar to you.
03:40 If not, let me explain.
03:41 When .NET goes to run your C# program, it needs to know where to start.
03:46 The Main function is that starting point.
03:49 It doesn't matter how many functions or lines of code your application contains;
03:53 somewhere in your program .NET expects to find one special function called Main,
03:58 and that's where it begins running your program.
04:01 It has to be written as you see it here.
04:03 It needs to be called Main, and the first letter must be uppercase because C# is
04:08 a case-sensitive language.
04:10 Case does matter here, because if you try to ignore case in C#, whether it's
04:14 for function names or variable names or anything else, you are in for a bunch of problems.
04:19 Now, it's important to note that not all C# project types have a Main function,
04:25 for example ASP.NET pages, but many of them do.
04:29 This isn't something that you'll ever have to worry about though, because when
04:32 you're using the visual C# programming tools to create projects, it will create
04:37 the Main function for you if it's needed.
04:40 Don't worry for now what the words "static" or "void" mean, or the stuff that's
04:45 inside the parentheses;
04:47 we're going to cover those later.
04:49 Let's take a look at some of the syntax rules of C#.
04:51 Now first, notice these curly braces on line 7, and 9, 11, 12, 13, and 14.
04:59 These braces are used to group related lines of code together in what are called
05:05 statement blocks of code.
05:06 You can see that they come in pairs.
05:08 There's an opening brace and there's a closing brace, and they must match up.
05:12 Now, they define starting and ending points for things like functions and
05:17 classes and loops, all of which we will see later in the course.
05:22 If you have experience in languages like JavaScript or C or Java, then
05:26 you've seen these before.
05:27 And if not, then all you need to know is that they group lines of code together.
05:32 Now, you'll notice that the Main function is empty, and that's okay, because
05:35 technically, this is a complete C# program.
05:38 But let's look at some basic examples of C# statement syntax.
05:43 To declare a variable, I need to specify a type and a name.
05:48 So for example, I can type "int" and then "myVariable."
05:54 This is different from languages like JavaScript where you don't need to specify
05:59 a type for your variable.
06:01 Now note, also, that every statement in C# must end with a semicolon, as I've done here.
06:08 Some other languages, like JavaScript for example, don't require this, but C# does.
06:13 Every time you type a statement, whether it's a variable declaration or you
06:16 call a function or any kind of statement that you write in the code, it has to end with a semicolon.
06:23 That's a really great practice because it really makes it clear where statements end.
06:28 Now, in C#, I can use some of the built-in .NET objects, since I've included
06:33 them in those namespaces using the using statements--for example, the Console object.
06:39 So let me just show you a quick example.
06:41 I'm going to start typing the word "Console," and you can see that as I'm typing,
06:45 the Visual C# Express development tool is helping me out here by trying to guess
06:50 what it is I'm going to type, and you can see it's centered on the word "Console"
06:53 there in the little pop-up.
06:54 So if I hit Return, it'll put the word "Console" for me.
06:58 Console is one of the built-in objects in .NET when you're using
07:02 console applications.
07:03 For example, to write something out to the console, I can use the WriteLine
07:07 function. So I'm going to type dot, and once again that little code hinter comes
07:12 up, and I'm going to start using word Write.
07:14 You can see that it zeros in on some of the functions available to me.
07:19 I'll just choose the WriteLine function.
07:23 I will just simply write out something like this.
07:26 Once again, notice that I've got a semicolon at the end of my statement.
07:30 The other thing that you should notice is that in C#, strings are contained
07:35 within two double quotes.
07:37 We'll cover a lot of this a little bit later in the course.
07:39 But if you're coming from languages where strings can be specified using either
07:43 single or double quotes, that's not the case in C#;
07:46 you have to use double quotes.
07:46 Now, notice how the word Console is in light blue.
07:50 That's because the Compiler notices that I'm using a built-in object in C#.
07:55 The Console object is contained within the System namespace.
07:59 Watch what happens when I go up here and I comment out the using System
08:04 statement up here on line 1.
08:05 Notice now I've got a little red squiggle down here on my Console object.
08:11 It says, "The name 'Console' does not exist in the current context," when I mouse over it.
08:16 So now I've gone from being able to use this object to not being able to use this object.
08:21 The reason for this is, when I commented out the System namespace, if I want to
08:25 be able to use that object now, I have to write what's called a fully
08:28 qualified path name.
08:30 So I would have to write out "System.Console.WriteLine" if I wanted to use this
08:36 now. And you can see that when I put the word "System" in front of the word
08:39 "Console," now it goes back to being light blue because the compiler recognizes it again.
08:43 So by using these using statements, I can write my code using shorthand, rather
08:49 than having to write out these big, long, fully qualified paths to all the objects in .NET.
08:55 So it makes writing your code a lot easier.
08:57 So I'll go back up to the top here and uncomment that line.
09:03 You notice even when I have it uncommented, I can leave it fully qualified if I want to.
09:07 But now, I have the ability to take out that System statement and now Console
09:11 goes back to being recognized.
09:14 White space doesn't really matter in C#.
09:16 Now, some languages consider the indentation level of lines of code to be
09:20 important, but C# does not.
09:22 You can put as much or as little white space in your program statements as you like.
09:27 For example, I could put this statement all the way over here, and I can just
09:31 put this statement all the way back over here.
09:33 It doesn't really matter; this is all good.
09:35 Obviously, there are places where white space is going to matter.
09:38 So for example, inside of a string, if I do this, well, that's
09:41 pretty significant.
09:42 That's going to affect the way that that string is written out.
09:44 But within lines of code, white space does not matter.
09:49 So if you're coming from a language where white space matters, you don't have to
09:52 worry about that here.
09:53 Indentation in C# is just used for maintaining readability.
09:58 So we've seen enough C# where we can now start writing our programs, and we can
10:02 go on to the next part of the course.
Collapse this transcript
Compiling and running your code
00:00 One last thing that we need to look at before we jump in and start writing our
00:04 C# code and learning how to do all kinds of great things, like writing programs
00:08 and using variables and objects and so on, and that is compiling and running the code.
00:14 I realized I've done this a couple of times so far, but I want to get a little
00:17 bit deeper into this.
00:18 That way, as you're working through the course, you can see how the building
00:22 process works and the various tools that you'll need for when errors happen in
00:27 your code. And I say when and not if because errors are going to happen and you
00:31 need to be prepared for that and to see how to recover from these situations and
00:35 how to build your code correctly.
00:38 So as I said earlier, C# is a compiled language.
00:41 You have to compile it before you can run it, so we're going to cover some
00:45 tips on how to do this.
00:47 Now, the term for compiling and creating your finished application is "build."
00:52 So let's just make a new project, and we're going to call it BuildAndRun and make
00:59 sure it's a console application.
01:01 I'm going to click OK.
01:03 Now, what I'm going to do first is I'm going to click the Save All icon here.
01:09 I can also just choose Save All from the menu here.
01:12 I'm going to save this application in my Documents folder.
01:16 Now, this folder will be different for you based upon the computer that you're
01:20 using and where your Documents folder is, but I'm going to save it in the
01:23 default location, which is the visual studio 2010/Projects folder, and we'll go
01:28 out to the file system and see this in just a minute.
01:30 But I'm going to save.
01:33 Now that I've saved it, I've actually put the project onto a physical
01:38 location on my disk.
01:39 It's no longer sitting out there in temporary space.
01:42 So recall that the way that we build that application is by using either F6, or
01:46 up here in the Debug menu, we can choose Build Solution.
01:50 So I'm going to choose Build Solution and you can see down here in the toolbar,
01:54 there's a little message that says "Build succeeded."
01:57 So let's go out to the file system and see where the application is actually built to.
02:03 I'm here in my Documents folder, and you can see that there's a folder here
02:07 called Visual Studio 2010.
02:09 This might be slightly different based upon which version you're using.
02:12 But I'm going to go into Visual Studio 2010.
02:15 There's a folder called Projects.
02:17 Here's the project that I just built called BuildAndRun.
02:20 So let's take a look in there.
02:21 You'll see that inside BuildAndRun, this is the solution, the top-level project
02:25 for our code, and then there's a folder that goes along with it.
02:29 And inside the folder, there's the Program.cs file.
02:32 This is where our code is kept.
02:34 This is the project file.
02:35 There's also a folder in here called bin.
02:38 bin is short for binary.
02:40 This is where the application is kept.
02:42 Inside there, there are two folders:
02:43 there's Debug, and there's Release.
02:46 If we look in the Debug folder, you'll see that there's some information here
02:50 about the application's debug information.
02:53 If we go into the Release folder, you'll see that there's a couple of things in here.
02:57 First, there is BuildAndRun, and you can see that that's an application.
03:00 This is the actual finished application that gets built when you create the
03:05 application using Build inside the C# Express environment.
03:08 So this is the finished application.
03:10 That little PDB file is called the program database.
03:14 It contains some information that .NET needs to use in order to debug and run
03:18 the application that we've built.
03:20 But for now, all you need to know is that when you build an application, this is
03:24 where it actually gets placed.
03:25 When you create a project and you save it in whatever folder you save it in, the
03:29 C# IDE will build this subfolder structure for you.
03:34 Let's go back to the IDE.
03:36 Now, we're going to take a look at how we can build errors and warnings and fix
03:42 things and so on like that.
03:43 Here in my Main function, what I'm going to do is write some code.
03:48 I'm going to say int myInt = 50.
03:55 Don't worry too much about following along with this code.
03:58 We're going to cover variables and stuff later.
04:00 I'm going to make one more line.
04:08 This is code that we've been working with in a couple of examples now. Let me save this.
04:14 Now, I'm going to hit F6, and you can see that everything built just fine.
04:18 However, you can see that there's a little squiggle here under myInt.
04:21 What I'm going to do is go up to the View menu, and in Other Windows, I'm going
04:29 to choose Error List.
04:31 When I choose the Error List, you can see here that there is a warning, and the
04:35 warning is that the variable myInt is assigned, but its value is never used.
04:40 Warnings are not necessarily as bad as errors; your application will still run
04:44 just fine without it.
04:46 And just to show it to you, let me you put one more line of code in here.
04:54 Now, when I press F5 to run the application, or if I choose this little
04:58 triangle up here, or if I go to the Debug menu > Start Debugging--that's
05:03 where I run the program; I'll just use F5--
05:06 you can see that the program ran just fine, even though I had a warning there.
05:09 But that's no excuse for having warnings.
05:12 If you've got a warning somewhere in your code, you should really pay attention
05:15 to it because the compiler is trying to tell you something.
05:18 And in this case, the warning is a little bit benign.
05:19 I just created a variable that I never used.
05:22 But warnings can actually be pretty serious, and they usually indicate something
05:25 is wrong with your code.
05:26 So if you get warnings in your code, go look them up in the error list here and go fix them.
05:30 The next thing I want to do is make an error.
05:34 So what I'm going to is I'm going to remove the double quotes from the end
05:38 of that line there.
05:40 You can see that when I do that, I get a red squiggle which says that there's
05:44 some kind of error going on.
05:45 And if I try to hit F6, there's a whole bunch of build errors.
05:50 You can see down in the error list,
05:53 there are now three errors and the warning for the variable that I had before.
05:57 You can see that the errors are hey!
05:59 There's a new line in the constant. There is no semicolon.
06:01 There is no closing parenthesis.
06:04 All of these errors are occurring because I left off that closing quote.
06:08 When you get an error like this and the error list pops up, you can just
06:11 double-click on any one of these guys, and it will take you right to the line
06:15 where the error occurs.
06:17 Now, in this case to fix this, I just need to put the double quotes back.
06:21 But if I don't do that and I leave it and I ignore these warnings and I try to
06:25 run, by pressing F5, you'll see that there are build errors.
06:29 And C# is telling me, hey!
06:30 There were build errors, but if you like, you can continue and run the last time
06:35 that this was successful.
06:36 But I'm not going to do that.
06:37 What I'm going to do is click No and I'm going to say, okay, let's go ahead and
06:40 fix that problem, so I'll put the quotes back in.
06:42 Now everything is fine.
06:45 Once I press F5, you can see that the code is now working again.
06:49 The next thing I want to do is see away that I can get more information about my build.
06:55 Under the Tools menu, I'm going to switch over to Expert Settings.
07:00 Don't be intimidated; this really isn't a very big deal.
07:03 What I'm going to do is choose the View menu.
07:07 I have the Error List still, but now I have a new window here under Expert
07:11 mode called Output.
07:12 You can see that when I choose it, there it is right there.
07:15 So the Output window shows me a lot more detailed information about the
07:18 build-and-run process.
07:20 So, for example, if I now hit F6, you'll see that the output window is giving me
07:24 a whole bunch of information about the files that got compiled, any warnings or
07:28 errors that popped up.
07:29 You can see that whether the build succeeded or not.
07:32 You can see that where the output of the application was built.
07:36 You can see that BuildAndRun.exe was placed in this path down here at the bottom.
07:40 By using the Output window, you can get more information about where the build
07:44 process is and what it's doing and what the results are.
07:48 The last thing I want to do is show you how you can find out more
07:51 properties about your project.
07:54 Under the Project menu, I'm going to choose BuildAndRun Properties.
07:58 This menu item will change based upon whatever your project is called.
08:02 It'll be project name and then the word Properties here.
08:05 When I choose this, I get a whole bunch of properties about what my program is
08:09 and how it's being built.
08:11 So here under the Application tab, I can see that this is what my Assembly name is.
08:16 An assembly is basically just a generic term that says this is some physical
08:20 piece of code on the disk somewhere and it's the name of my project.
08:23 Same thing for the namespace.
08:25 I can also see what target framework I'm going after.
08:28 In this case, I'm using the .NET Framework 4.
08:31 But if I click on this, you can see I can build my application to target other
08:34 versions of the .NET Framework, all the way from 2.0 up through 3 and through 4,
08:39 and there are other frameworks I can install as well.
08:42 Under the Output type dropdown, this controls what kind of application I'm building.
08:46 Now, it's currently set to be a console application, but I can change it to be a
08:49 Windows app or a class library, and so on.
08:52 The last thing I want to show you is under Build, there are ways that I can
08:57 control how the application is built.
09:00 We'll see a little bit of these later on, but I can change how the errors and
09:04 warnings are reported.
09:05 I can say what the warning level is and there are four warning levels, all the
09:09 way up from very verbose down to not very detailed at all. So I can choose what
09:13 warning level I want.
09:14 I'm going to leave it on 4.
09:15 I can also suppress individual warnings that I don't want to know about.
09:19 Now, I don't suggest that you do this, because it's really good idea to know
09:23 about all the warnings in your code, but it is possible to do this.
09:27 You can also set a little preference over here that says Treat warnings as errors.
09:31 I can say None or All or Specific warnings.
09:34 If I changed this to All, for example, and then went back to my application,
09:40 you can see that when I hit up 6, now the warning that was hey!
09:44 The variable 'myInt' is assigned, but its value is never used, it's an error now.
09:48 It's no longer a warning.
09:50 So I'm going to go back and change that back to the way it was.
09:55 Now, I'm going to hit F6, and you can see that we're back to being a warning.
10:00 This is how you can control how your application is built, and it's how you get
10:04 more information about the process by which Visual C# Express builds your
10:08 application and runs it and fixes errors.
10:11 Now that you know how applications are actually built, we can dive right in and
10:15 start doing some more interesting stuff.
Collapse this transcript
3. Program Flow
Reading and writing from and to the Console
00:00 So now that we've got the foundational stuff out of the way, we can dive in and
00:03 start writing some real C# code. And what we're going to do in this particular
00:07 example is see how to read information from, and write information to, the console window.
00:14 And this is important to know how to do because for the rest of the course
00:17 we're basically going to be building examples that use the console as the place
00:21 where we write information to and read information from.
00:24 So we need to get a fundamental understanding of how the console works in order to do that.
00:28 So I've opened up, under Chapter 3, the HelloWorldProject in the example files
00:33 folder. And if you don't have that, you can just simply create a new project and follow along.
00:38 The other thing I've opened up is the ExampleSnippets.txt file, and this contains
00:44 the code that I'm going to be copying and pasting from so that you don't have to
00:47 sit there watch me type.
00:49 So let's go back to the program. You can see that we have our HelloWorldProject,
00:54 and down here in our Main function, this is where we're going to be filling the code in.
00:58 So let's go ahead and do something really simple, which we've already done a
01:02 couple of times, but just for refresher, let's write some information out to the console.
01:05 So I'm going to copy this line right here that says Console.WriteLine. I'm going to paste that in.
01:12 So the console object has a series of functions that read and write data, and the
01:17 most common ones are WriteLine and ReadLine. And you can guess what they do.
01:21 WriteLine writes out a string of text followed by a carriage return, which takes
01:26 the cursor back to the new line.
01:28 Now we could use Write which writes out the string and does not put a carriage
01:31 return on there, but for readability, we'll just WriteLine. And then there is the
01:35 ReadLine function which reads a string of text.
01:39 In this case, I'm using it just to keep the console window up, so you can see
01:42 the example working, but it will return a string if we want it to.
01:46 So let's just go ahead and save this, build it--
01:49 you see the Build succeeded--and run it, and no surprise, the string "Hello World!"
01:55 gets written out to the console.
01:56 So let's go ahead and make a couple of changes here.
01:59 What I'm going to do now is go back to the Snippets, and this time we're going to
02:03 read information from the console window and then write it out.
02:08 So I'm going to copy these three lines, paste them in.
02:13 So now what we're going to do is write out a string that says, "What is your name?"
02:18 And then we're going to use the ReadLine function to read a string of data from
02:22 the console and then write out a message that says, "Hello there" plus whatever
02:27 name the person gave us.
02:28 So you can see here that we've got a string variable that is being assigned to
02:32 the result of the ReadLine function.
02:35 Down here, we're just not using the result, which is why the window is
02:38 staying up. But here we're actually going to read the result and use it in the next string.
02:43 So I'm going to save, I'll build, and we'll run.
02:47 You can see it says, "Hello World! What is your name?"
02:49 And I'm going to type in "joe," hit Return and it says, "Why, hello there joe."
02:54 Let's go take and look at the code and see why that works.
02:56 You can see that the string variable here that gets returned from ReadLine
02:59 contains my name, and then in the WriteLine statement we're writing out the
03:04 string "Why, hello there" and then plus the string here.
03:09 Writing strings out to the console window takes many forms.
03:12 It's something that you'll probably do a bunch.
03:14 And although you can use the plus operator, there is actually other ways
03:17 to write strings out.
03:18 So let's take a look at how those work.
03:21 To build strings in C# for the purposes of displaying to the user or formatting
03:26 them for output, there is a couple of ways you can do this.
03:28 Now you've already seen the example where we use the plus operator.
03:31 This is something that you're probably familiar with if you done this in JavaScript.
03:35 It works in JavaScript and as you've seen,
03:36 it works in C# too.
03:38 However, it's not the most efficient way to build strings in C#, for
03:42 reasons we'll see later on.
03:43 There are other ways to format strings for display to the user, and the way that
03:48 we do that is by using the String.Format method.
03:52 And that method takes an argument, which is the string you want to write out
03:55 along with data that you want to put into that string.
03:59 So for example, if we wrote String.Format,
04:02 "There are," and then some code that we'll get back to in a second, "seconds in a
04:07 year" and then an argument, which is probably a number.
04:11 The way that you format a string is by using those curly braces with an integer
04:15 number in there that serves as a placeholder for data that's going to be
04:19 inserted into the string for you.
04:21 And as you might have guessed, if you had more than one piece of data you wanted
04:24 to do this with, you would use more than one curly brace.
04:28 So in this example, it says String.Format.
04:30 There are something seconds in a year, and that little i is going to be
04:34 substituted where the 0 is in those curly braces--and in fact, it
04:38 substitutes entire thing.
04:39 The curly braces and the 0 don't appear in the finished string;
04:42 it gets substituted with the value of the data.
04:45 If you had more than one, you'd simply use more than one curly brace, and you'd
04:48 increment the number for each one of the variables.
04:51 So in this case, if I had two arguments that I wanted to format into the string,
04:55 I would simply supply those as arguments and use two sets of curly braces in the
04:59 String.Format argument.
05:01 So let's go back to the code and see how this works.
05:03 So I want to go back to my Snippets, and I'm going to copy this line right here.
05:07 Now I'll paste it in.
05:12 So now we have a variable called mySeconds, which we are calculating.
05:15 So there is 60 seconds in a minute, times 60 minutes in an hour, times 24
05:20 hours in a day, times 365 days in a year, and that gives us the number of
05:25 seconds in one year.
05:26 So you can see here that we have our Console.WriteLine, and we have our string
05:31 with the curly brace.
05:32 Now notice we're not using the String.Format method, and that's because the
05:35 WriteLine method of the console object knows how to use the String.Format method internally.
05:41 So we pass it what is called a format string, which has this little escape
05:45 sequence, or code sequence in it. And we're passing in the mySeconds variable and
05:50 when we run this, if everything goes well, then we should have the number that's
05:53 calculated inserted into the string.
05:55 So let me go up here and just comment out the code that we're not using, and we'll save.
06:03 This time I am also not going to use F6;
06:05 I'm just going to hit F5, which builds the program for me and runs it.
06:11 So I'm going to collapse two steps down to one and press F5 and you can see
06:16 that the number of seconds in one year has been substituted where those curly
06:20 braces were in the string.
06:22 We were going to be using Console.WriteLine and Console.ReadLine to write and
06:27 read information to the console throughout this course.
06:30 And after following the example here, you can see how to do it for yourself.
Collapse this transcript
Writing conditional statements
00:00 One of the things that any application has to be able to do is make decisions.
00:05 Decisions are inescapable.
00:07 They are an important part of pretty much any nontrivial program that
00:11 you're ever going to make.
00:12 Decisions are made when your program flow is chugging along nicely and suddenly
00:16 you come into a situation where you have to make a decision, and there is also
00:19 the decision of either true or false.
00:22 And this is, of course, built in classical programming using the if statement.
00:26 The if statement takes a Boolean condition and if that condition is true then
00:31 the code that is inside the if statement is executed.
00:35 Now, of course, there is a case for when the condition is not met, and that is the else case.
00:40 If the condition is not met and you have an else case on your if statement,
00:43 because they are after all optional, then the code for the condition where the
00:48 condition is not met is run instead.
00:50 In C# you can also have the else if statement, so we could replace that else
00:55 with an else if on another condition.
00:57 And in fact we can chain a bunch of these together to make a whole bunch of if,
01:01 else if, else if, else if, and so on. And if you want, you can have a trailing
01:06 else condition to handle everything else.
01:08 So let's jump over the code and see this in action.
01:11 Here in the code, I've opened up my ConditionalCode example file, and I've got my
01:16 Program.cs code open.
01:18 I've also got the ExampleSnippets file open right here. And I'm going to scroll
01:22 down to the Conditional Statements section, because these are the statements
01:25 that we're going to be using.
01:27 So back over here in the code, let's put together an if statement and see how it works.
01:32 So I'm going to copy these lines right here in my variable declaration, along
01:38 with the if statement. I'll copy and we'll just paste that in.
01:44 And you can see here that we have a variable, named theVal, which is initialized
01:48 to be 50, and then we have an if statement, which tests the condition to see if
01:53 (theVal == 50) then run some code.
01:57 Notice that there is two equal signs in here.
02:00 If I just tried to put one equal sign in here, I would get an error.
02:04 You can see the little red squiggle shows up, and it says, hey, you can't do a
02:07 conversion. And it's not important what that error means;
02:10 the point is that you can't do that.
02:12 So to test for equality it's two equal signs.
02:15 One equal sign does assignment; two equal signs tests for equality.
02:20 So if (theVal == 50) then we'll write out this data, so it's firstVar is 50.
02:27 And actually, let me change that because it's misspelled. There we go; theVal is 50.
02:32 So we'll save this, and we'll run it.
02:34 I'll use F5 to do that. And you can see that "theVal is 50" is being written out.
02:40 So let's go back to the code and change the value.
02:43 Let's make it 51, and we'll save and run it again.
02:47 And you can see this time nothing is being written out because the
02:50 condition is not being met.
02:51 Let's go back to the code.
02:53 Let's change this back to 50.
02:54 The other thing I want to point out on the if statement is you'll notice that
02:58 I'm using these curly braces to contain the code that's being executed in the
03:02 case of the if condition.
03:04 If all you have is one line of code for your if condition, you actually can
03:09 technically leave these braces out and that will work just fine.
03:13 However, for the sake of readability, and because if statements are very rarely
03:19 limited to one line, I always use the braces.
03:21 I always put them in there. it's a good idea to do so.
03:24 It helps readability of code.
03:25 It helps keeping your statements together.
03:27 So my suggestion is to always use the curly braces, even if you only have one line.
03:32 Let's go back to the Snippets, and let's bring a couple of other lines in here now.
03:38 We're going to try the else if condition this time.
03:42 So I'll copy this, and we'll paste it in below the if.
03:46 So now we have a condition that says if (theVal == 50) then write out this
03:50 statement; otherwise else if it's 51, write out something else. And once again,
03:54 I'll just change that.
03:56 Okay, so let's run this.
03:57 Okay, so you can see that the first condition is being met.
04:02 Now let's change it to 51, save and run, using F5.
04:09 And you can see that this time the else if condition ran, because the value was
04:14 51 instead of the 50. So this time, this condition was executed instead.
04:18 One more test to try.
04:20 Let's go back and copy this code over.
04:23 I'll now copy this and paste at the bottom of my else. And in this case, this
04:32 code is going to run when none of the conditions are met.
04:36 So we have if (theVal == 50), else if (theVal == 51), and the last else condition
04:41 catches everything else.
04:43 So let's just change this to, I don't know, something like 75.
04:46 We'll save and hit F5.
04:49 And you can see that in this case "theVal is something else" is being written
04:52 out, because the last else condition is triggering because the value was not
04:56 equal to 50 or not equal to 51.
04:58 So none of these if conditions right here fired.
05:02 You can have more than one condition in the if statement.
05:06 So for example, if I wanted to have this if condition execute if theVal was
05:11 equal to 50, or something else, I would simply put this one in parentheses,
05:17 and then I would use the OR operator, which is the two vertical bars--and we'll learn
05:24 about this a little bit later, but just bear with me for now.
05:27 So if ((theVal == 50) or (theVal == 49)) then you can write out "theVal is 50 or 49."
05:39 We'll save and now this if condition will execute if theVal is equal to one
05:45 of those two numbers.
05:46 So we'll change it to 49, hit F5, and you can see that the first if condition is
05:51 now being set, so that code is executing.
05:55 Let's go back. If we wanted to change it to AND instead of OR, I am going to
05:58 just use two ampersands.
06:00 Again, we'll learn about that in a little bit. But just for sake of example, I
06:03 want to show you how this works.
06:05 Now in this case, theVal is something else. Why?
06:08 Because here theVal is 49, but for this entire condition right here to be
06:12 true, both of those statements have to be true: theVal has to be 49 and theVal has to be 50.
06:19 And since that's clearly impossible, that first statement is not going to execute.
06:23 So you can see here that we're using if statements to create tests for
06:27 conditions in our code, and we can chain a whole bunch of these things together
06:31 using if, else if, and else. But if you find yourself running into situations
06:36 where you have a lot of different conditions to test for, using the whole bunch
06:39 of ifs and else ifs gets really hard to read and really hard to manage, and
06:44 there's a structure for doing that which we'll take a look at in a little bit.
Collapse this transcript
Using the switch statement
00:00 For cases where your code has to check a lot of different conditions in order to
00:05 execute different parts of your code, it's usually not very efficient to have a
00:08 whole lot of if and else if statements.
00:11 It makes the code harder to read, and in that particular case
00:14 it's usually better to use something called the switch statement.
00:17 And the switch statement can be thought of as a whole bunch of if and else if
00:21 statements, but with a slightly different way of writing it.
00:25 The way you use a switch statement is you write the word "switch" and there is a
00:29 value that you pass to the switch statement, and then inside the switch
00:34 statement, you use a whole bunch of cases.
00:36 So you have a case for some value, which will then run some code, and you have a
00:41 break statement which says okay that's the end of this case. And then you can do
00:45 this as many times as you need it.
00:46 So you can have a case for a whole bunch of different values that all
00:49 run different code.
00:50 Now in the case where none of the values map to a particular case, you can
00:55 have a default case, which will run some code, or do nothing--
00:59 it's up to you. But the default case will be executed when none of the
01:03 other values match.
01:04 Now if you're coming from some other languages like C or Objective-C, for
01:08 example, they let you do things like this.
01:10 You can take that break statement out, in which case, when value1 or valueN are
01:16 met, the code will run.
01:18 And in the case of value1, the code for value1 will run as well as the code for
01:23 valueN, because there is no break statement in there to stop it.
01:26 Now, this is not legal in C#.
01:29 In C#, every case has to have a break command at the end.
01:33 Your code can't fall through to next case like in some other languages.
01:38 And the reason for this is because the designers of C# did a whole bunch of
01:42 studying of where bugs come from in programming logic.
01:45 And it turns out that a lot of bugs can be traced back to developers mistakenly
01:49 leaving out break statements in their switch cases when they probably shouldn't have.
01:54 So the C# language enforces this.
01:56 You have to have a break at the end of each one of your cases.
02:00 There is ways to get around this, but they're kind of esoteric, and I'm not
02:02 going to show you how to do them in this course, because they're not good
02:04 programming practices.
02:05 Just suffice it to say that you have to have a break at each one of your cases.
02:10 So let's go ahead over to the code and see how a switch statement works.
02:12 Here I have my SwitchStatement project open, and in my ExampleSnippets, I've
02:18 scrolled down to my Switch area.
02:20 So what I'm going to do is copy some code. I'll just copy the first part of the
02:25 switch case here, and I'll paste it in, and I'll close off the switch right
02:32 there, and I'll save.
02:33 So in this case, what we're going to do is write some code that does pretty much
02:37 the same thing that a whole bunch of if else statements would do, but using
02:41 switch case instead.
02:43 So here you can see I've got an integer variable called theVal, and it's being
02:47 set to a value of 50. And then the switch statement says hey what's the value of
02:52 theVal? And for case of 50, the Console will write line, The value is 50.
02:59 So let's save this and run it, and you can see, sure enough, "The value is 50"
03:03 is being written out.
03:04 So if we go back and change it to, say, something like 51 and we save that and run it,
03:08 well, now nothing is happening.
03:10 Okay, let's go back to the code and make some changes.
03:13 Go back to my Snippets, and I'm going to copy the rest of the cases in.
03:17 I'll save that, and now you can see that we have a whole bunch of cases:
03:24 there is 50, 51, 52, and a default case.
03:28 So in the case where I change theVal to be 52, then I save it, and then I run it,
03:34 in that case, the case for 52 is being run.
03:37 If I change it to something else, say 99 in this case, none of these cases is
03:43 going to match, so the default case should be run instead. And sure enough, that's
03:47 exactly what's happening.
03:49 So let's see what happens when you try to take out this break right here.
03:52 And you can see that when I take out the break, the little red error squiggle
03:57 appears under this case. And specifically, it says, "Control cannot fall through
04:01 from one case label to another."
04:03 So you can see here that C# is explicitly enforcing the rule that you have to
04:08 have breaks in your cases.
04:09 So let me just undo that, and we'll save, and we'll run it again, and you can see
04:14 that everything is working just fine.
04:16 So the switch statement provides a pretty handy replacement for a whole bunch
04:21 of nested if else, and I think you can agree with me that reading code that
04:25 looks like this with a whole bunch of cases is a lot nicer than reading a whole
04:29 bunch of ifs and elses.
Collapse this transcript
Using operators and expressions
00:00 Any nontrivial program that you write is going to be full of calculations.
00:04 You are going to be calculating things like scores and prices and all kinds of things.
00:08 And in order to do that, you need expressions, and you need operators to
00:12 build those expressions.
00:14 An expression is essentially just a collection of operators and operands, which
00:19 are the things that operators work on, that produce a result.
00:23 So for example, if we had an expression like this, we had 5 + 2 * the absolute
00:29 value of x, that is an expression.
00:32 And the plus and the star, those are operators.
00:37 Operators are simply symbols and functions that determine how expressions are evaluated.
00:43 So for example, we of course have the arithmetic operators.
00:47 These are pretty common in almost every programming language.
00:49 There's addition, subtraction, division, multiplication, and the percent sign--
00:54 maybe something you have not seen before,
00:55 but it exists in a lot of other languages, like C and JavaScript and
00:59 Objective-C and C++.
01:01 It's the remainder, or modulus, operator.
01:04 Basically it gives you the leftover results of a division operation.
01:10 So for example, 5 modulus 2 would be 5 divided by 2 but what's left over, so it would be 1.
01:16 There's also the assignment operator.
01:19 The assignment operator is the equals sign.
01:21 So take an example: if we had two variables, x and y, and we wanted to add them
01:26 together using the plus operator, or the addition operator,
01:29 we can then take the result of that expression and assign it to a third variable
01:33 called result, using the equal sign.
01:36 If we had a variable named distance and we wanted to add a number to it, we
01:40 could do distance = distance + 10.
01:43 This takes the existing variable, adds 10 to it, puts the result back in the same variable.
01:49 In fact, this is so common that there is a shorthand notation for doing this.
01:53 You can write distance = distance + 10 the same way by just doing distance += 10.
01:59 And in C# that means, take the variable and add to itself the number on
02:04 the right-hand side.
02:05 It also works of course for the minus, the multiplication, the divide, and the
02:10 modulus operators as well.
02:11 In addition to the math operators, there are also comparison operators.
02:16 So for example, we can check to see if things are equal to or not equal to each
02:21 other by using the equality check operators.
02:23 The two equal signs together say, hey, is a equal to b?
02:27 Do they have the same value?
02:29 We can check for things that are not equal by replacing the first equal sign
02:33 with an exclamation point.
02:34 In this case, this says a not equal to b. And as you might expect, there are also
02:39 operators for comparison testing to see if there are a larger or smaller numbers.
02:44 We can do things like a > b, a < b, a >= b, and a <= b.
02:54 The logical operators, such as AND and OR, allow you to combine more than
02:55 one condition.
03:01 So, for example, the AND operator, we can use to see if a=b and c=d. We use
03:09 two ampersands together.
03:10 There is no space in there.
03:11 We just put them next to each other and that is a logical AND operator.
03:15 We can do the same thing for OR.
03:17 The OR operator is just two vertical bars.
03:20 So in this case, if a=b or c=d, then the code inside those curly
03:26 braces would execute.
03:27 We can also do a NOT operator.
03:30 The NOT operator you can place in front of any Boolean expression to produce
03:35 the opposite of what that value evaluates to.
03:38 So for example, in this case, we are saying if not some Boolean value.
03:43 So if we set a to true for a certain Boolean value, then if we use bool b = !a,
03:50 that gives us the inverse value of a. So b is now false.
03:54 That's what the NOT operator does.
03:56 There are also operators for incrementing and decrementing, because again, this
03:59 happens a lot in programming.
04:01 The increment operators are, as you might expect, the addition operator, where you
04:05 simply take a and add 1 to itself.
04:07 We've already seen how to reduce that down using shorthand notation, to take the
04:11 value of a variable and add a value to itself.
04:14 But there's even a shorter hand way of doing this, because this is so common.
04:18 So there's the ++, and the ++ operator, postfix and prefix.
04:24 So when the ++ comes after the variable, that's postfix; and when ++ comes
04:29 before the variable, that's prefix.
04:31 They both do the same thing:
04:33 they both add 1 to whatever the variable is. But they do it in a certain way
04:38 that's slightly different from each other, and we'll see why in just a moment.
04:41 As you might expect, there's also decrement operators.
04:44 So for a + 1, we also have a = a - 1.
04:48 And we've already talked about how we can do the -= operator.
04:51 But there's also post and prefix versions of decrement as well, where you
04:55 simply put two minus signs next to the variable rather than two plus signs.
04:59 So what's the difference there?
05:01 The difference is this:
05:02 Suppose we had a variable whose value is 10.
05:04 If we use this statement, Console.WriteLine ("The value of a is:
05:08 and using our string formatting, we put the value of a into that replacement
05:13 curly braces expression there, the ++ prefix notation would execute first before
05:20 putting the value into the string.
05:22 So in this case, the output would be 11, because a gets incremented before it
05:27 gets put into the value of those curly braces.
05:30 If we use the postfix notation, that increment would get done after the
05:35 substitution took place.
05:37 So in that case, the output would be 10, even though a would then be incremented
05:42 and would be equal to 11.
05:44 So that's the main difference between prefix and postfix increment.
05:47 There's also type testing operators.
05:49 There's the is operator and the as operator.
05:53 And we'll learn more about these as we go through the object-oriented part of the course.
05:57 But essentially, what happens here is the is operator returns true if a given
06:02 object is a certain type.
06:04 The as operator takes a given object and converts it to another type if
06:09 it's possible to do so.
06:10 So let's just take a quick example--and I understand if you don't follow along
06:14 right away with this, but as we get to the chapter on object orientation, this
06:17 will become more clear.
06:19 So suppose we had a function that takes an object,
06:21 a generic object type.
06:23 We can say something like if obj is the type of Employee object.
06:29 So the is operator will return true if the object is of type Employee.
06:34 And if that's the case, we can then use the as operator, which will convert the
06:39 object to the type that we give it.
06:41 And if it can't be done, it will return null.
06:44 So in this case, we are taking the Employee emp and we are saying obj as Employee.
06:50 So it's converting the obj to an employee object which we can then operate on.
06:55 There's also an operator called the ternary operator.
06:57 Now most operators we have seen so far are binary operators.
07:00 So for addition, for example, you have two operands.
07:03 You have the two operands that are being added together.
07:05 The ternary operator works a little bit differently.
07:08 It actually has three operands, and it's written using the question mark and the colon.
07:13 It operates as if it were a very compact if else statement.
07:18 So it works like this:
07:19 You have a condition which evaluates to true or false just like any other statement.
07:24 You then put the question mark next to it and then the value that you want to
07:29 be assigned in the case that the condition is true, and then a colon, and the
07:33 value that you want to be assigned in case the condition is false.
07:36 So let's take a real example.
07:37 Suppose we had a couple of prices and we wanted to find out which of price1 and
07:42 price2 was the low price.
07:44 Now we could write it like this:
07:45 we could say if price 1 < price2 then the lowPrice = price1; otherwise
07:51 lowPrice is price2.
07:52 Or we could write it like this:
07:54 we could say lowPrice = and then the condition.
07:57 The condition here is price1 < price2.
08:01 Now if that evaluates to true--we put the question mark there--price1 would be the low price.
08:06 That's the true case. And then a colon
08:09 and then the value for the false case.
08:10 In this case, it will be price2.
08:11 So you can see we've taken the if statement and compacted it down to just one line of code.
08:17 Finally, there is operator precedence.
08:20 Most programming languages have the notion of operator precedence.
08:23 Operators are operated on in a particular order, based upon what the operator is.
08:28 So let's take a look at an example.
08:30 Suppose I had this expression.
08:32 I have an integer variable named result, and there's a whole bunch of numbers
08:36 being operated on, 2 + 3 * 6 / 2.
08:40 The temptation of course is to execute this expression going from the left and
08:43 traveling to the right, just like you probably learned in school.
08:46 And if you did that, you probably say, okay, well 2 + 3 is 5 and then 5 * 6 is
08:51 30 and then 30 / 2 is 15, so hey, the answer must be 15, right? Well, wrong.
08:56 And the reason it's wrong is because those operators are executed in order based
09:01 upon what the operator is.
09:03 This is what operator precedence means.
09:05 So that's actually wrong.
09:07 What happens is the multiplication operator gets executed first, because that
09:11 comes first in the precedence order.
09:14 So 3 * 6 would be 18.
09:16 Then the division operator would execute, and 18 * 2 would be 9.
09:22 Then we would go back and we would do the addition, because 9 + 2 is now 11.
09:27 So the real result would be 11.
09:29 Now you can change the order of precedence by using parentheses.
09:33 So if we put parentheses around the 2 and the 3 then things would execute in
09:37 the order that you thought they would.
09:38 In this case, the (2 + 3) would be executed first because it's in parentheses.
09:42 Then *6 is 30, divided by 2 is 15,
09:44 so the answer in that case would be 15.
09:47 So how do you know which operators come first?
09:49 Well, let's take a look.
09:50 The operator precedence operates in a very predictable order.
09:53 First, there is the Multiplicative operators, which are things like
09:57 multiplication, division, and the modulus operator.
10:00 Next comes the Additive operators, which in this case are + and -.
10:04 Then there is the Comparison and Type Testing, so things like >, <, >=, <=, the
10:11 is, the as operators.
10:13 Then the Equality tests come, so == and !=.
10:17 That's followed by a Conditional AND, which is followed by Conditional OR.
10:21 Then the Ternary operator comes.
10:23 And then finally, the last operator to execute is the Assignment operator.
10:27 Keep these rules in mind, because this is the source of a lot of bugs in programs
10:32 of beginning developers.
10:34 And once you realize that the operators execute in an order of precedence, this
10:38 will save you a lot of headaches down the road.
Collapse this transcript
Using constants and enumerations
00:00 In this example, we are going to look at using constants and enumerations.
00:04 Constants and enumerations are basically C# programming constructs that make
00:09 your code easier to understand and easier to maintain.
00:13 So let's take a look at what we mean by that.
00:16 Suppose we had some code that looked like this.
00:19 So we have some if statement and we've got some variable, and we are comparing it
00:23 to the constant number 32.
00:26 And if that condition evaluates to true then some code is going to run.
00:30 The problem is this is a bad practice. First of all, what does 32 even mean?
00:33 I mean if I am a programmer, I am writing the code,
00:35 I might know what it means, but two years from now, I might not know what it means.
00:39 Somebody goes to look at my code, but has no idea what that means.
00:42 Worse yet, what if it changes in the future?
00:44 If I am using this 32 value all over my program, I am going to have to change it
00:48 if for some reason in the future that 32 is no longer applicable and the test
00:53 needs to test for some other number.
00:55 Well, the way that we fix this problem is by using constants and enumerations.
01:00 So we can write the same thing by writing if (someVar == FREEZING), then the code runs.
01:07 That's much better.
01:08 It's clear what the code is trying to do.
01:10 It's testing for some freezing value of some liquid.
01:14 And if we ever decide to switch it, we just change the constant definition in one place.
01:19 And the way you define that constant freezing is by using the const structure.
01:24 So here I am saying const and then the int, and then the name of the constant
01:29 that I want to use is equal to some number.
01:33 So constants are used for numbers whose value is not going to change over the
01:38 life of the program.
01:40 So here you can see I have got a definition for const int FREEZING = 32.
01:45 That's the freezing point of water.
01:47 The freezing point of water is very unlikely to change in the future,
01:50 so therefore, I define a constant for it.
01:53 So if I want to change this constant to something else in the future, or change
01:57 it to some other definition, I just do it in one place and the rest of my code
02:01 just picks up the change,
02:03 and people reading my code in the future know what that means.
02:06 Enumerations are a close cousin to constants.
02:09 And what you'll probably find in many situations is that you'll use a whole
02:14 bunch of constants that are related to each other.
02:16 For example, if we had a constant for the freezing point of water, we might have
02:20 a whole bunch of other constants that go along with it.
02:22 There might be one for LUKEWARM and for HOT and for BOILING.
02:25 Well, it seems kind of silly to have all these separate constants defined for
02:30 different values that are really all related.
02:32 So the way you solve that problem is using what's called an enumeration.
02:37 In this case, we can build what's called an enumeration for temperatures, and
02:41 we just simply group them altogether.
02:43 So, for example, we would group the value of FREEZING and LUKEWARM and HOT and
02:48 BOILING all into one enumeration.
02:51 This way if we wanted to add a new one in the future--like say we want to add
02:54 one for ROOMTEMP--all we would do is make room for it in the enumeration, add
02:59 the value for it, and then we are done.
03:01 So now we have a whole bunch of temperatures that are grouped together logically,
03:05 instead of having a whole bunch of different const int definitions.
03:08 Enumerations start off at 0 by default if there is no value assignment.
03:13 So for example, if we have our temperatures enumeration and we put something at
03:17 the front of it, like, say, REALLYCOLD, that's going to default to the value of
03:21 0, unless you explicitly assign a value to it.
03:24 So to build an enumeration, you simply have the values that you want to assign
03:28 to words which are easy to read.
03:30 And if you don't assign it, then it defaults to 0.
03:34 If you also don't make a definition after one that's already been defined, then
03:38 that defaults to one more than whatever the previous definition was.
03:42 So for example, if we were to put another definition in here right after
03:46 FREEZING which would be, say, JUSTBARELYABOVEFREEZING and we didn't put an
03:50 equal sign, then it would default to the value of 33 in this case.
03:54 Now enumerations by default are integer types, but you can specify other
04:00 types if you want to.
04:01 Now we'll learn a little bit more about types in the next section, but just bear
04:05 with me here for a second.
04:06 So if we have temperatures and we have all of these values assigned to our
04:11 temperature enumeration, those default to integers.
04:14 But if I wanted to, say, assign them to the value of a byte in order to save space
04:18 in my program for some reason, then I could put a colon there and the name of
04:22 the type that I want the temperature enumeration to be.
04:25 So for example, in this case, if I know the value is never going to go above
04:27 255, which is the maximum value that one byte can hold, I can just define this to be a byte.
04:34 To define enumerations, you can use types that are numeric in nature, such as
04:38 byte and shorts and ints and longs.
04:41 And again, we'll learn what these are a little bit later in the course.
04:44 But I just wanted to point this out here, that you can define enumerations
04:48 that are not integers by using a colon and then the type that you want the enumeration to be.
04:53 So let's go ahead and jump over to the code and see some constants and
04:56 enumerations in action.
04:57 Here I have got my ConstAndEnums project open in my editor, and I've got
05:03 my Snippets.txt file.
05:05 And I've scrolled down to the Constants and Enumerations section.
05:08 So let's go ahead and copy some code over and see how things work.
05:11 So I am going to start with these lines right here, copy those, and put them in
05:17 my program, right here in Main.
05:20 So I have now defined constants for the freezing point of water and the
05:24 boiling point of water.
05:25 You can see I am getting a little warning that says, hey, you've defined this
05:28 constant, but you've never used it, so let's go ahead and fix that.
05:31 I am going to save, go back over to my Snippets, and I am going to copy
05:36 this code right here.
05:37 So now I have copied in some code that's going to use those constants.
05:47 So here, let's go down a little bit.
05:49 I've got an integer variable named myTemp, and I am setting it to be 65.
05:53 And then I have an if else condition for if myTemp is greater than freezing
05:58 point and it's less than the boiling point, then we write out, hey, at this
06:02 temperature, water was liquid;
06:04 otherwise we write out, hey, water is not liquid at this temperature.
06:07 So let's save and let's run it,
06:11 and we can see that at 65 degrees, water is a liquid.
06:14 And if we change this to, say, 30 and run it, then we say, aah!
06:20 At this temperature, water is not a liquid.
06:24 So let's do the same thing now, only using an enumeration, because you can see
06:27 here, I've got two different constants for freezing and boiling.
06:30 Let's go back to my Snippets.
06:31 What I am going to do is up here I have an enumeration for my temperature,
06:36 so I am going to copy that back over to my program.
06:42 Now I am going to put this definition outside the Main function.
06:45 I am going to put it in my class definition up here.
06:48 Paste that in, so now I have an enumeration for my temperatures. So you can see
06:51 here that the syntax highlighting is showing me that everything looks right.
06:55 So I have enumeration for FREEZING, LUKEWARM, ROOMTEMP, HOT, and BOILING.
06:59 Go back to my snippets. And now I am going to use these two lines down here instead.
07:07 Copy. And we'll go back to Main. And what we'll do is we'll get rid of these
07:14 guys, and we'll paste these in.
07:17 So now you can see I am using temperatures enumeration instead of the constants
07:21 that I've got defined here.
07:22 And in fact, since I am not using them anymore, let's just get rid of them.
07:25 The nice thing about enumerations is that, because they are part of your program
07:29 and the C# interpreter can look at them and see what they are,
07:32 when you type, it will actually help you type the value out.
07:36 So for example, suppose this piece of code wasn't there.
07:41 I can start writing the word Temperatures,
07:43 and you can see that the Temperatures IntelliSense is showing up right there.
07:46 So I am going to double-click that and it's going to get inserted.
07:48 Then when I hit the period, you can see that it's introspecting the
07:52 enumeration for me.
07:53 So I can scroll down to the one that I want, and that's FREEZING.
07:58 So I am going to have to just do this. Bear with me for a second while I do this,
08:03 because we'll learn about conversion in the future, but I have to tell the
08:07 interpreter that the Temperatures enumeration is an integer.
08:11 And now I can say okay, if the temperature is greater than FREEZING and is less
08:16 than BOILING, then we are doing the same thing.
08:18 At this temperature, water is a liquid or it's not.
08:21 So let's change this to 65 and run it,
08:24 and you can see that water is a liquid at 65.
08:28 The nice thing about this is that the code here is much easier to read than
08:31 having some numerical value that you don't know what it is.
08:35 And in the future, if I ever wanted to, I could change these numbers up here,
08:39 and I would not have to change them all over my program wherever they are being used.
08:43 Just make the change in one place.
08:45 So that's the argument for using constants and enumerations to make your code a
08:49 lot easier to read and a lot easier to maintain.
Collapse this transcript
Using loops
00:00 Along with some pretty basic stuff, like constants and enumerations and
00:05 conditional statements and operators and expressions, loops are one of the most
00:09 basic building blocks of any kind of programming language.
00:13 Loops are essentially blocks of code that execute over and over again.
00:18 And there are two different basic kinds of loops:
00:22 there are loops that execute while a condition is met and there are loops that
00:26 execute a set number of times.
00:29 So for example, you might have a loop that's running some piece of code for as
00:33 long as a certain condition is true, like the user has not logged out, or the end
00:38 of a file has not yet been reached, or something like that.
00:41 You might also have a loop that runs a set number of times: the number of people
00:45 attending a concert or something like that.
00:48 The way that you write loops is by using a couple of different constructs.
00:52 For loops that execute while a condition is met, you have a while loop,
00:57 and the while loop is written as you see it there.
00:59 It can have the keyword while.
01:01 And then inside some parentheses, you have a condition that is true.
01:05 And then inside the curly braces, you've got some code that's going to execute
01:09 as long as that condition is true.
01:10 There's also a close cousin of the while loop, which is the do-while loop.
01:15 And in this case, the while goes at the bottom of the loop instead of the top.
01:20 And the main difference here is that the while loop is only going to execute
01:25 when that condition is met.
01:27 If that condition test is not met, nothing inside the while loop is going to
01:31 run and that condition is evaluated before the while loop ever even gets a chance to run.
01:36 The do-while loop is a little bit different.
01:38 The code that is inside that loop is going to execute at least one time.
01:43 And that's because it executes once-- then the while is executed at the end of
01:48 the loop to see if things should keep going.
01:51 So in the case where you want to have a loop that runs only while a condition is
01:55 met and no other times, use the while loop.
01:57 If you have a condition where you want to execute some code just one time and
02:02 then check to see if you should keep going, that's the do-while loop.
02:05 For the set number of times case, there is the for loop.
02:10 And the for loop executes a given number of times and it runs the code that's
02:15 inside the curly braces.
02:16 A close relative of the for loop is the for-each loop,
02:21 but we're not going to cover that one in this particular movie because it has to
02:25 do with something called enumeration.
02:27 And we'll look at it a little bit later in the course.
02:30 For now we're going to concentrate on the while, do-while, and for loops.
02:35 Let's take a look at the code to see how this works.
02:38 I've got my example here opened.
02:41 This is my Loops project.
02:43 And over in my Snippets, I've got my code, and I'm scrolled down to the Loops section.
02:49 So let's take a look at how the basic while loop works.
02:52 So I am going to copy these lines of code here.
02:54 I am going to copy that, and I'm going to paste into my Main.
03:01 So I've got here an integer variable named myVal, and we have a basic while loop.
03:07 We're first going to write out a string of text that says Basic while() loop.
03:11 And then you see here, here's the while definition:
03:14 so while (myVal < 20). We're going to write myVal is currently and we're going
03:21 to use the console's WriteLine method with some string formatting here to write
03:25 out what the current value of myVal is.
03:28 As always with loops, you want to make sure that the loop has some way to exit;
03:32 otherwise, you'll end up with what's known as an infinite loop.
03:36 An infinite loop is a loop of code that just keeps going and going and going and
03:39 going and never has any way to get out of it.
03:42 So you want to make sure that you've got some code inside your loop, such that at some point
03:47 this condition up here is going to become false, and therefore your loop can
03:50 terminate, and your program can continue on its merry way.
03:54 So what we're doing here is, at the bottom of this loop, we're taking myVal and
03:59 we're adding 3 to it each time.
04:01 And recall that the += notation there means myVal = myVal + 3.
04:07 So when myVal becomes greater than 20, that condition will no longer be true if
04:11 they're in the while loop, and the loop should stop.
04:13 So let's save this, and we're going to go ahead and run it.
04:17 And you can see that the string gets written out, Basic while() loop, and myVal is
04:23 15, and then we add 3, so myVal is currently 18.
04:27 And then we add 3 and myVal becomes 21.
04:30 So when the code executes and goes back to the top of the loop, that test is no
04:35 longer true, and the loop stops.
04:38 So right here. So the code executes in this line, from top to bottom. The last
04:43 statement is the myVal += 3 right here.
04:46 When that executes, it gets to this curly brace,
04:49 it will go back up to the top of the loop, and then this condition gets tested, and it fails the test.
04:54 And that's what terminates the loop. Okay.
04:56 Let's take a look at another example.
04:59 In this case, we're going to look at the do-while loop. And I am going to copy
05:05 these lines of code right here.
05:07 Okay, let's get rid of this one. And paste.
05:19 In this case, we have a do-while loop, and remember that in the case of
05:22 the do-while loop, the code inside the braces gets executed once before
05:26 this condition gets met.
05:28 So in this case we have pretty much the same code.
05:30 We're writing out the Console.WriteLine value there.
05:33 We're adding 3 each time.
05:34 But let's see what happens.
05:36 So this time we're going to save, and we're going to run it.
05:40 You can see here that the do-while() loop, myVal is currently 15, myVal is
05:44 currently 18, and then we add 3 and then myVal is 21, and the condition no longer
05:50 is true and therefore the loop executes right here.
05:53 So right here when we add the myVal += 3. This is no longer running.
05:57 But let's watch what happens when I set this up at 20 to begin with.
06:02 I am going to save it.
06:03 I am going to run it.
06:05 And you see even though myVal is not less than 20,
06:08 it still goes through the loop at least one time.
06:12 So that code is going to get executed once before the while condition has a
06:15 chance to be evaluated.
06:17 So even though the condition is false, the code got executed one time.
06:22 So that's the do-while loop.
06:23 Let's take a look at our friend, the for loop.
06:25 Here's the code for the for loop right here.
06:31 I am going to copy that, and we're going to paste it.
06:37 A for loop is set up using three compact statements within the for statement itself.
06:43 So here's the for right here.
06:46 And then the first statement is the initialization of the counter variable.
06:51 In fact, I could expand that out and do something like this, where I say int i,
06:57 and then I wouldn't need to do this here.
06:59 I would simply say for (i = 0).
07:01 What I was doing there was just concatenating one with the other.
07:05 So this is the initialization, or setup, of the counter variable.
07:08 Then we have the test to see if i is less than myVal.
07:12 This is the condition that gets evaluated each time.
07:15 And then this is the statement that gets evaluated when the loop is complete. So this is setup,
07:20 this is the condition, and then this is what happens each time through the loop.
07:24 So i is going to start out at 0.
07:26 We're going to test to see if it's less than myVal, which is 20 right here, and
07:30 we're going to add 5 each time.
07:32 And each time through the loop we're going to write out i is currently
07:35 whatever its value is.
07:36 So I am going to save and we run it.
07:38 And you can see that i starts out at 0, then it's 5, then it's 10, then it's 15,
07:44 and then it gets to be 20, and that condition no longer needs to be true.
07:49 So 20 is not less than 20.
07:52 If we change this to be less than or equal to, then 20 will actually match the condition.
07:57 So if we run it again, you'll see that in this case i is less than or equal to
08:02 myVal, because 20 matches the less than or equal to part of the condition.
08:08 So that's the for loop, and that's how you get a loop to execute a certain number of times.
08:13 Let's take a look at some other keywords we can use with loops.
08:15 There are two special keywords that can be used with loops.
08:18 There's the break keyword, which breaks out of the loop at the current point,
08:23 regardless of whether the test condition has been met or not.
08:27 And there's the continue keyword, which basically says, hey, skip the rest of the
08:32 code in the loop and then just jump back to the top of the loop code as if you
08:37 had it completed one of the loops.
08:39 So let's take a look at how these work.
08:41 So I am going to erase the code from my previous example, and we're going to
08:45 go back to the Snippets, and I am going to copy over the last part of the
08:49 example right here.
08:50 I am going to copy, and I am going to paste.
08:56 So in this case, we're going to use the continue and break keywords.
09:00 So here I have a for loop that's starting off at 0, and it's going to run until i
09:06 is less than 10, and we're going to increment i by 1 each time.
09:10 We're using the postfix increment operator here.
09:13 Now, there are two special conditions in here.
09:16 When i is equal to 5, I am going to use the continue keyword.
09:21 continue basically says, hey, skip everything from here on down, go down to the
09:25 last brace, and then go back to the top again and execute whatever the third
09:29 statement over here is--
09:31 this part of the increment loop right here.
09:33 And then in the case where i is equal to 9, I am going to use the break keyword,
09:38 which basically means, hey, you know what?
09:40 Just stop the loop.
09:41 It doesn't really matter where we are.
09:43 It doesn't matter what the condition test up here. Just stop.
09:46 So let's save and we will run it.
09:49 Let's take a look at the output.
09:50 So you can see that i starts off at 0, Then it goes to 1, then 2, then 3, then 4.
09:56 But remember, for the 5 case, we use the continue keyword.
10:01 So we skipped over the line of code that said Console.WriteLine, so that line of
10:05 code never got executed.
10:07 The loop just continued as if it had run, but it skipped passed all the logic
10:11 that put where the continue keyword was.
10:14 And then we continue incrementing, so i is now 6, then 7, and then 8.
10:19 And then remember, when we got to the 9 case, we used the break keyword, which
10:24 stops the loop in its tracks, as if the condition had failed.
10:28 So let's go back to the code, and let's take this statement out.
10:32 I am going to comment this out and run it again.
10:37 And you can see, in this case, the loop does make it to 9, and then the value of i
10:41 becomes 10, which is where it triggers the condition, and the condition is no
10:45 longer met and the loop stops.
10:47 So if we go back to the code and we uncomment this, put the code back in, if I
10:52 change this to say 7 and save and then run, you'll see that in this case, the
10:57 loop only makes it as far as 6 because as soon as i gets to be 7, we're calling
11:02 the break command, which stops the loop.
11:05 Loops are a very powerful part of programming, and you can see that C# loops are
11:10 pretty versatile and pretty powerful in their own right.
Collapse this transcript
Using functions and methods
00:00 The last major piece of program flow that we're going to take a look at in this
00:03 section are functions.
00:05 Functions are a nice mechanism for breaking up large sections of code into
00:12 smaller pieces that are reusable, and make your programs easier to understand and
00:17 maintain. And one of the things you'll find when you're doing your C#
00:21 development, or development in any language, really, you'll find that any
00:24 nontrivial program that consists of many lines of code starts to get really
00:29 unwieldy and is really hard to change and maintain, and functions really make
00:33 that process a lot easier.
00:35 Now the reason why I included the word "methods" is because C# is an
00:40 object-oriented language and in object-oriented parlance, functions are
00:44 typically called methods, because in C# a function has to be part of an object.
00:50 There are no global functions, which I covered a little bit earlier.
00:53 So the word function and method are pretty much interchangeable in this context.
00:59 So anywhere you see me use the word functions, you can just mentally hear me
01:03 using the word methods, and/or vice versa.
01:06 To define a function, it's a pretty straightforward process.
01:11 We start off by giving it a name.
01:14 So to create a function, the function has to have a name, and you can use
01:17 whatever uppercase, lowercase rules you want to use. In this case, I am starting
01:20 off with a lowercase letter and I am using what's called CamelCase, and I am
01:24 capitalizing the interior words of the function.
01:28 But that's up to you.
01:29 You can use letters.
01:30 You can't use special symbols, like dollar signs or parentheses or anything like that;
01:34 it's got to be alphanumeric.
01:35 So here I have a function and I have given it a name.
01:38 Then I have to give it what's called a parameter list.
01:41 There are two parentheses and inside those parentheses, these are the arguments
01:47 that the function takes.
01:49 This is the data that the function is going to operate on. And inside the
01:53 function, I have the code of the function.
01:56 This is the stuff that the function does.
01:59 In this case, the function is simply calling Console.WriteLine.
02:03 In the parameter list, where the arguments go, I can supply one or more arguments,
02:09 or parameters, to the function.
02:11 So for example, if I want to pass in an integer, I would pass in int x. In
02:16 some other languages, like JavaScript, you don't have to declare the type in
02:20 front of the argument.
02:21 You simply give the argument a name, and you pass it into the function, and C# doesn't work like that.
02:27 In C# you have to tell the function, here's the kind of argument that's going to be coming in.
02:32 In this case, it's an integer.
02:34 If I wanted to pass in more than one, I would use a comma to separate them.
02:38 And in this case I am passing in an integer named X and a date argument named D.
02:44 Now in addition to the name of the function and the arguments, I have to say
02:49 what the return type of the function is. What kind of value does the function pass back?
02:55 I can say, for example, that the function passes back an integer.
02:58 Now, notice I don't name what the function is passing back.
03:01 I am just simply saying here that the function returns an integer. And it
03:04 can return an integer; it can return a string;
03:07 it can return any other kind of data type. And we'll learn a little bit more
03:10 about data types later on in the course.
03:11 But for now, just follow along with me here. I am saying that this function
03:15 returns an integer, and it takes an integer and a date as an argument.
03:20 If I didn't want to pass in any argument, I can simply leave the area inside the
03:24 parentheses blank and not pass in any arguments at all. But in this case, I've
03:29 got a couple of arguments.
03:30 And then finally, there is the code inside the curly braces for the function, and
03:34 that's what the function actually does.
03:36 In cases where functions return a value--in this case, this function is
03:40 returning an integer--
03:41 I have to make sure that the function actually does that, and I do that by using
03:44 the return statement.
03:46 In this case, I am returning a variable named someValue, which is probably
03:52 defined somewhere in this function as an integer.
03:55 The value that I am returning has to match the type of the return value for the function.
04:01 So if I declare this someValue variable in my function somewhere, it would have
04:05 to be an integer just like the return type of the function.
04:08 Functions don't have to return values.
04:10 I could just simply say void, in which case I've defined a function that takes a
04:14 couple of arguments but doesn't return anything. And in that case I don't need a
04:19 return statement at all.
04:20 I can just simply get rid of that, because there is no return value for the function.
04:25 I can also just simply use the word return with a semicolon by itself, but in
04:29 this case I've just got rid of it because it doesn't return anything.
04:32 So let's actually jump over to the code and see how to write a function that
04:36 does what we have described here.
04:38 So in my FuncsAndMethods project I've also got my Snippets file open, and I have
04:44 scrolled down to the Functions and Methods part.
04:46 So let's go ahead and copy some of this code and paste it in.
04:49 I am going to copy these three lines.
04:52 I will paste that, and let's take a look at what I've pasted in.
04:58 I have got an integer variable named result1, and then I am assigning
05:02 result1 the result of a formula function. And you can see here there are some
05:08 red squiggles there.
05:09 It says, "The name 'formula' does not exist in the current context."
05:12 That's a function that apparently takes an integer argument which I have not defined yet.
05:18 So let me go get the code for the formula function, and that's it right here.
05:24 I am going to copy that, and I am going to paste it.
05:30 So now, I have defined a function named formula which takes an integer argument
05:35 and returns an integer.
05:36 For the moment, you've probably noticed this word static right here. Just bear
05:40 with me about why we need that.
05:42 I am not going to cover it right now.
05:43 We'll get to that when we get to the section on object-oriented programming
05:46 a little bit later. It's just something we need right now for the function to work.
05:50 So don't worry about that right now. Let's pretend it's not there.
05:53 What's important is the return type right here of int, and the argument it takes
05:57 is an int, and this is the name of the function right here.
06:01 In some languages, for example C or Objective-C, the order in which you define
06:06 your functions is somewhat important.
06:08 So for example, if this were C and I put the definition of this function down
06:13 below where I am calling it up here,
06:15 I would have to have some type of code statement up here that says, "Hey!
06:20 program, there is going to be this function called formula that you're going to come across.
06:23 Don't worry about it."
06:24 I am just telling you about it now.
06:26 In C# you don't need to do that.
06:28 In C# you can just declare this function wherever you like and you can call it
06:31 from over here, and the C# interpreter is smart enough to realize oh, okay,
06:35 well, there must be a function named formula coming down, so I will just wait till I see it.
06:39 So here's what we're going to do.
06:40 We're going to call the formula function with an argument--in this case, it's
06:44 14. The function is going to do its work.
06:46 It's going to return an integer value and that value is going to be set into
06:50 result1, and then this statement right here Console.WriteLine is going to write
06:55 out whatever the result is.
06:56 So let's go ahead and save that, and let's run it. And you can see that the
07:02 result being written out is 24.
07:05 So the result of the formula inside the function evaluated to be 24.
07:10 So I'll say, okay. Let's go back up here.
07:12 Let's change this to something else.
07:13 I am going to type a new variable, and I am going to call it arg1. And I am going
07:22 to give it a value of 25. And now instead of passing in the hard-coded value of
07:32 14, I am going to copy arg1 and I am going to paste it in the calling place
07:38 where I am calling formula.
07:39 I am going to save it, I am going to run it, and you can see that now we've
07:43 produced a different result.
07:45 So that pretty much brings us to the close of this section.
07:48 In this section we've seen how program flow works.
07:50 We've covered things like functions, and we've seen constants and enumerations.
07:53 We learned how to write conditional statements, and we have learned about
07:56 operators and expressions.
07:58 We've got to the point now where we continue on and learn more about C# and
08:01 learn how to do things like declare variables and use objects and so on.
08:05 But this chapter should have given you a good foundation for a lot of the
08:08 basic parts of C# that you're going to come across in any program that you
08:12 decide to write, or work on.
Collapse this transcript
4. Variables
Understanding data types
00:00 Earlier in one of the course, I mentioned that C# was a strongly typed
00:04 language, meaning that you can't just simply declare variables and not tell the
00:10 system what the types are.
00:11 You'll find that as you build your C# programs, this actually becomes quite an
00:15 advantage, rather than the encumbrance that it sounds like.
00:19 Program store and keep track of all kinds of data.
00:23 They keep track of numbers and prices and names and email addresses and dates,
00:28 and these pieces of data are stored in memory locations called variables, and
00:32 each piece of data can have a type, which is used to declare a variable.
00:39 In some languages, such as JavaScript, you can declare variables and you can
00:44 change their types around.
00:45 You can do all kinds of great stuff. And you can't do that with C#.
00:50 So for example, in JavaScript you can just do this.
00:52 You can say myData = true; that's okay in JavaScript.
00:56 You can't do that and C#; you have to actually declare the variable.
01:00 In JavaScript if you just use a variable about declaring it, JavaScript
01:03 assumes it's a global variable. Well, C# doesn't have a global variables, so this wouldn't work.
01:08 You have to actually declare it, so you declare it.
01:11 In JavaScript you can do things like var myData = 123456.
01:13 And in fact, you can do this in to C# too.
01:18 C# does support the var keyword, but it's a little bit advanced for C#, and we're
01:23 not going to cover it in this course.
01:25 However, in JavaScript you can do things like this: once you declare the
01:28 variable and you've assigned it a number, later on in life you can say, hey, you
01:32 know what, myData is a text string now.
01:34 Again, that's okay in JavaScript, but you can't do that in C#.
01:38 Your variable can't change type once you've declared it and once
01:42 you've initialized it.
01:44 So that's an example of things that work in some other languages
01:47 that don't work in C#.
01:49 So how do you declare and name a variable in C#?
01:52 Well, let's take a look at that.
01:53 To declare variable, you simply indicate a type and then you give it a name, and
01:59 optionally you can give the variable an initial value.
02:03 So all of these are valid ways of declaring, and in some cases initializing, C# variables.
02:10 C# variable names can start with a letter or an underscore. And after that, you
02:16 can have letters, numbers, and underscores up to 255 characters.
02:22 Now you can't start a variable name with a number.
02:25 It has to be a letter or underscore, and the letter can be upper- or lowercase.
02:28 Remember that C# is case sensitive.
02:31 So, uppercase and lowercase variable names are different, so you have to keep that in mind.
02:36 This will sometimes lead to bugs for newer C# developers who've come from
02:40 languages where things are not case sensitive.
02:43 They're case insensitive.
02:44 That's not the case here with C#.
02:45 You do have to remember that.
02:46 C# has a number of primitive data types that are built into the language, and the
02:53 reason they're called primitive data types is because they are the basic
02:57 building blocks that you use to build other data types.
03:00 For example--and you've probably seen me using some of these throughout the
03:04 course so far, as we built some of our examples--
03:06 there is the int data type, which is an integer.
03:09 That's 4 bytes. And it holds numbers from about -2.1 billion up to about +2.1 billion.
03:18 There are date data types. The date is 8 bytes, and it represents January 1st
03:24 from the year one, up through midnight on December 31st of the year 9999, which
03:30 is a very long time.
03:31 There's also a char data type, which is a single character, and that's 2 bytes,
03:35 because it's Unicode.
03:36 Unlike other languages where character is 1 byte, in C#, it's 2 bytes.
03:40 There are strings. Strings can hold from about 0 to 2 billion characters.
03:45 That's a very, very long string.
03:47 There is also an object type. And in this case the object is actually defined by
03:52 your program, although C# and .NET does provide a base object definition for
03:58 you. And it takes up as much memory as its structure and as memory allows.
04:03 So you can have all kinds of data fields inside your objects.
04:06 And then rounding out the primitive data types are a whole bunch of other types
04:10 like Boolean and bytes and decimals and doubles, and all kinds of other numeric
04:16 data types and Boolean other non numeric data types.
04:19 There is also a special kind of data type in C# called a nullable type.
04:24 A nullable type can represent the full range of values of the normal underlying
04:29 data type, along with the additional value of null.
04:35 And normally when you declare a variable, like an integer, it has to be a number;
04:38 you can't set that variable to null like you can in JavaScript.
04:42 In C#, if you want to be able to do that, you have to declare what's called a nullable type.
04:47 This is a little bit advanced, and we won't see very much of it in the course,
04:50 but I wanted to point it out to you, because you will occasionally run cross
04:53 it in your C# travels, so I wanted make sure that you know what it is.
04:57 So, a nullable type, like I can said, it can be null along with whatever its
05:01 normal data type is.
05:02 So for example, if we declared a Boolean variable with the name of B, that can
05:07 be either true or false.
05:09 If you try to do this, however, set it to null, that's an error.
05:12 You can't set B to null.
05:13 If you want to do that, you'll have to declare the Boolean variable as a
05:18 nullable type, and the way you do that is you declare as a bool with a question mark
05:22 at the end.
05:23 And that tells the compiler, hey, this is a variable that can be either true or false or null.
05:29 You can do the same thing with integers.
05:31 If I put question mark on the end of the integer,
05:33 it can be an integer value or it can be null.
05:37 Using these kinds of primitive data types, you can build all kinds of C#
05:42 variables and higher-order objects which we will see a little bit later in the course.
05:46 For now though, now that we've seen primitive data types, there is one other
05:49 thing we just need to look at and understand, and that is how C# deals with
05:52 the notion of objects.
Collapse this transcript
(Almost) everything is an object
00:00 One of the things that I said earlier on in one of the course is that almost
00:02 everything is an object in .NET and in C#. And the way that that works is that
00:08 at the base level of the .NET library is a base type called System.Object.
00:14 All of the other types that we talked about so far, such as ints and doubles and
00:18 characters and bytes and so on, all of these are primitive types, but C#
00:22 actually derives all of these base primitive types from System.Object.
00:28 What's interesting about this is that even though the int data type is built
00:32 into .NET and C#, int actually maps to a System.Int32. int is just a shorthand
00:40 way of saying, use the class System.Int32. The same thing goes for char.
00:45 A char data type is actually a System.Char object.
00:49 Same thing with strings; strings are System.String objects.
00:52 These all derive from System.Object, and the same is true for all the other
00:56 objects that you see listed here, and all the primitive data types.
00:58 Date, bytes, doubles, all of those are actually objects.
01:02 They derive from System.Object.
01:04 So why is this important?
01:05 Well, it lets you do some pretty neat things.
01:07 If I were to declare a variable int i = 0,
01:11 I could do the same thing by saying int i = new int.
01:15 Other languages don't let you do this because they don't understand it, but in
01:18 C# and .NET, because pretty much everything is an object, you can do this.
01:22 These are functionally equivalent to each other. Declaring the variable as an
01:26 integer, initializing it to 0, and saying new is pretty much the same thing.
01:32 It also means that the built-in objects have some pretty cool features.
01:36 So for example, this integer is really an object, and it has functions that
01:40 I can call on it. So I can do things like i.GetType, and that will return System.In32.
01:46 That's the kind of object that it is.
01:48 I could say, i.ToString, and that would return a string.
01:51 Now remember, I'm doing all this on a basic integer.
01:53 I can do things like i.Equals, and give it an argument, and that returns whether
01:58 two objects are equal.
01:59 So once you get around the idea that everything pretty much in .NET and C# is an object,
02:05 it gives you a certain amount of freedom in your programs and some really great
02:09 functionality that other languages don't provide.
02:11 Let's take a look at an example.
02:13 Let's return to our old friend, the is operator.
02:16 Now I briefly talked about the is operator earlier on in the course, but now
02:20 let's take a look at how you might use it.
02:21 Suppose I had a function that took an object as an argument. And again, remember
02:27 here that that word "object" is really an alias.
02:30 It is a shorthand way of saying System.Object.
02:33 So here I have a function that's taking an object as an argument and it returns
02:37 an integer data type.
02:39 Inside this function I would be able to do things like say, hey, if the obj
02:43 argument that I'm being given is an int, and then I can convert that object to
02:48 an integer and then operate on the argument as if it were an integer. Or I could
02:52 say, hey, if the obj is a string, then convert the object to a string and then
02:57 operate on it as if it were a string.
02:59 This gives me a lot of flexibility in the way that I write my code.
03:02 I can write some C# code that's very flexible,
03:04 takes different kinds of arguments in one large container, and then convert
03:09 between them as I need them.
03:11 So what's so great about this?
03:12 Well, first, the fact that pretty much everything is an object provides a
03:16 unified way of working with all the variable types. You don't have to
03:21 treat primitive types one way and objects another way like you do in other languages.
03:26 Basic variable types in C# have some pretty cool automatic features built in,
03:31 and we'll see more of this as we work with each one of the other data types in depth.
03:35 All the C# types can be converted to and from objects, so they can be passed to
03:40 functions that take objects as parameters, as you saw it earlier.
03:44 So now you can write code that's very flexible.
03:46 You can write functions that take objects and take variables of different types
03:50 and work on them as if they were each with their own types.
03:54 So for example, I can write a function that takes an object or a series of
03:57 objects, pass them all kinds of variables, like strings and integers and doubles
04:01 and floats, find out what kinds they are, and then work on them as I would in
04:05 ordinary variable of that type.
04:07 And will see examples of this as we move through the course.
Collapse this transcript
Working with numbers
00:00 Let's talk a little bit about working with integer numbers in C#.
00:03 Up until now you've been seeing me use the int data type throughout all the
00:07 examples that we've encountered up until now, but there are plenty of other
00:10 ways of working with integer numbers. And the only real difference between the
00:14 various data types for working with integers is the size of the variable
00:19 container, which basically dictates the range of numbers that that variable can hold.
00:23 For example, there is bytes, which are 8 bits in size, and they are unsigned by default.
00:31 They are 0 to 255.
00:34 That's just 8 bits, and 255 is the largest number that you can hold inside of a byte.
00:40 Along with a byte is the sbyte, which means signed byte, that's also 8 bits, and
00:46 it can hold the number from -128 to 127.
00:51 So byte and sbyte are both the same size.
00:53 It's just a question of which one you want to use when you know that the number
00:56 is only going to be positive, or if the number might be signed.
00:59 Similarly, there is a data type called the short. The short is 16 bits, or 2 bytes,
01:04 and that can hold -32,768 up to 32,767.
01:10 Now notice unlike byte, shorts are signed by default.
01:14 So if you want to use an unsigned version of this, you have to use the ushort,
01:18 which stands for unsigned short. It's also 16 bits, and it can hold the
01:22 number from 0 to 65,535.
01:24 The next step off from there is of course the int, which is what you've been
01:29 seeing we use all this time.
01:30 It's 32 bits, and it can hold from -2.1 billion to 2.1 billion. And there is of
01:36 course an unsigned version of it, which is uint, for unsigned integer. It's also
01:40 32 bits, and since it's unsigned, it can hold from 0 up to about 4.3 billion.
01:48 That's a pretty good range of data, but suppose we want to handle numbers that
01:52 are larger than 4.3 billion.
01:54 Well, no, we are not out of luck.
01:55 There are other data types that we can use.
01:58 There is of course the long, which is 64 bits, and it has a range of well really,
02:04 really, really, really big.
02:06 You can see those numbers right there.
02:08 It goes from that -9 up to the 9, whatever that number even is.
02:11 I have no idea what the name of that number is, but it's really, really huge.
02:15 In addition to the long, there is the unsigned version of this, which is the ulong.
02:21 It's also 64 bits, and it can handle from 0 to well, even really, really bigger.
02:27 But of course there's also floating point numbers, not just integers. Usually we
02:31 use floating-point numbers for things like decimals and other kinds of
02:35 fractional numbers. And to do that there is a float number type and when you
02:39 declare a float number, you have to put a lowercase f on the end. And you can
02:43 see here I am declaring a floating point number of 123.45, and it has 7 digits
02:48 of precision from the range that I have shown there.
02:50 There is also a double, which is another type of floating-point number, but it
02:55 has 15 to 16 digits of precision. And you can see that when you declare it you
02:59 have to put a little d on the end to distinguish it from the float. Floats have
03:02 fs; doubles have d. So in this case I've got a double number which has much
03:08 higher precision than the floating-point.
03:10 And then finally there's the decimal number.
03:13 The decimal number is an interesting beast because it actually works in base 10
03:18 and not base 2, like the other kinds of floating-point number types that C# works with.
03:24 And to declare a decimal number, you simply say decimal and then the name of the
03:27 variable. And here I've got 123.45, and you put the little lowercase m on the end
03:33 which indicates that it is a decimal number.
03:35 Decimal numbers have 28 to 29 digits of precision, making them very, very
03:40 highly accurate numbers.
03:42 In addition to these data types, there are some special floating-point values that
03:47 you should be aware of.
03:48 The first of these is NaN, which means Not a Number. If a floating-point
03:53 variable gets into a state where you either try to divide by 0, or some other
03:56 kind of error happens, then the variable is set to NaN which means not a number.
04:02 There is also a PositiveInfinity and a NegativeInfinity setting.
04:06 For example, if you have a variable f defined to be of type float, you can do
04:11 things like say, hey, if f is less than float.PositiveInfinity. You can also
04:16 check to see if float is equal to not a number.
04:19 You can do things like float is PositiveInfinity, or is NegativeInfinity, and
04:24 these are useful for things like sorting algorithms.
04:26 You can also check to see if the float is not a number. Again because these
04:30 floating-point data types, along with all the other primitive data types, derive
04:33 from System.Object they have all these great methods and properties built into the language.
04:39 Okay, let's talk a little about why you'd use floating points, such as floats or
04:44 doubles, versus something like decimal, because one of the things you will find
04:47 is that with floating point numbers-- and I am not going to go too deep into
04:51 this because it's a bit of a advanced subject--but because of the way computers
04:54 work, computers calculate values using base 2 notation rather than base 10 like we humans do,
05:01 and that can lead to a loss of precision for certain kinds of transactions.
05:06 So let's take a look at a piece of code that explains how that happens.
05:10 So I have got my DoubleVsDecimal project open here, and here's the program file,
05:16 and I've got my snippets open as well.
05:18 So what I am going to do is copy these lines of code over to my main function.
05:25 So what we are going to do in this example is compare how double precision works
05:30 with decimal precision. And like I said earlier, internally, computers represent
05:35 numbers having to do with base 2 notation.
05:39 This is the famed 0s and 1s you've probably heard about if you've ever worked
05:43 with software before.
05:44 But what it essentially means is that because of the way numbers are calculated
05:47 on a microprocessor, you can sometimes lose precision when working with certain
05:51 data types. And I am going to show you a difference of how decimals are handled
05:56 versus how doubles are handled.
05:58 So right here at the top of my function I have got two variables, twentieth and
06:02 one. And you can see that I defined twentieth and one to be types double and
06:07 so I have got 0.2f and 1.0f. And what I am going to do is write out what one - twentieth is.
06:16 So 1.0 - 0.2, you would expect that to be equal to 0.8, right?
06:21 So let's see how the double data type and decimal data type compare when doing the
06:26 same kind of option, because down here, I have got two variables, decimals, which
06:30 are one twentieth and the real one.
06:33 So now I have got the same kind of calculation.
06:35 I have got 1.0, subtracting tracking off 0.2 each time.
06:38 The only thing that's different is in one case they are doubles; in one
06:41 case they are decimals.
06:43 So let's save this, and let's run it. And you can see that in the first case the
06:48 1.0 - 0.2 when using a double results in 0.799999...whatever, a whole bunch of,
06:56 like, you know high-precision numbers here. But obviously there is a loss of
07:01 precision when using a double number, whereas in the case of the decimal the 1.0
07:07 - 0.2 did fact result in 0.8, as you would expect.
07:13 And again, that's because the decimal data type works with base 10 numbers
07:17 naturally, whereas doubles work with base 2 numbers.
07:20 Now you might be saying to yourself, oh my God!
07:22 Is this some kind of a bug in .NET?
07:23 Is this a huge shortcoming of C#? It's not.
07:26 You will find this in lots of different computer languages that work with
07:29 floating-point numbers. Whether it's C or Objective-C or Java, it doesn't really matter.
07:33 This is just one of the ways that computers keep track of numbers internally.
07:37 So let's go back and take a look at the chart of when you want to use double
07:39 versus when you want to use decimal.
07:41 Let's take a look at why double and decimal are different from each other.
07:44 First, in the nature of precision, doubles are 15 to 16 figures of precision,
07:49 where decimals are 28 to 29 figures, so you've got double the amount of
07:52 precision in a decimal number as you do a double.
07:55 In internal format, in other words how the microprocessor on the computer
07:58 works with the number, in doubles it's base 2; in decimals it's base 10.
08:04 So, so far it's looking like you might never want to use a double, right?
08:07 After all you've got higher precision using base 10.
08:10 Speed, however, is a important factor to consider.
08:13 Because doubles are native to the CPU-- in other words they are native in the
08:17 fact that they use base 2 notation--the speed when using doubles is very, very, very fast.
08:22 Decimals, on the other hand, because they work in base 10 and have to be
08:26 conferred to and from the native processor format, can be up to 10 times slower
08:30 than using doubles.
08:32 So what are they good for?
08:33 Well, scientific calculations can usually be executed quite accurately and quite
08:37 fast using doubles, so they're good for scientific calculations, whereas decimal
08:42 numbers are good for financial calculations.
08:45 When you're dealing with hundreds of millions or billions of dollars, or even
08:48 small amounts but many, many, many times, these differences in precision and
08:52 accuracy on the CPU can add up to real money.
08:56 So because decimals work in base 10 and are very highly accurate when
08:59 working with floating-point numbers, they are ideal for being used in
09:03 financial calculations.
09:05 You can use doubles and other floating-point numbers for
09:07 scientific calculations.
Collapse this transcript
Working with characters and strings
00:00 C# also has built-in data types for working with characters and strings.
00:05 They're the char and string data types, not surprisingly.
00:08 The character data type, or char, in C# represents a single Unicode character, and
00:13 that's 16 bits or 2 bytes.
00:15 So the way we declare is char
00:18 and then the name that you want to give the variable, and you can initialize if you want to.
00:23 And it's important in C# to recognize that, unlike languages like JavaScript,
00:26 when you declare characters you have to use a single quotes, and for strings
00:31 you use double quotes. And in JavaScript you can use either single or double
00:35 quotes for the characters or full strings,
00:36 it doesn't matter; in C# it does matter.
00:39 So, for the character data type use single quotes; for strings use double quotes.
00:42 If you're not familiar with Unicode, don't worry too much about it.
00:45 It's basically an international standard for representing a wide variety of
00:49 characters from a wide variety of languages, and it supersedes the old ASCII
00:53 data set that were used in computers up until just recently.
00:57 So here we have an example of a character being declared, and this is a
00:59 lowercase letter a. And as I mentioned it's 16 bits, or 2 bytes, but you are not
01:04 limited to lowercase letters.
01:05 You can use things like numbers.
01:07 You can even use punctuation. All of these are legitimate characters.
01:11 For strings, you use the string data type, and a string is a series of
01:17 Unicode characters.
01:18 And unlike other languages, like, say, C or languages based on it, like
01:22 Objective-C, C# provides a native built-in data type for working with strings
01:28 and it's just called the string.
01:29 So to declare a string, you use the string data type, again the name of the
01:33 variable that you want, and you can initialize it, and you can see I'm using
01:36 double quotes to initialize my string, which is part of the C# syntax rules.
01:42 strings can also have escape characters in them. In this case, for example, \n
01:47 represents a new line character, and these are handled automatically for you by C#.
01:52 If you make a string that has an escape sequence, which is basically a backslash
01:56 followed by a special character code, such as a T for tab or an R for a
02:01 carriage return or N for a new line, C# will simply convert that for you.
02:05 Now this provides some rather interesting side effects for working with things
02:09 like directory paths.
02:10 So for example, if I wanted to make a string that contained a directory path,
02:15 I'd have to escape out the backslashes by putting a backslash in front of them.
02:20 And this can get a little cumbersome and tiresome to read,
02:23 so C# provides a special way for telling the compiler, hey, don't worry
02:28 about escape characters.
02:29 I just want every character that's in the string to be what it really is.
02:32 And the way you do that is you put an @ symbol in the front of the string.
02:36 So in the case of declaring the myDirectory variable, in the first case I had
02:40 to escape out the backslashes; in the second case, by putting that little @
02:43 symbol in front of the string, I'm telling the compiler, hey, those backslashes
02:46 aren't escape characters;
02:47 they are just real backslashes-- please treat them as such.
02:50 But the fun doesn't stop there.
02:52 Remember that characters and strings are objects.
02:55 The character data type is really a system.char object, and the string data type
03:00 is really a system.string object, which basically means that each one of these
03:05 data types has some really cool features and methods built in.
03:09 So for example, if I define a character variable as the lowercase letter a
03:13 right here, I can do some really cool things on it.
03:15 I can ask the character, hey, is it an uppercase letter, or it is it a digit, or
03:20 is it a letter? Is it punctuation or a white space?
03:24 I can do things like convert the character to uppercase or to lowercase.
03:29 The same is true of things like strings.
03:31 If I declare a variable that holds a string, I can do some really
03:35 interesting things on it, because remember, it's an object, and the objects
03:38 have built-in methods.
03:39 So for example, I can do things like convert the string to upper- or lowercase.
03:44 I can search the string to see where a substring appears in the string.
03:49 I can do that searching forward or searching backwards.
03:52 I can take strings and trim white space off of them.
03:55 We already saw how to do things like string.formatting using
03:57 the Console.WriteLine.
03:59 You can see if a string is null or is empty. And all of these features come built in
04:06 to the language, simply because these data types, even though they're primitives,
04:10 derive from System.Object.
04:12 One of the things to keep in mind is that strings are what's called immutable.
04:17 They can't be changed once they are created.
04:20 Now you might be saying, well, wait a second Joe.
04:21 I've seen you change strings throughout this course so far. What you're talking about?
04:25 Well, the thing is that operations that appear to change a string actually
04:29 create a new string, and the thing is, this can cause a pretty significant
04:34 performance penalty if you're not careful.
04:37 So let's take an example. Suppose we had a string variable called Result and we
04:42 initialize it to be an empty string, and then we have a loop that executes, say, a
04:46 thousand times, and then inside that loop we're saying, result += "some other
04:49 strings", you know some kind of thing that we calculated.
04:54 Well, even though that += appears to be modifying the string, what's really
05:00 happening is, each time this loop executes, a new string is being created that
05:06 holds the temporary results of concatenating the string on the end, and then
05:10 that new string is assigned to the result variable, and then the old string that
05:16 used to be there is just simply discarded.
05:18 Now, if you do this a lot in your programs, you're going to hit a pretty
05:22 significant performance penalty.
05:23 So if you're doing a whole a lot of string manipulation, sometimes it's better
05:27 to use some of the built-in classes to do this.
05:29 C# provides one of these called the stringBuilder. So what you do is you would
05:33 instead of just declaring a variable named result,
05:36 you'd build a stringBuilder object.
05:39 In this case, I'm using the stringBuilder class to declare a variable called sb.
05:43 And then instead of doing a concatenation in the loop, like you see there, I'll
05:46 simply use the stringBuilder's Append method. And we will cover objects such
05:50 as this later on, but the point here is that I'm not just using a straight string to do this.
05:55 At the end, if I wanted to get the whole result of the stringBuilder as one long
05:59 string, I'd simply call the Tostring method on it and assign it to a string
06:03 variable that called result.
06:05 Let's take a look at some examples of using some of the features that we've seen
06:08 here for characters and strings in real code.
06:10 So I'm over here in my code, and I've got my charsAndstrings project open, and
06:16 I've also got my ExamplesSnippets open. Over here in the ExampleSnippets, you
06:21 can see that I've scrolled down to the chars and strings sections.
06:25 So let's go ahead and copy some of this, so I'm going to copy these lines
06:27 right here. Paste those in. So I'm going to save, and don't worry about the little warning.
06:36 I am not using the string.
06:37 We'll get to that in a second.
06:39 So you can see here that I've declared a variable called mychar, which is a char
06:43 type, and it's a lowercase letter a. And essentially what I'm doing is
06:47 exercising some of the methods that the character class provides for me.
06:50 So I'm going to do a whole bunch of WriteLines and write out the results of a
06:55 whole bunch of these methods, things like IsUpper, IsDigit, and so on.
06:58 So it starts off as the lowercase letter a. So let's go ahead and run the code
07:03 and see what happens.
07:05 So you can see that the results for these tests are, well, is lowercase letter
07:10 a upper? No, that's false.
07:11 It's obviously not a digit. It is a letter.
07:14 It's not white space or punctuation. And you can see here the results of calling
07:18 ToUpper and ToLower on it.
07:20 Okay, so let's change it.
07:23 Let's change it to say the number 8, and we will save and we will rerun it.
07:27 Well, in this case you can see that ToUpper and ToLower have the same result,
07:32 because there is no such thing as an upper- and lowercase 8, but in this case the
07:35 IsDigit function returned as true.
07:37 And I'll leave this as an exercise for you to play with.
07:40 What I'm going to now, though, is go back to the Snippets.
07:41 I'm going to copy those string tests.
07:48 Let's just do some of the string tests.
07:54 So in this case you can see I've got my string variable.
07:57 It says, "This is a message with a new line," and you can see it's got some leading
08:00 and trailing spaces on the front and back. And we are going to do things like
08:04 call Trim and ToUpper and ToLower and IndexOf and LastIndexOf.
08:09 So let's go ahead and save this and run it. And you can see here that this is a
08:17 string with a message and new line and spaces in it.
08:19 You can see that the spaces have been cut off. Here the result of ToUpper is
08:24 that all the letters have been converted to uppercase.
08:27 Here they've all been converted to lowercase, and then we found the indexes of
08:31 the letter a and the substring end.
08:32 So you can see that even though we've got primitive data types for characters
08:36 and strings, they're really pretty powerful, just again, because they derive
08:40 from the base System.Object class in C#. And because they are objects, they have
08:45 a whole bunch of really useful features that just come built in.
Collapse this transcript
Understanding variable scope
00:00 One of the other common "gotchas" that you have to watch out for when you're using
00:04 languages like C# or Objective-C or Java or anything else that's a compiled
00:08 language is the notion of variable scope.
00:11 All variables have what's called a scope.
00:13 This is where the variable is visible to the code and can be used.
00:18 So let's take a look at an example, and then I'll explain it.
00:21 So suppose I had a function named myFunction and inside that function I had a
00:25 variable called X, and I've declared the variable X and I've assigned it a value of 10.
00:29 And suppose I also have a for loop and inside the for loop I've got a variable
00:34 named Y which I'm declaring inside the for loop and the value of Y is being set
00:38 to the value of X+20.
00:41 That's okay because I can refer to the value of X inside the for loop.
00:44 I can declare the Y variable inside the for loop as well.
00:48 Now I can also refer to the X variable here if I wanted to use the increment
00:53 operator on X outside the for loop; that's fine. And I can also increment X
00:59 outside the for loop after the for loop; that's fine too.
01:02 What I can't do, however, is refer to the Y variable outside of the for loop. Why?
01:08 Because it's not available there.
01:09 I've declared it inside the for loop. And in this case when you declare
01:14 the variable inside those curly braces, that variable is only valid inside
01:20 those curly braces.
01:21 That's because in languages like C# variables have what's called a block scope.
01:28 Those curly braces define a block of code the same way that the curly braces
01:33 near the function define a block of code.
01:35 This is not the case in a language like JavaScript, and the reason is because in
01:40 languages like JavaScript variables have function-level scope.
01:45 When the JavaScript interpreter goes to interpret the function, it first looks
01:49 through the function to find variable declarations, and then it lifts them to
01:54 the top of the function.
01:56 It does that internally;
01:57 it doesn't modify your script code.
01:58 But it gives all the variables inside the function the same function-level scope.
02:03 That is not true in a language like C#.
02:07 In a language like C# or language like C or Objective-C or Java, the variable
02:12 is only available to you in the block where it is declared.
02:16 So let's take a look at this in action, and we can see how it works.
02:21 Over here in the code I've got my VariableScope project open, and here in the
02:24 Snippets I've scrolled down to the Variable Scope. And I'm going to copy these lines.
02:29 I'm going to paste it in right here.
02:32 So here I have my loop, and you can see inside the loop I'm declaring a
02:38 variable named int var1.
02:41 So when I run this program--let's just write it really click--you can see that what's
02:44 going to happen is I'm going to WriteLine, the value of var1 at pass whatever I
02:49 is is whatever the value of var1 is.
02:51 So I'm going to run it, and you can see that it's staying the value of 20 all the
02:55 way through the loop.
02:56 So now let's take a look at what happens when I try to uncomment this line of code here.
03:00 I'm going to try to WriteLine the last value of var1, but I'm going to do it
03:05 outside the for loop.
03:07 I am going to save, and you can see that I'm getting a little red
03:11 squiggle there which basically says, hey, the name var1 does not exist in
03:15 the current context.
03:16 That's because it's declared inside this for loop.
03:19 So if I wanted to do this, I would have to cut that and move it up here and save,
03:25 and now everything works fine.
03:27 So let's go ahead and undo that. Put it back where it was.
03:30 You might be wondering, hey, you know, in other languages I can re-declare
03:35 variables in different scopes and they're just given different meanings.
03:38 So for example, the C and Objective-C languages let you do something like this.
03:47 And what I've done here is I've declared the variable var1 in a separate scope
03:51 than the other var1 that's inside the for scope.
03:55 Inside the for loop you'd think that this variable would have its own scope and
03:59 this will have a different one, but that's not the way C# works.
04:03 This can be very confusing to someone who's reading code, and it's also the
04:07 source of a lot of bugs in other languages.
04:10 So the designers of C# explicitly don't allow variables to be declared in
04:15 separate scopes with the same name.
04:17 You can see that when I try to do this there is a little squiggle down here
04:20 that says, hey, a local variable named var1 cannot be declared in this scope,
04:24 because it would give a different meaning to var1, which is already used in a
04:28 parent or current scope to denote something else.
04:31 So these two variables conflict with each other,
04:33 so I can't do this.
04:36 It's important to note that this kind of scope-level referencing only works
04:41 from the inside out.
04:43 So if I declare the variable var1 in here, I can refer to it within the scope;
04:48 but if I declared it out here then I would be able to refer to it in this
04:54 current function-level scope, as well as all the other scopes that are contained
04:58 within the function.
04:59 So for example, I could do something like this, and that works just fine
05:06 because the for loop scope is contained within the scope for the Main function.
05:12 So in fact if I save this and I run it, you'll see that var1 is getting
05:17 incremented by 10 each time and now that last little console, that WriteLine that
05:21 I've got that says, what the last value of var1 was, is working just fine.
05:26 Understanding variable scope is a pretty important part of writing good C#
05:31 code, and it's something that you should pay close attention to, especially if
05:34 you're coming from a language like JavaScript that does not enforce these kinds of rules.
05:38 This kind of thing can bite you, so pay attention to it.
Collapse this transcript
Understanding type conversion
00:00 There is one more important concept that we have to understand in working with
00:04 C#, and that is understanding type conversion.
00:07 If you've come from a language like C or C++ or Java, you've seen this before.
00:12 Converting one type of variable to another is called casting, and this is the
00:17 kind of thing that pops up in languages that require you to give types to your variables.
00:22 You're probably wondering, or at least you soon would be, well, how do I share
00:26 data between variables that are different types?
00:29 The way that you do this is by casting one type of variable to another.
00:34 It's how you convert data types among different kinds of data-type variables.
00:39 So for example, suppose I had an integer named i and it is set to the value of
00:44 10, and I also had a float and that was set to the value of 20.0.
00:50 Suppose I wanted to set f to the value of i. I can just do f=i, and that's okay,
00:57 because that's an implicit cast, or a conversion from an int to a float.
01:03 Since an int is 4 bytes and a float is larger, there is no risk of data loss here.
01:08 The integer can simply be converted into a float and all is well.
01:12 The reverse is not true.
01:14 If I said i is equal to f, that causes an error, because you need to explicitly
01:20 cast from the float to the int, because data might be lost.
01:25 You can't fit all the precision of a float into an integer automatically.
01:30 However, if I did this, if I said i is equal to, and then in parentheses I put
01:35 the word int in front of the variable that I'm casting from, that's now okay.
01:41 I've explicitly cast, or converted, from the floating-point value to the integer value.
01:48 You'll see this all over languages like C and C++ and Objective-C and Java, and now in C#.
01:55 So let's go over to the code and actually see it in action. So here I am!
01:57 I've got my Conversion project open, and I'm going to open up my Snippets file.
02:03 That's right there.
02:04 So let's go ahead and scroll down to the Conversion section, and that's right
02:10 here, Type Conversion.
02:12 So I'm going to copy those lines, and I'm going to paste them in here. A couple of things.
02:20 You can see that I've got an integer, a short, and a float.
02:24 So in this case, the integer starts out as 10 and the short starts out as 5.
02:31 Now, you'll notice that I can simply assign the value of x to the value of i. Why?
02:36 Because x is a short. It's 16 bits, whereas the int is 32 bits, so there is
02:41 no loss of data here.
02:42 That's okay; the complier doesn't complain.
02:44 However, if I try to go the other way, if I try to set the value of i into x,
02:51 well, there is data loss here, or there's potential data loss here.
02:54 What's going to happen is I've got 32 bits trying to go into a 16-bit bucket, and
02:58 you can see that little squiggle is saying, hey!
03:00 Error, cannot implicitly convert type 'int' to 'short', are you missing a cast? Well, yes, I am.
03:05 All I'm going to do is say--if I put the word short in front of the i variable
03:13 inside parentheses, that says to the compiler, hey,
03:16 compiler, take the value of i and explicitly convert it into a short.
03:21 Now, you notice that that little red squiggle has gone away, and everything is just fine.
03:26 So let's go ahead and put a Console.WriteLine in here.
03:36 We'll write value x, and we'll write out x. So let's put a Console.ReadLine at
03:49 the bottom, and let's also comment out that error for the moment.
03:56 So let's save it and run it.
03:58 You can see that the value of x is 5. Why?
04:01 Because here we put x into i, and then we just put i back into x, and since x
04:07 started out as 5, that's what's happened, so now x is back to being 5.
04:11 So let's suppose we comment this line out and we make i something that a
04:18 short can't handle,
04:20 so something like 800,000.
04:23 So now when we run this, you'll see that the value of x is 13,568. Why?
04:30 Because some of the bits of the integer got stripped off.
04:34 Remember, the integer is 32 bits, but the short is 16 bits.
04:38 So 16 bits of information got stripped off, and what was left over was what could
04:43 fit in those 16 bits, and that worked out to be 13,568.
04:48 So that's the kind of thing you need to watch out for when you're working with
04:51 type conversion because some types of containers are larger than others.
04:55 Let's go back to the code here.
04:57 Let's go ahead and get rid of these two lines. And let's look at the floating-
05:02 point versions instead.
05:04 So here you can see I have the floating-point number f, which is equal to 20,
05:11 and here I've got the i, which is now 800,000.
05:14 Again, I can assign the value of i into the value of f. Why?
05:18 Because floats are larger than integers; that works just fine.
05:21 Same story down here.
05:22 I'd have to actually cast the float to be an integer, and in order for that
05:29 to work, I simply put the word int inside parentheses, and now that converts
05:34 the value of the float into an integer, which can be stored inside the integer variable.
05:39 You'll see this kind of thing all over C# code, and you'll see it in
05:43 other languages as well.
05:44 It's important to understand how conversion and casting works because you'll be
05:47 using it in your own code.
Collapse this transcript
5. Custom Classes and Objects
Object orientation refresher
00:00 Up until now, I have been talking how C# is an object-oriented language, and
00:05 you've been seeing me use objects throughout some of the previous examples.
00:08 And we've reached the point now in the course where we actually need to learn how to
00:11 define and use our own objects in C#.
00:13 If you are going to be a C# programmer, there's no getting around the
00:16 object-orientedness of the language, and now is as good a time as any to take
00:20 a look at how to get started with the object orientation in C#.
00:24 So as I have mentioned many times C# is of course an inherently object-oriented
00:28 language. There's no getting around this, and in fact, everything that we have
00:31 been doing up until now has involved objects in one way or another.
00:35 The variables that we've been defining, those are objects--those integers and
00:38 strings and everything else.
00:40 We have been using the console object to write output to the console window, and
00:45 even the program itself that we've been using is itself an object.
00:49 So objects are everywhere in C#, and your programs will not be any different.
00:54 Programs are basically collections of objects.
00:56 So objects contain data, and they contain the logic that operates on that data.
01:01 It's a way of keeping related data and logic in the same place.
01:05 And of course objects can communicate with each other, because if they didn't
01:08 communicate with each other, not a whole lot of useful work would get done. And of
01:11 course not only do the objects communicate with each other, they communicate with
01:15 the program that hosts them, because the program itself is an object, and this is
01:19 how your programs communicate with the .NET framework as well.
01:22 In C# there are three main terms
01:24 you are going to have to keep track of:
01:25 there is class, there's interface, and there is object.
01:29 Interface is a little bit advanced, so we are not going to focus on that right now.
01:33 We are just going to focus on the class and object terms for the remainder of
01:37 this section, and we'll see a little bit about interfaces later on.
01:41 Classes in C# are one of the most common type that you will come across, and a
01:45 class essentially provides a blueprint, or a description, of what an object looks
01:51 like and what it does.
01:52 The blueprint, or description if you will, defines things like what kinds of data
01:57 that an object of a certain type holds, and it also defines what kinds of things
02:01 that an object can do.
02:03 It's important to keep in mind, however, that a class is just a definition.
02:06 It's a description.
02:07 It's not the actual object itself. For example, when you have a blueprint of a
02:11 house, the blueprint you can think of as being a class, but it's not the actual house.
02:16 When you build the actual house, that's the object; the blueprint just provides a
02:20 description of how to do that.
02:22 In your C# programs, you'll usually defined your own classes to do whatever
02:27 custom work you need to get done, as well as using the classes that are provided
02:32 by the .NET framework.
02:33 The .NET framework is pretty full featured.
02:35 It provides hundreds of classes for doing all different kinds of things, and
02:39 you'll take advantage of these classes as you build your own applications. For example,
02:43 suppose we were building an application that managed the list of to-do items.
02:48 You can imagine that we would have a class to handle the to-do items;
02:51 we would probably have another class to group all of those to-do items in a to-do list.
02:56 And these are classes that your program would define. But there's a whole bunch
03:00 of other classes that the .NET framework would provide for you, things like
03:03 dates and times and array lists and classes for working with strings and
03:07 communicating with the Internet.
03:09 These are all provided by the .NET framework, and as you build your applications
03:13 and learn more about C# and .NET, you'll use more and more of the .NET classes to
03:18 round out your applications' functionality.
03:20 So what do classes define?
03:22 Classes essentially define two major things, and these are called the members.
03:27 The first set of things is fields and properties and the second set of things are
03:32 methods or functions.
03:34 Nowfunctions and methods are pretty much the same thing, but the word method
03:38 is what's commonly used in object-oriented terminology, so that's what I am going to use here.
03:42 The fields and properties are the kinds of data that the object holds and works with.
03:47 The methods are what the object can do;
03:50 this is their logic, the functionality that contains in the object.
03:54 Again, if you go back to our to-do list item example, you can imagine that a
03:57 to-do item might have a name, a description and a priority, then something
04:02 like a due date, and then we would need to have methods to operate on that
04:05 data--for example, setting the description and changing the priority, and marking items complete.
04:10 These are what classes defined and as you build your own classes, you will define
04:14 your own fields and properties, and you will write your own methods to work on
04:17 those pieces of data.
04:19 Classes can also inherit attributes and methods from other classes, and this is
04:26 a very important concept in object-oriented programming, so it's important that you understand this.
04:31 For example, let's imagine that I have a class that I want to define called class A, and class
04:36 A contains a couple of fields like name and age and it has a function in it--in
04:41 this case it called sayHello().
04:42 Now you've probably already seen examples like this, and in C# you would refer to
04:47 these fields and functions by using the dot notation. So you would say A.name,
04:51 A.age for the fields, and A.sayHello() to call the method.
04:56 I can also define a class that inherits from class A, and in object-oriented
05:01 terminology this is called creating a subclass.
05:04 So if I want to create a class B that inherits from class A, I would define
05:09 class B, put a colon after its name, and then put the name of the class that the
05:15 class inherits from.
05:16 So here you can see the class B with the colon and the A means this class B and
05:21 it inherits from class A. And in class B, I've defined a couple of things. I've
05:25 got another property called address and a function called sayGoodbye.
05:29 So again you would refer to this using standard.notation for the class B, like
05:34 B.address and B. sayGoodbye. But because the class B inherits from class A, it
05:39 also has all of the fields and properties that class A has.
05:42 So class B also has a sayHello function and the name property, even though I
05:46 haven't defined it in class B; it just gets all those things because it
05:50 inherits from class A.
05:52 So in object-oriented terminology, we say that class B is a subclass of class A,
05:58 and class A is class B's superclass.
06:02 You'll see these terms used throughout object-oriented documentation whenever
06:06 you read documentation on web. Especially in MSDN, you'll see terms like that.
06:11 You can think of C# objects as being a kind of stamping machine.
06:17 So classes, as I mentioned earlier, are used to create individual objects, and each
06:22 object that is created from a class is called an instance.
06:25 So you can think of this as some kind of machine that stamps out physical parts.
06:28 Suppose I had a class definition called person and the Person class had the name and age
06:33 and SayHello function.
06:35 Each time I made an object, that's called creating an instance of class person.
06:41 So here I've got three instances of the Person class.
06:44 I have got person A, B, and C, and each one of these real objects has actual data
06:49 that's filling out the class.
06:51 So we're using the class definition, or the blueprint, to actually make
06:55 instances of that class.
06:57 So why would you use classes and objects?
06:59 Well, using classes and objects, especially in C#, which is objected-oriented
07:03 language, really makes it easier to maintain and build applications.
07:07 First, it helps abstract ideas away from a specific implementation, which allows
07:12 you to focus on the core parts of the program.
07:15 Since the .NET framework provides a whole bunch of classes that cover common
07:19 areas of functionality that you don't have to write yourself, you can focus
07:22 on building the specific parts of your program that are only pertinent to
07:26 your business logic.
07:27 You can then reuse all the classes that .NET provides for you, which really makes
07:31 developing applications a lot faster and a lot easier.
07:34 Using classes and objects also helps encapsulate the programs functionality
07:38 into understandable pieces, because each object has its related data and logic
07:43 all kept in one place.
07:45 To go back to want to-do list item example, each to-do item would have not only
07:49 the information about that particular to-do item, but the logic that operates on it.
07:53 So you wouldn't have different pieces of logic scattered all over the place in
07:56 different locations without knowing where each one is.
07:59 It just makes it easy to understand the way that an application works.
08:03 It also helps organize a program into natural parts that could be easily
08:06 extended, and this is sometimes referred to in the object-oriented world as factoring.
08:11 Once you have factored your application into its natural parts, the object
08:15 itself and the program comes to mirror real-world constructs and ideas.
08:19 Again, taking a page from out to-do list example from earlier, when you make
08:23 objects that mirror real-world constructs like a to-do item and the to-do list and so on,
08:29 that makes the program a lot easier to understand and go back in and
08:31 maintain years later.
08:33 So using classes and objects is a really fast and easy way to build applications
08:38 that you can maintain in the future and other people can work on as well and get
08:41 up to speed on quickly.
08:43 So we reach the point now where we've completed our refresher into the world of
08:47 object-oriented programming, and we are going to spend the rest of this section
08:50 seeing how to define classes in C# and build our own object-oriented programs
08:56 in .NET and C#.
Collapse this transcript
Defining a class
00:00 Probably the best place to start when we define our own classes in C# is to see
00:04 how we define a class before we can start using them.
00:07 So we are going to take a look here at how to define a class using C#, and
00:11 then we are going to take a look at how to use it as we move through the rest of the section.
00:16 So to define a class in C# you use, surprise, the class keyword.
00:21 So you say the word class, and then you have to give it a name. In this case, I
00:25 am going to use myClass. And you can use whatever combination of letters and
00:30 numbers you want, as long as it starts with a letter and is a valid C# class
00:33 name--you can have special characters or anything like that.
00:36 So I've got class myClass, and then I am going to define some curly braces, which
00:41 are going to define the code for this class.
00:44 Once we have got the class definition laid out here, we can start adding some
00:49 fields and some methods.
00:51 You can add fields and methods in whatever order you like.
00:54 You can define field and then method and then field and then method if you want to.
00:58 My practice that I use is and I define all the fields upfront near the top, and
01:03 then I put all the methods at the bottom.
01:06 So let's define some fields.
01:07 I have got two fields here:
01:08 one is called myInteger; one is called myMessage.
01:11 We have got an integer and a string.
01:13 We could use whatever data types we'd like.
01:15 In this case, I have just got a couple for examples.
01:18 Then I am going to define a method.
01:20 And here I have defined a function called myFunction, or method--whatever word
01:25 you want to use--and it returns an integer.
01:28 In this case, it returns the myInteger field. So when the code that uses this
01:33 class calls myFunction, it will simply return the value of myInteger.
01:37 For the moment, don't pay too much attention to that word "public" that's in
01:41 front of the word "int."
01:42 We are going to get into what that means a little bit later in this section.
01:46 For now, just assume that the word public means we have to put it there so that
01:50 the rest of the world can see this function.
01:53 This is pretty much a complete class definition;
01:55 we could just stop here if we wanted to. But it's customary in C# to define
02:00 what's called a constructor.
02:01 A constructor function has the same name as the class.
02:06 So to define the constructor-- you can see I have done that here--
02:09 I've got a method call myClass, and in this case is this method is taking a
02:13 string argument which uses the value of the argument to set the initial value of
02:17 the myMessage member field. And again,
02:21 I have got the work public in front of it, and I don't want to pay too much
02:23 attention on that right now--we will get into that.
02:25 But what I have done here is defined what's called a constructor, and the
02:29 constructor takes the same name as the class itself. And you can give it however
02:34 many arguments you want, or you can give it no arguments at all.
02:37 Now, if you don't define a constructor, the C# .NET framework will automatically
02:42 put one in for you. But it is customary to define one, because you use
02:46 constructors all the time to initialize the value of class fields.
02:50 So now that we've done that, we can go ahead and take a look at how we might
02:54 create and use an object using a class that we've defined.
02:58 So in C#, the way that you create, or to use object-oriented terms instantiate, an
03:05 object is to use the keyword "new." And it's an operator,
03:08 so the way that you do this is use you use the type of myClass, and that's the
03:12 class that we defined earlier.
03:14 Then you give it a variable name, myObj.
03:16 So here instead of saying int and then some myInteger, which is a built-in C#
03:21 .NET type, we are using the type that we've defined called myClass. And we have
03:25 got a variable called myObj, and then we simply say = new myClass.
03:30 And in this case we're passing in a string to the constructor function--
03:34 this is how the constructor gets called-- so that string will become the initial
03:38 value of that myMessage field.
03:41 To use the fields and methods of a class that you have instantiated, you use the dot operator.
03:46 And again, we've seen this throughout the course so far, but let's just make it official.
03:49 So let's imagine I have an integer called myResults and this is some variable I have created.
03:54 I can then refer to the methods or fields of the object by using the dot notation.
04:00 So in this case, I'm calling some imaginary function called AddNumbers on my object.
04:04 We haven't defined it yet, but we could. And you can see it takes two
04:07 arguments, and then it returns an integer result.
04:10 So use the dot operator to reference the fields and methods of the class.
04:14 Classes can also have special members called static members.
04:19 Static members don't require you to create, or instantiate, an object's instance
04:24 in order to use them.
04:26 That may sound kind of weird, but we've actually seen this throughout the course so far.
04:30 Every time we've used the console object, for example, you notice that we
04:34 haven't had to say "new console."
04:37 We simply use the name of the class, which is console, and then dot and then
04:41 the word WriteLine.
04:42 So we are calling what's called a static, in this case, a member method, called
04:47 WriteLine, and it belongs to the entire class.
04:50 You don't have to have it be part of a specific instance of that class.
04:55 So let's take a look at the difference between instance members and static members.
04:59 Instance members of a class--
05:01 whether it's a field or a method--get copied each time a new object is created.
05:07 Static members, however, belong to the entire class, and there is only one of them.
05:11 So let's take a look at an example.
05:13 Let's imagine we have a class that defines the notion of a bottle of wine.
05:17 For each bottle of wine, you are going to have something like a year and name
05:21 to go along with it, and you would have a constructor function that looks
05:25 something like this, where when you create a new instance of the wine bottle.
05:29 you will pass in the name and the year. But suppose we wanted to keep track of
05:33 how many bottles we had in our cellar.
05:35 Well, it seems a little silly for each instance of the wine class to keep track of
05:38 its own bottle count; we only need one variable to do that.
05:41 So we would have a static member called bottleCount. And in this case,
05:46 bottleCount belongs to the entire wine class, and each instance of the wine
05:50 bottle will be able to reference this member, but it doesn't belong to any one of them;
05:54 it belongs to the entire class.
05:56 So here in the constructor, we don't need to refer it to using the class name,
05:59 because we are in the constructor for the class. But if we're using code that
06:03 was outside the class--again, think back to the Console.WriteLine example--
06:08 we would simply put the name of the class in front of the function, and that
06:11 says to the C# compiler, hey, I'm calling the static member called this
06:15 function, or whatever it is--
06:17 in this case, its not a function at all; it's a member of variable--
06:20 and I am referring to the variable that belongs to the entire class.
06:24 So let's take a look at some code that makes all this work, and then it will
06:28 become a little bit clearer.
06:30 So over here in C# Express, I've got my DefiningAClass example open. I have
06:35 also got my ExampleSnippets.txt file open, and I've scroll down to the
06:39 DefiningAClass section.
06:40 So I am going to start off by copying some of this code over.
06:43 So we will copy over the class definitions, just a few of these lines right here.
06:48 And the nice thing about C# is you can put the code anywhere in the class file.
06:51 Now I could make a separate file to contain the wine class, but we will do that
06:55 a little bit later. For now in this example, I am going to have the two classes
06:58 be in the same file.
07:00 So now we have defined the class called myClass and we've got a couple of members here.
07:04 We have an integer and a string member, and you can see that we have declared
07:07 a static integer called myStaticInt. And again, don't worry about that public keyword for now;
07:12 we'll just get to that a little bit later.
07:14 Okay, let's go back over here, and let's copy over the functions, and we'll put those in the class.
07:27 So now we have a complete class definition.
07:30 We have our member variables;
07:32 we have a function called myFunction, which returns an integer--in this case,
07:36 it's the myInteger member; and we have the myClass Constructor.
07:40 When we call the myClass constructor, we're initializing the values of myInteger
07:44 and myMessage to some initial values.
07:47 And we also have the myStaticInt, which is being initialized to the value of 100.
07:52 So now let's copy some code over that actually exercises the class and see what happens.
07:58 I will just copy these lines right here, scroll down to the main function and put them in.
08:11 So let's take a look at the code and see what's happening.
08:16 The first thing that we are doing right here on line 30 is we are instantiating
08:20 a new instance of the myClass object, and once we've done that, we can then use
08:26 the various members of the class.
08:29 So on line 32, you can see that we are using the console to write out the
08:33 results of myFunction. And in this case, we are using the instance, which is the
08:38 myC variable, to call the myFunction member function. And in the next line, line
08:43 33, we are going to use the static member. But instead of using the myC
08:47 variable, we are going to use the myClass name, because it's a static member, and
08:52 we need to refer to it on the class name itself.
08:55 So we are going to go ahead and build and run this, and what we should see is the
08:59 result of calling myFunction. Let's just scroll back up here.
09:03 So myFunction is going to return myInteger, which you can see on line 21 is being
09:08 initialized to 50, and then we have the value of myStaticInt, which is 100.
09:12 So let's go ahead and run this, and you can see that the results of calling
09:16 myFunction is 50 and using the static member is 100.
09:20 Let's go back to the code.
09:22 Using this example, you can see how we have defined member variables which are
09:27 both local to the instance of an object and the static member which belongs to
09:31 the entire class, and we've seen how to define and instantiate a new class
09:36 using the new operator.
09:37 As we move through the rest of the course, we will be doing a lot more of this.
Collapse this transcript
Using access modifiers
00:00 The C# language provides a feature called access modifiers, which allow you to
00:05 control how the member variables and methods of your classes are seen by the
00:10 outside world--in others words code that uses your objects.
00:14 And if you're coming for the language, like Java or C++, you've probably
00:18 seen something similar.
00:19 JavaScript does not have this kind of idea in it, so if you're coming from
00:24 JavaScript, you might want to pay attention to this.
00:26 So by default when you define data and methods in your class, those data fields
00:32 and methods can only be used inside of that class itself.
00:36 You have to choose to expose them to other code that's going to consume your classes,
00:42 and this is what access modifiers let you do.
00:44 They let you specify how programs-- including your own--that use your classes can
00:49 access their data and their methods.
00:52 So let's take a look at how this works.
00:54 Suppose we had a class and I have a class here called myClassName, and we've
00:59 got some fields in it.
01:00 So we have got an integer, and we've got a string, and we have some method called myFunction.
01:05 By default, all of these are what's called private. Only the class that
01:10 defines these can use it.
01:13 We need to change that in order for code that wants to consume our class to be
01:17 able to access the members of this class.
01:21 The way that we do that is by using what's called access modifiers.
01:24 And if you watch the preceding the movie, you'll have probably noticed me
01:28 using the word "public."
01:29 Well, there are a couple of different ways to expose members of the class to
01:33 code that wants to use them.
01:34 So let's take a look. The first one is called the private modifier.
01:39 When you use the private access modifier, it means that the member of the class
01:44 who is marked as private can only be accessed within the class itself.
01:48 Now this is the default setting, so if you don't specify private, the C# compiler
01:54 defaults to making a member variable or a member method as private.
02:01 The next one is public. A public class member can be accessed by any other
02:07 object that uses the class, and this is why I was using the public keyword in
02:11 the previous examples so that our code can consume that particular member of the class.
02:17 The next one is called protected.
02:20 A protected class member can only be accessed within this class or any subclass--
02:26 in other words a class that inherits from this class.
02:30 So we have got private, we have got public, and we have got protected.
02:33 So there is one more, and it's called internal, and this is a class member that
02:37 could be accessed by any class in what's called a same assembly. An assembly
02:42 is a package of code, like a library or another program, but this is an advanced feature of
02:47 C#. I am not going to cover it here in this course. Just know that you might see
02:51 the word "internal" every now and then.
02:53 It's sort of like protected, but it means that only a group of related code
02:57 can use it. But for the purpose of this course we are going to use private,
03:00 public, and protected.
03:02 So in order to see how his work, let's jump over to the code and define a class
03:07 that uses these, and you can see what happens when you try to use code that uses
03:10 each one of these access modifiers.
03:12 So over here in the code I have got my ExampleSnippets open for the
03:16 access modifiers example, and over here I have got my program file.
03:21 So here is what we are going to do. First, we are going to define a new class, and
03:24 in this case we are going to put the class in a separate file.
03:27 So what I am going to do over here is I am going to right-click on the project
03:31 name called AccessModifiers, and I am going to go down to the Add submenu, and you
03:36 can see that I can add items to my project.
03:38 What I am going to do is I am going to add a class, and the Add class
03:42 dialog comes up. And you can see there is a whole bunch of things that we can
03:45 add, all kinds of classes.
03:46 What I am going to do is just make sure that the default one here in the list
03:49 called Class is selected, and then I am going to give my class a name. And in
03:53 this case I am going to call it my Wine class. I'm going to click Add,
03:59 and you can see that the file for Wine.cs got added, and you can see that the C#
04:07 Express application has done a whole bunch to work for us. First of all, it's
04:10 automatically put the Wine class into the same namespace as our example.
04:13 It's included the using statements for the .NET framework that we are going be
04:17 using. And right here you can see it has provide a definition for class Wine.
04:21 So let's go back to Snippets.
04:22 What we are going to do now is fill out that wine class with some default code.
04:29 So I am going to copy these lines here.
04:31 I will go back to my Wine class, and I am going to paste them in.
04:35 So now in our Wine class we have a couple of different members.
04:38 We have the wine name,
04:40 we have the wine price, and we have the wine description. And you can see that all
04:43 of those are public,
04:44 so any code that wants to use this Wine class will have access to those member variables.
04:50 We have a decimal variable here called discount, and that's marked as private.
04:56 So nobody outside this class can see what that is. And then we have a public
05:00 constructor, which takes a wine name and a price. And inside the constructor you
05:05 can see that we've got the name and price public variables that are being set to
05:10 the arguments that are being passed to the constructor, and then we give the
05:13 discount variable and initial value as well.
05:16 And we can do that here because this is our class and we can refer to our own
05:21 private members within our own class.
05:23 So let me save this, and let's go back to the snippets.
05:28 Now let's go ahead and copy over some code.
05:30 I want to copy these two lines first, and we are going to go to the main function,
05:33 and I am going to paste tem in.
05:35 So here you can see that I have got two instances of the Wine class being
05:40 created, and I am passing in some default values for names and prices.
05:44 So let's write some code now that exercises some of the fields of the class.
05:48 So for example, if I wanted to refer it to the name of one of the wines, I
05:52 could simply write string and give it a variable name, =, and I could say w1.
05:57 And now watch what happens when I press dot.
05:59 Now when I press the dot, C# Express is looking at the class description and
06:03 saying, okay, what can the code in this particular area see inside that class?
06:08 And we have got a couple of default things, because we always derive from the
06:11 base system object, but here's the name and the price fields that I've defined.
06:16 Here is the description field, because those were all public, and you can see that
06:19 this is an alphabetized list. What's missing? Well, the discount field is missing. Why?
06:24 Because it's private, and because it's private, my code can't see it.
06:28 So I can go ahead and refer it w1.Name all I want to, but if I try to refer to
06:33 the discount field--let me make a decimal and we'll call it dsc--
06:38 if I say w2.discount, now watch what happens. I am going to save this. See, that
06:45 little red squiggle showed up and if we mouse over that little squiggle, we say
06:49 error. It says the AccessModifiers. Wine.discount is inaccessible due to its
06:54 protection level. Go back over to the wine code.
06:57 You can see that this is private, so private members can't be referred to
07:01 outside of the class that defines them.
07:04 Now we could also have made it protected, and protected would also result in an
07:08 error, so let's just change that.
07:09 Let's just make this private and make this protected, and we will save, and we
07:14 will go back over to the program, save and compile. And you can see that we still
07:19 have that same error there, right, even though we made it protected, because in
07:22 this case we don't have a class that descends from wine, so it's not inheriting
07:28 the discount field, and because its protected, only subclasses can see it.
07:32 So this is how you use the various access modifiers of C# to selectively expose
07:39 member variables and member functions to code that's going to consume their
07:42 objects. And the reason you want to do this is because in good programming
07:46 practices, you don't want to just make everything public.
07:48 You want choose how you expose your code to consumers of your code. That way you
07:53 can change the way things are implemented inside your class without breaking
07:57 people that are consuming the class in other programs.
08:00 So using access modifiers, you can selectively expose parts of your program
08:05 to other consumers.
Collapse this transcript
Defining properties
00:00 Okay, I promised you we would get to some really cool features of C#, and we're
00:04 about to do that right here with defining properties.
00:05 Properties are a really neat feature of the C# language, and I really like using them.
00:11 In this section, we're going to explore what they are and how they work.
00:13 Properties are essentially like data fields, but they have logic behind them.
00:18 And from the outside, they look like any other member variable, but they act
00:23 like a member function.
00:25 They actually have code behind them.
00:26 Now you define them like you would a member variable, but they have a get and a
00:32 set section of code added.
00:34 And they can use access modifiers just like member fields and member methods can,
00:40 and we explored those earlier.
00:43 Let's take a look at an example of what a property looks like.
00:47 So let's imagine we had a class called myExample and we had some private member
00:50 variable called someValue.
00:52 Now because this is private, there is no way for someone who's consuming this
00:57 class to get at that data.
00:59 Now we could make it public, which exposes the implementation of the class to the
01:04 outside world, which is not a very good programming practice.
01:06 You really want to keep the inner workings of your class private and then choose
01:10 to selectively expose data.
01:12 We could also just make a member function, which would allow an external consumer
01:17 of this class to get the value and set the value.
01:19 Or we could make what's called a property.
01:22 A property is defined like this. I'm making a public integer property called
01:28 CurrentValue, and instead of making it look like a member of function with
01:33 parentheses and arguments and so on, all I have to do is define the name of
01:38 the property with two curly braces and inside I put the word get. And
01:43 the word get here is essentially going to return the value of that private
01:48 integer that I have.
01:49 And then to set this value, I have the word set.
01:53 And in the set code, I'm setting the internal someVal property to this word value.
02:00 And value is implicit.
02:01 C# just simply generates that for you.
02:03 Let's see how this actually works when you consume this.
02:06 So to do this, I would define myEX variable, which is an instance of the
02:11 myExample class. And I'm creating a new myExample object there.
02:15 If I wanted to get the value, I would just do this.
02:17 I have an integer i, and I say myEX.CurrentValue.
02:22 That will trigger the get logic.
02:24 And in this case, the get logic is pretty simple.
02:26 It's returning the value of that internal private variable.
02:29 And if I wanted to set it, I would do this:
02:31 myEX.CurrentValue = 5, and that will trigger the set logic.
02:35 And the value of that special value keyword there in the set logic would be set
02:40 to an integer whose value is 5.
02:43 The C# language and .NET just takes care of all that for you.
02:46 You don't have to declare some argument called value;
02:48 it just magically shows up.
02:51 So you can have automatic properties.
02:54 Let's suppose, for example, I had my class, which I declared up above in the
02:58 previous example. So I've got myExample class here with my private someVal int,
03:02 and I've got the get and the set.
03:04 Since all that this example is doing is getting and setting the value of that
03:09 private internal variable,
03:10 I can rewrite this very simply, just like this.
03:14 I have my class, and then I have my property, and all I do is have the words get
03:19 and set, and that's all I need to do.
03:21 This is called an automatic property.
03:25 You can also have read-only properties, and you can have write-only properties.
03:29 Read-only properties and write-only properties are properties that can only be
03:31 read and can only be written.
03:33 So let's take a look at an example.
03:35 Using the same example we've been using up until now, I have my example class
03:38 with my private variable. And inside my public int CurrentValue, I have get
03:44 and return someVal.
03:45 Now if I don't define a set, then the property is read-only because there is no way to set it.
03:50 All I can do is get the property.
03:52 Alternately, I can define just a set.
03:55 If I don't define a get, then the property is write-only.
03:59 You'll very rarely see write-only properties.
04:01 Properties are pretty useless
04:02 if you can't actually get their value.
04:04 But you can do this.
04:05 So if you don't define a get, or you don't define a set, then the property is
04:09 either read-only or write-only.
04:12 All of this is pretty fun, but why would you use properties? A couple of reasons.
04:16 First, properties can be calculated on the fly.
04:19 So if you wanted to expose a property that looks like a member variable but has
04:24 some logic behind it that actually gets calculated on the fly whenever it gets
04:27 accessed, read, or set, then you can use a property for that.
04:31 Properties also provide complete control over the data field access, because the
04:35 logic is hidden from the object's consumer.
04:38 The consumer of the object's property doesn't need to know how it's calculated,
04:41 or what's being calculated.
04:42 And if later on down the line you go back and you change the way this object
04:46 works and the way that that property is calculated changes, then the people who
04:51 are consuming your object don't need to worry about that.
04:52 They just simply go ahead and keep on referring to that property, but the logic can change.
04:58 Properties also promote the idea of encapsulation.
05:01 We've talked about this a couple times before in this course.
05:03 What you're doing is you're taking the logic that implements that property and
05:06 you're hiding it from the consumer.
05:08 So they don't need to worry about how it works.
05:11 Let's take a look at an example of how you'd have a property whose value is
05:14 calculated on the fly.
05:16 Let's imagine I had a class that represented a wine, and in that class, I have a price.
05:23 I could define the price as just a public member variable, like I've done here.
05:28 And I've got some private ones, like say that there is a wholesalePrice and
05:32 there is a retailMarkup.
05:33 So when a wine store buys wine, they don't pay the retail.
05:36 There is a wholesale price they pay, and then there is a markup that they apply
05:40 to the wholesale price which is what the real price is.
05:43 So rather than having a public member variable, I could expose a public property.
05:48 And you can see here I've only defined a get;
05:51 there is no set here.
05:53 And when the consumer of this Wine object wants to know what the price of the
05:56 wine is, you can see that the logic inside the getter is simply multiplying the
06:01 wholesalePrice times whatever the retailMarkup is.
06:04 So I can have some code that goes out and figures out what my retail markup is
06:08 based on some other parameters I've got in my business,
06:10 and the consumer of this Wine class has no idea how or why I'm doing that.
06:15 They just simply ask what the retail price is by accessing the property and it's
06:19 calculated for them on the fly.
06:21 Let's jump over to the code and define some properties in one of our classes
06:24 and see how this works.
06:26 I'm here in my DefiningProperties example, and I've got my ExampleSnippets open
06:32 right here. And I've scrolled down to the Properties section, and I've got a Wine class here.
06:38 So what I'm going to do is go back over to the program code, and I'm going to
06:42 make a separate class file for my Wine class. And this just promotes the idea of
06:46 encapsulation. And we've already done this once before, but if you skipped over
06:49 that part, or you need a refresher, just follow along.
06:51 So I'm going to right-click on the project name, and I'm going to click Add, and
06:56 then at the bottom of the Add menu, I'm going to add a class. And I'm going to
06:59 call this my Wine class.
07:00 First, I'm going to make sure that the Class option is selected there,
07:04 and then I'm going to come down here and type in Wine.cs, and I'm going to add that.
07:11 Visual C# Express has made a new Wine class for me.
07:14 Let's go back over to the Snippets, and let's just copy this class in its entirety over.
07:23 Copy this into the Wine class, and let's save that.
07:29 So now we have our Wine class defined.
07:31 Let's go back over to the program, and let's copy in some other code from the
07:35 Snippets, which is right here.
07:43 First, let's just copy these few lines, and we can explain what's going on.
07:51 Let's take a look at the Wine class to see what we've done, before we go any further.
07:56 Here is my custom-built object.
07:57 It's a class that encapsulates the notion of a wine bottle. And you can see I've
08:02 got several private members here.
08:05 And because they're private, code that is not inside this class can't see them. So I have a Name.
08:10 I have a Year.
08:11 I have an appellation, which in the wine world is where the wine comes from.
08:15 I have a wholesalePrice, and then I have a retailMarkup of 1.35, so I've got 35%
08:20 markup on whatever wine I buy.
08:23 Then I've got a property called Price, and you can see that the price is
08:27 being calculated on the fly by multiplying whatever the wholesalePrice is
08:30 times the retailMarkup. And in the setter case, I'm setting the
08:34 wholesalePrice to the value.
08:36 So I'm not actually setting an internal price variable;
08:39 I'm just setting the wholesalePrice which would have been calculated by the retailMarkup.
08:44 I also have a property which is a string called the menuDescription.
08:47 And if you've ever been in a restaurant, you've probably seen this. Wines are
08:50 usually described on wine lists as having the year, followed by the name, and
08:54 sometimes where they've come from.
08:56 So I've got a string property that's being built up on the fly right here from
09:00 the private internal properties that I have.
09:02 And then I have my public constructor, and the constructor is what creates a new
09:07 instance of the Wine object.
09:09 And it's just taking a bunch of arguments and setting them into the private
09:13 internal member variables.
09:14 So let's go back over to the program, and you can see here that I'm instantiating
09:19 a couple of instances of the Wine class.
09:21 I've got a year for each one, I've got a name, and then I've got a string that
09:25 explains what the origin is, and then I have a wholesale price which is going to
09:30 be used to calculate the retail price.
09:32 So let's go back over to the Snippets.
09:34 Let's do some exercising here.
09:35 We're going to write out some of these property values.
09:37 I'm going to just copy these lines of code right here.
09:39 I'm going to go back over and paste them in.
09:44 In the first case, I'm going to write out the menuDescription and the Price of the two wines.
09:52 So I've got Wine 1 and Wine 2.
09:53 And remember, back in the Wine class, each one of these properties is
09:57 being built on the fly.
09:58 So I'm going to save, I'm going to build, and I'm going to run this.
10:04 And you can see that I've got Wine 1 is a 2003 Chateau Ste.
10:07 Michelle Merlot, from Seven Hills, and it's $31.72. And then I've got a
10:12 Mark Ryan Dissident that's from Ciel du Cheval, and that's $54.
10:16 But remember, those aren't the numbers that I put into the constructor.
10:19 If you look at the constructor, I've got 23.50 and 40.
10:22 The reason why those numbers are coming back differently is because--let's go
10:25 back over to the Wine class--is because of this logic right here on line 20.
10:31 On line 20, I'm taking the retailMarkup and multiplying it by
10:34 the wholesalePrice.
10:35 But from the point of view of the code's consumer--let's go back to the program--
10:39 you can see all I'm doing is accessing this Price property.
10:41 I don't have any knowledge of how that's being generated behind the scenes.
10:45 Let's go ahead and change the wholesalePrice of one of the wines using the
10:48 setter, and then we'll write out the new price. Paste that in here.
10:57 What we're doing now is using the setter logic of the Price property.
11:01 Here I'm changing the wholesalePrice of Wine 2 to $45,
11:06 and then I'm going to write out the wine description, and notice how the retail
11:10 price has automatically changed because of that calculation logic.
11:14 So I'm going to just run this.
11:16 And you can see that in the first case
11:18 it's $54, but because of the price that I set here in the setter, the new retail
11:24 price is being calculated as $60.75.
11:26 Okay, let's go back to the code.
11:29 The reason why I use properties is because you want to encapsulate some logic
11:33 inside your class, give it the appearance of a member variable, but it has logic
11:38 behind it that determines how that property is calculated on the fly.
11:42 And you can use this technique to expose private internal data in your class in
11:46 a controlled fashion, and you can get really creative with this.
11:50 Suppose, for example, I wanted to log every time somebody changed the
11:54 wholesale price of a wine.
11:56 Well, here in the setter logic, I could just simply add some code that would
12:00 write out to a log file when the price was changed. Or let's suppose I wanted
12:04 to use my debugger to set a breakpoint on whenever a value of the property was changed.
12:10 You can't do that on a private internal variable, but you can do it on a property.
12:14 So properties are really versatile, and they make your code a lot easier to
12:17 encapsulate and expose and make consumers use the classes in a way you feel best
12:21 they should be used.
Collapse this transcript
Understanding value and reference types
00:00 Now that we've learned how to create our own classes in C#, we've come to an
00:04 important point in the course where we need to learn the difference between
00:07 value types and reference types.
00:09 C# has two main types:
00:11 there's value types and there's reference types.
00:14 Value types are all of the primitive types that we've learned about so far,
00:19 things like integers and longs and shorts and decimals and chars and
00:23 booleans and so on.
00:24 And there's also a thing called struct, which we haven't covered yet, but we
00:28 will cover later on in the course.
00:30 Anyway, those are the value types.
00:32 Reference types are classes, arrays, and a couple of things called delegates and
00:37 interfaces which, again, we haven't yet covered, but we will cover later.
00:41 So why is there this difference, and what's so important about it?
00:45 The main difference between value types and reference types is how they
00:49 are handled in memory.
00:51 And the best way to learn this is to see an example.
00:54 So we're going to compare the value types with the reference types.
00:57 Now, for a value type, let's take a really simple example.
01:00 Let's suppose I have a variable i and I declare it as an integer and I set its value to 5.
01:06 Now, when I do that, the C# compiler goes out in memory and makes a little box
01:09 called i and it puts the value 5 in it.
01:12 If I declare another variable called j and I set it equal to i, then the
01:17 compiler sets aside another little box, and this little box is called j, and it
01:20 also gets the same value as i, which is 5.
01:24 Now, the important thing to remember here is that j is a copy of the value
01:28 that's stored in i right now.
01:30 So if I go back and change the value of i to 3, the value of i gets changed,
01:35 but the value of j does not get changed, because these are different memory locations.
01:39 Now, let's compare that with how reference types works.
01:42 So suppose I made a class called Point,
01:45 and inside my Point class I had two integer member variables
01:49 X and Y, which represent the coordinates of the point.
01:53 To create a new Point, I would declare a Point class variable named P1, and I
01:59 would use the new operator to create a new instance of the Point object.
02:03 Then I could do something.
02:04 Now since these are public member variables, I could say P1.X and P1.Y are equal to 10.
02:11 Let's watch what happens in memory.
02:12 Well, in memory, that little location called P1 for the variable gets created,
02:17 but what also gets created is a set of bytes somewhere else in memory that
02:21 actually hold the member variables.
02:23 And P1 is not actually containing that data.
02:27 It contains a reference to that data.
02:30 There's this little reference that goes out into memory and knows where X and Y are stored.
02:35 So let's suppose I made another variable called point P2.
02:39 And rather than doing new Point, I say point P2 = P1.
02:44 Well, that creates a little local variable there called P2.
02:47 But watch what happens.
02:48 The reference gets set to the same reference as P1.
02:52 They're sharing the same reference to the same location in memory, because I
02:57 didn't make a new instance of Point; I simply set P2 to be equal to P1.
03:02 And when you do that with a reference type, you're sharing the same reference.
03:05 What does that mean?
03:06 Well, if I then do something like this where I set P1.X =20, it changes for the both of them.
03:12 So even though I didn't do anything to mess with P2, P2.X is now having the
03:17 value of 20, the same way that P1.X is.
03:20 This is an interesting side effect of how reference types works, and you need to
03:24 watch out for it in your code.
03:25 Let's go over to the code environment and take a deeper look at this.
03:29 So I'm here in my ValAndRefTypes example file, and I've got the Program.cs file
03:35 open, and I've got my Snippets here.
03:37 So what I'm going to do is back here in my code, I'm going to put some code in
03:41 here that exercises both the reference and value types that we saw earlier.
03:47 So let's go back over here.
03:48 What I'm going to do is copy this line right here, which is the Point
03:51 definition, put it into my file over here.
03:54 I'll just put right in front of the Program class. I'll save that.
03:57 And then I'm going to copy over this function right here called testFunc1.
04:03 And this is the first test that we'll run. So I'm going to copy that.
04:06 I'm going to put that in my program down here.
04:10 So now let's copy over some of the logic to see what's happening.
04:13 Go back to my Snippets.
04:15 I'm going to scroll down a little bit, copy these few lines right here, starting
04:20 with this variable and down through this WriteLine.
04:22 I'm going to copy that and paste it into my Main.
04:27 So let's take a look at the code that we have here.
04:30 We'll use point a little bit.
04:31 I just want to make sure we have it in place.
04:32 For now, I'm just going to concentrate on this code right here.
04:35 In my Main function I've got a variable called i, and I'm setting it to be the value of 10.
04:40 And then I call this function, testFunc1, with the i variable.
04:43 So let's scroll down and see what testFunc1 is.
04:47 You can see it takes an integer argument.
04:49 And the first thing it does is it adds 10 to the argument that's passed into the function.
04:56 When this Console.WriteLine gets executed, it's going to write out the value
05:00 of whatever arg1 is.
05:02 And then when the function completes and goes back up, we're going to write out
05:05 whatever the value of i is.
05:07 Go ahead and place your wagers and let's see what happens.
05:11 Build this, and we're going to run it.
05:13 So you can see that what happened was we passed the 10 into the function, and
05:19 arg1 was set to 10, but then we added 10 to it, so now it's 20.
05:23 But when we come back out of the function, the original variable i is unchanged.
05:27 It's still 10, even though we added 10 to it inside the function.
05:31 So let's go back and take a look at the code.
05:33 The reason why this works is because for primitive value types, like
05:36 integers, when you call a function and you pass in the value as an argument to the function,
05:42 it is passed as a copy.
05:44 When you pass value types, you pass a copy of their original values.
05:50 So even though we changed the value in here on line 29, since we're passing in
05:54 a copy of the local i variable from Main, we're not actually changing the i variable;
06:00 we're only changing the local copy that testFunc1 is working with.
06:04 Let's go back and copy in the rest of our code.
06:09 And I'm going to copy in these lines here, put them in my Main function.
06:19 And I need to copy over my other test function, which is this one right over here.
06:27 And I'll put that down below here, and now we'll save everything.
06:33 Now, let's go ahead and run our next test. And for this I'm going to get rid of
06:36 these lines of code because we don't need them.
06:39 So here I'm using the Point class, which I've defined up above my Main.
06:43 Here's the Point class. It's got an x and a y value.
06:46 So on line 19, I'm creating a new point, and I set p.x and p.y to both be 10.
06:52 Then here on line 22 I write out the value of the X property. Then I call this
06:58 testFunc2 with p--that's the point-- and then I write out p.x again.
07:04 Let's see what testFunc2 is doing.
07:06 Well, testFunc2 takes a Point argument, as you'd expect,
07:10 it writes out the value of pt.x, then it adds 10 to the value, and then it
07:14 writes out pt.x again.
07:16 So we're going to write out four things here.
07:19 We're going to write out the value of the Point's x field, both inside the test
07:22 function and outside the test function.
07:24 So let's go ahead and compile this and run it.
07:27 And you can see that before we call the function, the value of p.x is 10.
07:32 Then we go into the function and pt-- that's the local variable inside
07:36 that function--is 10.
07:38 Then we add 10 to it, which gives us the value of 20, and we write that out.
07:41 So inside the function, pt.x has been changed to 20.
07:44 Then we exit the function and go back into Main and you can see that the value
07:48 of p.x has been changed to 20.
07:50 So in this case the value was changed. Let's go see why.
07:55 Remember that Point is a class,
07:59 and the class was one of those things that we looked at earlier was a reference type.
08:04 So when you make a new point like this here on line 19, and then you pass
08:08 it into a function,
08:09 you're not passing a copy; you're now passing it by reference.
08:14 And because testFunc2 has a reference to the original point, if you change it
08:19 inside the function, it will change outside the function as well.
08:23 This is the fundamental difference between value types and reference types, and
08:27 it's something you'll come across in C# on a regular basis.
Collapse this transcript
6. Collections
Working with arrays
00:01 In this section, we're going to cover some of the data structures that .NET
00:06 provides for you, and specifically we're going to focus on collections.
00:10 Collections are essentially classes that help you keep track of and manage a
00:14 whole bunch of data, and since a lot of programming involves keeping track and
00:19 managing data, it seems like this is a pretty good place to start.
00:23 We're going to start off by looking at C# arrays.
00:26 Now in C#, arrays hold a fixed number of elements, all of the same type.
00:32 An array is basically just a list of items and values.
00:37 So for example, if I declared an integer variable called oneValue and set it to
00:42 be equal to 100, we've already seen this. Somewhere out in memory the C# compiler
00:47 and the .NET framework creates a little box called oneValue and puts the value
00:52 inside that little variable box.
00:54 Now an array is a little bit different than that, and the way you declare them as a
00:58 variable is also a little bit different.
01:00 When you declare an array you specify the type that you want the array to hold,
01:05 so here it's an integer just like always, but then you put these two square
01:08 little brackets next to the type definition.
01:11 So you have the opening square bracket and the closing square bracket with
01:15 nothing in it, and then you give it the variable name, just as you always would.
01:19 And this just tells the Compiler, hey,
01:20 we're not declaring one integer.
01:22 We're declaring a whole bunch of integers.
01:24 And then you complete the sentence by saying = new and then the type that
01:29 you're creating, in this case an integer, and then inside the square brackets you
01:33 put the number of slots that you want to create.
01:36 So this line of code right here int, square brackets, manyValues creates a variable called
01:42 manyValues, which is an array of, in this case, four integers.
01:46 And out in memory what's going to happen is the .NET framework is going to
01:50 create some space and it's going to create a variable called manyValues and
01:53 there will be four little boxes all initialized to 0.
01:57 The .NET framework takes care of initializing the array for you so that they are all 0.
02:01 Now arrays are zero-based indexes. So that first element in the array there is not element 1;
02:07 it's actually element 0, and it counts up from 0 up to 3.
02:10 So there are four elements, but it goes from 0-3.
02:13 So if I wanted to reference one of the elements in the array, I would simply
02:17 use manyValues and then inside the square brackets the index number of the one I want to change.
02:22 So if I wanted to change the first element in the array to a value of 100, I
02:25 would say manyValues, subzero, =100, and lo and behold, the value changes.
02:30 If I wanted to change the last one, I would do manyValues and then 3 in the
02:34 square brackets and that works.
02:37 Just like other variables in C#, I can also initialize array variables just like
02:42 I can initialize other variable types.
02:44 So in this case, I'm declaring an integer array called manyValues and rather
02:49 than creating the new memory using the new operator, I'm using curly braces and
02:53 then just putting the array values inside the curly braces, separated by commas.
02:57 This will create an array of four integers, just like we saw in the previous example.
03:02 And of course, I can do this with strings too.
03:04 I can say string array myStrings = and then inside the curly braces just four strings.
03:09 One of the cool things about C# is that unlike other languages, like say
03:12 Objective-C, C# provides what's called automatic bounds checking for arrays.
03:17 So in programming, if you try to reference an array index that's outside of the
03:22 bounds, or the size of the array, some languages don't check that for you and it
03:26 can lead to code problems and bugs down the road.
03:29 But in C# if I tried to do this, manyValues and then 100 inside the little
03:34 brackets as an index, if I try to set that value, that's going to cause an error. Why?
03:38 Because there is only four elements inside the manyValues array, so there is no
03:43 element 100, and that's going to cause a problem.
03:45 The good news is, C# catches that for you.
03:48 Now arrays are fixed in size.
03:50 Once you declare them, that's just how big they are.
03:52 There are other data structures that we'll get to that allow you to change
03:56 the size of the array, but when you declare arrays like this, that's just how big they are.
04:00 Why? Because this allows them to be contiguous somewhere in the computer's memory,
04:04 which is very efficient for the processor to access and change them.
04:09 The other thing you need to realize is that array elements are all the same type,
04:12 so you can't have an array to clear like you see it here that has numbers and
04:16 strings and floats and different data types.
04:18 When you declare an array using either int brackets or string brackets or float brackets or whatever,
04:24 choose your data type brackets, they're all going to be the same type.
04:28 Arrays can also be multidimensional.
04:31 Now in the previous example we saw a single dimensional array.
04:34 It was just one list of numbers. But you can make arrays multidimensional, and
04:38 the way that you do that is you declare the type, so for this case, integer.
04:41 Then inside the brackets you put a little comma.
04:43 This is going to have two dimensions.
04:45 It'll have the name of the variable called multiDimArray. Inn this case I'm saying new int and 3,3.
04:50 So that's going to make a 3x3 matrix of memory locations somewhere out in the
04:56 computer's memory, and it's going to initialize them all to 0.
04:59 And then to round out the picture here, the first number in the index there is
05:04 going to represent the row number, and the second number in the index
05:07 represents the column number.
05:08 So if I wanted to refer to a specific box inside the memory of the array here, I
05:14 would say something like multiDimArray, 0,1, = 10.
05:18 That means row 0, column 1 and that's the one that gets changed to a 10;
05:22 and just like other arrays, you can initialize these too.
05:25 So to do that, I would have the int, the type declaration, along with my little
05:30 brackets with the comma inside, and then I would just give the variable a name.
05:33 And in this case I have new int, comma, withinside the curly braces a set of curly
05:39 braces, each one representing a row of data.
05:42 This would create a 3x3 array with all of the boxes set to (0,1,2), (3,4,5), (6,7,8).
05:50 So you can initialize them and you can make multidimensional arrays with set values.
05:56 Now arrays, of course, are, just like everything else in C#, objects.
06:00 So, for example, if I had this declaration here for int manyValues = 100, 200
06:06 and so on, that gives me an array object with four entries in it.
06:11 So I can then do something like this.
06:13 I can say manyValues.
06:15 and then call a function called GetLength(), and that will come back with a
06:18 number four, because how many there are.
06:20 I can also call some static member functions. Remember, we talked about
06:23 static items earlier on.
06:25 I can do Array.Clear and then give it the name of the array and a couple of indexes.
06:30 Then starting at 0, it'll clear out the four elements.
06:33 I can do Array.Sort.
06:35 It will sort the given array, assuming that the members of the array are sortable.
06:39 Same thing with Reverse.
06:41 I can just reverse the given array.
06:43 Because arrays are objects, you get access to a whole bunch of built-in features.
06:47 So let's exercise some of these features.
06:48 Okay, here in the code I've got my Arrays example open, and I've got my Snippets
06:54 here. Scroll down to Arrays, and here's my program code.
06:57 So let's just go ahead and copy some of these over.
06:59 I'm going to do the first couple of lines right here, and we'll paste that in.
07:04 And here what we're doing is we're just declaring an array called manyValues
07:07 that has a whole bunch of values in it, and then we're going to write out the
07:10 value of the fourth number.
07:12 And remember, to do that, since this is the fourth number and it's a 0-based index,
07:15 we use the number 3, and set right here on line 13.
07:18 So let's hit F5 to run this, and the fourth number is 34.
07:22 Okay, that's pretty simple and straightforward. Let's keep on going.
07:25 In this case, we'll do the same thing with strings.
07:29 So here I have an array of strings.
07:31 I've got four strings: Joe, Marini, Teaches, C#.
07:34 And what I'm going to do here is use a for loop to write out the values of each
07:38 one of the elements.
07:39 So I have a for loop going from 0, and notice I'm using <4 here, not < or =,
07:45 because it has to stop at 3.
07:46 I'm going to write out each one of the strings using the i variable here to
07:52 index into the array.
07:53 So once again I'll hit F5, and you can see that works just fine.
07:57 Okay, so let's keep on going because this is getting interesting.
08:00 Let's go back over here.
08:02 We'll copy and paste this and put that down here.
08:06 So here you can see that I've created an integer array called otherValues and
08:10 I've set it equal to manyValues, and now I'm changing the last item in the
08:16 otherValues array to 0.
08:17 But what I'm writing out over here is the manyValues array, or at least the last
08:23 element of the manyValues array.
08:25 Now see if you can guess what's going to happen.
08:28 If we look at the item here, you can see that manyValues(3) is 0, 1, 2,
08:31 3; it's currently 34.
08:34 Let's see what happens when we change the otherValues array or sub three to zero.
08:38 I get it set to 0. Why?
08:40 Because remember arrays are reference types.
08:43 We passed in a reference to the array; therefore we actually changed the value of
08:48 both manyValues and otherValues.
08:50 And if you skipped the section earlier on value types versus reference types,
08:54 you should go back and review it now.
08:55 Let's try something else. Let's try some sorting.
08:57 I am going to copy this.
08:58 I'm going to paste it over here.
09:02 So now I'm calling the array class's Sort static member function on
09:08 my manyValues array.
09:09 And when I do that, we're going to write out what the fourth number is.
09:12 So let's go ahead and build that, and you can see that the fourth number is 16.
09:18 So we sorted the array going from smallest to largest, and that's a
09:22 built-in feature of .NET.
09:24 Arrays are really useful collection objects to use in C#.
09:27 You will find yourself using arrays for all kinds of things.
09:30 Arrays are used for processing lists of information and so on. What we'll take a
09:34 look at next is a collection type called ArrayList, which has some added
09:37 benefits on top of arrays themselves.
Collapse this transcript
Using array lists
00:00 All right. The next collection class that I am going to cover here is ArrayLists.
00:05 Now ArrayLists are like arrays, but there are a couple of unique features to them.
00:10 First, they can be dynamically resized as needed.
00:13 Recall from the previous movie that arrays are set in size once you create them;
00:18 ArrayLists aren't like that.
00:19 Now the way you create an ArrayList is by using the ArrayList class. And here
00:25 I've got an ArrayList with a variable named myAL, and I just say new ArrayList.
00:31 And we'll see how to do this in a bit in the code.
00:34 You have to include another namespace in order to use these, but the class name is ArrayList.
00:39 And in this case, I'm just calling the constructor that doesn't take any
00:43 arguments, but there is a version that does take an argument.
00:45 I could also just declare this variable by saying new ArrayList and then give it
00:49 some number, which is the capacity that I wanted to start off with.
00:52 If you don't do this, it starts off with some default capacity, and I don't
00:56 remember what is on the top of my head. I think it's like 10 or 50 or
00:58 something like that.
00:59 But you can say new ArrayList with a hundred or a thousand if you know you're
01:02 going to start off with a number that's that large.
01:05 So to add and remove items from the ArrayList, you use the functions that go
01:11 along with the ArrayList class.
01:13 So for example, to add an object to the ArrayList, you would simply call myAL.Add.
01:19 And notice that items get added as objects.
01:22 It takes an object as its argument.
01:24 But remember, everything in C# is an object--
01:27 well, almost everything anyway. Certainly all of the primitive data types and
01:31 any of the classes that you're going to come up with.
01:33 So you can add objects into your ArrayList.
01:36 Now you can add, which puts them at the bottom, or you can use the Insert method,
01:40 which takes an object and puts it in at a specific index. And then to remove
01:44 things you can use the Remove and RemoveAt.
01:46 So the Remove function takes the object that you're passing as an argument,
01:50 finds it in the ArrayList, and removes it.
01:52 RemoveAt removes the object that is at the index that you pass in, and remember
01:57 indexes here are zero-based.
01:58 There is also an easy way to find out how many things there are in the ArrayList.
02:03 There is the myAL.Count, which is a property on the ArrayList that tells you how
02:08 many items are currently in the ArrayList.
02:11 You can also do indexing with ArrayLists the same way that you would do them
02:14 with regular arrays. You can do things like myAL subzero.
02:16 You can even set values this way, which I guess is okay to do, but my preference
02:23 is to use the functions that come with the class.
02:25 Okay, let's take a look at ArrayLists and loops.
02:29 So suppose we had an ArrayList that we declared like this and we added a whole
02:34 bunch of items, items 1, 2, 3 and 4.
02:36 Out in memory this goes ahead and creates an ArrayList with four items in it.
02:41 Now if we want it to loop over the contents of this array, there is a couple
02:45 ways we could do it.
02:46 We could use the for loop, which we've seen in the past. And in this case, we
02:50 would have an integer variable named i and we would loop i up to being less than
02:55 the count of the items in the array, and we would increment the loop counter.
02:59 Now this is a perfectly valid way of doing this;
03:01 however, there is another way to do this.
03:04 And of course we could operate on the contents of the ArrayList.
03:06 We could write things out.
03:07 But my preference when working with things like this is to use the foreach loop.
03:13 Now we didn't talk about this earlier in the course, but I'm going to introduce it now.
03:16 The foreach loop construct loops over all of the elements in a collection, and
03:21 you can use it with arrays and other things throughout C#.
03:24 We're going to do it with ArrayList right here.
03:27 So foreach doesn't take a loop counter. What you do is you declare a variable
03:31 inside those parentheses; in this case it's an object because ArrayLists contain objects.
03:36 So you would say foreach (object obj in, and then the name of the collection.
03:41 In this case it's myAL. That's my ArrayList.
03:44 And then we can go ahead and operate on each object inside the loop.
03:47 So rather than doing the myAL sub-I that you see there in the loop, we would change
03:52 that to Console.WriteLine and then obj, because obj is going to be set to a
03:57 different object each time through the loop.
03:59 That's basically how foreach works.
04:01 It's really nice because there's no loop counters to keep track of.
04:04 There is no comparisons to make. The foreach construct just knows how to loop
04:09 over all the elements of a collection and put it into an object's variable
04:14 that you declare here.
04:15 Well, in this case it's an object; it could be other things too.
04:18 But in this case it's an object because ArrayLists keep track of objects.
04:21 ArrayLists can also have mixed content, unlike arrays. So if we declare an
04:27 ArrayList that looks like this, and then we go and add content to it using the
04:32 Add, remember each one of these is added as an object.
04:36 So I've got strings. I've got numbers.
04:38 I can put anything I want in here, as long as it derives from system.object,
04:42 which all the primitive value types do and all the reference types that we've
04:46 talked about, they do as well.
04:48 So I can do things then like this.
04:49 I can have an integer variable named result, and once again, I'm going to use my
04:53 foreach construct. And in this case, remember they are all objects,
04:57 so for each object in the ArrayList, I can then do something like this.
05:02 If the object is an integer--remember the is operator from earlier on in the course--
05:09 I can then say result +=, and then I cast, or convert, the object to an integer by
05:15 putting the word int in parentheses in front of it.
05:18 So this is going to loop over each object in the ArrayList,
05:21 see if it's an integer, and if it is an integer, add it to a running total.
05:25 So ArrayLists are really nice and flexible.
05:27 Let's go ahead over to the code and see some of this in real action.
05:30 Okay, here in the code I've got my ArrayLists example open, and I've got my
05:35 ExampleSnippets file. I'll scroll down to the ArrayLists section, and I'm going to copy
05:39 these lines right here, and I'm going to paste them into my program.
05:44 Put those into Main.
05:45 All right, so let's go ahead and take a look at the lines of code and see what they are doing.
05:50 Here on line 13 I'm declaring a new ArrayList object, then putting it into the
05:55 myAL variable, and then I add some stuff to the ArrayList.
05:59 I've got a string, integer, another string, another integer, and then a
06:02 floating-point number.
06:04 Then I have my foreach construct right here on line 20, and I've got my object o
06:10 variable, and that's going to be set to whatever the current object is each time
06:15 through the loop. And then I'm checking to see if o is an integer, and if it is
06:19 an integer, I write out the value of o using the Console.WriteLine construct.
06:25 So let's run this, and you can see that 2 and 4 are being written out.
06:30 Okay, let's go back and make a quick modification.
06:33 Let's say for each object, if o is an integer or o is a float, then we'll write it out.
06:45 In this case, we'll run it again,
06:47 you can see that the floating-point number as well as the integers are being written out.
06:51 So ArrayLists are really nice flexible alternative to using arrays in C#.
06:56 If you find yourself needing an array construct that is flexible, can contain
07:01 mixed content, and so on, consider using ArrayLists rather than just fixed-
07:05 sized arrays.
Collapse this transcript
Working with stacks
00:00 The next collection class that we are going to look at is called the stack.
00:05 Stacks maintain a list of items just like arrays and ArrayLists do, but they
00:10 operate on a slightly different paradigm called push-on and pop-off, and you can
00:15 think of a stack as, like, in fast food restaurants they have those cup stacks
00:20 where they push all the cups into the holder and then each time a person takes a
00:24 cup, it pops off the top.
00:26 Stacks are pretty much the same way.
00:28 Stacks are declared by using the stack class.
00:31 So to declare a stack, I will use the stack class, and then mystack is the
00:34 variable name. This is probably familiar by now. I say new stack.
00:38 That will create a stack object out in memory.
00:41 To put data on the stack, I use the push method to push data on the stack.
00:47 Remember, these are objects,
00:48 so I can pass any primitive type or any reference type, anything I can come up with.
00:54 In this case, I will just push a string called a string 1.
00:56 What that will do is that will put string 1 onto the top of the stack.
01:01 If I then push another piece of data, say string 2, what will happen is string 1
01:05 will slight down and string 2 will now be the new top.
01:08 And I can keep on doing this with successive pieces of data.
01:11 I can have strings 3, 4, 5, and so on.
01:14 To get the data off the stack, instead of using push, I use pop.
01:18 So I would declare an object variable.
01:22 In this case, it's called o, and then I would call mystack.Pop.
01:25 This would get the top value on the stack.
01:28 So after calling pop, string 2 pops off and then string 1 slides back on up and
01:33 now the value of o is the string 2.
01:36 If I wanted to just see what was on top of the stack without changing it, I
01:40 would use the Peek method.
01:42 This looks at the top value, but doesn't actually pop it off.
01:47 Then finally I can see how many things there are on the stack by asking the
01:50 stack's count property how many things there are.
01:53 In this case, it will tell me that there is one item on the stack.
01:56 Stacks are commonly referred to as LIFO,
01:59 Last In, First Out, data structures, because the things that you push onto
02:04 the stack earlier get pushed down towards the bottom and later elements are nearer the top.
02:09 So as you pop them off, those items are going to come out first.
02:12 So it's Last In and First Out.
02:14 Again, stacks are one of the common data structures you will find throughout
02:17 programs for various purposes.
02:19 Let's go ahead and jump over to the coding environment and actually exercise
02:23 this to see how it works.
02:25 So here in the code I have scrolled down to my Stacks section in my
02:29 ExampleSnippets, and I have got my Stacks project open over here with my Main function.
02:36 Let's go ahead and copy some code over.
02:38 So the first thing I am going to copy over is this setup code right here, and I
02:42 am going to paste that in.
02:45 Right there on line 13 you can see that I am declaring a new stack variable, and
02:50 then I am pushing some data on the stack.
02:51 I am Pushing strings, items 1, 2, and 3.
02:54 Then I am just going to write out how many items there are on the stack by using
02:57 the mystack.Count property.
03:00 So we are going to run this, and you can see that sure enough, there are
03:03 three items on the stack. So far so good.
03:06 Let's go back over to the code.
03:08 Now let's have a peek at what the top item is.
03:11 So we are going copy that, and we will paste that below here.
03:16 Now remember Peek is non-destructive.
03:19 In other words, it doesn't actually change the stack;
03:21 it just shows me what's on the top.
03:22 So we will run this and you can see that items 3 in on the top. Why?
03:26 Because item 3 was the last item pushed on; therefore, it will be at the top of the stack.
03:33 So far, things are operating the way they are supposed to.
03:35 Let's go ahead and try popping something.
03:37 I will go ahead and paste that code in down here.
03:44 So now here on line 23 you can see I am calling the Pop function, which is
03:48 going to pop item 3 off the top of the stack, which means that item 2 will now be the top item.
03:54 So when I write this out, it should say item 2. So let's run this.
03:57 Yeah, sure enough item 2 is now on the top of the stack.
04:00 Let's go back to the Snippets over here. One more thing.
04:04 We'll paste that code in here.
04:11 So now I am going to call these stacks Clear function right here on line 27, and
04:15 that will get rid of everything on the stack here.
04:17 It will clear out the contents and then when I call mystack.Count, I should have the value 0.
04:23 So let's press F5 and sure enough, I have got 0 items on the stack.
04:30 You will find stacks used throughout C# programs and other programming
04:33 languages in general.
04:34 They are pretty useful for keeping tracks of certain kinds of data structures,
04:37 mathematical expressions, evaluations, and so on.
04:40 There are a couple of great examples.
04:41 So that's how you use stacks.
Collapse this transcript
Working with queues
00:00 Well, continuing on with the cavalcade of collection data structures, we are now
00:04 going to look at queues.
00:06 Queues maintain a list of items kind of like stacks do, but they are different
00:10 than stacks in that they're FIFO, or First In, First Out--kind of like a line of
00:15 people waiting at a counter.
00:16 In fact, if you've ever spent any time in UK, you will probably hear lines
00:19 referred to as queues, and queues in programming work pretty much the same way.
00:25 Something enters the queue, and it's the first one in. It's also the first one out.
00:28 And items move in the queue in an orderly fashion, or at least they should.
00:33 Using queues in C# is similar to using stacks, only instead of having Last In,
00:39 First Out, it's going to be First In, First Out.
00:42 To declare a queue, you use the Queue class name and here I have got a queue
00:47 named myQ and I create a new queue.
00:49 Then to put things on the queue, instead of using push and pop, we are going to
00:52 use Enqueue and Dequeue.
00:55 So in this case, I am going to create my new myQ variable.
00:58 I will call Enqueue. And in this case I am passing a string, but it's an object,
01:02 so it can be anything; it could be a number or whatever.
01:04 So I am passing in a string.
01:05 When I do that, string 1 will be placed in the queue.
01:08 If I then Enqueue string 2, string 1 will move down and then string 2 will now
01:12 be at the back of the queue.
01:15 Instead of using Pop, I am going to use Dequeue.
01:18 So when I say Dequeue, the first item will come off of the queue like this.
01:24 That leaves string 2 as the current first item.
01:28 Just like using stacks I can do things like Peek, and Peek is non-destructive.
01:32 In other words, it's does not take things off the queue;
01:34 it just shows me what's at the front of the queue.
01:36 In this case, it's now string 2. And also like stacks, I can use the Count
01:40 property to see how many items are actually on the queue.
01:44 So since this is so similar to stacks, let's just go ahead and waste no time and
01:47 get over to the code so we can see this working in action.
01:50 Here we are in the code.
01:52 One of the things that I haven't pointed out up until now, which you
01:55 probably have noticed, is that you need to include a name space in order to
01:58 use the collection classes.
02:00 Up until now we've had a Collections.Generic which has been included for us by
02:04 default, but in order to use things like stacks and queues and ArrayLists, you
02:08 need to include this guy right here using System.Collections.
02:11 This is the namespace you need to include in order to use the classes we have
02:15 been talking about so far.
02:17 So to use queues and stacks and ArrayList and so on, just make sure you have that included.
02:21 So let's jump over to the Snippets, and you can see I have scrolled down to the
02:25 queue section. And I am going to go ahead and copy these lines and this is the
02:30 setup code right here.
02:31 I'll just paste this in.
02:36 So right there on line 13, creating a new queue, and then I am Enqueuing four
02:40 items. And I am going to write out how many items there are in the queue and sure
02:44 enough, there four items, just like you would expect there to be.
02:48 Now let's go back to the Snippets.
02:50 Just to show you that you can use other kinds of loop constructs with these
02:54 collection classes, I am going to use a while loop.
02:57 And if you have been watching along with me so far, you've probably noticed
03:00 I've used for loops.
03:01 I have used for each loops.
03:03 It's time to give the while loop its turn.
03:05 So here I am going to say while myQ.Count > 0 we are going to Dequeue items--
03:13 you can see they're on line 23--and then in the following line 24 we are just
03:15 going to say Dequeuing object whatever and write it out to the console.
03:21 Each time we Dequeue something the Count property is going to automatically
03:25 be decremented for us.
03:26 We don't have to worry about taking care of that.
03:28 The class keeps track of how many items there are in the queue. And since Dequeue
03:32 takes things off of the queue, the Count will change for us.
03:35 So I am going to go ahead and compile this and build this, make sure it works, and it did.
03:38 Now let's just go ahead and run this.
03:42 You can see that we are Dequeuing items in the same order that they were put o to the queue.
03:47 So item 1 was the first one in, and it's the first one out, followed by items 2, 3, and 4.
03:52 So queue is similar to stacks, only they operate more like a Line.
03:55 If you find yourself in need of a collection class where the order is
03:58 important and you need to process things in the same order that they come in,
04:02 use queues instead of Stacks.
Collapse this transcript
Using dictionaries
00:00 The last example of a collection class that we are going to look at is the dictionary.
00:05 And dictionaries are used to associate a particular key with a given value,
00:11 and you can think of them as lookup tables. Essentially, you use a key to look up a value.
00:16 So if I have a dictionary object then I essentially have a key that's associated
00:21 with a value inside that dictionary.
00:24 And some examples of that might be a product ID with a product name, or I could
00:28 associate say an abbreviation for a state name with its full name.
00:32 But really I can associate any object with any other object.
00:37 This is what hashtables are essentially used for.
00:40 They are probably one of the most useful collection classes out of all of them.
00:44 Keys have to be unique.
00:46 You can't have duplicate keys, and dictionaries don't have any sense of order.
00:52 So unlike other collection classes, like stacks or queues or arrays, there is no
00:57 sense of order here.
00:58 You simply put in keys, associate them with values, and there's no notion of who
01:04 is first or who is last.
01:06 Probably the most common example of a dictionary is the hashtable
01:11 or associative array.
01:13 You probably heard it called many different names depending on what other
01:16 programming language you may have come from.
01:18 If you've never heard of it before then I will introduce it to you now.
01:22 The hashtable is an example of a dictionary, and the Hashtable class in C# is
01:28 declared the same way you declare any other collection class;
01:30 you simply have the Hashtable class, and in this case I'm declaring a variable
01:34 named myHT, which is of type Hashtable, and then you just use the new operator
01:39 like you would in any other class.
01:41 So this will create a new hashtable named myHT, and then we can start adding
01:46 things to the hashtable. And the way you do that, well, there are a couple ways
01:49 to do it, but the first way to do it is to use the Add function.
01:52 When you add something to a hashtable you give it the key that you want.
01:56 So for example, I could give a three-letter airport code, like SEA, and then I
02:01 give it the value, which might be something like Seattle Tacoma Airport.
02:05 Then over in a hashtable I would have a little key named SEA and would be
02:08 associated with a value.
02:10 And I could do the same thing for say SFO, and that associates it with
02:14 San Francisco Airport.
02:15 I can also use bracket notation.
02:18 For example, I can say myHT, and then in brackets I can have the three-letter
02:22 code for IAD, which is Washington's Dulles Airport. And using the bracket
02:28 notation, I will simply use the equals, or assignment operator, to say myHT sub
02:33 ID is Washington Dulles Airport, and that would also put something into the hashtable.
02:38 That's how you get data into the hashtable.
02:41 The way that you get data out of the hashtable is to use the Remove function.
02:45 In this case, I would call myHT.Remove, and then I give it the name of the key
02:49 that I want to be removed.
02:50 So if I want to remove San Francisco Airport, I would simply say Remove SFO and
02:54 that will cause SFO to be removed from the hashtable.
02:58 Just like other collection classes, there are a couple of utility
03:01 properties and so on.
03:02 For example, I can see how many things there are in the hashtable by using the
03:06 by now ubiquitous Count property.
03:07 This will tell me in this particular case there are two things in the hashtable.
03:11 I can also see if hashtables contains certain values by using a test.
03:15 I can, for example, declare a Boolean variable name b and call the ContainsKey
03:21 function on a given hashtable. And I can pass in a key name, in this case SFO,
03:26 which will return false now, because it's gone. Or I can also use the
03:30 ContainsValue version as well.
03:32 So I can say, hey, hashtable, do you contain the value San Francisco Airport?
03:36 In this case, it's now false, but if it was still there, it would be true.
03:39 So let's just jump over to the code and make ourselves a hashtable and exercise this.
03:45 So here I am in code.
03:47 Once again you'll notice I am using the System.Collections using statement up
03:51 here that includes the name space for the collections class, which includes
03:56 things like dictionaries and hashtables and queues and stacks and all the
04:00 examples we have been using so far.
04:02 So jumping over to the Snippets code, you can see I have scrolled down to the
04:05 Dictionary section, and I am going to copy the setup codes over here.
04:08 I am going copy that and it will paste it into the Main.
04:17 You can see on line 13 I have created a new hashtable, and then I've added some
04:21 data to the hashtable.
04:22 I have added airport codes SFO, SEA, and IAD, and I have set their associated
04:28 values to the full names of their airports.
04:31 Then we can test this out by saying, hey, let's do a Console.WriteLine to see
04:35 the value for key, whatever is this.
04:39 And we are going to pass in the name of that key. In this case I will look
04:42 up the value by using the bracket notation.
04:44 So you can see here on line 16 I use the bracket notation to set the value.
04:48 I can also look up the value by using the bracket notation, but without an
04:52 assignment operator.
04:54 So I am going to do a build.
04:55 You could see the build succeeded, and we are going to run it.
04:59 And you can see it worked fine.
05:02 The value for key SEA is Seattle Tacoma Airport. That's great.
05:07 Let's continue on with the exercise.
05:09 I am going to copy this line here, which simply tells me how many items there
05:14 are in the hashtable.
05:15 So I'll save that and run it.
05:18 And as you expect, there are 3 items in the hashtable. So far so good.
05:24 Let's do our last exercise right here.
05:27 Copy and we'll paste this in.
05:31 In this case, we are going to exercise the Remove functionality, but before I
05:35 uncomment that Remove line--let's just go ahead and write it out that right now--
05:41 you can see that the value for key SFO is San Francisco Airport.
05:45 That's because SFO is still in the table;
05:47 I haven't removed it yet. But if I uncomment this line right here, I'm going to
05:53 remove the SFO key, and then the next line is the if statement on line 22 that
05:58 says, hey, if myHT contains the key SFO then write it out.
06:03 Now that condition is going to be false, because we've moved it.
06:05 So let's run it again, and you can see that this time there was no WriteLine for
06:11 the SFO key, because it's not there anymore.
06:14 Hashtables are probably one of the most useful of the collection classes, and if
06:19 you're coming from a language like JavaScript you've probably used these a lot.
06:23 In fact, they are used all over the world of programming, and in C# it's no different.
06:27 You can use hashtables to associate keys with objects, or any other kind of data
06:32 that you can think of.
06:33 They're pretty useful.
06:34 They are also pretty efficient.
06:36 If you find yourself in need of having a lookup mechanism, a hashtable
06:39 usually fits the bill.
Collapse this transcript
7. More Complex Classes
Overloading methods
00:00 We have reached the section of the course now where we are going to start
00:02 learning about some of the more advanced object-oriented features of C#.
00:07 The information in this part of the course is going to build on the
00:11 information that we learned about earlier in the chapter on creating custom
00:15 classes and objects.
00:17 Go ahead and watch that content if you haven't already, and then pick it up here.
00:21 We are going to start with method overloading, and method overloading is when
00:25 you define methods that have the same name but different ways of calling them.
00:30 So let's look at a real example.
00:32 Let's go back to our ubiquitous Wine class example, and you can remember from
00:37 earlier examples I've got a class here called Wine. And I can declare some
00:42 member variables like Year, Name and Price, as I have done in the past. And you
00:45 have probably seen me do something like this where I declare a constructor
00:49 function called Wine, which is the same name of the class, and in this case it
00:54 takes a string argument and it sets the value of the Name variable to whatever
00:59 argument was passed in.
01:00 That's great, but what if I also wanted to give people that are using this
01:03 class a way to initialize the class, or construct the class, with both a name and a year?
01:11 Well, I could simply just define another Wine constructor function like this,
01:16 and in this case I have got a Wine constructor which takes a string and takes a Year.
01:20 You might be saying, well, wait a minute.
01:21 You have already got a constructor function called Wine.
01:24 Isn't this a problem? Aren't you redefining something? No, not really.
01:27 What I am doing here is I'm overloading the Wine constructor, and this doesn't
01:33 just work with constructors.
01:34 You can do this with any function.
01:35 I just happened to be doing with the constructor function here.
01:38 And the reason this works is because the signatures of the two methods are different.
01:44 In other words, the parameters that each one of these constructor takes is unique.
01:49 So for consumers who wanted to call the constructor for the Wine class using
01:54 just a name, they can do that.
01:56 If they want to use both the name and a year in their code, they can do that too.
02:00 As long as you define the function with the same name and a different set of
02:05 parameter lists, that's fine. That's legal C#.
02:08 Let's take a look at an example that doesn't work.
02:12 If I have a class and I wanted to provide two functions of the same name, here I
02:17 have got a function that takes an integer and returns an integer and I've got
02:21 another function that takes an integer but returns a float.
02:23 The problem is this is an error.
02:26 The return type of the function is not part of the signature.
02:29 It's the parameter list.
02:31 These methods are not considered different by the compiler. And you can imagine
02:36 in the code I would call out a function with an integer argument,
02:39 the compiler wouldn't know which one to call. So you can't do this.
02:43 You can't have functions that defer only by the return type.
02:46 The parameter list has to be different.
02:49 So let's take a look at some real code to see how this works.
02:52 So in the MethodOverloading example I've got my program, opened and here's my
02:57 Snippets code, and I've scroll down to the overloading methods section.
03:01 So I am just going to go ahead and copy this entire class right here for Wine.
03:07 And we are going to need this to set up the example, so I will just copy this in,
03:10 and I will put it above the program class.
03:15 Before I copy the rest of the code, let's take a look at what's going on here.
03:18 I have my Wine class and I have got my member variables here, and then I've got
03:23 a set of constructors.
03:24 You can see that I've got a constructor for the Wine class that takes just a string,
03:28 I have got one that takes a string and a year, and I've got one that takes a
03:32 string, a price and a year.
03:36 So I have got three different constructor functions, so I am overloading this
03:39 function three times.
03:40 Okay, now let's go back to the Snippets and let's copy in some code that
03:45 actually exercises this.
03:47 I will copy that and put it into the Main function, and we will just put it in right there.
03:56 You can see here, starting on line 35, I am creating three Wine objects, w1, w2
04:03 and w3, and I am calling the constructor in a different way each time.
04:07 For w1 I am just passing in a string by putting in a name, for w2 I have got a
04:11 name and a year, and for w3 I've got the name, the price and the year, and
04:17 then I've got three lines here that's going to write out the various parts of the objects.
04:23 So for Wine 1 I am going to write the name, and so on.
04:25 Let's go ahead and try this code out and see what happens.
04:29 So you can see that when I run the code for w1, I am writing out just the name;
04:33 for w2 I have the year and the name; and for w3 I have got the year, the name, and the price.
04:41 Now, because I've overloaded these functions, I can call them with different
04:46 values and different parameters.
04:47 So, for example, I have given the consumers of this class three different ways
04:51 to build their Wine class objects:
04:54 so just the name, the name and the year, and the name and the year and the price.
04:58 I want to go back and change the way that I constructed w1,
05:02 I can put my cursor in here and type comma. And you can see that when I type the
05:07 comma, C# Express gives me a little pop-up that says hey, there are three
05:12 different ways you can call this function.
05:14 You can see right here it's on 2 of 3, but I can cycle through all of these.
05:18 1 of 3 is to call the Wine constructor with just a string.
05:22 Here is the version with just a string and an integer. And you can see, since I
05:27 have put the comma in there, it's highlighting the integer in bold saying, hey,
05:30 that's where I think you are going to type next. Or in the third case,
05:35 I've got the string, the price, and the year. And again I am on parameter number
05:39 two right now so it assumes I am going to type a price in here.
05:42 But the point is that C# Express is looking at my constructor list and helping
05:47 me choose the one that I want, and it's showing me what's available.
05:50 I can choose to use either this version or this version.
05:53 So let's go ahead and use the second version.
05:55 I am going to just type in 2007. I need to change the Console.WriteLine as well.
06:04 So I will put this in here w1.Name, and now I will do w1.Year. And when I save
06:15 and I rerun this, you can see I have got the name and the year that's being written out.
06:21 Just to recap, overloading a method is when you declare a method with the same
06:27 name but with a parameter list that's different each time.
06:30 In this example I showed you how to do it with the constructor, but you can do
06:34 this with any method. It doesn't have to be the constructor.
06:37 You can't do this with properties. You can't do this with fields.
06:39 You can do this with methods.
Collapse this transcript
Overriding methods
00:00 A very close cousin of overloading methods is called overriding methods.
00:05 In overriding methods, you basically get to change or augment the behavior of
00:10 methods and classes, and this is called overriding their logic.
00:14 It's one of the most powerful things of object-oriented programming and it
00:18 really, really helps you when you want to encapsulate your logic in your objects
00:22 and separate the behaviors of different objects from each other.
00:26 Let's suppose you have a phone. And a phone knows how to do something, like ring,
00:32 but of course you just have a phone.
00:35 You have a particular type of phone.
00:36 You might have a landline.
00:38 You might have a cellular.
00:39 You might have a satellite phone.
00:40 Well, each of those knows how to ring as well.
00:43 In fact, they have got their own custom ways of ringing.
00:46 Now when you get a phone call the person calling you doesn't necessarily know
00:50 what kind of phone you have; all they know is that you have got a phone.
00:54 When they make a phone call the system looks up your phone and tells your phone
00:57 to ring. And when the phone is told to ring it figures out what kind of phone
01:02 you have, and it tells that particular kind of phone to go ahead and do its
01:06 ringing. And this is the same kind of concept that we will do in object-oriented programming.
01:12 You will have a class, a subClass, and the baseClass, or the superClass, to use
01:18 object-oriented terminology,
01:20 will have some method in it, and you want to either completely replace the
01:24 logic that's in that method, or you want to augment it somehow.
01:29 You use overriding in order to do this.
01:31 Now there are three important things you have to understand.
01:34 There are three keywords in C#.
01:36 The first one is virtual.
01:38 The virtual keyword tells the compiler that it can be overridden.
01:43 The override keyword is another important one, and then there's the base keyword.
01:48 To use the overriding mechanism, there are three things you have to do.
01:51 First, you have to mark a method as being virtual.
01:55 This tells the compiler that this particular method can be overridden by derived classes.
02:00 If you're coming from other languages like JavaScript or C++, this may look
02:05 somewhat familiar, but it's a little bit different.
02:08 You have to specifically mark a function as being over overridable.
02:12 So here you can see I have got a function called myFunction.
02:14 It returns an integer. And I have got the public keyword in front of it, but I
02:19 have inserted the word virtual between the public and the return type.
02:24 This tells the compiler, hey, somebody might want to override this.
02:27 Now they don't have to, but they might want to.
02:29 To actually override the method, in the subClass, I tell the compiler that a
02:35 particular method is going to override the same method in the baseClass by using
02:39 the override keyword.
02:41 So in this case instead of virtual, I use override.
02:44 You can see I have done the same thing here: between the return type and the word
02:47 public, I've used the word override.
02:51 And these two go hand in hand when you want to override methods.
02:55 Then finally, there is the base keyword, and you can use this in your subClass to
02:59 call the baseClass's method. And you use this because you don't necessarily
03:04 always know what the name of the baseClass is.
03:07 Instead of you actually using the name of the baseClass, you simply say base, dot,
03:11 whatever the function is. And this will call into the code in the superClass
03:16 instead of your subClass.
03:18 Now there is a little bit complex.
03:21 It's probably helpful to see an example of this in action,
03:24 so let's jump over the code and see it work.
03:29 So here I am in my example.
03:31 This is for method overriding. And I am going to go over to my Snippets, and you
03:35 can see in my Snippets I have scrolled down to the Overriding Methods section.
03:39 The first thing I am going to do is copy over my class definitions.
03:42 I have two classes:
03:43 I have one that's a baseClass and I have one that is a subClass of that baseClass.
03:47 Let's go ahead and copy these over, and I will put these in my program definition here.
03:56 So now I am going to scroll back over here down a little bit. I'm going to copy this
04:02 code and put it into my program.
04:08 Before we run this, let's take a look at the class definitions, so we can
04:13 see what's going on.
04:16 In my baseClass, you can see here on line 10 I have got a function called
04:21 doSomething. And it doesn't return anything, so it's a void return type and it's
04:26 public. And I have declared it as a virtual method.
04:29 What that means is when I create a subClass that descends from this baseClass
04:34 the subClass has the opportunity, if it wants to, to override this method.
04:38 Now the baseClass method for doSomething just simply writes something out to the
04:42 console. It says, hey, this is the baseClass saying "hi."
04:44 Go down to the subClass. On line 18 you can see that I've got the same
04:49 method, doSomething.
04:51 In this case I've got the override keyword.
04:54 So this tells the compiler, hey, I'm overriding whatever the baseClass does.
04:59 In the doSomething method for the baseClass I am calling the baseClass's version
05:03 of doSomething, which will call the Console.WriteLine method. And then I can put
05:08 on whatever additional programming logic I want to.
05:12 I can do another Console.WriteLine.
05:14 I can put it before or after the baseClass call.
05:18 I can put it here if I want to.
05:19 I will just leave it there for now.
05:22 So let's go back down to the program. And you can see that what I am doing is I
05:25 am creating an object.
05:27 I have got a subClass object.
05:31 I have created a new subClass object called obj1, and I am going to call doSomething.
05:35 So let's see what happens when I run this.
05:39 Two things get written out:
05:41 "This is the baseClass saying hi!"
05:43 and "This is the subClass saying hi!"
05:45 So why did that happen?
05:46 Well, in obj1 we called doSomething.
05:48 obj1 is a subClass, so we will look in the subClass. And you can see that in
05:55 doSomething the first thing we do is call the baseClass's version of doSomething,
06:01 which will be this right here.
06:02 The baseClass saying hi!
06:04 gets called first, and then that returns and then the subClass gets called.
06:08 We can reverse that order.
06:10 We can cut this line and put it up here, and let's run it again, and now you can
06:14 see that the subClass says hi first instead of the baseClass.
06:18 Let's go back to the code.
06:19 We can actually just take this call out.
06:21 We don't have to call the baseClass if we don't want to.
06:23 Now we've completely replaced the functionality that the baseClass provides, and
06:28 we are only doing what the subClass says to do.
06:31 So we are going to save this and run it and now you can see that only the
06:34 subClass's version of that function is running; the baseClass's version is not
06:38 getting a chance to run. Hit Return.
06:41 Let's try something else.
06:44 Since subClass is a version of the baseClass object, I can do something like this.
06:52 I can say baseClass obj1 = new subClass.
07:00 Now that may seem strange at first, because wait a second. Shouldn't I be
07:03 creating a new subClass?
07:05 No, I'm actually going to create a baseClass object.
07:07 Let's see what happens here. Ah!
07:10 "This is the subClass saying hi!"
07:12 Why did that happen?
07:13 Why is it that when I created an object of type baseClass, or I gave it a
07:18 name of baseClass, and I created a new type of subClass, why did it not call
07:23 the baseClass's version? Why?
07:25 Because when you create a virtual function C# is actually going to look up what
07:29 the lowest descendent is and call that version of the function.
07:33 Since I actually created a new instance of subClass, even though I arranged it to
07:38 be assigned to a variable named baseClass type, it's still going to look down in
07:42 the functions and say, oh, you know what?
07:44 That subClass object is actually overriding this function,
07:46 so I am going to call that version instead.
07:48 Let's change this so that instead of creating a new subClass type, I am creating
07:53 a new baseClass type.
07:55 Now let's see what happens.
07:57 I am going to run it.
07:59 Now it's the baseClass's version saying hi. Why?
08:01 Because it's not a subClass anymore;
08:03 it's a baseClass now.
08:05 That's how you override methods.
08:07 You use the keyword "virtual" to indicate that a method can be overridden and then
08:12 use the "override" keyword to indicate that you are overriding it in a baseClass.
08:17 And you can use this to augment the functionality provided by baseClasses in
08:22 your own programs, as well as other programs that you might be adding on to.
08:26 It's a really great way of segmenting your program so that pieces of
08:31 functionality don't have to be changed in baseClasses in order to provide new
08:35 pieces of functionality in classes that derive from them.
Collapse this transcript
Creating abstract classes and methods
00:00 All right, in this section we are going to talk about abstract classes, and
00:04 abstract classes tend to be one of those subjects that trip people up who
00:06 are learning object-oriented programming for the first time, so I'll try to make this easy.
00:11 Essentially, an abstract class can't be instantiated by itself.
00:14 You have to create a subclass, and you have to instantiate that instead.
00:18 In other words you've got to derive a class from an abstract class and make
00:22 that class instead;
00:23 you can't instantiate an abstract class.
00:25 abstract classes have abstract members and these are members that have to be
00:30 overridden by subclasses in order to provide functionality.
00:34 So, okay, why would you do this?
00:36 Well, there are going to be times in programming where you define a class that
00:39 describes an abstract idea, but it doesn't make sense by itself.
00:43 It has to have an actual physical implementation, and that physical
00:46 implementation is going to change among different versions of that class.
00:50 And we'll take a closer look at that in a moment.
00:52 First, let's see how to actually describe an abstract class.
00:55 Abstract classes are indicated by putting the word abstract in the class definition.
01:00 So if I normally describe a class like this using public class, myClass, and then
01:06 declare the class normally like you see me do throughout the course,
01:09 what I would do here instead is put the word abstract inside the class definition.
01:13 That tells the compiler that this is an abstract class.
01:16 Then once I've done that, I can declare an abstract member function, like you see here.
01:22 Now I don't provide an implementation for this function here.
01:26 Remember, I'm forcing the subclass to do that.
01:29 The subclass has to provide an implementation.
01:33 So let's take a look at a real-world scenario where you would do something
01:38 with abstract classes.
01:39 Consider an example where you've got a car dealership or some kind of dealership
01:43 where you sell different types of vehicles.
01:46 Now vehicles, depending on what they are, have unique characteristics, but some of
01:51 them might be common among all different kinds of vehicles. For example, they
01:55 might have properties like what kind of fuels they use and what their licensing
01:59 code number is, right?
02:01 But you don't actually go down to the dealership to buy a vehicle.
02:05 What you do is you buy something like a motorcycle or a car or a truck or a boat.
02:10 These are real-world implementations of this abstract notion of a vehicle.
02:16 Even though they may all share some of the same characteristics, there is no
02:20 such thing as actually making a vehicle. So in this case if the vehicle, the
02:25 class you see in the dotted line there, is an abstract class and the classes you
02:29 see in the thick lines are real subclasses that derive from the vehicle
02:35 subclass, you could do something like this.
02:37 I could say class Car c = new Car. That works great.
02:41 It's a real class that derives from the abstract class.
02:44 What I can't do is this:
02:45 I can't actually instantiate the abstract class, because the rules of object-
02:51 oriented programming in C# is that abstract classes have to be derived from.
02:55 So I would have to instantiate one of the real classes, the motorcycle, the car,
02:58 the truck, the boat.
02:59 And I could add more real classes as time goes on.
03:03 So let's just go over to the code and see this in action.
03:06 Okay, I've got my abstract classes example opened.
03:11 Let's go over to the snippets.
03:13 You can see I've scrolled down to my Abstract Classes and Methods section. And I
03:16 am just going to copy these two class definitions and I am going to paste them
03:20 in my program over here.
03:23 So now I have my abstract class, which is myBaseClass, and in there you see I've
03:28 got my abstract method called myMethod.
03:31 And then if we scroll down a little bit, you'll see here starting on line 13,
03:34 I have a derived class which inherits from myBaseClass. And it overrides--again I
03:42 am using the word override here to override the abstract member function called
03:47 myMethod--and in this case it just takes two arguments and returns the sum of
03:51 those two arguments.
03:53 So if we go down into the Main function, I could do something like this.
03:57 I can say myDerivedClass = new myDerivedClass, and then I can say int result =.
04:09 Actually, I have to make it a variable there. I can say mdc.
04:15 and then I can call myMethod right here. And I'll just give it two numbers, 5 and 6.
04:23 And then we'll just write out the result there, and then we'll have the program
04:31 wait for us so we can see the results.
04:34 So let's save this, and let's run it.
04:36 And you can see that the results here is 11. Why? Because 5+6 equals 11.
04:42 So we can see that the real derived class from the abstract class provides
04:47 implementation and actually works.
04:49 Let's comment this code out so that we don't have to deal with any errors in it.
04:54 Okay, let's see what happens when we take the myMethod implementation out of
05:01 the derived class. I am just going to cut this code and save it, and now I am
05:05 going to hit F6 to build.
05:07 And you can see that we get an error.
05:09 There is little blue squiggle underneath myDerivedClass, and if you look down
05:13 here in the error list, it says "abstractClasses.myDerivedClass does not implement
05:19 inherited abstract member myMethod."
05:22 So you can see that because I declared myMethod to be an abstract method, I have
05:27 to override it in my base class.
05:30 So let's undo that. Put that back in, and the error goes away.
05:34 Let's try another little experiment. Let's do this.
05:37 Let's say myBaseClass mbc = new myBaseClass, and we'll save and we'll build, but another error.
05:49 What's the error this time?
05:50 It says, "Cannot create an instance of the abstract class or
05:55 interface myBaseClass."
05:57 Abstract classes, as you can see, cannot be instantiated by themselves, and this
06:01 is enforced by the C# compiler.
06:05 So let's go ahead and delete that code.
06:09 So abstract classes are a way of defining abstract ideas that group together
06:15 some common properties and functionality of real instances of that class,
06:21 but it's just abstract.
06:22 You can't actually instantiate that class.
06:24 That's a way for you to write your programs such that you can group together the
06:29 related pieces of functionality
06:30 but force people who want to use your classes to override them and make real
06:35 physical instances of them.
Collapse this transcript
Using sealed classes
00:00 The next somewhat advanced and somewhat esoteric subject we're going to look at
00:05 in advanced C# is sealed classes and methods.
00:08 Now sealed classes and methods are essentially the opposite of abstract classes.
00:13 Whereas abstract classes force you to derive a subclass in order to use them,
00:19 sealed classes actually prevent you from deriving from them.
00:22 So there is no way to make a subclass from a class that has been sealed.
00:27 It's also possible to mark individual methods in classes as being sealed, which
00:32 prevents them from being overwritten in some classes. But it is far more common
00:37 to seal entire classes than methods.
00:40 And the way that you create sealed class is by using the sealed keyword.
00:44 So if I define a class like this, I have a public class myClass.
00:47 If I wanted to seal this class, I'd just simply put the word sealed inside
00:51 myClass, and then at this point I can no longer create a subclass.
00:56 So before the sealed keyword was in there I can make my subclass off of myClass,
01:00 but now that the sealed keyword is in there, this is an error;
01:02 I can't derive from myClass anymore.
01:05 So let's actually see this in action.
01:07 I'm actually going to go over to my Snippets here in my SealedClasses example,
01:12 and I'm going to copy these lines of code right here, and I'll paste them in.
01:20 So here I have my class, and let me just take this guy out for a moment.
01:25 So I have a class called myExampleClass and I have my subclass which derives
01:31 from myExampleClass. And if I hit F6, you can see that everything works fine;
01:36 the Build succeeds.
01:37 Let's put the sealed keyword back in there. Save.
01:41 Now let's try to build. Oh!
01:42 We get an error, and it says that the subclass right here cannot derive from
01:47 sealed type myExampleClass.
01:50 So by sealing this class, I prevent any further subclasses from being created.
01:55 You'll do this when you create classes that you don't want people messing with.
01:59 It's not a particularly common thing that you'll see a lot of.
02:02 The .NET Framework does this in a couple of places where it doesn't want you
02:05 messing with things like the Math class or other things.
02:09 Basically, if you create a class where you want it to behave a certain way and
02:13 you don't want authors to be able to override methods in your class, you can
02:17 create a sealed class.
02:19 So pretty quick simple example of how you can create classes in C# that cannot
02:23 be derived from or sub-classed.
Collapse this transcript
Defining structs
00:00 If you're coming from a language such as C or C++, you're probably familiar with
00:05 the notion of a struct.
00:08 If you're not, don't worry about it. I'll explain it here.
00:10 But structs essentially are similar to classes, but there are some important
00:15 differences that you're going to find.
00:17 First, structs don't support inheritance.
00:19 When you define a struct you define its members and its data types and so on,
00:24 but you can't derive one struct from another.
00:28 Structs are also value types, while classes are reference types. And if you
00:32 haven't yet watched the movie where I explain the difference between value
00:35 types and reference types, you should probably go watch that, because it'll make a lot more sense.
00:40 You also can't initialize the fields of a struct inside the definition.
00:44 So, for example, when you have a member variable inside of a struct, you can't
00:49 put a little equal sign after it and initialize it to a value.
00:52 You have to do that outside the definition.
00:54 Structs are usually used when you just want some small and simple data
00:58 structure to represent some piece of information and you don't want all the
01:02 overhead of a class.
01:04 Now structs can have properties and methods just like a class can.
01:08 You just have to remember that they're not really classes.
01:10 You can't have inheritance.
01:12 There are all kinds of things you can't do.
01:14 So let's take a look at real example.
01:15 Suppose we wanted to define a data type for representing a point on a
01:20 two-dimensional surface.
01:21 Well, we could do that with a class.
01:23 We'd say public class Point and we would have an X coordinate and we would have a Y coordinate.
01:27 We could also have a constructive function.
01:31 So when someone said new point, they could pass in a value for the X and the Y,
01:36 and that would set the X coordinate and Y coordinate to whatever the values are.
01:39 We could also just simply declare this to be a struct, in which case it's not a
01:44 class anymore, but everything still works.
01:46 We've got member variables, we have a constructor function, and everything is fine.
01:51 So let's go jump over to the code and exercise this.
01:55 Right, here I'm in my structs example, and I've got my Snippets scrolled down to
01:59 the part on Defining Structs.
02:01 So over here in the code I'm going to just copy these lines right here.
02:05 I am going to copy this structure definition, copy that, and I want to paste it over here.
02:13 So now I've got my struct which defines a point, and it's got these two private
02:19 number variables for X coordinate and for the Y coordinate.
02:23 Then you can also see that just with the class, I've got my constructor
02:27 function for the Point, and I've also got a property for setting X and a
02:32 property for setting Y.
02:34 So let's go back over here and copy some code.
02:37 So the first thing I am going to copy is this one right here.
02:41 I'll scroll down to my main function and paste that in. And what I'm doing here
02:45 is I'm creating a point, and the variable name is p1, and I'm creating new point
02:50 with an X coordinate and a Y coordinate both equal to 100.
02:55 From the outside looking in, this doesn't look any different than creating a class.
02:59 It's so happens that this is a struct.
03:02 So let's go back, get some more code.
03:07 I can also do the same thing this way.
03:09 Point p2 is s new point, and then I can set p2.x to 50 and p2.y, and this will
03:16 invoke the getters and setters the same way that I'd with the class.
03:20 Let's go ahead and hit F6, and you can see that the Build succeeded.
03:25 So if we scroll back up, you notice that pretty much the only thing is
03:28 different here is that I'm using the keyword struct instead of using the keyword
03:32 class right there on line 8.
03:34 So then you are probably asking yourself, okay, well, why would I want to use a
03:36 struct versus using a class?
03:38 Well, the main reason is because you've got some small data type.
03:41 In this case, I've got a point which only contains really two properties that I
03:44 really care about setting.
03:45 So if you got something small and you don't want all the overhead of a class, or
03:50 you don't have to worry about things like inheritance and overwriting stuff,
03:54 you can define a struct.
03:55 You can also use a struct when you don't want to have to worry about things
03:58 being passed by value or passed by reference.
04:02 Again, I explained that earlier in the section on value types versus reference types.
04:07 Structs are value types,
04:08 so you can pass these around as value types, and the values will be copied, and
04:12 you don't have to worry about references being changed without you knowing about it.
04:15 So anyway, that's a quick lesson on using structs.
04:18 You'll find that in many cases if you're define a small data structure, you
04:22 can use a struct in places where you would normally use a class.
Collapse this transcript
Using interfaces
00:00 The last subject that we are going cover in this section on building some more
00:04 advanced classes in C# is using interfaces.
00:09 Interfaces are a really neat little feature of C#.
00:12 They essentially provide a way for grouping a set of common behaviors in a
00:18 single place where more than one class can use them.
00:22 Now an interface is sort of like a class, but it provides a specification, or
00:28 you might think of it as a contract, rather than an implementation.
00:33 You can think of interfaces as an alternative to using abstract classes.
00:40 One of the nice things about interfaces is that classes can implement
00:44 multiple interfaces.
00:46 Now C# doesn't have the notion of multiple inheritance, like some other
00:50 languages do, but classes in C# can implement multiple interfaces.
00:57 One of the best ways of thinking about interfaces as opposed to classes is that
01:00 classes tend to be things, whereas interfaces tend to be behaviors.
01:07 So what I can do is I can group a whole bunch of functionality into an interface
01:11 and then that sort of becomes a contract.
01:14 If my class says that it implements an interface, then that class has to go
01:20 ahead and providing implementations for all of the functions that the
01:23 interface contains.
01:25 The nice thing about that is that my class can then advertise to the world,
01:30 hey, these are the interfaces that I implement and then in code that use my
01:35 class, the code can check my class to say, hey, are you able to implement this kind of interface?
01:41 And if it is, then the code that's using my interface can just say, hey, I know
01:45 that you know how to do this,
01:47 so I'm going to go ahead and call that method.
01:49 So let's take a look at how using interfaces makes grouping behavior more easy
01:55 to understand and implement.
01:56 So let's imagine I had a few classes.
01:58 I've got class A, B, and C. Now let's imagine further that these classes
02:03 all knew how to do something, like save their data out to some persistent storage place.
02:10 Well, they could all just implement a function name SaveData.
02:15 The problem is, without some interface to enforce this, class A might call it
02:20 SaveData, class B might call it something else, class C might call it something
02:24 else, but by grouping the notion of saving data into an interface called
02:30 ISaveable--and interfaces don't have to begin with a capital letter I, but it's
02:35 a nice convention that Microsoft has come up with for interfaces;
02:38 That way when you see it in a class definition you know that it's an
02:42 interface rather than class.
02:43 If I said, hey, I'm going to make an interface called ISaveable and anybody who
02:48 implements the interface called ISaveable has to have a function in their class
02:52 somewhere that's called SaveData.
02:55 So then I could do something like this.
02:57 I could say, you know what? Each one my classes, class A, B, and C, all implement
03:01 an interface called ISaveable.
03:03 Well, that enforces what's called a code contract.
03:07 So now everybody has to name their function that saves the data the same
03:12 thing, because they're all implementing from the same interface.
03:16 Now if I wanted to go a step further and say, you know what, not only do my
03:19 objects know how to save their data, they also know how to do something like
03:23 compress their data,
03:25 well, I could implement an interface called IShrinkable. And inside IShrinkable,
03:30 I might have a function called CompressedData.
03:34 Now notice in the interface there's no implementation of this function.
03:38 All that the interface says is, hey, if you implement me, you've got to have a
03:42 function named this. And the implementation is actually saved for the classes that
03:47 choose to implement it.
03:48 So if classes A, B, and C decided to implement both the ISaveable and
03:54 IShrinkable interfaces-- you separate them with a comma--
03:58 well, now each one of these classes has to have a function named SaveData, and
04:03 they all have to have a function named CompressData as well.
04:06 Now if one of these classes decided not to have shrinkable or saved or whatever,
04:10 they could choose not to implement the function. But if you say that you
04:14 implement an interface, you have to implement the members of that interface.
04:19 So let's take a look at this working in real code.
04:22 So here in the code I've got my UsingInterfaces example open, and I've got my
04:27 ExampleSnippets open and scrolled down to the Interfaces section.
04:31 So let's go ahead and copy over this line of code right here and paste
04:37 it into my program.
04:39 Now to declare an interface, you use the word interface and then you give
04:44 your interface a name.
04:45 It's kind of like declaring a class, although you'll notice that inside my
04:48 interface definition, I am not providing any implementation for these methods.
04:52 I am just saying that this interface contains two functions: one is called
04:55 SayHello, one is called SayGoodBye. And anybody who chooses to say that
04:59 they support the ITalkative interface has to provide implications for those two methods.
05:06 So let's go back over to the Snippets, and let's copy over this example
05:09 class right here called myExampleClass, and we'll paste that into my program over here.
05:16 So now I've declared a class called myExampleClass, and it says, yes, I am using
05:22 the ITalkative interface.
05:24 So here's the constructor for myExampleClass starting on line 16. And you'll see
05:28 that on lines 20 and lines 25, I've got implementations for the SayHello and
05:34 SayGoodBye functions.
05:36 Let's watch what happens really quickly if I take these out.
05:39 So I am going to cut this and save it and then build using F6.
05:44 You will see that if I try to build this, I'm now getting an error, why?
05:47 Because the errors say, hey, my example class does not implement interface
05:51 members SayGoodBye and does not implement interface member ITalkative.SayHello.
05:57 Well, that's because my class claims to implement ITalkative, but it's not
06:02 actually doing that.
06:03 There's no implications for the SayHello and SayGoodBye functions.
06:06 So let me just go ahead and paste those back in and save, and then we will hit
06:10 Build again using F6, and now everything is fine.
06:14 So let's go ahead and exercise this code, and we'll do that by copying these
06:20 lines of code right here and we'll paste them in there.
06:26 So now in my Main function I am declaring a variable, myEC, which is of type of
06:33 myExampleClass, and I am using the new operator to create that object. And once
06:37 I've created that object, I can say, all right, well, since you are a
06:41 myExampleClass and myExampleClass implements the ITalkative interface, I know
06:47 that you've got functions called SayHello and SayGoodBye.
06:50 So I can call each one of those.
06:52 So let's build and run.
06:54 We are going to hit F5 here, and you can see that sure enough, when we run the
06:58 program the functions for SayHello and SayGoodBye get executed and produce their output.
07:05 Let's go back to the Program here.
07:07 So once again, interfaces are a way of grouping together common points of functionality.
07:14 The interfaces are not things.
07:16 You don't instantiate an interface necessarily, although in certain esoteric
07:21 circumstances you can do that in C#, but we are not going to get to that in this course.
07:25 It's a little bit advanced.
07:26 What you do here is you simply create a class that says, I implement this
07:30 interface. And if you find yourself building classes that all have similar
07:34 behavior, it's probably a sign that you might want to make an interface that
07:38 groups that behavior into a common place and then have each one of those classes
07:43 implement that interface.
07:45 That way you can be sure that they're all getting the same behavior and that the
07:48 consumers of your class know that
07:50 that behavior can be counted on.
Collapse this transcript
8. Exceptions
Understanding exceptions
00:00 At some point in your C# coding experience you're going to have to learn how to
00:04 deal with error conditions.
00:06 Yes, I know, shock of all shocks.
00:08 Sometimes your code isn't going to work the way you thought that it would, or
00:11 something is going to happen to cause a problem in your program.
00:15 The way that we deal with that in C# and .NET is through the use of
00:19 exceptions, and that's what we are going to see how to use in this
00:22 particular section.
00:24 An exception is basically an error that happens during your program's execution,
00:29 whether it's because the user put in some data value that you weren't expecting
00:34 or the system runs out of memory or something else that happens.
00:38 So let's take a look at an example of an exception, and then we will learn about
00:43 how to handle exceptions in your code.
00:47 Let's imagine I have two variables, x and y.
00:49 They're both integers and I declared them as you see here.
00:53 Then I declare another variable called result, and I divide x by y. Well,
00:57 dividing 10 by 5, that's okay.
00:59 The result is 2. But what happens if I set y to 0, and then I try to divide x by
01:05 y, and oh, that's a problem: I'm dividing by 0.
01:09 What happens here is the .NET Framework raises what's called an exception.
01:14 In this case, it's a DivideByZero exception, and we'll learn about these terms
01:19 a little bit later, but the point is that an exception, just generically,
01:23 speaking is a problem in the code or somewhere in the system that you have to
01:29 anticipate and handle.
01:31 So before we go any further, let's learn about some exception terminology.
01:36 Exceptions are raised--or using object-oriented nomenclature,
01:42 they are thrown--when an error is encountered. When an exception happens the
01:48 normal flow of the program is interrupted, and the control is transferred to the
01:55 nearest exception handler.
01:57 You might say that the handler catches the exception.
01:59 So, the exception is thrown somewhere, and then it is caught somewhere else.
02:05 Now if there is no exception handler to process that exception and the exception
02:11 happens to be a fatal one, then the program just terminates with an error code.
02:16 Now not all exceptions are fatal, but some of them are and if the exception that
02:20 gets raised is fatal, then your program is going to stop working.
02:24 Now, exceptions don't just come from the .NET Framework.
02:27 You can build your own exceptions and then raise them yourself.
02:31 In other words, you throw your own exceptions using the throw instruction, and we
02:36 will see how to do that.
02:38 Let's take a look at an example of how exceptions are handled in code.
02:43 Now there are three main keywords you're going to have to learn about when
02:47 you're working with exceptions.
02:49 The first one is try.
02:51 Code that is placed inside the try block. Inside those curly braces is a bunch
02:57 of code that attempts to do something.
02:59 It doesn't matter how many lines you have in there. It could be one, it could five,
03:02 it could be 25,000; it doesn't matter.
03:04 The point is that inside that try block you're going to do a whole bunch of code.
03:08 You're going to assign a catch block.
03:12 Now this is actually optional, but you assign a catch block where you think an
03:16 exception might happen.
03:18 So if the code inside the try block might cause a problem then you assign a
03:22 catch block, and this is where exceptions are handled.
03:25 So if something goes wrong inside the code that's inside the try then the code
03:29 that's inside the catch is going to happen.
03:31 Then last, there is finally keyword.
03:34 And this code is always run.
03:36 It doesn't matter if things were great or things were bad,
03:39 if the code in the try section is completely just fine or if there was a problem
03:43 and the code in the catch section had to run, the code in the finally section is
03:47 always going to run.
03:49 So let's take a look at an example.
03:50 Suppose we had our example from earlier.
03:53 We have those two integers, one is 10, one is 0, and we have the result.
03:57 Well, if we try to divide x by y-- in this case we got 10 divide by 0--
04:01 that's going to cause an exception, in which case the program flow will be
04:06 transferred to the catch block. And here we are going to just write out, hey,
04:11 look at error happened, and we do a whole bunch of things in here. In
04:14 this case, we are writing out an error message, but there is other code that we
04:17 could've written here to try to handle the exception.
04:19 Maybe we could ask the user to try putting a different value, or we can just
04:22 try something else.
04:24 The point is that the code in the catch block is going run when the problem happens.
04:28 So let's take a look at some real code to see how to write this.
04:31 So I am in my UsingExceptions example, and in my Snippets you see I've scrolled
04:38 down to the Exceptions section.
04:41 So let me copy the setup code, and we'll paste it here into main. And we'll go
04:49 back to the sample, and we'll scroll down a little bit, and we'll take this entire
04:54 piece of try, catch, and finally, and we will paste that in as well.
05:01 So what I've done here is I've defined three different blocks of code:
05:05 one is called try, one is called catch, one is called finally.
05:09 Now if I run this code in its current state, I've got 10 being divided by 5
05:15 on line 18 right here, and that should just be fine.
05:19 What should happen is the Console.WriteLine for The result is, is going to be
05:23 executed, and it will show me the result.
05:24 So let's go ahead and run this and see what happens. And you can see that the
05:28 result is 2, and you can also see that a line is being written out there that
05:31 says, "Just proving that this code always runs."
05:34 And if we go back to the code, you'll see that
05:35 that's in the finally section down here.
05:37 Remember earlier I said that the code in the finally section always gets run;
05:41 it doesn't matter what happens in the try or the catch block.
05:44 So now let's change the code so that we have an error happen. So let's do this.
05:48 We are going to change y to 0.
05:51 So now we are going to 10 divided by 0, and that's going to cause a problem.
05:56 So we are going to get to line 18.
05:57 We are going to try to divide 10 by 0, and an exception is going to happen.
06:01 What that means that the code at line 19, this Console.WriteLine statement, is
06:06 never going to get run.
06:08 What's going to happen is the code is going to be transferred, the program flow
06:12 is going to be interrupted, and we are going to jump down here into this catch
06:15 block where this line of code, the An error occurred!
06:19 Better check the code line, is going to be run.
06:21 So now let's try this.
06:24 You can see that what happened was we tried to divide 10 by 0, which is a math
06:28 error, and you can see the Console. WriteLine inside the catch block is writing
06:33 out An error occurred!
06:34 Better check the code. And also we can see that the code in the finally block
06:39 always runs, because that Console.WriteLine also got executed.
06:44 So that's a quick introduction on how to use exceptions and as we move through
06:47 the rest of this section, we will learn more about how to create our own
06:51 exceptions and work with exceptions in a more advanced fashion.
Collapse this transcript
Introducing the Exception object
00:00 Exceptions are in fact objects, and in fact the exception object is defined and
00:06 derived from System.Exception.
00:09 That is the base class for all the exception objects in .NET. And the .NET
00:14 Framework actually defines a pretty large number of exception classes.
00:19 For proof of that, let's just quickly jump over to the MSDN web site and you can
00:22 see what I am talking about.
00:24 This is the Exception Class definition here on msdn.microsoft.com. And if you do
00:30 a search for System.Exception or if you go to the URL up there in the URL bar,
00:34 you'll see the exception class.
00:35 Now as we scroll down a little bit, you'll see that just like other objects,
00:40 there are constructors.
00:42 In this case, we've got four different constructors and there are some properties.
00:47 So these are the properties that exceptions make available.
00:50 There's Data and HelpLink and Message, and we'll explore some on these later on
00:53 as we through the exceptions, but what I really want to point out is as we
00:56 scroll all the way down, you'll see that System.Exception is the base class for a
01:02 pretty large number of exceptions throughout .NET.
01:05 Look at how large this list is.
01:07 This isn't even a complete list.
01:08 This is a list of a lot of the exceptions that descend directly from
01:12 System.Exception, but the one that we're most interested in is right here,
01:17 System.ApplicationException.
01:19 This is probably one of the most common exceptions that you will come in contact
01:23 with as a C# developer. And in fact, I've opened that window right over here.
01:28 So this is the ApplicationException class, and this class encapsulates all the
01:33 exceptions that are thrown when non-fatal application errors happen.
01:38 So once again, we can scroll down.
01:41 You can see that there is Properties, and there are all kinds of ways you can
01:44 create application exceptions. But once again we get down to the Instance
01:48 Hierarchy or the Inheritance Hierarchy.
01:50 You can see that a lot of other exceptions happen to descend from
01:54 ApplicationException. And this is true throughout .NET.
01:57 You've got exceptions that are descendents of other exceptions. And you might be
02:02 wondering, well, with all these different types of exceptions is it possible to
02:07 write catch handlers that only catch certain kinds of exceptions?
02:12 So to catch specific exceptions, you can put inside parentheses for each one of
02:16 the catch handlers the kind of exception that you're looking for.
02:20 So in the case that you see here, I've got a try block where I'm going to try a
02:25 whole bunch of code and then I have several catch handlers all in a row.
02:29 So I've got a catch handler for an exception that's DivideByZero.
02:32 I've got a catch handler for ArithmeticException.
02:34 I've got a catch handler in case we run OutOfMemory.
02:37 There are all kinds of stuff that I can put here, and I can put a generic catch
02:41 at the bottom of all these too that catches exceptions that don't get caught by these.
02:45 So let's jump over to the code and see how we can handle catching specific
02:50 types of exceptions.
02:51 So here we are in the example.
02:52 This is the ExceptionObject example.
02:54 I've got my program file open, and down in the Snippets I scroll to the
02:57 Exception Object section.
02:59 So let's go ahead and copy the set of code, and we'll paste that it into Main.
03:04 All right, now let's copy the try and catch, all the way down to the finally,
03:10 okay, and we'll paste that in.
03:13 You know what? Since we already know that the finally always runs, I am just
03:17 going to comment this line out.
03:18 We don't really need it for this example.
03:20 So let's comment it out.
03:22 All right, so this is pretty much the same example as I showed previously.
03:26 We've got two numbers.
03:27 We've got x here which is 10.
03:28 We've got y which is 0.
03:30 We have an integer for holding the result. And you can see here that we are
03:33 going to try to divide by zero.
03:35 The only difference from the previous example is that here I am now catching a
03:39 DivideByZeroException, and this is an arithmetic exception. And since I know that
03:46 it's a DivideByZeroException I can say, hey, you tried to divide by zero.
03:52 I can also write out members of the exception object that's passed in.
03:57 So when you catch a specific exception, you get an argument;
04:00 in this case I've named it e, but you can name it whatever you want to.
04:03 This will be passed into your catch handler, and this is the exception object
04:07 that caused the exception.
04:09 So we can do things like introspect that object and see things like what the
04:13 message that goes along with it is and so on and so forth.
04:16 So let's save this and let's build. Build succeeded.
04:20 All right, let's go ahead and run it and try to divide by 0 and see what happens.
04:24 Sure enough, you can see that You try to divide by zero.
04:27 Now that first sentence there, "Whoops!
04:28 You tried to divide by zero!"
04:30 is what I'm writing out, and the "Attempted to divide by zero!"
04:33 string is being written out from the message property of the exception object.
04:38 All right, let's go back to the code, and let's try something else.
04:43 Let's copy this catch handler and paste it down here.
04:47 Now what I am going to do is instead of looking for a
04:51 System.DivideByZeroException, I'm going to look for an ArithmeticException.
04:55 So I am going to hit dot and scroll down here, and I've got an
05:01 ArithmeticException right here.
05:03 So now I'm going to save, and I am going to build, and you can see that the build
05:08 succeeded. And what I am going to do is run this.
05:13 Now because I have the DivideByZero handler already in place, that's the first
05:17 one it's going to jump to.
05:19 The exception is going to jump to the first catch handler that makes the most sense.
05:22 So even though this is an ArithmeticException, it's going to jump to the
05:26 DivideByZero version, because that's more specific to the kind of exception I am seeing.
05:31 Let's try something else.
05:33 Let's take the ArithmeticException and cut it and put it in front of the
05:37 DivideByZeroException.
05:39 Now you'll notice that when I do that I get a little red squiggle on the
05:41 DivideByZeroException.
05:44 Let's see what that error is saying. It says, "Error:
05:48 A previous catch clause already catches all exceptions of this or of a super type."
05:54 What this basically means is because DivideByZeroException is a subclass of the
06:01 ArithmeticException object, this is never going to be called.
06:05 What's going to happen is a DivideByZeroException is going be thrown, but since
06:10 it's a subclass of this guy right here, this catch block is going to catch all
06:15 the math problems that might come up, including DivideByZero. And since it
06:20 occurs first, this code will never get executed.
06:23 So the C# compiler is catching that situation for me and saying, hey, you sure
06:28 you want to do this?
06:29 Why would you put in a catch handler that's never going to be called? So let's do this.
06:33 Let's take that WriteLine out, cut that line.
06:36 Let's put that in there instead. Let's see what the message is for
06:39 ArithmeticException, and let's just take out the DivideByZeroException.
06:43 So now I am catching the more general case.
06:46 I'm catching the ArithmeticException now, not just specifically the
06:49 DivideByZero, although DivideByZero is an ArithmeticException.
06:54 So let's run this, and you can see that we're getting the same message in this case.
06:58 So even though we got an ArithmeticException, it knows specifically what
07:01 happened, and the message in this case is an "Attempted to divide by zero."
07:05 So by using the ExceptionObject, your code can look for and catch specific
07:10 exceptions. And if you don't want to catch a specific exception, you can use the
07:15 catch handler. That just catches any exception that comes its way.
07:19 This is way for your code to be on the lookout for specific kinds of exceptions
07:23 so that it can take corrective action and try to prevent the user from having a
07:26 bad experience while using a program.
Collapse this transcript
Creating your own exceptions
00:00 Now I mentioned earlier that exceptions don't just simply come from .NET;
00:04 you can create your own custom exceptions--and in this movie we are going to
00:08 see how to do that.
00:09 Essentially, by sub-classing the exception object from the system namespace you
00:15 can create your own exceptions.
00:17 And then when you're ready to raise an exception, you use the throw instruction.
00:22 So for example, you can do things like throw a new System.Exception, or you can
00:27 throw a new MyCustomException.
00:28 You have to have the new in there because you've got to create the exception object
00:33 that you are going to throw, and then the throw keyword will cause the exception
00:36 to be thrown, and then the catch mechanism will go into effect.
00:41 So let's go over to some live code to see how we define our own exceptions and
00:45 then throw and catch them.
00:47 So I have my Custom Exceptions example here, and here is my Snippets. I've
00:51 scrolled down so they are creating exceptions section.
00:54 What I am going to first is just scroll down here and I am going to copy some of
00:58 the setup code, copy this, and I am going to paste this in my program. And then
01:05 I'm going to go back and I am going to ignore the catch section for a moment;
01:08 I'm just going to get the finally section, put that in here.
01:12 Now one of the first things you realize is that you don't actually need to have
01:16 a catch section at all.
01:17 You can just have try and finally if you want to.
01:20 So what I've got here is some code. I've got a string variable called the name,
01:24 and then in my try block I've got a function called getName.
01:28 Well, actually, I haven't defined it yet. That's why there is a little squiggle there.
01:31 But the getName function is going to ask the user to input a name, and it's
01:35 going to return it in the form of a string. And then I've got code on line 17
01:40 which simply writes out "Hello" and then whatever the name that you put in. And
01:44 then in the finally block, which remember always runs, we have a string that says, "Have a nice day!"
01:48 So let's go back to the snippets and get that getName function. And what I am
01:53 going to do is get this right here, copy that, and I am going to paste that
01:59 function in right up here. And for the moment I am going to just take this part out of it.
02:05 So what we are going to do in getName is use the Console.ReadLine function to
02:10 read a string, and then we are going to return that string.
02:14 So let's go ahead and run the code that we have and see how well it works.
02:18 So I am going to just build. It ran.
02:21 So now it's waiting for me to enter a name, and I am just going to type in the name scott.
02:26 It says, "Hello scott. Have a nice day!"
02:27 Great, okay everything is working fine.
02:29 Let's suppose we wanted to catch a certain name though and have that cause an exception.
02:35 So let's go back to the getName function, and what we are going to do is we are
02:41 going to say you know, if the string that was entered equals Joe, we're not going
02:45 to allow the word Joe to be put in.
02:47 So we are going to throw an exception called the NoJoesException.
02:50 Now we have to define the NoJoesException, which you see right here on line 14.
02:56 So let's go back to the Snippets and scroll up.
03:00 Here we have our definition for the NoJoesException.
03:03 Let's copy that, and we'll paste it in. And it's a class,
03:07 so I am going to paste it outside my program class.
03:10 So you can see on line 8, I've got a definition here for public class
03:14 NoJoesException, and there's the colon, which means it inherits from the exception
03:19 class, which is contained in the system namespace.
03:22 And remember, since I'm using the system namespace up here, I don't have to write
03:26 out System.Exception.
03:27 I can just use the word exception here.
03:29 So inside my NoJoesException, I've got my constructor, and my constructor is a
03:34 public NoJoesException constructor. And what I'm doing here is I'm calling the
03:40 base exception constructor with a string.
03:44 So before I go any further, let's just jump back over to the MSDN documentation
03:48 to see what the system exception looks like.
03:52 So here we are, in the documentation for the exception class.
03:55 Let's scroll down, and you can see that there are four different ways I can
03:59 construct an exception class.
04:02 There is a constructor that takes no arguments.
04:05 There is a constructor that takes an argument that's a string, and it says
04:08 here, "Initializes a new instance of the exception class where they specified error message."
04:14 Well, that sounds pretty much like the one I want. Let's just make sure.
04:18 Next one is exception with serialization and info and streaming context,
04:22 whatever that is, because it's obviously wrong.
04:24 And there's the exception here with a specified error message and a reference to
04:28 the inner exception. Okay, that's pretty advanced. I am not going to use that one.
04:32 Looks like number two is the one I want.
04:34 So I have to initialize a new instance of the exception class with the
04:37 specified error message.
04:39 Okay, that sounds great. Let's go back to the code.
04:41 Well, the way that I do that in C#--
04:43 well, there is a couple of ways I can do it.
04:45 First, I am just going to call the base-level constructor with the string here.
04:49 Now you might be wondering, why am I not just simply inside my constructor doing
04:53 something like this?
04:54 this.Message = No Joes allowed.
05:00 I am going to save that and I am going to build. Wait, we've got an error.
05:04 It says, "Property or indexer System.Exception. Message cannot be assigned to--it is read only."
05:10 Oh! So I can't actually make an assignment to that.
05:13 Looks like the only way to do it in this case is through the constructor. Okay,
05:17 well, I guess I won't do that then.
05:20 So it looks like this base method is the only way to do that.
05:22 So I'm passing in an error message to initialize the exception with "We don't
05:25 allow No Joes in here!"
05:27 However, I can give the user some help . And there is a field, or a property in
05:33 this case, called HelpLink. Again let's just jump over to the documentation very quick.
05:38 So if we scroll down, you'll see there is a property called HelpLink, and it
05:42 says, "Gets or sets a link to the help file associated with this exception." Oh cool!
05:48 Okay, so I can tell the user what to do in case an exception like this happens.
05:53 Let's go back to the code.
05:55 So what I am going to do is initialize my HelpLink here on line 13 to be a
05:59 link to my web site.
06:01 So back down here in the program--let me close this error window so we have more space--
06:06 you can see that when we get the input from the user, we are going to see if the
06:11 string is equal to Joe and if it is, we are going to throw the NoJoesException.
06:16 Now there's one more thing we have to do:
06:18 we have to implement the catch block for the NoJoesException. So let's go back
06:21 to the code, and down here in the Snippets we've got my catch handler.
06:26 I am going to copy that,
06:28 go back over here, and in between try and the finally, I am going to paste that in.
06:31 So you can see here what I am doing is I'm going to catch specifically a
06:36 NoJoesException, and I've named the variable nje.
06:40 So what I am going to do is write out the message, which is what I initialized
06:44 it with up in the constructor, and then another line I am going to write out "For
06:48 help, visit," and then I am going to write out the HelpLink field that's in my NoJoesException.
06:52 All right, it looks like everything is ready to go.
06:57 Let's hit F6. Okay, the build succeeded.
06:59 Let's hit F5 to run it.
07:01 All right, so I am going to type in "scott," "Hello scott Have a nice day!"
07:06 That seems to work okay.
07:07 Let's try it one more time with Joe. Oh!
07:10 Now, we get an error. It says "We don't allow no Joes in here! For help, visit:"
07:14 and then use the help link that I put into my help message for the user.
07:19 And of course in the finally block it says, "Have a nice day!"
07:22 All right, so this is how you can create your own exceptions, throw your own
07:26 exceptions, and use some of the fields provided by the base system exception
07:31 object to give your users some help and some detailed messages for when
07:34 those errors occur.
Collapse this transcript
Re-throwing exceptions
00:00 The last subject that we're going to examine in the area of exceptions is
00:05 that of rethrowing exceptions. And what that means is when an exception happens
00:10 inside your catch handler, you can do some processing, but if you handle the
00:15 exception, the exception pretty much stops with you.
00:18 You can keep it going by throwing it again, or hence the term 'rethrowing' the exception.
00:24 Now, why would you want to do this?
00:25 Let's take a look at an example, and hopefully that will make it a little bit more clear.
00:29 So here in my RethrowingExceptions example what I am going to do is go to my
00:32 Snippets and I am going to copy some code in over here.
00:37 So first, I am going to start with these lines down here, and I am going to copy
00:41 those and paste them into my Main function.
00:46 So I've got some code that calls a function called DoSomeMath, and it catches an
00:53 ArithmeticException and writes out a message that says hey!
00:56 Look, something went wrong in there.
00:58 You might want to be careful, or something like that. All right!
01:00 Now let's go back to the Snippets.
01:04 Let's copy the DoSomeMath function. All right and that's going to go up here.
01:11 So starting here on line 10 I've got my DoSomeMath function, and this is the
01:16 example that we've been working with up until now.
01:18 So what DoSomeMath is going to do is the same thing we've seen up until now,
01:22 which is try to divide by 0.
01:24 So here I've got my two variables on line 12.
01:26 I've got my result on line 13.
01:27 Here on line 15 I've got my try block, and I am going to try to divide 10 by 0.
01:33 Now, of course, what's going to happen is that's going to cause an exception.
01:37 So the catch handler will execute here, and I will write out something like hey!
01:43 You know, there is an error in DoSomeMath.
01:45 But I don't want the exception to just die here with me;
01:48 I want the exception to continue on and have other exception handlers do their
01:54 thing, because there might be some additional work that needs to be done.
01:58 So inside my catch handler, I am going to throw a new ArithmeticException.
02:04 Now, if I want to just rethrow the same exception, I wouldn't do this.
02:07 What I would do is I would just simply do this;
02:09 I would take out this new and just say throw.
02:12 What that means is, take the same exception that I am currently handling and
02:16 just rethrow it again. And that would be the same exception objects. Things
02:21 would just continue on as they were, and my catch handler would just be one and
02:25 a line of catch handlers.
02:27 But what I am going to do here is--let me put that code back in--I am actually
02:30 going to throw an entirely new exception called an ArithmeticException, because
02:35 remember, what I am catching here is a divide-by-0 exception.
02:38 So let's go ahead and save, and I am going to run this.
02:41 So you can see that what happened here is both catch handlers executed.
02:46 There's the catch handler inside the DoSomeMath function, and then there was the
02:51 catch handler that was in my Main program.
02:54 So let's go back and take a look.
02:57 You can see that this catch handler executed and this catch handler executed.
03:02 If I didn't have this line of code in here--and let me just comment it out, now
03:07 let's try rerunning it again--
03:09 you can see that in that case, only my catch handler executed.
03:12 So the other catch handler doesn't get a chance to run. The exception just gets
03:17 handled and dies in the DoSomeMath function and doesn't get a chance to continue on.
03:22 So by rethrowing the exception, or in this case throwing the new one, we give the
03:27 other exception handler a chance to do its stuff.
03:30 So why would you do this?
03:31 Well, suppose you've got an exception handler whose job is to just log out
03:36 whenever a particular exception happens.
03:39 You don't want that catch handler to be the be-all and the end-all.
03:42 You just want to insert it in the handling process so that that way your log
03:46 file shows that an exception happened. And then once that exception handler is
03:49 done logging out whatever information it needs to log out, it can continue on and
03:54 rethrow that exception so that the other real exception handlers in the process
03:59 somewhere get a chance to do their work.
04:01 So let's take a look at what happens when I take out the new ArithmeticException.
04:07 And I am not going to change the catch section right here.
04:10 I am just going to leave it alone.
04:11 So I am going to run it, and you can see that now both catch handlers are being
04:15 handled again. And because a divide by 0 is an ArithmeticException, the other
04:21 exception handler is being executed.
04:23 So this is a really great way to segment out your catch handlers so that each one
04:28 does its own little piece of work and they don't interfere with each other and
04:32 they are able to pass the exception on down the chain so that all the exception
04:36 handlers have the chance to do whatever it is that they need to do.
04:39 Just make sure that the last exception handler in the line is the last exception
04:43 handler in the line.
04:44 It doesn't pass the error up through to the user.
04:47 At some point, the error needs to be handled and not shown to the user--well, at
04:51 least in most cases.
04:52 So you're going to want to make sure that at least one of your catch handlers is
04:55 where the exception eventually stops.
Collapse this transcript
9. File Management
Introducing streams and files
00:00 We've reached the point now where we've seen enough C# to start doing some real
00:04 stuff, and one of the more common "real stuffs" that you'll probably do when
00:09 working with C# is moving information into and out of files. And the .NET
00:14 Framework provides some really great utilities for working with files and
00:17 information in files, and that's what we're going to cover in this section.
00:21 We're going to start off with an introduction to streams and files.
00:26 So let's start talking about that right off.
00:28 When you want to move the data into or out of a file or across the network or
00:32 over the Internet or some block of memory or some other location, the data has
00:38 to be what's called streamed.
00:40 You can think of a stream as an analogue to its real-world counterpart.
00:44 Think of water moving between two bodies of water in the form of a stream
00:50 or river or whatever.
00:51 In this case, however, the stream data is a bunch of 1s and 0s that represent
00:57 the information of a file, and the body of water is called the backing store.
01:03 Now the backing store can be anything. It can be a file.
01:06 It can be someplace on the network.
01:10 It can be some place out over the Internet;
01:12 it doesn't really matter what it is.
01:13 The point is the backing store is where the information goes to or comes from.
01:19 Streams have certain properties:
01:20 they can be readable, they can be writable, or they can be both.
01:25 Streams can also be what's called seekable.
01:28 In other words, some kinds of streams have this notion where there is a position
01:32 that you can look at and modify.
01:35 Sometimes this is called a random access stream.
01:38 Streams descend from the System.IO.Stream abstract base class.
01:45 Now we're not going to work too deeply with streams themselves in this section;
01:49 we're going to stick to the higher-level classes and utilities for working with files.
01:53 But it's important to have an understanding of what they are, and it's useful to
01:57 have this background so that later on, when you want to go and work a little bit
02:00 more deeply with files, you'll understand what a stream is.
02:03 So at the top, we have the stream class and again, this is an abstract
02:06 base class. And we looked at abstract base classes a little bit earlier in the course;
02:10 if you haven't watched that section, you should go do that now.
02:13 This is a class that forces you to create a subclass in order to provide an implementation.
02:19 So these stream abstract base class provides a whole bunch of abstract, or
02:23 theoretical, things that streams need to be able to do, and then the real stream
02:27 classes you work with descend from streams, such as the FileStream.
02:31 This is a class for working with physical files on the disk.
02:35 There is also the MemoryStream, which is locations located somewhere in
02:39 the computer's memory.
02:40 There is the NetworkStream.
02:42 This is used to move information across the network.
02:45 So actually, let's take a quick look over at MSDN so you can see what the stream
02:49 base class looks like.
02:50 All right, so this is the stream class documentation here on msdn.microsoft.com.
02:55 You can see the URL up there in the browser if you want to go and look at it for yourself.
03:00 The stream class--let's just scroll through this--
03:02 you can see that there's a constructor which makes a new stream, and there
03:06 are some properties, things like CanRead, and CanSeek, CanTimeout, CanWrite,
03:10 that kind of thing.
03:11 And if we scroll down a little bit further, there are methods,
03:14 methods for reading and writing information, for copying information, so on and so forth.
03:18 These are all the base-level functionality features that a stream has to
03:23 provide to its users.
03:24 Now remember, this is an abstract base class, so you won't actually instantiate a stream class;
03:30 what you'll use is one of the subclasses. And if you continue scroll down,
03:34 you'll see that underneath the System IO Stream, there is a whole bunch of other streams.
03:38 There's BufferedStream, there is FileStream, there is MemoryStream, and here is
03:42 the NetworkStream I talked about earlier.
03:43 These are the actual stream classes that you will use.
03:46 But we're not going to cover that right now;
03:48 what I'm going to do is talk about the file and directory higher-level classes
03:52 that we're going to use in this section.
03:55 .NET provides a collection of useful classes for working with files and
04:00 directories, so let's go over those right now.
04:03 One is called the File class, and this provides a very simplified high-level set
04:07 of functions for working with files.
04:09 In fact, this is mostly a static class where you call the methods of this class
04:14 using the file.notation. And if you haven't watched the section on classes, you
04:19 should go do that to understand what a static class is.
04:22 So file is probably the highest level example of working with files.
04:26 The next one down is the FileInfo class.
04:28 This provides more detailed lower-level functions that provide a little bit more
04:32 control over working with files.
04:34 Then there is the FileStream class, which I briefly talked about just a few moments ago.
04:38 This exposes a stream object around a file, which provides very detailed
04:42 control over how information gets written to and read from the file.
04:47 For directories, there is a sirectory class and this is sort of the analogue to
04:51 the file class. It provides very simple high-level functions for working with
04:55 directories, or folders. And then there's the DirectoryInfo class which provides
04:59 some more detailed lower-level functions that provide a bit more control over
05:04 working with directories.
05:05 So we're going to use some of these classes in the rest of the section to work
05:08 with files and directories.
Collapse this transcript
Working with existing files
00:00 Let's begin with something simple.
00:01 We are going to see how to work with existing files.
00:04 Now, the file class provides some features for working with files. And as I
00:08 mentioned earlier, most of the methods in this class are static.
00:11 You call them directly on the file object. And if you're not familiar with
00:15 static classes, you should go back and watch the section on classes to find out
00:19 what a static class is.
00:21 So the file object provides some really simple functions.
00:24 I am going to go over some of them here, not all of them, because it's quite a few.
00:27 But, for example, there is an exists method that checks to see if a file at a
00:31 given path exists or not and if a file does not exist, you can call a method
00:36 called create, which, surprisingly, creates the file at the specified path.
00:40 There are also functions for copying and moving and deleting files.
00:45 There is File.Copy, which copies a file to another location.
00:48 There is a Move function, which as the name indicates, moves a file, and there is a
00:53 delete function which deletes a file at a specified path.
00:57 So let's jump over to the code and exercise some of these functions and see how they work.
01:02 Okay, so I'm here in my existing project with my program file open, and here is
01:09 my Snippets. And I've scrolled down to the Existing Files section.
01:13 So let's begin by just checking to see if a file exists. And what I am going
01:18 to do is use a couple of other utilities to get a path to a special location
01:24 here on my computer.
01:25 So we're going be working with files in the My Documents folder, and I am going
01:29 to copy these first few lines right here.
01:34 So let's take a quick review of these lines of code before we do anything else.
01:38 So the first few lines, I have a Boolean variable called fileExists and I
01:42 initialize it to false because we are going to assume that the file doesn't exist.
01:46 Then we need to build up a file path, and the path just basically specifies where
01:51 on the computer the file exists or not.
01:54 So here I am going to say I have string called the path, and I am going to use a
01:59 special .NET class called the environment class.
02:03 The environment class gives me some utilities for working with the
02:06 Windows environment.
02:08 So I am going to ask the environment to get me a folder path, and the
02:11 GetFolderPath function can take a couple of different arguments.
02:14 I'm going to use the Environment.SpecialFolder.MyDocuments property, and this
02:20 will get me a path to the My Documents folder on this computer.
02:25 Now I could have just hard coded this by typing in C:\users\Joe Marini, so on and so forth.
02:33 That's really not a very good practice.
02:35 You don't want to hard code things into your applications if you can avoid it.
02:39 And windows, and in this case .NET, provides a bunch of utilities for working with
02:43 special document folders. Not just My Documents, but things like the temporary
02:47 directory and the trash or the recycle bin, that kind of thing.
02:51 So I am using this environment class right here to get the path to the My Documents folder.
02:56 So once I have the path to the My Documents folder, I'm then going to add on to
03:03 the end this string right here, which is testfile.txt. And recall I put the @
03:10 sign at the front of the string to prevent this \t here from being treated as a tab character.
03:17 I want the backlash to be treated as a path separator.
03:21 So at the end of all this I'll have a full path to a file named testfile.txt.
03:26 All right, let's go bring up my, My Documents folder, so
03:29 you can see what's in it.
03:31 Okay this is the My Documents folder, and you can see that right now there is
03:34 no file named test file.txt in here, so we're going to create it if it doesn't exist.
03:39 Let's go back to code.
03:41 We start off by using the File.Exists function here on line 17.
03:46 So we call File.Exists. That returns a Boolean result indicating whether the file
03:50 exists. And then I have an if statement and my if statement says if the file
03:55 exists. Then just write out to the console that the file exists.
03:59 Otherwise write out that the file does not exist and we are going to create it.
04:02 Then we call the File.Create function with the path, and this will create the file for us.
04:08 So let's go ahead and see what happens when we build and run this.
04:13 The code compiles and runs, and you can see that we're getting a message out to
04:16 the console that says, "The file does not exist. creating it."
04:19 So let's go back for our My Documents folder, and you can see now that the
04:23 test file has been created. And in this case, I am hiding known file extensions, so
04:29 you don't see that.txt on the end there, but it is there.
04:32 Okay, so test file has now been created. Let's go back and do some more work with it.
04:37 Let's go back to Snippets, and we'll copy this over, copy, and we'll paste this in.
04:52 Okay, so I am going to comment out these last two lines, just for a moment.
04:57 So once we've determined that the file exists, we can then get some
05:00 information about it.
05:01 In this particular section of code here I'm saying if the file exists then let's
05:06 figure out when it was created. And we are going to use the Files.GetCreationTime
05:11 method and the GetLastAccessTime method for the file, and we passed in the file
05:17 path both times to get information about the file.
05:20 And this will tell us when the file was created and when it was last accessed.
05:23 Okay, so now when I run the program again the file already exists,
05:28 so this part of the If statement should execute and we shouldn't have to re-create it.
05:32 So I am going to save, and I am going to run, and sure
05:36 enough, you can see that I am getting the message, "The file exists."
05:39 So we didn't have to re-create it, and you can see it was created on such and
05:42 such a date at such and such a time, and it was last accessed on such and such a
05:46 date and such and such a time.
05:48 Let's finish up our exercise by moving the file to a new location.
05:51 So I am going to hit return and exit on that.
05:53 Now I am going to uncomment these last two lines here, and we are going to move
05:57 the file somewhere else using the File.Move function.
06:01 And what we are going to do is move the file from its existing path--that's the
06:05 first argument--to the path, but we are just going to give it a new name.
06:09 So it's going to stay in the same folder, but it's going to be renamed to newfile.txt.
06:14 So we are going to save, and we are going to run, and you can see that we are
06:20 still getting the original message that it exists and the creation and access times.
06:24 And now we are moving the file.
06:26 So let's go back to the My Documents folder, and you can see, that test file is no longer there.
06:31 It is now called newfile.
06:33 So you can use these functions to operate on files that are existing or create
06:37 new ones on your file system.
06:40 And if you feel like getting a little bit more advanced, go take a look at the
06:42 file class. There is a whole bunch of other useful methods in there that you can
06:46 experiment with for working with existing files.
Collapse this transcript
Working with directory and disk information
00:00 As you might have guessed, just as there are ways for working with existing
00:03 files, there are ways to work with existing directories. And whether you called
00:07 them directories or folders, it doesn't really matter; they're the same thing.
00:11 But in the .NET Framework the class is called a directory.
00:15 Now working with directories is pretty similar to working with files, except that
00:20 directories can also contain other files and directories, whereas files just
00:25 contain information.
00:26 But there are classes for working with directories.
00:28 There is of course the Directory.Exists function which tells you whether a
00:32 directory exist or not.
00:33 You can also create and delete directories the same way you can with files.
00:38 You can figure out what the current directory is for the application.
00:41 This is the directory that the application is currently looking at, what it
00:45 thinks is the current one, where information will be written to or read from.
00:50 And just like in the other directories, they contain other things. You can get the
00:54 files and get the directories that are contained within a directory. And just
00:58 like files, you can move directories around.
01:00 So let's jump over to the code and exercise some of these functions so we
01:04 can see how they work.
01:05 Here I am in my ExistingDir project, and once again I've got my Snippets file open.
01:10 So I've scrolled it down to the Existing Directories part, and I'm going to just
01:15 copy these first few lines right here.
01:21 So this example, so far, isn't too different than the example we saw for the files case.
01:27 Right here at the top, I've got the string variable called the path, which I'm
01:31 using to figure out where the MyDocuments folder is.
01:35 Once again, I'm using the Special Environment class, and I'm calling the
01:40 GetFolderPath, which will tell me where the MyDocuments folder is. And just to
01:46 show you there are lots of features on here, I'm going to just hit little
01:49 dot here on special folder, and you can see there is a whole bunch of special
01:53 folder I can get paths to.
01:54 There is the Admintools.
01:55 There is CommonDocuments.
01:56 There's things like Music and Pictures.
01:59 There's the Startup directory.
02:01 There is the Desktop.
02:02 There is a whole bunch of special paths that you can get access to.
02:06 I'm just going to go ahead and leave it as MyDocuments.
02:08 This will get me the path to the MyDocuments folder.
02:11 Then we're going to call the Directory.Exists function right here on line 1,6 to
02:16 see if that directory actually exists or not.
02:19 Since it's the MyDocuments folder, I'm pretty sure it's going to exist.
02:24 So we have an if clause here that says if the directory exists then write out to
02:29 the console that it does; otherwise write out that it doesn't.
02:32 So this is a pretty good place to start.
02:34 Just go ahead and save and run this in its current form.
02:38 And you can see that the result is that the directory exists. So far so good.
02:42 Let's continue on.
02:44 Let's go back to the Snippets and get some more code.
02:47 What we're going to do now is use the GetFiles function on the directory class
02:53 to write out the names of the files that are in that directory.
02:56 So we are going to copy, and we are going to paste that down here.
03:05 So let's save, and let's take look.
03:07 So the GetFiles function that you see here on line 24 returns a string array,
03:13 which is why I'm declaring this string array variable called files, which will
03:18 hold the results of the GetFiles function. And I pass in the path which is now
03:24 the MyDocuments folder.
03:25 Then below that I'm using our newly discovered foreach loop construct, and so I'm
03:32 going to loop over all the strings in that files array.
03:35 So for each string--and I'm going to call each one of that S--that's in the files array,
03:40 I'm going to write out to the console I found a file plus whatever the file
03:44 name is right here.
03:46 Now I could use the Formatting String function, but I just chose not to
03:49 for simplicity here.
03:50 So let's go ahead and build this, and we can see the build succeeded, and let's run it.
03:54 It looks like we found a couple of files in there.
03:57 We've got a couple of contents of the directory,
04:00 so that seems to be working.
04:02 Let's hit Return and go back to the code. Let's move on.
04:08 Now we are going to do a little bit of extra credit.
04:10 It turns out that there is a class called Drive Info, and I'm going to leave that
04:15 up to you as an exercise to go onto MSDN and look up this class to see what it
04:20 does. But I'm just going to do a really quick simple experiment here. I want
04:23 to copy the code, and then we'll explain what it does.
04:28 So just like you can work with files and directories, you can also work with
04:33 disks or other storage devices that are attached to your computer.
04:38 So what we're going to do here is get information about each one of the disk
04:41 drives on the computer, as long as it is a fixed drive. You'll notice that there are
04:47 different kinds of drives when you look up information about this class.
04:51 There are things like removable drives and so on and so forth.
04:53 So what we're going to do is write out that we're getting the drive information.
04:57 You can see that up here on line 32.
04:58 Then we're going to call here on line 33 the GetDrives function, and as a
05:05 shorthand we're just going to loop this inside a foreach loop.
05:08 So we're going to get each DriveInfo, because the GetDrives function comes back
05:14 with an array of DriveInfo structures.
05:17 So we're going to say for each DriveInfo D which is in the array that comes
05:22 back from GetDrives,
05:24 we're going to execute the code in this loop. And we're going to ask the
05:27 DriveInfo if the DriveType is equal to the DriveType.Fixed.
05:33 Like I said earlier, there are all kinds of examples here.
05:36 If I hit the period, you'll see that there is CDRom and Fixed and Network and
05:39 so on and so forth.
05:40 So we're just going to stick with Fixed, and we're going to write out the
05:43 information about each one of the fixed drives.
05:44 We'll write out its name, how much free space it has, what type it is, and so on.
05:49 So let's go ahead and save. Let's build.
05:51 It works, and now let's run it.
05:55 You can see now that we're writing out some information about not just the
05:58 files, but the drive information.
05:59 So we seem to have too fixed drives: one is called C:, one is called D:.
06:04 They're both fixed and they both have a lot of free space. That's how many bytes
06:08 are free in each one.
06:09 That's a quick example for working with directories and drives.
06:12 Now let's move on and look at some more file information.
Collapse this transcript
Using the Path class
00:00 One of the things that you're going to find yourself doing over and over again
00:03 as you work with files and directories and so on is that there's a lot of
00:07 information contained in paths, and you'll find yourself having to parse out
00:12 paths to extract file names, or just the path portion, or just the directory name,
00:17 or just the file name without the extension. And it turns out that the .NET
00:21 Framework provides a helper class called the path class that makes a lot of
00:25 these operations really simple.
00:27 So if you look at the way a typical path is built, it has a predictable
00:32 structure. And here's a sample path, and this may look different based upon the
00:37 files you work with, but this is just a sample.
00:39 So right at the front, there's the drive name, and it can be a letter followed by
00:44 a colon, followed by a backslash.
00:46 The drive name is the root level of the path, and it's the disk or the
00:51 location where a file is.
00:53 That's followed by the path.
00:55 This is the directory structure that specifies where a file is located. And this
01:00 is usually a nested set of directories, or folders, whatever you want to call, them
01:05 that leads down to the actual file name itself, which is right here,
01:09 somefilename, which is usually followed by an extension.
01:14 Now not all file systems do this, but some do.
01:17 Windows, for example, does, and this also works on the Mac.
01:20 But since we're working here on Windows, we can pretty much be sure that most
01:24 files will have extensions.
01:25 So file extensions are usually a period followed by some amount of characters,
01:30 usually between three and five.
01:32 So let's take a look at the path helper class to see how we can use it to
01:37 help us work with paths.
01:40 In the Path Operations example, I've got my snippets file open, and I've scrolled
01:45 down to the Path Operations section. So let's go ahead and copy over the setup
01:50 code, and we'll paste it over here.
01:55 Now I'm going to be working with a path to the testfile.txt file which we
02:02 created in an earlier example.
02:03 So if you have deleted it, you can go just make a new file called testfile.txt
02:08 in the My Documents folder. And you can see here that I'm using the code I used
02:13 in the earlier examples to get a path to the MyDocument special folder here on my Windows system.
02:19 Let me make this a little bit wider, so you can see that.
02:21 So right here, this is the MyDocuments path, and then we're going to put the
02:25 testfile.txt on the end of it.
02:27 So this is the example file we'll be working with.
02:29 If you don't have that already on your My Documents folder, you should just go make one.
02:33 So what we're going to is save this, and I'm going to go back over to the Snippets and
02:37 start copying over some of the exercises.
02:40 So I'll start with this one, and I'll copy that and paste this over.
02:47 So the first thing we're going to do is extract the directory name from the
02:52 path information, and to do that, we're going to use the Path class. And again
02:56 this is a static class.
02:57 You are going to call most of these methods using the class name followed by
03:01 the function name--in this case it's GetDirectoryName. And you pass in thePath as the argument.
03:07 This will parse out all of the information that's not relative to the directory
03:11 name and then just return the name of the directory that's inside the path.
03:15 So let's save this, and let's hit F5 to run it.
03:21 And you can see here that in this case the directory name is C:\Users\Joe
03:25 Marini\Documents, and it's parsed out the part that is the file name.
03:29 It's giving me just the directory name. And you can see here it is a
03:32 fully qualified path.
03:34 What I mean by fully qualified is it starts at the drive, which is the root, and
03:38 goes all the way down to where the document is.
03:42 So it gives me the entire, full directory structure that leads to that file.
03:46 Okay, let's go back and do some more experiments.
03:50 The next one I'm going to do is get the example that extracts just the file
03:55 name, so this is the opposite of the example we just showed.
03:57 In this case, we're only going to ask for the file name. And in this case, we're
04:00 going to use the GetFileName function on the path class, and this will give me
04:04 the name of the file without the directory information.
04:07 So I'll save that and run it, and you can see here that now I've got the
04:13 directory name, and the file name is testfile.txt.
04:17 So that function parsed out all the information that was not relative to the
04:21 file name and just returned the full file name with the extension.
04:24 Okay, let's go back, and let's do another one.
04:30 We'll copy and paste this one.
04:31 In this case, we're going to get the file name without the extension.
04:36 So let's scroll down here.
04:38 You can see that the path class provides a function called
04:41 GetFileNameWithoutExtension, and again, it takes thePath as an argument.
04:46 So we'll save and we'll run, and in that case, I get just the file name without
04:52 the directory and without the three-letter extension on the end.
04:55 Okay, let's go back.
04:57 It looks like we have one more.
04:59 We're going to copy and we're going to paste and paste this in, okay.
05:07 In this case, the path class is going to give us a random file name.
05:13 Now you might be asking yourself, why would I ever need to get a random file name?
05:17 What this is going to do is ask .NET to generate some random file name for us.
05:22 It's going to consists of a certain number of characters, followed by a period,
05:25 followed by three characters.
05:28 The reason you might want to do this is because sometimes in your applications
05:30 you'll need to save out temporary data and rather than going through the
05:34 exercise of trying to figure out what file name you can come up with that
05:38 doesn't conflict with a file that's already existing in a particular directory,
05:43 you can just call GetRandomFileName.
05:46 .NET will then figure out what file name you can use that doesn't conflict with
05:50 a file that's already in the directory.
05:52 You can then use that file to save out whatever temporary data you have and then
05:56 get rid of the file. And this is the nice little utility to save you all the
05:59 trouble of having to figure out,
06:00 well, can I use this file name or can I use that file name, without conflicting
06:03 with an existing file.
06:05 So let's just go ahead in exercise and see what it does.
06:07 I going to run this, and you can see that the random file name for the current
06:12 path is this sequence of characters right here.
06:16 Now if I exit the program and run it again, you can see that it come up with
06:20 another set of characters here. And it will keep on doing that each time I run this.
06:24 So that's a nice handy little utility for creating random file names that you
06:29 know aren't going to conflict with existing file names in the current directory.
06:34 So that's a quick introduction to the path class.
06:36 I highly recommend you go look it up on MSDN and try some more examples on
06:40 your own.
Collapse this transcript
Reading and writing files
00:00 The last example that we're going to look at in this section is probably the
00:03 one you've been waiting for, and that is actually writing and reading data to and from files.
00:08 Now, there's lots of ways to do this in the .NET Framework.
00:11 The .NET Framework provides a whole bunch of ways for writing data to
00:14 and reading from files.
00:16 There's probably more ways to do this than there are ways to order sushi.
00:19 But we're only going to look at some of the more simple ways of doing this.
00:22 I mentioned earlier that we're not going to get deep into streams;
00:24 you can feel free to go do that as an extra credit exercise.
00:27 What we're going to look at is the higher level order functions for reading and writing data.
00:33 So for writing data, there are some really simple functions.
00:35 There's File.AppendAllText, which simply takes a bunch of text content and
00:40 appends it to the end of an existing file.
00:43 There's the WriteAllBytes and WriteAllLines, which, as their name implies, for
00:49 WriteAllBytes you can just give it an array of bytes; for WriteAllLines, you
00:53 give it an array of strings. They will write out the content to the file.
00:56 And then there's File.WriteAllText.
00:59 Now, unlike AppendAllText, WriteAllText will replace the existing contents of the file.
01:05 So if you want to just replace the content, use WriteAllText.
01:08 If you want to add to the existing content, use AppendAllText.
01:13 Not surprisingly, there are some counterparts for reading data.
01:16 There is ReadAllBytes, and as you might have guessed, this will read all the
01:21 content of a file as a bunch of binary bytes.
01:25 But for the purposes of our exercise, we're going to be working with text, so
01:29 we'll probably use things like ReadLines and ReadAllLines and ReadAllText.
01:33 This will actually read the contents of a file as text content.
01:38 So let's just jump over to the code and actually start exercising some of this,
01:42 so that you can see how it works. Okay.
01:44 In my ReadingWritingData example, I have got my Snippets opened, and I
01:48 have scrolled down to the Reading and Writing Files section.
01:51 So I am going to start off by copying over the setup code, which are these lines right here.
01:57 So I will copy those and paste them in.
02:00 I'll put them in my main function. All right!
02:03 So before we go any further, let's take a look at what's going on here.
02:07 So if you've been following the examples up until now, you're probably familiar
02:10 with the first line here on line 14.
02:12 This is the filePath.
02:14 We're going to be using the environment class to get the path to the
02:18 My Documents folder.
02:20 But we're going to be doing something a little bit different this time.
02:22 If you watched the section on the path helper class, which is previous,
02:26 you will probably notice that they are using a path helper section here.
02:31 Instead of using the backslash character hard coded into my examplefile.txt file
02:37 name, I am using the Path.DirectorySeparatorChar constant, which tells me what
02:44 the separate character for this file system happens to be.
02:47 Now, here on this version of Windows and .NET, it will be a backslash, but it
02:51 might be different based upon what platform you happen to be running on.
02:54 So I am going to just use this constant right here so that I don't have to hard
02:58 code a directory separator into my code, which is never a good idea.
03:04 So I am taking steps here to make my code work cross-platform. All right!
03:07 So now that we've got the path built up, we're going to see if the file exists.
03:13 And if you watched that particular example, you will know that we use the
03:16 File.Exists function do that, here on line 18.
03:20 So we'll see if the file does not exist, so we'll put that little not operator
03:25 right here in front of the File.Exists call.
03:29 So if the file does not exist then we're going to create it by using the
03:33 WriteAllText function.
03:35 So we'll have a string variable here on line 20, which will be the contents of
03:40 the file. And the content is going to be a string called, "This is a text file,"
03:43 And once again, I am using my environment class to figure out what the new line
03:48 character is for this particular platform.
03:50 So once again, rather than hard coding in a /r or /n, or whatever a state
03:55 sequence happens to be the NewLine character on this particular file system, I
04:00 will just use the NewLine constant for this particular environment.
04:04 Then I am going to write out the console that we're creating the file, and then
04:08 I'll use the File.WriteAllText method. And WriteAllText takes two arguments:
04:13 the first is the path to write to, the second is the text content that we are writing out.
04:18 So I am going to build this, and I am going to run it. And you can see that
04:25 the Creating the file... string got written out, because the file did not
04:28 exist in the My Documents folder. So now we've created it, and if you want to
04:33 go ahead and check your My Documents folder to see if it exists, you can go ahead and do that.
04:37 I am just going to keep on moving on here. All right!
04:41 So let's go back to the Snippets.
04:43 Now, let's use the AppendAllText method to add content to the file.
04:49 We'll copy, and we'll paste, and we'll save.
04:54 Okay, so I am going to build this, and now I am going to run it.
05:00 Okay, now you can see that I am adding content to the file.
05:04 Let's go back and look at the code and see what happened here.
05:07 The file already exists, so the if statement here on lines 18 through 23 did
05:12 not need to execute.
05:13 The file's content is getting appended,
05:16 so this line right here, Adding content to the file... got written out, then we
05:21 use the AppendAllText to add the added text string, which I am building up right
05:28 here into the file, and that writes the content out to the file.
05:32 So just to make sure that things are working okay, let's go ahead and open the
05:35 file up so we can look at the contents.
05:37 So here I am in my documents folder.
05:40 Let's open up examplefile, and you can see, here is, "This is a text file" and this
05:44 is "Text added to the file."
05:46 Well, that's great, but I would rather not have to open up Notepad to make sure
05:49 that the content is getting added correctly.
05:51 So let's see if we can read the contents and display the contents into the console.
05:54 All right, so back here in the code, let's scroll down. All right!
06:02 Now, we're going to read the contents of the file. So I am going to copy these
06:06 lines right here and back in my code,
06:11 I am going to paste them in.
06:13 So we're going to write out to the console that we are reading the file, and you
06:17 can see right here we're writing out that The current contents of the file are:,
06:21 and then it will separate a line, to separate the content.
06:23 Then we're going to use the ReadAllText static method on the file class to get
06:27 the current content.
06:28 The current content will come back as a string.
06:30 So we've got a string variable right here on line 35, which will hold the
06:34 results of the ReadAllText function on the filePath.
06:38 Once we have the current content, we will write out the current content to
06:42 the console, and then we'll put a little line separator to increase
06:46 readability right here.
06:47 So I am going to build. Okay, the build succeeds.
06:51 We run it, and you can see that we've now added content to the file and The
06:56 current contents of the file are:.
06:58 And we've got a couple of lines, "This is a text file," and then we've got "Text
07:01 added to the file" twice.
07:03 So I am going to hit Return.
07:04 I am going to run it one more time, because each time we run it, this line right
07:08 here, the "Text added to the file" is going to get added.
07:10 So I am going to run it again, and you can see that now that there are three;
07:14 and then I'll run it again and you can see that now there are four.
07:18 Okay, let's go back to the code.
07:21 One more thing I want to do here.
07:22 I want to show you how to read the contents of the lines of the file using the
07:27 ReadAllLines function.
07:29 I want to copy this, and I am going to paste it in over here.
07:34 This is just another way of reading the contents of the file, so I am going to
07:37 paste that in here. And for now, I am just going to comment out these lines,
07:42 and I am going to uncomment these lines, so that we can actually run the code.
07:52 So whereas the ReadAllText function on the file class will read all the content,
07:58 the ReadAllLines will read the lines and return an array of strings.
08:04 So ReadAllText comes back with one string; ReadAllLines comes back with an array
08:09 of strings, and that's this right here on line 40.
08:12 So I am declaring an array of strings-- that's this contents variable right
08:17 here. Then I call the ReadAllLines function, which will return an array, and
08:21 then here's our old friend the foreach function.
08:24 So I am going to loop over each string that is in the contents array, and I am
08:29 going to call each one of those strings the variable S. And inside my loop, I am
08:34 going to just write out whatever that S string is.
08:38 So let's build, and I am going to run, and you can see that we get the same
08:44 results, only this time, instead of reading the content as one long string, we
08:49 read the contents as an array of strings. All right!
08:54 That bring us to the close of this example and this chapter, so I highly
08:57 encourage you to go explore the file class and do some of your own experiments
09:01 working with reading and writing data to files.
Collapse this transcript
10. Some Advanced C#
Using variable parameter lists
00:00 Up until now we've been working with some of the more basic features of C#, and in
00:05 this section we're going to start looking at some of the more advanced features
00:08 of C# that were added in some of the more recent versions.
00:11 Now most of the stuff that you've seen so far you'll see in C# applications
00:16 all over the place,
00:17 but the ones that we're going to look at now are going to enable you to write
00:20 applications that are more advanced and have more concise code in them.
00:24 And we're going to start off by looking at something called variable parameter lists.
00:27 Variable parameter lists are useful because there's going to be times when you
00:31 want to create functions that take a number of arguments that you don't know in advance.
00:36 The way that you do this is by using the params keyword.
00:40 The params keyword allows you to define a parameter list for function that takes
00:44 a variable number of parameters, and it looks something like this.
00:49 Suppose I have a function that added a bunch of numbers together.
00:51 Now, I could add a whole bunch of numbers, but the problem is, without using
00:55 variable parameter list, I'd have to have a fixed number of parameters.
00:59 So for example, I could supply two integers, in this case, a and b.
01:03 But what if I wanted to add three integers or four integers or some
01:07 unknown number of integers?
01:08 Well, I could go the route of overloading methods, if you watched the movie on
01:13 that section, in which case, I would just define a whole bunch of addNumbers
01:18 functions and define a version of addNumbers that takes two arguments and then
01:22 one that takes three arguments and then one that takes arguments.
01:25 The problem is that gets really tedious really quickly and really bloats the
01:28 code. Or I could just simply use the params keyword and tell my function that it
01:34 takes an array of arguments.
01:36 So, for example, rather than just adding two numbers, I would do something like this.
01:41 And here I've used the params keyword and following the params keyword, I say int
01:47 with square brackets.
01:48 So this tells the C# compiler, hey, compiler, this function is going to take
01:52 an array of arguments.
01:54 And we don't know how long that array is going to be.
01:57 So the params keyword says, just be ready for a whole bunch of arguments.
02:01 Now once I've done that, I can rewrite the body of this function from just adding
02:05 two numbers to adding a whole bunch of numbers. And I'll use the foreach
02:09 construct to loop over each one of the integers in the nums argument that you
02:14 see there in the parameter list, and just keep a running total.
02:18 So let's jump over to the code and actually write this example and see it work.
02:22 Here in my variable params example, I've scrolled down to the Variable
02:26 Parameter Lists sections of my ExampleSnippets, and the first thing we're going to do
02:30 is copy over the function.
02:32 So this is the function that's going to add a whole bunch of numbers.
02:35 So I'll just copy this and go over to the program code, and I'm going to paste it in.
02:40 I'll paste it down here.
02:43 So now I have my addNumbers function, and you can see I'm using the params
02:46 keyword that takes an integer array of arguments.
02:51 So let's exercise this.
02:52 Let's go back up to the code. And I'm going to copy over this code here, which I'm
02:56 going to paste in the Main function.
03:00 So let's paste this in.
03:03 So let's take a look at what's happening here.
03:04 First, you'll notice that we have two different calls to addNumbers.
03:08 There is one here on line 14. There is one here on line 17.
03:11 The one on line 14 is passing in three arguments, 4, 6, and 8, and then the one
03:16 here on 17 is passing in a whole bunch of arguments.
03:18 So what's going to happen is each one of these calls to the addNumbers function
03:22 is going to generate an array of integers, and then inside my addNumbers, I'm
03:26 just going to loop over each one of the integers, add it to my running total,
03:30 and then return the total back to the caller, which will be stored in this
03:34 result variable right here.
03:36 So let's just build this and run it, and you can see that in the first case the
03:42 result is 18, and in the second case the result is 84.
03:45 So I've been able to now define a function that takes a variable number of
03:49 parameters so that I can write my code using this function and not know how many
03:54 arguments I'm going to have in advance.
03:56 Now there are a couple of things you need to keep in mind about the
03:58 parameters function.
03:59 One of the most important ones is that if you're going to use the params keyword,
04:03 that has to be the last argument to the function.
04:05 What I can't do is something like this.
04:09 You'll see that when I try to do that I get some errors, and if I mouse over it,
04:13 you'll see, "A parameter array must be the last parameter in a formal parameter list."
04:19 The reason for this is because since this is variable, the compiler has no way of
04:23 knowing how many arguments are in the array, and therefore, which argument goes
04:28 in the array and which integer is the last one.
04:30 So if I wanted to do something like this, I'd have to make sure that any other
04:36 arguments, whether they be strings or integers or objects, all of those have to
04:45 come before the params array.
04:48 So now we see that there is no error. Well, there is an error up here because I'm
04:51 not passing in the string integer object.
04:54 But anyway, that's how you use variable parameters in your functions.
04:59 So using the params keyword you can define functions that take a variable number
05:03 of parameters which greatly simplifies code that has to work on an unknown
05:08 number of arguments.
Collapse this transcript
Using function parameter modifiers
00:00 Earlier on in the course I talked about the difference between calling functions
00:04 and passing parameters by value and passing parameters by reference.
00:08 So if you haven't watched that movie, now is probably a good time to go watch
00:11 it, so you'll understand what's going on here, because I am going to be talking
00:13 about function parameter modifiers which allow you to change the way that
00:18 parameters are passed to and from functions.
00:22 So let's just take a quick recap to see how things normally work.
00:27 Suppose I had a function that takes an integer parameter, and it looks like
00:31 this, and inside that function, I have a piece of code that adds the number 10
00:36 to whatever that integer parameter was passed.
00:39 Now, if I call it from another function that looks like this, and I have an
00:42 integer named x and I initialize it to the value of 10, and then I call my
00:47 function, the code that's inside my function does not change the value of the x
00:53 variable in the test function down there below.
00:57 However, I can use a keyword in the parameter list for the function called ref.
01:03 This causes a parameter to be passed by reference, instead of having a copy of
01:08 its value passed in, which is what the normal case is in C#.
01:13 Now what I'd do here is I would declare my function as normal.
01:16 I'd have an integer parameter named param1, but I would put the ref keyword in front
01:21 of the type name--in this case integer.
01:24 This causes the param1 parameter to be passed by reference.
01:29 So now here I have my test function, and I've got my integer variable named x.
01:34 Now, when I call the function, I also have to put the ref keyword in front of
01:39 the parameter that I'm passing to the function.
01:42 When I do this param1 is now a reference to the x variable and not a copy of
01:49 its existing value.
01:51 This line of code here, param1 += 10, will in fact change the value of x down in
01:58 the calling function.
01:59 X will now be equal to 20 when this function returns.
02:04 The reason why I need the ref keyword in both places is so that it's really
02:07 clear what's going on in the code.
02:10 So you can deliberately do this when you want to be able to change the value of
02:13 parameters that are passed to functions.
02:16 So let's take a look at one more example.
02:19 There's the out keyword.
02:21 Now, normally functions return values through their return type, but the out
02:27 keyword allows a return value to be passed back via a parameter, and you would
02:33 use this in cases where you wanted a function to be able to pass back more than one result.
02:39 So let's take a look at an admittedly contrived example.
02:43 Suppose I had a function named SqrAndRoot, and SqrAndRoot takes a number as its
02:49 first parameter, and I want it to return both the square of that number and the
02:54 square root of that number.
02:56 I could pass in a parameter named sq, which would be the square, and I put the out
03:01 keyword in front of it.
03:03 I do the same thing for another parameter named sqrt, and I also put the out
03:08 keyword in front of that type named for that parameter.
03:12 Now, inside the body of the function, I would simply assign values to the square
03:17 and square root results.
03:19 So for sq I'd simply multiply num by itself, and that's the square of the number,
03:24 and then for sqrt I'm using the .NET Framework's math library to calculate the
03:29 square root of that number.
03:31 When I call this from a function, say, named test and I pass in the parameters,
03:36 you'll notice that I've to put the out keyword in front of the parameters
03:40 that I'm passing in.
03:41 So when I call SqrAndRoot, I pass in the first parameter, which is x. That's the
03:45 number I want to have the square and square root of.
03:48 Now when this function completes, theSquare and theRoot are going to have the
03:52 values that were calculated by the square and root function.
03:56 You notice I don't have to actually initialize those values, because those values
04:00 are going to be calculated for me by the function.
04:03 So I don't have to assign initial values to them.
04:06 Now, it's one thing to hear me yammer on about it;
04:08 let's actually go over to the code and actually watch it work.
04:10 Okay, so here I'm in my FuncParamModifiers project.
04:13 I've got my Snippets open to the code for this example.
04:17 So first, I'm going to copy this function, which is the SquareAndRoot function,
04:21 copy that and put it over in my code.
04:25 That's the function that we're going to call.
04:27 You can see I'm using the out keyword right here on line 10 to indicate to the
04:32 compiler that sq and sqrt are going to be out parameters.
04:37 I'm going to copy the code, going to call it with, and we'll put that down here
04:44 in the Main function.
04:45 Okay, I am going to put a line there.
04:47 So what we're starting off with here is a number,
04:50 in this case 9.0, and it's a double, and I've got variables named theSquare and
04:56 theRoot which are going to hold the results, and now I just simply call square and root.
05:00 I pass in 9 and I've got my out keyword in front of each one of the parameters
05:04 that are going to hold the output.
05:06 Then I've got Console.WriteLine call that says, hey!
05:09 The square of this number is this, and its square root is this, and I'm just
05:14 passing in those results to the WriteLine function.
05:17 So, everything looks good.
05:19 I hit F6, and it builds just fine.
05:22 Now let's run it, and you can see that the square of 9 is 81 and its square root is 3.
05:30 So it works just as we expected it to, and you can use the out keyword and the
05:34 ref keywords to change the way that parameters are passed to and from functions.
Collapse this transcript
Using optional and named function parameters
00:00 Okay, the next advanced C # feature we are going to take a look at are optional
00:04 and named parameters.
00:05 Now up until now when we've been calling functions with parameters we have been
00:08 supplying values for those parameters, because if we don't, then the C# compiler
00:13 complains that we left a parameter out of the function call.
00:16 Optional parameters allow you to define default values for parameters so that if
00:20 you don't feel like passing in a value for that parameter, you don't have to.
00:24 And the way that you do that looks a little bit like this.
00:27 So I can define a function, and you can see that I define the function normally
00:30 with two integer parameters. But I've got equals and then values after each one
00:35 of those parameters.
00:36 So here for my function, I don't have to supply values for a or for b, because
00:41 if I don't, then a will default to 0 and b will default to 1.
00:45 So, for example, it's just as valid for you call the function like this, where I
00:49 have got a just defaulting to 0 and b to 1, as it is to call it like this, where
00:54 a is now 10, but b retains its default value.
00:58 The other feature is named parameters.
01:00 Now up until the version of C#, I think it was 3.0, you had to call parameters in
01:05 the order in which they were declared in the function declaration; named
01:09 parameters, however, changed that.
01:11 Suppose, for example, that I have a function that looks like this.
01:14 I have got two integer arguments: one named a and one named b.
01:18 I can actually just simply call the function by passing in the name of the
01:22 parameter, a colon, and then the value, and it looks like this.
01:26 So if I wanted to call this function with parameters that are out of order, I
01:29 would simply say b:5 and a:3. And this would call the function normally.
01:35 And you notice I don't have to do anything special to the to the function declaration.
01:38 This just automatically works in C#.
01:40 So I can call the functions with the parameters that are out of order.
01:44 If I wanted to call the function otherwise, I could do it like this.
01:47 I can call the function with just the value 3, which is now a is 3 in that case,
01:52 and I'll put the name of b:7, although in this case I wouldn't have to do that.
01:57 Now notice that if you don't supply a named parameter, then they have to go first.
02:02 So, for example, if I wanted to this b:7 and then 3, that would cause an error,
02:07 because the C# compiler would say well, wait a second. You are not supplying a
02:11 name for a, and therefore I don't know which parameter you are talking about.
02:14 So you have to put the non-named parameters first.
02:18 Let's go over to the code and actually exercise this.
02:21 So here I am in my NamedOptionalParams exercise, and in the Snippets, under the
02:26 Named and Optional Parameters section, I am going to copy over the two functions
02:30 I am going to be using to exercise this.
02:33 So let's just copy these guys first and paste them into the code, and I will
02:38 put them below the Main function here.
02:39 So I have got two functions.
02:41 I have got one called myoptionalParamFunc, and you can see here that I've got a param here
02:48 that's -- param1, this is not optional because it doesn't have a default value.
02:52 This one here is optional because it's being supplied with a default value for
02:57 param2 and then for the third one, which is a string, I've also got a default
03:01 value which is a string value.
03:03 And it's worth pointing out here that you can provide default values for pretty
03:07 much just about any parameter type you can come up with.
03:10 Inside the function all we are doing is writing out what the function was called
03:15 with, and we will write out the values for param0, param1, and param2.
03:20 And you will notice here that I am using some escape sequences.
03:23 I have a \n and \t. That basically means, do a new line and then tab in, which
03:30 will make the results a little bit easier to read. All right!
03:33 Next, I have mynamedParamExample, in which case I'm going to call this function
03:38 with named parameters in the code from the Main function.
03:42 And again, you will notice, I don't have to do anything special to the
03:45 function declaration.
03:46 This just works with normal C# functions.
03:48 So let's go back and copy over the code that actually exercises these.
03:53 Let's start with the named parameters example.
03:56 So I will copy those lines and I will paste them into Main. All right!
03:59 So the first thing we are going to do is call the named parameter example, and
04:05 you can see I have got cityName, stateName, and zipCode.
04:08 I am just going to call them in different orders.
04:10 So the first example is going to call it with state, zip, and then city; the
04:14 second is going to call with city then zip and then state; and then the last one
04:17 is going to do zip, city, and then state.
04:20 So let's go ahead and exercise that.
04:22 We will build it and run it.
04:26 And you can see that in each one of the cases the arguments were passed in
04:30 different orders, but the output is in the right order.
04:33 So each one got its city name correctly, the state name is correct, and the
04:37 zip code is correct.
04:39 Okay, so let's do this.
04:40 Let's go back to the Snippets, and let's pass in the optional parameters example.
04:47 Copy this, paste it over here.
04:50 So now we are going to call the optionalParam function, and in each one of these
04:56 cases we are going to pass in a different set of values.
04:59 This one is going to pass in just one parameter.
05:01 This one will pass in two, and this one will do three, and then we will get to
05:05 this one in just a moment.
05:06 So let's save and build, and now we are going to run it, and you can see that now,
05:13 on the lower part of the output here, I have got Called with.
05:16 In the first case, you can see that the first parameter was 15 and then this two
05:20 second parameters were the default values.
05:22 In the second case, I passed in two parameters, so the first two parameters
05:26 are different, but the placeholder string is still the same. And in third case
05:30 I passed in three parameters which are different values and all of the default ones.
05:34 So let's go back to the code and see what happens when I uncomment this one right here.
05:39 Actually, before I do that, let me comment these guys out to make the output a
05:41 little more readable. All right!
05:42 So I am going to save. And you'll see that I am getting an error here, and the
05:48 reason I am getting an error is because the best overloaded method match for
05:53 blah, blah, blah has some invalid arguments.
05:55 What that basically means is, because I'm using optional parameters here,
06:01 you'll see that there is no version of myoptionalParamFunc that takes an
06:07 integer and then a string.
06:10 So this is a problem here.
06:11 If I'm going to pass in parameters that are being supplied instead of the
06:15 defaults, I have to supply values for all the optional parameters leading up to that point.
06:21 So I can't leave out the middle parameter here, because it thinks I am trying to
06:25 pass in a string value to this double right here, which is not correct.
06:29 So if you are going to use optional parameters and you want to supply values for
06:33 parameters in different orders, you will probably have to use the
06:36 named parameters and optional parameters in the same function call, which is
06:40 what we are going to do right now.
06:41 So let me comment that back out to get rid of the error. Now do both.
06:49 So to fix the error that I had above, what I am going to do pass in the value
06:55 for the first parameter, because it's mandatory.
06:58 There is no default value here, so I have got to supply a value to that, but
07:01 I want to skip over the middle parameter and just provide a string for the last one.
07:05 So to do that, I'm combining the named parameter feature with the optional
07:11 parameter feature. And now the compiler is like, oh, I see, you're trying to
07:14 supply a string for param3, which is over here, and not for param2.
07:21 Okay, well, that's fine with me.
07:23 So let's go ahead and build, and let's run it, and you can see now that all the
07:28 cases work. And this is the most recent case we just added.
07:31 So we have got the mandatory value here,
07:34 the default value is now being passed in for param2, and in the last case we have
07:38 a different string being passed in for param3.
07:41 So optional and named parameters really allow you some great flexibility in how
07:45 you define your functions.
07:46 They allow you to define default values for parameters that you don't want to
07:51 make mandatory for the caller, and named parameters allow you to call functions
07:55 with parameters in different orders.
Collapse this transcript
Using the C# preprocessor
00:00 During your C# coding travels, you're probably going to come across C#
00:04 preprocessor directives, and that's we are going to cover in this particular movie.
00:08 The preprocessor is what its name implies.
00:11 It does some pre-processing of the files before the compiler actually goes and
00:17 looks at all the code and compiles the application.
00:20 The preprocessor directives simply give instructions to the compiler
00:24 which help the compiler do its job before the compilation process actually runs.
00:29 Preprocessor directives are preceded by a hash character, or a pound character, or
00:35 whatever you want to call it.
00:36 So we'll take a look at some of those here.
00:38 The first two are define and undef, and you can see that they have got that
00:42 little--I guess you can call it sharp character, if you want to, whatever is it,
00:45 it has a word preceded by that little character.
00:49 In this case, define and undef allow you to define or undefine a symbol.
00:55 Now, why would you want to do that?
00:56 Well, we will take a look at an example that explains why you would want to
00:59 do that in just a moment, but there are a few other directives we want to look at first.
01:03 Using preprocessor directives, you can also do things like logic.
01:06 You can use #if, #else, #elif, or #andif, and these allow you to use logic to see
01:13 if a certain symbol is defined.
01:15 Now if the light bulb hasn't gone off yet, don't worry; it will in just a moment,
01:18 but there are two more directives we want to take look at.
01:20 They are region and nregion, and these are used for documenting your code, so that
01:27 the C# Express development environment allows you to do things like label
01:31 regions and collapse regions and so on.
01:34 But rather than just talk about them, let's actually see them in action, because
01:37 slides just don't do it justice.
01:39 Let's jump over to the code.
01:40 I have got my preprocessor example open here, and here is my program file.
01:46 The first thing I am going to do is this:
01:48 I am going to do a couple of defines.
01:51 Now, if you're going to define symbols, you need to do it before any other line
01:56 of code in the file.
01:57 So I need to put these defines up here above the using statements; otherwise, this
02:01 will cause problems.
02:02 So if I try to take these out and put them down here and save, you'll see
02:07 that these little red squiggles show up, and that's because the compiler is complaining.
02:11 It says hey, you cannot define or undefine preprocessor symbols after the
02:15 first token in the file. And that's just a fancy way of saying, these got to come first.
02:20 So let's go ahead and cut those and put them back up there.
02:25 So now I have defined some symbols, but what exactly does that mean. Why am I
02:28 defining symbols in the first place?
02:30 Well, the reason for doing this will become clearer when we paste in the rest of
02:34 the example. And I am going to go ahead and paste these guys in down here, copy,
02:39 and I'll put these in the Main part of my program.
02:43 So what you'll do here is you will notice that when I've got these #if and #else
02:48 and #endif, they are checking to see if a particular symbol has been defined.
02:53 So let's imagine that you're building a version of your application where you
02:56 only want to include some code if it, say, in a debug configuration, or if
03:03 it's in a demo mode.
03:04 Suppose I wanted to have this code right here only included in my application
03:10 if I'm shipping a demo version of my application, versus a fully released, fully
03:15 functional version.
03:16 Well, in that case I can simply change this from the DEBUGCODE to DEMOMODE or
03:21 whatever it is that I want.
03:22 You can see I have also defined a JOE symbol here.
03:26 I can make up whatever symbol I name I want.
03:27 Now, what's going to happen is the compiler is going to come across this logic
03:30 and say #if DEBUGCODE. Okay, well, if there's a symbol name DEBUGCODE then the
03:36 code that's in between this #if and #else is going to be included in the
03:42 compilation process and code that does not meet that logic test is not going to be included.
03:47 You can see here on line 18 that this code is in gray.
03:51 That's because the compiler is going to ignore it.
03:53 I can just write things that's not even code in here. Watch!
03:56 No red squiggles, right? Why?
03:58 Because the compiler is completely ignoring this code; it's not meeting the
04:02 logical test to see if the DEBUGCODE symbol is present.
04:05 Let me go ahead and delete that.
04:08 So now if we build and run--let's just do that really quickly, build and run;
04:12 we will hit F5--you'll see that the lines of code that met the logical tests of
04:18 those preprocessors was included in the application and they are executing.
04:22 So let me hit Return and get out of here.
04:24 Now let's go back up to the top.
04:26 What I am going to do is I am going to take out this #define for JOE, and we'll save.
04:31 Now watch, notice how the line of code that's inside this #if, #endif section
04:37 for the JOE symbol went and turned gray.
04:40 That's because I've gotten rid of the JOE symbol and this line of code is no
04:44 longer relevant, because this logical test on line 20 no longer evaluates to true.
04:49 Similarly, I can get rid of the #define DEBUGCODE, and you'll notice that the
04:54 line of code that used to be included in the compilation process when DEBUGCODE
04:59 was defined is now gray and the else condition is now being included.
05:03 So this bright line right here, it says:
05:06 "This only gets written out in non- debug code" is going to execute.
05:09 So if I run this now, you will see that that line of code is getting executed
05:13 where the other lines of code are not getting executed.
05:15 In fact, they are not even included in the program.
05:17 If you were to disassemble this code using a disassembler, you'd notice that
05:21 those lines of code aren't even present in the final application. Okay.
05:25 So let's take a look at one more preprocessor directive, and that is the region directive.
05:30 What I am going to do is copy this right here, #region.
05:33 I am going to put that in front of the Main, and then I am going to copy the
05:40 endregion. And I am going to put that below the Main function right here.
05:48 Now when I save, what that does is it tells the C# compiler that this is a region of code.
05:53 Now, this doesn't affect compilation.
05:55 It's really just for documentation, because watch what I can do now.
05:58 Over here in the C# Express IDE, I can click on this little collapse button and
06:04 you can see that it collapses down, and the text that I've included after the
06:07 region declaration here on line 10 is what gets included in that little label.
06:12 So I can collapse that down and you can see now that all that code is hidden.
06:16 So if I wanted to just collapse my code down to make it easier to read, I can
06:20 separate my code into different regions and then expand and then collapse them as I see fit.
06:25 Now if you're coming from other languages, such as C or C++ or Objective-C,
06:31 you'll probably see sometimes these preprocessor directives used to define
06:36 constants, and you'll see the #define directive used to define numbers and so on.
06:43 That's not the way things are done in C#.
06:46 In C# we have the const keyword, which we discussed earlier in the course
06:50 for defining constants.
06:52 So if you're coming from a language like C where you're used to using the
06:55 #define preprocessor directive to define constant values, you are not going to do that here.
07:00 You can use the const keyword instead.
07:02 Here, we are going to use the #define and #undef and so on, just to affect the
07:07 way that compilation happens.
Collapse this transcript
Working with delegates
00:00 Next couple of subjects that we are going to take a look at are fairly advanced,
00:04 and they are delegates and events.
00:07 I am going to start off by taking a look at C# delegates.
00:10 C# delegates are sort of like callbacks that you may have seen in other languages.
00:14 If you're familiar with programming languages such as JavaScript or Java or C or
00:20 C++, then you're probably familiar with the notion of a callback function.
00:25 A callback function is assigned at runtime and you can change callback functions
00:29 while the program is running. And the callback function is simply a way for you
00:33 to provide a piece of functionality that can be switched in and out as it is
00:37 needed. And delegates provide that functionality in C#.
00:40 Essentially, a C# delegate decouples the caller of a function from the call
00:46 function, which is essentially the same thing that callbacks do.
00:49 So to declare a delegate use the delegate keyword, and you're essentially
00:53 defining a type of function that is going to be called.
00:57 So I use the delegate function. Then I provide the type that the delegate
01:02 is going to return.
01:03 So in this case I'm declaring a delegate that returns an integer. Then I need to
01:08 provide a name for the delegate, and I can make it up as much as I want to.
01:12 I can use whatever a legal function name would be.
01:15 In this case I am just using the generic term delegateName, but you can use
01:18 whatever name you want. And then you have to provide any parameters that the
01:22 delegate is going to handle.
01:23 In this case I'm declaring a delegate that returns an integer and takes two parameters:
01:27 there is an integer and a string.
01:30 Then when I want to use the delegate, I use it like any other kind of type name.
01:34 So in this case I'm declaring a variable named func, which is of type
01:40 delegateName, and I'm assigning it to be someFunction.
01:43 So as long as I declare someFunction to be the same format as the delegate that
01:48 I have declared above, I can switch that function in and out as much as I like.
01:52 Then I just call the function like I would any other function.
01:55 In this case I've got an integer result which is being assigned
01:59 to the result that comes back from the func variable, which is now pointing at
02:03 the someFunction function, and it takes the integer argument 3 and the string argument "hello."
02:09 Then all we have to do is actually write the someFunction callback. And you can
02:14 see here that I've got a function named someFunction, which returns an integer
02:18 and takes two parameters--an integer and a string--and it has the same format as
02:23 the delegate that I declared at the top of the slide there.
02:27 So let's jump over to the C# code and actually implement this and see how it works.
02:32 Okay, so I am here in my delegate example, and I've got the UsingDelegates
02:37 project open, and I have also got the ExampleSnippets file open, and I've scrolled
02:42 down to the section on using delegates.
02:45 So the first thing I am going to do is copy my delegate declaration.
02:49 That's this line right here, so I will copy that and I will paste it into
02:52 the Main program here.
02:55 Now I am going to paste this inside the namespace but outside of my program class.
03:00 So I will just put it up here. And this basically says to the C# compiler, hey
03:04 compiler, there's going to be this thing called a function that has the format
03:08 of returning an integer and taking an integer argument, so be on the lookout for it.
03:14 So I am going to save that, go back to the snippets.
03:17 Now I am going to scroll down here and copy these two functions,
03:21 the functions Square and Cube.
03:24 So let's copy these guys, and we'll put them in the code outside of the Main function.
03:31 Now notice how each one of these functions returns an integer and takes an
03:36 integer argument, just like the delegate is declared up here.
03:41 So this delegate returns an integer and takes an integer argument. All right!
03:45 Now we can write the code that actually uses the delegate.
03:48 Here is what we are going to do. To do that, we are going to go back over to
03:52 Snippets and we are going to copy this piece of code right here.
03:57 Let's put this in our Main function.
04:00 Let me explain what's going on here.
04:02 Now that I've defined my delegate as a NumberFunction--that's this guy right
04:07 here--I can now declare that as a variable.
04:10 So on line 15 I am creating a variable named f which is of type NumberFunction,
04:16 and remember, that's a delegate.
04:17 So I can assign to f the name of a function that matches the same description as the delegate.
04:24 In this case, it's the Square function.
04:27 So down here is the Square function.
04:29 It takes an integer argument, and it just simply returns the square of that number.
04:32 It takes that number and multiplies it by itself.
04:36 So, on the next line, on line 16, I am doing a Console.WriteLine that says. the
04:41 result of the delegate is. and then the result number is going to go in here, and
04:45 then I simply call the function f with the number 5.
04:48 So f is now pointing at the Square function, because I assigned it to that up here on line 15.
04:52 So, I am going to call the function f with 5, and that's going to square the number.
04:58 That's going to write out the number 25.
05:01 So let's go ahead and run that. But before we run, that let's comment out these
05:04 two lines, so we can isolate the results for the moment. All right!
05:07 So we will save and we will run, and you can see that the string that's being
05:12 written out is the "result of the delegate is 25," just as we expected.
05:16 Okay, so far so good.
05:17 Now what we're going to do is uncomment these lines. And notice I'm changing
05:21 the delegate on the fly.
05:23 So now, instead of the f variable pointing at the Square function, it's going to
05:28 point at the Cube function.
05:30 So, while the program is running, I'm changing what the function that's going to
05:34 be called is, by changing the value of the f variable from Square to Cube.
05:39 So now this f variable right here on line 19 is going to be pointing at this
05:44 function down here to Cube.
05:45 And Cube takes the number and multiplies it by itself three times, which is how
05:50 you arrive at the cube of a number.
05:53 So on line 20, I am going to write out the result of the delegate is, and then the result.
05:58 I am going to call the function the same way.
06:00 I am going to call the function f with the value of 5, but in this case the
06:04 result is going to be very different.
06:06 So we should see two things written out.
06:08 We should see this line written out here, when f is pointing at the Square
06:12 function, and then we should see a different value written out here, when f is
06:17 pointing at the Cube function.
06:19 So let's build, and we can see the Build succeeded.
06:21 Okay, let's run it.
06:24 And you can see that the result of the delegate is 25, and then the result of
06:29 the delegate is 125, which is what we would expect, because we changed the
06:34 delegate to point from Square function to the Cube function.
06:38 Delegates are a really powerful and flexible programming construct in C#.
06:43 They do the same thing as callback functions, but they do it in a more modular way.
06:48 If your code calls for such flexibility, such that you need to be able
06:51 to provide callback functions, the way that you accomplish that in C# is by
06:55 using delegates.
Collapse this transcript
Handling events
00:00 In this example we're going to see how to use C# events, and specifically we're
00:04 going to create our own events and our own event handler.
00:08 Now the work in this particular movie is based on the delegates movie.
00:12 So if you haven't watched that one, you go back and watch it now because events
00:16 need delegates to work, and it's important that you understand delegates before
00:20 you attempt this movie.
00:21 So there are four steps involved in declaring and triggering C# events.
00:27 The first is that we have to create a delegate which is the event handler.
00:30 And just like we did in the previous section, we do that by using the delegate
00:34 keyword and then we declare the delegate named. In this case have got an
00:39 EventHandler which returns a void value.
00:42 So there's no return value from this function.
00:44 And then I declare the parameter list.
00:47 In this case, there is an integer parameter and a string parameter.
00:51 Now inside the class that's going to implement this event, I need to use the event keyword.
00:55 So what I do is I define a my class, and I do that normally with my class
01:00 definition. And then somewhere in my class I do something like this.
01:03 I say public and then the word event in front of the EventHandler delegate name,
01:10 and then I give it a name which is going to be used by the consumer of this
01:14 class to hook onto my event.
01:17 So somewhere else in the code someone who is using this class is going to write
01:21 something like this.
01:22 They'll write myClass and then some variable name, in this case object
01:25 equals new my class.
01:27 So now they've created an instance of this class.
01:30 Now what they want to do is listen for, or sometimes the word subscribe is
01:34 used, to this event.
01:36 To do that, they'll use the myEvent property which I've declared up there in myClass.
01:42 They'll use the += operator to specify a handler function that will be used
01:49 to handle that event.
01:51 This is called subscribing to an event, and it adds the handler function to the
01:55 list of functions that the myEvent is going to broadcast to.
01:58 Then what all I have to do is declare that function.
02:01 Here I've got a handler function, and notice that it matches the same format as
02:05 the delegate that I declared in the first line up there.
02:08 It say void function, and it takes two parameters, an integer and a string, and
02:13 then it implements whatever code there is.
02:15 Now this is the function that's going to be called whenever that event happens.
02:20 And you can see that there's the += operator. That subscribes to the event.
02:24 If you wanted to have your code to stop listening to an event, you would simply
02:28 use the -= operator and the same name of the function that you used to subscribe with.
02:34 So let's take a look at this in action in real code.
02:37 All right, so I've got my UsingEvents example open, and here is the
02:42 program code, and over in my snippets I've scrolled down to the using the events section.
02:46 So let's just take this one step at a time.
02:48 I'm going to first copy over the delegate declaration for myEventHandler.
02:52 So I am going to copy that and paste it inside my namespace here, outside my
02:57 program class. And this basically tells the C# compiler, hey there's going to be
03:02 this thing called a delegate which is an event handler and it takes a string
03:05 argument, and I'll supply that later. Don't you worry about it, but it's going
03:08 to be coming along.
03:09 Okay, now let's go ahead and declare a class, and this as an example class that's
03:15 just going to raise an event that other people can listen to. And I'll put that
03:20 class declaration up here above my program.
03:22 So let's take a look at the class declaration, and then we'll go further.
03:26 Here in my class I've got a member variable for this class on line 13, and
03:30 it's called theValue.
03:31 I've also got an event handler for valueChanged here on line 14.
03:37 So whenever this string value here called the value changes I'm going to
03:42 raise an event so that people who are using this class can listen for it and
03:46 say, oh, the value changed.
03:48 Then I've got a property right here starting on line 16. And if you are not
03:53 familiar with properties, you can go back and watch the section of this course on properties.
03:58 But I am exposing a public string property named val, and you'll notice that I am
04:02 only supplying a setter which starts here on line 18.
04:06 So the setter does two things.
04:07 First, it sets the value of theValue member variable to whatever the value
04:13 supplied to the property was.
04:15 And then it calls the value change event here on line 21.
04:20 So anyone who is subscribed to listening to this event is going to get notified
04:25 that the value has changed.
04:27 And it passes in the value of this private--the value member right here as
04:33 the first argument.
04:35 All right, so all that's left to do now is go back over to the Snippets and copy
04:41 over the code here that listens for the event, and I will put that in my Main.
04:50 So let's go through this line by line.
04:53 Here on line 30 I am creating a new instance of my event example class, and
04:59 that's this class right here-- the one that implements the event.
05:02 And I have got a variable called myEvt.
05:06 Then on line 32 I say myEvt.valueChanged, which is the name of the event.
05:11 All right scroll back up.
05:13 You can see there on line 14, that's the value changed event, +=new
05:19 myEventHandler, which is the name of the delegate. And then I need to supply the
05:25 name of the function that's going to handle that event. And the reason there is
05:28 a red squiggle there right now is because I haven't declared the my Evt_value changed function.
05:34 So let's go do that right now. Back over in the snippets I'm going to copy this
05:39 function right here.
05:40 This is my Evt value changed, and I am going to copy that and paste it, and I am
05:46 going to paste it below the Main function.
05:49 So now you can see the little red squiggle error has gone away, because now I
05:52 have a function which is going to handle the event.
05:55 And let's just take a quick look at the event handler.
05:57 So here on line 46, you can see that in the function all we do is just write out
06:02 the value of that argument that was passed to us.
06:06 And if we scroll back up to the class, remember that when we call this event
06:10 we are going to pass in the string that is represented by the private, the value
06:15 member of my class here.
06:17 So now we're pretty much about done; all we need to do is take a look at
06:21 what lines 34 through 41 are doing.
06:23 What I've got here is a string variable, and then I have a dowhile loop. And what's
06:29 going to happen is I'm going to read a line of text from the console, and if that
06:34 string is not equal to the value of exit, I'm going to set the public property of
06:40 the myEvt object to that string.
06:43 Let's scroll back up.
06:45 That's going to cause the setter of this property to trigger.
06:48 It's going to set the value of the theValue member variable to that string, and
06:54 then it's going to trigger the event.
06:56 And so this loop is going to just keep right on executing until I type in the word exit.
07:02 And when the word exit gets entered, the program will terminate, because there's
07:05 no more code after this in the Main function.
07:07 All right, so let's actually run this.
07:10 Okay, so now the program is waiting for me to put in the string, and I am
07:14 going to put in the word Joe. And you can see that when I set the value of that
07:19 string, the event handler gets triggered.
07:22 My event handler gets called.
07:24 The string gets passed in as the argument and we are just writing out that string.
07:28 I can type in anotherstring.
07:32 And once again, the event handler gets called. I can yet another string, and I can
07:37 go on and on like this, but now I am just going to change the value to exit, and
07:43 then the program terminates.
07:45 So that's how you declare an event handler and an event in C# using
07:50 delegates and the event keyword.
Collapse this transcript
11. Garbage Collection
How garbage collection works
00:00 Earlier in the course, you may have heard me refer to C# and .NET as a
00:04 managed-code environment.
00:05 What that basically means is that the .NET Framework provides automatic
00:09 memory management for you.
00:10 You as the programmer are not responsible for freeing up the memory that your
00:15 program's objects use during the course of the running of your program.
00:20 Now, this is not like other languages.
00:22 In languages like C and C++ and Objective-C, you as the programmer, when you
00:28 create objects that take up memory, you are responsible for making sure that
00:31 that memory gets returned to the system at some point.
00:35 But languages like .NET and other language like JavaScript in Java and so on,
00:39 those are managed-code environments.
00:41 There are ways that the system figures out that memory is no longer being used
00:45 by your program and reclaims it automatically.
00:48 Now, to take a simple example, when you do something like this in your C#
00:52 program, you have some object type definition, maybe you've made a new class,
00:56 and you use the new operator to create a new instance of that object,
01:00 that allocates memory somewhere in the system. That tells .NET, hey, you've got
01:05 to go find some memory to hold my object.
01:08 And the Framework will take care of figuring out when this object is no longer being used.
01:12 You don't have to do anything special. .NET will just figure out that you're
01:16 done using this object, and it will put the memory back in the system for you.
01:20 So let's take a look at conceptually how this works.
01:23 There is a big pool of memory available to the system, and we can think of it as
01:27 this big purple box you see right here.
01:30 Now, your program is going to use this memory during the course of its
01:34 operation. And as your program runs, it's going to allocate blocks of memory and
01:39 when it does that those blocks of memory are going to be taken out of the system
01:43 memory pool and assigned to your program. And then in your program will do
01:46 whatever it does with that memory and all these objects.
01:49 At some point there is a special class in the .NET Framework called the
01:53 Garbage Collector, and garbage collection is the process by which .NET figures
01:58 out that memory is no longer being used by your program and can take it back into the system.
02:04 So the Garbage Collector has a way of keeping track of the objects that you have
02:07 allocated, and when it figures out that these objects are no longer being used,
02:11 it simply puts them back in the system memory pool.
02:14 This process is completely invisible to your program.
02:17 You don't have to worry about doing this at all.
02:18 It all just happens for you.
02:20 So let's take a look at how garbage collection works.
02:23 Suppose we have a function, looks like this.
02:26 It's called myFunction. And inside myFunction I've got this new MyObject.
02:32 Well, out in the system memory pool when I do that, a block of memory is going
02:35 to be allocated that holds MyObject.
02:37 That creates what's called a reference.
02:40 That myObj variable that you created inside your function is now going to hold a
02:44 reference to that memory location.
02:47 Now, you can go and do a bunch of things:
02:49 you can call a method, you can set a property, you can call SomeOtherMethod.
02:54 But when that function ends, that myObj variable is going to go out of scope.
02:59 And at that point there are no more references to MyObject. Because that
03:03 variable is gone now, that little reference line disappears. And the Garbage
03:07 Collector comes along and says, hey, no one is using that thing anymore.
03:10 I can just return that object back to the memory pool.
03:14 So what are some important things to know about garbage collection?
03:17 First, your program does not need to initiate this process; the Garbage
03:21 Collector figures out when it needs to run and reclaim memory.
03:25 Now, there is a way for your program to initiate garbage collection, and we'll
03:28 actually take a look at that in an example in just a bit.
03:31 The Garbage Collector balances between performance and app memory usage, and the
03:38 objects are not necessarily reclaimed right away.
03:41 So these two things mean that you, A, don't know when Garbage Collection
03:47 is going to happen.
03:48 The Garbage Collector tries to figure out how your program is doing its work and
03:52 how much memory is being used, and it tries to strike a balance between making
03:57 sure that your application doesn't take a performance hit while figuring out how
04:02 much memory is being used and trying to say, okay, well, memory use is getting
04:05 kind high, maybe I should go take some of that memory back.
04:08 The other thing you need to realize that when you're finished with an object,
04:11 it might stick around for a while until the Garbage Collector figures out that it needs to run.
04:15 Now, objects can detect that they are about to be released from memory, so
04:20 when you create an object in a class, you can actually write a method called the finalizer.
04:25 Now, this is rather advanced.
04:27 I'm not going to cover it in this course. But you can just be aware that there
04:31 are ways for your objects to figure out that they're about to be released back
04:35 into the system memory pool.
Collapse this transcript
The Garbage Collector object
00:00 Let's take a look at a real example to see how garbage collection actually works.
00:04 So I've got my Garbagecollection project open up here, and in my Snippets file I
00:09 have scrolled down to the Garbage Collection section.
00:11 So let's go ahead and take a look at some of the garbage-collection routines
00:16 that are available to us.
00:18 So first I'm going to copy these three lines and paste them into my application.
00:24 Now there is a global object in .NET called GC.
00:29 You can see I'm using that right here on line 12.
00:32 The GC object is the Garbage Collector, and I'm going to call a function on the
00:38 GC object which is a static function here called GetTotalMemory. And it takes a
00:43 parameter--I'm not going too deeply into this. Don't worry about what this does.
00:46 Basically I'm saying to Garbage Collector, hey, tell me how much total memory is
00:50 currently allocated to my application.
00:52 So this is a pretty simple place to start.
00:54 Let's just build this and run it and see what happens.
00:56 So I'm going to run it, and the console is going to write out how much allocated
01:00 memory there is to my app. And you can see that when I run this the amount of
01:05 memory that's allocated to my application right now is 186,836 bytes.
01:10 Now don't worry if this number looks different for you and your example. This is
01:14 going to different for everyone's system.
01:16 This is basically how much memory is currently allocated to my app.
01:20 So let me hit Return, and we'll exit the app.
01:23 Okay, let's go back to the snippets and paste in some more information.
01:26 So the next few lines I am going to copy right here, and I'm going to paste
01:29 those below these lines.
01:32 So starting on line 16, I'm going to allocate 100,000 bytes in an array that holds bytes.
01:40 So this is 100K of memory that I'm going to allocate, and then I'm going to
01:44 basically do the same thing here on lines 18 through 20 that I do at the
01:49 beginning of program. And we'll see if this makes a difference in how much memory
01:52 that Garbage Collector thinks is allocated to my programs.
01:55 So let's run, and you'll see that we start off with 186,000 bytes.
01:59 Now let me hit Return, and this is going to cause the allocation to happen.
02:03 And now you can see that the amount of memory allocated to my app is 295,060 bytes.
02:09 Now notice it's not exactly 100,000 bytes more than the original size. Again,
02:15 don't worry too much about that, and don't worry too much if this number looks
02:19 different for you on your system.
02:21 The .NET Framework keeps track of a whole bunch of overhead internally, so when
02:26 I allocated those 100,000 bytes, a lot of other things happened under the hood.
02:31 So it looks like more memory got allocated then I asked for, but that's just the
02:35 .NET Framework doing its work.
02:36 So let's go back to the application.
02:40 Now what we're going to do is actually trigger the garbage-collection process,
02:44 so I am going to copy these lines here, and I'm going to paste them in here.
02:49 And you'll notice that on line 22 I'm calling the Garbage Collector's collect method.
02:54 This will actually trigger the garbage-collection process.
02:58 So we're going to start off by seeing how much memory my application gets when
03:02 it starts. Then we're going to allocate a whole bunch of memory and see how much
03:06 that changes things.
03:07 Then we're going to call the Garbage Collector's collect function which will
03:11 cause the Garbage Collector to go out and look at memory and say, hey, how much
03:14 memory isn't being used and how much can I reclaim? And that's going to be this
03:19 line right out here. We're going to write out what the results of that are, so
03:22 let's save this and run it.
03:25 Okay so we start with 186k. It goes up to 295k. Now let's watch what happens
03:32 when the Garbage Collector runs and we call that collect function.
03:34 Okay, it looks like the allocated memory dropped back down to about 210,000,
03:40 almost 211,000 bytes.
03:42 Again, I didn't get all hundred thousand bytes back, and that's because, as I said,
03:48 earlier the .NET Framework has some overhead that it's working on. So it did
03:52 figure out, however, that those bytes actually aren't being used by anybody.
03:56 So I was able to reclaim those bytes by running the garbage-collection process.
04:01 Now again, I want to emphasize that this is just an academic exercise here and
04:05 shows you how the Garbage Collector works.
04:07 There are going to be very few instances in your C# career when you're going to
04:11 have to actually care about running the Garbage Collector, if ever.
04:15 I've been working with C# for a long time.
04:17 I've never actually had to do this. But it interesting to see how the Garbage
04:20 Collector works and what you can do with the Garbage Collector to figure out how
04:24 much memory your application is consuming.
Collapse this transcript
12. Debugging
Common compilation issues
00:00 In the long, and no doubt illustrious, C# coding career that lies before you, you
00:06 are going to have to deal with compiler issues and bugs, and that's what we're
00:10 going to talk about in this section, debugging, and we're going to start off with
00:14 dealing with common compilation issues.
00:17 Now, many of these are fairly common, and they tend to trip up new C# developers.
00:22 Don't feel bad if this happens to you.
00:24 I personally assure you that I myself have committed every single one of the
00:28 issues I am about to show you.
00:30 So I've got my CompileIssues sample project opened, and what I am going to do is
00:33 walk through each one of these issues and show you why each one is a problem.
00:38 So I am going to start with issue number one.
00:40 Let me uncomment this line of code, and we'll save. And we've got a problem.
00:45 In fact, let me hit the F6 button to try to build, so we can see what the
00:48 problem exactly is, and I will scroll that code into view.
00:52 We can see here down in the error list it, says, ah!
00:54 There is a semicolon expected.
00:57 Well, a semicolon is expected at the end of every line of C# code.
01:02 If you're coming from a language like JavaScript where semicolons are optional,
01:06 you need to realize that in C#, that's not the case.
01:08 You do have to have a semicolon that terminates every single one of your statements.
01:13 Double-click on the error, and it takes us right to that point in the code.
01:17 We can put in our semicolon, and save, and then we can build, and now everything
01:21 is all right again.
01:22 Now we're getting a bit of a warning here that says that the myString variable
01:26 is assigned, but it's never used, but let's just ignore that for the moment.
01:30 Go down to issue number two.
01:32 So issue number two, I am going to uncomment this line of code, and once again we
01:35 get a whole bunch of errors.
01:38 Sometimes it's tempting to try to look for the error that's the simplest to fix
01:42 and try to fix it that way.
01:43 In fact, if you look in the error list, you'll see that there's a bunch of errors.
01:46 One of them says "; expected," One of them says ") expected."
01:50 So you might be tempted to just jump to that line and try to like put a
01:53 semicolon in to fix things;
01:55 that's actually the wrong thing to do here.
01:57 What I suggest you do is start with the topmost error, because sometimes when
02:01 you fix the topmost error, that will fix all the errors below it. And if you
02:06 look really closely at this line, you'll notice that the problem is that I
02:10 didn't close off the string using double quotes. And sure enough, once I do that,
02:16 all the other errors go away.
02:18 Before you try to figure out which is the easiest problem to solve, try to
02:22 figure out what the actual error is, because now you can see that the compiler
02:25 is saying, oh yeah, there is a semicolon, and oh yeah, there's the parentheses.
02:29 It just couldn't see them before, because it thought they were part of the
02:32 string, Hello World.
02:35 In the next issue, I'm going to use an ArrayList.
02:37 If you watched the section on collections, you know what ArrayLists are.
02:41 They are a type of collection that works like an array.
02:44 I am going to uncomment this line, and sure enough, we've got problems.
02:48 If we look in the error list, it says, "The type or namespace name
02:53 ArrayList could not be found (are you missing a using directive or an
02:57 assembly reference?)."
02:58 That's just a very long-winded way of the C# compiler saying, I don't know what that is.
03:03 And there's also a visual cue.
03:05 You'll notice that objects that are recognized by the C# compiler are
03:09 highlighted in a certain color, like the console object right here.
03:13 Now ordinarily, ArrayList would be highlighted as well, and it's not, and that's
03:17 your first clue that something is wrong, along with this giant red squiggle
03:20 underneath it that gives you the error.
03:23 It turns out that the problem is I have not included the right namespace in
03:27 order to use ArrayLists.
03:29 So I have to scroll to the top of the file, and sure enough, I'm using the
03:34 System.Collections.Generic namespace, but ArrayLists are contained in the
03:39 System.Collections namespace.
03:42 So I have to say using System.Collections. And when I put that using statement
03:49 in, you can see that the problem goes away.
03:53 Let's scroll back down to where that code is, and you'll see now that the
03:57 ArrayList object is highlighted in light blue the same way that the console is,
04:02 which means that the C# compiler is recognizing it. All right!
04:06 Let's move on down to the next issue.
04:08 I am going to uncomment these lines of code right here.
04:12 I am going to save, and you see that we're getting a complaint that a
04:22 curly brace is expected.
04:24 The curly brace is actually expected way down at the end of the program. Well,
04:28 clearly something is pretty wrong here.
04:31 And if we scroll back up to where the error actually is, you'll notice that
04:36 I've got my open curly brace here and a closing curly brace here, and those seem to match up.
04:42 You can see that when I put the cursor next to the curly brace, the IDE
04:46 highlights the two braces to show me they match.
04:48 But the problem is that I have actually got an extra one all the way over
04:51 here on the end of the for statement, and that's causing the compiler to
04:56 think that all the rest of the code following that line is contained in an
05:01 unclosed curly brace block.
05:03 Once I get rid of that extra curly brace and I save and I hit F6, you can see
05:09 that that error goes away.
05:11 So the lesson here is, indentation does not necessarily mean what blocks are.
05:17 You have to put braces so they match each other.
05:20 Just because you put one brace up here and another brace in another line down
05:23 there, does not mean that those make a block.
05:26 You have to make sure that you have the same number of closing braces as you
05:30 have opening braces; otherwise, you're going to get weird errors like that.
05:35 Let's move on to issue number five.
05:37 I am going to uncomment this string right here, I am going to save, and I am
05:41 going to get a nice big red squiggle.
05:43 It says down here in the error list:
05:45 "Too many characters in character literal" and "Cannot implicitly convert
05:50 type 'char' to 'string'."
05:53 What's going on here?
05:54 I've got my quotes.
05:55 I've got the string defined. The problem here is that you can't use single
06:00 quotes to define a string in C#;
06:03 you must use double quotes.
06:05 The single quotes are for individual characters. And so you see that when I put
06:12 the single quotes into double quotes, the error goes away.
06:16 Now, I am getting another warning that says that that string is not used, but
06:18 don't worry about that for now.
06:20 Scroll down to the next issue.
06:21 I'm going to uncomment these two lines.
06:29 So I have an integer array of values and it's called myarray = 0, 1, 2, 3, 4,
06:36 so we've got 5 items in the array, and then I am trying to set the array item at
06:41 index 2 to be 10, and I am getting an error.
06:44 It says "'myarray' is a 'variable', but it is used like a 'method'" and the
06:49 problem here is that you don't use parentheses to index into arrays; you
06:54 use square brackets.
06:58 Parentheses are used for calling function; brackets are used to index into arrays.
07:05 You can see that once I change the brackets, everything is fine. All right!
07:08 Let's go on to the next issue.
07:10 I am going to uncomment this call to Console.WriteLine, and then I get an error.
07:15 It says, "'System.Console' does not contain definition for 'Writeline'."
07:19 What are you talking about? Sure it does.
07:20 I've been using Writeline throughout this course.
07:23 There's a function there called Writeline.
07:24 I know that there is. In fact, I used it probably up here earlier. See, there it is!
07:28 And then I realized, oh, wait a minute!
07:29 No, there is a capitalization problem in there.
07:33 That actually has to be a capital L. That's because C# is a case-sensitive
07:39 language; case matters.
07:41 This is something you'll run into probably at least once when you're
07:44 writing your C# code.
07:45 You need to make sure that the cases match. That's true of variables.
07:49 It's true of function names.
07:50 It's true of almost any type of declaration that you make in C#.
07:55 Let's move on to issue number 8.
07:58 In issue number 8 I have got three lines of code.
08:01 I've got an integer variable that's set to 2,500,
08:04 I've got a floating-point variable that's set to 35.895, and then I'm trying
08:12 to set the value of f into the value of i. Now, I've got two different
08:18 problems going on here.
08:19 First, "A local variable named 'i' cannot be declared in this scope, because it
08:23 would give a different meaning to 'i', which is already used in a 'child' scope
08:26 to denote something else."
08:28 That's a very, very long-winded way of saying, you know what, I've already used
08:32 i somewhere else in this code block.
08:34 So if I scroll back up, there it is.
08:37 I've already used the i variable in this for loop.
08:41 So it's not going to let me use it again down here.
08:44 No problem. I will just simply call this i1, and I will call that one i1.
08:51 I've got another problem. The problem here is-- let's look at the error list--"Cannot
08:55 implicitly convert type 'float' to 'int'.
08:58 An explicit conversion exists (are you missing a cast?)." Yes, I am.
09:04 Remember, you can't implicitly cast a variable that is of a larger size into a smaller size.
09:11 You have to explicitly tell the compiler that you're doing that.
09:14 So what I need to do to convert a float into an int, I have to put the word int
09:19 in parentheses. And what this tells the compiler is, hey compiler!
09:23 Treat that floating-point number as if it were an integer, which will let me
09:27 assign it to another variable that is of that same type--in this case integer.
09:32 And you can see when I put that cast in front of the F, everything goes away, and we're fine.
09:37 Next issue, issue number 9, I am going to uncomment these lines.
09:41 I've got two integer variables: one named a, one named b. And then I've got an
09:45 if statement, if (a = b) then we're going to write out, yup!
09:49 They're equal numbers, and no sooner do I do that, then oops!
09:52 I get an error, and it says, "Cannot implicitly convert type 'int' to 'bool'."
09:57 What's the problem here?
09:58 I am not trying to convert anything to anything.
10:01 Well, remember that inside if statements what you're checking for is a Boolean condition.
10:06 That's how the if statement knows to execute. And the problem here is that I'm
10:10 not using double equals signs.
10:12 I'm using the assignment operator, not the equality check operator.
10:16 So once I change this to the equality check operator, the error goes away,
10:20 and everything is fine.
10:22 One more issue that I want to show you, and you'll run into this, and sometimes
10:27 it can be pretty confusing as to what's going on.
10:29 I am going to uncomment this entire function.
10:31 I've got a function here called func, and it takes an integer variable and if
10:38 that integer parameter is greater than 0, then it returns 0.
10:43 If that parameter is less than 0, it returns -1.
10:46 But I'm getting an error.
10:48 It says, "CompileIssues.Program.func: not all code paths return a value."
10:55 The problem here is that I've declared this function to return an integer value,
11:00 and I am returning an integer value here and returning an integer value here.
11:05 But what happens if the parameter a is equal to 0?
11:08 Well, there's no path in here that returns a number.
11:12 I have to make sure that if my function is going to return a value, then all of
11:16 the possible code paths that it can take have a return statement in there.
11:20 There's a couple of ways I can fix this.
11:22 I could put in an if case for a is double equal to 0, but since that's
11:27 the only case left, and the function would have returned by now if any other
11:31 case have been encountered, I can just simply say return whatever else.
11:35 I can say return 100, or I can return 1,000, or I can return whatever I want as
11:40 long as it is a valid return type.
11:44 Those are 10 of the most common compilation issues that you'll probably run
11:48 across in your C# coding.
11:50 Next, we're going to take a look at how to use the debugger to look at
11:53 code while it's running.
Collapse this transcript
Setting breakpoints and examining code
00:00 As useful as it is to be using the console and the Console.WriteLine methods to
00:06 see what's going on inside our application while it's running,
00:09 there's really no good substitute for using a good debugger which you can use to
00:14 examine the code while it's actually running. And the debugger allows you to do
00:18 things like place breakpoints in your code, examine the code, examine variables,
00:23 change things while it's running, and so on.
00:26 If you've done any kind of programming in other environments, like, say,
00:29 JavaScript using either Firebug or the WebKit Developer tools or coding
00:34 environments like C++ or Java, you might be familiar with using a debugger.
00:39 If not, don't worry about it.
00:40 I am going to show you how to use the debugger that's contained here in the free
00:44 version of Visual C# Express.
00:47 I am just going to use the existing example that we've already got from the
00:51 section that we did on reading and writing file data, so I've got that example
00:57 back open in my editor here.
01:00 Take a quick look. Under the Debug menu,
01:03 you'll see that there are a couple of options related to debugging.
01:07 There's the Start Debugging option, which is this option right here on F5,
01:10 and that's actually how I've been running our examples each time we've tried them out.
01:14 I just hit F5 and that starts the debugging process.
01:18 You can also start an application without debugging by doing the Ctrl+F5. But if
01:22 you want to actually have debugging information, you'd use the F5 version.
01:25 There are also things like Step Into and Step Over, and things like Toggle
01:30 Breakpoint, and we are going to see how each one of these works.
01:33 So let me close this menu. And the first thing I am going to do is show you how
01:38 to place a breakpoint.
01:40 Here we have our Main function, and the Main function is going to be the entry
01:45 point into our application from the .NET Framework.
01:48 The .NET Framework is going to find this function and then call it to start our program up.
01:51 So the first thing I am going to do is find the first place where I can put a
01:56 breakpoint. And it looks like this line right here, line 14 is where our program
02:00 actually does something.
02:02 So way over here in the left-hand side of the gutter, next to the line numbers, I
02:06 am going to click, and you see that when I click, a couple of things happen.
02:10 First, this little red circle shows up.
02:13 That little red circle indicates that it is a breakpoint, and you'll notice that
02:17 when I place that breakpoint, all the executable code that gets associated with
02:22 that line--in this case, it's line 14 and 15, because I have one statement
02:27 that's spanning multiple lines--gets outlined in red. And it indicates to me
02:32 that that is a breakpoint.
02:34 A breakpoint is a point in the program where when you're running the
02:37 application, the debugger will stop execution right before it's about to
02:42 execute that statement.
02:44 So let's go ahead and start debugging the program.
02:47 Open the Debug menu. I am going to choose Start Debugging, or you can just press F5.
02:54 Now when I do that, you saw the Console window kind of momentarily come up there
02:58 and then disappear behind the IDE. And now you can see this little yellow arrow
03:03 inside that little breakpoint there, and it shows me where the current statement is.
03:08 The breakpoint that was red is now outlined in yellow, and you can see that
03:13 we've got a couple of other windows that have shown up.
03:15 Down here in the bottom, on the left- hand side, we have the Locals window.
03:21 We also have something called the Watch window.
03:24 The Locals window shows me all of the local variables that are currently
03:29 within the current scope.
03:31 So inside the Main function, I can see all the local variables that I can
03:35 currently have access to.
03:37 Over here in the Call Stack, this shows me all of the functions that have been
03:41 called leading up to this point.
03:43 Now right now we are in the main function.
03:46 I have only got two items on the Call Stack.
03:48 I have got External Code which is the .NET Framework's execution engine, and
03:52 then I've got the ReadingWritingData. exe!ReadingWritingData.Program.Main, so
03:58 that's the function that I'm in.
04:00 so ReadingWritingData.exe! that's my program.
04:03 ReadingWritingData is my namespace. Program is the class.
04:06 That's this program right up here.
04:08 Main is the function, and it says I am on line 14. And sure enough, if I look
04:13 over at the little arrow, yes, I am on line 14.
04:17 The other thing that happens is that this little Debug toolbar showed up in my
04:21 toolbars up here. And I have got buttons for Continuing, so if I hit F5 right
04:25 now, the program will just continue to run until it reaches the next breakpoint.
04:29 Or I can stop debugging which will stop the application, or I can restart.
04:34 I can have the program go back to the beginning.
04:36 I can click on this little yellow arrow here to show me what the next statement
04:39 is going to be, and that's where the yellow arrow right over here is.
04:42 I've also got these three icons for Step Into, Step Over, and Step Out, and we'll
04:49 take a look at what each one of these is.
04:51 To step over this code, I can simply choose the Step Over function.
04:56 That will cause the current statement, the one that's highlighted right here, to
04:59 execute. And if you look down here in the Locals window, you will notice the
05:03 filePath variable right now is null.
05:07 There is no value assigned to it.
05:09 Watch what happens when we step over that line.
05:13 First, the little yellow arrow goes to line 18, because that's where the next
05:18 line of executable code is.
05:20 The second thing that happens is, if you look down in the Locals window, the
05:24 filePath variable now has this string in it, and it has a path to the example
05:30 file.txt. And you notice also it's red, and the reason it's red is because the C#
05:36 debugger is highlighting the local variable that changed.
05:41 After I step again, it's going to stop being red, because it's not going to
05:45 change after that point.
05:46 I can scroll down a little bit here.
05:49 Now if I wanted to, I actually could just simply change the value that's in
05:53 this local variable.
05:54 I can just double-click on it and say, you know what?
05:56 I don't want it to be called examplefile.txt; I want it to be
05:59 called joesfile.txt.
06:05 I just changed the contents of that variable while the application is still running.
06:10 So now this line of code right here is going to check to see if the file exists,
06:14 and it does not. So when I step over that statement, we'll see that the brace
06:20 gets highlighted, and I step again, and now we step into the if statement.
06:25 So now we are going to create that file and set its contents.
06:30 And once again, I can step over this, and you can see now that this content
06:34 variable has changed.
06:36 So I can also do things like hover over using the mouse.
06:40 I can hover over things that are in the code.
06:42 For example, if I hover over the Environment.NewLine statement right here, you
06:46 will see I get this little pop-up window that says what the new line's value is.
06:50 And you can see that it's \r\n. Or I can hover over this local variable, and it
06:55 shows me what the contents of that local variable is.
06:58 I can also hover over things that are built into the .NET Framework.
07:01 I can hover over the file class, for example.
07:03 When I hover over the file class it shows me that it's of type System.I/O.File,
07:09 and I can click on this little expander here, and it shows me all the things
07:13 that are inside that file class.
07:16 Now, it's a built-in class, so it's not going to show me very much, because
07:19 it's in native code.
07:20 But I can now just use my debugger to step through this code, and I can watch
07:25 the application as it runs.
07:27 You will see that variables are changing.
07:30 I can change the value of variables and so on.
07:33 If I've gotten tired of just stepping through this, I can just go ahead and hit
07:37 the little green arrow, which will cause the application to run, and we can see
07:42 that the application is now running.
07:43 And if I go ahead and hit the Return button, the application will stop, the
07:48 debugger stops, and I am dumped back into my text editor.
07:51 Let's make a slight modification to this application.
07:54 What I'm going to do is make a function, and I am going to make a function down
07:59 here called static void ReadAndListContents(). And it's going to read and list
08:13 all the contents of the file. So basically, I am going to copy these lines of
08:17 code right here, take them out of the Main function, and put them into a
08:22 function And I am doing this because I want to show you how the Step Into
08:26 functionality works.
08:27 I'll just get rid of that comment right there.
08:30 I need to pass in the filePath, and I also need to call that function,
08:37 so we'll call ReadAndListContents with the filePath. And just to isolate this,
08:47 we'll take out this code right here, so that we only have one piece of code,
08:52 that's ReadingAndListingTheFileContents.
08:55 What I am going to do is run the application again, and it's going to stop at
09:00 this breakpoint right away.
09:02 This time I am going to start at using this little green arrow right here.
09:06 You can see that the breakpoint got hit.
09:08 What I am going to do now is scroll down and I am going to place a breakpoint
09:12 on this function call.
09:13 So I just click there to place another breakpoint, and now I'm going to hit the
09:18 little green arrow again, which is going to continue on to the next breakpoint.
09:22 The application ran until it got to this breakpoint.
09:25 Now I can use the Step Into function, and that's this icon right here.
09:31 If I wanted to just simply execute this function without stepping into it, I
09:34 could use the Step Over.
09:35 That doesn't mean skip over the function;
09:38 it means execute it but don't go inside. Just do whatever the work it does, and
09:43 then go on to the statement at the level where I currently am.
09:46 So if I stepped right now, the next statement would be this Console.ReadLine.
09:49 But if I do a Step In, I will actually step into that function.
09:55 And now I can do Step Over and Step Over again, and you can see now that the
10:00 current line, as indicated with this little yellow arrow right here, is inside the
10:04 ReadAndListContents.
10:06 I could just simply keep on stepping and stepping and stepping and
10:09 going through these foreach statements and so on, or I could use the Step Out function.
10:15 If I click on Step Out, the execution is going to continue to the end of this
10:19 function and it's going to put me back into where the calling context was.
10:23 If I click Step Out, now I'm back out here where ReadAndListContents was called,
10:30 but now the function has finished executing and if I step again, I'll go on to
10:34 the next statement, which is the Console.ReadLine.
10:38 That's a pretty quick introduction to using the debugger.
10:41 The nice thing about the debugger is that it allows you to slow down the
10:44 program's execution so that you can see things as they are happening.
10:47 And as you saw, we were able to place breakpoints and examine variables.
10:51 We were able to change the contents of variables.
10:54 We were able to step into and out of functions.
10:56 The debugger really will become your best friend as you're writing your code
11:00 because it makes debugging of your applications so much easier.
Collapse this transcript
Using the Debug class
00:00 Throughout this course I've been using the console window to write out
00:03 debugging and other diagnostic information so that we can see what's going on
00:08 inside the application.
00:09 For examples like this, that's all well and good, but when you write your real
00:12 applications, if you're writing a console application, you probably don't want
00:15 to have it littered with debugging information that your users are going to see.
00:19 Or if you're writing an application that doesn't use the console window at all,
00:22 you're going to need to have some other way to get that output visible to you
00:26 while you're debugging your app.
00:28 The way that we are going to do this in this particular example is by using
00:31 the System.Diagnostics namespace, which gives us access to something called the debug class.
00:38 The debug class gives us a way for logging debugging information in a way that
00:42 we can see it which doesn't interfere with the actual output of the program.
00:48 To use the debug class, I am going to do a couple of things.
00:51 See, on line 16 the System. Diagnostics namespace. This gives me access to
00:57 something called the debug class, which gives us a bunch of features that are
01:00 similar to what we've been using the console window for--
01:03 WriteLine statement and a few other things that we'll take a closer look at.
01:07 The debug class is going to log all this information to a place called the
01:11 output window, and the output window is going to show up here in the IDE
01:15 when we make it visible.
01:17 To use the output window, there is a couple of things you are going to have to do.
01:20 First, under the Tools menu, go down to the Settings submenu and make sure that
01:25 the Expert Settings option is checked.
01:27 Once you've done that, under the View menu, there will be an option for Output,
01:32 and when you choose Output this little output window will show up here in your IDE.
01:37 Don't worry about the Show output from option just yet. Tight now it's empty,
01:40 but that will be filled in for us.
01:43 If you are a sharp-eyed reader, you'll notice that I'm using pretty much the
01:46 same code that we used in the Reading and Writing Data Files example, although
01:51 I've re-organized it a little bit to use functions and so on.
01:55 What we are going to do now is first build the application, so hit F6.
02:01 And you'll see that down in the output window, a whole bunch of information was
02:05 logged for us by the IDE.
02:07 It says that the build was started, and then there is a line that says,
02:09 hey, Build 1 succeeded.
02:11 So everything looks pretty good.
02:13 Our code can also use this same output window to log debugging information, and
02:18 the way that we are going to do that is by using the debug class.
02:21 Go ahead and scroll down and see how the debug class works.
02:25 This code probably looks familiar to you if you watched the earlier example on using files.
02:30 I'm not going to focus too much on that.
02:32 What I am going to focus on instead is the information that I've put into the
02:35 file to help with debugging.
02:37 Here's a debug class call. And you will notice that the debug object has a
02:42 function called WriteLine, which works pretty much the same way that the
02:47 console's WriteLine object works as well.
02:50 Only instead of sending output to the Console window, this is going to write
02:54 information out into this output window down here.
02:58 Here I am write-lining out some piece of information that the file was created,
03:02 and so on and so forth, and we do the same thing down here.
03:06 A couple of other features, though.
03:07 There is a assert function call, and assert basically makes sure that the
03:13 Boolean condition supplied in here is true.
03:17 If it ever evaluates to false, the debugger is going to pop up and say, hey,
03:21 something went horribly wrong in your program.
03:23 You might want to take a look at it. And we'll see an example of that in a little bit.
03:26 We also have this here, Debug Indent and Debug Unindent, and that will help us
03:32 make our debug log output more visible in the output window below, which we'll
03:37 see in just a moment.
03:39 Let's go ahead and run this program, and we'll see what happens.
03:43 Let's just take a quick refresher of the code.
03:46 You can see that when the code starts
03:47 we have a string variable that holds a filePath, and we are going to create a data file.
03:52 We are going to write some information out to it,
03:54 and then I am going to read the contents back in. And all that's going to be
03:58 happening in these functions down here.
04:00 We have a function for creating the file, we have a function for writing the
04:03 file content out, and then we have a function for reading the content back in.
04:09 So the last thing I want to point out before we run this is that unlike the
04:12 console window, the debug object has a special version of WriteLine.
04:17 It's called WriteLineIf.
04:19 What you do here is you supply a Boolean expression. If this expression
04:24 evaluates to true, then the WriteLine happens; otherwise the WriteLine doesn't happen.
04:29 In this particular case, we are saying Debug.WriteLineIf the contents array
04:34 length is greater than 2.
04:37 Well, if that length of that array is more than 2, then this particular
04:41 WriteLine will happen; otherwise it won't. So let's go ahead and run this example.
04:49 We ran the file, and we added a whole bunch of content to the file, so let's
04:53 go ahead and hit Return to exit, and let's go examine the output in the output window.
05:00 The first thing you will notice is there is a whole bunch of output messages
05:03 that were put here by the .NET Framework.
05:06 You don't really need to pay attention to any of these.
05:08 These are messages that the debug version of .NET Framework is sending out for
05:13 you to look at as a programmer, but for now, we are just going to ignore that.
05:16 What we are going to do is look for our first examples of debug output, and
05:20 they are right here.
05:21 For example, we have Writing File Data, File Data Written,
05:26 The file has more than two lines.
05:28 Well, where did those come from?
05:29 Well, if we scroll down in our content, we can see right here, this did not
05:35 execute, because the file already exists, but if the file hadn't existed,
05:39 we would have called the WriteLine function for creating the file with content whatever.
05:43 However, when we write the file data out, you'll notice that the WritingFile
05:48 Data string got written out, and because it's indented, right here you can see
05:53 that there is a little bit of a tab space in here, which makes the debug
05:56 information a little bit easier to read.
05:59 Down here we do the same thing. After the file's data has been written, we have
06:03 a debug output statement that says the file data has been written, and that's
06:07 also indented. And because the contents of that file had more than two lines,
06:13 you can see that this WriteLineIf statement executed.
06:17 Let's do one more example.
06:20 Let's see if we can get this assert to trigger right here.
06:26 What we are going to do is pass in an empty string content to write to the file.
06:32 I've decided that here in my application that anyone who calls this function has
06:37 to provide string content that's not empty.
06:41 If I pass in an empty string, I want my program to raise a warning message and
06:46 say that someone has tried to do something that I don't approve of. And the
06:50 great thing about these debug messages is that when you build the release
06:54 version of your code, none of this stuff gets included;
06:57 only the debug version of your application will contain these debug calls.
07:04 So let's go back up into the code here.
07:05 I'm going to uncomment this call to WriteFileData, and I am going to pass in an
07:13 empty string. And that's going to cause that assert to pop up.
07:18 Let's see what happens when I try this.
07:20 I am going to run this.
07:22 When I ran this, the Assertion Failed dialog message comes up.
07:27 So here the title says Assertion Failed, and then I have some options. Do I want
07:30 to abort or retry or ignore?
07:33 Now this is a non-fatal assert, so I can just go ahead and ignore it if I want to.
07:38 But for now what I am going to do is click Abort, which will cause the
07:42 application to stop.
07:43 I can see where that assert was. It's down in here.
07:47 You notice that there wasn't a whole lot of helpful information that came up in
07:51 that Assert box, just a big stack of messages that says, hey, here's the
07:55 function where things went wrong.
07:57 So I can include a message in this assert.
08:01 I can say, "Tried to call WriteFileData with an empty string."
08:10 This version of the Assert function will not only pop up the dialog;
08:15 it will give me a nice easy-to-understand message, so I can see what's going wrong.
08:19 Let's try that one more time. And you can see that this time, next to that
08:24 little red error message that says, Tried to call WriteFileData with an empty string,
08:28 that's the message that I put into my Assert box, and it shows me all the
08:32 functions that got me to the current place.
08:35 So right here at the top it says, at Program.WriteFileData.
08:38 That's where the assertion happened. And you can see that we got there by
08:42 calling through Main, and then we came in via the .NET Framework.
08:46 These are all the .NET Framework functions right here. Bt it shows me how we
08:49 got to where the assert is.
08:51 So I am going to click Abort. And then at this point I would go back and I would
08:56 try to figure out, okay, who is calling WriteFileData, who is doing it with an
09:00 empty string, and so on?
09:02 This is how you can use the debug class to add some extra debugging information
09:08 right into the IDE while you are debugging your application.
Collapse this transcript
Conclusion
Goodbye
00:00 Well, that brings us to the end of C# Essential Training, and I want to thank
00:04 you for joining me as we explored the basic concepts of the C# language.
00:08 You are probably wondering where you should go next, and I have a few
00:11 recommendations for you.
00:12 Spend some time exploring the online documentation for the C# language and .NET
00:17 Framework on the Microsoft Development Network web site at msdn.microsoft.com.
00:23 This is a very good reference resource for learning more about many of
00:26 the objects, classes, and language features that we were introduced to in this course.
00:31 Since C# is the foundational language for other Microsoft frameworks, such as
00:36 Silverlight, Windows Phone, and ASP.NET,
00:39 take a look at some of the other programming resources in the lynda.com Online
00:44 Training Library, such as Objective-C or JavaScript Essential Training.
00:48 Seeing how other languages approach similar problems and situations can
00:53 significantly increase your understanding of how each language has its own
00:56 benefits and drawbacks, and will broaden your understanding of the discipline of programming.
01:01 Finally, go back to some of the examples in this course and try some experiments.
01:05 The more practice you have with the language, the better a C# programmer you will be.
01:09 Good luck with your C# coding!
Collapse this transcript
Subscribe to:
Posts (Atom)