return a = “hello”; What will Happen?

• Posted by Shay Friedman on April 28, 2010
• 12 comments

I came across an interesting piece of code the other day, something I didn’t even know possible in C#.

Consider the next code (which doesn’t make lots of sense, but it gets the point across):

public string Test()
{
  string a;
  return a = "hello";
}

What do you think will happen? what will be returned from this method?

…
……
………….
………………

So?

…
……
………….
………………

The answer is that this method will return “hello”.

Why did it happen?

When thinking more about it, this behavior is expected. It becomes very clear when reading about the assignment (=) operator on MSDN:

To make things even simpler, think about the syntax of multiple assignments in one line – b = a = “hello”; – this is exactly the same. In the sample above I just return the value instead of assigning it to the variable b.

All the best,
Shay.

A Mini-Review-Benchmark of Ruby’s Different Testing Frameworks

• Posted by Shay Friedman on April 9, 2010
• 15 comments

On of the most shining features of the Ruby language for .NET developers is, in my opinion, its testing frameworks. Ruby has got such amazing testing frameworks that it is such a shame that people still use other languages to test code.

The goal of this post is simple – to show you how to test a given code in various different frameworks, so you can choose the one for you. In the meanwhile I will also take the amount of time taken for each framework to run the tests and compare the times at the end.

For that I’m using my Ruby implementation of choice – IronRuby RC4 (1.8.6 compatible) and my powerful computer (running Windows 7 64-bit). Each testing framework will contain the same 7 tests of the tested code and be executed from the command line.

Note: The testing frameworks I bring in this post are my own random picks. I tried to bring the popular ones and some other small but interesting ones. There are more testing frameworks in Ruby and if you think I should add another ones, let me know and I’ll add them to the list too.

The Tested Code

The code I’m going to test is a C# code (IronRuby FTW!) which resides in an assembly named WaterHelper.dll. The code is as follows:

namespace Demo
{
    public class WaterHelper
    {                
        public bool IsWaterBoiled(decimal celsius)
        {
            return celsius >= 100;
        }

        public bool IsWaterFrozen(decimal celsius)
        {
            return celsius <= 0;
        }

        public string GetWaterStatus(decimal celsius)
        {
            if (IsWaterBoiled(celsius))
            {
                return "Steam";
            }
            else if (IsWaterFrozen(celsius))
            {
                return "Ice";
            }
            return "Liquid";
        }
    }
}

Not much of complication here – three methods that do some water temperature related calculation.

Test::Unit

Official site: http://ruby-doc.org/stdlib/libdoc/test/unit/rdoc/classes/Test/Unit.html

The first testing framework I’m using is Ruby’s built-in one – Test::Unit. It is very similar to NUnit (in .NET) or JUnit (in Java).

The Test::Unit test code which tests the WaterHelper class is as follows:

require 'test/unit'
require "WaterHelper.dll"

class TC_WaterHelper < Test::Unit::TestCase
  def setup
    @instance = Demo::WaterHelper.new
  end
  
  def test_water_boiling_point
    result = @instance.is_water_boiled(100)
    assert_equal true, result
  end
  def test_water_is_boiled
    result = @instance.is_water_boiled(150)
    assert_equal true, result
  end
  
  def test_water_freezing_point
    result = @instance.is_water_frozen(0)
    assert_equal true, result
  end
  def test_water_frozen
    result = @instance.is_water_frozen(-50)
    assert_equal true, result
  end
  
  def test_water_status_steam
    result = @instance.get_water_status(300)
    assert_equal "Steam", result
  end  
  def test_water_status_liquid
    result = @instance.get_water_status(70)
    assert_equal "Liquid", result
  end
  def test_water_status_Ice
    result = @instance.get_water_status(-5)
    assert_equal "Ice", result
  end
end

Execution time: 0.082005 seconds.

RSpec

Official site: http://rspec.info/
Version: 1.3.0

By following BDD principles and providing a clean and elegant DSL (Domain Specific language), RSpec has gained a lot of fans. It is maybe the most popular testing framework in the Ruby world currently.

The code to test the WaterHelper.dll with RSpec is as follows:

require "rubygems"
require "spec"
require "spec/autorun"
require "WaterHelper.dll"

describe "Testing WaterHelper class" do
  before(:each) do
    @instance = Demo::WaterHelper.new
  end
  
  it "should be boiling water when it is 100 degrees" do
    result = @instance.is_water_boiled(100)
    result.should be_true
  end  
  it "should be boiling water when it is 150 degrees" do
    result = @instance.is_water_boiled(150)
    result.should be_true
  end
  
  it "should be frozen water when it is 0 degrees" do
    result = @instance.is_water_frozen(0)
    result.should be_true
  end
  it "should be frozen water when it is -50 degrees" do
    result = @instance.is_water_frozen(-50)
    result.should be_true
  end
  
  it "returns Steam for 300 degress" do
    result = @instance.get_water_status(300)
    result.should == "Steam"
  end
  it "returns Liquid for 70 degress" do
    result = @instance.get_water_status(70)
    result.should == "Liquid"
  end
  it "returns Ice for -5 degress" do
    result = @instance.get_water_status(-5)
    result.should == "Ice"
  end
