Since our plain white application is quite boring, let's modify the view layer of our application with some controls. To do this, we will modify the MainStoryboard.storyboard file in your project in Xcode. At the time of writing this book, Xamarin Studio will launch and communicate with Xcode to modify iOS layout files. An iOS design tool in Xamarin Studio is currently in development and will function very similarly to Xcode.

Let's add some controls to our app by performing the following steps:

Your application should start looking a lot more like a real app as seen in the following screenshot:

Now you might be wondering about adding user interaction options to the app at this point. In Xcode, we can make an outlet that will make each view visible from C#. An outlet is a reference to a view in a storyboard or XIB file that will be filled out with an instance of the view at runtime. You can compare this concept to naming a control in other technologies such as ASP.NET, WebForms, or WPF (Windows Presentation Foundation). A Xamarin Studio behind-the-scenes tool will create a property in a partial class, which gives you access to the label and button from your controller. Additionally, you can wire an action from a storyboard or XIB file, which is a method that will be called when an event occurs. Xamarin Studio exposes Xcode actions as partial methods to be implemented in your classes. It is generally cleaner from a C# developer's perspective to just use the C# event, but it is neat to have both options.

Let's add some interactions to the app as follows:

If you get lost in Xcode, don't fret. It is a very different experience compared to Visual Studio if you are used to Microsoft tools. Apple is big on minimalistic interfaces, so it can be difficult to pick up their workflow without a detailed explanation. Coming from a WPF and WinForms background, I initially had trouble figuring out how to use Xcode's interface myself.

Here is what the first outlet dialog should look like:

Now that we have two outlets defined, two new properties will be available from your controller. Expand the *ViewController.cs file in your solution and open the *ViewController.designer.cs file. You will see your properties defined as follows:

[Outlet]
MonoTouch.UIKit.UILabel label { get; set; }

[Outlet]
MonoTouch.UIKit.UIButton button { get; set; }

It is not a good idea to modify this file since Xamarin Studio may rebuild it if you make further changes in Xcode. Nevertheless, it is good practice to learn how things actually work behind the scenes.

Open your *ViewController.cs file and let's enter the following code in your controller's ViewDidLoad method:

public override void ViewDidLoad() 
{
  base.ViewDidLoad();

  int count = 0;
  button.TouchUpInside += (sender, e) => 
  label.Text = string.Format("Count: {0}", ++count);
}

When ViewDidLoad is called for the first time, your controller's view is loaded. This happens once in the lifetime of your controller. We subscribed to the TouchUpInside event, which is fired when the button is clicked; iOS does not have a click event that is commonly used on Windows platforms. We also used C#'s convenient lambda expression syntax to update the label when the event is fired.

Run your application and you will be able to interact with your button and increment the value displayed in the label, as shown in the following screenshot:

Next, we need to make a transition from one controller to another. To do this, iOS has a concept called segue, which is basically some kind of animation that switches from one controller to the next. There are several types of segues, but the most common segue slides a new controller from the left or bottom of the screen.

Now let's add a second controller to the application as follows:

Since we've set up a modal segue from the first controller's button, your second controller will appear while clicking it. However, there isn't a way to exit the new controller yet. If you return to Xamarin Studio, you'll notice that a SecondController.cs file and SecondController.designer.cs file have automatically been created for you.

Let's add a button to your second controller as follows:

If you compile and run your application, clicking on the button will increment the value on the label and display the modal second controller. You can then close the second controller by tapping on Close. Notice the neat sliding animation; iOS automatically applies these kinds of transition effects, which are very easy to customize on iOS.

Since we have gone over the basics of laying out controls in Xcode and interacting with outlets in C#, let's go over the standard lifecycle of an iOS application. The primary location for handling application-level events is in the AppDelegate class.

If you open your AppDelegate.cs file, you can override the following methods:

Likewise, in your *ViewController.cs file, you can override the following methods on your controller:

Apart from these methods, there are other methods but many are deprecated for iOS 6 and above. Familiarize yourself with Apple's documentation at http://developer.apple.com/library/ios. It is very helpful to read the documentation on each class and method when trying to understand how Apple's APIs work. Learning how to read (not necessarily code) Objective-C is also a useful skill to learn so that you are able to convert Objective-C examples to C# when developing iOS applications.