Comments on: The Power of Enum http://elegantcode.com/2010/05/08/the-power-of-enum/?utm_source=rss&utm_medium=rss&utm_campaign=the-power-of-enum Tue, 08 May 2012 09:13:00 +0000 hourly 1 http://wordpress.org/?v=3.3.1 By: Wilian http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-63767 Wilian Sun, 03 Apr 2011 22:57:00 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-63767 very nice and helpful very nice and helpful

]]> By: Joep Lijnen http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-63762 Joep Lijnen Sat, 02 Apr 2011 22:10:00 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-63762 I also like how the switch-snippet in Visual Studio will automatically fill in all enumeration fields when you use it; e.g. switch-[TAB]-[TAB] fruits [TAB] [ENTER] I also like how the switch-snippet in Visual Studio will automatically fill in all enumeration fields when you use it; e.g. switch-[TAB]-[TAB] fruits [TAB] [ENTER]

]]> By: Elegant Code » Enforce Correct Usage By Wrapping Types http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-58092 Elegant Code » Enforce Correct Usage By Wrapping Types Sun, 11 Jul 2010 22:40:59 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-58092 [...] are achieving the same kind of valuable input constrictions that we have been able to achieve with enumerations, except we are adding more complex restrictions than a simple list of [...] [...] are achieving the same kind of valuable input constrictions that we have been able to achieve with enumerations, except we are adding more complex restrictions than a simple list of [...]

]]> By: Jeff http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-57254 Jeff Tue, 18 May 2010 18:22:24 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-57254 I like enums as replacements for magic numbers, per Raymond Chen at the Old New Thing. Using ints, bools, and other basic types as function parameters is bad since you can't tell from the source code line what the values are SEMANTICALLY. Enumeration values provide a way to document what was meant, not just pass a value. I like enums as replacements for magic numbers, per Raymond Chen at the Old New Thing. Using ints, bools, and other basic types as function parameters is bad since you can’t tell from the source code line what the values are SEMANTICALLY. Enumeration values provide a way to document what was meant, not just pass a value.

]]> By: Derek Fowler http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-57041 Derek Fowler Wed, 12 May 2010 12:27:34 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-57041 Ha, just realised there was a previous page of comments and that stuff had already been covered...doh! Ha, just realised there was a previous page of comments and that stuff had already been covered…doh!

]]> By: Derek Fowler http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-57040 Derek Fowler Wed, 12 May 2010 12:24:54 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-57040 First off, enumerations don't constrain your set of choices e.g. if your Fruits enum "inherits from" the default of int you can pass this in to your method no problem: (Fruits)123456. Similarly Enum.Parse() will also accept "123456" as a valid value for Fruits. Enumerations simply allow you to give some of the values of, in this case, int a special meaning. It depends on how the values are getting into your system as to whether you'd ever need to worry about these unspecified values but it's something you should be aware of. Secondly, I think the best solution to you first example is what Abinesh was getting at i.e. a more OO solution where you have an abstract Fruit class with an abstract Eat() method with Apple, Banana etc classes inheriting from it and implementing the Eat() method. First off, enumerations don’t constrain your set of choices e.g. if your Fruits enum “inherits from” the default of int you can pass this in to your method no problem: (Fruits)123456. Similarly Enum.Parse() will also accept “123456″ as a valid value for Fruits. Enumerations simply allow you to give some of the values of, in this case, int a special meaning. It depends on how the values are getting into your system as to whether you’d ever need to worry about these unspecified values but it’s something you should be aware of.

Secondly, I think the best solution to you first example is what Abinesh was getting at i.e. a more OO solution where you have an abstract Fruit class with an abstract Eat() method with Apple, Banana etc classes inheriting from it and implementing the Eat() method.

]]> By: Abinesh http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-57033 Abinesh Tue, 11 May 2010 17:31:16 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-57033 <a href="#comment-57032" rel="nofollow">@Abinesh</a> Typo in eat method public void eat(Fruit fruit){ fruit.print();// no dirty switch case } @Abinesh

Typo in eat method
public void eat(Fruit fruit){
fruit.print();// no dirty switch case
}

]]> By: Abinesh http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-57032 Abinesh Tue, 11 May 2010 17:28:38 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-57032 How about this??? public enum Fruit{ APPLE{ public void print(){System.out.println("i am apple");} }, ORANGE{ public void print(){System.out.println("i am orange");} },MANGO{ public void print(){System.out.println("i am mango");}}; public abstract void print(); } your eat() can now become public void eat(Fruit fruit) { fruit.eat();// no dirty switch case } This is in java.I hope kind of enum is possible in C#. How about this???

public enum Fruit{
APPLE{
public void print(){System.out.println(“i am apple”);}
},
ORANGE{
public void print(){System.out.println(“i am orange”);}
},MANGO{
public void print(){System.out.println(“i am mango”);}};
public abstract void print();
}

your eat() can now become

public void eat(Fruit fruit)
{
fruit.eat();// no dirty switch case
}

This is in java.I hope kind of enum is possible in C#.

]]> By: John Sonmez http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-57024 John Sonmez Tue, 11 May 2010 02:23:31 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-57024 <a href="#comment-57023" rel="nofollow">@Adil Ahmad</a> Sure, if we were doing this for a real application, we might have IFruit, and have an Apple, Orange etc class which all implemented a method Eat which had the different behavior. Of course, we should not automatically jump to that pattern to solve this problem, because the solution maybe much simpler and be easily solved with a dictionary that maps the type of fruit to the message. The point of this example was not to solve the problem of making the code as clean as possible, but to point out the use of an enum to improve that code as is. Perhaps I should have used a different example though. @Adil Ahmad
Sure, if we were doing this for a real application, we might have IFruit, and have an Apple, Orange etc class which all implemented a method Eat which had the different behavior.

Of course, we should not automatically jump to that pattern to solve this problem, because the solution maybe much simpler and be easily solved with a dictionary that maps the type of fruit to the message.

The point of this example was not to solve the problem of making the code as clean as possible, but to point out the use of an enum to improve that code as is. Perhaps I should have used a different example though.

]]> By: Adil Ahmad http://elegantcode.com/2010/05/08/the-power-of-enum/?utm_source=rss&utm_medium=rss&utm_campaign=the-power-of-enum Tue, 08 May 2012 09:13:00 +0000 hourly 1 http://wordpress.org/?v=3.3.1 Comments on: The Power of Enum http://elegantcode.com/2010/05/08/the-power-of-enum/?utm_source=rss&utm_medium=rss&utm_campaign=the-power-of-enum Tue, 08 May 2012 09:13:00 +0000 hourly 1 http://wordpress.org/?v=3.3.1 By: Wilian http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-63767 Wilian Sun, 03 Apr 2011 22:57:00 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-63767 very nice and helpful very nice and helpful

]]> By: Joep Lijnen http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-63762 Joep Lijnen Sat, 02 Apr 2011 22:10:00 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-63762 I also like how the switch-snippet in Visual Studio will automatically fill in all enumeration fields when you use it; e.g. switch-[TAB]-[TAB] fruits [TAB] [ENTER] I also like how the switch-snippet in Visual Studio will automatically fill in all enumeration fields when you use it; e.g. switch-[TAB]-[TAB] fruits [TAB] [ENTER]

]]> By: Elegant Code » Enforce Correct Usage By Wrapping Types http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-58092 Elegant Code » Enforce Correct Usage By Wrapping Types Sun, 11 Jul 2010 22:40:59 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-58092 [...] are achieving the same kind of valuable input constrictions that we have been able to achieve with enumerations, except we are adding more complex restrictions than a simple list of [...] [...] are achieving the same kind of valuable input constrictions that we have been able to achieve with enumerations, except we are adding more complex restrictions than a simple list of [...]

]]> By: Jeff http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-57254 Jeff Tue, 18 May 2010 18:22:24 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-57254 I like enums as replacements for magic numbers, per Raymond Chen at the Old New Thing. Using ints, bools, and other basic types as function parameters is bad since you can't tell from the source code line what the values are SEMANTICALLY. Enumeration values provide a way to document what was meant, not just pass a value. I like enums as replacements for magic numbers, per Raymond Chen at the Old New Thing. Using ints, bools, and other basic types as function parameters is bad since you can’t tell from the source code line what the values are SEMANTICALLY. Enumeration values provide a way to document what was meant, not just pass a value.

]]> By: Derek Fowler http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-57041 Derek Fowler Wed, 12 May 2010 12:27:34 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-57041 Ha, just realised there was a previous page of comments and that stuff had already been covered...doh! Ha, just realised there was a previous page of comments and that stuff had already been covered…doh!

]]> By: Derek Fowler http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-57040 Derek Fowler Wed, 12 May 2010 12:24:54 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-57040 First off, enumerations don't constrain your set of choices e.g. if your Fruits enum "inherits from" the default of int you can pass this in to your method no problem: (Fruits)123456. Similarly Enum.Parse() will also accept "123456" as a valid value for Fruits. Enumerations simply allow you to give some of the values of, in this case, int a special meaning. It depends on how the values are getting into your system as to whether you'd ever need to worry about these unspecified values but it's something you should be aware of. Secondly, I think the best solution to you first example is what Abinesh was getting at i.e. a more OO solution where you have an abstract Fruit class with an abstract Eat() method with Apple, Banana etc classes inheriting from it and implementing the Eat() method. First off, enumerations don’t constrain your set of choices e.g. if your Fruits enum “inherits from” the default of int you can pass this in to your method no problem: (Fruits)123456. Similarly Enum.Parse() will also accept “123456″ as a valid value for Fruits. Enumerations simply allow you to give some of the values of, in this case, int a special meaning. It depends on how the values are getting into your system as to whether you’d ever need to worry about these unspecified values but it’s something you should be aware of.

