C# Passer une propriété par référence

Non, il n'est pas possible de passer directement de la propriété de référence. Visual Basic propose ce soutien dans la langue en mettant la valeur de la propriété dans une variable temp, puis qui est passé par référence et réaffectés à leur retour.

En C#, vous pouvez seulement se rapprocher de ce comportement par le passage d'un Func<T> pour obtenir la valeur de la propriété, et un Action<T> pour le réglage de la valeur (à l'aide de fermetures), où T est le type de la propriété.

Comme d'autres l'ont souligné, vous pouvez le faire à l'aide de délégués, à l'aide de l'une des nombreuses façons de spécifier les délégués. Toutefois, si vous avez l'intention de le faire régulièrement, vous devriez envisager la création d'une enveloppe de type pour le passage des propriétés de la référence qui encapsule les délégués requis, il peut créer une belle API.

Par exemple:

class PropertyReference<T>
{
   public T Value
   {
       get
       {
           return this.getter();
       }

       set
       {
           this.setter(value);
       }
   }

   public PropertyReference(Func<T> getter, Action<T> setter)
   {
      this.getter = getter;
      this.setter = setter;
   }
}

De cette façon, vous pouvez passer autour d'une référence à votre propriété et de le modifier par la définition de la valeur de référence.

var reference = new PropertyReference(
                        () => this.MyValue,
                        x => this.MyValue = x);

reference.Value = someNewValue;

Pourquoi ne pas utiliser des génériques et de retour de l'objet?

private T setFromQueryString<T>(String queryString, HttpContext context)
{
    String valueString = context.Request.QueryString[queryString].ToString(); 

    //Shouldn't be null any more
    Type t = typeof(T);
}

private void callingMethod(HttpContext context)
{
    Foo myFoo = new Foo();
    myFoo.Age = setFromQueryString<int>("inputAge", context);
}

Pas très bien pourquoi vous êtes donc mis sur l'inférence, mais étant donné que vous êtes, vous pourriez le faire

private void setFromQueryString(ref T aProperty, String queryString, HttpContext context)
{
    String valueString = context.Request.QueryString[queryString].ToString(); 

    //Shouldn't be null any more
    Type t = typeof(T);
}

private void callingMethod(HttpContext context)
{
    Foo myFoo = new Foo();
    setFromQueryString(ref myFoo.Age, "inputAge", context);
}

Voici une autre solution pour vous:

Créer des classes dérivées à partir du Système.Web.L'INTERFACE utilisateur.La Page qui ont la QueryString paramètres de propriétés. Aussi, à l'aide d'une fonction d'utilité (voir ConvertType, ci-dessous), vous n'avez pas besoin d'en faire trop pour obtenir les données de la chaîne de Requête. Enfin, à l'intérieur de ces classes dérivées, de définir une statique à l'intérieur de la classe qui contient les constantes qui sont les noms des paramètres de chaîne de Requête, de sorte que vous n'avez pas besoin de faire référence à toute la magie des valeurs de n'importe où.

J'ai l'habitude de définir une page de base de la classe pour mon projet, ce qui en fait un endroit idéal pour faire des choses ordinaires qui se produisent sur toutes les pages, ainsi que quelques fonctions utilitaires:

public class MyBasePage : System.Web.UI.Page
{
public T GetQueryStringValue<T>(
string value,
T defaultValue,
bool throwOnBadConvert)
{
T returnValue;
if (string.IsNullOrEmpty(value))
return defaultValue;
else
returnValue = ConvertType<T>(value, defaultValue);
if (returnValue == defaultValue && throwOnBadConvert)
//In production code, you'd want to create a custom Exception for this
throw new Exception(string.Format("The value specified '{0}' could not be converted to type '{1}.'", value, typeof(T).Name));
else
return returnValue;
}
//I usually have this function as a static member of a global utility class because
//it's just too useful to only have here.
public T ConvertType<T>(
object value,
T defaultValue)
{
Type realType = typeof(T);
if (value == null)
return defaultValue;
if (typeof(T) == value.GetType())
return (T)value;
if (typeof(T).IsGenericType)
realType = typeof(T).GetGenericArguments()[0];
if (realType == typeof(Guid))
return (T)Convert.ChangeType(new Guid((string)value), realType);
else if (realType == typeof(bool))
{
int i;
if (int.TryParse(value.ToString(), out i))
return (T)Convert.ChangeType(i == 0 ? true : false, typeof(T));
}
if (value is Guid && typeof(T) == typeof(string))
return (T)Convert.ChangeType(((Guid)value).ToString(), typeof(T));
if (realType.BaseType == typeof(Enum))
return (T)Enum.Parse(realType, value.ToString(), true);
try
{
return (T)Convert.ChangeType(value, realType);
}
catch
{
return defaultValue;
}
}
}
public class MyPage : MyBasePage
{
public static class QueryStringParameters
{
public const string Age= "age";
}
public int Age
{
get 
{ 
return base.GetQueryStringValue<int>(Request[QueryStringParameters.Age], -1);
}
}
}

Puis, dans votre page régulière, dans le code derrière, il ressemble maintenant à ceci:

public partial class MyWebPage : MyPage
{
protected void Page_Load(object sender, EventArgs e)
{
Foo myFoo = new Foo();
Foo.Age = this.Age;
}
}

Elle rend le code derrière classes très propre (comme vous pouvez le voir), et il est facilement maintenable car tout le gros du travail est fait par deux fonctions (GetQueryStringValue et ChangeType) qui sont réutilisés dans chaque page de classes, et tout est de type sécurisé (vous remarquerez que dans GetQueryStringValue que vous pouvez spécifier si la fonction renvoie si la valeur ne peut pas être converti ou utilise simplement renvoie la valeur par défaut; les deux sont appropriées à différents moments, en fonction de votre application).

En outre, vous pouvez même facilement écrire un VS plugin ou CodeSmith script pour générer les dérivées de la classe de la page assez facilement. Et il n'y a pas un tas de délégués et des trucs étant passé autour, que je trouve de nouveaux développeurs ont du mal à comprendre.