Dynamo for Software Developers: C#, Python, and More—Workshop - Part 2 of 4

PRESENTER: I think we have everyone, so I'm going to ask you guys to quiet down, so we can get cracking. All right, something weird is going on with my laptop, but bear with me. Hopefully this works, and it stops playing by itself. Cool, so hopefully-- yeah. Anyone know how to work PowerPoint. It's playing by itself. I don't know why. [LAUGHS] No. OK. It's just advancing by itself.

AUDIENCE: [INAUDIBLE]

PRESENTER: No. I don't know. Let's see. I'm just going to keep flicking back and forth if it keeps doing it. Cool, so-- sorry?

AUDIENCE: [INAUDIBLE]

PRESENTER: Transitions on mouse click.

AUDIENCE: [INAUDIBLE]

PRESENTER: Yeah, no. It's OK. We can-- I think it's fine now. All right, so what we're going to do in this session, we've looked at Python previously. So you saw how to develop directly into Dynamo, which is pretty cool because you get immediate feedback. And hopefully by the end of the session, you will understand the value of that.

In this session, we're going to go back right back to basics and learn a bit about programming languages in general, about compilers. Not too much. Don't worry. And then we're going to learn the basics of C #, which is a different programming language than Python, but it's also the language that Revit and Dynamo were written in. So it's going to provide a little bit of a different way to integrate with those two.

So this is what I get asked the most probably, like should I learn Python or C #? There is no right or wrong answer by the way. Everyone's going to give you their own opinion. The answer is basically depends what you want to do, how much time do, you have what do you want to accomplish. So by giving you guys a broad overview of all of them, hopefully you can pick for yourselves and see which one is more suited. What I will say about the C # side, hopefully you'll see, it's a little bit friendlier to beginners. And it gives you more assistance along the way so less of stabbing in the dark, I guess.

I'm going to have to advance with this. So how-- backing up, we have code. We were writing letters into a little gray box and then something was happening on the screen, something was executing. So I'd like to pause for a second and just go through the journey of like what happens when we go from that source code that we wrote, the little text that we typed in, all the way to the machine executing those things. How do we get from one to the other, which will help us understand the language a little bit better.

So we generally start of on the right hand side with high level code. So this is, for example, it could be Python, it could be JavaScript or C. It's a high level language. So you type in things that resemble to English, and you as a human can read it. What happens is this needs to be translated into something that machines can understand. So there's several steps for that. You can go to assembly code first, and then eventually what actually needs to happen is it needs to be translated to machine code on the left. So imagine having to write your Python scripts like the thing on the left. That's what they used to do in the 60s. People did that. It was very hard. So we have it very lucky today that we can do that.

So to get from one to the other, what happens is it goes through a process usually called compilation. So we start off with source code. So for example print 4 times a variable plus 1. First thing that happens is a lexer takes this text because it's just a text file. And it starts making a list, and breaking it down into its component. So it identifies oh, the first thing is print. Then I have an operation, which is the semicolon, and then I have a number, and just builds up the list of these things and recognizes, which part of the text is what.

The next step that happens after this is that list gets basically transformed by a parser into something called an abstract syntax tree. You'll hear this term in Dynamo land, for example, when you're dealing with UI nodes. Under the hood, Dynamo is doing this and compiling your stuff to something called DesignScript.

So it builds an abstract syntax tree from your graph, and it basically makes this diagram of like, OK, this calls this. And then this depends on that. And it will use this abstract syntax tree to then build something called an action tree, which is a kind of a more developed version of that. And eventually this then gets transformed into byte code and run on the machine.

Now this might look familiar to you. If you look at the diagram on the left, and we kind of flipped the Dynamo graph on its head, it's exactly the same thing. So when you're programming visually, you're really just writing an abstract syntax tree at a 90 degree angle kind of thing. So this is why it feels intuitive. It's because we can visually make these things, and it's a lot easier than having to type the code in and imagine in your mind actually these two things depend on that. So that's where the intuitive of visual programming comes from.

So back to our question, how does help us figure out how to go from source code to machine code? And that is the job of something called a compiler, essentially. There's a joke in here. So if you ever see programmers slacking off, it's usually because it's compiling. Computers are usually fast enough now that it's no longer a valid excuse. But I wanted to touch on a different-- since we're talking about Python earlier and we're going to be talking about C # in the second, I wanted to touch a bit about on the different kind of compilers or flavors of these steps, if you will.

