MSDN Magazine - February 2009 - (Page 58)

JBehave was the result of problems North faced with Test-Driven Development (TDD) and was implemented for the Java language. Later, North created RBehave, which has since been integrated into RSpec, a popular framework for Ruby. RSpec accommodates two different approaches to BDD: Dan North’s approach, based on stories and scenarios to describe application’s behavior, and Dave Astels’ approach (blog.daveastels.com), which is more focused on creating examples at an object level. C# does have some BDD frameworks, such as NSpec and NBehave. The main problem with writing tests in C# is that the true intent of the test is often hidden due to fact that you have extra structural elements and metadata such as braces, public and private. Overall, I don’t think what is on offer via C# and NSpec/ NBehave can match what is available via IronRuby and RSpec. Previously, this would have been a major problem for C# developers, as you could not have used the Ruby-based RSpec to test C# apps. With IronRuby, this is no longer a problem. While still early in development, IronRuby is taking advantage of the Dynamic Language Runtime (DLR) to create an implementation of the Ruby language on top of the CLR. With IronRuby, you can employ existing Ruby apps and frameworks together with the .NET Framework and .NET-compliant languages. The result is that you can use the Ruby language and RSpec to test C# applications! As a language, Ruby is concise, allowing you to write less code and express it in a much more natural manner, making your code easier to maintain. For example, to read all the lines of text from a file and write them out to the console, you would write this: File.readlines('AboutMicrosoft.txt').map {|line| puts line} Ruby is a concise language, allowing you to write less code and express it in a much more natural manner. To demonstrate this, I created a method that accepts a value, the type of which will be inferred at run time. It will then output Hello plus the value: def SayHello(val) puts "Hello #{val}" end Because of the way types are handled, you can reuse the same method for both strings and integers without changing any of the code: SayHello("Test") => "Hello Test" SayHello(5) => "Hello 5" I could have also have called the method without brackets, as these are optional in Ruby and can make the syntax much more readable: SayHello "Test" => "Hello Test" This can be achieved in C# using object, but let’s look at how this works with more complex objects. I defined a new method to output the result of a call to GetName. As long as the value of the parameter n implements a method called GetName, the code will work: def outputName(n) puts n.GetName() end Here are two unrelated classes: class Person attr_accessor :name def GetName() @name end end class Product def GetName() "The product with no name" end end The code opens the file AboutMicrosoft.txt and reads all the lines, passing each line into the block, with the line as a parameter that is then written to the console. In Ruby, a block is the collection of statements between the braces and is similar to invoking a method in C#, which uses the yield statement to return control to the calling method. Its natural language approach is one of the reasons why Ruby is excellent to use when testing. The tests, or scenarios in this case, are much more readable. Person has an accessor allowing the name variable to be set, while Product returns a hardcoded value. In Ruby, there is no need to write the return statement, the last result of the last line of code of a method is returned by default. If you call the method outputName, the GetName method is called, demonstrating how Ruby’s typing can enhance code reusability since we are not fixed to a single type: outputName(Product.new) => "The product with no name" $x = Person.new $x.name = "Ben Hall" outputName($x) => "Ben Hall" Ruby and Duck Typing One of the reasons why Ruby and dynamic languages are easier to read is due to how they handle typing. Instead of the developer defining a type, when the Ruby code is interrupted, the type of the variable is inferred. The language is still strongly typed, but it determines the variable’s type dynamically. With C#, interfaces allow for decoupling of objects while still defining a contract for the implementation. With Ruby, there is no need for contracts and interfaces. Instead, if the object has an implementation of the method you are calling, then it’s called. If it doesn’t, then an error is returned. As such, the contract for the object is defined by its implementation, not its relationship to other parts of the code. 58 msdn magazine If you call the method using an argument that doesn’t implement GetName, then a NoMethodError is raised: outputName("MyName") => :1:in 'outputName': \ undefined method 'GetName' \ for MyName:String (NoMethodError) While this concept concerns some people, it can be useful; it allows for improved testability and application design, especially when testing C# applications, which I will discuss in the next section. Ruby and MetaProgramming Similar to other dynamic languages, Ruby embraces the concept of meta-programming. This allows you to extend any class or object at run time, enabling you to define methods and behavior at run time, giving you the ability to develop a self-modifying appliIronRuby and RSpec http://blog.daveastels.com

Table of Contents Feed for the Digital Edition of MSDN Magazine - February 2009

MSDN Magazine - February 2009 Contents Toolbox CLR Inside Out Data Points Cutting Edge Patterns In Practice Best Practices .Net Interop "Oslo" Basics Patterns Silverlight Under The Table Foundations Windows With C++ .NET Matters Going Places { End Bracket }

MSDN Magazine - February 2009

For optimal viewing of this digital publication, please enable JavaScript and then refresh the page. If you would like to try to load the digital publication without using Flash Player detection, please click here.