MonoTouch

What's New in MonoTouch 5.0
MonoTouch 5.0 introduces support for the new APIs and features found on iOS 5.

These are the new frameworks supported by MonoTouch 5.0 with strongly-typed C# bindings:

• iCloud - With iCloud you can access cloud storage to upload user files and automatically sync them, wirelessly, between other computers and devices.
• Twitter Integration - Take advantage of easy Twitter access, URL shortening, photo uploads, geolocation, and more, all with a simple and easy to use API.
• AirPlay - Stream audio, video and photos from iOS devices directly to an HDTV (via Apple TV) or take advantage of encrypted streams using HTTP Live Streaming.
• Bluetooth - Using the MonoTouch Bluetooth APIs you can easily access and communicate with external Bluetooth hardware devices and accessories.
• Newsstand - Use MonoTouch to interact with the new home screen folder Newsstand to publish and update magazines and newspaper subscriptions. Best of all, handle updates in the background without interrupting the user.
• Core Image - The new Core Image API allows access to many built-in features such as applying effects to photos and videos, auto-enhance, reduce red-eye, and facial recognition. 

What's New in MonoTouch 4.0
Core Mono Runtime upgraded to Mono 2.10:

• Defaults to .NET 4.0 APIs
• Parallel Frameworks support
• C# 4.0 support

LLVM-backed optimizing compiler

• Use LLVM to reduce your executable size and improve your application performance

Support for iOS SDK 4.3

• New APIs bound

What's New in MonoTouch 3.2.4

• Fixed AudioUnit linking error on simulator and device
• Completed CoreTelephone and AssetLibrary bindings
• Exposed CoreGraphics marshalling constructors (for btouch users).

What's New in MonoTouch 3
MonoTouch 3.0.8 introduced support for Apple's iPhone 4 SDK and supports the following platforms:

• iOS 4 (iPhone and iPod devices)
• iPhoneOS 3.2 (iPad)
• iPhoneOS 3.0 (iPhone and iPod devices).

Multitasking
MonoTouch 3.0 supports all the new APIs to allow your application to multi-task on iOS 4.0. As part of this effort, Novell introduced bindings to Grand Central Dispatch (see the class MonoTouch.CoreFoundation.Dispatch).

You can build applications that support:

• Background Audio
• Voice over IP
• Background Location
• Receive push notifications even if your app is sleeping
• Local notification support, without requiring a server to push the data.
• "Just one more minute" support, to let your application complete any critical task before it is put in the background.
• Fast App Switching support.

Multitasking support builds also on top of the new binding to the Blocks API.

Integration Technologies
All of the new iOS =4.0 "Integration Technologies" features introduced by Apple are supported in this edition of MonoTouch.

Location Notifications
Local notifications, provided by the MonoTouch.UIKit.UILocalNotification

EventKit
EventKit framework, gives you access to the device calendar (MonoTouch.EventKit).

CoreMotion
CoreMotion gives you access to the gyroscope and accelerometer (MonoTouch.CoreMotion).

CoreTelephony
CoreTelephony gives you access to information about your cell provider (MonoTouch.CoreTelephony).

Apple iAd
iAd allows developers to integrate advertisements into their applications (MonoTouch.iAd)

Graphics and Multimedia

High Resolution APIs
Support for iPhone 4's Retina Display is accomplished through various extensions to the UIKit and CoreAnimation APIs.    These new APIs are also exposed to MonoTouch developers (MonoTouch.UIKit.UIScreen.Scale, MonoTouch.UIKit.UIImage.CurrentScale, MonoTouch.UIKit.UIView.ContentScaleFactor).

Quick Look Framework

This new API has been bound allowing your application to preview the contents of foreign file formats.   The APIs are available in MonoTouch.QuickLook.

AVFoundation

The AVFoundation framework gives developers more fine grainer control over music and video playback and with iOS 4.0 it got a significant boost in terms of functionality.    The new classes are available under MonoTouch.AVFoundation.

These are some of the new additions:

• Media asset management
• Movie capture
• Movie playback
• Track management
• Metadata management for media items
• Stereo panning
• Precise audio sync between sounds
• APIs to query details about the media files including data format, sample rate and channels

Core Services

Transparent access to the Blocks API
For those familiar with both Objective-C and C# we mapped C# delegates and lambdas into Objective-C blocks, so all the new blocks-based API is available to developers.   Developers in C# can continue to use lambda functions as well as anonymous methods, and those will be transparently exposed to Objective-C as Objective-C blocks.