So traditionally, you can have a compiler or an interpreter. And you'll hear these terms when we talk about different languages. I'm going to go through the differences between them. So a compiler takes your entire program, for example, analyzes all of it, and then spits out machine code. An interpreter goes here's the first line, I'm going to read it, process it, and execute it. Then I'm going to go to line two. So it's very sequential. A compiler kind of generates this kind of intermediate object code, whereas an interpreter usually does it and it just straight up executes things.

A compiler executes faster because it knows about the entire program, and it can do optimizations, and it can do all sorts of other things. Whereas an interpreter is just going in the dark and saying, oh, here's the next step, here's the next step. And it doesn't know what comes next. So we can't do a lot of these optimizations. A compiler, however, requires more memory because it has to keep the entire program into memory when it compiles it, and that kind of has a knock on effect. An interpreter is faster because it just goes line by line, so you only ever need to know about the line that you're currently on.

A compiler doesn't compile every time you run. So if I take my code, and I compile it, when I go to run it, I never need to compile it again. It just runs. If I run it a million times, it just runs. An interpreter, however, if you run it a million times, it needs to basically do this compilation a million times. And in terms of errors. If you're dealing with a compiler this will give you a lot of errors at compile time, so when you're trying to compile. Whereas an interpreter because it doesn't know what the next line is it will only display the error when it's running your code. So that means that you don't know what you're doing wrong until you actually run your code.

So examples of compiled versus interpreted languages, and why this is relevant for us is C#, Java, C++ and a lot of others are compiled languages. We type code, a compiler does a lot of heavy lifting, and it spits out an object, a DLL usually or something like that. Python, JavaScript, and a few others are interpreted languages. So like we said, they go line by line, meaning that they get compiled every time, and there's performance drawbacks there. But there is also kind of ease of use in that approach.

I've put C # in this pile as well because, as you'll see C # is a bit of a-- and Java different kinds. They're kind of hybrid between the two where basically it's got a compile stage, so it compiles your program to something called an intermediate language representation. And then when it runs that code , it further does interpretation on that to optimize it based on the machine that it's running. So it's kind of like a two stage, and it tries to get the best of both worlds, which is why it's a pretty cool language. And it's generally regarded as a next generation kind of compiler.

So that's it for the intro. Any questions on that before I go on? No burning questions. Curiosities? No, OK? Got one.

AUDIENCE: [INAUDIBLE]

PRESENTER: Well we had them up on the screen earlier. So you pick the ones you want from the left or the right. That's hard to say. I stick with C# so. Because it gives you-- I think it's the analysis of your entire program and it gives you all the errors it finds when it tries to compile. That is massively helpful, for example. So I know that I don't have any errors in the codes before I run it. And if there are any errors, it's because I'm stupid, not the computer. So it kind of helps kind of get rid of some errors plus it actually runs a lot faster.

So object oriented programming.

Yeah

AUDIENCE: [INAUDIBLE]

PRESENTER: Pardon.

AUDIENCE: [INAUDIBLE]

PRESENTER: Yeah, so that's the part with interpreted languages. I don't need to have a massive compiler, write a lot of code, fix all the errors. I can just type three lines and it runs, right? So you can prototype in interpreted languages much, much faster. So that's why I said you, pick what you need based on what you're doing.

So object oriented programming because we're going to need to know these concepts for the C # bits. It's called object oriented for a very simple reason. It looks at the world through the lens of objects. Like everything in the world is an object. I'm an object. The table's an object, but so are actions. So if I'm performing a particular action, I can model that as an object in object oriented programming.

So objects in this world have two things they have data, which are usually called properties, things like color name height, whatever. And they have methods, which ability to do other stuff. So I can move. I can scale. I can talk. I can do stuff. So think about it as data is I have something, and then methods are I can do something.

So a little terminology. Objects like words like we saw are bits of data and methods stuck together. So a particular object has some properties, and it knows how to do some stuff. Objects also have a type. So you identify as a type. So for example I'm a human type. The desk is a type of furniture, and so on. So they function on this idea of something having a type and discriminating objects based on that.

