C# Fundamentals

There are a number of basic concepts about the C# programming language that you need to know in order to get started. In this section, I describe some of the fundamental concepts used in C#, including how the code is organized, how libraries are used, namespaces, and how to document your code.

C# is a case sensitive language so you must take care when typing the names of methods or classes in libraries. Fortunately, Visual Studio’s IntelliSense feature recognizes mistyped case letters, which allows you to choose the correct spelling from a drop-down list as you write your code. Once you get used to this feature, it is very hard to live without it.

class Vector
{
    private double[] elem;
    private int sz;

    public Vector(int s)
    {
        elem = new double[s];
        sz = s;
    }

    public ∼Vector() { /* destructor body */ }

    public int size() { return sz; }

    public double this[int i]
    {
        get { return elem[i]; }
        set { elem[i] = value; }
    }
}

Vector v = new Vector(10);
for (int i=0; i < v.size(); ++i)
{
    v[i] = (i * 3);              
}
Console.Write("Values of v: ");
for (int j=0; j < v.size(); ++j)
{
    Console.Write(v[j]);              
    Console.Write(" ");
}
Console.WriteLine();

//
// Windows 10 for the IoT
//
// Example C# console application rewrite.
//
// Created by Dr. Charles Bell
//

if (size < max_size) {
  size++;  /* increment the size */
} //else {
//  return -1;
//}

How C# Programs Are Structured

Now let’s look at how C# programs are structured by examining a slightly different version of the temperature application you saw in Chapter 4. Listing 6-2 shows the code rewritten for C#.

Listing 6-2. Temperature Code Example Rewrite

//
// Windows 10 for the IoT
//
// Example C# console application rewrite
//
// Created by Dr. Charles Bell
//
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace temperature_csharp
{
    class Program
    {
        static double convert_temp(char scale, double base_temp)
        {
            if ((scale == 'c') || (scale == 'C'))
            {
                return ((9.0/5.0) * base_temp) + 32.0;
            }
            else
            {
                return (5.0 / 9.0) * (base_temp - 32.0);
            }
        }

        static void Main(string[] args)
        {
            double temp_read = 0.0;
            char scale = 'c';

            Console.WriteLine("Welcome to the temperature conversion application.");
            Console.Write("Please choose a starting scale (F) or (C): ");
            scale = Console.ReadKey().KeyChar;
            Console.WriteLine();
            Console.Write("Please enter a temperature: ");
            temp_read = Convert.ToDouble(Console.ReadLine());

            if ((scale == 'c') || (scale == 'C'))
            {
                Console.WriteLine("Converting value from Celsius to Fahrenheit.");                                                                                                                                                               
                Console.Write(temp_read);
                Console.Write(" degrees Celsius = ");
                Console.Write(convert_temp(scale, temp_read));
                Console.WriteLine(" degrees Fahrenheit.");
            }
            else if ((scale == 'f') || (scale == 'F'))
            {
                Console.WriteLine("Converting value from Fahrenheit to Celsius.");
                Console.Write(temp_read);
                Console.Write(" degrees Fahrenheit = ");
                Console.Write(convert_temp(scale, temp_read));
                Console.WriteLine(" degrees Celsius.");
            }
            else
            {
                Console.Write("ERROR: I'm sorry, I don't understand '");
                Console.Write(scale);
                Console.WriteLine("'.");
            }
        }
    }
}

In the example, the only methods created are convert_temp() and MainPage() but this is because you are implementing a very simple solution. Had you wanted to model (create a separate class for) temperature, you would still have the one class named Program with the MainPage() method (which is the starting method for the application), but would have added a new class named Temperature, which would contain its own methods for working with temperature. Indeed, this is how one should think when writing C# code—model each distinct concept as a class. Here you see the sample application named temperature_csharp was implemented with a class with the name Program.

Wow, that’s quite a change from the code in the last chapter! While the functionality is exactly the same, the code looks very different from the C++ version. The following describe the C# concepts I have implemented in this example.

