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

PRESENTER 1: Cool. So now that we're back everyone, Tom is going to explain to you why it didn't work and why it was my fault, as usual. Blame the other guy, you know. And then, we're going to go straight into extensions up until 5:00, and we're going to do a bunch of stuff. So hang in there. I know it's been a long day. It's only got 90 minutes left so. Tom.

PRESENTER 2: Just so it's on record. OK, so the issue here-- and actually, it's kind of good this happened because, of course, when you guys go about your offices and you can boast that you don't know Seashell from Python and you start writing all of your own nodes, this is going to happen. You're going to have this amazing script. You've run it, and then of course, it doesn't work. And it can be very frustrating.

So there's many different ways of addressing these kind of issues. The most common is actually debugging, which unfortunately, we can't show you today. But maybe actually afterwards, we can show you because it's an important skill to have. But anyway, if I run this, first of all, does it run? The answer is yes. It's definitely running because I'm getting desk coming out of there. The problem is, I can't see them anywhere. So what's the issue?

So the most obvious thing that I do is just click on the ID. And Revit is showing me the desk. And by the looks of things, that isn't desk. So I'm like, hey, well, it's selected. So I'll go to view. And then I do-- where's that crop box [INAUDIBLE]. OK, try that again. Yeah. OK, so if I'm try to select this, it's showing me literally nothing.

But I can select the desk somehow. Let me just trying to find it. OK. OK, this is my desk. Although it doesn't look like much of a desk, but I managed to locate it. If I click on this desk, you'll notice that when I do edit type, with the depth above 0. So that explains the problem. Thanks, [INAUDIBLE].

So yeah, so this node, of course, is a reliance. It's called dependency on the desk arrangement object. So when it's reading all the desks, of course, those abstract desks have a 0 length and a 0 width. So in this case, the solution would be to go back into our code, update that desk object so it actually has a valid length and width, and then, of course, we just recompile and rerun it and it's problem solved.

And then, we can always just check this manually if I go in and modify this. And then apply. I've now got proper desks again. So I know that's definitely the problem. So yeah, these things happen. It's not a bad thing. You are only human. You will invariably make mistakes. Or you get a phone call, and then before you know it's broken your train of thought. I mean, you forget to update something and you run it. And before you know it, it doesn't work anymore. And it's very common.

So in actual fact, that's not a bad thing that happened in the workshop because that actually gives you guys, once again, more insight into the types of scenarios which are going to occur when you start developing. And do not get disheartened because it's going to happen, and it's going to be frustrating. But perseverance pays. That's the one takeaway that I've got about coding.

The individuals that tend to excel are the ones that when they are confronted by these kind of problems, they don't give up until they find out what the cause of the problem is. So yeah, that was the issue and that's not fixed, and it is now working. So if I go to my floor, you can see that I've got a really high density. And whoever owns the building is going to be really happy because they can rent out multiple different desks to multiple different people. But of course, you know you can see we'll also need to just resolve the spacing of the desks inside this room as well.

But either way this works. Unfortunately, we're not going to have time to do the path of egress. But in actual fact, it's a very simple Revit API call. It's literally one line of code. And you'll find that on GitHub. So there's a good opportunity for you guys to-- after the workshop, go ahead and build some more zero touch nodes using what we've got on GitHub to build those two classes, the egress result and the egress check class to give you the results about the path of egress from each desk to wherever you want to escape from.

So as I said, we're not going to have time to do that now. This gives you, again, more of an insight into how you can declare. So your [INAUDIBLE] classes level what Revit showed you. Then, declare say [INAUDIBLE] specific classes. In this case, I've declared these classes are specifically for zero touch import, which then take information from those classes and then use it to then output information that's then readable within Revit. In this case, it's the output of desks.

