Find the Right method

As usual - let's begin with documentation.

To create elements in Revit API we can find methods in 2 places:

• Class of element itself (e.g. Wall.Create())

• Document from Creation namespace. (e.g. doc.Create.NewRoom())

💡Notice that we need Document class from Creation namespace, not DB.

And to use methods from DB (Creation Namespace) we need to write doc.Create.MethodName() instead of doc.MethodName(). Might be confusing, but that's the design pattern developers choose to better separate methods.

​

In practice to find the right method:
​First of all go to the Class of element and look for Create method. If you can't find it, it might be inside Document and named something like NewRoom, NewFamilyInstance...

Overload Methods

Once you find the right method, you will often see Overload list. This means that there are multiple ways of using this method by providing different arguments.

This actually makes sense. Because you might need to create Point-Based or Line-Based family, so inputs will be different. \

Or you might want to create element with default values (less arguments) or provide full list of arguments. It all depends on how much control you need.

How to Choose the Right Method?

Read descriptions to better understand the difference between various methods. It tells you in human language what it is for.

However, I tend to look at the arguments so I can quicker find methods that suit my needs.

For Example: If I'm creating a point-based family, then I look for methods with XYZ argument which represents the point location. If I'm creating a line-based family, then I'd want a method with Line argument. And so on...

Also think if it's a View Dependant or Level Dependant element and so on...

It can be tricky at first, but just know that if you provided all arguments and you still don't see new element, then maybe it's worth to try another method before giving up.

It can be confusing but you'll get better with practice.

Example: Create Wall

Now let's practice. There are too many options, so I'll focus on the basics.

For example to create a wall go to Wall Class and check if there is a Create method. And luckily, you'll find a list of Create methods there.

Now, read descriptions and select the method that works best for you. I tend to use the one with default values(2nd from top), or where you need to provide the most arguments(last one) if I know the height and other stuff.

Now use it like any other method. Prepare arguments and create a new wall:

in case you wanted to use another method and provide more arguments, then here's how we'd use another method:

In a nutshell, you need to find the right method and then it's about providing the right values in arguments.

💡 If something is confusing, check Remarks section in documentation. It can be helpful on tricky elements.

Example: NewFamilyInstance

Let's look at another example - NewFamilyInstance().

This is how you create instances of any loadable family, and the trickiest part of using it is to select the right one out of 12 options...

There are quite a few things to consider:

• Point-Based, Line-Based, Host-Based, Face-Based?

• View Dependant or 3D?

Then you can visually go over the list and filter options that do not suit your requirements. Usually this will shorten the list down.

​

View-Based?

Point-Based + Level-Based?

You get an idea...

💡And don't forget to read Remarks.

Then it's about using the method. I'll use this one for the example to create a simple point-based family with Level.

Here's Syntax:

💡FamilySymbol - is a class for Family Types of Loadable Families. It's a weird name, but that's because Type has different meaning in programming so they chose this instead...

​

Now, let's create an element!

And here's our brand new VW Auto 🚗.

P.S.

Do you think I should create a an E-Book: Revit API Element Creation Cookbook in the future?

I could go over as many methods as possible and create a ton of examples so you can copy-paste them into your scripts.

Let me know if there's a demand for that.

​

Happy Coding!