Re: Set license key / product in c# project - installation package. - C# Discussion Boards

11-Feb-09 10:12

Hi,
I'm just sick of this lengthy switch case drama and I have a feeling there are already better solutions out there, if not, please help me with a creative way you may have used once to make it easier and shorter..

Many thanks for sharing guys!

All generalizations are wrong, including this one!
(\ /)
(O.o)
(><)

akidan11-Feb-09 10:20

11-Feb-09 10:20

You have a few options... it depends on the situation, really.

One possibility is to take the bodies of the case statements and make methods out of them.

Another is to create a dictionary of key to delegate, and do a dictionary lookup/invoke in place of a switch.

Another is to look for an object-oriented way where you differentiate behavior by overriding an abstract/virtual method, in place of a switch statement somewhere.

All depends, though. Smile | :)

Muammar©11-Feb-09 10:28

11-Feb-09 10:28

Thanks, anyway to do it with Enums you know??

All generalizations are wrong, including this one!
(\ /)
(O.o)
(><)

akidan11-Feb-09 11:04

11-Feb-09 11:04

Yes, it should work with enums.

Again, though, it really depends a lot on what you're trying to do, so it's hard to recommend one approach over another... but here's a sample of some different techniques. Each have their strengths and weaknesses, depending on your situation.

Assuming an enum like:

enum MyEnum { Foo, Bar, Baz }

switch way:

bool method(MyEnum val)
{
	switch (val)
	{
		case MyEnum.Foo:
			Console.WriteLine("Some");
			Console.WriteLine("big");
			Console.WriteLine("case");
			Console.WriteLine("statement");
			Console.WriteLine("that");
			Console.WriteLine("Foo");
			Console.WriteLine("does");
			return true;
		case MyEnum.Bar:
			throw new Exception("Bar!");
		case MyEnum.Baz:
			Console.Beep();
			Console.WriteLine("Beep.");
			return false;
		default:
			throw new ArgumentOutOfRangeException("val");
	}
}

Refactor to methods way:

bool method(MyEnum val)
{
	switch (val)
	{
		case MyEnum.Foo:
			return FooMethod();
		case MyEnum.Bar:
			return BarMethod();
		case MyEnum.Baz:
			return BazMethod();
		default:
			throw new ArgumentOutOfRangeException("val");
	}
}

bool FooMethod()
{
	Console.WriteLine("Some");
	Console.WriteLine("big");
	Console.WriteLine("case");
	Console.WriteLine("statement");
	Console.WriteLine("that");
	Console.WriteLine("Foo");
	Console.WriteLine("does");
	return true;
}

bool BarMethod()
{
	throw new Exception("Bar!");
}

bool BazMethod()
{
	Console.Beep();
	Console.WriteLine("Beep.");
	return false;
}

Dictionary way (.Invoke() is just for clarity):

delegate bool BoolFunc();
readonly Dictionary<MyEnum, BoolFunc> methods;

MyClassConstructor()
{
	methods = new Dictionary<MyEnum, BoolFunc>();
	methods.Add(MyEnum.Foo, FooMethod);
	methods.Add(MyEnum.Bar, BarMethod);
	methods.Add(MyEnum.Baz, BazMethod);
}

bool method(MyEnum val)
{
	BoolFunc funcToCall;

	if (!methods.TryGetValue(val, out funcToCall))
		throw new ArgumentOutOfRangeException("val");

	return funcToCall.Invoke();
}

bool FooMethod()
{
	Console.WriteLine("Some");
	Console.WriteLine("big");
	Console.WriteLine("case");
	Console.WriteLine("statement");
	Console.WriteLine("that");
	Console.WriteLine("Foo");
	Console.WriteLine("does");
	return true;
}

bool BarMethod()
{
	throw new Exception("Bar!");
}

bool BazMethod()
{
	Console.Beep();
	Console.WriteLine("Beep.");
	return false;
}

Subclass/override way (the enum actually goes away here):