So yeah, that covers everything for zero touch. So hopefully that, again, gives you more ideas how you can use C # to generate your own node libraries. And as I said, check with GitHub. There's more stuff on there for the path of egress. And if you've got any questions about today's session, then please feel free to fire away now. OK, any questions? OK, good. Go ahead.

AUDIENCE: [INAUDIBLE]

PRESENTER 2: I suspect with it being the Revit API, it will just treat an L shaped room as a big square. Because Revit API treats flat surfaces as untrimmed. It's a limitation.

PRESENTER 1: The desk layout there just takes the surface, so it should work.

PRESENTER 2: Yeah, but that's my point. In Revit API the surface. Mind you-- actually, I guess if you're using Dynamo [INAUDIBLE]. OK, if you're using [INAUDIBLE] it's fine.

Yeah, there is a limitation inside Revit's geometry engine, where if you have a completely flat surface that stays L shaped, basically any trim surface, it will not treat it as trimmed. It will treat it as just one big elongated surface. And so if you plot points on an L shaped surface and use [? CV ?] prompts [INAUDIBLE] already is done. In Theory, it should follow the surface [INAUDIBLE] space. But Revit doesn't honor that if it's completely flat. So it's a bit of a flaw.

But let's try anyway. If we go for an L shaped room, let's have a look at what it actually does. And of course, if it breaks again, I'll just blame [INAUDIBLE]. OK. OK, one of the limitations that I've got is every time we're on the node, it tries to create it's family type. And if it's already created, and I try and create it again, Revit is like, nope. You can't create it again. So I always just delete it. So again, that is another limitation which it needs to update. And it's another good example of the kinds of issues which you might be confronted with yourself.

So what you do in that instance is just check that it already exists. And if it does, then just go ahead and make the modification inside the code. And of course, this would change the desk size. Because it's still 0 0.

AUDIENCE: [INAUDIBLE] just click the project [? parameter. ?]

PRESENTER 1: [INAUDIBLE]

PRESENTER 2: Yeah.

AUDIENCE: [INAUDIBLE]

PRESENTER 2: Thanks. This is [INAUDIBLE]. Yeah, so in that case, you'd perhaps want to think about other ways of sharing desks with an arrangement. There's actually many ways of resolving that. So even though there are these limitations inside Revit and [INAUDIBLE] Dynamo's geometry engine, it's not the end of the world. Because there's always methods that you can use as a developer to get around these limitations. And that's also part of the fun of it.

So yeah, there are limitations, even in the API. And you might find you've got to write clever techniques to get around it. But yeah, in this case, it's not going to handle L shaped rooms. Yeah. Great, OK. Well, thanks very much for staying alert. And I'll [INAUDIBLE] now is going to go through Dynamo extensions. Which, as you know, they're essentially just add-ins for Revit. So you can do add-ins for Revit, then the same thing for Dynamo in essence. So I'll leave it with [INAUDIBLE]. Thanks.

PRESENTER 1: OK, so we made it. We're at the end of the day. We're going to talk about extensions.

[INTERPOSING VOICES]

PRESENTER 1: Yes. I'm going to give you a very, very brief 10 minute overview of extensions, what they're capable of, and what they involve in development. Because it's quite different from doing the C # with the zero touch stuff. There's a little bit more involved. And then, we're going to dive right in and create our own extension.

I'll give you a preview at the end of what it's going to look like. But diving straight in, making an extension involves a couple of things. First one is, actually, coding the extension as a .NET assembly, like we've been doing in zero touch, for example. And you have to implement some very specific interfaces that Dynamo team have created for us. And the second thing that it involves is actually making an xml file where we declare that this is an extension, and which dll to load the extension from.

So when Dynamo starts up, it looks for these xml files. If it finds one, it's like, OK, this is an extension next xml. I'm going to look for the file that's inside of-- that it's pointing me to. And maybe I find an extension in there.

So like I said, Dynamo starts up. It looks for these things. If it finds the xml which is pointing to a dll file, which by now, you should know is what is the output of a C# project. It tries to load that dll.