end

Execution time: 0.201012 seconds.

Cucumber

Official site: http://cukes.info/
Version: 0.6.4

Cucumber is one of the most innovative frameworks out there. It took BDD one step further by providing a simple way to write requirement documents in a language called Gherkin (which is plain English with a few rules) and interpret them via code.

The next Gherkin code contains the requirements for the WaterHelper class:

Feature: WaterHelper
  As all users
  I want to know the status of the water
  To know how to treat it
  
  Scenario: Water are boiled at 100 degrees
    Given the temperature is 100 degrees
    When I check whether the water is boiled
    Then I should find out that it is
    
  Scenario: Water are boiled at 150 degrees
    Given the temperature is 150 degrees
    When I check whether the water is boiled
    Then I should find out that it is
    
  Scenario: Water are frozen at 0 degrees
    Given the temperature is 0 degrees
    When I check whether the water is frozen
    Then I should find out that it is
    
  Scenario: Water are frozen at -50 degrees
    Given the temperature is -50 degrees
    When I check whether the water is frozen
    Then I should find out that it is
    
  Scenario Outline: Water status
    Given the temperature is <temperature> degrees
    When I check the water status
    Then I should find out it is "<status>"
    
    Examples:
      | temperature | status |
      |     300     | Steam  |
      |     70      | Liquid |
      |     -5      |  Ice   |

And this is the Ruby code file to interpret the requirements:

require "WaterHelper.dll"

Before do
  @instance = Demo::WaterHelper.new
end

Given /the temperature is (.*) degrees/ do |temperature|
  @temperature = temperature.to_f
end

When /I check whether the water is boiled/ do
  @result = @instance.is_water_boiled(@temperature)
end
When /I check whether the water is frozen/ do
  @result = @instance.is_water_frozen(@temperature)
end
When /I check the water status/ do
  @result = @instance.get_water_status(@temperature)
end

Then /I should find out that it is/ do
  @result.should == true
end
Then /I should find out it is "(.*)"/ do |status|
  @result.should == status
end

Execution time: 0.883 seconds.

Shoulda

Official site: http://github.com/thoughtbot/shoulda
Version: 2.10.3
Modification: there is currently a bug in IronRuby which prevents Shoulda from running. I altered the IronRuby code to make it work and I’m in contact with the IronRuby team about the problem.

Shoulda is another popular testing framework. It is built on top of the Test::Unit testing framework and it makes it more developer-friendly.

The test code is as follows:

require 'rubygems'
require 'shoulda'
require "WaterHelper.dll"

class WaterHelperTest < Test::Unit::TestCase
  context "WaterHelper" do
    setup do
      @instance = Demo::WaterHelper.new
    end
    
    should "be boiling water when it is 100 degrees" do
      result = @instance.is_water_boiled(100)
      assert_equal true, result
    end
    should "be boiling water when it is 150 degrees" do
      result = @instance.is_water_boiled(150)
      assert_equal true, result
    end
    should "be frozen water when it is 0 degrees" do
      result = @instance.is_water_frozen(0)
      assert_equal true, result
    end
    should "be frozen water when it is -50 degrees" do
      result = @instance.is_water_frozen(-50)
      assert_equal true, result
    end
    should "return Steam for 300 degress" do
      result = @instance.get_water_status(300)
      assert_equal "Steam", result
    end
    should "return Liquid for 70 degress" do
      result = @instance.get_water_status(70)
      assert_equal "Liquid", result
    end
    should "return Ice for -5 degress" do
      result = @instance.get_water_status(-5)
      assert_equal "Ice", result
    end
  end
end

Execution time: 0.096005

riot

Official site: http://github.com/thumblemonks/riot
Version: 0.10.13
Modification: changed code to use iron-term-ansicolor (IronRuby’s equivalent to term/ansicolor)

The riot testing framework is a cute little thing. Its main goal is to make it quicker to write tests and to execute them. The code turns out very minimalistic, which makes this framework a good choice when you need to write some quick unit tests.

The next code contains the unit tests for the WaterHelper class written with the riot framework:

require "rubygems"
require "riot"
require "WaterHelper.dll"

context "Tests WaterHelper class" do
  setup {  Demo::WaterHelper.new }  
  
  asserts("the water is boiling when it is 100 degrees") {  topic.is_water_boiled(100) }    
  asserts("the water is boiling when it is 150 degrees") {  topic.is_water_boiled(150) }    
  asserts("the water is frozen when it is 0 degrees") {  topic.is_water_frozen(0) }    
  asserts("the water is frozen when it is -50 degrees") {  topic.is_water_frozen(-50) }
  asserts("you get steam when it is 300 degress") { topic.get_water_status(300) == "Steam" }
  asserts("you get liquid when it is 70 degress") { topic.get_water_status(70) == "Liquid" }
  asserts("you get ice when it is -5 degress") { topic.get_water_status(-5) == "Ice" }
