Scribd
Upload
13 views6 pages

Grasshopper Scripting 104

Uploaded by

mutashima
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
13 views6 pages

Grasshopper Scripting 104

Uploaded by

mutashima
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
You are on page 1/ 6

Grasshopper Scripting 104

Lists
In the last post we discussed applying conditional operations to single
values. But that is way too simple. We expect to process many different
values when working with Grasshopper and the power of scripting increases
when we deal with collections of data. The main collection type you should
care about is The List.

Download here the GH file (0.9.014) containing the examples.

Working With Lists

Lists can be created or processed within the scope of a Grasshopper C#


scripting component. To access an input parameter as a list we must specify
so in the context menu. This will allow us to iterate through all the elements
of the list instead of performing the defined operations for each input by
default, as happened in the examples in 103.
Now we can access the list as a whole to, for instance, measure how many
elements are there in the list with the Count property.

private void RunScript(List<double> x, ref object A)


{
A = String.Format("There are {0} elements in the list",
x.Count);
}
Declaring Lists

In order to process a list we are going to need a bit more of flow control than
just conditionals but before diving into loops let’s see how to declare and
populate a list inside a C# component.

Lists are a special construct that needs to be declared with a sentence you
should get familiar to.

List<double> myList = new List<double>();

We must precede our variable name with the words “List<dataType>” and
then assign a “new” empty list by calling the function “List<double>()”.
Whenever you see a statement with empty parenthesis like .ToString() you
are dealing with a function (called methods in C# jargon).

Let’s see lists in action:

private void RunScript(ref object A, ref object B, ref object C)


{
//declare a new list
List<int> myList = new List<int>();

//fill the list with Fibonacci series


myList.Add(1);
myList.Add(1);
myList.Add(2);
myList.Add(3);
myList.Add(5);
myList.Add(8);
myList.Add(13);

//output myList through A


A = myList;

//create a new list copying the contents of myList


List<int> myReversedList = new List<int>(myList);

//use the Reverse Method to find the reversed version of the


list
myReversedList.Reverse();

//output the second list through B


B = myReversedList;

//retrieve the third element in the list


C = myList[2];
}

We interact with List mainly through methods and properties:

 List.Add(E) will add E to the list.


 List.Reverse() will invert the order of elements in the list.
 List[i] will retrieve the element of the list with index i
 List.Count will access the property containing the length of the list;

A Note On Reference-Type Variables

In the second lesson we talked about reference-type values saying they were
more flexible. You have to be careful when dealing with them as they behave
quite different from value-type variables. Let’s seen an example.

private void RunScript(ref object A, ref object B)


{
//declare a first variable
int myFirstInteger = 3;
//declare and assign a second variable
int mySecondInteger = myFirstInteger;
//modify the second variable
mySecondInteger += 5;
//output values
A = myFirstInteger;
B = mySecondInteger;

The result here is something we would expect, the second variable gets the
same as the first, then we alter the former but the later stays the same.
Now let’s do something similar with a list of strings:

private void RunScript(ref object A, ref object B, ref object C)


{
//declare a new list
List<string> myList = new List<string>();
//fill the list with animal names
myList.Add("Dog");
myList.Add("Cat");
myList.Add("Rabbit");
myList.Add("Lion");
myList.Add("Tiger");
myList.Add("Elephant");

//output myList through A


A = myList;
//create a new void list
List<string> mySecondList = new List<string>();
//assign myList to mySecondList
mySecondList = myList;
//reverse the second list
mySecondList.Reverse();
//output the second list through B
B = mySecondList;

Look at the result:


Weird right? Despite we only reversed the second list, both outputs have
been reversed. That is because Lists, and Points, Surfaces, Meshes and
everything else are Reference-Type variables, meaning that when we
called mySecondList = myList; we where not copying the contents of one list
into the other but actually linking both variables to the same data, so if we
modify one we’ll do so for all of its references.

That’s why, on the previous example, we created the copy of the list not
using a “=” statement but a speciall method of Lists:

List<int> myReversedList = new List<int>(myList); //this will


crate myReversedList as a brand new copy of myList

Understanding this is important not to get fooled when working with loops
and complex assignments.

Challenge

1. Write a component that checks if a list has an odd number of items and if
so, returns the element at the middle.
2. Write your own version of the List Item component.

You might also like