Now, naming is very important, and this gets me every single time because I keep forgetting it. The name of the xml file needs to be the same as your dll, I think. So if your extension is called myextension.dll, this should be my extension_extension, not xml. The other one should be called my extension_viewextension. And we'll see the difference between the two in a second.

Which brings us to the architecture of the extensions and what happens when Dynamo tries to load one of these. So Dynamo starts-- when you first launch Dynamo, it goes through a process of starting up, right? It initializes the computing engine, and then at one point, it starts looking for these extensions or plug-ins, right? So just need to see the screen here. It gets-- I don't know if you can see my cursor. I can't see what I'm doing.

So basically, once the Dynamo engine has initialized, it starts looking for extensions, right? If it finds one, it loads the dll. And it tries to load to-- it calls a very specific method on that extension. It calls the loaded method, which tells your extension, oh, by the way, Dynamo has loaded. Here's some information about Dynamo. Then, it continues with starting up Dynamo. And then it finally reaches to a point where it initializes the user interface of Dynamo.

Then, it looks for view extensions in Dynamo, which are extensions that know about the user interface of Dynamo. So if it finds any of the extensions, it also calls the ready method on those view extensions to let the extension know Dynamo user interface is ready to be interacted with. And you can modify it or intercept it.

So as you can see, the extensions are much more powerful than zero touch nodes or the C # nodes that we were looking at because they know about Dynamo. And they can interact with it and control it, to a certain extent. So when Dynamo gives its references to these extensions, it tells, here's a reference to my user interface. There's methods on there that you can use to change the user interface and interact with it. Use it responsibly, is what Dynamo is trying to say, essentially.

So I won't go too much into this because I don't think we need to cover MVVM very much. But there is an extension manager inside Dynamo. And all this is to say is that if you develop an extension, you can actually make use of other extensions. A great example of this is the new dependency extension that we saw [INAUDIBLE] demo earlier. That one is actually calling the library extension saying, oh, are there any kind of packages installed? Give me the list of packages that are installed, and I'll see if any of the nodes missing have libraries there or not.

And then, it calls into the package manager extension and says, oh, actually install the missing one. So that's an extension that makes use of other extensions to provide this very advanced functionality. And that's what this is trying to show that you can-- if you have a view extension, you can interact with the other ones via this Dynamo extensions manager.

So what happens when Dynamo calls these startup methods in your extension? It essentially gives you a reference to some of its internal objects, which means here's a copy of who I am, and you can use this object to do stuff. So the two objects it gives you are called ready params, which you get that object when the view has loaded. This only happens in view extensions. And the other one is called start up params. It's also for the view extensions. And that means that the view is starting to be initialized.

So your extension gets called by Dynamo twice. Once when it starts initializing the view, and once when it's finished initializing the view. So if you were really mean, you could write a view extension that every time Dynamo tries starting up, it kills it. And it prevents it from starting up. No use for it whatsoever, but you have that kind of power and responsibility when you write extensions, if that makes sense. Hopefully, guys can think of better use cases than the examples I'm giving.

But in terms of like knowing what's involved in making one of these extensions, basically your view extension is aware of two things. It's aware of the Dynamo model, it's aware of the-- and aware of the Dynamo view model. I won't spend time going into view models and these things because it would take us a bit too long.

But essentially, the Dynamo view model is the middle layer, the manager that is responsible for reconciling the data of Dynamo, like the graph engine and all of those things, to the user interface. So it's the middle man between the two. It's keeping everything in sync. And that also, when you do something on the user interface, it tells the underlying Dynamo engine, oh, do the thing that was requested of you. Does that explanation make sense?

So one of the cool things about extensions is that when Dynamo calls your extension and gives you these references to these objects, you can also get access to events inside of Dynamo. So Dynamo publishes these events that essentially are triggered every time that particular thing happens. So in this example on the screen, we have an event called node added or node removed.

