Van egy próbálkozás a Convert.ToInt32-vel, elkerülve a kivételeket

int variable = 0;
int.TryParse(stringValue, out variable);

Ha nem lehet elemezni, a változó 0 lesz. Lásd: http://msdn.microsoft.com/en-us/library/f02979c7.aspx

A kommentekből kiindulva. A válasz nem. Nem teheti meg azt, amit Convert.ToInt32(object) tesz kivételek nélkül. Csinálhatsz valami hasonlót (és már megtetted). Az egyetlen dolog, amit optimalizálnék, az a value esete, amely már int.

if (value is int) 
    return (int)value;

Nem teheti meg, hogy Convert.ToInt32(object), mert a Convert.ToInt32(object) nem egyszerűen teszteli, hogy a value short, int, long, ushort, ...-e, majd átküldi őket. Ellenőrzi, hogy a value értéke IConvertible. Ha igen, akkor a IConvertible.ToInt32-t használja. Sajnos a IConvertible felület elég gyenge: nincsenek nem dobó módszerek (IConvertible.Try*)

Bár hülyeség (de talán nem túl sok), valaki készíthet például egy UnixDateTime struktúrát: (A UnixTime a másodpercek száma 1970-01-01 éjféltől), ahol a IConvertible.ToInt32 ezt a másodpercszámot adja vissza, míg a ToString() egy formázottat. dátum. Az összes int.TryParse(value.ToString(), out parsed) megfulladna, míg a Convert.ToInt32 hibátlanul működne.

Itt nem kell újra feltalálni a kereket. használja a int.TryParse segítségével elérheti célját. Bool értéket ad vissza, jelezve, hogy az érték értelmezve van-e vagy sem. és ha elemezzük az eredményt a kimeneti változóba mentjük.

int result;
object a = 5;
if(int.TryParse(a.ToString(),out result))
{
   Console.WriteLine("value is parsed");  //will print 5
}    

object b = a5;
if(int.TryParse(b.ToString(),out result))
{
    Console.WriteLine("value is parsed");  
}
else
{
    Console.WriteLine("input is not a valid integer");  //will print this   
}

Ez a típusátalakítót használó verzió csak végső megoldásként konvertálna karakterláncra, de nem jelent kivételt:

public static bool TryToInt32(object value, out int result)
{
    if (value == null)
    {
        result = 0;
        return false;
    }
    var typeConverter =  System.ComponentModel.TypeDescriptor.GetConverter(value);
    if (typeConverter != null && typeConverter.CanConvertTo(typeof(int)))
    {
        var convertTo = typeConverter.ConvertTo(value, typeof(int));
        if (convertTo != null)
        {
            result = (int)convertTo;
            return true;
        }
    }
    return int.TryParse(value.ToString(), out result);
}

Keveréket használnék abból, amit már csinálsz;

• Ellenőrizze, hogy az objektum nulla-e - adjon vissza false értéket és 0 értéket;
• Próbálja meg közvetlenül konvertálni – ha sikeres, adja vissza a true értéket és a konvertált értéket
• Kísérlet az érték elemzésére.ToString() - ha sikeres, adja vissza true és az elemzett értéket
• Minden más eset - Hamis értéket ad vissza és 0 értéket, mivel az objektum nem konvertálható/parbilis

A kapott kód:

public static bool TryToInt32(object value, out int result)
{
    result = 0;
    if (value == null)
    {
        return false;
    }

    //Try to convert directly
    try
    {
        result = Convert.ToInt32(value);
        return true;
    }
    catch
    {
        //Could not convert, moving on
    }

    //Try to parse string-representation
    if (Int32.TryParse(value.ToString(), out result))
    {
        return true;
    }

    //If parsing also failed, object cannot be converted or paresed
    return false;
}

Egy nullázható int. így megtudhatja, hogy elemezte-e a 0-t.

int? value = int.TryParse(stringValue, out int outValue) 
    ? outValue
    : default(int?);

Én írtam ezt a káoszt, elszomorít a nézés.

using System;
using System.Globalization;

internal static class ObjectExt
{
    internal static bool TryConvertToDouble(object value, out double result)
    {
        if (value == null || value is bool)
        {
            result = 0;
            return false;
        }

        if (value is double)
        {
            result = (double)value;
            return true;
        }

        var text = value as string;
        if (text != null)
        {
            return double.TryParse(text, NumberStyles.Float, CultureInfo.InvariantCulture, out result);
        }

        var convertible = value as IConvertible;
        if (convertible == null)
        {
            result = 0;
            return false;
        }

        try
        {
            result = convertible.ToDouble(CultureInfo.InvariantCulture);
            return true;
        }
        catch (Exception)
        {
            result = 0;
            return false;
        }
    }
}

Szerkesztés Figyelje meg, hogy duplán válaszoltam, amikor a kérdés int volt, de megtartottam. Talán hasznos valakinek.