Classes, and we'll come to those in a second, they're basically a way to define types, custom type. So Tom told you earlier that Boolean is a type. It's a true or false basic, right? So that's an example of a type. Integer, double string, they're are all types. So they all come predefined with the language. However, with an object oriented language, you can define your own custom types, and you do that through the use of classes.

An instance is basically one particular-- I'm not sure if there is a better word for it, instance of a type. So if I'm an instance of the type human, I'm a particular instance. I am called Radu, and I'm unique. So are all of you. Right so I represent a type, but I also have my own properties that no one else has. There might be other people with the same name, but we all have different properties. So instance, is something you can point to and say, yep, that's of that type, and it's that particular instance. And you identify objects like this.

And then something called static is a concept where you no longer have something that can have multiple instances, but instead you have a class that can only have one. So an example of this would be from The Matrix. There can only be one. He is the chosen one. He is a static class. We'll see another example.

So in an applied world, like if we looked at the this through the lens of architecture, for example, let's consider a truss for example right. A truss is defined basically by a list of points. Then the capability to generate geometry. So we have a list of top points, a list of bottom points for our truss. And then we have a method to generate that geometry and out comes an actual truss, right?

So in this case, we can say that the class truss is basically a type of geometry, and it has some properties and capabilities whenever we make a new truss, we say we make an instance of that class. So if we make seven trusses, they can all be different instances and they are unique in their own ways. But they also share the same capabilities that the base truss class has.

So how does that relate to Dynamo? For example, if you take a list of inputs, a list of nodes, pairs of points and things like that, and you feed that to the method that generates geometry, it could spit out for example truss instances. So whenever you're making a wall and you feed it some inputs, what that method is actually doing is creating new instances of that class, right? So the method that Tom used earlier wall.create, that is a method that creates a new instance of the class wall, or it tells Revit to do it for you, essentially, if we are kind of getting into the nitty gritty of it.

So that's it for object oriented programming. I'd like to ask if there's any questions before we get to C#, and I promise there's only five more minutes of lecture and then we actually type stuff. No? Can I go on? OK. So this should feel familiar because it's very, very close to Python. The reason it's close to Python in terms of syntax is because most languages are close to a language called C. So they all kind of look familiar, which is why it sometimes is confusing.

But there is a couple of base types built into a C #. There is an integer type, for example. And you declare these things by typing the type first, so int for example. I have a variable named x, and I'm assigning it the value 5 here. So integers are whole numbers just like Tom told you. Doubles are numbers with decimal points. Strings are basically representations of text. So if I say hello world, that's a text, which means in computer language it's a string. And booleans are just true or false. They can never be anything else. The beauty with booleans is it's either true or false. It can be undefined, for example. No, it's true or false, and computers like that. They don't like uncertainty.

So how do you write these things? In C #, you write statements. So like I said at the beginning, to declare a variable, for example, you declare its type, its name. So I say int x or I can go int y And then I assign a value to it, and then I type out the value. More importantly in C #, you always finish your statement by pulling semicolon at the end. If you don't horrible, things will happen. It's not like in Python where you can go around the place and not put any semicolons. There is structure here. I'm kidding. Not horrible things will happen. It just won't compile.

So how do we-- we saw how we define a variable. So let's look at how we define a method now, and then we're going to jump straight into coding a little bit. When we define methods, there's a couple of things we'd need to define about that method before we actually write the code of that method. We need to declare something called an axis modifier, which simply says who can see this method. If it's public, anyone can see it. If it's private, only the class it's part of can see it. Then you have a modifier, which you can omit, as in not have. So if you want to make it static, you type in static. You can type in read only, for example, or you just limit it. Most of the time we don't have entities.

Then you have a return type so that means this method does something, and then it returns me something. And this is the type of that's something that returns back to me. So it answers the question, what do I get back when I run this method? Then you have the name of the method. So in this case it's AddToNumbers. And just like Tom said, we are using camel case here. And then in between curly braces you basically declare something called parameters, which are inputs. There what your method needs to be able to run. So this is how you pass information to your method.

Now in between curly braces, which you open right after the normal braces, you type in your statements. And this is the body of the function. So when I'm going to say, oh, please put this in the body of the method, it's in between the curly braces. And this is where you type all your statements and do stuff.