So every time you add a node to the canvas, Dynamo fires off this event. By the way, the node was added. Doesn't give you any more context than that. Just says, a node was added. Here's the node that was added. So you can subscribe to events like that. And basically, get notified when things happen in Dynamo and then react to them, which is what we're going to be doing today.

So let's get into it. And here's a very brief demo of what we're going to build. We're going to make a view extension that can say hello. So I'm going to start it again. So you're going to get a menu inside Dynamo that says dev workshop. You can say hello and it'll say your username. You can also launch this new window, which is like an input statistics window, which will tell you how many nodes there are on the canvas, how many connectors or wires there. And also, if any of the nodes are marked as is input, which is very useful in refinery and other places, it will list them separately in a table and it will list the current value of those inputs.

So if you have these big graphs like we do at practice, for example, you usually have a group on the left with all of your inputs. And you're all the way somewhere on the right working on your logic and you forgot what those inputs are. You could have this little window open and it would tell you what those current values would be. Obviously, an improvement for this would be to be able to click into those values and change them and that's your homework. I can't do all the work for you.

All right, so let's get into it. The first exercise we're going to do is actually make a basic extension in Dynamo. So I'm going to swap over to this other computer. So if you can open the data set. And if you go to the S4 extensions folder, you should find an exercise 1 start folder. And just open the SLN file. The Visual Studio solution inside there.

Now, what we've done to save time in workshops like this is we've prepared the solution so that whenever you build and then you press start, it automatically builds your extension. It packages up as an extension. As a dynamo package, essentially. Puts it into the right folder in Dynamo, and then launches Dynamo for you. So what this means for us is that we write some code, we press start, Dynamo is immediately fired and we see the result of our codes. If you're interested in how this is set up, there is a bigger guide on the GitHub page and other repositories. It just takes too long to set up for demos like this.

OK, so let's start adding our extension. So the first thing I'm going to do is I'm going to add a class on here. But before I do that, let me just show you these xml files so you understand what's been prepared for you. I've prepared the xml files that define an extension and the view extension. You can see that I'm going to be calling our extension Dynamo dev, and our extension actual class name should be extension sample. And the view extension is going to be called view extension example.

So because these are the names we've put in the xml, these are the names we're going to have to use for our class. If we change the class names, we're going to have to come back to the xml to change our declarations here, OK? So I'm going to close all of these, and I'm going to right click on the project which is the little C # green icon. Click add. And click on class. And I'm going to call it extension example.

Remember, to add public in front of this so we make it discoverable by Dynamo. All right, and the easiest way to do this is I'm going to write after the class name I extension, which in C # terms it means that this class needs to implement this interface. And if I hover over it and use the light bulb, it should give me a suggestion to add using Dynamo.extensions. This will not clear the red squiggly lines, but this should make extension look blue or green or whatever color this is.

And if you hover over it again, it says that it doesn't implement certain interface members. So this is where Visual Studio is very helpful, again. I don't need to necessarily go to look at the documentation and implement each one of these things by hand. I can just click the light bulb and go implement interface. So what you'll see happen is a bunch of different methods and properties have just appeared on my screen, which means that this is the contract that Dynamo gives us.

If you want to be an extension, you need to have these two properties and these four methods. And then, I can consider you an extension. So by implementing this interface, we're essentially guaranteed to be able to talk to Dynamo as an extension. At the moment, all of the methods throw a not implemented exception. That's just the code that was generated for us. So now we're going to go in and change this.

Do you still have the chrome GitHub ripper open for the snippets? In case we need to copy paste some stuff.

AUDIENCE: [INAUDIBLE] a little bigger?

PRESENTER 1: That better? Can't do much about the thing on the right hand side, unfortunately. OK, so unique idea. I'm going to delete that part. I'm going to go to my snippets. And I will copy-- well, I don't think I actually have that here. So I will have to show you guys how to generate a new unique ID. So if you go to tools and you go to Create GUID, a new window will pop up. So if you have this window, select maybe the fifth option, right? And go copy. And you can exit after that.