Secondly, I think the best solution to you first example is what Abinesh was getting at i.e. a more OO solution where you have an abstract Fruit class with an abstract Eat() method with Apple, Banana etc classes inheriting from it and implementing the Eat() method.

]]> By: Abinesh http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-57033 Abinesh Tue, 11 May 2010 17:31:16 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-57033 <a href="#comment-57032" rel="nofollow">@Abinesh</a> Typo in eat method public void eat(Fruit fruit){ fruit.print();// no dirty switch case } @Abinesh

Typo in eat method
public void eat(Fruit fruit){
fruit.print();// no dirty switch case
}

]]> By: Abinesh http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-57032 Abinesh Tue, 11 May 2010 17:28:38 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-57032 How about this??? public enum Fruit{ APPLE{ public void print(){System.out.println("i am apple");} }, ORANGE{ public void print(){System.out.println("i am orange");} },MANGO{ public void print(){System.out.println("i am mango");}}; public abstract void print(); } your eat() can now become public void eat(Fruit fruit) { fruit.eat();// no dirty switch case } This is in java.I hope kind of enum is possible in C#. How about this???

public enum Fruit{
APPLE{
public void print(){System.out.println(“i am apple”);}
},
ORANGE{
public void print(){System.out.println(“i am orange”);}
},MANGO{
public void print(){System.out.println(“i am mango”);}};
public abstract void print();
}

your eat() can now become

public void eat(Fruit fruit)
{
fruit.eat();// no dirty switch case
}

This is in java.I hope kind of enum is possible in C#.

]]> By: John Sonmez http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-57024 John Sonmez Tue, 11 May 2010 02:23:31 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-57024 <a href="#comment-57023" rel="nofollow">@Adil Ahmad</a> Sure, if we were doing this for a real application, we might have IFruit, and have an Apple, Orange etc class which all implemented a method Eat which had the different behavior. Of course, we should not automatically jump to that pattern to solve this problem, because the solution maybe much simpler and be easily solved with a dictionary that maps the type of fruit to the message. The point of this example was not to solve the problem of making the code as clean as possible, but to point out the use of an enum to improve that code as is. Perhaps I should have used a different example though. @Adil Ahmad
Sure, if we were doing this for a real application, we might have IFruit, and have an Apple, Orange etc class which all implemented a method Eat which had the different behavior.

Of course, we should not automatically jump to that pattern to solve this problem, because the solution maybe much simpler and be easily solved with a dictionary that maps the type of fruit to the message.

The point of this example was not to solve the problem of making the code as clean as possible, but to point out the use of an enum to improve that code as is. Perhaps I should have used a different example though.

]]> By: Adil Ahmad http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-63767 Wilian Sun, 03 Apr 2011 22:57:00 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-63767 very nice and helpful very nice and helpful

]]> Comments on: The Power of Enum http://elegantcode.com/2010/05/08/the-power-of-enum/?utm_source=rss&utm_medium=rss&utm_campaign=the-power-of-enum Tue, 08 May 2012 09:13:00 +0000 hourly 1 http://wordpress.org/?v=3.3.1 By: Wilian http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-63767 Wilian Sun, 03 Apr 2011 22:57:00 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-63767 very nice and helpful very nice and helpful

]]> By: Joep Lijnen http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-63762 Joep Lijnen Sat, 02 Apr 2011 22:10:00 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-63762 I also like how the switch-snippet in Visual Studio will automatically fill in all enumeration fields when you use it; e.g. switch-[TAB]-[TAB] fruits [TAB] [ENTER] I also like how the switch-snippet in Visual Studio will automatically fill in all enumeration fields when you use it; e.g. switch-[TAB]-[TAB] fruits [TAB] [ENTER]

]]> By: Elegant Code » Enforce Correct Usage By Wrapping Types http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-58092 Elegant Code » Enforce Correct Usage By Wrapping Types Sun, 11 Jul 2010 22:40:59 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-58092 [...] are achieving the same kind of valuable input constrictions that we have been able to achieve with enumerations, except we are adding more complex restrictions than a simple list of [...] [...] are achieving the same kind of valuable input constrictions that we have been able to achieve with enumerations, except we are adding more complex restrictions than a simple list of [...]

]]> By: Jeff http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-57254 Jeff Tue, 18 May 2010 18:22:24 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-57254 I like enums as replacements for magic numbers, per Raymond Chen at the Old New Thing. Using ints, bools, and other basic types as function parameters is bad since you can't tell from the source code line what the values are SEMANTICALLY. Enumeration values provide a way to document what was meant, not just pass a value. I like enums as replacements for magic numbers, per Raymond Chen at the Old New Thing. Using ints, bools, and other basic types as function parameters is bad since you can’t tell from the source code line what the values are SEMANTICALLY. Enumeration values provide a way to document what was meant, not just pass a value.

]]> By: Derek Fowler http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-57041 Derek Fowler Wed, 12 May 2010 12:27:34 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-57041 Ha, just realised there was a previous page of comments and that stuff had already been covered...doh! Ha, just realised there was a previous page of comments and that stuff had already been covered…doh!

]]> By: Derek Fowler http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-57040 Derek Fowler Wed, 12 May 2010 12:24:54 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-57040 First off, enumerations don't constrain your set of choices e.g. if your Fruits enum "inherits from" the default of int you can pass this in to your method no problem: (Fruits)123456. Similarly Enum.Parse() will also accept "123456" as a valid value for Fruits. Enumerations simply allow you to give some of the values of, in this case, int a special meaning. It depends on how the values are getting into your system as to whether you'd ever need to worry about these unspecified values but it's something you should be aware of. Secondly, I think the best solution to you first example is what Abinesh was getting at i.e. a more OO solution where you have an abstract Fruit class with an abstract Eat() method with Apple, Banana etc classes inheriting from it and implementing the Eat() method. First off, enumerations don’t constrain your set of choices e.g. if your Fruits enum “inherits from” the default of int you can pass this in to your method no problem: (Fruits)123456. Similarly Enum.Parse() will also accept “123456″ as a valid value for Fruits. Enumerations simply allow you to give some of the values of, in this case, int a special meaning. It depends on how the values are getting into your system as to whether you’d ever need to worry about these unspecified values but it’s something you should be aware of.

Secondly, I think the best solution to you first example is what Abinesh was getting at i.e. a more OO solution where you have an abstract Fruit class with an abstract Eat() method with Apple, Banana etc classes inheriting from it and implementing the Eat() method.

]]> By: Abinesh http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-57033 Abinesh Tue, 11 May 2010 17:31:16 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-57033 <a href="#comment-57032" rel="nofollow">@Abinesh</a> Typo in eat method public void eat(Fruit fruit){ fruit.print();// no dirty switch case } @Abinesh

Typo in eat method
public void eat(Fruit fruit){
fruit.print();// no dirty switch case
}

]]> By: Abinesh http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-57032 Abinesh Tue, 11 May 2010 17:28:38 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-57032 How about this??? public enum Fruit{ APPLE{ public void print(){System.out.println("i am apple");} }, ORANGE{ public void print(){System.out.println("i am orange");} },MANGO{ public void print(){System.out.println("i am mango");}}; public abstract void print(); } your eat() can now become public void eat(Fruit fruit) { fruit.eat();// no dirty switch case } This is in java.I hope kind of enum is possible in C#. How about this???

public enum Fruit{
APPLE{
public void print(){System.out.println(“i am apple”);}
},
ORANGE{
public void print(){System.out.println(“i am orange”);}
},MANGO{
public void print(){System.out.println(“i am mango”);}};
public abstract void print();
}

your eat() can now become

public void eat(Fruit fruit)
{
fruit.eat();// no dirty switch case
}

This is in java.I hope kind of enum is possible in C#.

]]> By: John Sonmez http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-57024 John Sonmez Tue, 11 May 2010 02:23:31 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-57024 <a href="#comment-57023" rel="nofollow">@Adil Ahmad</a> Sure, if we were doing this for a real application, we might have IFruit, and have an Apple, Orange etc class which all implemented a method Eat which had the different behavior. Of course, we should not automatically jump to that pattern to solve this problem, because the solution maybe much simpler and be easily solved with a dictionary that maps the type of fruit to the message. The point of this example was not to solve the problem of making the code as clean as possible, but to point out the use of an enum to improve that code as is. Perhaps I should have used a different example though. @Adil Ahmad
Sure, if we were doing this for a real application, we might have IFruit, and have an Apple, Orange etc class which all implemented a method Eat which had the different behavior.