Cool. Now this looks a little bit different from Python. And we have a lot more types, and you have to declare these returns every time. And it's a little bit different to Python because this is a statically typed language, essentially. So you have to tell it I'm working with an integer, and it behaves like an integer, right? If you give it a double, it's going to complain. In Python and JavaScript, you have more loose concepts of types.

So you can be a lot more dynamic, and if you give it a double or an integer, It's just going to try and convert on the fly for you and going to try and figure out, oh, you gave me an int. So I'm just going to work with that. Whereas in C #, we have to be very, very precise about our types.

So if we tried to for example, assign-- we have a method here called math.AddNumbers, which obviously, adds two numbers, right? So it expects an integer and a second integer, for example. If we tried to passing hello to this method, it won't it won't run. It won't even compile in C #. So you won't even be able to ever test this because it will never compile. And this is where that usefulness comes in.

OK, final point, and this looks all over the place. It wasn't like that. When you declare a class, it usually has a few things inside of it. It has a list of fields at the top or properties, we'll learn about the distinction later. There's something called a constructor, which is a special method. And this is special because it's the one that is responsible for creating an instance of that class. So I have a method that can create a desk, and that's the constructor of that desk class. Then you have methods that can basically-- are the capabilities of the class and they can do whatever.

How you make new instances of things? Generally, you declare a variable, and you use the new keyword, which tells the compiler called the constructor method of this class to make a new object. So if I type in new truss, and I give it a list of points for example, it will make a new truss for me and what I get back into this variable is an instance of that truss. So here I'm making three separate instances of a truss. I could be giving it the same points, but they would still be separate instances.

So I'm going to cover this because we skipped it in the previous one, but to code in C # and to develop this we, use Visual Studio. This is an IDE, an Integrated Developer Environment, and essentially you'll see it in a second, there's a few concepts to know here. One is the concept of building a solution, which is just fancy words for saying compile my stuff. Make it work. Make it runable by a computer.

So it takes all your codes, all your dependencies, if you're importing Dynamo libraries, it takes those in as well, and it produces your program. Now what it actually produces is, depending on the type of project you have, it usually produces a DLL file. And this is that intermediate object representation we were talking about. So this is where all your code gets compiled to, and it's now ready to be run by the .NET Framework.

You can also create .exe files instead of .dlls. So you can create standalone programs that are just straight up run. Now those will run but they won't be useful to anyone if they're just a library of functionality, for example. So most of the time we want to be making lots of libraries, and then we have one program that can run those libraries and use them to interact and do stuff.

Coding time. So can everyone please launch Visual Studio 2019. It should be on your desktop. And I'm going to swap over to the computer if I can. So, if you guys go to your Data Sets folder, and I'm sorry if you can't see me over there. Can't see it? Five, you're OK. Cool.

So if you go to your Data Sets folder, we're going to be in session two. And you might want to pin this folder to your Quick Bar here. To do that, I'm just going to drag it to the Quick Access here at the top. So I can just refer to it really quickly. I'm just going to move the microphone.

OK, I'm going to go open up exercise one. And I've included sample files for both the start and the complete version of each exercise. So if we get stuck in exercise one, and you just want to catch up at the next one, feel free to just bail on it, and then in exercise two, there's a kind of a start, which brings you up to speed with where we should be. We're probably going to be using those just to make sure everyone is on the same page. So I'm going to go to exercise one start. And I'm going to double click the solution file, which is the SLN. If you have Visual Studio, open you could just go File open, solution, or something like that.

OK so, let's really quickly run through Visual Studio, and then we're going to start typing up some code. But before I forget, and I almost did forget this. I'm going to need everyone to open Chrome and make sure you open it inside frame, and not using the bar at the bottom. And go to github.com/dynamods/dynamoworkshops. And you should see this. This is the repository where all the files that we use today are hosted for all of the four sessions and all of the exercises. They also include stuff from last year, so we're mainly going to be looking at the 2019 folder.

I'm going to be pointing you guys to a very specific file where we're going to be copy pasting snippets of codes to kind of make us go a bit quicker and not type everything out. So just keep it open. Don't close it. And I'm going to be switching back and forth between Visual Studio and Chrome, if that's OK with everyone. This is also publicly available, open source, and MIT license. So when you get home, download it go nuts with it. Is everyone up to this point? Yeah? OK.

