My evolved talk on intro to Obj-C and iOS for .NET savvy people.
Obj-C for C# devs
try to think different
UH grad in EE
Former DotNetter, now full-
time mobile and rails developer.
Head of the C#UG for the last
#1 A mac
free to sign up and start coding to the
simulator, $99/yr to deploy an app
Created in 1986 by Tom Love and Brad Cox
Marriage of C with Smalltalk
Dynamic language, runs natively not on/in a virtual
Simply put, it’s a superset of C, with OO and
Steve Jobs at Next adopted it, later Mac OSX was
based on it.
It is C, so you can use all the features and libraries available
Basic building blocks:
Classes, deﬁned by interfaces
Value types (Structs, primitives, etc.)
Pointers are needed when referring to objects.
Function pointers are achieved through Blocks
really a message
Calling a method
Yes, in the dynamic world you’re sending a message
to an object, and at runtime the system will try to
ﬁnd a method (or property) with that matching
name and params to then execute.
A good analogy is to think of a class as a
dictionary, with a key-value system.
return type method name
reads as, Add num1
Fluent reading built in
Making a class
Start with an interface ﬁle
The @ symbol
Declare properties, methods and instance
Make an implementation ﬁle
Notice the #import statements, there
are no namespaces in Obj-C.
What we’re used to. Remember, no
need for interface in C# to create a
must be deﬁned in
practice of setting
self to result of base
must return self
Constructors are called Initializers in
Allocating and Initializing a Class
must call alloc ﬁrst
on the class
then call init with
the result of alloc
id can be used to
represent any type
What would a OO language be without
Syntax is the same
goes in the interface
Notes on Obj-C inheritance
It’s like (if not the same) as Ruby.
if you want to override a base method, simply name
it the same, have the same return type and params.
No need to mark things virtual, or use the new
keyword, override, etc.
Inheritance is everywhere in Objective-C/Cocoa,
where as in C# interfaces and Composition are
Back to methods
- indicates the method is an instance method
+ indicates a “class” method, static in the C# lingo.
All methods and properties in the interface section
are visible to the caller or subclass.
@private at the top of the implementation section can
list methods you want to be private.
Here’s the equivalent of auto implemented
properties in C#.
tells compiler to
create getter and
attributes type variable name
Extending a class
How is it done in C#?
Objective-C calls them Categories, they work in the
same way extending in Ruby works (almost).
( catName ) tells
compiler it’s a
will add DoFoo to
any instance of Base
We love interfaces in C#
Protocols in Obj-C
can inherit another
Can “conform” to
Can set adoption to
optional or required
If @required or @optional are not marked above methods in the protocol (the
2 can be mixed), then it’s required by default.
if the method was marked @optional, then the adopter/conformer doesn’t
have to implement the method
But caller of the class needs to check if the method is implemented
use reﬂection to test
conformity and implementation
of an optional method
There is no garbage
collection on iOS
Memory mgt. at 1000ft
you had to release an obj when
you were ﬁnished
retain it to increase the retain
count so it won’t be deallocated
You were in charge of managing objects on your
own with the pre-deﬁned rules on when to retain,
release and/or set to nil.
Doing this incorrectly could cause memory leaks.
iOS 5 brought ARC, or Automatic Reference
Simply put, the compiler adds the appropriate
release, retains where they’re needed.
Cool things in
C# eventually had the dynamic keyword, Obj-C has
this by nature, it’s called id
nil is special
desc will now be nil, no exception is
can’t do this in C#, unless it was a
if statements fail if condition is nil
or null (works on value and object
This is a feature added by the Foundation
framework, but it’s cool enough to be on the list
*”KVO provides a mechanism that allows objects to
be notiﬁed of changes to speciﬁc properties of other
objects.” - Apple documentation
call addObserver method
from NSObject to setup the
to complete the functionality
method will catch all changes of
any properties, so set logic for
change you’re interested in
Blocks => Lambdas
In Obj-C we have blocks to create anonymous
functions, used in the same way anon/lambdas are
used in C#.
ext. method category
method call message send
null nil (for objects) null (for values)
static method class method
Anonymous method Block
There’s not an equivalent to Generics in C#. Mainly
because of the dynamic nature, much like Ruby.
Obj-C discourages method chaining, because it
becomes more unreadable unlike other languages.
Less hand holding than what VS and the C#
Like Rails, CocoaTouch has MVC baked in, it’s the
preferred way to build applications.
Because iOS apps generally aren’t enterprise, you
won’t see complex DDD layers and architectures.
Cocoapods is the NuGet/Gems equivalent.
The standard Unit Test framework that ships is
called OCUnit. Much like NUnit, JUnit, etc.
There’s also plenty of BDD, Speciﬁcation testing
options as well.
Apple documentation is great, much better than