using System;

using System.Threading.Tasks;

static void Main(string[] args)

Variables and Types

No program would be very interesting if you did not use variables to store values for calculations. As you saw earlier, variables are declared with a type and once defined with a specific type cannot be changed. Since C# is strongly typed, the compiler ensures that anywhere you use the variable that it obeys its type. For example, that the operation on the variable is valid for the type. Thus, every variable must have a type assigned.

There are a number of simple types that the C# language supports. They are the basic building blocks for more complex types. Each type consumes a small segment of memory which defines not only how much space you have to store a value, but also the range of values possible.⁵

For example, an integer consumes 4 bytes and you can store values in the range –2,147,483,648 to 2,147,483,647. In this case, the integer variable is signed (the highest bit is used to indicate positive or negative values). An unsigned integer can store values in the range 0 to 4,294,967,295.

You can declare a variable by specifying its type first and then an identifier. The following shows a number of variables using a variety of types.

int num_fish = 0;                    // number of fish caught
double max_length = 0.0;             // length of the longest fish in feet
char[] fisherman = new char[25];  // name of the fisherman

Notice also that I have demonstrated how to assign a value to the variable in the declaration. The assignment operator is the equal sign. All assignments must obey the type rules. That is, I cannot assign a floating-point number (e.g., 17.55) to an integer value. Table 6-1 shows a list of the commonly used built-in types you will use in your applications.

It is always a good practice to initialize your variables when you declare them. It can save you from some nasty surprises if you use the variable before it is given a value (although the compiler will complain about this).

Arithmetic

You can perform a number of mathematical operations in C#, including the usual primitives but also logical operations and operations used to compare values. Rather than discuss these in detail, I provide a quick reference in Table 6-2 that shows the operation and example of how to use the operation.

Bitwise operations produce a result on the values performed on each bit. Logical operators (and, or) produce a value that is either true or false and are often used with expressions or conditions.

Now that you understand variables and types, the operations permitted on them, and expressions, let’s look at how you can use them in flow control statements.

Flow Control Statements

Flow control statements change the execution of the program. They can be conditionals that use expressions that restrict execution to only those cases where the expression evaluates true (or negated), special constructs that allow you to repeat a block of code (loops), and the use of methods to switch context to perform some special operations. You’ve already seen how methods work so let’s look at conditional and loop statements.

if (expr1) {
  // execute only if expr1 is true
} else if ((expr2) || (expr3)) {
  // execute only if expr1 is false *and* either expr2 or expr3 is true
} else {
  // execute if both sets of if conditions evaluate to false
}

switch (eval) {
  case <value1> :  
     // do this if eval == value1
     break;
  case <value2> :  
     // do this if eval == value2
     break;
  default :  
     // do this if eval != any case value
     break;  // Not needed, but good form
 }

while (expression) {
   // do something here
 }

do {
  // do something here – always done once
} while (expression);

for (<init> ; <expression> ; <increment>) {
// do someting
}

for (int i; i < 10; i++) {
   // do something here
}

Basic Data Structures

What you have learned so far about C# will allow you to create applications that do simple to moderately complex operations. However, when you start needing to operate on data—either from the user or from sensors and similar sources—you need a way to organize and store data and operations on the data in memory. The following introduces three data structures in order of complexity: arrays, structures, and classes.

Arrays allocate a contiguous area of memory for multiple storage of a type. That is, you can store several integers, characters, and so forth, set aside in memory. Arrays also provide an integer index that you can use to quickly access a specific element. The following illustrates how to create an array of integers and iterate through them with a for loop. Array indexes start at 0.

Int[] num_array = {0,1,2,3,4,5,6,7,8,9};  // an array of 10 integers
for (int i=0; i < 10; ++i) {
  Console.Write(num_array[i]);
  Console.Write(" ");
}
Console.Writeline();

