C # passando único como referência

Question

Eu gostaria de ter um método em que o parâmetro pode ser Int32 ou Single:

void myMethod( ref object x )
{
     //...CodeHere
}

Uma vez que C # não permite-me para passar uma especialização de objeto ao usar out ou ref, a solução que eu encontrei alegou que a atribuição da variável a uma variável do tipo object seria suficiente:

Single s = 1.0F;
object o = s;
myMethod( ref o );

Isso não funcionou. De acordo com a documentação do Microsoft Olhei, o deve ser um ponteiro para s. As fontes I observava estado que a atribuição de tipos não-primitivos gerar uma referência e não um exemplo new.

É possível ter um método onde eu posso passar Single ou Int32 ou qualquer outro tipo que é uma especialização de object?

Answer 1

Overload o método:

void myMethod( ref int x )
{
    //...
}

void myMethod(ref single x)
{
    //...
}

Answer 2

Infelizmente, você está sem sorte. Você vai ser melhor usar dois métodos:

void MyMethod(ref float x)
{
  //....
}

void MyMethod(ref int x)
{
  //....
}

Answer 3

"Eu gostaria de ter um método em que o parâmetro pode ser Int32 ou Single"

Que tal usar um genérico método em vez disso?

NB:. Na versão atual do C # você só pode ser capaz de restringir os tipos permitidos para struct tipos não específicos, tais como int, float

Answer 4

Em vez de boxe o valor em um objeto, você pode sobrecarregar a função:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication2
{
    class Program
    {
        static void Main(string[] args)
        {
        }

        static int test = 0;

        static void MyMethod(int arg)
        {
            test += arg;
        }

        static void MyMethod(ref int arg)
        {
            test += arg;
        }

        static void MyMethod(Single arg)
        {
            test += Convert.ToInt32(arg);
        }

        static void MyMethod(ref Single arg)
        {
            test += Convert.ToInt32(arg);
        }
    }
}

O que você faz com o argumento de dentro dos métodos depende do que você está tentando realizar, claro.

Answer 5

Eu provavelmente usar a abordagem de Ash e ir com uma implementação genérica ao longo das seguintes linhas:

    static void myMethod<T>(ref T value) where T : struct, IConvertible, IComparable<T>, IEquatable<T>
    {
        value = (T)Convert.ChangeType(value.ToSingle(CultureInfo.CurrentCulture) * 2.0, typeof(T));
    }

    static void Main(string[] args)
    {
        int data1 = 5;

        myMethod(ref data1);
        if (data1 != 10)
            throw new InvalidOperationException();

        Single data2 = 1.5f;

        myMethod(ref data2);
        if (data2 != 3)
            throw new InvalidOperationException();
    }