interactive technology privateer

Whenever I jump into a new language there are two basic questions I ask:

1. How do I define a variable?
2. How do I output stuff?

In that order, actually, which almost seems backwards when I look at it. For now I’m only going to go over the first question because the second question is still pretty mystical to me and I have beef with some of the terminology.

What are you complaining about this time?

In part 1 of this series I constantly got compiler errors that said “field this..” or “field that…” So, I thought to myself “What the hell is a field? It’s referring to a variable!” Here’s what I found:

They’re the same thing and people use the terms interchangably!

It’s a freakin’ variable, so call it a variable! What’s so difficult about that? Is “field” the new hip term and I’m just a square? Come on! Even the term “variable” itself tells me exactly what it’s used for, “field” does not.

From here on out, or until I hear a perfectly reasonable explanation, to express my disdain I will italicize field whenever I use it. And I’m only going to use it when I think it’s absolutely necessary.

Get on with some code already

So, to define a varible in AS3 you would do something along these lines:

// class level variable
public var foo:uint = 0;
 
// class level static variable
protected static var foo:Boolean = false;
 
// a variable scoped in a function or control structure
var foo:String = "bar";

Defining the same fields in C# is similar:

// class level
public uint foo = 12;
 
// class level static
protected static bool foo = false;
 
// scoped in a function or control structure
string foo = "bar";

There’s not too much of a diference between the two. Basically you just have to move the type declaration before the variable name and remove the “var” statement. This irks me some because now fields start to look dangerously close to methods. Notice:

// a field
public string foo = "bar";
 
// a method
public string bar() { ... }

At least in AS3 you have the “var” and “function” statements to help visually seperate the two.

Go on…

One thing I think C# does well is getters and setters, and this is a big deviation from the AS3 way. Here’s how to do it in AS3:

// getter
public function get foo():uint { ... }
 
// setter
public function set foo(value:uint):void { ... }

And now in C#:

public uint foo
{
    // getter
    get { ... }
 
    // setter
    set { ... }
}

Honestly, this is just fantastic. AS3 can get ultra messy because you can seperate the getter and setter in the code and make it a pain for someone to find them. But C# forces you to keep them together. It forces your code to be more organized.

However, this also makes fields look even more like methods and it’s starting to be a real pain to skim over code and imediately know what I’m looking at.

That’s it for now

This post really ballooned into something unexpected, my bad. It’s day 5 and I can confidently code without having to compile every two minutes.