You can also define multiple dimensional arrays (arrays of arrays). Arrays can be used with any type or data structure.

If you have a number of data items that you want to group together, you can use a special data structure called, amazingly, struct. A struct is formed as follows.

struct <name> {
  // one or more declarations go here
};

You can add whatever declarations you want inside the struct body (defined by the curly braces). The following shows a crude example. Notice that you can use the structure in an array.

struct address {
  int street_num;
  string street_name;
  string city;
  string state;
  string zip;
};

address[] address_book = new address[100];

Arrays and structures can increase the power of your programs by allowing you to work with more complex data types.

Wow! That was a wild ride, wasn’t it? I hope that this short crash course in C# has explained enough about the sample programs shown so far that you now know how they work. This crash course also forms the basis for understanding the other C# examples in this book.

OK, now it’s time to see some of these fundamental elements of C# in action. Let’s look at the blink an LED application you saw in Chapter 3 only this time you’re going to write it for Windows 10 IoT Core!

Required Components

The following lists the components that you need. All of these are available in the Microsoft Internet of Things Pack for the Raspberry Pi from Adafruit. If you do not have that kit, you can find these components separately on the Adafruit web site ( www.adafruit.com ), from SparkFun ( www.sparkfun.com ), or any electronics store that carries electronic components.

• 560 ohm 5% 1/4W resistor (green, blue, brown stripes⁶)

• Diffused 10mm red LED (or similar)

• Breadboard (mini, half, or full sized)

• (2) male-to-female jumper wires

You may notice that this is the same set of components you used in Chapter 3.

Set up the Hardware

Begin by placing the breadboard next to your Raspberry Pi and power the Raspberry Pi off orienting the Raspberry Pi with the label facing you (GPIO pins in the upper-left). Next, take one of the jumper wires and connect the female connector to pin 6 on the GPIO. The pins are numbered left-to-right starting with the lower left pin. Thus, the left two pins are 1 and 2 with pin 1 below pin 2. Connect the other wire to pin 7 on the GPIO.

Next, plug the resistor into the breadboard with each pin on one side of the center groove. You can choose whichever area you want on the breadboard. Next, connect the LED so that the long leg is plugged into the same row as the resistor and the other pin on another row. Finally, connect the wire from pin 6 to the same row as the negative side of the LED and the wire from pin 7 to the row with the resistor. Figure 6-2 shows how all of the components are wired together. Be sure to study this drawing and double-check your connections prior to powering on your Raspberry Pi. Once you’re satisfied everything is connected correctly, you’re ready to power on the Raspberry Pi and write the code.

Figure 6-2. Wiring the LED to a Raspberry Pi

Since you are building a headed application, you’ll also need a keyboard, mouse, and monitor connected to the Raspberry Pi.

OK, now that the hardware is set up, it’s time to start writing the code.

Write the Code: User Interface

Begin by opening a new project template. Choose C# ➤ Windows ➤ Universal in the tree and the Blank App (Universal Windows) template in the list. This template creates a new solution with all of the source files and resources you need for a UWP headed application. Figure 6-3 shows the project template you need. Use the project name BlinkCSharpStyle.

Figure 6-3. New Project dialog: blank application

Notice that there are a number of files created. You first add the XAML code in the MainPage.xaml file. Listing 6-3 shows the bare XAML code placed in the file by default. I’ve added a note that shows where to add new code.

Listing 6-3. Bare XAML code (MainPage.xaml)

<Page
    x:Class="BlinkCSharpStyle.MainPage"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="using:BlinkCSharpStyle"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d">
    <Grid Background="{ThemeResource ApplicationPageBackgroundThemeBrush}">
        --> Our code goes here.
    </Grid>
</Page>

Recall that the XAML file is used to define a user interface in a platform independent way using an XML-like language. In this project, I demonstrate the more basic controls: a text box, a button, and an ellipse (circle) placed inside a special controlled called a stacked panel. The stacked panel allows you to arrange the controls in a vertical “stack,” making it easier to position them. As you can see in the listing, you want to place your XAML user interface items in the <Grid></Grid> section.