And if you control view on your keyboard paste, that gives you a new GUID on the canvas. And you just delete everything that is not in between the inverted commas. So all we really care about is the string that's inside that GUID. So each extension needs a GUID because it needs to be a uniquely identifiable extension. We should be familiar with this because we use these GUIDs in our C# class third year.

Name. I'm just going to give it the name extension example. And again, I have to put it in between commas. Semicolon at the end. I don't need to do anything in this post. So I can just delete that code and leave nothing on there. And for the other ones, I'm just going to delete all of these lines that say throw, and we're going to replace them with other things.

So what I was telling you about earlier, that these extensions have a certain lifecycle that Dynamo calls your extension at specific points in time when it starts up and it does things. These methods are how we interact with that. So we're building an extension right now. So we don't know about the user interface. But Dynamo is able to tell us when it's starting up. So that will be the startup method. And ready will be called once Dynamo has fully started up and is ready to be interacted with, but not in a user interface way.

So let's make some message boxes pop up just so we exactly see the result of this happening. I'm going to go to my snippets, and I'm going to copy this messagebox.show snippet. Alternatively, you can also type it out. It's not very long. So messagebox.show. And we're going to put some text in here and the extension is ready And a semicolon at the end.

And message box will be underlined with red. So just hover over it, hit the light bulb, and go ad using system.windows, which if you look at the top, it's added it for us. And that way the message box class is available for use. I'm going to copy paste this into the startup method. I'm going to change the text to say the extension is just starting up. Actually, I'm going to say Dynamo is just starting up.

You'll also notice that these methods get called with some parameters. We learned about this in the C# class. And these are the object references that I was talking about the Dynamo gives to you. So it gives you an instance of the start up parameters class. And if we pick that to see what's inside of that class, you'll see that we get a reference to the preferences of Dynamo. We get a reference to the library loader, the version of Dynamo, and a few other things. That's the startup one.

The ready one has different things available to it. So if we pick that definition, you'll see that you get a workspace model and a command executive. So this is starting to be a bit more advanced already. And if I look at that workspace model, I can continue peeking. I get a name, description, and file name for the workspace, which means you're currently open graph. And I also get connector and node models. So this is a list of all the nodes and all the connectors in your workspace graph.

So you can see that just by looking at the things that Dynamo gives us when these extensions are initialized, we can already interact with it and see what's inside Dynamo and write some code to react to that. So I think this is ready enough for us to actually test. So I want you to hit build and build solution. And if everything went right, you should see one succeeded.

And now, if I'm going to hit start, which is this button on the toolbar, what should happen and doesn't happen is we need to tell the solution where Dynamo is. So right click on the project, go properties, and if you go to the debug menu on the sidebar here. After program files, there's a slash. Just add in Autodesk over there.

So what happened is this was where Dynamo was installed last night, but today it's in a different place. Because that's how labs work. So hopefully that's the right path. So if we press start again, this time it should actually work. It's compiling in the background. Its packaging up our extension as a Dynamo package. It's putting it in the Dynamo packages folder. And then, it actually starts Dynamo.

So what you're seeing here is the message box that we created that says, Dynamo is just starting up. And notice that we get the message box, but we don't get the UI of Dynamo. We don't get anything else. This is because our extension was loaded before the user interface of Dynamo was loaded. Before even the entire engine of Dynamo was finished loading. So you get really early access to how Dynamo works.

So I'm going to click OK. And what should happen is the engine has now finished loading, so we get the extension is ready. And after that, and after some other time, Dynamo actually starts up, OK? Very exciting stuff. Message boxes appearing on a screen. But hopefully, you can see where you have a lot of power. You get early access to Dynamo and you can tell it to do stuff and modify its behavior before it's even started, and Dynamo would not even be aware that that has happened, necessarily.

