ph-lee

/// <summary>
/// constructor for creating a new user
/// </summary>
/// <param name="str_username">username of the user</param>
 
public User(string str_username)
{
   //check method parameters/arguments for null or empty
 
   if (String.IsNullOrEmpty(str_username))
   {
      //throw an exception since parameters entered are not valid
      throw new ArgumentException("argument str_username was null or empty", "str_username");
   }
 
   this.str_username = str_username;
}
 
/// <summary>
/// absurd method for the purpose of this example
/// creates two users
/// </summary>
 
public static void createBobAndEmpty()
{
   //try and create bob
 
   try
   {
      new User("Bob");
   }
   catch (ArgumentException e)
   {
      //this exception will not be thrown in this case
   }
 
   //try and create empty
 
   try
   {
      new User("");
   }
   catch (ArgumentException e)
   {
      //this exception will be thrown in this case
 
      //e is the variable storing the exception which we can print the exception message, variable of concern
      //in other cases the entire stack trace can be printed for debugging purposes
 
      //in this particular case it would be best to log the error and simply notify the user they can't create a user with empty string as username
   }
   finally
   {
      //this finally block is optional and normally used for garbage collection/closing connections/closing files etc
   }
}

/**
 * constructor for creating a new User object
 *
 * @param str_username the username of the user
 */
 
public User(String str_username)
{
   //check parameter is not null
 
   if(str_username == null)
   {
      throw new NullPointerException("str_username is null");
   }
 
   //check parameter is not an empty string
 
   if(str_username.isEmpty())
   {
      throw new IllegalArgumentException("str_username is empty");
   }
 
   this.str_username = str_username;
}
 
/**
 * absurd method for the purpose of this example
 * creates 2 users
 */
 
public static void createBobAndEmpty()
{
   //try and create the user bob
 
   try
   {
      new User("Bob");
   }
   catch (NullPointerException e)
   {
      //this exception will not be thrown in this case
   }
   catch (IllegalArgumentException e)
   {
      //this exception will not be thrown in this case
   }
 
   //try and create user empty
 
   try
   {
      new User("");
   }
   catch (NullPointerException e)
   {
      //this exception will not be thrown in this case
   }
   catch (IllegalArgumentException e)
   {
      //this exception will be thrown in this case
 
      //e is the variable storing the exception which we can print the exception message, variable of concern
      //in other cases the entire stack trace can be printed for debugging purposes
 
      //in this particular case it would be best to log the error and simply notify the user they can't create a user with empty string as username
   }
   finally
   {
      //this finally block is optional and normally used for garbage collection/closing connections/closing files etc
   }
}

#class constructor for a user
#username represents the username for the new user
 
def initialize(username)
   #check argument username is not an empty string
   raise ArgumentError if username.empty? #keyword "raised" used instead of "throw"
 
   @username = username
end
 
#absurd method for the purpose of this article
#create 2 users
 
def User.create_bob_and_empty
   #try and create user user Bob
 
   begin #this keyword is used instead of "try"
      User.new("Bob")
   rescue ArgumentError => e
      #this rescue clause will not be performed in this example
   else
      #this clause will be performed since none of the above rescue clauses were fired
      #can be used to report success of operations where no exceptions were encountered
   end
 
   #try and create user empty
 
   begin
      User.new("Bob")
   rescue ArgumentError => e
      #this clause will be fired in this case
 
      #the variable e holds the exception that has been raised and can be used to trace exceptions stack
   ensure
      #this clause will be fired in this case
      #this is equivalent to the finally cluse in java or csharp
   end
end

catch(:done) do
   a = 1
   while true
      throw :done if a == 100
      a++
   end
end

class Client < ActiveRecord::Base
   has_many :properties
end

class Property < ActiveRecord::Base
   belongs_to :client
end

class HomeController < ApplicationController
   def my_very_specific_query
      my_client = Client.find(:first, :joins => [:properties], :conditions => {:first_name => "Fred", :properties => {:house_number => 3}})
   end
end