end

Execution time: 0.083005 seconds.

Protest

Official site: http://rubyprotest.org/
Version: 0.3

Protest is another small and fun testing framework. It is described as a “small, simple and easy-to-extend testing framework” on its web site. It keeps it promise, I tell ya!

The next code tests the WaterHelper class using the Protest framework:

require "rubygems"
require "protest"
require "WaterHelper.dll"

Protest.context "WaterHelper class" do
  setup do
    @instance = Demo::WaterHelper.new
  end
  
  test "should be boiling water when it is 100 degrees" do
    result = @instance.is_water_boiled(100)
    assert result == true
  end
  test "should be boiling water when it is 150 degrees" do
    result = @instance.is_water_boiled(150)
    assert result == true
  end
  test "should be frozen water when it is 0 degrees" do
    result = @instance.is_water_frozen(0)
    assert result == true
  end
  test "should be frozen water when it is -50 degrees" do
    result = @instance.is_water_frozen(-50)
    assert result == true
  end
  test "returns Steam for 300 degress" do
    result = @instance.get_water_status(300)
    assert result == "Steam"
  end
  test "returns Liquid for 70 degress" do
    result = @instance.get_water_status(70)
    assert result == "Liquid"
  end
  test "returns Ice for -5 degress" do
    result = @instance.get_water_status(-5)
    assert result == "Ice"
  end
end

Execution time: 0.164009 seconds.

Stories

Official site: http://github.com/citrusbyte/stories
Version: 0.1.3

The Stories testing framework is built on top of Test::Unit and provides an entire different syntax for it. It has a convenient DSL for writing tests as “stories”.

The next code tests the WaterHelper class using the Stories framework:

require "rubygems"
require "stories"
require "WaterHelper.dll"

class WaterHelperClass < Test::Unit::TestCase
  story "As a user I want to know the status of the water" do
    setup do
      @instance = Demo::WaterHelper.new
    end
    scenario "Given 100 degrees, the water should be boiled" do
      result = @instance.is_water_boiled(100)
      assert_equal true, result
    end
    scenario "Given 150 degress, the water should be boiled" do
      result = @instance.is_water_boiled(150)
      assert_equal true, result
    end
    scenario "Given 0 degress, the water should be frozen" do
      result = @instance.is_water_frozen(0)
      assert_equal true, result
    end
    scenario "Given -50 degress, the water should be frozen" do
      result = @instance.is_water_frozen(-50)
      assert_equal true, result
    end
    scenario "On 300 degrees, water status should be steam" do
      result = @instance.get_water_status(300)
      assert_equal "Steam", result
    end
    scenario "On 70 degrees, water status should be liquid" do
      result = @instance.get_water_status(70)
      assert_equal "Liquid", result
    end
    scenario "On -5 degrees, water status should be ice" do
      result = @instance.get_water_status(-5)
      assert_equal "Ice", result
    end
  end
end

Execution time: 0.118007 seconds.

Lemon

Official site: http://proutils.github.com/lemon/
Version: 10.03.06

Lemon is an interesting unit testing framework. It provides a DSL which makes it very clear to identify which class and method you are testing. Moreover, it has code coverage capabilities which can report you which methods are not covered by your code. It is dependant on a bunch of other gems which makes it a bit slower than other frameworks.

The next code tests the WaterHelper class using the Lemon framework:

require "WaterHelper.dll"

TestCase Demo::WaterHelper do
  Concern "Water statuses are returned as expected."

  Before { @instance = Demo::WaterHelper.new }

  Unit :is_water_boiled => "returns true for 100 degress" do
    result = @instance.is_water_boiled(100)
    result.assert == true
  end
  Unit :is_water_boiled => "returns true for 150 degress" do
    result = @instance.is_water_boiled(150)
    result.assert == true
  end
  
  Unit :is_water_frozen => "returns true for 0 degress" do
    result = @instance.is_water_frozen(0)
    result.assert == true
  end
  Unit :is_water_frozen => "returns true for -50 degress" do
    result = @instance.is_water_frozen(-50)
    result.assert == true
  end
  
  Unit :get_water_status => "returns Steam for 300 degress" do
    result = @instance.get_water_status(300)
    result.assert == "Steam"
  end
  Unit :get_water_status => "returns Liquid for 70 degress" do
    result = @instance.get_water_status(70)
    result.assert == "Liquid"
  end
  Unit :get_water_status => "returns Ice for -5 degress" do
    result = @instance.get_water_status(-5)
    result.assert == "Ice"
  end
end

Execution time: 1.204097 seconds.

bacon

Official site: http://rubyforge.org/projects/test-spec
Version: 1.1

bacon is a small RSpec clone which is written in 300 lines of code. Its syntax is very similar to RSpec with a small difference on the expectation method (should).

The next code tests the WaterHelper class with the bacon framework:

require "rubygems"
require "bacon"
require "WaterHelper.dll"