So can you please go to the 2019 folder, and then click on the Dynamo For Software Developers folder, and then click on Session 2, C # Fundamentals. Now if you remember what we said at the beginning of the day, we're going to try and pretend we're space work for a day. So what we're trying to achieve with session 2 is a C # library that can basically model the concept of a desk, model the concept of people having memberships to our kind of space business, and the concept of being able to layout of room with some desks. So we want to be pretending to be desk architects, if you will, and layout the space.

That's why we're going to get through by the end of the session. And I've split it up into several exercises. So we're going to start with exercise one, and whenever I ask you to paste-- copy paste a snippet of code, please come back to this window and just copy whatever is in between the gray background, and none of the things that are on the white background, OK? So gray background, it's code. Not gray background, it's an explanation of what I'm doing there.

So going back to Visual Studio.

AUDIENCE: [INAUDIBLE]

PRESENTER: Does everyone have their glasses on? I don't know how to answer that one. It should be great. Maybe the screens are a little bit lower quality or not. Keith, we've got someone there. Speaking to that, I'm going to change my glasses. Are we good? Yeah. OK so I'm going to give you a crash course into Visual Studio, and all the things you need to worry about, and all the things you don't need to worry about and you can learn about later.

The interface is quite simple. You have a Solution Explorer on the right hand side, which is basic your Windows Explorer. It shows all the files, all the code that is in your solution. It's called a solution because you can have multiple things inside of it, to it. We have one project called DynamoDevS2E1start. And what you need to know is that every project gets compiled to its own DLL, or its own executable. So if I have three projects, that means I will produce three DLL when I compile.

If you open up the Dynamo solution, if you download it from GitHub, you're going to see there have something like 25 projects in there. That's because they've split up the functionality into discrete little projects that can interact with each other. So there's a core. There's a user interface project. Then there's ProtoCore, which is the actual execution engine which is separate from all of this. So it allows you to keep things quite modular, unlike in Python, for example, when we saw we had everything in one file. So you can still pull up your files obviously in Python, but this enforces you kind of to do that a little bit better.

Inside the project you have something called dependencies, and we won't look at this too much in detail today, but you also have something called desk.css. So every C # code file ends with .cs. So what I want you guys to do before we kind of get any further, just to make sure everything works because demos sometimes have issues, I want you go to the menu at the top right, click on Build, and just click on Rebuild solution.

Now if everything went well you should probably see what I'm seeing here, which is the output on the screen. And it says rebuilt all, 1 succeeded, as in one project succeeded in building. That means that everything went fine. The compiler was able to take our code, put it into a DLL, and we can now continue to add more code. Is everyone's solution compiling?

AUDIENCE: [INAUDIBLE]

PRESENTER: OK, we have one with packages missing. Two. Did you click on rebuild? Did you click on build or rebuild?

AUDIENCE: [INAUDIBLE]

PRESENTER: Keith, we've got packages missing over here? By the way, this is a .NET standard so. It's here. And one more there.

AUDIENCE: [INAUDIBLE]

PRESENTER: So, yeah if you get an error on your screen saying failed to restore packages or something like that, you might need to copy that folder onto the desktop, and then run it from there because Windows has stupid limitations about how long your path can be and where the data sets are, it's quite long. OK so just raise your hand if you need assistance with that.

But without kind of anything else, I'm just going to point you to the error list at the bottom. This is basically the compiler doing the heavy lifting and providing you with lots and lots of feedback about what's happening when it compiles your code. So I can turn off the errors. There aren't any, thankfully. And it has seven warnings. So it's telling me, oh, by the way you should probably look at this. Something doesn't quite make sense, but I was still able to compile it. I can turn off all the warnings because we're not doing production code here, so we don't care about it today. But please look at the warnings when you're at home or writing code for your office, OK. Don't just ignore them.

I'm going to close the output window because I don't need it at the minute. And I'm going to double click in the Solution Explorer on desk.cs. And this is where things should start to get a bit familiar because we talked about classes, but essentially what we have here is the code inside that file. And what we're looking at is a couple of using statements, which essentially is a way of saying, oh, I want to use the functionality in this other package, this other DLL file. So please import it into this code file, so I can use it. So when I say using autodesk.designscript.geometry, there should be an Auto NAT DesignScript that geometry yellow somewhere, and it should be able to import it.

