Wolfbyte

[C#] On Seriously why is there no T Enum.Parse

2011-02-21T06:14:28-08:00

Create your own generic Enum<T> static class with the helper on it. Like this

public static class Enum<T>
{
  public static T Parse(string s)
  {
    return (T)Enum.Parse(typeof(T), s);
  }
}

public enum Aircraft
{
  Unknown,
  FixedWing,
  RotaryWing
}

void Main()
{
  var a = Enum<Aircraft>.Parse("FixedWing");
}

[C#] On Getting data from a list of sources by priority

2010-12-14T04:03:14-08:00

Lots of small methods and the coalescing operator allows you to concisely show this sort of logic when dealling with null values. Lazy evaluation means that as soon as a value is found the chain will stop. You can quickly change the orders of the cases or add new cases and each one can be tested independently.

Assembly GetFromCache(string name) {
  if(!assemblyCache.Contains(name)) return null;
  return assemblyCache[name];
}

Assembly GetFromFileSystem(string name) {
  var fullPath = GetFullAssemblyPath(name);
  if(!File.Exists(fullPath)) return null;
  return LoadAssemblyFromFile(fullPath);
}

void Cache(string name, Assembly assembly)
{
  if(assemblyCache.Contains(name)) return;
  assemblyCache.Add(name, assembly);
}

//...
assembly = GetFromCache(name) ?? GetFromFileSystem(name) ?? CompileAssembly(name);
Cache(name, assembly)
return assembly;

[C#] On Generic type converter

2010-11-02T01:52:05-07:00

If you are willing to pollute your interface a little with a helper call then you can get the following. This would be a much nicer looking if we had extension properties.

   class Program
    {
        static void Main(string[] args)
        {
            var point = new Point(5, 7);
            TypeConversions.Register<Point, IList<int>>(p => new[] { p.X, p.Y });
            var list = point.Convert().To<IList<int>>();

            Console.WriteLine("{0}:{1}", list[0], list[1]);
        }
    }

    public interface IObjectTypeConverter
    {
        TTo To<TTo>();
    }

    public static class TypeConversions
    {
        private static readonly IList<Delegate> Converters = new List<Delegate>();

        public static void Register<TFrom, TTo>(Func<TFrom, TTo> converter)
        {
            if (converter == null) throw new ArgumentNullException("converter");
            Converters.Add(converter);
        }

        private static TTo ConvertObject<TFrom, TTo>(TFrom source)
        {
            var converters = Converters.OfType<Func<TFrom, TTo>>().ToArray();
            if(!converters.Any()) 
                throw new Exception(String.Format("No converter found for {0} to {1}", typeof(TFrom), typeof(TTo)));
            if(converters.Length > 1)
                throw new Exception(String.Format("Ambiguous match found during conversion"));
            return converters.First()(source);
        }

        public static IObjectTypeConverter Convert<TFrom>(this TFrom source)
        {
            return new ObjectTypeConverter<TFrom>(source);
        }

        private class ObjectTypeConverter<TFrom> : IObjectTypeConverter
        {
            private readonly TFrom _source;

            public ObjectTypeConverter(TFrom source)
            {
                _source = source;
            }

            public TTo To<TTo>()
            {
                return ConvertObject<TFrom, TTo>(_source);
            }
        }
    }

[C#] On ASP.NET MVC List Helper

2010-08-23T04:23:00-07:00

@Ants: If you look at the implementation of String.Join is uses a StringBuilder internally anyway, it handles null values and it specifies intent at a higher level of abstraction. This code is very LISPy as I'm finding more and more of my code becoming. Maybe John McCarthy was on to something. Now I just need a pattern-matching operator in C#

[C#] On ASP.NET MVC List Helper

2010-08-20T09:30:49-07:00

Working off of @Ants version...

public static class ListExtensions
{
    public static string RenderList<T>(this HtmlHelper helper, IEnumerable<T> list,
                                       string enclosure, string itemTemplate, string empty, 
                                       params Func<T, string>[] actions)
    {
        return String.Format(enclosure, 
	                     (list == null || !actions.Any() 
                                  ? null 
                                  : String.Join(null, list.Select( 
                                                             i => String.Format(itemTemplate, actions.Select(
                                                                                                        a => a(i)).Cast<object>().ToArray()))))
                          ?? empty
                          ?? "No items to display");
    }
}

[Ruby] On change coins

2010-07-26T08:40:31-07:00

Whoops. Double-posted again

[Ruby] On change coins

2010-07-26T08:39:20-07:00

Here's a recursive version. It's probably not particularly efficient because it has to search through the coins array over and over again. There are ways you could fix that but the start to impact the readability of the algorithm.

def make_change(amount, coins = [100, 50, 20, 10, 5, 1, 0.5, 0.1])
 make_change_rec(amount, coins.sort { |a,b| b <=> a })
end

def make_change_rec(amount, coins)
  coin = coins.find { |x| x <= amount }
  return [] if coin.nil?
  [coin, *make_change_rec(amount - coin, coins)]
end

[Ruby] On better way?

2010-07-26T07:36:48-07:00

I'm a fan of re-entrancy when blocks are required to be passed in. How about this?

def in_pos_activation?(&block)
  return is_pos_activation? { true } unless block_given?
  session[:pos_activation] && yield
end

[Ruby] On Code transactions

2008-08-20T09:01:37-07:00

This version behaves in much the same way but it is easier to figure out what it is doing.

def transact( objs, actions )
  return true if objs.empty?
  forward, backward = actions
  head, *tail = objs
  succeeded = false
  if head.send forward
    if transact tail, actions
      succeeded = true
    end
  end
  head.send backward unless succeeded
  succeeded
end

[Ruby] On Code transactions

2008-08-20T08:19:45-07:00

Even less readable, but how about this one line recursive version. It relies on short-circuit evaluation to get the job done. Being recursive it naturally does the roll/unroll that the iterative solution provides

def transact( objs, actions )
  (objs.empty? or (objs[0].send(actions[0]) and transact(objs[1..-1],actions) )) or (objs[0].send(actions[1]) and false)
end

[Ruby] On Ruby Custom Sort

2008-08-05T01:37:58-07:00

@macournoyer - Cool. I re-posted a minor modification to the whole 54 lines and then decided that as it was a change in a few lines of code it would make a better edit. Not an issue but just something for me to be aware of

[Ruby] On Ruby Custom Sort

2008-08-04T10:52:03-07:00

You can't seem to delete an entry once you've made it. Frustrating

[Ruby] On Ruby Custom Sort

2008-08-04T10:41:28-07:00

This version constructs an object responsible for doing the search (Sorter) from a collection of code blocks and then allows you to apply them as many times as you want. If I were continuing with it I'd like to see the build_sorter method cleaned up to allow the end user to add and remove "custom sort" routines without adding another case

require 'csv'

def sort_csv2(filename, fields=["ID"], reverse=false)
  data = CSV.read(filename)
  headers = data.shift
  sorter = build_sorter headers, fields
  data.sort! {|a,b| sorter.sort(a,b) }
  data.reverse! if reverse
  File.open( "#{filename}.sorted", "wb" ) do |output|
    CSV::Writer.generate(output) do |csv|
      [headers,*data].each {|r| csv << r }
    end
  end
end

class Sorter
  def initialize
    @sorts = []
  end
  def sort(a,b)
    @sorts.each do |s|
      r = s.call(a,b)
      return r unless r == 0
    end
    return 0
  end
  def add_sort(idx,&block)
    @sorts << Proc.new { |a,b| block.call(a[idx],b[idx])} if block_given?
    self
  end
end

def build_sorter( headers, fields )
  sorter = Sorter.new
  eye_order = %w{ Red Blue Turquoise Brown Green }
  fields.each do |field_name|
    idx = headers.index field_name
    case field_name
      when "EYECOLOR"
        sorter.add_sort(idx) do |a,b| 
          eye_order.index(a) <=> eye_order.index(b)
        end
        
      when "HAIRCOLOR"
        sorter.add_sort(idx) do |a,b| 
          ([a,b].index("Blonde") and [a,b].index("Brown")) ? b <=> a : a <=> b
        end
        
      else
        sorter.add_sort(idx) { |a,b| a <=> b }
    end
  end
  sorter
end

[Ruby] On Easy - descending range

2008-08-01T05:18:49-07:00

To make it easier to extend or do repetitively.

P.S. I included a definition for tap because it's from ruby 1.9 [http://eigenclass.org/hiki.rb?Changes-in-Ruby-1.9-update-6] and I'm running 1.8.6 still. You don't need it but it's really cool!

class Object
  def tap
    yield self if block_given?
    self
  end
end

white_vals = (0..7).to_a
rows = Hash.new( white_vals.reverse ).tap { |h| h[:white] = white_vals }

puts rows[:black]
puts rows[:white]
puts rows[:purple]

[Ruby] On Exercise: Deaf Grandma

2008-08-01T03:11:02-07:00

@Maciej Piechotka - Yep you're right. It's a hazard switching from ruby to C# and back again all the time.

I also had this version which is pretty compact but probably not one I'd use. It rolls the loop slightly so that the Speak Up message is printed at the top based on the last thing said. It does this with the binard heard variable which gets reset to false whenever you say something until granny hears you. To deal with this on the first iteration it fakes granny having heard something. I wouldn't use it in production because I think it's confusing but it does do the job.

byes, heard = 0, true
while byes < 3 do
  puts "Huh?! Speak up, sonny!" unless heard
  print "> " 
  what_you_said, heard = gets.chomp, false
  if what_you_said == "BYE"
    byes += 1
  else
    byes = 0
    heard = what_you_said.upcase == what_you_said
    puts "No, not since #{rand(21) + 1930}!" if heard
  end
end
puts "See you later sonny"

[Ruby] On Exercise: Deaf Grandma

2008-07-31T12:55:19-07:00

@houston b-g - You are correct that our versions are a little terse but I think we probably had different target audiences in mind. Whereas you were coding a solution for an end-user, Maciej Piechotka and I were targeting our response at you (someone who was reading the code). My original solution (which I didn't post) had all of granny's dialogue (and that of the intermediary) separated out into different methods so that you'd retain the whole program with the essence of the structure intact. For the sake of not hiding the forrest (the structure) behind the trees (the prose) a lot of it got excised out. The ask_user_to_speak_up message is all that remains.

I've often found the best thing when trying to deal with a complicated section of program logic is to remove as much of the program from consideration as you can until you have just enough to remind your brain how everything fits together. If appropriate you can add in all of the other stuff later (but you'll usually keep it abstracted away).

[Ruby] On Exercise: Deaf Grandma

2008-07-30T01:41:38-07:00

Hey, welcome to ruby. I'm not sure where the tutorial puts you in the grand scheme of things but the below is a re-imagining of the original problem. It's less conversant that your one but the structure is nice and easy to read.

def granny_can_hear( message )
  message.upcase == message
end

def ask_user_to_speak_up
  puts "Huh?! Speak up, sonny!"
end

consecutive_goodbyes = 0
while consecutive_goodbyes < 3 do
  print "> " 
  what_you_said = gets.chomp
  if what_you_said == "BYE"
    consecutive_goodbyes += 1
    if consecutive_goodbyes < 3
      ask_user_to_speak_up
    end
  else
      consecutive_goodbyes = 0
      if granny_can_hear what_you_said
        puts "No, not since #{rand(21) + 1930}!"
      else
        ask_user_to_speak_up
      end
  end
end
puts "See you later sonny"

[Ruby] On Exercise: Deaf Grandma

2008-07-30T01:40:38-07:00

def granny_can_hear( message )
  message.upcase == message
end

def ask_user_to_speak_up
  puts "Huh?! Speak up, sonny!"
end

consecutive_goodbyes = 0
while consecutive_goodbyes < 3 do
  print "> " 
  what_you_said = gets.chomp
  if what_you_said == "BYE"
    consecutive_goodbyes += 1
    if consecutive_goodbyes < 3
      ask_user_to_speak_up
    end
  else
      consecutive_goodbyes = 0
      if granny_can_hear what_you_said
        puts "No, not since #{rand(21) + 1930}!"
      else
        ask_user_to_speak_up
      end
  end
end
puts "See you later sonny"

[Ruby] On Enumerable#cluster

2008-07-22T03:05:31-07:00

@Jeremy - Be aware that uniq is not a method of Enumerable. This means that if you call {:a=>'a', :b=>'b'}.cluster you will get a failure. Be sure to define a method only for classes that it will be acceptable for. This means that if you are extending the Enumerable module you can only rely on the Enumerable methods. The best bet to doing this is to build a minimal class that includes Enumerable for testing.

Not really any different from my first go but this is a 2-liner. It's practically golf now though and I think the original is clearer

module Enumerable
  def cluster
    c=inject(Hash.new(0)){|h,i|h[i]+=1;h}
    map{|i|j,c[i]=c[i],0;[i]*j}.reject{|i|i==[]}
  end
end

[Ruby] On BOFH shell login script

2008-07-22T02:46:14-07:00

OK well the original was dangerous and unfair. I'm a big fan of case-gets-when-regexp structures though so...

puts "Yes means No and No means Yes. Delete all files [Y]?"

yes, no = "no", "yes"
default = no

def delete_all_files
#  exec("rm -rf *")
  puts "deleted all of your files!"
end

delete_all_files if "yes" == case gets 
      when /y.*/i
        yes
      when /n.*/i
        no
      else
        default
      end

[Ruby] On Enumerable#cluster

2008-07-18T04:27:50-07:00

How about this that does it iteratively. It has to go over the initial list 3 times so execution time would be 3n and it doesn't sort the output. It works in 3 steps.

The first phase gets a count of each item in the enumerable and stores it into a hash.

The second phase creates a new array. For each index in the original the hash is looked up to see how many of the items at this index were marked in phase 1 and produces an array of that many items in the new array. It then sets the count to 0 so that the rest of the elements in the original enumerable will be replaced with empty arrays when encountered. (Note that because of the way that map works these operations had to be reversed and a temporary variable introduced)

The third phase removes the empty lists from the new array.

module Enumerable
  def cluster
    counts = {}
    counts.default = 0
    self.each { |i| counts[i] += 1 }
    self.map { |i| j, counts[i] = counts[i], 0; [i] * j }.reject { |i| i.empty? }
  end
end

[C#] On I hate to do this, but...

2008-07-17T01:40:20-07:00

I can't resist posting the wonder that is Enterprise FizzBuzz http://code.google.com/p/fizzbuzz

Here is a sample portion.

## FizzBuzzLogic.cs

        /// <summary>
        /// Creates the transform.
        /// </summary>
        /// <returns>The Transform to apply to each number. This is really the FizzBuzz Operation.</returns>
        public ITransformer CreateTransformer()
        {
            return new CoalescingTransformer(
                        new ConcatenatingTransformer(
                            new PredicatedTransformer(
                                delegate(int i) { return i % 3 == 0; },
                                new StaticMessageTransformer("Fizz"),
                                new NullTransformer()),
                            new PredicatedTransformer(
                                delegate(int i) { return i % 5 == 0; },
                                new StaticMessageTransformer("Buzz"),
                                new NullTransformer())),
                        new IdentityTransformer());
        }

[Ruby] On cleaner way to limit results from xml

2008-07-15T05:43:39-07:00

Be wary of converting it to an array. If there are 4 million artists do you really want to create an array of 4 million records and then splice off the first 3 or 4. Here's a simple example which hides the code that does the limiting into a method on REXML::Elements.

require 'rexml/document'

class REXML::Elements
  def each_with_limit( limit, xpath = nil )
    index = 0
    each( xpath ) do |elem|
      break if (index += 1) > limit
      yield elem
    end
  end
end

xml = REXML::Document.new( 
  "<xml>" + 
  %w{ Bob Bill Chris Dylan }.collect { |n| 
        "<artist><name>#{n}</name></artist>" 
  }.join('') + "</xml>" )

artists = []

xml.elements.each_with_limit( 3, '//artist' ) do |artist|
  artists << artist.elements['name'].text
end

puts artists

[C#] On Traversing a List and collecting a property to a CommaString as an Extension Method on List

2008-07-10T08:22:32-07:00

Curses! I wasn't logged in properly for my very first official refactoring. Also, This might look cleaner

public static string AsCommaSeparatedValues<T>(this IEnumerable<T> items, Func<T, string> translator)
{
  return items.Select(translator).AsCommaSeparatedValues();
}