describe "Testing WaterHelper class" do
  before do
    @instance = Demo::WaterHelper.new
  end
  
  it "should be boiling water when it is 100 degrees" do
    result = @instance.is_water_boiled(100)
    result.should.be.true
  end
  it "should be boiling water when it is 150 degrees" do
    result = @instance.is_water_boiled(150)
    result.should.be.true
  end  
  it "should be frozen water when it is 0 degrees" do
    result = @instance.is_water_frozen(0)
    result.should.be.true
  end
  it "should be frozen water when it is -50 degrees" do
    result = @instance.is_water_frozen(-50)
    result.should.be.true
  end
  
  it "returns Steam for 300 degress" do
    result = @instance.get_water_status(300)
    result.should.equal "Steam"
  end
  it "returns Liquid for 70 degress" do
    result = @instance.get_water_status(70)
    result.should.equal "Liquid"
  end
  it "returns Ice for -5 degress" do
    result = @instance.get_water_status(-5)
    result.should.equal "Ice"
  end  
end

Execution time: 0.120007 seconds.

Contest

Official site: http://rdoc.info/projects/citrusbyte/contest and http://github.com/citrusbyte/contest
Version: 0.1.2

Contest’s target is to bring contexts to Test::Unit. Its syntax is similar to Shoulda’s just with a different test method name (named test).

The code:

require 'rubygems'
require 'contest'
require "WaterHelper.dll"

class WaterHelperTest < Test::Unit::TestCase
  context "WaterHelper" do
    setup do
      @instance = Demo::WaterHelper.new
    end
    
    test "be boiling water when it is 100 degrees" do
      result = @instance.is_water_boiled(100)
      assert_equal true, result
    end
    test "be boiling water when it is 150 degrees" do
      result = @instance.is_water_boiled(150)
      assert_equal true, result
    end
    test "be frozen water when it is 0 degrees" do
      result = @instance.is_water_frozen(0)
      assert_equal true, result
    end
    test "be frozen water when it is -50 degrees" do
      result = @instance.is_water_frozen(-50)
      assert_equal true, result
    end
    test "return Steam for 300 degress" do
      result = @instance.get_water_status(300)
      assert_equal "Steam", result
    end
    test "return Liquid for 70 degress" do
      result = @instance.get_water_status(70)
      assert_equal "Liquid", result
    end
    test "return Ice for -5 degress" do
      result = @instance.get_water_status(-5)
      assert_equal "Ice", result
    end
  end
end

Execution time: 0.077004

Custom Testing Framework

This is a custom testing framework built in one line of code. I found it in a blog post by Paul Berry. It is not really for production purposes but it works well, it’s cool and it shows you how powerful Ruby is.

This next piece of code contains both the tests and the testing framework implementation. I surrounded everything with the Benchmark library to get the amount of time it takes to execute the tests:

require "benchmark"
require "WaterHelper.dll"

total_time = Benchmark.measure do
  tests = {
    "is_water_boiled(100)" => true,
    "is_water_boiled(150)" => true,
    "is_water_frozen(0)" => true,
    "is_water_frozen(-50)" => true,
    "get_water_status(300)" => "Steam",
    "get_water_status(70)" => "Liquid",
    "get_water_status(-5)" => "Ice"
  }

  instance = Demo::WaterHelper.new
  
  # The next line goes over all tests and executes them
  tests.each{|e,v| puts((r=eval("instance." + e))==v ? ". #{e}" : "! #{e} was '#{r}', expected '#{v}'")}
end

puts total_time

Execution time: 0.156001 seconds.

Benchmark Conclusion

Benchmarking testing frameworks is not such a good idea. Performance is not something you should care about when you write tests. It is much more important to have a maintainable set of tests instead of fast running ones that need a week of work when a requirement changes.

But, it’s cool and interesting to have charts in blog posts! so, here it is… the comparison between the execution time of all testing frameworks in this post:

It turned out that Contest is the quickest one but except Cucumber and Lemon, the rest of the frameworks are behind only by a small difference.

Interesting facts:

• All frameworks finished the tests under 1 second.
• Test::Unit is more than 2 times faster than RSpec.
• Contest, which is build on top of Test::Unit, actually runs a bit faster (I tried that multiple times!)
• The custom testing framework got a real nice spot in the middle.
• Cucumber is not the quickest one at all but it is still the coolest one :-)

Conclusion

IronRuby opens a whole new world of opportunities for .NET developers and Rubyists. In this post I focused on testing code but of course there is much more to it than just that. However, this showcase gets my point through – this post includes a variety of 11 (!!!) different testing frameworks. Each frameworks has its own uniqueness, making it very easy for you to choose the framework that works best for you.

And just for you to know - I had so much fun writing this post! Ruby is just awesome. Period.

All the best,
Shay.

Share: DZone | RubyFlow | Reddit

Use .NET Built-in Methods to Save Time and Headaches

• Posted by Shay Friedman on January 16, 2010
• 23 comments