Any questions so far? Anyone whose solution isn't working like this at the minute? Anyone actually trying to make it work? We've got one or two. OK. Well, shall I keep going? All right, let's see a few extension, and then we can add some code that actually does some stuff after that. So I'm going to close Dynamo and that will finish my debugging session. And I'm going to close all of these other windows I have. And I'm going to right click on the project and go add class. And I'm going to call this view extension example.

And guess what? We're going to do the exact same thing. We're going to make this a public class. And this time, we're going to implement an interface called I view extension. So they're slightly different. Again, I'm not going to hover over the light bulb and I'm going to add using Dynamo.wpf.extensions. So this is already hinting that it's a different one. Then, I can hover over the I view extension interface and tell it to implement interface.

I'm going to go back to my extension copy paste the GUID because I can't be bothered to generate a new one. Just make sure you put the quotes before you paste it in. And then, change the last two letters to 99 or something so it's different to the first one. I'm going to change the name to be view extension example. And I'm going to get rid of all of these throw statements. And I'm going to replace them with-- guess what? Message boxes again.

So Tom was telling you guys earlier how it's really important to have this debugging skill and the ability to understand what your code is doing. Message boxes are the poor man's version of that. Where if you don't know how to do that, you just put loads of message boxes everywhere. It is not the recommended way to do things. We are only doing this to demonstrate to you when these things fire. Because once a message box fires, everything else pauses until you click OK, all right? So that's why it's important to see when these things are happening.

So we've added two more message boxes in the loaded and the startup. Now, because this is a view extension, these things will come after the extension. So let's change the text to reflect that. So let's say the-- view extension, I'll make that screen is ready. And the view extension-- well, is not ready. Is starting up. And it's not the extension, but the Dynamo UI.

OK, I'm going to save and I'm going to click the Start button, which should recompile our solution and ship it to Dynamo and start Dynamo. We are still going to get the old message boxes from the extension because we're loading both the extension and the view extension. So Dynamo is just starting up. That's from our extension. The extension is ready.

The Dynamo UY is now starting up. And then, you'll see the Dynamo user interface appear. And at some point after that, the message box that tells us the Dynamo UI is ready pops up. So it shows you this clear sequence that Dynamo starts up in. Any questions on this?

AUDIENCE: [INAUDIBLE]

PRESENTER 1: Can we?

AUDIENCE: [INAUDIBLE] the extension [INAUDIBLE].

PRESENTER 1: It behaves the exact same way. It's just when you press start, you're going to tell Revit to start. You have to manually start Dynamo in there. So as always, my suggestion do it in sandbox. Only go to Revit when you need that headache. OK, so we've got message boxes now. So what should we do next? Let's make that many item. Yeah? Got a question? Yeah.

AUDIENCE: [INAUDIBLE]

PRESENTER 1: Just make sure that the string you pasted at the top is different from the first one. If they're the same, Dynamo will refuse to load them. Because that thing-- the extension manager that allows you to talk to other ones is the one managing these things. And it's [INAUDIBLE] it's on top of things.

OK, so let's now actually start modifying Dynamo. We know when these things are happening. I'm going to go to the extension and just get rid of these message boxes because they're going to be very annoying. And I will get rid of them and the view extension as well in the startup. I might leave it in loaded just so we know that it's still working.

And now, we want to add a menu item to Dynamo. So we are actually modifying Dynamo from the extension. So first thing I'm going to do is I'm going to add a property to the view extension here, and then I'll mark it as private because I don't want anyone else having access to this. The type will be view loaded params. And I'm going to call it view loaded params.

Now, what this is is us, basically, keeping track of this particular view loaded parameters object that Dynamo gives us when it's fully loaded. The reason we want to keep a reference to it is because to interact with Dynamo, we need to go through this object. This object is the bridge between the extension and Dynamo, essentially. So it allows us to call into Dynamo and react to it.