Grand Central Dispatch
This task queue management system is used in iPhone OS and MonoTouch now exposes these APIs for application developers to use.   

Accelerate Framework
This API is a flat C API and is only available to developers by manually using P/Invoke to call into these routines.   No object-oriented binding has been provided for it.

UIKit and UI Improvements
All of the improvements that Apple introduced in iOS 4.0 for UIKit are exposed in MonoTouch 3.0, this includes the new multi-tasking methods in UIApplicationDelegate as well as its support for scheduling local notifications.

Multithreading improvements
In iOS4 it is possible to use a graphics context (MonoTouch.CoreGraphics.CGContext) in a multi-threaded application.   Access to UIImage, UIColor and UIFont is now also thread safe.

Block Animations
The new Block-animation APIs in UIView which provide various callbacks for custom animations are exposed in the API.  Blocks in the UIView are merely C# instances of NSAction, so you can just use delegates, anonymous methods or lambda functions as your block values.

Font Smoothing Support
CoreGraphics now supports fine grained control of font smoothing in MonoTouch.CoreGraphics.CGContext.

MessageUI
The new MFMessageComposeViewController now supports a compositing tool for SMS messages without leaving your application.

MapKit
Map overlays and draggable map annotations are now supported.

Foundation Bindings
Many new Foundation APIs were introduced with iOS 4.0, these have been bound, and the most interesting include:

• NSDateComponents
• NSBlockOperation that allows adding lambdas/delegates to operation queues
• NSCache
• All new features from CoreLocation (MonoTouch.CoreLocation)

GameKit 
All the new APIs from GameKit (MonoTouch.GameKit) have been added.

What's New in MonoTouch 2.0
MonoTouch 2.0 introduces support for the Apple's iPad, the support includes:

• MonoTouch upgrade
• Bindings for the new iPhoneOS 3.2 APIs for iPad development
• Tools required to support iPad, iPhone and Universal (iPad/iPhone) applications
• MonoDevelop upgrade
• Templates for iPad projects
• Templates for Universal (iPad/iPhone) projects
• New configuration options for Projects to support iPad projects

This includes all of the improvements that were done on the 1.4.xx and 1.5 releases, including reduced startup time, reduced application footprint, reduced memory use as well as support for Apple's profiling tools.

MonoTouch is a software development kit for Mac OS X that lets you use .NET programming languages to create native applications for Apple iPhone, Apple iPod Touch and Apple iPad devices. MonoTouch allows developers to use the .NET framework and more efficient programming languages, such as C#, to create applications that run on the iPhone and can take advantage of native iPhone APIs. Developers can test MonoTouch applications on the iPhone simulator, as well as physical hardware, and can distribute MonoTouch applications on Apple's App Store.

MonoTouch Features:

• Mono for the iPhone, iPad and iPod Touch
• C# and .NET on the iPhone
• .NET Bindings to Native APIs
• Distribute on the Apple App Store
• Enterprise deployable
• MonoDevelop Integration
• XCode Integration

MonoTouch is delivered as a static compiler that turns .NET executables and libraries into native applications. There is no JIT or interpreter shipped with your application, only native code. In addition to the core Base Class Libraries that are part of Mono, MonoTouch also ships with bindings for various iPhone APIs to allow developers to create native iPhone applications with Mono.

MonoTouch requires a Mac and Apple's iPhone SDK to test on the emulator and deploy on the device. And you will need to be an Apple iPhone developer to deploy on the device.

MonoTouch is a commercial product based on the open source Mono project and is licensed on a per-developer basis.

MonoTouch is based on a hybrid .NET 2.0 and Silverlight 2 API profile. If you want to use existing C# code, you will need to compile it from scratch using the MonoTouch compiler and tools to make sure that the proper assemblies are referenced.

MonoTouch supports garbage collection, multi-threading, and many features of .NET 3.5, including C# 3.0 and LINQ, with some exceptions due to the security system in the device.

You cannot reuse the 1.0 or 2.0 desktop/server assemblies from Mono or .NET with MonoTouch. 

To reuse existing .NET code with MonoTouch, you must recompile your libraries with MonoTouch's compiler and base assemblies.

Monotouch is available in Professional Edition and Enterprise Editions:

• MonoTouch Professional Edition (previously known as Personal Edition) license is non-transferable, entitles the owner to one year of MonoTouch updates, and allows distribution of applications built with MonoTouch on Apple's App Store.
• MonoTouch Enterprise Edition license is owned by a legal entity for use by one developer at any given time, entitles the owner to one year of MonoTouch updates, and allows enterprise deployments of MonoTouch applications, as well as the distribution of applications built with MonoTouch on Apple's App Store.

Other Features:

Automatic Memory Management
Mono comes with a garbage collector that allows developers to focus on their software and let the runtime take care of the bookkeeping required to release objects.   This avoids common memory leaks and reduces the amount of code that needs to be written to avoid these leaks.    

Type Safety
The C# language in combination with the ECMA runtime prevent a whole class of errors from your application. With C# the common errors of reusing disposed objects accidentally, overflowing a buffer, casting an object into the wrong type (leading to corruption), releasing the memory twice or keeping dangling objects are a thing of the past.

C# 3.0
The C# 3.0 language is a rich high-level language that brings many constructs that improve programmer productivity.

In addition to traditional object oriented languages, C# offers many interesting new constructs: type safe generic types, automatic state machines created with iterators, lambda functions and anonymous methods, built-in properties and built-in event systems as well as the System.Linq namespace that allows developers to create functional programming constructs.  

The terse syntax allows configurations of objects in one pass:

 var slider = new UISlider (new RectangleF (174f, 12f, 120f, 7f)){

        BackgroundColor = UIColor.Clear,
        MinValue = 0f,
        MaxValue = 100f,
        Continuous = true,
        Value = 50f,
        Tag = kViewTag

};
slider.ValueChanged += delegate {
        Console.WriteLine ("New value {0}", slider.Value);
};

Use iPhone 3.1 APIs
MonoTouch binds the Objective-C APIs that developers use on the iPhone into C# APIs that expose the functionality and map this to any ECMA CIL powered language. Objective-C delegates are exposed to C# applications in a number of ways giving developers complete control of how to consume and integrate with native APIs.

MonoTouch provides a C#/ECMA binding for:

• Addressbook and AddressbookUI
• AudioToolbox
• AVFoundation
• CoreAnimation/Quartz
• CoreGraphics/Quartz
• CoreLocation
• Foundation and CoreFoundation
• GameKit
• OpenGL ES 1.1 and OpenGL ES 2.0
• MediaPlayer
• MessageUI
• StoreKit
• SystemConfiguration
• UIKit

From the pure C#-based event model to the native Objective-C system, the two mechanisms are supported.

For example, to respond to events, programmers can just connect to the events they are interested in:

var page = new UIPageControl (new RectangleF (120f, 14f, 178f, 20f)){

        BackgroundColor = UIColor.Gray,
        Pages = 10,
        Tag = kViewTag
};

page.TouchUpInside += delegate {
        Console.WriteLine ("Current page: {0}", page.CurrentPage);
};

Access to .NET APIs
MonoTouch includes the .NET APIs that make sense in the iPhone device.

The assemblies shipped with MonoTouch include:

Additionally there is experimental support for WCF web services.

Access to Third Party .NET Libraries
You can tap into the extensive universe of .NET libraries and APIs that exist out there for Mono and .NET and use them with MonoTouch.

Access to third party iPhone/Objective-C Libraries
MonoTouch allows you to access libraries created in the Objective-C language for the iPhone easily and to create C#/.NET bindings to Objective-C libraries.

The new btouch tool simplifies binding an Objective-C API and does the heavy lifting for you: registering the selectors, taking care of invoking the proper handle for overwritten classes, doing parameter checking and doing some of the common marshaling required for your project.

MonoDevelop and XCode Integration
MonoTouch is an SDK that can be used with your favorite editor, be it a fully integrated development environment or a simple text editor. 

The MonoDevelop integration helps developers get started by providing iPhone application templates that will get you from zero to your device in no time.   

MonoDevelop's code completion helps you quickly explore the API as you write your application:

Tutorials are available which will walk you through creating your first MonoTouch application, testing it on the simulator and then deploying it to your iPhone.

Interface Builder Integration
Both MonoDevelop and the MonoTouch SDK allow you to use Interface Builder to create and customize your UIs. The Inteface Builder has been taken one step further than XCode by making MonoTouch automatically bind any outlets you define on your interface and any methods that you define in your interface to your C# code.

You will never have to manually bind any outlets from Interface Builder to your code as MonoTouch takes care of this.