Differenza tra Convert.ToString () e .ToString ()

Qual è la differenza tra Convert.ToString()e .ToString()?

Ho trovato molte differenze online, ma qual è la differenza principale?

Convert.ToString()gestisce null, mentre ToString()non lo fa.

La chiamata ToString()a un oggetto presuppone che l'oggetto non sia nullo (poiché un oggetto deve esistere per chiamare un metodo di istanza su di esso). Convert.ToString(obj)non è necessario presumere che l'oggetto non sia nullo (in quanto si tratta di un metodo statico sulla classe Convert), ma restituirà invece String.Emptyse è nullo.

Oltre ad altre risposte sulla gestione dei nullvalori, Convert.ToStringprova a utilizzare IFormattablee IConvertibleinterfacce prima di chiamare base Object.ToString.

Esempio:

class FormattableType : IFormattable
{
    private double value = 0.42;

    public string ToString(string format, IFormatProvider formatProvider)
    {
        if (formatProvider == null)
        {
            // ... using some IOC-containers
            // ... or using CultureInfo.CurrentCulture / Thread.CurrentThread.CurrentCulture
            formatProvider = CultureInfo.InvariantCulture;
        }

        // ... doing things with format
        return value.ToString(formatProvider);
    }

    public override string ToString()
    {
        return value.ToString();
    }
}

Risultato:

Convert.ToString(new FormattableType()); // 0.42
new FormattableType().ToString();        // 0,42

Comprendiamo la differenza con questo esempio:

int i= 0;
MessageBox.Show(i.ToString());
MessageBox.Show(Convert.ToString(i));

Possiamo convertire l'intero iusando i.ToString ()o Convert.ToString. Quindi qual è la differenza?

La differenza fondamentale tra loro è che la Convertfunzione gestisce NULLS mentre i.ToString ()non lo fa; genererà un errore di eccezione di riferimento NULL. Quindi, come una buona pratica di programmazione convertè sempre sicura.

Puoi creare una classe e sovrascrivere il toStringmetodo per fare tutto quello che vuoi.

Ad esempio, è possibile creare una classe "MyMail" e sovrascrivere il toStringmetodo per inviare un'e-mail o eseguire altre operazioni invece di scrivere l'oggetto corrente.

Il Convert.toStringconverte il valore specificato per la sua rappresentazione di stringa equivalente.

object o=null;
string s;
s=o.toString();
//returns a null reference exception for string  s.

string str=convert.tostring(o);
//returns an empty string for string str and does not throw an exception.,it's 
//better to use convert.tostring() for good coding

I metodi sono "sostanzialmente" uguali, tranne per la gestione di null .

Pen pen = null; 
Convert.ToString(pen); // No exception thrown
pen.ToString(); // Throws NullReferenceException

Da MSDN:
metodo Convert.ToString

Converte il valore specificato nella sua rappresentazione di stringa equivalente.

Object.ToString

Restituisce una stringa che rappresenta l'oggetto corrente.

In Convert.ToString(), il Convert gestisce o meno un NULLvalore ma in .ToString()esso non gestisce un NULLvalore e un NULLerrore di eccezione di riferimento. Quindi è buona pratica usare Convert.ToString().

Per gli amanti del codice questa è la risposta migliore.

    .............. Un Safe code ...................................
    Try
        ' In this code we will get  "Object reference not set to an instance of an object." exception
        Dim a As Object
        a = Nothing
        a.ToString()
    Catch ex As NullReferenceException
        Response.Write(ex.Message)
    End Try


    '............... it is a safe code..............................
    Dim b As Object
    b = Nothing
    Convert.ToString(b)

Sono d'accordo con la risposta di @ Ryan . A proposito, a partire da C # 6.0 per questo scopo puoi usare:

someString?.ToString() ?? string.Empty;

o

$"{someString}"; // I do not recommend this approach, although this is the most concise option.

invece di

Convert.ToString(someString);

