C# passage simple comme référence

Question

Je voudrais avoir une méthode où le paramètre pourrait être Int32 ou Single:

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

Depuis C# ne me permet pas de passer une spécialisation de l'objet lors de l'utilisation out ou ref, la solution que je trouve a affirmé que l'attribution de la variable à une variable du type object serait suffisant:

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

cela n'a pas fonctionné. Selon la documentation de Microsoft que j'ai regardé, o devrait être un pointeur vers s. Les sources que j'ai regardées indiquent que l'attribution de types non-primitifs génère une référence et non une instance new.

Est-il possible d'avoir une méthode où je peux passer Single ou Int32 ou tout autre type qui est une spécialisation de object?

Answer 1

surcharge la méthode:

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

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

Answer 2

Malheureusement, vous êtes hors de la chance. Vous serez mieux en utilisant deux méthodes:

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

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

Answer 3

« Je voudrais avoir une méthode où le paramètre pourrait être Int32 ou simple »

Que diriez-vous à l'aide d'un Generic method à la place? NB: Dans la version actuelle de C#, vous ne pouvez contraindre que les types autorisés à structurer des types non spécifiques tels que int, float.

Answer 4

au lieu de la boxe la valeur dans un objet, vous pouvez surcharger la fonction:

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

Ce que vous faites avec l'argument à l'intérieur des méthodes dépend de ce que vous essayez d'accomplir, bien sûr.

Answer 5

Je probablement utiliser l'approche de Ash et aller avec une implémentation générique le long des lignes suivantes:

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