About The Author

Frank Cohen

Frank Cohen is, Founder of PushToTest, Author of FastSOA. Through his speaking, writing and consulting, Frank Cohen, is the expert that information technology professionals and enterprises go to when they need to understand and solve problems in complex interoperating information systems, especially Service Oriented Architecture (SOA), Ajax, and Web services. PushToTest is the open-source test automation solutions business, and maintainer of the popular TestMaker open-source project

Website: www.pushtotest.com

The Cohen Blog: www.pushtotest.com/docs/thecohenblog

Recommended Book

As a Java developer, you want a guide that shows you how to add Ajax functionality to your web applications with a minimum of effort. Well look no further than Pro Ajax and Java Frameworks. In this book, recognized Java experts and authors of the best-selling Apress title, Foundations of Ajax, will show you how.

---

By James Sugrue

15,445 Downloads · Refcard 62 of 151 (see them all)

The Eclipse Rich Client Platform (RCP) provides a foundation for building and deploying rich client applications. It includes Equinox, a component framework based on the OSGi standard, and an integrated update mechanism for deploying desktop applications from a central server. This DZone Refcard introduces you to the Eclipse plug-in development environment and shows you how to add key functionality to your RCP application using Views, Perspectives and Editors. Learn how to add a Menu to your Plug-in, create a Help system for your user, and how to brand and productize your Eclipse RCP application.

IntelliJ IDEA

Updated for 8.1

Download
FREE PDF

The Essential IntelliJ IDEA Cheat Sheet

About the Author

Share this Refcard with
your friends & followers...

DZone greatly appreciates your support.


Your download should begin immediately.
If it doesn't, click here.

Click here to download more Refcardz!

People who downloaded this DZone Refcard also liked:

HTML Preview

Getting Started with Visual Studio 2010

By Alessandro Del Sole

INTRODUCTION

The new version of the Visual Studio 2010 Integrated Development Environment ships with a number of new important features. Such features are both related to the IDE architecture and to the coding experience, with the addition of new tools as well. This Refcard is a quick reference to the most important new features and instruments in Visual Studio 2010, also providing tips to most common shortcuts.

STARTING WITH VISUAL STUDIO 2010

Visual Studio 2010 is the developer tool used for creating .NET applications. There are different editions which cover every need, such as the Ultimate edition or the free Express editions (the latter are specific for hobbyists and students).

Starting the IDE

When you run Visual Studio 2010, the first thing you notice is a new Start Page which provides shortcuts, organized into tabs, to lots of learning resources about programming different Microsoft technologies with Visual Studio. These include the .NET Framework and programming languages, data platform, cloud computing or tools for teams. The following figure shows how the Start Page looks:

Visual Studio 2010 offers a convenient way for managing the most recently used projects by simply right-clicking each project name in the list. With this action you can pin or remove items from the list itself.

Creating applications

You create .NET applications in Visual Studio 2010 by first creating projects. A project is the place where all the parts composing your application, such as code, libraries, dialogs, pages and resources, reside. An application can be composed of one or more projects. Multiple projects bound together are combined into a Solution. Thus, the first step is creating a new project. You accomplish this by selecting the New|Project command from the File menu. This will show the New Project dialog which looks like this:

As you can see, there are a number of available project types, grouped by programming language or by typology. As you can see from the above figure, the programming language project types are sub-grouped by technology. Once you have selected the desired project type, just assign a name and click OK. The Visual Studio documentation that ships with the product provides full descriptions for both Windows and Web projects.

In Visual Studio 2010 you can also target different versions of the .NET Framework (as shown in the figure above) or search specific project templates using the Search Installed Templates search box.

Building and debugging applications

You can build and run your executable application by pressing F5. This is common to both Windows and Web applications and will run your application with an instance of the Visual Studio debugger attached. Visual Studio provides a lot of debugging tools available in the Debug menu. For example, you can place breakpoints (also by pressing F9) or check for the value of local variables via the Locals tool window. If you don’t want to run the application under the debugger investigation, simply press Shift+F5.

You can quickly deploy your application using the ClickOnce technology, which you access via the Build|Publish command.

Browsing the documentation

You can access the Visual Studio documentation in different situations by pressing F1. For example you can get general information by pressing F1 anywhere or get specific help for an element in your code by selecting the code element (such as the name of a type) and, again, press F1. In Visual Studio 2010 the help system has been rebuilt completely and now allows you to browse the documentation inside your Web browser. The following figure shows an example:

WPF-BASED CODE EDITOR

Most of the Visual Studio 2010 architecture now relies on Windows Presentation Foundation, the most recent technology from Microsoft for building rich client applications. If you are an existing Visual Studio developer this is something you immediately notice when running the IDE for the first time; it affects a number of areas such as the Start Page and tabbed dialogs or tool windows. The code editor is also built upon WPF which provides some great benefits, including:

• Better text r endering
• Code editor zoom by pr essing CTRL + mouse wheel
• Automatic selection of all occurr ences of a word
• Tabbed code dialogs can be undocked and tr eated like any other window outside the IDE
• Improved extensibility: the code editor also takes advantage of MEF (Managed Extensibility Framework) to receive pluggable components. This allows hosting rich content inside the code editor, such as images, videos, WPF controls, comment adornments and so on.
• Reusability: you can reuse the code editor as a component in your own Visual Studio add-ins.

You interact with the code editor via the IWPFTextView interface which is described in the MSDN Library. The following image shows how the WPF-based code editor looks:

Notice that the zoom percentage is greater than 100%. This was accomplished simply by pressing CTRL + mouse wheel. A good number of code editor extensions are available in the Visual Studio Gallery Web site.

“GENERATE FROM USAGE” TOOL

In its continuous evolution, the Visual Studio environment has committed to offer even more sophisticated tools for helping developers write code. IntelliSense®, syntax highlighting, and auto-completion are just a few examples. It previously lacked the ability to create new objects on the fly. With Visual Studio 2010 you can now create new objects while writing code. This is useful when you realize that you need an object that you did not consider before or that you need to extend an existing object with new members. This functionality is integrated into the code editor and is known as Generate From Usage; it is available for both Visual Basic and C#.

Creating new types on the fly

Let’s start describing Generate From Usage by creating a new Console application. Consider the following situation, in which the code attempts to create an instance of the Contact class that actually does not exist yet and pay attention to the error correction options provided by the IDE:

Click Generate ‘Class Contact’ and Solution Explorer you will notice the presence of a file named Contact.vb (or .cs in C#) which contains the empty definition of the new class.

Now you can populate your class with new members, like in the following figure, where the code attempts to assign a non-inexistent property, but the IDE provides the possibility of generating a property or a field:

If you select the first option, Visual Studio will add a property named LastName of type String to the Contact class. Similarly you can add both instances and shared methods on the fly. It is worth mentioning that Visual Studio:

• generates members of the appropriate type when possible.
• is able to generate interfaces and methods referring to delegates according to the current scenario. When generating such methods, it is able to add the appropriate signature.

You saw how to create a class, which is the default type, and members with default visibility. But you can do more with Generate From Usage as explained in next subsection.

Creating different kinds of types

There are situations in which you need to create different kinds of objects, such as structures or enumerations. Generate From Usage makes this task easy. For example, you might want to create a new structure. If you type the following line of code:

Dim someData As New CustomData

the IDE marks CustomData as non-existent. From the error correction suggestions popup, simply select Generate New Type. This will prompt you with the Generate New Type dialog shown in the next figure:

Here you can:

• Provide the new object’s visibility by setting the Access property
• Decide what kind of object you want to cr eate from the Kind property
• Add the new member to a dif ferent project in your solution via the Project combo box
• Create a new code file or add the new object to an existing code file inside the File Name box

Simply click OK when you are done and the new object will be added to your solution according to the specified settings. At this point you can add new members as described in the previous section.

WPF & SILVERLIGHT: DRAG AND DROP DATA-BINDING

Visual Studio 2010 introduces an important feature for data development to both WPF and Silverlight: drag and drop data-binding. This technique has been very popular in the past among Windows Forms developers since it allows creating data forms quickly and easily. In order to make the data development experience easier in modern client technologies, such a technique is now available for WPF and Silverlight. In WPF full support is offered for DataSets and ADO.NET Entity Framework. With full support we intend complete UI and codebehind code generation. Support is also offered for custom business objects or different data sources such as LINQ to SQL or WCF Data Services, but only on the UI side, meaning that you need to write all the data access code from scratch. In Silverlight you don’t have DataSets, so you can use this kind of data-binding with Entity Framework and custom objects.

Creating the data-bound interface

Whatever your data source is, you may open the Data Sources window and then simply drag your desired data item from the window onto the designer surface, as it was done previously in Windows Forms applications. The following figure provides an example based on the Entity Framework as the data source:

As in older technologies, you can still create grid views or details views and you are allowed to replace the default controls with different ones. You can drag an entire object to create a view or a single object onto an items container control such as the ListBox for creating lists.

Dragging and dropping the data is just the first step since you obviously need some code.

A tour of the code

When you use the drag and drop binding, Visual Studio generates some useful code for you. This not only refers to the user interface and controls, but also to querying data. On the XAML side, it first generates the appropriate CollectionViewSource objects acting like “bridges” between data and UI:

<Window.Resources>
	  <CollectionViewSource x:Key=”CategoriesViewSource” d:DesignSo
urce=”{d:DesignInstance my:Category, CreateList=True}” />
	  <CollectionViewSource x:Key=”CategoriesProductsViewSo
urce” Source=”{Binding Path=Products, Source={StaticResource
CategoriesViewSource}}” />
	</Window.Resources>

Next it generates data-bound controls, such as a DataGrid and Label/TextBox couples if considering the previous image (notice the Binding markup extension pointing to the bound property):

<DataGrid AutoGenerateColumns=”False” EnableRowVirtualization=”True”
Height=”128” HorizontalAlignment=”Left” ItemsSource=”{Binding}”
Name=”CategoriesDataGrid” RowDetailsVisibilityMode=”VisibleWhenSelect
ed” VerticalAlignment=”Top” Width=”248”>
	<DataGrid.Columns>
		<DataGridTextColumn x:Name=”CategoryIDColumn”
Binding=”{Binding Path=CategoryID}” Header=”Category ID”
Width=”SizeToHeader” />
		<DataGridTextColumn x:Name=”CategoryNameColumn”
Binding=”{Binding Path=CategoryName}” Header=”Category Name”
Width=”SizeToHeader” />
		<DataGridTextColumn x:Name=”DescriptionColumn”
Binding=”{Binding Path=Description}” Header=”Description”
Width=”SizeToHeader” />
	</DataGrid.Columns>
  </DataGrid>
…
	<Label Content=”Product ID:” Grid.Column=”0” Grid.Row=”0”
HorizontalAlignment=”Left” Margin=”3” VerticalAlignment=”Center” />
	<TextBox Grid.Column=”1” Grid.Row=”0” Height=”23”
HorizontalAlignment=”Left” Margin=”3” Name=”ProductIDTextBox”
Text=”{Binding Path=ProductID, Mode=TwoWay,
ValidatesOnExceptions=true, NotifyOnValidationError=true}”
VerticalAlignment=”Center” Width=”100” />
…

It is worth mentioning that Visual Studio also maps data types to the appropriate controls. A typical example is when you have data of type System.DateTime that is represented via a DatePicker control (available in .NET 4 only). On the managed code side, Visual Studio generates some starting code for querying data. In case you use the Entity Framework as the Data Access Layer, the generated code looks like this (continuing the example from the previous image):

Class MainWindow
	Private Function GetCategoriesQuery(ByVal NorthwindEntities As _
										WpfApplication1.
NorthwindEntities) _
										As System.Data.Objects.
ObjectQuery(Of WpfApplication1.Category)

	Dim CategoriesQuery As System.Data.Objects.ObjectQuery(Of
WpfApplication1.Category) =
		   NorthwindEntities.Categories
		‘Update the query to include Products data in Categories. You
can modify this code as needed.
		CategoriesQuery = CategoriesQuery.Include(“Products”)
		‘Returns an ObjectQuery.
		Return CategoriesQuery
	End Function
	
	Private Sub Window_Loaded(ByVal sender As System.Object,
							  ByVal e As System.Windows.
RoutedEventArgs) _
							  Handles MyBase.Loaded
		Dim NorthwindEntities As WpfApplication1.NorthwindEntities =
			New WpfApplication1.NorthwindEntities()
		‘Load data into Categories. You can modify this code as
needed.
		Dim CategoriesViewSource As System.Windows.Data.
CollectionViewSource =
			CType(Me.FindResource(“CategoriesViewSource”), System.
Windows.Data.CollectionViewSource)
		Dim CategoriesQuery As System.Data.Objects.ObjectQuery(Of
WpfApplication1.Category) =
		  Me.GetCategoriesQuery(NorthwindEntities)
		CategoriesViewSource.Source = CategoriesQuery.
									  Execute(System.Data.Objects.
MergeOption.AppendOnly)
   End Sub
End Class

This will allow loading some data when you run the application. Once you have your starting code, you can write your own queries or extend the auto-generated code with additional features, such as Insert/Update/Delete operations or provide data navigation functionalities.

WPF & SILVERLIGHT: MULTI-TARGETING DESIGNER

In previous versions of Visual Studio the design-time experience for WPF and Silverlight developers did not offer specialized design tools. For WPF developers, the IDE lacked some tooling familiar to Windows Forms developers. Visual Studio 2008 introduced some improvements to the WPF design experience, like the ability to drag controls from the toolbox and drop them onto the designer surface, or the possibility to access event handlers by double-clicking the controls. But no support was available for setting special properties inside the Properties Window (e.g. brushes) so developers needed to manually write the code to set them. For Silverlight developers, things were even worse, in that you had neither drag and drop support nor design time support such as adjusting the application layout, so everything had to be set in code. Although Visual Studio is a developer tool, Microsoft Expression Blend is the tool best suited for deep customization of the user interface. While lots of developers use only Visual Studio to create the user interface for their applications, the need for better VS designer program was paramount. This is what happened with the release of Visual Studio 2010. In the next section you get an overview of the new and improved features, while later you will get information about how this targets multiple .NET Framework versions.

Improved experience

With Visual Studio 2010, both the WPF and Silverlight esigners now provide a full design-time experience and, most importantly, both technologies share the same tools. This means that you have the same instrumentation available for both WPF and Silverlight projects. You now have full support for dragging and dropping controls from the toolbox, for rearranging controls on the controls’ surface and you can also set complex properties within the Properties Window. The following figure represents such a description with regard to a WPF project:

If you try to do this inside a Silverlight project, you get exactly the same result and tools available. Notice how you now have a new color picker editor available for properties of type brush, which allows specifying the brush color, its type (e.g. a gradient or an image) and manually entering the color code. Prior to Visual Studio 2010 this had to be performed by writing pure XAML code. There are a number of other improvements in this area that are listed below.

Setting grid columns and rows

You can easily set rows and columns within a Grid control by selecting the RowDefinitions and ColumnDefinitions properties in the Property Window and then by taking advantage of a new dialog that looks like the following figure:

You simply click Add, then set properties for each row or column, such as the Height or Width.

Searching for a property

The Properties Window has been enhanced with a number of new features. You got a taste of this in the previous section when discussing how to set properties of type Brush. Another interesting addition is that you can now search for a specified property by writing its name in the search box at the top of the window. Also, you do not need to write the entire property name since Visual Studio filters the property list as you type characters inside the search box:

This way you can easily reach and set the properties you want to assign.

Setting controls’ fonts

In Visual Studio 2010 you can now easily set font properties to controls supporting fonts via an integrated tool inside the Properties Window.

For instance, you can select the font from a combo box and then set text alignment, size and weight all together, as shown in the following figure:

Visually setting data-binding and resources

The Properties Window also improves the way you assign data-bound properties or resources. You select the data-bound property for your control and then you can easily use the Binding popup as follows:

1. Select your data source. This can be the DataContext—another control or a resource as shown in the followingfigure:

   

2. Switch to the Path tab in order to select the property you wish to be bound;
3. Select any value converter you want to apply via the Converter tab; and
4. Finally go to the Options tab and apply any other additional options. This is really impressive in that you have a great number of available properties such as data error validation or triggering property changes.

You can apply resources similarly. For example, if you defined a style for a button and then you want to apply such a style, just right click the Style property in the Properties Window and select Apply Resource. This will provide a useful popup where you will be able to pick both default and local resources, as demonstrated in the following figure:

You can also choose between static and dynamic resources and you are offered a preview of the result you get once the resource is applied.

Multiple .NET Framework versions targeted

Visual Studio 2010 ships with integrated support for Silverlight 3 but it also supports Silverlight 4 when you install the appropriate developer tools. The good news is that all the stuff you have seen so far, including the drag and drop databinding, is available for both .NET Framework 3.5 SP 1 and 4.0 in Visual Studio 2010. This is what is usually referred to as multi-targeting, when talking about the designer. This basically means that you can create applications for WPF 3.5, WPF 4, Silverlight 3 and 4 taking advantage of all the new designer features independent of the technology or its version. If you want to check this out by yourself, simply create a new WPF or Silverlight project and in the New Project dialog select the .NET Framework 3.5 as the target Framework. You will notice no difference in the designer if compared to .NET 4.

COMMON SHORTCUTS AND TIPS

Visual Studio 2010 offers both shortcuts for quick access to common tools and instruments that you may find really useful. This section provides information on both topics.

Common shortcuts

• Start the application in debugging mode by pr essing F5 or without attaching the debugger by pressing Shift+F5
• Save all files in your solution by pr essing Ctrl+Shift+S
• Build your solution by pr essing Ctrl+Shift+B
• Run your application without the debugger by pr essing Shift+F5
• Show the toolbox by pr essing Ctrl+Alt+T
• Navigate to a specific member definition by pr essing Ctrl+
• Comment multiple line of codes by pr essing CTRL+K and CTRL+C in sequence or uncomment lines by pressing CTRL+K and CTRL+U in sequence
• Show up the Properties window by pressing F4
• Select code blocks by pr essing ALT + mouse
• Place a breakpoint by pressing F9 on the specified line of code

Common tips

• Download and manage Visual Studio extensions via the Tools|Extension Manager tool
• Add menu items for running external tools via the Tools|External Tools command
• Add IntelliSense code snippets within the code editor by pr essing Ctrl+K or right-click and then Insert Snippet
• Export project or item templates in or der to create reusable templates with File|Export template
• Find all references of a type or member by performing right click inside on a member inside the code editor and then selecting Find All References

Share this Refcard with
your friends & followers...

DZone greatly appreciates your support.


Your download should begin immediately.
If it doesn't, click here.

Click here to download more Refcardz!

People who downloaded this DZone Refcard also liked:

HTML Preview

Objective-C: for the iPhone and iPad

By Ben Ellingson and Matthew McCullough

An Introduction to the Language and tools

Objective-C is the primary language used to create applications for Apple’s Mac OS X and iOS (iPhone and iPad) platforms. Objective-C was created by Brad Cox and Tom Love in the early 1980s. In 1988, Objective-C was licensed by NeXT, a company founded and helmed by Steve Jobs during his absence from Apple. Apple acquired NeXT in 1996, bringing Objective-C to the Macintosh platform.

Objective-C is an object oriented superset of ANSI C. Its object syntax is derived from Smalltalk. It supports single inheritance, implementation of multiple interfaces via the @protocol syntax, and the redefinition and augmentation of (open) classes via categories. Apple’s iPhone SDK for the iOS mobile operating system offers developers a rich set of Objective-C APIs. This free SDK, which includes the Xcode IDE, is used to create applications for the iPhone, iPad, and iPod Touch.

The Syntax

Class Declaration

Objective-C classes typically include an interface .h and an implementation .m pair of files. The .h file contains property and method declarations. The .m file contains method implementations.

Example .h interface file

@interface Speaker : NSObject {
	NSInteger *ID;
	NSString *name;
}
@property NSInteger *ID;
@property(nonatomic,retain) NSString *name;
- (void) doSomething: (NSString *) value anotherValue: (int) value2;
@end

Example .m implementation file

#import “Speaker.h”
@implementation Speaker
@synthesize ID,name;
- (void) doSomething: (NSString *) value anotherValue: (int) value2 {
	// do something
}
@end

Inheritance

Class inheritance is specified in the .h interface file with the syntax: @interface <MyClass> : <ParentClass>. The following example tells the compiler that the Employee class inherits from (extends) the Person class.

// Employee.h file
@interface Employee : Person {
}
@end

Interfaces

Objective-C interfaces are created using the @protocol declaration. Any class can implement multiple interfaces. Interfaces are typically declared in a .h header file and can be included via #import statements in the .h header file of other classes.

// Mappable.h: Declare the Mappable @protocol
@protocol Mappable
- (double) latitude;
- (double) longitude;
@end
// Location.h: Specify that Location class implements the Mappable
// @protocol
#import “Mappable.h”
@interface Location : NSObject <Mappable> {
}
@end
// Location.m: Provide implementations for the Mappable methods
@implementation Location
- (double) latitude {
	return 46.553666;
}
- (double) longitude {
return -87.40551;
}
@end

Primitive Data Types

As a superset of ANSI C, Objective-C supports its same primitive data types.

int	Integral numbers without decimal points
float	Numbers with decimal points
double	Same as float with twice the accuracy or size
char	Store a single character such as the letter ‘a’
BOOL	Boolean values with the constants YES or NO

Common Object Data Types

NSObject	Root class of the object hierarchy
NSString	String value
NSArray	Collection of elements, fixed size, may include duplicates
NSMutableArray	Variable sized array
NSDictionary	Key-value pair collection
NSMutableDictionary	Variable sized key-value pair collection
NSSet	Unordered collection of distinct elements
NSData	Byte buffer
NSURL	URL resource

Instance Variables

Class instance variables are declared within a curly braced {} section of the .h file.

// Book.h: Variables declared in a header file
@interface Book : NSObject {
	NSString *title;
	NSString *author;
	int pages;
}
@end

Notice that the object variable declarations are preceded by * symbol. This indicates that the reference is a pointer to an object and is required for all object variable declarations.

Dynamic Typing

Objective-C supports dynamic typing via the id keyword.

NSString *name1 = @”Bob”;
// name2 is a dynamically typed NSString object
id name2 = @”Bob”;
if ([name1 isEqualToString:name2]) {
	// do something
}

Methods

Methods are declared in the .h header file and implemented in the .m implementation file.

// Book.h: Declare methods in the header file
@interface Book : NSObject {
}
- (void) setPages: (int) p;
- (int) pages;
@end
// Book.m: Implement methods in the implementation file
@implementation Book
- (void) setPages: (int) p {
	pages = p;
}
- (int) pages {
	return pages;
}
@end

Method Declaration Syntax

Method Invocation Syntax

Method invocations are written using square bracket [] notation.

Using Dot Notation Method Invocation

Objective-C 2.0 added the ability to invoke property accessor methods (getters/setters) using “.” notation.

// Using dot notation calls the book instance’s setAuthor method
book.author = @”Herman Melville”;
// equivalent to
[book setAuthor: @”Herman Melville”];

Multi Parameter Methods

Multi-Parameter methods are more verbose than other languages. Each parameter includes both an external name, data type, and a local variable name. The external parameter name becomes a formal part of the method name.

// declare a method with multiple parameters
- (void) addBookWithTitle: (NSString *) aTitle andAuthor: (NSString *)
anAuthor;
// invoke a method with multiple parameters
[self addBookWithTitle: @”Moby Dick” andAuthor: @”Herman Melville”];

Self and Super Properties

Objective-C objects include a self property and a super property. These properties are mutable and can be assigned in an advanced technique called “swizzling”. Most commonly, the self attribute is used to execute a method on the enclosing object.

[self setAuthor: @”Herman Melville”];
// Invoke methods on the “super” property to execute parent class
// behavior. a method that overrides a parent class method will likely call
// the parent class method
- (void) doSomething: (NSString *)value {
	[super doSomething: value];
	// do something derived-class specific
}

Properties using @property and @synthesize

Objective-C 2.0 added property declaration syntax in order to reduce verbose coding of getter and setter methods.

// use of @property declaration for the title variable is equivalent to
// declaring a “setTitle” mutator and “title” accessor method.
@interface Book : NSObject {
	NSString *title;
}
@property (retain, nonatomic) NSString *title;
@end
// use the @synthesize declaration in the .m implementation file
// to automatically implement setter and getter methods.
@implementation Book
@synthesize title, author; //Multiple variables
@synthesize pages; //Single variable
@end

Multiple variables may be included in a single @synthesize declaration. Alternatively, a class may include multiple @synthesize declarations.

@property Attributes

Property attributes specify behaviors of generated getter and setter methods. Attribute declarations are placed in parenthesis () after the @property declaration. The most common values used are (retain, nonatomic). retain indicates that the [retain] method should be called on the newly assigned value object. See the memory management section for further explanation. nonatomic indicates that the assignment operation does not check for thread access protection, which may be necessary in multi-threaded environments. readonly may be specified to indicate the property’s value can not be set.

Object Initialization

Object instances are created in two steps. First, with a call to alloc and second, with a call to init.

// example of 2 step object initialization
Book *book = [[Book alloc] init];
// equivalent to
Book *book2 = [Book alloc];
book2 = [book init];

In order to perform specific object initialization steps, you will often implement the init or an initWith method. Notice the syntax used around the self property in the following example. This is a standard init pattern found in Objective-C. Also notice the method uses a dynamic id return type.

// Event.m: Implementation overrides the “init” method to assign a default
// date value
@implementation Event
- (id) init {
	self = [super init];
	if (self != nil) {
	self.date = [[NSDate alloc] init];
	}
	return self;
}
@end

Class Constructors

Classes often include constructor methods as a convenience. The method type is + to indicate that it is a class (static) method.

// Constructor method declaration
+ (Book *) createBook: (NSString *) aTitle withAuthor: (NSString *)
anAuthor;
// Invoke a class constructor
Book *book2 = [Book createBook: @”Moby Dick” withAuthor: @”Herman
Melville”];

#import Statements

#import statements are required to declare the classes and frameworks used by your class. #import statements can be included at the top of both .h header and .m implementation files.

// import a class
#import “Book.h”
// import a framework
#import <MapKit/MapKit.h>

Control Flow

// basic for loop
for (int x=0; x < 10; x++) {
	NSLog(@”x is: %d”,x);
}
// for-in loop
NSArray *values = [NSArray arrayWithObjects:@”One”,@”Two”,@”Three”,nil];
for(NSString *value in values) {
	// do something
}
// while loop
BOOL condition = YES;
while (condition == YES) {
	// doSomething
}
	// if / else statements
BOOL condition1 = NO;
BOOL condition2 = NO;
if (condition1) {
	// do something
} else if(condition2) {
	// do other thing
} else {
	// do something else
}
	// switch statement
int x = 1;
switch (x) {
	case 1:
		// do something
break;
	case 2:
		// do other thing
		break;
	default:
		break;
}

Strings

Objective-C string literals are prefixed with an “@” symbol (e.g. @”Hello World”). This creates instances of the NSString class; instead of C language CFStrings.

// create a string literal via the “@” symbol
NSString *value = @”foo bar”;
NSString *value2 = [NSString stringWithFormat:@”foo %@”,@”bar”];
// string comparison
if ([value isEqualToString:value2]) {
	// do something
}
NSURL *url = [NSURL URLWithString:@”http://www.google.com”];
NSString *value3 = [NSString stringWithContentsOfURL:url];
NSString *value4 = [NSString stringWithContentsOfFile: @”file.txt”];

NSLog / NSString Formatters

Formatters are character sequences used for variable substitution in strings.

%@ for objects
%d for integers
%f for floats
// Logs “Bob is 10 years old”
NSLog(@”%@ is %d years old”, @”Bob”, 10);

Data Structures

Using NSArray

// Create a fixed size array. Notice that nil termination is required
NSArray *values = [NSArray arrayWithObjects:@”One”,@”Two”,nil];
// Get the array size
int count = [values count];
// Access a value
NSString *value = [values objectAtIndex:0];
// Create a variable sized array
NSMutableArray *values2 = [[NSMutableArray alloc] init];
[values2 addObject:@”One”];

Using NSDictionary

NSDictionary *di = [NSDictionary dictionaryWithObjectsAndKeys:
	@”One”,[NSNumber numberWithInt:1],
	@”Two”,[NSNumber numberWithInt:2],nil];
NSString *one = [di objectForKey: [NSNumber numberWithInt:1]];
NSMutableDictionary *di2 = [[NSMutableDictionary alloc] init];
[di2 setObject:@”One” forKey:[NSNumber numberWithInt:1]];

Memory Management

Objective-C 2.0 includes garbage collection. However, garbage collection is not available for iOS apps. iOS apps must manage memory by following a set of object ownership rules. Each object has a retain count which indicates the number of objects with an ownership interest in that object. Ownership of an object is automatically taken when you call a method beginning with alloc, prefixed with new, or containing copy. Ownership is manually expressed by calling the retain method. You relinquish object ownership by calling release or autorelease.

When an object is created it has a retain count of 1 When the “retain” message is sent to an object, the retain count is incremented by 1 When the “release” message is sent to an object, the retain count is decremented by 1 When the retain count reaches 0, it is deallocated

// alloc sets the retain count to 1
Book *book = [[Book alloc] init];
// do something...
// Release message decrements the retain count,
// Retain count reaches 0. Book will be deallocated
[book release];

dealloc Method

When an object’s retain count reaches 0, it is sent a dealloc message. You will provide implementations of the dealloc method, which will call release on the instances retained variables. Do not call dealloc directly.

// Book.m: Implement release of member variables
- (void) dealloc
{
	[title release];
	[author release];
	[super dealloc];
}

Autorelease Pools

An autorelease pool (NSAutoreleasePool) contains references to objects that have received an autorelease message. When the autorelease pool is deallocated, it sends a release message to all objects in the pool. Using an autorelease pool may simplify memory management; however, it is less fine grained and may allow an application to hold onto more memory than it really needs. Be watchful of which types and size of objects you use with autorelease.

// call autorelease on allocated instance to add it to the autorelease pool
Book *book = [[[Book alloc] init] autorelease];

Categories

Categories are a powerful language feature which allows you to add methods to an existing class without subclassing. Categories are useful to extend the features of existing classes and to split the implementation of large classes into several files. Categories are not subclasses. Generally, do not use methods in a category to extend existing methods except when you wish to globally erase and redefine the original method. Categories can not add instance variables to a class.

// BookPlusPurchaseInfo.h adds purchase related methods to the Book class
#import “Book.h”
@interface Book (PurchaseInfo)
- (NSArray *) findRetailers;
@end
// BookPlusPurchaseInfo.m implements the purchase related methods
#import “BookPlusPurchaseInfo.h”
@implementation Book (PurchaseInfo)
- (NSArray *) findRetailers {
	return [NSArray arrayWithObjects:@”Book World”,nil];
}
@end
// call a method defined in the BookPlusPurchaseInfo category
Book *book = [Book createBook:@”Moby Dick” withAuthor:@”Herman Melvile”];
NSArray *retailers = [book findRetailers];

Selectors

Selectors create method identifiers using the SEL datatype. A value can be assigned to a SEL typed variable via the @selector() directive. Selectors, along with NSObject’s method performSelector: withObject: enable a class to choose the desired message to be invoked at runtime.

// Execute a method using a SEL selector and the performSelector method
id target = [[Book alloc] init];
// Action is a reference to the “doSomething” method
SEL action = @selector(doSomething);
// The message sender need not know the type of target object
// or the message that will be called via the “action” SEL
[target performSelector: action withObject:nil ];

Working With Files

iOS applications have access to files in an app-specific home directory. This directory is a sand-boxed portion of the file system. An app can read and write files within this its own hierarchy, but it can not access any files outside of it.

// Get the path to a iOS App’s “Documents” directory
NSString *docDir = [NSSearchPathForDirectoriesInDomains(NSDocumentDirectory,
NSUserDomainMask, YES) lastObject];
// List the contents of a directory
NSFileManager *fileManager = [NSFileManager defaultManager];
NSArray *files = [fileManager contentsOfDirectoryAtPath:docDir error:nil];
for (NSString *file in files) {
	NSLog(file);
}
// Create a directory
NSString *subDir = [NSString stringWithFormat:@”%@/MySubDir”,docDir];
[fileManager createDirectoryAtPath:subDir attributes:nil];
// Does the file exist?
NSString *filePath = [NSString stringWithFormat:@”%@/MyFile.txt”,docDir];
BOOL exists = [fileManager fileExistsAtPath: filePath];

Tools

Xcode

The IDE included in the iOS SDK is named Xcode. It is the primary tool in the suite of utilities that ship with the SDK. Xcode has a long history but has been given a dramatic set of feature additions in the modern iPhone and iPad releases, including detection of common user-coded memory leaks and quick-fixing of other syntax and coding mistakes.

Plain text editors and command line Make files can be used to produce iOS applications. However, Xcode offers compelling features such as syntax highlighting and code completion. These features make writing Objective-C in the Xcode IDE a delight and a favorite of developers everywhere.

Once the code is in a valid-syntax state, compile it by choosing Build ➡ Build from the menus, or > B. If there are code errors, they will appear as a yellow or red icon in the lower right corner of the IDE. Clicking on the icon will reveal a panel detailing the warnings and errors.

Deploying an application to the simulator has two simple steps. First, choose the Simulator target from the main Xcode toolbar. Building and Deploying can be done in one seamless step by pressing the Command and Enter keys. The simulator will receive the compiled application and launch it.

To deploy to an iPhone or iPad, first select Device from the aforementioned toolbar menu. Second, right click on the element beneath the Target node of the Groups and Files tree and choose Get Info. Choose the Properties tab and ensure the Identifier matches the name or pattern you established with Apple for your Provisioning Profile at http://developer.apple.com/iphone

Organizer

The Organizer window provides a list of favorite projects, enumerates your attached iOS devices, streams the current device console log to screen and displays details of past crash logs. It can be opened from Xcode via

Debugging

The Xcode platform provides a robust debugger and supplementary mechanisms for stepping through code. Breakpoints are easily set by single clicking in the gutter next to any line of code. A blue arrow indicates a breakpoint is set and active.

Once a breakpoint is hit, variables can be inspected and the stack examined via the key combination The bottommost panel is called the console, and is where all logging output, written via calls such as NSLog(@“My counter is: %d”, myIntCount), is routed.

Interface Builder

A tool as powerful as Xcode is Interface Builder. Its name clearly expresses its use for designing Objective-C NIBs and XIBs, which are the binary and XML form of user interface definition files on the Mac, iPhone, and iPad.

NIBs, though graphically designed, actually instantiate the objects declared via the tool when called upon via code. Accordingly, it may help to think of IB (as it is known in the community) primarily as a class-instance designer and property value setter.

New elements can be added to a design canvas in a dragand- drop WYSIWYG approach via the Library panel, which can be accessed via the key combination. After saving changes, the design’s behavior can be immediately tested through the Simulate Interface command, which can be invoked via + R.

Simulator

The iPhone and iPad Simulator is another distinct application in the iPhone SDK that communicates and integrates with the Xcode IDE and with Interface Builder. In the Xcode section, we saw how to deploy our application to the Simulator, which both installs the application and launches it.

While the Simulator offers a great desktop testing experience that requires no purchase of hardware, it has a few shortcomings such as the lack of a camera, gyroscope, or GPS facilities. The lack of camera is somewhat mitigated by a supply of several stock photos in the Photo application. The harsh absence of a gyroscope is minimized only by the shake and rotate gestures possible through the Hardware menu. And last, the omission of a true GPS simulator is performed by GPS calls always resolving to 1 Infinite Loop, Cupertino, CA, USA.

The iPhone Simulator offers iPad, iPhone and iPhone 4 simulation modes. The modes are toggled via the Hardware ➡ Device menu.

The Simulator ships with a limited number of core applications; namely, the Photos, Settings, Camera, Contacts and Safari programs. These are the applications that offer API connectivity from the source code of your application. For a broader set of programs and more realistic mobile horsepower CPUs, testing on an actual iOS device is critical. Commercial apps that you’ve purchased from the iTunes App Store cannot be installed on the Simulator for DRM reasons and the vast difference in CPU architecture of x86 desktops and ARM mobile devices.

Xcode Keyboard Shortcuts

Common XCode Shortcuts

	toggle between .h and .m file
	quickly open a file via search dialog
	build
	build and run
	clean the build
	go to console view
	go to project view
	show / hide upper right pane
	show / hide all but the active document window
	while in file editor - show / navigate list of recent files
	while in file editor - show / navigate list of class methods
	build and debug
	debugger continue
	open quick documentation for class at mouse cursor

Unit Testing and Code Coverage

Currently, the unit testing tools for Objective-C are less mature than those of other languages. XCode currently includes the OCUnit unit testing framework. OCUnit tests are coded similarly to those of xUnit tests in languages such as Java. The Google Toolbox for Mac provides several useful enhancements to OCUnit and is the testing solution currently recommended by ThoughtWorks for the iOS platform. Complementing OCUnit is OCMock, an Objective-C implementation of mock objects. CoverStory can be used in concert with OCUnit and OCMock to check the code coverage of your tests.

Resources

SDK

Apple Developer Programs - http://developer.apple.com/
iOS SDK - http://developer.apple.com/iphone/index.action

Testing

Google Toolbox for Mac - http://code.google.com/p/google-toolbox-for-mac/
OCMock - http://www.mulle-kybernetik.com/software/OCMock/
CoverStory - http://code.google.com/p/coverstory/

Blogs, Videos, Books

WWDC 2010 Session Videos - http://developer.apple.com/videos/wwdc/2010/ Objective-C Basics -

http://en.wikibooks.org/wiki/Cocoa_Programming/Objective-C_basics iPhone Development Wiki - http://iphonedevwiki.net/index.php/Main_Page The Objective-C Programming Language -

http://developer.apple.com/mac/library/documentation/Cocoa/Conceptual/ObjectiveC/ Bookmarks - http://delicious.com/matthew.mccullough/objectivec

DZone » Refcardz » : NetBeans Java Editor 6.8