In this example, you want a text box at the top, a circle (ellipse) to represent the LED that you will use to turn on (change to green) and off (change to gray) to correspond with the hardware on/off code that you will add later. You also need a button to toggle the blink operation on and off. Finally, you’ll add another text box to allow you to communicate with the user about the state of the GPIO code (that you’ll add later).

Now let’s add the code. Since the stacked panel is a container, all of the controls are placed inside it. Listing 6-4 shows the code you want to add (shown in bold).

Listing 6-4. Adding XAML Code for the User Interface: MainPage.xaml

<Page
    x:Class="BlinkCSharpStyle.MainPage"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="using:BlinkCSharpStyle"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d">
    <Grid Background="{ThemeResource ApplicationPageBackgroundThemeBrush}">
        <StackPanel Width="400" Height="400">            
            <TextBlock x:Name="title" Height="60" TextWrapping="NoWrap"            
                     Text="Hello, Blinky C# Style!" FontSize="28" Foreground="Blue"            
                     Margin="10" HorizontalAlignment="Center"/>            
            <Ellipse x:Name="led_indicator" Fill="LightGray" Stroke="Gray"  Width="75"            
                     Height="75" Margin="10" HorizontalAlignment="Center"/>            
            <Button x:Name="start_stop_button" Content="Start" Width="75" ClickMode="Press"            
                     Click="start_stop_button_Click" Height="50" FontSize="24"            
                     Margin="10" HorizontalAlignment="Center"/>            
            <TextBlock x:Name="status" Height="60" TextWrapping="NoWrap"            
                     Text="Status" FontSize="28" Foreground="Blue"            
                     Margin="10" HorizontalAlignment="Center"/>            
        </StackPanel>            
    </Grid>
</Page>

Notice the button control. Here you have an event that you want to associate with the button named start_stop_button_Click, which you assigned via the Click attribute. That is, when the user clicks it, a method named start_stop_button_Click() will be called.

XAML provides a great way to define a simple, easy user interface with the XML-like syntax. However, it also provides a mechanism to associate code with the controls. The code is placed in another file called a source-behind file named MainPage.xaml.cs. You will place all of the source code for the application in this file.

If you were typing this code in by hand, you will notice a nifty feature of Visual Studio—a context-sensitive help called IntelliSense that automatically completes the code you’re typing and provides drop-down lists of choices. For example, when you type in the button control and type Click=. A drop-down box will appear, allowing you to create the event handler (a part of the code that connects to the XML). In fact, it creates the code in the MainPage.xaml.cs file for you. If you copy and pasted the code, you would not get this option and would have to type in the code manually.

Let’s look at the code for the button control implemented in the class that you created in the source code file (MainPage.xaml.cs). Listing 6-5 shows the code you need to add in bold. You place everything in the class named BlinkCPPStyle (the application).

Listing 6-5. Adding the Code: MainPage.xaml .cs

using System;
using Windows.UI.Xaml;
using Windows.UI.Xaml.Controls;
using Windows.UI.Xaml.Media;
using Windows.UI.Xaml.Navigation;
// Add using clause for GPIO
using Windows.Devices.Gpio;

namespace BlinkCSharpStyle
{
public sealed partial class MainPage : Page
    {
        // Create brushes for painting contols              
        private SolidColorBrush greenBrush = new SolidColorBrush(Windows.UI.Colors.Green);              
        private SolidColorBrush grayBrush = new SolidColorBrush(Windows.UI.Colors.Gray);              

        // Add a variable to control button              
        private Boolean blinking = false;              

        public MainPage()
        {
            this.InitializeComponent();
            // Add code to initialize the controls
            this.led_indicator.Fill = grayBrush;              
        }