Now I've already prepared the solution, so it's got everything you need in it. If you want to know how that's done go to the GitHub file-- sorry, go to the GitHub site. We don't have time to cover that today. And I found that it really doesn't help in demos in classes. But that teaches you how to do it on the site if you need to look at it.

The next statement is something called namespace, and this is just a fancy way of saying this code that I am going to write in between the brackets that follow namespace belongs to this group or this kind of functionality. So it's a way of saying, oh, I'm going to package up all the my functionality to this group. And you can go namespace dot something else to kind of make a subfolder of that and group your functionality there. So it's just a way to organize your code. It has no effect on how it runs. It's just a way for you to kind of keep it organized and clean.

You see for example autodesk.designscript.geometry, that's the full namespace for that particular project. So anything inside that project is going to be autodesk.designscript.geometry dot something else, essentially, every class. So our namespace is dynamodev, and then we have a class inside of this. Our class is declared using the public access modifier. And then we type the keyword class, and the name of the class, which is desk. We open curly braces, and then we can type code.

Now I've prepared this file to have one property. So what we're going to do now is we're going to add a few more properties, and then we're going to add a few more classes to go through the motions. And then we're going to have a tiny little library that knows how to do a desk and a person and a few other things, OK?

So I'm just going to quickly check GitHub to see where we are, and what we want to do is add a few more properties, like length, height, width, and maybe the price of a desk per day because we're a space provider. We care about how much money we make. So I'm going to go to Visual Studio, and I'm going to enter some new lines, and I'm going to declare a few more objects-- sorry a few more properties. The same way that length is done. I'm just going to change the name of the property of this instance. So I'm going to I type in public, double, height. I'm going to use that same get set statements as above.

Now explaining what this does, we're declaring a property called height. It is public so other people outside of our code will see it. And it's of a type double. So that means it's a number with a decimal point. The bits after height are a nice kind of feature of C #, where if you declare a get and a set, that means that this property can be get. So I can get the value of this property. And I can also set the value of this property.

If I were to, for example, go set, I could set the property of-- sorry, set the value of this property, but I could never get it. If I tried to get it, it will tell me denied. So this is a handy way of kind of managing access. Yes. Although I don't think you can actually just set. I think you always need a get with a set, but you can have a get and not have a set or have a private set, for example. So only the class itself can set the value.

We won't go too much into detail about the distinction between properties and fields, but just know that this is syntactic sugar from the C # compiler allowing us to write less code. If you look at the snippets, I've actually included what this code would actually generate out to. It would-- the C # compiler would make another field in the background for you called length with a small l, and whenever you get the one a capital letter, it actually gets you the value of the small one. And whenever you set it, it sets the value of the small one. This is just a way to manage access and make sure that we're not kind of hitting the same object. And I won't go into more than that because it can be a full day just on that.

So we have a site-- height, let's quickly add a width to the desk, and then we'll add a price. So I'm going to go public double width. And just to show you why I said that Visual Studio and C # are a lot friendlier and a lot more productive to things, you can see that I'm typing a lot of the same stuff and just changing the name of it. And I could copy paste.

Or, for example, you can type in prop, don't press anything afterwards. And the little box you see underneath is something called IntelliSense, where the Visual Studio program kind of tries to figure out what you're trying to do and provides suggestions of what your code should look like or what the available methods are or what properties you could use. In this case prop is a snippet.

So if I type prop and then I hit Tab twice, it will autocomplete to a full property. And it'll automatically jump to int, so I can type in double, and then tab, and it jumps to the name of the property and I can call this pricePerDay. And for a pricePerDay, I'm going to delete the set here because I only want to be able to get the pricePerDay. I don't want to be able to set it from outside because you know intrepid users would just set it to 0 and not pay. Any questions so far on making properties? No?

So in the previous class where Tom was accessing wall.id for example. What he was doing is he was accessing the id property of the wall class, which is what we're doing here. We're declaring these properties of those classes. So this will hold data. This is where the data will sit and we will be able to access it.