During our everyday programming tasks we run into several repetitive code blocks that after the 20th time you implement them become really annoying. The worst case is to re-implement these code blocks every time, and the better case is to create a central class library with helper classes and methods. However, a large amount of these tasks can be achieved easily with built-in .NET methods.

In this post I will go through several repetitive code blocks and show you how to implement them using built-in .NET method. If you want to add your suggestions, comment! I’ll add your suggestions to the post periodically.

Disclaimer: I’m sure some of the code blocks I use in the NOT Recommended sections can be written much better. These code blocks are here just for demonstration purposes.

Code Block #1 – Check string for nullity or emptiness

NOT Recommended

str = "something"
if (str == null || str == String.Empty)
{
	// Oh no! the string isn't valid!
}

Recommended

str = "something"
if (String.IsNullOrEmpty(str))
{
	// Oh no! the string isn't valid!
}

Code Block #2 – Check string for nullity or emptiness (spaces only string is invalid too)

NOT Recommended

str = "something"
if (str == null || str.Trim() == String.Empty)
{
	// Oh no! the string isn't valid!
}

Recommended (C# 4.0 Only)

str = "something"
if (String.IsNullOrWhiteSpace(str))
{
	// Oh no! the string isn't valid!
}

Code Block #3 – Copy an Array

NOT Recommended

string[] source = new string[] { "a", "b", "c" };
string[] dest = new string[3];
for (int i=0; i < source.Length; i++)
{
	dest[i] = source[i];
}

Recommended

string[] source = new string[] { "a", "b", "c" };
string[] dest = new string[3];
Array.Copy(surce, dest, source.Length);

Code Block #4 – Check if a char is a digit

NOT Recommended

char c = '1';
if (c == '1' || c == '2' || c == '3' ||
	c == '4' || c == '5' || c == '6' ||
	c == '7' || c == '8' || c == '9' ||
	c == '0')
{
	// It's a digit!
}

Recommended

char c = '1';
if (Char.IsDigit(c))
{
	// It's a digit!
}

Code Block #5 – Combine Paths

NOT Recommended

string folder = @"C:\MyDir";
string file = "MyFile.docx";
// Combine to make a path
string path = folder + @"\" + file;

Recommended

string folder = @"C:\MyDir";
string file = "MyFile.docx";
// Combine
string path = System.IO.Path.Combine(folder, file);

Code Block #6 – Get file extension out of a file path

NOT Recommended

string path = @"C:\MyDir\MyFile.docx";
string extension = path.Substring(path.LastIndexOf("."));

Recommended

string path = @"C:\MyDir\MyFile.docx";
string extension = System.IO.Path.GetExtension(path);

Code Block #7 – Get MyDocuments Path

NOT Recommended

// Probably some nasty stuff here

Recommended

Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);

Code Block #8 – Check if object is of a specific type

NOT Recommended

object obj = "str";
if (obj.GetType() == typeof(String))
{
	// It's a string!
}

Recommended

object obj = "str";
if (obj is String)
{
	// It's a string!
}

As Adrian Aisemberg has pointed out, these samples are not entirely the same. The is keyword will return true also if obj is of a derivative type of String (in this sample).

Code Block #9 – Set default enum value

NOT Recommended

public class MyClass
{
	private enum Sample 
	{
		A,
		B,
		C
	}
	static Sample s = Sample.B; // Set default value explicitly
	public static void Run()
	{	
		Console.WriteLine(s); // Prints B
	}
}

Recommended

public class MyClass
{
	private enum Sample 
	{
		A,
		B = 0, // Make B the default value
		C
	}
	static Sample s; // Default value will be used
	public static void Run()
	{	
		Console.WriteLine(s); // Prints B
	}
}

Code Block #10 – Check if a string starts with another string

NOT Recommended

string str = "Hello World";
if (str.Substring(0, 5) == "Hello")
{
	// String starts with Hello!			
}

Recommended

string str = "Hello World";
if (str.StartsWith("Hello"))
{
	// String starts with Hello!		
}

Code Block #11 – Convert list of items of one type to a list of items of a different type

NOT Recommended

List<int> list = new List<int>(new[] { 1, 2, 3, 4, 5 });
List<string> convertedList = new List<string>();
foreach (int item in list)
{
	convertedList.Add(item.ToString());
}

Recommended

List<int> list = new List<int>(new[] { 1, 2, 3, 4, 5 });
List<string> convertedList = list.ConvertAll<string>(Convert.ToString);

Code Block #12 – Check if a string contains a number and get the number

NOT Recommended

string str = "4";

int num = 0;
bool success = false;
try 
{
	num = Convert.ToInt32(str);
	success = true;
}
catch
{
	success = false;
}

if (success)
{
	// Do something with the number
}

Recommended

string str = "4";

int num = 0;
if (Int32.TryParse(str, out num))
{
	// Do something with the number
}

Code Block #13 – Writing a string to a file (courtesy of Yaron Naveh)

NOT Recommended

const string str = "put me in a file";
const string file = @"c:\logs\file.txt";

var fs = new FileStream(file, FileMode.Create);          
var sw = new StreamWriter(fs);
sw.Write(str);