Of course, we should not automatically jump to that pattern to solve this problem, because the solution maybe much simpler and be easily solved with a dictionary that maps the type of fruit to the message.

The point of this example was not to solve the problem of making the code as clean as possible, but to point out the use of an enum to improve that code as is. Perhaps I should have used a different example though.

]]> By: Adil Ahmad http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-63762 Joep Lijnen Sat, 02 Apr 2011 22:10:00 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-63762 I also like how the switch-snippet in Visual Studio will automatically fill in all enumeration fields when you use it; e.g. switch-[TAB]-[TAB] fruits [TAB] [ENTER] I also like how the switch-snippet in Visual Studio will automatically fill in all enumeration fields when you use it; e.g. switch-[TAB]-[TAB] fruits [TAB] [ENTER]

]]> Comments on: The Power of Enum http://elegantcode.com/2010/05/08/the-power-of-enum/?utm_source=rss&utm_medium=rss&utm_campaign=the-power-of-enum Tue, 08 May 2012 09:13:00 +0000 hourly 1 http://wordpress.org/?v=3.3.1 By: Wilian http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-63767 Wilian Sun, 03 Apr 2011 22:57:00 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-63767 very nice and helpful very nice and helpful

]]> By: Joep Lijnen http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-63762 Joep Lijnen Sat, 02 Apr 2011 22:10:00 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-63762 I also like how the switch-snippet in Visual Studio will automatically fill in all enumeration fields when you use it; e.g. switch-[TAB]-[TAB] fruits [TAB] [ENTER] I also like how the switch-snippet in Visual Studio will automatically fill in all enumeration fields when you use it; e.g. switch-[TAB]-[TAB] fruits [TAB] [ENTER]

]]> By: Elegant Code » Enforce Correct Usage By Wrapping Types http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-58092 Elegant Code » Enforce Correct Usage By Wrapping Types Sun, 11 Jul 2010 22:40:59 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-58092 [...] are achieving the same kind of valuable input constrictions that we have been able to achieve with enumerations, except we are adding more complex restrictions than a simple list of [...] [...] are achieving the same kind of valuable input constrictions that we have been able to achieve with enumerations, except we are adding more complex restrictions than a simple list of [...]

]]> By: Jeff http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-57254 Jeff Tue, 18 May 2010 18:22:24 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-57254 I like enums as replacements for magic numbers, per Raymond Chen at the Old New Thing. Using ints, bools, and other basic types as function parameters is bad since you can't tell from the source code line what the values are SEMANTICALLY. Enumeration values provide a way to document what was meant, not just pass a value. I like enums as replacements for magic numbers, per Raymond Chen at the Old New Thing. Using ints, bools, and other basic types as function parameters is bad since you can’t tell from the source code line what the values are SEMANTICALLY. Enumeration values provide a way to document what was meant, not just pass a value.

]]> By: Derek Fowler http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-57041 Derek Fowler Wed, 12 May 2010 12:27:34 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-57041 Ha, just realised there was a previous page of comments and that stuff had already been covered...doh! Ha, just realised there was a previous page of comments and that stuff had already been covered…doh!

]]> By: Derek Fowler http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-57040 Derek Fowler Wed, 12 May 2010 12:24:54 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-57040 First off, enumerations don't constrain your set of choices e.g. if your Fruits enum "inherits from" the default of int you can pass this in to your method no problem: (Fruits)123456. Similarly Enum.Parse() will also accept "123456" as a valid value for Fruits. Enumerations simply allow you to give some of the values of, in this case, int a special meaning. It depends on how the values are getting into your system as to whether you'd ever need to worry about these unspecified values but it's something you should be aware of. Secondly, I think the best solution to you first example is what Abinesh was getting at i.e. a more OO solution where you have an abstract Fruit class with an abstract Eat() method with Apple, Banana etc classes inheriting from it and implementing the Eat() method. First off, enumerations don’t constrain your set of choices e.g. if your Fruits enum “inherits from” the default of int you can pass this in to your method no problem: (Fruits)123456. Similarly Enum.Parse() will also accept “123456″ as a valid value for Fruits. Enumerations simply allow you to give some of the values of, in this case, int a special meaning. It depends on how the values are getting into your system as to whether you’d ever need to worry about these unspecified values but it’s something you should be aware of.

Secondly, I think the best solution to you first example is what Abinesh was getting at i.e. a more OO solution where you have an abstract Fruit class with an abstract Eat() method with Apple, Banana etc classes inheriting from it and implementing the Eat() method.

]]> By: Abinesh http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-57033 Abinesh Tue, 11 May 2010 17:31:16 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-57033 <a href="#comment-57032" rel="nofollow">@Abinesh</a> Typo in eat method public void eat(Fruit fruit){ fruit.print();// no dirty switch case } @Abinesh

Typo in eat method
public void eat(Fruit fruit){
fruit.print();// no dirty switch case
}

]]> By: Abinesh http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-57032 Abinesh Tue, 11 May 2010 17:28:38 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-57032 How about this??? public enum Fruit{ APPLE{ public void print(){System.out.println("i am apple");} }, ORANGE{ public void print(){System.out.println("i am orange");} },MANGO{ public void print(){System.out.println("i am mango");}}; public abstract void print(); } your eat() can now become public void eat(Fruit fruit) { fruit.eat();// no dirty switch case } This is in java.I hope kind of enum is possible in C#. How about this???

public enum Fruit{
APPLE{
public void print(){System.out.println(“i am apple”);}
},
ORANGE{
public void print(){System.out.println(“i am orange”);}
},MANGO{
public void print(){System.out.println(“i am mango”);}};
public abstract void print();
}

your eat() can now become

public void eat(Fruit fruit)
{
fruit.eat();// no dirty switch case
}

This is in java.I hope kind of enum is possible in C#.

]]> By: John Sonmez http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-57024 John Sonmez Tue, 11 May 2010 02:23:31 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-57024 <a href="#comment-57023" rel="nofollow">@Adil Ahmad</a> Sure, if we were doing this for a real application, we might have IFruit, and have an Apple, Orange etc class which all implemented a method Eat which had the different behavior. Of course, we should not automatically jump to that pattern to solve this problem, because the solution maybe much simpler and be easily solved with a dictionary that maps the type of fruit to the message. The point of this example was not to solve the problem of making the code as clean as possible, but to point out the use of an enum to improve that code as is. Perhaps I should have used a different example though. @Adil Ahmad
Sure, if we were doing this for a real application, we might have IFruit, and have an Apple, Orange etc class which all implemented a method Eat which had the different behavior.

Of course, we should not automatically jump to that pattern to solve this problem, because the solution maybe much simpler and be easily solved with a dictionary that maps the type of fruit to the message.

The point of this example was not to solve the problem of making the code as clean as possible, but to point out the use of an enum to improve that code as is. Perhaps I should have used a different example though.

]]> By: Adil Ahmad http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-58092 Elegant Code » Enforce Correct Usage By Wrapping Types Sun, 11 Jul 2010 22:40:59 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-58092 [...] are achieving the same kind of valuable input constrictions that we have been able to achieve with enumerations, except we are adding more complex restrictions than a simple list of [...] [...] are achieving the same kind of valuable input constrictions that we have been able to achieve with enumerations, except we are adding more complex restrictions than a simple list of [...]

]]> Comments on: The Power of Enum http://elegantcode.com/2010/05/08/the-power-of-enum/?utm_source=rss&utm_medium=rss&utm_campaign=the-power-of-enum Tue, 08 May 2012 09:13:00 +0000 hourly 1 http://wordpress.org/?v=3.3.1 By: Wilian http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-63767 Wilian Sun, 03 Apr 2011 22:57:00 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-63767 very nice and helpful very nice and helpful

]]> By: Joep Lijnen http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-63762 Joep Lijnen Sat, 02 Apr 2011 22:10:00 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-63762 I also like how the switch-snippet in Visual Studio will automatically fill in all enumeration fields when you use it; e.g. switch-[TAB]-[TAB] fruits [TAB] [ENTER] I also like how the switch-snippet in Visual Studio will automatically fill in all enumeration fields when you use it; e.g. switch-[TAB]-[TAB] fruits [TAB] [ENTER]

]]> By: Elegant Code » Enforce Correct Usage By Wrapping Types http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-58092 Elegant Code » Enforce Correct Usage By Wrapping Types Sun, 11 Jul 2010 22:40:59 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-58092 [...] are achieving the same kind of valuable input constrictions that we have been able to achieve with enumerations, except we are adding more complex restrictions than a simple list of [...] [...] are achieving the same kind of valuable input constrictions that we have been able to achieve with enumerations, except we are adding more complex restrictions than a simple list of [...]

]]> By: Jeff http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-57254 Jeff Tue, 18 May 2010 18:22:24 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-57254 I like enums as replacements for magic numbers, per Raymond Chen at the Old New Thing. Using ints, bools, and other basic types as function parameters is bad since you can't tell from the source code line what the values are SEMANTICALLY. Enumeration values provide a way to document what was meant, not just pass a value. I like enums as replacements for magic numbers, per Raymond Chen at the Old New Thing. Using ints, bools, and other basic types as function parameters is bad since you can’t tell from the source code line what the values are SEMANTICALLY. Enumeration values provide a way to document what was meant, not just pass a value.

]]> By: Derek Fowler http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-57041 Derek Fowler Wed, 12 May 2010 12:27:34 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-57041 Ha, just realised there was a previous page of comments and that stuff had already been covered...doh! Ha, just realised there was a previous page of comments and that stuff had already been covered…doh!

]]> By: Derek Fowler http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-57040 Derek Fowler Wed, 12 May 2010 12:24:54 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-57040 First off, enumerations don't constrain your set of choices e.g. if your Fruits enum "inherits from" the default of int you can pass this in to your method no problem: (Fruits)123456. Similarly Enum.Parse() will also accept "123456" as a valid value for Fruits. Enumerations simply allow you to give some of the values of, in this case, int a special meaning. It depends on how the values are getting into your system as to whether you'd ever need to worry about these unspecified values but it's something you should be aware of. Secondly, I think the best solution to you first example is what Abinesh was getting at i.e. a more OO solution where you have an abstract Fruit class with an abstract Eat() method with Apple, Banana etc classes inheriting from it and implementing the Eat() method. First off, enumerations don’t constrain your set of choices e.g. if your Fruits enum “inherits from” the default of int you can pass this in to your method no problem: (Fruits)123456. Similarly Enum.Parse() will also accept “123456″ as a valid value for Fruits. Enumerations simply allow you to give some of the values of, in this case, int a special meaning. It depends on how the values are getting into your system as to whether you’d ever need to worry about these unspecified values but it’s something you should be aware of.