So going further, what we also want to do is we want to basically assign a desk to a person because this is a kind of co-working thing, people don't have set desks, or maybe it's hot desking or something. We want to know who is currently sitting on that desk or if it's reserved to a specific person. So I'm going to declare a property called public person occupier. And I'm going to go get set. I'm just going to quickly check my snippets that I want it to be a get set.

Now what you'll see here is that well, you've got the red squiggly line under person. And if you hover with your mouse over, it, says the type or namespace person could not be found. Are you missing a library or something else? That's because we don't have a person class. The Autodesk library doesn't have a definition of a person, and neither does the kind of built in system C # library. So what we need to do is we need to make our definition of this type. So we're going to make a new class.

Now we could make a new file, or if you hover and you go to this little light bulb icon, it should actually give up a suggestion, oh, why don't you generate the type person. And I'm going to go click on generate class person in a new file. And what you'll see on the right hand side is the new person.cs appeared in my browser. And if I double click it, it automatically put it in the same namespace. It declared the class for me, and I can start adding code to this.

So this is how productive and kind of useful Visual Studio is. I don't have to right click, make a new file, type in the name. I can just declare right I need and use these kind of suggestions to get really, really productive. If you start knowing the keyboard shortcuts, you'll be essentially flying through this. Everyone up to here? Everyone got the person.cs file?

OK, so what properties do you think a person should Have if we go back to here. I'm cheating by showing you what it should have. No, still no ideas? OK, let's go ahead and make them. Now I'm not going to make you type name and email again. So I'm just going to select them. Copy and I'm going to paste them inside the class just to save some time.

And essentially what you should get is red squiggly lines under this type called guid. Now any now anyone know what a guid is? I have one. So guid is a globally unique identifier. So that means that there is a almost guarantee that this string, this text, is a globally unique text. So if I give you an ID it'll something like ABC123-F9 something something. It's a long string, right?

And then when I say it's almost guaranteed, it means that it's going to try and generate a unique one. And there's like a 1 in 10 million chance it generates two that are the same. So you can generally rely on them being unique. Anyone use the in Dynamo Revit it element.id that's usually a number. Those are very hard to make unique. So what you usually use is element.guid or other things which are the specific type which are more unique.

So it's under red squiggly lines because we don't have the using statement for this. So I'm going to hover over it, hit the light bulb, and the first suggestion is addUsingSystem. So I'm going to click that. Adds it at the top, so now I can access that class, and I can do what I needed to do.

So now that we've defined this person, I'm going to click control+S or save here at the top. And I'm going to go back to my desk.cs file, and you'll see that person is no longer underlined with red, which means that it can find this class and use it. So I've just declared a desk. It has a length, height, width, pricePerDay, and also has a person that is currently occupying that desk. So we're starting to kind of get a sense of what the business of space work might be here.

So what are we going to do next is we're going to look at membership. So back in the person class, I'm going to add one more property, and you can feel free to copy paste this snippet, and I'm going to do the same public membership. And I'm going to call it membership. And again, it's a red squiggly line, so I can hover over the light bulb, generate the membership file in a new class. So I the class in the new file. And if I go over to it, this is called public class membership now, and I can add some properties to it.

Now what do I want with a membership? I want the membership to be unique. So I don't want people to share memberships. So I would need something that can be identified. So I'm going to add a guid, another identifier property. And I also need to specify what membership type this is. So I'm just going to quickly add these. So I'm going to say public guid and this is a get set. And again squiggly lines means hovering over using the suggestions. And then I'm going to type in public string Type with a capital T. And I'm going to use it get set again.

But looking at this, if I were to declare my membership type, like for example, co-working, or a dedicated, desk or a private office, I would have to basically spell it out as a text private office every time I wanted to use this functionality. That wouldn't be very clever because I'd have all of this text laying around, and if I spell it wrong once inside these brackets-- or sorry inside the commas, I invert the commas, my program essentially be wrong. It would compile, but the logic would be wrong.

So when you're trying to define something that has a limited set of possible values, you use something that's called in C # an enum, which is an enumeration of something. So what I'm going to do is I'm going to come out of this membership class underneath it and add two more lines, and add something called a public enum membership type. I think that's what I called it. Then I'm going to copy paste the possible values from the snippets just because I'm lazy and I don't want to type.