        private void start_stop_button_Click(object sender, RoutedEventArgs e)              
        {              
            this.blinking = !this.blinking;              
            if (this.blinking)              
            {              
                this.start_stop_button.Content = "Stop";              
                this.led_indicator.Fill = greenBrush;              
            }              
            else              
            {              
                this.start_stop_button.Content = "Start";              
                this.led_indicator.Fill = grayBrush;              
            }              
        }              
    }
}                                                                                                    

OK, there are a few extra bits here that may not be very obvious why they’re here. You want to paint the LED control green and gray for on and off. To do that, you need a reference to the green and gray brush resources. Thus, I create a new object from the Windows user interface colors namespace.

You also add the code for the button click event, start_stop_button_Click(), as well as a boolean member variable that you use to trigger the LED timer. You add code that inverts the blinking variable (toggles between false and true) and depending on the value, you turn the led indicator control green (meaning the LED is on) or gray (meaning the LED is off). You also change the label of the button to correspond with the operation. That is, if the button is labeled Start, the LED indicator is off, and when clicked, the label changes to Stop and the LED indicator is turned on.

That’s it! You’ve finished the user interface. Go ahead and build the solution correcting any errors that may appear. Once compiled, you’re ready to test it. The following shows an example of what you should see in the output window .

Restoring NuGet packages...
To prevent NuGet from restoring packages during build, open the Visual Studio Options dialog, click on the Package Manager node and uncheck 'Allow NuGet to download missing packages during build.'
1>------ Rebuild All started: Project: BlinkCSharpStyle, Configuration: Debug ARM ------
1>  BlinkCSharpStyle -> C:UsersChuckDocumentsVisual Studio 2015ProjectsBlinkCSharpStyleinARMDebugBlinkCSharpStyle.exe
========== Rebuild All: 1 succeeded, 0 failed, 0 skipped ==========

Test and Execute: User Interface Only

That was easy, wasn’t it? Better still, since this is a Universal app, you can run this code on your PC. To do so, choose debug and x86 (or x64) from the platform box and press Ctrl+F5 . Figure 6-4 shows an excerpt of the output (just the controls itself).

Figure 6-4. The user interface: timer off

Figure 6-5 shows what happens when you click the button. Cool, eh?

Figure 6-5. The user interface: timer on

You may be wondering where the blink part is. Well, you haven’t implemented it yet. You will do that in the next phase.

Add the GPIO Code

Now, let’s add the code to work with the GPIO header. For this phase, you cannot run the code on your PC because the GPIO header doesn’t exist, but you can add code to check the GPIO header status—hence the extra text box in the interface.

Let’s start with adding the resource you need to access the GPIO header. Right-click References in the project and choose Add Reference.... When dialog opens, choose Universal Windows ➤ Extensions from the tree view and Windows IoT Extensions for the UWP from the list. This allows you to include additional namespaces for the GPIO. Figure 6-6 shows the resources dialog with the item selected.

Figure 6-6. Adding a new resource

Notice on my system there are two entries—one for each version of the libraries I have loaded. You may only see the one entry. Click OK once you have the item selected.

Now, let’s add the variables you need for the timer in the source file (MainPage.xaml.cs). The following shows the code you need to add. Here you add an instance of the DispatchTimer as well as several private variables for working with the pin in the GPIO library . I show the changes in context with the new lines in bold.

...
        private SolidColorBrush greenBrush = new SolidColorBrush(Windows.UI.Colors.Green);
        private SolidColorBrush grayBrush = new SolidColorBrush(Windows.UI.Colors.Gray);

        // Add a Dispatch Timer              
        private DispatcherTimer blinkTimer;              

        // Add a variable to control button
        private Boolean blinking = false;

        // Add variables for the GPIO              
        private const int LED_PIN = 4;              
        private GpioPin pin;              
        private GpioPinValue pinValue;              
...