Secondly, I think the best solution to you first example is what Abinesh was getting at i.e. a more OO solution where you have an abstract Fruit class with an abstract Eat() method with Apple, Banana etc classes inheriting from it and implementing the Eat() method.

]]> By: Abinesh http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-57033 Abinesh Tue, 11 May 2010 17:31:16 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-57033 <a href="#comment-57032" rel="nofollow">@Abinesh</a> Typo in eat method public void eat(Fruit fruit){ fruit.print();// no dirty switch case } @Abinesh

Typo in eat method
public void eat(Fruit fruit){
fruit.print();// no dirty switch case
}

]]> By: Abinesh http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-57032 Abinesh Tue, 11 May 2010 17:28:38 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-57032 How about this??? public enum Fruit{ APPLE{ public void print(){System.out.println("i am apple");} }, ORANGE{ public void print(){System.out.println("i am orange");} },MANGO{ public void print(){System.out.println("i am mango");}}; public abstract void print(); } your eat() can now become public void eat(Fruit fruit) { fruit.eat();// no dirty switch case } This is in java.I hope kind of enum is possible in C#. How about this???

public enum Fruit{
APPLE{
public void print(){System.out.println(“i am apple”);}
},
ORANGE{
public void print(){System.out.println(“i am orange”);}
},MANGO{
public void print(){System.out.println(“i am mango”);}};
public abstract void print();
}

your eat() can now become

public void eat(Fruit fruit)
{
fruit.eat();// no dirty switch case
}

This is in java.I hope kind of enum is possible in C#.

]]> By: John Sonmez http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-57024 John Sonmez Tue, 11 May 2010 02:23:31 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-57024 <a href="#comment-57023" rel="nofollow">@Adil Ahmad</a> Sure, if we were doing this for a real application, we might have IFruit, and have an Apple, Orange etc class which all implemented a method Eat which had the different behavior. Of course, we should not automatically jump to that pattern to solve this problem, because the solution maybe much simpler and be easily solved with a dictionary that maps the type of fruit to the message. The point of this example was not to solve the problem of making the code as clean as possible, but to point out the use of an enum to improve that code as is. Perhaps I should have used a different example though. @Adil Ahmad
Sure, if we were doing this for a real application, we might have IFruit, and have an Apple, Orange etc class which all implemented a method Eat which had the different behavior.

Of course, we should not automatically jump to that pattern to solve this problem, because the solution maybe much simpler and be easily solved with a dictionary that maps the type of fruit to the message.

The point of this example was not to solve the problem of making the code as clean as possible, but to point out the use of an enum to improve that code as is. Perhaps I should have used a different example though.

]]> By: Adil Ahmad http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-57254 Jeff Tue, 18 May 2010 18:22:24 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-57254 I like enums as replacements for magic numbers, per Raymond Chen at the Old New Thing. Using ints, bools, and other basic types as function parameters is bad since you can't tell from the source code line what the values are SEMANTICALLY. Enumeration values provide a way to document what was meant, not just pass a value. I like enums as replacements for magic numbers, per Raymond Chen at the Old New Thing. Using ints, bools, and other basic types as function parameters is bad since you can’t tell from the source code line what the values are SEMANTICALLY. Enumeration values provide a way to document what was meant, not just pass a value.

]]> Comments on: The Power of Enum http://elegantcode.com/2010/05/08/the-power-of-enum/?utm_source=rss&utm_medium=rss&utm_campaign=the-power-of-enum Tue, 08 May 2012 09:13:00 +0000 hourly 1 http://wordpress.org/?v=3.3.1 By: Wilian http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-63767 Wilian Sun, 03 Apr 2011 22:57:00 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-63767 very nice and helpful very nice and helpful

]]> By: Joep Lijnen http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-63762 Joep Lijnen Sat, 02 Apr 2011 22:10:00 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-63762 I also like how the switch-snippet in Visual Studio will automatically fill in all enumeration fields when you use it; e.g. switch-[TAB]-[TAB] fruits [TAB] [ENTER] I also like how the switch-snippet in Visual Studio will automatically fill in all enumeration fields when you use it; e.g. switch-[TAB]-[TAB] fruits [TAB] [ENTER]

]]> By: Elegant Code » Enforce Correct Usage By Wrapping Types http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-58092 Elegant Code » Enforce Correct Usage By Wrapping Types Sun, 11 Jul 2010 22:40:59 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-58092 [...] are achieving the same kind of valuable input constrictions that we have been able to achieve with enumerations, except we are adding more complex restrictions than a simple list of [...] [...] are achieving the same kind of valuable input constrictions that we have been able to achieve with enumerations, except we are adding more complex restrictions than a simple list of [...]

]]> By: Jeff http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-57254 Jeff Tue, 18 May 2010 18:22:24 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-57254 I like enums as replacements for magic numbers, per Raymond Chen at the Old New Thing. Using ints, bools, and other basic types as function parameters is bad since you can't tell from the source code line what the values are SEMANTICALLY. Enumeration values provide a way to document what was meant, not just pass a value. I like enums as replacements for magic numbers, per Raymond Chen at the Old New Thing. Using ints, bools, and other basic types as function parameters is bad since you can’t tell from the source code line what the values are SEMANTICALLY. Enumeration values provide a way to document what was meant, not just pass a value.

]]> By: Derek Fowler http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-57041 Derek Fowler Wed, 12 May 2010 12:27:34 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-57041 Ha, just realised there was a previous page of comments and that stuff had already been covered...doh! Ha, just realised there was a previous page of comments and that stuff had already been covered…doh!

]]> By: Derek Fowler http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-57040 Derek Fowler Wed, 12 May 2010 12:24:54 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-57040 First off, enumerations don't constrain your set of choices e.g. if your Fruits enum "inherits from" the default of int you can pass this in to your method no problem: (Fruits)123456. Similarly Enum.Parse() will also accept "123456" as a valid value for Fruits. Enumerations simply allow you to give some of the values of, in this case, int a special meaning. It depends on how the values are getting into your system as to whether you'd ever need to worry about these unspecified values but it's something you should be aware of. Secondly, I think the best solution to you first example is what Abinesh was getting at i.e. a more OO solution where you have an abstract Fruit class with an abstract Eat() method with Apple, Banana etc classes inheriting from it and implementing the Eat() method. First off, enumerations don’t constrain your set of choices e.g. if your Fruits enum “inherits from” the default of int you can pass this in to your method no problem: (Fruits)123456. Similarly Enum.Parse() will also accept “123456″ as a valid value for Fruits. Enumerations simply allow you to give some of the values of, in this case, int a special meaning. It depends on how the values are getting into your system as to whether you’d ever need to worry about these unspecified values but it’s something you should be aware of.

