Diferença entre Convert.ToString () e .ToString ()

Qual é a diferença entre Convert.ToString()e .ToString()?

Encontrei muitas diferenças online, mas qual é a principal diferença?

Convert.ToString()alças null, enquanto ToString()não.

A chamada ToString()de um objeto pressupõe que o objeto não seja nulo (já que um objeto precisa existir para chamar um método de instância). Convert.ToString(obj)não precisa presumir que o objeto não é nulo (como é um método estático na classe Convert), mas retornará String.Emptyse for nulo.

Além de outras respostas sobre como manipular nullvalores, Convert.ToStringtenta usar IFormattablee fazer IConvertibleinterfaces antes de chamar a base Object.ToString.

Exemplo:

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();
    }
}

Resultado:

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

Vamos entender a diferença através deste exemplo:

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

Podemos converter o número inteiro iusandoi.ToString () ou Convert.ToString. Então qual a diferença?

A diferença básica entre eles é que a Convertfunção manipula NULLS enquanto i.ToString ()não; ele lançará um erro de exceção de referência NULL. Portanto, como uma boa prática de codificação, o uso converté sempre seguro.

Você pode criar uma classe e substituir o toString método para fazer o que quiser.

Por exemplo, você pode criar uma classe "MyMail" e substituir o toStringmétodo para enviar um email ou executar outra operação em vez de escrever o objeto atual.

O Convert.toStringconverte o valor especificado em sua representação de sequência 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

Os métodos são "basicamente" os mesmos, exceto manipulação nula .

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

Do MSDN:
Método Convert.ToString

Converte o valor especificado em sua representação de seqüência equivalente.

Object.ToString

Retorna uma string que representa o objeto atual.

Em Convert.ToString(), o Convert manipula um NULLvalor ou não, mas .ToString()nele não manipula um NULLvalor e um NULLerro de exceção de referência. Portanto, é uma boa prática usar Convert.ToString().

Para os amantes do código, esta é a melhor resposta.

    .............. 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)

Eu concordo com a resposta de @ Ryan . A propósito, começando com o C # 6.0 para esse fim, você pode usar:

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

ou

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

ao invés de

Convert.ToString(someString);

ToString()não pode manipular valores nulos e convert.ToString()pode manipular valores nulos; portanto, quando você deseja que seu sistema manipule o uso de valores nulos convert.ToString().

Convert.ToString(strName)manipulará valores nulos e strName.Tostring()não manipulará valores nulos e lançará uma exceção.

Então é melhor usar Convert.ToString()então.ToString();

ToString() Vs Convert.ToString()

Semelhanças: -

Ambos são usados ​​para converter um tipo específico em string, ou seja, int em string, flutuar em string ou um objeto em string.

Diferença :-

ToString()não pode manipular nulo enquanto no caso com Convert.ToString()manipulará valor nulo.

Exemplo:

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.
        }
    }
}

Para entender os dois métodos, vamos dar um exemplo:

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

Aqui, os dois métodos são usados ​​para converter a string, mas a diferença básica entre eles é: a Convertfunção manipula NULL, enquanto i.ToString()isso não gera um NULL reference exception error.So, pois as boas práticas de codificação convertsão sempre seguras.

Vamos ver outro exemplo:

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)primeiro tenta lançar obj para IConvertible , depois IFormattable para chamar os ToString(...)métodos correspondentes . Se, em vez disso, o valor do parâmetro foi nullretornado string.Empty. Como último recurso, retorneobj.ToString() se nada mais funcionar.

Vale ressaltar que Convert.ToString(value) pode retornar nullse, por exemplo, value.ToString()retornar nulo.

Consulte Fonte de referência .Net

eu escrevi este código e compilei.

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

usando 'engenharia reversa' ( ilspy ), descubro 'object.ToString ()' e 'Convert.ToString (obj)' fazem exatamente uma coisa. de fato 'Convert.ToString (obj)' chame 'object.ToString ()' so 'object.ToString ()' é mais rápido.

Método Object.ToString :

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

Método Conver.ToString :

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

Em C #, se você declarar uma variável de sequência e se não atribuir nenhum valor a essa variável, por padrão, essa variável assumirá um valor nulo. Nesse caso, se você usar o método ToString (), seu programa lançará a exceção de referência nula. Por outro lado, se você usar o método Convert.ToString (), seu programa não lançará uma exceção.

• Convert.Tostring() basicamente chama apenas o seguinte value == null ? String.Empty: value.ToString()

• (string)variableserá transmitido somente quando houver um operador implícito ou explícito no que você está transmitindo

• ToString()pode ser substituído pelo tipo (ele tem controle sobre o que faz); caso contrário, resulta no nome do tipo

Obviamente, se um objeto for nulo , você não poderá acessar o membro da instância ToString(), ele causará uma exceção

A função Convert.Tostring () lida com o NULL, enquanto o método .ToString () não. visite aqui .