The private variables store the pin value, a constant set to GPIO 4 (hardware pin #7), and a variable o store the pin variable result.

Next, you need a new method to initialize the GPIO—InitGPIO(). You add a new private method to the class and complete it with code to control the GPIO. As you can see, there is a lot going on here.

private void InitGPIO()
{
    var gpio_ctrl = GpioController.GetDefault();

    // Check GPIO state
    if (gpio_ctrl == null)
    {
        this.pin = null;
        this.status.Text = "ERROR: No GPIO controller found!";
        return;
    }
    // Setup the GPIO pin
    this.pin = gpio_ctrl.OpenPin(LED_PIN);
    // Check to see that pin is Ok
    if (pin == null)
    {
        this.status.Text = "ERROR: Can't get pin!";
        return;
    }
    this.pin.SetDriveMode(GpioPinDriveMode.Output);
    this.pinValue = GpioPinValue.Low; // turn off
    this.pin.Write(this.pinValue);
    this.status.Text = "Good to go!";
}

The code first creates an instance of the default GPIO controller class. Next, you check to see if that instance is null, which indicates the GPIO header cannot be initiated and if so you change the label of the status text and return. Otherwise, you open the GPIO pin defined earlier. If that value is null, you print the message that you cannot get the pin. Otherwise, you set up the pin for output mode, and then turn off the bin and state all is well in the status label text.

Next, you add a new method to handle the event fired from the DispatchTimer. The timer fires (or call) this method on the interval you specify (see the following changes to the MainPage() method ).

private void BlinkTimer_Tick(object sender, object e)
{
    // If pin is on, turn it off
    if (this.pinValue == GpioPinValue.High)
    {
        this.led_indicator.Fill = grayBrush;
        this.pinValue = GpioPinValue.Low;
    }                                                                                          
    // else turn it on
    else
    {
        this.led_indicator.Fill = greenBrush;
        this.pinValue = GpioPinValue.High;
    }                                                                                          
    this.pin.Write(this.pinValue);
}

In this method, you check the value of the pin. Here is where the real operation of the code happens. In this code, if the pin is set to high (on), you set it to low (off), and paint the LED control gray. Otherwise, you set the pin to high (on) and paint the LED control green. Cool, eh?

Next, you need to add code to the start_stop_button_Click() method to start and stop the timer. The changes are in bold.

private void start_stop_button_Click(object sender, RoutedEventArgs e)
{
    this.blinking = !this.blinking;
    if (this.blinking)
    {
        this.start_stop_button.Content = "Stop";
        this.led_indicator.Fill = greenBrush;
        this.blinkTimer.Start();            
    }
    else
    {
        this.start_stop_button.Content = "Start";
        this.led_indicator.Fill = grayBrush;
        this.blinkTimer.Stop();            
        this.pinValue = GpioPinValue.Low;            
        this.pin.Write(this.pinValue);            
    }

You see here a few things going on. First, notice that you invert the blinking variable to toggle blinking on and off. You then add a call to the blinkTimer instance of the DispatchTimer to start the timer if the user presses the button when it is labeled Start. Notice you also set the label of the button to Stop so that, when clicked again, the code turns off the timer and set the pin value to low (off). This is an extra measure to ensure that if the button is clicked when the timer is between tick events, the LED is turned off. Try removing it and you’ll see.

Finally, you must add a few lines of code to the MainPage() method to get everything started when you launch the application. The following shows the code with changes in bold.

public MainPage()
{                                                                                          
    this.InitializeComponent();
    // Add code to initialize the controls
    this.led_indicator.Fill = grayBrush;
    // Add code to setup timer            
    this.blinkTimer = new DispatcherTimer();            
    this.blinkTimer.Interval = TimeSpan.FromMilliseconds(1000);            
    this.blinkTimer.Tick += BlinkTimer_Tick;            
    this.blinkTimer.Stop();            
    // Initalize GPIO            
    InitGPIO();            
}

Notice you add code to create a new instance of the DispatchTimer class, set the interval for the tick event to 1 second (1000 milliseconds), add the BlinkTimer_Tick() method to the new instance (this is how you assign a method reference to an existing event handle). Next, you stop the timer and finally call the method that you wrote to initialize the GPIO.

That’s it! Now, let’s build the solution and check for errors. You should see something like the following in the output window .

Restoring NuGet packages...

To prevent NuGet from restoring packages during build, open the Visual Studio Options dialog, click on the Package Manager node and uncheck 'Allow NuGet to download missing packages during build.'
1>------ Build started: Project: BlinkCSharpStyle, Configuration: Debug x86 ------
1>  BlinkCSharpStyle -> c:userschuckdocumentsvisual studio 2015ProjectsBlinkCSharpStyleinx86DebugBlinkCSharpStyle.exe
========== Build: 1 succeeded, 0 failed, 0 up-to-date, 0 skipped ==========

OK, now you’re ready to deploy the application to your device. Go ahead and set up everything and power on your device.

Deploy and Execute: Completed Application

Once your code compiles, you’re ready to deploy the application to your Raspberry Pi (or other device). Recall from Chapter 4, you have to set up the debug settings to specify the IP address of your Raspberry Pi. Fortunately, you only have to change three things: IP address, authentication, and uninstall/install check box, as indicated in Figure 6-7. Remember to choose ARM for the platform. Click Apply and then OK to close the dialog.

Figure 6-7. Debug Settings for Deployment

Next, you should also name your application so that you can recognize it on the device. Double-click the Package.appxmanifest file. You see a new tabbed window open in the IDE. Click the Packaging tab and change the name of the application, as shown in Figure 6-8. You do this so that the application shows up in the application list on the device. Otherwise, you would get a strange name that is not readily recognizable.

Figure 6-8. Setting Package Name

Once you have these set, you can power on your Raspberry Pi, and once it is booted, go to the Device Portal and turn on the remote debugger, as shown in Figure 6-9.

Figure 6-9. Turning on the remote debugger

Now you can deploy the application from the Build menu. When complete, you’ll get messages like the following from the Output window.

1>------ Build started: Project: BlinkCSharpStyle, Configuration: Debug ARM ------
1>  BlinkCSharpStyle -> c:userschuckdocumentsvisual studio 2015ProjectsBlinkCSharpStyleinARMDebugBlinkCSharpStyle.exe
2>------ Deploy started: Project: BlinkCSharpStyle, Configuration: Debug ARM ------
2>Creating a new clean layout...
2>Copying files: Total 16 mb to layout...
2>Checking whether required frameworks are installed...
2>Framework: Microsoft.NET.CoreRuntime.1.0/ARM, app package version 1.0.23430.0 is not currently installed.
2>Installing missing frameworks...
2>Registering the application to run from layout...
2>Deployment complete (54476ms). Full package name: "BlinkCSharpStyle_1.0.0.0_arm__2v0q544fdcg4c"
========== Build: 1 succeeded, 0 failed, 0 up-to-date, 0 skipped ==========
========== Deploy: 1 succeeded, 0 failed, 0 skipped ==========

Notice the name that you were shown. This is the name that appears on your device. Go back to the Device Portal and click Apps, and then choose the application in the drop-down list and click Run. Figure 6-10 shows the settings.

Figure 6-10. Starting an application on the device

You should soon see the application start on your device. Go ahead and click the start/stop button and observe the application running. The LED on the breadboard should blink in unison with the LED represented in the user interface. Play with it until the thrill dissipates.

If the LED is not blinking, double-check your wiring and ensure that you chose pin 4 in the code and pin 7 on the pin header (recall that the pin is named GPIO 4 but it is pin #7 on the header).

You can stop the application in the Device Portal by clicking the Remove button, as shown in Figure 6-10. And that’s it! Congratulations, you’ve just written your first C# application that uses the GPIO header to power some electronics!