So in the loaded method, I'm going to go write another line of code and say, this dot view loaded parameters is equal to P, which means I'm assigning this object that Dynamo gives me to this property on our class just so I have it for reference later on and I can use it for other things.

OK, so now we want to add the menu. So how do we do that? Well, we need to interact with this view loaded parameters object. We're doing fine on time or what? OK. Cool. So I don't want to do this inside of the loaded method because it's going to become a very bloated code. And we're just going to end up stuffing a lot of stuff in here. So I'm going to make another method on here, and I'm going to say private void make-- with a capital M-- menu items. I don't need any parameters. And inside of there, I'm going to-- well, first of all, go and make a new property at the top under the view loaded parameters. I want to make a property that keeps track of our menu. So I'm going to make a private menu item extension menu.

All right, and if you hover over a menu item, hit the light bulb, you're going to get a suggestion to add system windows.controls. So going back to our make menu items method, I'm going to write this .extension menu is equal to-- what we learned in the C# class, to make a new object we have to use the new keyword. So I'm typing in new. And as soon as I do that, you see that Visual Studio suggests this is probably what you mean because you've declared it as a menu item. So suggest me to make a menu item.

And if I open the parameters-- sorry, the normal braces here, I see that it doesn't have any parameters, this constructor. So I will just make a new menu item. After I make it, I can also say this .extensionmenu.name-- or sorry, .header is assigned a string. So I'm going to call it Dynamo dev workshop.

Now, we've made the menu item. We haven't added it to Dynamo yet, but we've made an object that is a menu item. So the next thing we're going to do is we're going to add a few buttons to the menu item itself. And then after we've done that, we're going to add the entire menu to Dynamo. So the reason we have to do this is because you have to fully construct that menu and it's sub items and what happens when you click them, and only then add them to Dynamo. Otherwise, you can't add things after the fact.

I think you can't. You can't, right? No. OK, so let's make a new sub menu item now. I'm going to declare a new variable, so I'm just going to type in var. And I'm going to say that it's called say hello menu item is a new menu item. Right, and so that I don't have to make a new line and say that it's header is a specific text, I can open curly braces and just type in header is assigned say hello.

So this syntax in C# makes the object and then assigns the property header on that object to the text I'm writing in that curly brace. So those two things in one, and that's just a little bit shorter to type out. Is everyone following up to this point? Yeah? OK, don't see many people typing.

OK, the last thing we're going to do is we're going to add the behavior to this menu item so you see how that's done. And I'm going to type in say hello menu.click. And you can see that it's got the little thunderbolt symbol. This is C#'s and Visual Studio way of telling us this is an event. So what we're going to do is we're going to add something to this event. So I'm going to type in plus equals.

i won't get into the technicals of this, but for those of you don't want to follow this up at home, these are called delegates. And the property of delegates in C# is that they're multicast. Meaning that if I have a delegate, I can add multiple things to it. Long story short, this is an event that fires. And I can add things that listen to that event. And when it fires, we get notified.

So what's happening here we're saying, every time this say hello menu item is clicked, I will essentially make a new method here. And I'm using a syntax here which is basically making an anonymous method which will do certain things. So I will let you catch up with this because it's quite weird syntax. We could use a different syntax. We could make the method somewhere else in our code and then just pass in the name. But for things like this where it's a one line of code, you sometimes just want to do it in line like this, right? So make sure you follow this syntax.

After the plus equals, we have a sender in arguments in between brackets. And this is just like a method signature. And then, we have that equals and greater than symbol, which tells us this method should actually be associated with this function body. So inside here, inside the curly braces, we're going to do a message box.show. And you are probably bored of message boxes by now. And we're going to type in hello plus, and this is where we're going to add a bit of something else. Environments.username for example.