ToString()non può gestire valori null e convert.ToString()può gestire valori null, quindi quando si desidera che il sistema gestisca l'utilizzo di valori null convert.ToString().

Convert.ToString(strName)gestirà valori null-grado e strName.Tostring()non gestirà valore null e genererà un'eccezione.

Quindi è meglio usare Convert.ToString()quindi.ToString();

ToString() Vs Convert.ToString()

Analogie :-

Entrambi vengono utilizzati per convertire un tipo specifico in stringa, ovvero int in stringa, float in stringa o un oggetto in stringa.

Differenza: -

ToString()non può gestire null mentre nel caso in cui Convert.ToString()gestirà il valore null.

Esempio :

namespace Marcus
{
    class Employee
    {
        public int Id { get; set; }
        public string Name { get; set; }
    }
    class Startup
    {
        public static void Main()
        {
            Employee e = new Employee();
            e = null;

            string s = e.ToString(); // This will throw an null exception
            s = Convert.ToString(e); // This will throw null exception but it will be automatically handled by Convert.ToString() and exception will not be shown on command window.
        }
    }
}

Per comprendere entrambi i metodi, facciamo un esempio:

int i =0;
MessageBox.Show(i.ToString());
MessageBox.Show(Convert.ToString(i)); 

Qui entrambi i metodi vengono utilizzati per convertire la stringa, ma la differenza di base tra loro è: Converthandle di funzioni NULL, mentre i.ToString()non genererà una NULL reference exception error.pratica di codifica così buona usandoconvert è sempre sicura.

Vediamo un altro esempio:

string s;
object o = null;
s = o.ToString(); 
//returns a null reference exception for s. 

string s;
object o = null;
s = Convert.ToString(o); 
//returns an empty string for s and does not throw an exception.

Convert.ToString(value)prova prima a lanciare obj su IConvertible , poi su IFormattable per chiamare i ToString(...)metodi corrispondenti . Se invece il valore del parametro fosse nullquindi restituito string.Empty. Come ultima risorsa, tornare obj.ToString()se nient'altro ha funzionato.

Vale la pena notare che Convert.ToString(value) può tornare nullse, ad esempio, value.ToString()restituisce null.

Vedere sorgente di riferimento .Net

ho scritto questo codice e compilarlo.

class Program
{
    static void Main(string[] args)
    {
        int a = 1;
        Console.WriteLine(a.ToString());
        Console.WriteLine(Convert.ToString(a));
    }
}

usando 'reverse engineering' ( ilspy ) scopro 'object.ToString ()' e 'Convert.ToString (obj)' fanno esattamente una cosa. infatti 'Convert.ToString (obj)' call 'object.ToString ()' so 'object.ToString ()' è più veloce.

Metodo Object.ToString :

class System.Object
{
    public string ToString(IFormatProvider provider)
    {
        return Number.FormatInt32(this, null, NumberFormatInfo.GetInstance(provider));
    }
}

Metodo Conver.ToString :

class System.Convert
{
    public static string ToString(object value)
    {
        return value.ToString(CultureInfo.CurrentCulture);
    }
}

In C # se dichiari una variabile stringa e se non assegni alcun valore a quella variabile, per impostazione predefinita quella variabile assume un valore nullo. In tal caso, se si utilizza il metodo ToString (), il programma genererà l'eccezione riferimento null. D'altra parte, se si utilizza il metodo Convert.ToString (), il programma non genererà un'eccezione.

• Convert.Tostring() in pratica chiama semplicemente quanto segue value == null ? String.Empty: value.ToString()

• (string)variableservirà solo a lanciare quando v'è una implicita o esplicita operatore su quello che si sta casting

• ToString()può essere sostituito dal tipo (ha il controllo su ciò che fa), in caso contrario si traduce nel nome del tipo

Ovviamente se un oggetto è nullo , non è possibile accedere al membro dell'istanza ToString(), causerà un'eccezione

La funzione Convert.Tostring () gestisce il valore NULL mentre il metodo .ToString () no. visita qui .