sw.Close();
fs.Close();

Recommended

const string str = "put me in a file";
const string file = @"c:\logs\file.txt";

File.WriteAllText(file, str);

Code Block #14 – Pick value if not null and a different on if it is (courtesy of Abhishek)

NOT Recommended

string input = "sdfds";
string result = null;
if (input == null)
{
	result = "Input is null!";
}
else
{
	result = input;
}

Recommended

string input = "sdfds";
string result = input ?? "Input is null!";

This is it for now. If you have more, comment and I’ll add your suggestions to the list (with credits).

All the best,
Shay.

Is String.IsNullOrEmpty Good or Bad?

• Posted by Shay Friedman on October 29, 2009
• 7 comments

I started to wonder about that when I was looking for an equivalent method in Ruby. Apparently, Ruby doesn’t come with such a method built-in, but you can add it very easily by using Ruyb’s monkey patching abilities.

This is odd, because Ruby is the greatest language and has everything you possibly need (and IronRuby is even better! :) ). So why isn’t there an IsNullOrEmpty-like method? Well, they might just didn’t think it was important enough. And there might be a different answer, maybe the decision has other reasons below the surface.

Several developers have discussed the String.IsNullOrEmpty issue over the years. Some say it’s good, some say it’s bad and some even say it’s hazardous to your code (because of a bug it has).

For me, I go with Ruby’s approach (unless they didn’t add it because of time constraints). Most of the time there will be a big difference between a null string object and an empty string object. Therefore, I think that String.IsNullOrEmpty() should be avoided as much as possible and the application should have a convention of how uninitialized strings should look like – nulls or String.Empty. 

For example, say you need to validate some input and String.Empty is sent to you. How do you know if the string is an uninitialized string or a real input? saying that null is the convention would have solved this confusion.

I know there are cases where you have to use IsNullOrEmpty. For example, when using 3rd party components that you are not aware of their uninitialized string convention (if such exists…). This is why I don’t rule out IsNullOrEmpty entirely. I do say that wherever you can, do not use it and prefer str == null to spot uninitialized strings.

By the way, deciding that only null is the convention for uninitialized strings can also improve your application performance since str == null is faster than String.IsNullOrEmpty(str) in about 35%. However, you’ll notice an improvement only if you’re doing billions of String.IsNullOrEmpty calls, so don’t panic right away.

In conclusion, String.IsNullOrEmpty is there for convenience reasons.  Sometimes with convenience comes tranquility, so make use of it wisely!

Just a final addition, Ruby on Rails adds a blank? method to Ruby which provides the equivalent to String.IsNullOrEmpty method in C#. So, if Ruby does not contain everything you need, Ruby on Rails surely does! :)

So what do you think, IsNullOrEmpty is good or bad for your application?

All the best,
Shay.

C# Recorder using IronRuby

• Posted by Shay Friedman on October 26, 2009
• 19 comments

[This post is the second in my series of IronRuby samples. Read the first one here]

The release of Visual Studio 2010 Beta 2 and IronRuby .Net 4.0 Beta 2 CTP has brought some AMAZING abilities to the .Net world like the dynamic keyword. This keyword is a revolutionary little thing. It takes everything you know about C# and throws it away – explicit types, locating syntax errors in compilation time, compiled code…

Sounds bad? well, it is just AWESOME!!! The dynamic keyword brings so much goodness to our beloved C# language, that if it was possible I would have hugged it and asked it to join my family.

Well, enough with the nonsense, let’s get down to business. IronRuby is Microsoft’s implementation of the Ruby language. It runs on top of the DLR and provides a seamless integration with .Net code. In short, it ROCKZZZZZ. This post is about IronRuby’s seamless integration with .Net and the ability to use the great power of Ruby inside C#.

The Ruby language has some very powerful metaprogramming abilities. One of those is the method_missing method. When you declare it in your class, every call to a method that doesn’t exist will be routed to it. You can then do whatever you want with the call – execute a different method, raise an exception, interpret the call somehow or just do whatever you want (jump in the air? do your little Irish dance thing?).

Another nice metaprogramming feature is the ability to send requests to objects by using the send method. The concept is very similar to C#’s reflection method – Invoke.

Now if we combine method_missing and send, we can create a class that saves calls and playbacks them upon request. I will call it… tam tam tam… Recorder:

class Recorder
  # Initialize an array that will save the calls
  def initialize
    @calls = []
  end
   
  # Save the calls to method_missing	
  def method_missing(name, *args, &block)
    @calls << [name, args, block]
  end

  # Playback the calls on a given object	
  def playback(obj)
    @calls.each do |name, args, block|
      obj.send name, *args, &block
    end
  end
end

I think this code is pretty straight forward, no special things here. With this class defined, we can record Ruby calls and playback them on Ruby objects:

# Record calls
rec = Recorder.new
rec.reverse!
rec.insert 2, "ABAB"
rec.delete! "A"

# Playback them on a real object
str = "Hello World"
rec.playback(str)
puts str # Prints "dlBBroW olleH" 