So what I'm doing here is I'm saying, show a message box, and the content of that will be hello. But when it calls this, it's actually going to tell to the computer, what's the username of the user that's currently logged in? Take that username, put it next to hello, and then that's what's going to show up.

So let's test if this works. But before we can do that, we actually need to add this menu item back into Dynamo itself. So let's do that. So this say hello menu item needs to go into our extension menu. So we will go this.extensionmenu items.add. And we add our say hello menu item.

And then, we go this.viewloadedparameters. This is that last step. We've added our sub menu to our extension menu, and now we're adding the entire extension menu to the Dynamo menu. So to do that, we have to go through that view loaded parameters object that we were talking about. And I have a method here called add menu item. I think this is a new one. It didn't used to be in the Dynamo API. Do I trust it, or do I go the old route?

OK, add menu item. And I give it this.extensionmenu. Now, this one's a menu bar type and all sorts of other things, so let's not use that. So this.viewloadedparamters. You'll see that there is a property called Dynamo menu. It's a read only one, but we can still use it. .items.add. And then, we can say this.extension menu.

So this last step is basically adding it to Dynamo. You don't have to type out the comment, this is just a code comment. I'm leaving it there so you see what that bit does. So the very last step to do is now, actually, call this make menu items method somewhere where it makes sense. And where it actually makes sense is in the loaded method at the end after we've recorded our view loaded parameters.

And basically, because we've already taken reference to that view loaded parameters object, we can call these methods. And it's a little bit cleaner to separate these things out. So now, if everything went OK, I press save and I click start. Dynamo should be starting. And once the UI is ready, we'll get that message box. View extension is ready.

And if you look here in the background, you see that there's no menu item to Dynamo yet. So our message box gets fired first, and then we add the menu item. So as soon as I click OK, a menu item should appear. And it's there. Dynamo dev.workshop. We also saw refinery appear after our message box, which tells you that refinery is also a view extension, which adds these things the same way we are doing.

So the refinery team, for example, isn't using anything that we don't have access to. In Dynamo, they're using the same kind of extensions API. So let's click on that menu item. I'll just get this bit out of the way. Dynamo dev workshop. We only have one sub menu item, which is say hello. And if I tap it, this says hello frame. We're all going to be frame today because it's frame. But on your computer at home, it should say hello [INAUDIBLE] or Marcel or whatever your computer username is.

Cool. So that's pretty much done in terms of a basic view extension that does just about nothing other than set up the structure of it and say hello back. So what I would suggest now is minimize the solution for a bit, go back to the data sets, and go to exercise one complete. Launch that.

We're going to have to do that same step right click on the project, go properties, and go to the debug menu. And after program files, go Autodesk and then another slash so that we tell it where Dynamo is situated. And then, when we press start, this is the full sample of where we should be with the exercise if we follow the steps in the repo on GitHub.

And what I've basically done is I've added two more sub menu items compared to what we've done. Extension is ready. I told you this gets old quite quickly. View extension is ready. And we have this menu. We have say hello, which does the same thing as what we did. But we also have this other method which says hack. Now, should I press that? All right, very good people. Hack, OK? And it takes us to GIPHY, and we see a congratulations gif.

So you've made it this far. We are adding extensions to Dynamo and we are changing its behavior. Before we move on to the next exercise, any questions? No? OK, let's see how we're doing for time and depending on that we decided to do everything or not. 35?

OK, sorry that was the wrong thing. I will close Dynamo and I will close this solution, and I will open exercise two start. Again, I'm going to have to go right click on the project, go properties, debug, and add Autodesk on here so that we can see what we're doing and launch Dynamo. Close all the windows.

And the next thing I want to show you is how to actually react to these events and Dynamo. So for example, when a node is added to the canvas, we should get notified that a node was added to the canvas and some information about that node. Because it's a class, we're not going to do anything with it other than show a message box. But you can imagine saving that information out to a CSV or a database somewhere. And that's the basic bones of an analytics plugin for Dynamo, right?