Read here: LFFS – 12: Flex Builder Part 2 – Getting Acquainted With The Workbench

Also, we’ve registered www.learningflexfromscratch.com as a shortcut to our content on Inside RIA.

thanks for reading
-adam

I have a new post up on InsideRIA called : More on Static Code. This is in response to the high demand that I saw in my blog analytics for a post I did sometime back on this blog called Static Code Blocks in ActionScript!.

I hope you find it helpful.
-adam

Original post from: http://www.developria.com/2008/05/more-on-static-code.html

One of the most popular posts on my blog adamflater.net has been Static Code Blocks!. Due to the amount of requests for that post I thought it made for a good topic to feature on InsideRIA regarding ActionScript and static code.

First off, what is static code? Static code is executable code that is said to belong to a Class. An instance method of an Object exists N times for the N instances of the Class type of Object, but static code exists only once no matter how many instances of the Object exist. The other difference between an instance method and static code is that static code has a static scope. In other words, the code executing in the static block may only access the other static members of the Class that it belongs to.

There are essentially three ways to create static code blocks in ActionScript: Using the Mixin Class meta tag, wrapping the code in an unnamed block, and using a static method initializer pattern. In reviewing each of these solutions it’s important to consider order of execution and scope.

So, let’s take a look at these three solutions in the order that they’re executed.

1. Using a static var as an initializer

This solution is executed by the Flash Player first out of the other two solutions. It involves using a static variable to call a static method.

Generally it looks like this:

In this example initialized is a static variable that technically belongs to the Class (not the Object). Although this variable is accessible by the Object it “lives” at the Class level. When the class is being loaded by the Flash Player the variable initialized is created and assigned the value returned by the initializer method. Like the other examples, this code is executed once no matter how many times the Class it belongs to is instantiated.

2. Unnamed code block

If, for some reason, you’re using the static initializer pattern shown in the first example and you also have an unnamed code block in your class, the unnamed code block will be executed second. A simpler example is:

Again, the scope of this block is the static scope (ie Class members are accessible).

3. The Mixin meta tag

The last to execute in this series of static code blocks is the Mixin meta tag. An example of this solution is:

In this solution the init method also has a static scope limited to the Class it belongs to, but in addition there is a reference passed into the method to the application’s SystemManager called systemManager. The system manager provides access to many interesting areas of your application. SystemManager is also available via the static reference:Application.application.systemManager however, in the previous two examples the classes needed to obtain a reference the SystemManager using Application.application.systemManager have not yet been created. By using the Mixin tag you’re guaranteed that the Flash Player / Flex Framework has initialized and created the Application and SystemManger classes.

It’s equally important to note that the other two solutions executed before the Application and SystemManager have finished initializing. This is important if you have some code that you need to have executed before these classes finish their instantiations.

Aside from initializing custom styles in components you may not find a lot of uses for static code blocks in a typical Flex application, but these techniques can come in handy if you’re building a service API or Framework in Flex.

I hope this was a valuable follow up post to my original effort outline static code blocks. I’d love to hear your questions and comments.

Thanks to Rich for making me a two time Inside RIA guest blogger.

In LFFS 5 Scotty is taking us into the world of ActionScript loops and conditionals. Need a beginners look at a for, for in, for in each, while, or do while loop? Look no further than LFFS.

In LFFS 6 we’re jumping into Arrays. This post is an introductory look at using Arrays in ActionScript. It is by no means comprehensive, and doesn’t touch on collections yet, but it’s a good way to jump in to the concept.

Thanks for reading
-adam

Our latest post in the Inside RIA series “Learning Flex from Scratch” is up. It’s called: LFFS – 4: Actionscript 3.0. In this post Scott begins his journey into the syntax of Actionscript 3.0. This first post is a look at how to write a basic class… posts will follow with examples on writing loops, if-then conditionals and more..

stay tuned
-adam

Stay tuned.. thanks for reading.

LFFS – 1: Meet the Authors, Meet Flex

This first post is an introduction of Scott and myself and a way to set a base for what we’ll be up to in the coming posts. Our next post is called Flex Defined. In Flex Defined we’ll define the major topics of Flex that are important for a novice learning Flex to be aware of.

You’ll also be able to find the aggregation of all our posts at: InsideRIA: Adam Flater and Scott Sheridan Archives

Here’s our summary for the series:

This series of installments will chronicle the learning of a complete beginner as he attempts to become a Flex developer. The series will culminate with the production of a working application built in Flex and deployed on the web. Our hope is to create a reference that will serve as a guide to those new to programming and wishing to step into the world of Flex.