It is AWESOME, but the great thing about it is that with .Net 4.0 and the dynamic keyword, it is available in C# too!

To try the next code by yourself, first open Visual Studio 2010 Beta 2, create a new C# console application and add references to IronRuby.dll, IronRuby.Libraries.dll, Microsoft.Scripting.dll and Microsoft.Dynamic.dll (remember to use the CTP assemblies and not the regular IronRuby assemblies).

The following code loads the Ruby recorder class file (recorder.rb) to the C# environment, creates an instance of the Recorder class, records a few operations and playbacks them on .Net objects:

static void Main(string[] args) 
{      
  // Load the recorder IronRuby file
  var engine = IronRuby.Ruby.CreateEngine();
  engine.ExecuteFile("../../recorder.rb");
  dynamic ruby = engine.Runtime.Globals;

  // Initialize IronRuby's recorder class
  dynamic recorder = ruby.Recorder.@new();

  // Record
  recorder.Add(1);
  recorder.Add(2);

  // Playback on CLR's List object
  List<int> list = new List<int>();
  recorder.playback(list);

  // Print the results!
  foreach (var item in list)
  {
    Console.WriteLine(item);
  }

  // Record console printing
  recorder = ruby.Recorder.@new();
  recorder.Write("IronRuby");
  recorder.WriteLine(" and .Net 4.0");
  recorder.WriteLine("Rock!!!!!!!!!!");

  // Playback on console
  recorder.playback(Console.Out);
}

The output to the console will be:
1
2
IronRuby and .Net 4.0
Rock!!!!!!!!!!

Try it out and see the magic happens right in front of your very own eyes!

In my opinion, this joint venture is incredibly helpful and useful. I predict that as time goes by we will see more and more dynamic language code make its way to the conservative .Net world, enhancing it and adding it powerful abilities that it never has had before.

All the best,
Shay.

Share it:

Visual Studio Tip: Compilation Symbols

• Posted by Shay Friedman on October 15, 2009
• 5 comments

There are times when we need to use different code statements for different build configurations – this means that some code will not exist in assemblies that are built in certain build configurations.

Compilation symbols come to help in this case. You can set a symbol that will exist in  a specific build configuration and then use it inside your code files to write or exclude code when this project is built using this build configuration.

The most familiar case of this scenario is debug and release build configurations. Actually, the debug build configurations comes with a compilation symbol by default named DEBUG. By using it you can write code that will run only when you compile your project in debug mode (show extra message boxes, write more logs, etc.).

Creating Compilation Symbols

1. In Visual Studio, go to Project-> <project name> Properties…
2. The project properties view will open. Click on “Build” on the left.
3. The Build settings will open on the right. The first field there, with the label “Conditional compilation symbols” is the one you need.
4. Add there the name or names (semi-colon separated) of the compilation symbols you want to define. Pay attention that the naming convention for these symbols is all uppercase.
5. Save

You’re done. You can start using the compilation symbols you have just  defined. The next screenshot contains a sample project with two symbols defined – SHAY and FRIEDMAN:

Using Compilation Symbols

In order to use the compilation symbols you have defined, you need to use the special compilation conditions. If these conditions are not met, the code within the condition will not be compiled at all.

The condition starts with #if <condition> and ends with #endif. For example, the next code will be compiled only when SHAY is defined (which is in debug build configuration):

#if SHAY

Console.WriteLine("SHAY is defined! woot!");

#endif

You can also write more complicated conditions like !SHAY for all build configuration without SHAY defined. You can add conditions too – SHAY && FRIEDMAN.

Well, that’s about it!
Hope it helps,
Shay.

The dynamic Keyword Part 2 – IDynamicObject

• Posted by Shay Friedman on January 19, 2009
• 1 comments

This is the second part of my series about the new dynamic keyword in C# 4 (Read the first post here).

As I talked on the first post, the dynamic keyword does the dirty reflection work for you. This is very nice, but it’s like moving forward from a desktop computer to a 10kg laptop – you get to be more dynamic, but it’s still heavy to move around…

The dynamic keyword holds a greater power inside, and this is what I’m going to talk about today – the IDynamicObject interface.

What is the IDynamicObject interface?

When we declare an object as dynamic and execute actions upon it, we actually use a default IDynamicObject implementation.

The IDynamicObject interface has a few methods, the important ones (for this post) are – Invoke, GetMember and SetMember.
The idea is very simple -

dynamic myObject = GetIDynamicObject();
myObject.SomeProperty = "Hello"; // This calls IDynamicObject.SetMember
Console.WriteLine(myObject.SomeProperty); // This calls IDynamicObject.GetMember
myObject.RunSomething(); // This calls IDynamicObject.Invoke

This means that we can implement our own behavior for the dynamic invocation! let’s see what we can do with that…

What can I do with that?

If we implement our own IDynamicObject, we can ease the pain of various daily operations. For example, we can develop an IDynamicObject that will give us the ability to use un-typed datasets as if they were typed. Another example can be an implementation that will enable us to dot through an xml file, with no need of XmlDocument, xpath and their friends. I’m sure there are tons of other uses that can and will be implemented.