bool method(MyNonEnumClass val)
{
	return val.DoYourThing();
}

abstract class MyNonEnumClass
{
	public abstract bool DoYourThing();
}

class FooClass : MyNonEnumClass
{
	public override bool DoYourThing()
	{
		Console.WriteLine("Some");
		Console.WriteLine("big");
		Console.WriteLine("case");
		Console.WriteLine("statement");
		Console.WriteLine("that");
		Console.WriteLine("Foo");
		Console.WriteLine("does");
		return true;
	}
}

class BarClass : MyNonEnumClass
{
	public override bool DoYourThing()
	{
		throw new Exception("Bar!");
	}
}

class BazClass : MyNonEnumClass
{
	public override bool DoYourThing()
	{
		Console.Beep();
		Console.WriteLine("Beep.");
		return false;
	}
}

Hope this helps ease your switch/case pain! Smile | :)

modified on Wednesday, February 11, 2009 5:21 PM

Pete O'Hanlon11-Feb-09 11:07

Pete O'Hanlon

11-Feb-09 11:07

There's an even easier way. Take a look at my post below - it's as easy as this.

"WPF has many lovers. It's a veritable porn star!" - Josh Smith

My blog | My articles | MoXAML PowerToys

akidan11-Feb-09 11:11

11-Feb-09 11:11

Thanks... I did write that way under Dictionary way already, though. Smile | :)

Muammar©11-Feb-09 22:16

11-Feb-09 22:16

Wow, thanks akidan!
I think I will go with the last one.

All generalizations are wrong, including this one!
(\ /)
(O.o)
(><)

akidan12-Feb-09 3:10

12-Feb-09 3:10

My pleasure! Smile | :)

Happy I could help.

Deresen11-Feb-09 10:45

Deresen

11-Feb-09 10:45

Why would you like to throw away the switch case?

This is a great way to code statemachines, for instance when you've got a status.

Or you use if else, but is like the same as switch case.

It really depends on what is it when you would like to get rid of the switch case. It depends on the situation. Show a situation and we'll give the solution.

Pete O'Hanlon11-Feb-09 11:06

Pete O'Hanlon

11-Feb-09 11:06

You could always use a Dictionary with an enumeration and a Action to use. For instance, you could have an enumeration that closed a window like this:

public enum Operation 
{
  Close,
  Save,
}
public void Action(Operation action)
{
  if (_dictionary.ContainsKey(action))
  {
    _dictionary[action]();
  }
}
public void Register(Operation operation, Action action)
{
  _dictionary.Add(operation, action);
}

Then, you can add your implementation like this:

Register(Operation.Close, delegate(){ this.Close(); });

As you can see, calling this method removes the need for a switch altogether.

"WPF has many lovers. It's a veritable porn star!" - Josh Smith

My blog | My articles | MoXAML PowerToys

led mike11-Feb-09 11:29

led mike

11-Feb-09 11:29

Pete O'Hanlon wrote:
As you can see, calling this method removes the need for a switch altogether.

Not if you have legacy code as the OP does. He still has to switch the code to the new method. Poke tongue | ;-P

akidan11-Feb-09 11:31

11-Feb-09 11:31

Augh... that's terrible. Smile | :)

11-Feb-09 22:27

Hi Pete, I like your solution, it looks short and effecient, however, there's still one big problem.. I cant understand it Blush | :O

See, I have this statement:

            foreach (DataGridViewColumn grdC in grd.Columns)
            {
                switch (grdC.HeaderText)
                {
                    case "ID":
                        grdC.HeaderText = "id";
                        break;
                    case "NAME":
                        grdC.HeaderText = "name";
                        break;
                    ...
                }
            }<pre> 

<div class="ForumSig"><hr><font face="Comic Sans MS" size="2" color="#3300aa">All generalizations are wrong, including this one!</font><font face="Arial" size="4">
(\ /)
(O.o)
(><)</font></hr></div>