Secondly, I think the best solution to you first example is what Abinesh was getting at i.e. a more OO solution where you have an abstract Fruit class with an abstract Eat() method with Apple, Banana etc classes inheriting from it and implementing the Eat() method.

]]> By: Abinesh http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-57033 Abinesh Tue, 11 May 2010 17:31:16 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-57033 <a href="#comment-57032" rel="nofollow">@Abinesh</a> Typo in eat method public void eat(Fruit fruit){ fruit.print();// no dirty switch case } @Abinesh

Typo in eat method
public void eat(Fruit fruit){
fruit.print();// no dirty switch case
}

]]> By: Abinesh http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-57032 Abinesh Tue, 11 May 2010 17:28:38 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-57032 How about this??? public enum Fruit{ APPLE{ public void print(){System.out.println("i am apple");} }, ORANGE{ public void print(){System.out.println("i am orange");} },MANGO{ public void print(){System.out.println("i am mango");}}; public abstract void print(); } your eat() can now become public void eat(Fruit fruit) { fruit.eat();// no dirty switch case } This is in java.I hope kind of enum is possible in C#. How about this???

public enum Fruit{
APPLE{
public void print(){System.out.println(“i am apple”);}
},
ORANGE{
public void print(){System.out.println(“i am orange”);}
},MANGO{
public void print(){System.out.println(“i am mango”);}};
public abstract void print();
}

your eat() can now become

public void eat(Fruit fruit)
{
fruit.eat();// no dirty switch case
}

This is in java.I hope kind of enum is possible in C#.

]]> By: John Sonmez http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-57024 John Sonmez Tue, 11 May 2010 02:23:31 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-57024 <a href="#comment-57023" rel="nofollow">@Adil Ahmad</a> Sure, if we were doing this for a real application, we might have IFruit, and have an Apple, Orange etc class which all implemented a method Eat which had the different behavior. Of course, we should not automatically jump to that pattern to solve this problem, because the solution maybe much simpler and be easily solved with a dictionary that maps the type of fruit to the message. The point of this example was not to solve the problem of making the code as clean as possible, but to point out the use of an enum to improve that code as is. Perhaps I should have used a different example though. @Adil Ahmad
Sure, if we were doing this for a real application, we might have IFruit, and have an Apple, Orange etc class which all implemented a method Eat which had the different behavior.

Of course, we should not automatically jump to that pattern to solve this problem, because the solution maybe much simpler and be easily solved with a dictionary that maps the type of fruit to the message.

The point of this example was not to solve the problem of making the code as clean as possible, but to point out the use of an enum to improve that code as is. Perhaps I should have used a different example though.

]]> By: Adil Ahmad http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-57041 Derek Fowler Wed, 12 May 2010 12:27:34 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-57041 Ha, just realised there was a previous page of comments and that stuff had already been covered...doh! Ha, just realised there was a previous page of comments and that stuff had already been covered…doh!

]]> Comments on: The Power of Enum http://elegantcode.com/2010/05/08/the-power-of-enum/?utm_source=rss&utm_medium=rss&utm_campaign=the-power-of-enum Tue, 08 May 2012 09:13:00 +0000 hourly 1 http://wordpress.org/?v=3.3.1 By: Wilian http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-63767 Wilian Sun, 03 Apr 2011 22:57:00 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-63767 very nice and helpful very nice and helpful

]]> By: Joep Lijnen http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-63762 Joep Lijnen Sat, 02 Apr 2011 22:10:00 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-63762 I also like how the switch-snippet in Visual Studio will automatically fill in all enumeration fields when you use it; e.g. switch-[TAB]-[TAB] fruits [TAB] [ENTER] I also like how the switch-snippet in Visual Studio will automatically fill in all enumeration fields when you use it; e.g. switch-[TAB]-[TAB] fruits [TAB] [ENTER]

]]> By: Elegant Code » Enforce Correct Usage By Wrapping Types http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-58092 Elegant Code » Enforce Correct Usage By Wrapping Types Sun, 11 Jul 2010 22:40:59 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-58092 [...] are achieving the same kind of valuable input constrictions that we have been able to achieve with enumerations, except we are adding more complex restrictions than a simple list of [...] [...] are achieving the same kind of valuable input constrictions that we have been able to achieve with enumerations, except we are adding more complex restrictions than a simple list of [...]

]]> By: Jeff http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-57254 Jeff Tue, 18 May 2010 18:22:24 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-57254 I like enums as replacements for magic numbers, per Raymond Chen at the Old New Thing. Using ints, bools, and other basic types as function parameters is bad since you can't tell from the source code line what the values are SEMANTICALLY. Enumeration values provide a way to document what was meant, not just pass a value. I like enums as replacements for magic numbers, per Raymond Chen at the Old New Thing. Using ints, bools, and other basic types as function parameters is bad since you can’t tell from the source code line what the values are SEMANTICALLY. Enumeration values provide a way to document what was meant, not just pass a value.

]]> By: Derek Fowler http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-57041 Derek Fowler Wed, 12 May 2010 12:27:34 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-57041 Ha, just realised there was a previous page of comments and that stuff had already been covered...doh! Ha, just realised there was a previous page of comments and that stuff had already been covered…doh!

]]> By: Derek Fowler http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-57040 Derek Fowler Wed, 12 May 2010 12:24:54 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-57040 First off, enumerations don't constrain your set of choices e.g. if your Fruits enum "inherits from" the default of int you can pass this in to your method no problem: (Fruits)123456. Similarly Enum.Parse() will also accept "123456" as a valid value for Fruits. Enumerations simply allow you to give some of the values of, in this case, int a special meaning. It depends on how the values are getting into your system as to whether you'd ever need to worry about these unspecified values but it's something you should be aware of. Secondly, I think the best solution to you first example is what Abinesh was getting at i.e. a more OO solution where you have an abstract Fruit class with an abstract Eat() method with Apple, Banana etc classes inheriting from it and implementing the Eat() method. First off, enumerations don’t constrain your set of choices e.g. if your Fruits enum “inherits from” the default of int you can pass this in to your method no problem: (Fruits)123456. Similarly Enum.Parse() will also accept “123456″ as a valid value for Fruits. Enumerations simply allow you to give some of the values of, in this case, int a special meaning. It depends on how the values are getting into your system as to whether you’d ever need to worry about these unspecified values but it’s something you should be aware of.

Secondly, I think the best solution to you first example is what Abinesh was getting at i.e. a more OO solution where you have an abstract Fruit class with an abstract Eat() method with Apple, Banana etc classes inheriting from it and implementing the Eat() method.

]]> By: Abinesh http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-57033 Abinesh Tue, 11 May 2010 17:31:16 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-57033 <a href="#comment-57032" rel="nofollow">@Abinesh</a> Typo in eat method public void eat(Fruit fruit){ fruit.print();// no dirty switch case } @Abinesh

Typo in eat method
public void eat(Fruit fruit){
fruit.print();// no dirty switch case
}

]]> By: Abinesh http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-57032 Abinesh Tue, 11 May 2010 17:28:38 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-57032 How about this??? public enum Fruit{ APPLE{ public void print(){System.out.println("i am apple");} }, ORANGE{ public void print(){System.out.println("i am orange");} },MANGO{ public void print(){System.out.println("i am mango");}}; public abstract void print(); } your eat() can now become public void eat(Fruit fruit) { fruit.eat();// no dirty switch case } This is in java.I hope kind of enum is possible in C#. How about this???

public enum Fruit{
APPLE{
public void print(){System.out.println(“i am apple”);}
},
ORANGE{
public void print(){System.out.println(“i am orange”);}
},MANGO{
public void print(){System.out.println(“i am mango”);}};
public abstract void print();
}

your eat() can now become

public void eat(Fruit fruit)
{
fruit.eat();// no dirty switch case
}

This is in java.I hope kind of enum is possible in C#.

]]> By: John Sonmez http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-57024 John Sonmez Tue, 11 May 2010 02:23:31 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-57024 <a href="#comment-57023" rel="nofollow">@Adil Ahmad</a> Sure, if we were doing this for a real application, we might have IFruit, and have an Apple, Orange etc class which all implemented a method Eat which had the different behavior. Of course, we should not automatically jump to that pattern to solve this problem, because the solution maybe much simpler and be easily solved with a dictionary that maps the type of fruit to the message. The point of this example was not to solve the problem of making the code as clean as possible, but to point out the use of an enum to improve that code as is. Perhaps I should have used a different example though. @Adil Ahmad
Sure, if we were doing this for a real application, we might have IFruit, and have an Apple, Orange etc class which all implemented a method Eat which had the different behavior.

Of course, we should not automatically jump to that pattern to solve this problem, because the solution maybe much simpler and be easily solved with a dictionary that maps the type of fruit to the message.

The point of this example was not to solve the problem of making the code as clean as possible, but to point out the use of an enum to improve that code as is. Perhaps I should have used a different example though.

]]> By: Adil Ahmad http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-57040 Derek Fowler Wed, 12 May 2010 12:24:54 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-57040 First off, enumerations don't constrain your set of choices e.g. if your Fruits enum "inherits from" the default of int you can pass this in to your method no problem: (Fruits)123456. Similarly Enum.Parse() will also accept "123456" as a valid value for Fruits. Enumerations simply allow you to give some of the values of, in this case, int a special meaning. It depends on how the values are getting into your system as to whether you'd ever need to worry about these unspecified values but it's something you should be aware of. Secondly, I think the best solution to you first example is what Abinesh was getting at i.e. a more OO solution where you have an abstract Fruit class with an abstract Eat() method with Apple, Banana etc classes inheriting from it and implementing the Eat() method. First off, enumerations don’t constrain your set of choices e.g. if your Fruits enum “inherits from” the default of int you can pass this in to your method no problem: (Fruits)123456. Similarly Enum.Parse() will also accept “123456″ as a valid value for Fruits. Enumerations simply allow you to give some of the values of, in this case, int a special meaning. It depends on how the values are getting into your system as to whether you’d ever need to worry about these unspecified values but it’s something you should be aware of.

