Quando usar ref e quando não é necessário em C #

Tenho um objeto que é meu estado na memória do programa e também algumas outras funções de trabalho para as quais passo o objeto para modificar o estado. Tenho passado por ref para as funções de trabalhador. No entanto, me deparei com a seguinte função.

byte[] received_s = new byte[2048];
IPEndPoint tmpIpEndPoint = new IPEndPoint(IPAddress.Any, UdpPort_msg);
EndPoint remoteEP = (tmpIpEndPoint);

int sz = soUdp_msg.ReceiveFrom(received_s, ref remoteEP); 

Isso me confunde porque received_se remoteEPestão retornando coisas da função. Por que remoteEPprecisa de um refe received_snão precisa ?

Eu também sou um programador AC, então estou tendo problemas para tirar dicas da minha cabeça.

Edit: Parece que os objetos em C # são ponteiros para o objeto subjacente. Portanto, quando você passa um objeto para uma função, pode modificar o conteúdo do objeto por meio do ponteiro e a única coisa passada para a função é o ponteiro para o objeto, de forma que o próprio objeto não seja copiado. Use ref ou out se quiser ser capaz de alternar ou criar um novo objeto na função que é como um ponteiro duplo.

Resposta curta: leia meu artigo sobre passagem de argumento .

Resposta longa: quando um parâmetro de tipo de referência é passado por valor, apenas a referência é passada, não uma cópia do objeto. É como passar um ponteiro (por valor) em C ou C ++. As alterações no valor do próprio parâmetro não serão vistas pelo chamador, mas as alterações no objeto para o qual a referência aponta serão vistas.

Quando um parâmetro (de qualquer tipo) é passado por referência, significa que todas as alterações no parâmetro são vistas pelo chamador - alterações no parâmetro são alterações na variável.

O artigo explica tudo isso com mais detalhes, é claro :)

Resposta útil: você quase nunca precisa usar ref / out . É basicamente uma maneira de obter outro valor de retorno e geralmente deve ser evitado precisamente porque significa que o método provavelmente está tentando fazer muito. Nem sempre é esse o caso ( TryParseetc são os exemplos canônicos de uso razoável de out), mas usar ref / out deve ser uma raridade relativa.

Pense em um parâmetro não ref como sendo um ponteiro e um parâmetro ref como um ponteiro duplo. Isso me ajudou muito.

Você quase nunca deve passar valores por ref. Suspeito que, se não fosse por questões de interoperabilidade, a equipe do .Net nunca o teria incluído na especificação original. A maneira OO de lidar com a maioria dos problemas que os parâmetros ref resolvem é:

Para vários valores de retorno

• Crie estruturas que representam os vários valores de retorno

Para primitivas que mudam em um método como resultado da chamada do método (o método tem efeitos colaterais nos parâmetros primitivos)

• Implemente o método em um objeto como um método de instância e manipule o estado do objeto (não os parâmetros) como parte da chamada do método
• Use a solução de múltiplos valores de retorno e mescle os valores de retorno ao seu estado
• Crie um objeto que contenha o estado que pode ser manipulado por um método e passe esse objeto como parâmetro, e não os próprios primitivos.

Você provavelmente poderia escrever um aplicativo C # inteiro e nunca passar nenhum objeto / estrutura por ref.

Tive um professor que me disse isso:

O único lugar onde você usaria refs é onde você:

1. Deseja passar um objeto grande (ou seja, os objetos / estrutura tem objetos / estruturas dentro dele para vários níveis) e copiá-lo seria caro e
2. Você está chamando um Framework, API do Windows ou outra API que requer isso.

Não faça isso só porque você pode. Você pode ser mordido na bunda por alguns insetos desagradáveis ​​se começar a alterar os valores em um parâmetro e não estiver prestando atenção.

Concordo com seu conselho e, em meus mais de cinco anos desde a escola, nunca tive necessidade disso fora de chamar o Framework ou a API do Windows.

Visto que received_s é um array, você está passando um ponteiro para aquele array. A função manipula os dados existentes no local, sem alterar o local ou o ponteiro subjacente. A palavra-chave ref significa que você está passando o ponteiro real para o local e atualizando esse ponteiro na função externa, portanto, o valor na função externa mudará.

Por exemplo, a matriz de bytes é um ponteiro para a mesma memória antes e depois, a memória acabou de ser atualizada.

A referência do Endpoint está, na verdade, atualizando o ponteiro para o Endpoint na função externa para uma nova instância gerada dentro da função.

Pense em uma referência como significando que você está passando um ponteiro por referência. Não usar um ref significa que você está passando um ponteiro por valor.

Melhor ainda, ignore o que acabei de dizer (provavelmente é enganoso, especialmente com tipos de valor) e leia esta página do MSDN .

meu entendimento é que todos os objetos derivados da classe Object são passados ​​como ponteiros, enquanto os tipos comuns (int, struct) não são passados ​​como ponteiros e requerem ref. Não tenho certeza sobre string (em última análise, é derivado da classe Object?)

Embora eu concorde com a resposta geral de Jon Skeet e com algumas das outras respostas, há um caso de uso para usar ref, que é para aumentar as otimizações de desempenho. Foi observado durante a criação de perfil de desempenho que definir o valor de retorno de um método tem pequenas implicações de desempenho, ao passo que usar refcomo um argumento pelo qual o valor de retorno é preenchido nesse parâmetro resulta na remoção desse pequeno gargalo.

Isso é realmente útil apenas onde os esforços de otimização são levados a níveis extremos, sacrificando a legibilidade e talvez a testabilidade e a manutenção para economizar milissegundos ou talvez frações de milissegundos.

Regra do ponto zero primeiro, primitivos são passados ​​por valor (pilha) e não primitivos por referência (pilha) no contexto de TIPOS envolvidos.

Os parâmetros envolvidos são passados ​​por valor por padrão. Bom post que explica as coisas em detalhes. http://yoda.arachsys.com/csharp/parameters.html

Student myStudent = new Student {Name="A",RollNo=1};

ChangeName(myStudent);

static void ChangeName(Student s1)
{
  s1.Name = "Z"; // myStudent.Name will also change from A to Z
                // {AS s1 and myStudent both refers to same Heap(Memory)
                //Student being the non-Primitive type
}

ChangeNameVersion2(ref myStudent);
static void ChangeNameVersion2(ref Student s1)
{
  s1.Name = "Z"; // Not any difference {same as **ChangeName**}
}

static void ChangeNameVersion3(ref Student s1)
{
    s1 = new Student{Name="Champ"};

    // reference(myStudent) will also point toward this new Object having new memory
    // previous mystudent memory will be released as it is not pointed by any object
}

Podemos dizer (com aviso) Tipos não primitivos nada mais são do que Ponteiros E quando os passarmos por ref podemos dizer que estamos passando Ponteiro Duplo