C # Einzel als Referenz Passieren

Question

Ich mag eine Methode haben, wo der Parameter Int32 werden kann oder Single:

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

Da C # nicht erlaubt, mir eine Spezialisierung von Objekt zu übergeben, wenn out oder ref verwenden, die Lösung, die ich behauptete, festgestellt, dass der Variable auf eine Variable vom Typ object zuweisen würde ausreicht, um:

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

, die nicht funktionierten. Nach Angaben der Microsoft-Dokumentation ich sah, o sollte ein Zeiger auf s sein. Die Quellen, die ich im Zustand sah, dass die Zuordnung nicht-primitive Typen erzeugen eine Referenz und keine new Instanz.

Ist es möglich, ein Verfahren zu haben, wo ich Single oder Int32 oder jede andere Art passieren kann, dass eine Spezialisierung von object ist?

Answer 1

Überlastung der Methode:

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

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

Answer 2

Leider bist du kein Glück. Sie werden besser mit zwei Methoden:

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

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

Answer 3

„Ich möchte ein Verfahren haben, wo der Parameter Int32 oder Einzel sein könnte“

Wie wäre es ein Allgemeine Methode stattdessen?

. NB: In der aktuellen Version von C # können Sie nur in der Lage sein, die zulässigen Arten beschränken nicht bestimmte Typen wie int auf struct, float

Answer 4

Statt den Wert in einem Objekt des Boxens, könnten Sie die Funktion überlasten:

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

Was Sie mit dem Argument zu tun innerhalb der Methoden ist davon abhängig, was Sie versuchen, natürlich zu erreichen.

Answer 5

Ich würde wahrscheinlich Ashs Ansatz verwenden und mit einer allgemeinen Implementierung entlang der folgenden Zeilen gehen:

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