Secondly, I think the best solution to you first example is what Abinesh was getting at i.e. a more OO solution where you have an abstract Fruit class with an abstract Eat() method with Apple, Banana etc classes inheriting from it and implementing the Eat() method.

]]> Comments on: The Power of Enum http://elegantcode.com/2010/05/08/the-power-of-enum/?utm_source=rss&utm_medium=rss&utm_campaign=the-power-of-enum Tue, 08 May 2012 09:13:00 +0000 hourly 1 http://wordpress.org/?v=3.3.1 By: Wilian http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-63767 Wilian Sun, 03 Apr 2011 22:57:00 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-63767 very nice and helpful very nice and helpful

]]> By: Joep Lijnen http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-63762 Joep Lijnen Sat, 02 Apr 2011 22:10:00 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-63762 I also like how the switch-snippet in Visual Studio will automatically fill in all enumeration fields when you use it; e.g. switch-[TAB]-[TAB] fruits [TAB] [ENTER] I also like how the switch-snippet in Visual Studio will automatically fill in all enumeration fields when you use it; e.g. switch-[TAB]-[TAB] fruits [TAB] [ENTER]

]]> By: Elegant Code » Enforce Correct Usage By Wrapping Types http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-58092 Elegant Code » Enforce Correct Usage By Wrapping Types Sun, 11 Jul 2010 22:40:59 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-58092 [...] are achieving the same kind of valuable input constrictions that we have been able to achieve with enumerations, except we are adding more complex restrictions than a simple list of [...] [...] are achieving the same kind of valuable input constrictions that we have been able to achieve with enumerations, except we are adding more complex restrictions than a simple list of [...]

]]> By: Jeff http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-57254 Jeff Tue, 18 May 2010 18:22:24 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-57254 I like enums as replacements for magic numbers, per Raymond Chen at the Old New Thing. Using ints, bools, and other basic types as function parameters is bad since you can't tell from the source code line what the values are SEMANTICALLY. Enumeration values provide a way to document what was meant, not just pass a value. I like enums as replacements for magic numbers, per Raymond Chen at the Old New Thing. Using ints, bools, and other basic types as function parameters is bad since you can’t tell from the source code line what the values are SEMANTICALLY. Enumeration values provide a way to document what was meant, not just pass a value.

]]> By: Derek Fowler http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-57041 Derek Fowler Wed, 12 May 2010 12:27:34 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-57041 Ha, just realised there was a previous page of comments and that stuff had already been covered...doh! Ha, just realised there was a previous page of comments and that stuff had already been covered…doh!

]]> By: Derek Fowler http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-57040 Derek Fowler Wed, 12 May 2010 12:24:54 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-57040 First off, enumerations don't constrain your set of choices e.g. if your Fruits enum "inherits from" the default of int you can pass this in to your method no problem: (Fruits)123456. Similarly Enum.Parse() will also accept "123456" as a valid value for Fruits. Enumerations simply allow you to give some of the values of, in this case, int a special meaning. It depends on how the values are getting into your system as to whether you'd ever need to worry about these unspecified values but it's something you should be aware of. Secondly, I think the best solution to you first example is what Abinesh was getting at i.e. a more OO solution where you have an abstract Fruit class with an abstract Eat() method with Apple, Banana etc classes inheriting from it and implementing the Eat() method. First off, enumerations don’t constrain your set of choices e.g. if your Fruits enum “inherits from” the default of int you can pass this in to your method no problem: (Fruits)123456. Similarly Enum.Parse() will also accept “123456″ as a valid value for Fruits. Enumerations simply allow you to give some of the values of, in this case, int a special meaning. It depends on how the values are getting into your system as to whether you’d ever need to worry about these unspecified values but it’s something you should be aware of.

Secondly, I think the best solution to you first example is what Abinesh was getting at i.e. a more OO solution where you have an abstract Fruit class with an abstract Eat() method with Apple, Banana etc classes inheriting from it and implementing the Eat() method.

]]> By: Abinesh http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-57033 Abinesh Tue, 11 May 2010 17:31:16 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-57033 <a href="#comment-57032" rel="nofollow">@Abinesh</a> Typo in eat method public void eat(Fruit fruit){ fruit.print();// no dirty switch case } @Abinesh

Typo in eat method
public void eat(Fruit fruit){
fruit.print();// no dirty switch case
}

]]> By: Abinesh http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-57032 Abinesh Tue, 11 May 2010 17:28:38 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-57032 How about this??? public enum Fruit{ APPLE{ public void print(){System.out.println("i am apple");} }, ORANGE{ public void print(){System.out.println("i am orange");} },MANGO{ public void print(){System.out.println("i am mango");}}; public abstract void print(); } your eat() can now become public void eat(Fruit fruit) { fruit.eat();// no dirty switch case } This is in java.I hope kind of enum is possible in C#. How about this???

public enum Fruit{
APPLE{
public void print(){System.out.println(“i am apple”);}
},
ORANGE{
public void print(){System.out.println(“i am orange”);}
},MANGO{
public void print(){System.out.println(“i am mango”);}};
public abstract void print();
}

your eat() can now become

public void eat(Fruit fruit)
{
fruit.eat();// no dirty switch case
}

This is in java.I hope kind of enum is possible in C#.

]]> By: John Sonmez http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-57024 John Sonmez Tue, 11 May 2010 02:23:31 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-57024 <a href="#comment-57023" rel="nofollow">@Adil Ahmad</a> Sure, if we were doing this for a real application, we might have IFruit, and have an Apple, Orange etc class which all implemented a method Eat which had the different behavior. Of course, we should not automatically jump to that pattern to solve this problem, because the solution maybe much simpler and be easily solved with a dictionary that maps the type of fruit to the message. The point of this example was not to solve the problem of making the code as clean as possible, but to point out the use of an enum to improve that code as is. Perhaps I should have used a different example though. @Adil Ahmad
Sure, if we were doing this for a real application, we might have IFruit, and have an Apple, Orange etc class which all implemented a method Eat which had the different behavior.

Of course, we should not automatically jump to that pattern to solve this problem, because the solution maybe much simpler and be easily solved with a dictionary that maps the type of fruit to the message.

The point of this example was not to solve the problem of making the code as clean as possible, but to point out the use of an enum to improve that code as is. Perhaps I should have used a different example though.

]]> By: Adil Ahmad http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-57033 Abinesh Tue, 11 May 2010 17:31:16 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-57033 <a href="#comment-57032" rel="nofollow">@Abinesh</a> Typo in eat method public void eat(Fruit fruit){ fruit.print();// no dirty switch case } @Abinesh

Typo in eat method
public void eat(Fruit fruit){
fruit.print();// no dirty switch case
}

]]> Comments on: The Power of Enum http://elegantcode.com/2010/05/08/the-power-of-enum/?utm_source=rss&utm_medium=rss&utm_campaign=the-power-of-enum Tue, 08 May 2012 09:13:00 +0000 hourly 1 http://wordpress.org/?v=3.3.1 By: Wilian http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-63767 Wilian Sun, 03 Apr 2011 22:57:00 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-63767 very nice and helpful very nice and helpful

]]> By: Joep Lijnen http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-63762 Joep Lijnen Sat, 02 Apr 2011 22:10:00 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-63762 I also like how the switch-snippet in Visual Studio will automatically fill in all enumeration fields when you use it; e.g. switch-[TAB]-[TAB] fruits [TAB] [ENTER] I also like how the switch-snippet in Visual Studio will automatically fill in all enumeration fields when you use it; e.g. switch-[TAB]-[TAB] fruits [TAB] [ENTER]

]]> By: Elegant Code » Enforce Correct Usage By Wrapping Types http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-58092 Elegant Code » Enforce Correct Usage By Wrapping Types Sun, 11 Jul 2010 22:40:59 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-58092 [...] are achieving the same kind of valuable input constrictions that we have been able to achieve with enumerations, except we are adding more complex restrictions than a simple list of [...] [...] are achieving the same kind of valuable input constrictions that we have been able to achieve with enumerations, except we are adding more complex restrictions than a simple list of [...]

]]> By: Jeff http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-57254 Jeff Tue, 18 May 2010 18:22:24 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-57254 I like enums as replacements for magic numbers, per Raymond Chen at the Old New Thing. Using ints, bools, and other basic types as function parameters is bad since you can't tell from the source code line what the values are SEMANTICALLY. Enumeration values provide a way to document what was meant, not just pass a value. I like enums as replacements for magic numbers, per Raymond Chen at the Old New Thing. Using ints, bools, and other basic types as function parameters is bad since you can’t tell from the source code line what the values are SEMANTICALLY. Enumeration values provide a way to document what was meant, not just pass a value.

]]> By: Derek Fowler http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-57041 Derek Fowler Wed, 12 May 2010 12:27:34 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-57041 Ha, just realised there was a previous page of comments and that stuff had already been covered...doh! Ha, just realised there was a previous page of comments and that stuff had already been covered…doh!

]]> By: Derek Fowler http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-57040 Derek Fowler Wed, 12 May 2010 12:24:54 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-57040 First off, enumerations don't constrain your set of choices e.g. if your Fruits enum "inherits from" the default of int you can pass this in to your method no problem: (Fruits)123456. Similarly Enum.Parse() will also accept "123456" as a valid value for Fruits. Enumerations simply allow you to give some of the values of, in this case, int a special meaning. It depends on how the values are getting into your system as to whether you'd ever need to worry about these unspecified values but it's something you should be aware of. Secondly, I think the best solution to you first example is what Abinesh was getting at i.e. a more OO solution where you have an abstract Fruit class with an abstract Eat() method with Apple, Banana etc classes inheriting from it and implementing the Eat() method. First off, enumerations don’t constrain your set of choices e.g. if your Fruits enum “inherits from” the default of int you can pass this in to your method no problem: (Fruits)123456. Similarly Enum.Parse() will also accept “123456″ as a valid value for Fruits. Enumerations simply allow you to give some of the values of, in this case, int a special meaning. It depends on how the values are getting into your system as to whether you’d ever need to worry about these unspecified values but it’s something you should be aware of.

