Datasheet

ManualsBrandsFor Dummies ManualsSoftware978-0-470-56348-9

Chapter 1: Programming

Dynamically!

In This Chapter

✓ Understanding dynamic typing

✓ Defining variables

✓ Putting dynamic to use

✓ Making static operations dynamic

or many years, I thought that dynamic programming referred to being

really flashy and flamboyant while writing code. So, I started wearing

Hawaiian shirts and singing loudly.

Later, I found out this isn’t the case.

Dynamic programming is another one of those buzzwords that really doesn’t

have a clear definition. At its loosest, it means developing something in such

a way that the program makes more decisions about the way it runs while

running, rather than when you compile it.

Scripting languages are a great example of this. When you write something

in VBScript, you don’t compile it at all — all of the decisions are made at

runtime. Ruby is another good example: Most of the time, an entire program

can just be typed into a command prompt and run right from there.

There are examples that are not so good — like VB Classic. Remember the

Variant type? You could declare a variable to be Variant and VB wouldn’t

decide what it was supposed to be for real until the program ran. In the

best of cases, this added immense flexibility to the language. In the worst of

cases, you got Type Mismatch errors at runtime.

To give a concrete example, when you declare a variable in a dynamically

typed language, you don’t have to say what type you are making that vari-

able. The compiler will just figure it out for you. In a static language, like C#

3.0, you do have to say what type you are making that variable.

Microsoft originally promised that dynamic types would never be in C#,

but later decided that the feature had to be added. Why? Mostly, it’s

because of the development for Microsoft Office (like the reasoning for

much of the rest of Book VIII). Office uses COM, the pre-.NET structure for

Microsoft applications.

53_563489-bk08ch01.indd 76953_563489-bk08ch01.indd 769 3/19/10 8:17 PM3/19/10 8:17 PM

COPYRIGHTED MATERIAL

Summary of content (12 pages)

PAGE 1
Chapter 1: Programming Dynamically! AL In This Chapter ✓ Understanding dynamic typing ✓ Making static operations dynamic MA F TE ✓ Putting dynamic to use RI ✓ Defining variables D or many years, I thought that dynamic programming referred to being really flashy and flamboyant while writing code. So, I started wearing Hawaiian shirts and singing loudly. TE Later, I found out this isn’t the case.
PAGE 2
770 Shifting C# Toward Dynamic Typing COM expects that the languages that use it (like VB Classic and C++) will have dynamic types. This made developing for Microsoft Office difficult for C# programmers, which was exactly opposite of what Microsoft wanted to happen. The end result? The dynamic type. Shifting C# Toward Dynamic Typing So-called “dynamic languages” are a trend that keeps coming back, like ruffled tux shirts. Dynamic languages are languages that allow for loose typing, rather than static.
PAGE 3
Shifting C# Toward Dynamic Typing 771 ✦ Python ✦ Cobra (my new favorite) ✦ Groovy ✦ Boo ✦ Newspeak Programmers who work in dynamic languages — how can I put this gently — feel strongly about their choice of tools. The communities are very strong.
PAGE 4
772 Programming Dynamically Other benefits to dynamic languages in general show up as you use them more. For instance, macro languages are usually dynamically typed. If you have tried to build macros in previous versions of Visual Studio, you know what a pain it is to use a static language. Making C# (and VB.
PAGE 5
Programming Dynamically 773 However, we can do this: dynamic newCourse = SomeFunction(); newCourse.Schedule(); All this code needs to have is the stub of a function that returns some value, and we are good to go. What if SomeFunction() returns a string? Well, we will get a runtime error. But it will still compile! About now, if you are anything like me, you have to be thinking: “This is a good thing? How!?!” I hear you, trust me. For the time being, you can blame COM.
PAGE 6
774 Putting Dynamic to Use What happens if newCourse comes back as something that doesn’t have a Schedule method? You get a runtime error. But there are try/catch blocks for runtime errors. Nothing will help it compile without the dynamic keyword. Readers who are long-time Visual Basic programmers, or even newer VB.NET programmers, realize that you can handle this dynamically — and have always been able to — in Visual Basic.
PAGE 7
Putting Dynamic to Use 775 ✦ int newString = (int) dynamicVariable;: This is an explicit cast to int. The compiler encodes this as a cast — you actually change the type here. ✦ Console.WriteLine(dynamicVariable);: Because there is no overload of WriteLine that accepts a dynamic type explicitly, the entire method call is dispatched dynamically.
PAGE 8
776 Running with the Dynamic Language Runtime Here is the compiled C# code: class C { [return: Dynamic] public object MyMethod([Dynamic] object d) { if (MyMethodo__SiteContainer0.p__Site1 == null) { MyMethodo__SiteContainer0.p__Site1 = CallSite> .Create(new CSharpCallPayload( CSharpCallFlags.None, “Foo”, typeof(object), null, new CSharpArgumentInfo[] { new CSharpArgumentInfo(CSharpArgumentInfoFl ags.None, null) })); } return MyMethodo__SiteContainer0.p__Site1 .
PAGE 9
Running with the Dynamic Language Runtime 777 Figure 1-1: The Dynamic Language Runtime. The runtime helps the compiler to construct code in the compiled assembly that will make a lot of choices dynamically. The code block at the end of the preceding section is an example of the simplest kind. The DLR assisted in the creation of IRONRuby, which makes it possible to code in Ruby — the current hot dynamic language — right in Visual Studio.
PAGE 10
778 Running with the Dynamic Language Runtime def main Array.new(11) { gets.to_i }.reverse.each do |x| y = f(x) puts “#{x} #{(y>400) ? ‘TOO LARGE’ : y}” end end end This isn’t a Ruby book, and that fact isn’t lost on me. Nonetheless, this is the best dynamic language that I can use for an example — bar none. Two functions are defined: f and main. Main accepts 11 numbers from the console and then moves them to an integer array (that’s what gets.to_i does).
PAGE 11
Running with the Dynamic Language Runtime 779 dynamic y = f(array[i]); if (y > 400.0) { Console.WriteLine(string.Format(“{0} TOO LARGE”, i)); }else{ Console.WriteLine(“{0} : {1}”, i, array[1]); } } Console.ReadKey(); } Line for line, the application does the same thing as the Ruby code, albeit longer. I kept the names the same so it was easier to follow. Because I had to use for loops to handle the integrators, it made the body of the program quite a bit beefier.
PAGE 12
780 Running with the Dynamic Language Runtime Add to that the reality that C# is making runtime decisions about every single variable throughout the entire run of the program. That’s a whole lot of extra processing that we could have avoided if we had just done that static typing. The take-home here is that using dynamic types makes your programming job much easier and your troubleshooting job much harder.