Sample IDynamicObject implementation – Working with un-typed datasets

The first thing we’ll do is to create an extension method to the System.Data.DataSet class:

public static class Extensions
{
    public static dynamic AsDynamic(this DataSet dataSet)
    {
        return new DataSetDynamicCaller(dataSet);
    }
}

When we call DataSet.AsDynamic(), we’ll receive a DataSetDynamicCaller class in return, as a dynamic type object. 

Now what we need to do, is to generate classes that dynamically access the dataset objects. This is a very easy process as you will see in just a moment.

So let’s create the DataSetDynamicCaller class:

public class DataSetDynamicCaller : DynamicObject
{
    DataSet dataset;

    public DataSetDynamicCaller(DataSet dataset)
    {
        this.dataset = dataset;
    }

    public override object GetMember(System.Scripting.Actions.GetMemberAction info)
    {
        return new dataset.Tables[info.Name];
    }
}

This is it… Now to the explanation…

Firstly, I inherit from DynamicObject – this is the basic implementation to the IDynamicObject interface (download link is at the end of the post). As I understand, the DynamicObject class will be a part of the System.Dynamic namespace in C# 4, so you won’t need this file on the final version. I won’t deep dive into this implementation, it’s a subject to another post.

Secondly, The DataSetDynamicCaller class is very simple – we get the untyped dataset in the constructor and save it in a private member. Then, whenever the user asks for a property, we return a DataTable that matches the name of the requested member.
This will give us the ability to call a table directly. For example:

DataSet ds = new DataSet();
ds.Tables.Add("MyTable");

dynamic dynDS = ds.AsDynamic();

DataTable tbl = dynDS.MyTable; // This will work!

It’s as simple as that!

I attach the class I’ve written (the link is at the end of the post). The sample contains two more classes and enables you to use the un-typed dataset even more easily. For instance, calling dynDS.MyTable.GetRow(0).MyColumn will return the value of the MyColumn column from the first row of the MyTable table…

In conclusion, the IDynamicObject interface opens a large amount of possibilities for improving our everyday work in a lot of aspects. It starts from accessing untyped datasets as if they were typed and ends where your imaginations does. This is what they mean when they say dynamic capabilities!

Downloads:
DynamicObject.cs
DynamicDataSet.cs

All the best,
Shay.

The dynamic Keyword Part 1 - Introduction

• Posted by Shay Friedman on December 19, 2008
• 2 comments

Firstly, in order to use the dynamic keyword, you'll have to download the VS2010 VPC image and work there. There is no way currently, to download and install Visual Studio 2010 on your local computer.

Now we're ready to explore the future!

So what is the dynamic keyword?

The dynamic keyword is a new type of variable that will be added to the syntax of C# 4.0. Behind the scenes, the dynamic keyword is declared as an object with an attribute that indicates that this is a "special" object that should be treated dynamically.

The way you declare it is just like any other variable type:

dynamic myDynamicVariable = something;

What is it good for?

This dynamic mechanism is a wonderful thing for a bunch of different things that now we have trouble with. Things like - reflection in different environments, calling dynamic languages, dynamic fluent interfaces and more. All of these will become tremendously easier, using the dynamic keyword.

Example - Reflection using dynamic

Let's say I have a type that I define on one class library, I'll call it TheMysteriousType. This is its code:

namespace Mysterious
{
    public class TheMysteriousType
    {
        public string RevealYourSecrets()
        {
            return "Never!";
        }
    }
}

Now, I'll create another class library with a method that receives a dynamic variable and executes the RevealYourSecrets method:

namespace Revealer
{
    public class Revealer
    {
        public static void RevealSecrets(dynamic obj)
        {
            Console.WriteLine("Reveal you secrets, object! {0}", obj.RevealYourSecrets());
        }
    }
}

And last thing - I'll create a console application that has the above 2 class libraries references. It will contain the following code:

namespace ConsoleApplication2
{
    class Program
    {
        static void Main(string[] args)
        {
            Mysterious.TheMysteriousType myst = new Mysterious.TheMysteriousType();
            Revealer.Revealer.RevealSecrets(myst);
        }
    }
}

The flow of the application goes like this:

1. myst variable is created.
2. Revealer.RevealSecrets gets the myst variable as dynamic.
3. Inside Revealer.RevealSecrets: obj.RevelarYourSecrets() will generate a dynamic invocation of the RevealYourSecrets method. Behind the curtains, this will end up running the traditional reflection code for us.
4. The application ends up writing to the screen: "Reveal your secrets, object! Never!".

This is a sample reflection scenario - the Revealer class does not know the object it receives. In order to invoke the RevealYourSecrets method prior to C# 4, we had to use some complicated reflection code. From C# 4, we'll have the dynamic keyword on our side that will do that for us.

This is great because it saves us time and make our code more readable, eventually making it easier to maintain.

Stay tuned to the next parts!
Happy Holidays!
Shay.