C# Modificadores ref e out

[Kauan Oliveira]

Estou estudando bastante C# e me deparei com o tal dos modifcadores de parâmetros, cheguei a aprender o modificador params e entendi o motivo dele existir, até ai tudo bem, mas logo em seguida me avisaram que existe o modificador ref e out, eu até entendi pra que eles serverm, mas na minha opinião não são tão úteis assim, ou pelo menos ainda não consigo imaginar um cenário que eu precise deles, e também me alertarem que eles não são muito utilizados por desenvolvedores C#, igual aquele goto que também existe mas ninguém usa.

Então eu queria saber de vocês, alguém já usou esses modificadores de parâmetro alguma vez? Alguém sabe o por que deles não serem aconselhados a usar? 

[Matheus Maldi]

São uteis, implementações do proprio framework, para uso do out

 

string line = Console.ReadLine();

int n;
if (int.TryParse(line, out n))
{
 	// Conseguiu converter 
}
else
{
    // não conseguiu converter
}

Ou a implementação de um Swap utiliza-se ref

 

void Swap(ref int x, ref int y)
{
	int tmp = x;
	x = y;
	y = x;
}

 

Raramente você vai precisar usar goto, mas ele é util, normalmente para escapar de loop dentro de loop.

 

Segue 2 codigos abaixo, porém em C, segue primeiro o sem goto:

 

void quick_sort_int (int* array, int i_lo, int i_hi)
{
    int lo = i_lo, hi = i_hi;
    int mid = array[((lo + hi) >> 1)];
    do
    {
        while (array[lo] < mid)
            ++lo;
        while (array[hi] > mid)
            --hi;

        if (lo <= hi)
        {
            int temp = array[lo];
            array[lo] = array[hi];
            array[hi] = temp;
            lo++;
            hi--;
        }
    } while (lo < hi);
    if (hi > i_lo)
        quick_sort_int (array, i_lo, hi);
    if (lo < i_hi)
        quick_sort_int (array, lo, i_hi);
}

 

O codigo abaixo usa goto para evitar chamadas recursivas

 

void quick_sort_int_goto (int* array, int i_lo, int i_hi)
{
skip_recursive_call:;
    int lo = i_lo, hi = i_hi;
    int mid = array[((lo + hi) >> 1)];
    do
    {
        while (array[lo] < mid)
            ++lo;
        while (array[hi] > mid)
            --hi;

        if (lo <= hi)
        {
            int temp = array[lo];
            array[lo] = array[hi];
            array[hi] = temp;
            lo++;
            hi--;
        }
    } while (lo < hi);
    if (hi > i_lo)
    {
        if (lo < i_hi)
        {
            quick_sort_int_goto (array, i_lo, hi);

            i_lo = lo;
            goto skip_recursive_call;
        }
        else
        {            
            i_hi = hi;
            goto skip_recursive_call;
        }
    }
    else if (lo < i_hi)
    {
        i_lo = lo;
        goto skip_recursive_call;
    }
}

 

Não se preocupe em entender a logica do código acima, é escrito para ser performatico e não legivel.

 

O primeiro codigo ordena um array de 100.000.000 inteiros randomicos em 9,4 segundos e o segundo em 8.1 segundos.

 

Apesar de usar raramente o goto, as vezes tem sua utilidade.