Secondly, I think the best solution to you first example is what Abinesh was getting at i.e. a more OO solution where you have an abstract Fruit class with an abstract Eat() method with Apple, Banana etc classes inheriting from it and implementing the Eat() method.

]]> By: Abinesh http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-57033 Abinesh Tue, 11 May 2010 17:31:16 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-57033 <a href="#comment-57032" rel="nofollow">@Abinesh</a> Typo in eat method public void eat(Fruit fruit){ fruit.print();// no dirty switch case } @Abinesh

Typo in eat method
public void eat(Fruit fruit){
fruit.print();// no dirty switch case
}

]]> By: Abinesh http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-57032 Abinesh Tue, 11 May 2010 17:28:38 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-57032 How about this??? public enum Fruit{ APPLE{ public void print(){System.out.println("i am apple");} }, ORANGE{ public void print(){System.out.println("i am orange");} },MANGO{ public void print(){System.out.println("i am mango");}}; public abstract void print(); } your eat() can now become public void eat(Fruit fruit) { fruit.eat();// no dirty switch case } This is in java.I hope kind of enum is possible in C#. How about this???

public enum Fruit{
APPLE{
public void print(){System.out.println(“i am apple”);}
},
ORANGE{
public void print(){System.out.println(“i am orange”);}
},MANGO{
public void print(){System.out.println(“i am mango”);}};
public abstract void print();
}

your eat() can now become

public void eat(Fruit fruit)
{
fruit.eat();// no dirty switch case
}

This is in java.I hope kind of enum is possible in C#.

]]> By: John Sonmez http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-57024 John Sonmez Tue, 11 May 2010 02:23:31 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-57024 <a href="#comment-57023" rel="nofollow">@Adil Ahmad</a> Sure, if we were doing this for a real application, we might have IFruit, and have an Apple, Orange etc class which all implemented a method Eat which had the different behavior. Of course, we should not automatically jump to that pattern to solve this problem, because the solution maybe much simpler and be easily solved with a dictionary that maps the type of fruit to the message. The point of this example was not to solve the problem of making the code as clean as possible, but to point out the use of an enum to improve that code as is. Perhaps I should have used a different example though. @Adil Ahmad
Sure, if we were doing this for a real application, we might have IFruit, and have an Apple, Orange etc class which all implemented a method Eat which had the different behavior.

Of course, we should not automatically jump to that pattern to solve this problem, because the solution maybe much simpler and be easily solved with a dictionary that maps the type of fruit to the message.

The point of this example was not to solve the problem of making the code as clean as possible, but to point out the use of an enum to improve that code as is. Perhaps I should have used a different example though.

]]> By: Adil Ahmad http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-57032 Abinesh Tue, 11 May 2010 17:28:38 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-57032 How about this??? public enum Fruit{ APPLE{ public void print(){System.out.println("i am apple");} }, ORANGE{ public void print(){System.out.println("i am orange");} },MANGO{ public void print(){System.out.println("i am mango");}}; public abstract void print(); } your eat() can now become public void eat(Fruit fruit) { fruit.eat();// no dirty switch case } This is in java.I hope kind of enum is possible in C#. How about this???

public enum Fruit{
APPLE{
public void print(){System.out.println(“i am apple”);}
},
ORANGE{
public void print(){System.out.println(“i am orange”);}
},MANGO{
public void print(){System.out.println(“i am mango”);}};
public abstract void print();
}

your eat() can now become

public void eat(Fruit fruit)
{
fruit.eat();// no dirty switch case
}

This is in java.I hope kind of enum is possible in C#.

]]> Comments on: The Power of Enum http://elegantcode.com/2010/05/08/the-power-of-enum/?utm_source=rss&utm_medium=rss&utm_campaign=the-power-of-enum Tue, 08 May 2012 09:13:00 +0000 hourly 1 http://wordpress.org/?v=3.3.1 By: Wilian http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-63767 Wilian Sun, 03 Apr 2011 22:57:00 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-63767 very nice and helpful very nice and helpful

]]> By: Joep Lijnen http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-63762 Joep Lijnen Sat, 02 Apr 2011 22:10:00 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-63762 I also like how the switch-snippet in Visual Studio will automatically fill in all enumeration fields when you use it; e.g. switch-[TAB]-[TAB] fruits [TAB] [ENTER] I also like how the switch-snippet in Visual Studio will automatically fill in all enumeration fields when you use it; e.g. switch-[TAB]-[TAB] fruits [TAB] [ENTER]

]]> By: Elegant Code » Enforce Correct Usage By Wrapping Types http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-58092 Elegant Code » Enforce Correct Usage By Wrapping Types Sun, 11 Jul 2010 22:40:59 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-58092 [...] are achieving the same kind of valuable input constrictions that we have been able to achieve with enumerations, except we are adding more complex restrictions than a simple list of [...] [...] are achieving the same kind of valuable input constrictions that we have been able to achieve with enumerations, except we are adding more complex restrictions than a simple list of [...]

]]> By: Jeff http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-57254 Jeff Tue, 18 May 2010 18:22:24 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-57254 I like enums as replacements for magic numbers, per Raymond Chen at the Old New Thing. Using ints, bools, and other basic types as function parameters is bad since you can't tell from the source code line what the values are SEMANTICALLY. Enumeration values provide a way to document what was meant, not just pass a value. I like enums as replacements for magic numbers, per Raymond Chen at the Old New Thing. Using ints, bools, and other basic types as function parameters is bad since you can’t tell from the source code line what the values are SEMANTICALLY. Enumeration values provide a way to document what was meant, not just pass a value.

]]> By: Derek Fowler http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-57041 Derek Fowler Wed, 12 May 2010 12:27:34 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-57041 Ha, just realised there was a previous page of comments and that stuff had already been covered...doh! Ha, just realised there was a previous page of comments and that stuff had already been covered…doh!

]]> By: Derek Fowler http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-57040 Derek Fowler Wed, 12 May 2010 12:24:54 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-57040 First off, enumerations don't constrain your set of choices e.g. if your Fruits enum "inherits from" the default of int you can pass this in to your method no problem: (Fruits)123456. Similarly Enum.Parse() will also accept "123456" as a valid value for Fruits. Enumerations simply allow you to give some of the values of, in this case, int a special meaning. It depends on how the values are getting into your system as to whether you'd ever need to worry about these unspecified values but it's something you should be aware of. Secondly, I think the best solution to you first example is what Abinesh was getting at i.e. a more OO solution where you have an abstract Fruit class with an abstract Eat() method with Apple, Banana etc classes inheriting from it and implementing the Eat() method. First off, enumerations don’t constrain your set of choices e.g. if your Fruits enum “inherits from” the default of int you can pass this in to your method no problem: (Fruits)123456. Similarly Enum.Parse() will also accept “123456″ as a valid value for Fruits. Enumerations simply allow you to give some of the values of, in this case, int a special meaning. It depends on how the values are getting into your system as to whether you’d ever need to worry about these unspecified values but it’s something you should be aware of.

Secondly, I think the best solution to you first example is what Abinesh was getting at i.e. a more OO solution where you have an abstract Fruit class with an abstract Eat() method with Apple, Banana etc classes inheriting from it and implementing the Eat() method.

]]> By: Abinesh http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-57033 Abinesh Tue, 11 May 2010 17:31:16 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-57033 <a href="#comment-57032" rel="nofollow">@Abinesh</a> Typo in eat method public void eat(Fruit fruit){ fruit.print();// no dirty switch case } @Abinesh

Typo in eat method
public void eat(Fruit fruit){
fruit.print();// no dirty switch case
}

]]> By: Abinesh http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-57032 Abinesh Tue, 11 May 2010 17:28:38 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-57032 How about this??? public enum Fruit{ APPLE{ public void print(){System.out.println("i am apple");} }, ORANGE{ public void print(){System.out.println("i am orange");} },MANGO{ public void print(){System.out.println("i am mango");}}; public abstract void print(); } your eat() can now become public void eat(Fruit fruit) { fruit.eat();// no dirty switch case } This is in java.I hope kind of enum is possible in C#. How about this???

public enum Fruit{
APPLE{
public void print(){System.out.println(“i am apple”);}
},
ORANGE{
public void print(){System.out.println(“i am orange”);}
},MANGO{
public void print(){System.out.println(“i am mango”);}};
public abstract void print();
}

your eat() can now become

public void eat(Fruit fruit)
{
fruit.eat();// no dirty switch case
}

This is in java.I hope kind of enum is possible in C#.

]]> By: John Sonmez http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-57024 John Sonmez Tue, 11 May 2010 02:23:31 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-57024 <a href="#comment-57023" rel="nofollow">@Adil Ahmad</a> Sure, if we were doing this for a real application, we might have IFruit, and have an Apple, Orange etc class which all implemented a method Eat which had the different behavior. Of course, we should not automatically jump to that pattern to solve this problem, because the solution maybe much simpler and be easily solved with a dictionary that maps the type of fruit to the message. The point of this example was not to solve the problem of making the code as clean as possible, but to point out the use of an enum to improve that code as is. Perhaps I should have used a different example though. @Adil Ahmad
Sure, if we were doing this for a real application, we might have IFruit, and have an Apple, Orange etc class which all implemented a method Eat which had the different behavior.

