Funktion verkürzen

[faux]

So, hätte mal kurz ne Frage.

Wie kann ich denn die folgene Funktion etwas verkürzen?

Code:

public static bool BoolToInt(object input)
{
  if (input is int)
  {
    if ((int)input == 0)
      return false;
    else
      return true;
  }
  else if (input is string)
  {
    if (Convert.ToInt32(input) == 0)
      return false;
    else
      return
        true;
  }
  return
    false;
}

Ich lese einen Wert aus der Registry; dieser wird vom .NET Framework als object zurückgegeben.
Der Wert kann ein string oder ein int sein. Ich überprüfe jetzt mit dem Schlüsselwort is, ob der Wert ein int bzw ein string ist, und gebe wenn der Wert 0 bzw "0" ist, false zurück; ansonsten true.
Das ganze geht doch sicherlich auch kürzer, denke ich mal.

Grüße
Faux

[jfheins]

Du könntest es imho zumindest so machen:

Code:

public static bool BoolToInt(object input) 
{ 
  if (input is int) 
  { 
    return ((int)input != 0) 
  } 
  else if (input is string) 
  { 
    return (Convert.ToInt32(input) != 0) 
  } 
  return  false; 
}

[faux]

OK, das ist auch wieder wahr.
Aber ich hätte eher die Zeile mit dem is gemeint. Die würde ich gerne etwas verallgemeinern, denn es könnte ja auch ein long oder ein byte übergeben werden.

Grüße
Faux

[JasonDX]

wenn du dir sicher bist, dass ein int oder ein string zurueckgegeben wird, der eine Zahl enthaelt, so ginge eine etwas seltsame, unschoene, aber kurze Variante:

Code:

public static bool BoolToInt(object input) 
{
  return Convert.ToInt32(input.ToString()) != 0; 
}

greetz
Mike

[faux]

Gute Idee.

Werde das Ganze noch mit TryParse absichern.

Hab da was verwechselt. Die Funktion gibts ja garnicht..
Wie könnt eich das sonst absichern?!

Hab doch nichts verwechselt, nur in der falschen Klasse nachgesehen.
Nicht Convert.TryParse, sondern Int32.TryParse..

Danke.

Code:

int val;
return (Int32.TryParse(input.ToString(), val) && val != 0);

[Elvis]

Auweia... ;?

Suche mal nach Boxing/Unboxing oder einfach ".Net ist langsam". Diese Aussage kommt oft in Zusammenhang mit dem CLR Feature Boxing. Dieses Parsing eines strings in einen int, der mal ein int war und doch zu einem String gewandelt wurde....

Generics sind hier ein Weg, damit du jeden Value type ohne Umwandlung gegen sein default[1] vergleichen kannst.
Einen int aus Faulheit in ein object zu boxen ist nur unter .Net 1.1 zu verzeihen.

[1]alle numerischen Value types haben 0 als default, bool hat false als default

Hier mal ein Bleistift wie man a) alle Value types gegen 0/default in einen bool wandeln kann.
Außerdem enthält es noch eine Methoe, die lle mit String vergleichbaren typen gegen 1, True oder true vergleicht.

Einfach als abstraktes Beispiel auffassen, das zeigen soll, wie man type contraint von generics dazu benutzen kann, um mit den generischen Werten überhaupt etwas anfangen zu können.

Code:

class Program
{
   static bool PrimitiveToBool<T>(T value)
      where T : struct, IEquatable<T>
   {
      return !default(T).Equals(value);
   }

   static bool StringToBool<T>(T value)
      where T : IEquatable<String>
   {
      return !object.Equals(value, default(T)) &&
             (value.Equals("1") ||
              value.Equals("True") ||
              value.Equals("true"));
   }


   public static void Main(string[] args)
   {
      TestPrimitive<Int32>(0);
      TestPrimitive<Int32>(1);
      TestPrimitive<Int64>(0);
      TestPrimitive<Int64>(1);
      TestPrimitive<Decimal>(0);
      TestPrimitive<Decimal>(1);
      TestPrimitive<Single>(0);
      TestPrimitive<Single>(1);

      TestString<String>("true");
      TestString<String>("mööp");

      TestString<StringCompatible>("1");
      TestString<StringCompatible>(new StringCompatible("hallo"));
   }

   const string format = "{0}: {1} is {2}";

   private static void TestPrimitive<T>(T value)
      where T : struct, IEquatable<T>
   {
      Console.WriteLine(format, typeof(T), value, PrimitiveToBool<T>(value));
   }

   private static void TestString<T>(T value)
      where T : IEquatable<String>
   {
      Console.WriteLine(format, typeof(T), value, StringToBool<T>(value));
   }
}

struct StringCompatible : IEquatable<String>
{
   String value;

   public bool Equals(String other)
   {
      return String.Equals(value, other);
   }

   public StringCompatible(String value)
   {
      this.value = value;
   }

   public override String ToString()
   {
      return value;
   }

   public static implicit operator StringCompatible(String value)
   {
      return new StringCompatible(value);
   }
}

edit:

Output

System.Int32: 0 is False
System.Int32: 1 is True
System.Int64: 0 is False
System.Int64: 1 is True
System.Decimal: 0 is False
System.Decimal: 1 is True
System.Single: 0 is False
System.Single: 1 is True
System.String: true is True
System.String: mööp is False
Samples.GenericToBool.StringCompatible: 1 is True
Samples.GenericToBool.StringCompatible: hallo is False

[faux]

@elvis:
Danke, aber das Stichwort "boxing" alleine hätte auch gereicht...

btw:
Bei deinem Beispiel muss man ja erst wieder den Typ kennen, würde ich mal sagen, oder sehe ich das falsch?

[Dax]

Nuja

Code:

TestPrimitive<typeof(myVar)>(myVar);

[Elvis]

Zitat von Dax:

Nuja

Code:

TestPrimitive<typeof(myVar)>(myVar);

Won't do

[Dax]

Wir wärs dann mit

Code:

MethodInfo method = typeof(Program).GetMethod("TestPrimitive");
MethodInfo tester = method.MakeGenericMethod(myVar.GetType());
tester.Invoke(null, new object[] {myVar});