Of course, we should not automatically jump to that pattern to solve this problem, because the solution maybe much simpler and be easily solved with a dictionary that maps the type of fruit to the message.

The point of this example was not to solve the problem of making the code as clean as possible, but to point out the use of an enum to improve that code as is. Perhaps I should have used a different example though.

]]> By: Adil Ahmad http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-57024 John Sonmez Tue, 11 May 2010 02:23:31 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-57024 <a href="#comment-57023" rel="nofollow">@Adil Ahmad</a> Sure, if we were doing this for a real application, we might have IFruit, and have an Apple, Orange etc class which all implemented a method Eat which had the different behavior. Of course, we should not automatically jump to that pattern to solve this problem, because the solution maybe much simpler and be easily solved with a dictionary that maps the type of fruit to the message. The point of this example was not to solve the problem of making the code as clean as possible, but to point out the use of an enum to improve that code as is. Perhaps I should have used a different example though. @Adil Ahmad
Sure, if we were doing this for a real application, we might have IFruit, and have an Apple, Orange etc class which all implemented a method Eat which had the different behavior.

Of course, we should not automatically jump to that pattern to solve this problem, because the solution maybe much simpler and be easily solved with a dictionary that maps the type of fruit to the message.

The point of this example was not to solve the problem of making the code as clean as possible, but to point out the use of an enum to improve that code as is. Perhaps I should have used a different example though.

]]> Comments on: The Power of Enum http://elegantcode.com/2010/05/08/the-power-of-enum/?utm_source=rss&utm_medium=rss&utm_campaign=the-power-of-enum Tue, 08 May 2012 09:13:00 +0000 hourly 1 http://wordpress.org/?v=3.3.1 By: Wilian http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-63767 Wilian Sun, 03 Apr 2011 22:57:00 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-63767 very nice and helpful very nice and helpful

]]> By: Joep Lijnen http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-63762 Joep Lijnen Sat, 02 Apr 2011 22:10:00 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-63762 I also like how the switch-snippet in Visual Studio will automatically fill in all enumeration fields when you use it; e.g. switch-[TAB]-[TAB] fruits [TAB] [ENTER] I also like how the switch-snippet in Visual Studio will automatically fill in all enumeration fields when you use it; e.g. switch-[TAB]-[TAB] fruits [TAB] [ENTER]

]]> By: Elegant Code » Enforce Correct Usage By Wrapping Types http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-58092 Elegant Code » Enforce Correct Usage By Wrapping Types Sun, 11 Jul 2010 22:40:59 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-58092 [...] are achieving the same kind of valuable input constrictions that we have been able to achieve with enumerations, except we are adding more complex restrictions than a simple list of [...] [...] are achieving the same kind of valuable input constrictions that we have been able to achieve with enumerations, except we are adding more complex restrictions than a simple list of [...]

]]> By: Jeff http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-57254 Jeff Tue, 18 May 2010 18:22:24 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-57254 I like enums as replacements for magic numbers, per Raymond Chen at the Old New Thing. Using ints, bools, and other basic types as function parameters is bad since you can't tell from the source code line what the values are SEMANTICALLY. Enumeration values provide a way to document what was meant, not just pass a value. I like enums as replacements for magic numbers, per Raymond Chen at the Old New Thing. Using ints, bools, and other basic types as function parameters is bad since you can’t tell from the source code line what the values are SEMANTICALLY. Enumeration values provide a way to document what was meant, not just pass a value.

]]> By: Derek Fowler http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-57041 Derek Fowler Wed, 12 May 2010 12:27:34 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-57041 Ha, just realised there was a previous page of comments and that stuff had already been covered...doh! Ha, just realised there was a previous page of comments and that stuff had already been covered…doh!

]]> By: Derek Fowler http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-57040 Derek Fowler Wed, 12 May 2010 12:24:54 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-57040 First off, enumerations don't constrain your set of choices e.g. if your Fruits enum "inherits from" the default of int you can pass this in to your method no problem: (Fruits)123456. Similarly Enum.Parse() will also accept "123456" as a valid value for Fruits. Enumerations simply allow you to give some of the values of, in this case, int a special meaning. It depends on how the values are getting into your system as to whether you'd ever need to worry about these unspecified values but it's something you should be aware of. Secondly, I think the best solution to you first example is what Abinesh was getting at i.e. a more OO solution where you have an abstract Fruit class with an abstract Eat() method with Apple, Banana etc classes inheriting from it and implementing the Eat() method. First off, enumerations don’t constrain your set of choices e.g. if your Fruits enum “inherits from” the default of int you can pass this in to your method no problem: (Fruits)123456. Similarly Enum.Parse() will also accept “123456″ as a valid value for Fruits. Enumerations simply allow you to give some of the values of, in this case, int a special meaning. It depends on how the values are getting into your system as to whether you’d ever need to worry about these unspecified values but it’s something you should be aware of.

Secondly, I think the best solution to you first example is what Abinesh was getting at i.e. a more OO solution where you have an abstract Fruit class with an abstract Eat() method with Apple, Banana etc classes inheriting from it and implementing the Eat() method.

]]> By: Abinesh http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-57033 Abinesh Tue, 11 May 2010 17:31:16 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-57033 <a href="#comment-57032" rel="nofollow">@Abinesh</a> Typo in eat method public void eat(Fruit fruit){ fruit.print();// no dirty switch case } @Abinesh

Typo in eat method
public void eat(Fruit fruit){
fruit.print();// no dirty switch case
}

]]> By: Abinesh http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-57032 Abinesh Tue, 11 May 2010 17:28:38 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-57032 How about this??? public enum Fruit{ APPLE{ public void print(){System.out.println("i am apple");} }, ORANGE{ public void print(){System.out.println("i am orange");} },MANGO{ public void print(){System.out.println("i am mango");}}; public abstract void print(); } your eat() can now become public void eat(Fruit fruit) { fruit.eat();// no dirty switch case } This is in java.I hope kind of enum is possible in C#. How about this???

public enum Fruit{
APPLE{
public void print(){System.out.println(“i am apple”);}
},
ORANGE{
public void print(){System.out.println(“i am orange”);}
},MANGO{
public void print(){System.out.println(“i am mango”);}};
public abstract void print();
}

your eat() can now become

public void eat(Fruit fruit)
{
fruit.eat();// no dirty switch case
}

This is in java.I hope kind of enum is possible in C#.

]]> By: John Sonmez http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-2/#comment-57024 John Sonmez Tue, 11 May 2010 02:23:31 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-57024 <a href="#comment-57023" rel="nofollow">@Adil Ahmad</a> Sure, if we were doing this for a real application, we might have IFruit, and have an Apple, Orange etc class which all implemented a method Eat which had the different behavior. Of course, we should not automatically jump to that pattern to solve this problem, because the solution maybe much simpler and be easily solved with a dictionary that maps the type of fruit to the message. The point of this example was not to solve the problem of making the code as clean as possible, but to point out the use of an enum to improve that code as is. Perhaps I should have used a different example though. @Adil Ahmad
Sure, if we were doing this for a real application, we might have IFruit, and have an Apple, Orange etc class which all implemented a method Eat which had the different behavior.

Of course, we should not automatically jump to that pattern to solve this problem, because the solution maybe much simpler and be easily solved with a dictionary that maps the type of fruit to the message.

The point of this example was not to solve the problem of making the code as clean as possible, but to point out the use of an enum to improve that code as is. Perhaps I should have used a different example though.

]]> By: Adil Ahmad http://elegantcode.com/2010/05/08/the-power-of-enum/comment-page-1/#comment-57023 Adil Ahmad Tue, 11 May 2010 01:37:55 +0000 http://elegantcode.com/2010/05/08/the-power-of-enum/#comment-57023 What is your opinion on the pattern called : -Replace Conditional with Polymorphism which basically means, If you have a conditional that chooses different behavior depending on the type of an object. Move each leg of the conditional to an overriding method in a subclass. Make the original method abstract. Do you think its applicable here. What is your opinion on the pattern called :
-Replace Conditional with Polymorphism which basically means,
If you have a conditional that chooses different behavior depending on the type of an object.
Move each leg of the conditional to an overriding method in a subclass. Make the original method abstract.
Do you think its applicable here.

]]>