Accesseur avec l'ensemble différent et obtient des types?

Question Simple, je l'espère, une réponse simple:

Je voudrais faire la chose suivante:

private DateTime m_internalDateTime;
public var DateTimeProperty
{
   get { return m_internalDateTime.ToString(); } //Return a string
   set { m_internalDateTime = value; } //here value is of type DateTime
}

Ci-dessus est juste un exemple de ce que je suis en train de faire. J'aimerais avoir un accesseur public à une variable interne de type x. Je veux l'obtenir que la variable une chaîne de caractères, mais définir à l'aide de quelque chose de type x.

Est-ce possible?

--edit--

Je viens de réalisé que je pouvais faire quelque chose comme:

private DateTime m_internalDateTime;
public object DateTimeProperty
{
   get { return m_internalDateTime.ToString(); } //Return a string
   set { m_internalDateTime = (DateTime)value; } //here value is of type DateTime
}

Mais alors, disons que j'ai une utilisation de type y, au lieu d'une "chaîne" comme mon 'get' type. Si je veux utiliser "DateTimeProperty" ailleurs dans mon code, je serais obligé de le jeter.

source d'informationauteur Nick

accessor c#types variables

8

Pas. Vous pouvez bien évidemment ajouter l' .ToString() dans le code appelant, mais vous ne pouvez pas faire ce que vous proposez, sans noms différents comme ceci:
```
private DateTime m_internalDateTime;
public DateTime SetDateTime { set { m_internalDateTime = value; } }
public string GetDateTime   { get { return m_internalDateTime.ToString(); } } 
```
Ou, encore mieux d'utiliser des méthodes plutôt que des propriétés (comme indiqué dans les commentaires):
```
private DateTime m_internalDateTime;
public void SetDateTime(DateTime dateTime) { m_internalDateTime = dateTime; }
public string GetDateTime() { return m_internalDateTime.ToString(); }
```
Gardez à l'esprit que var est pour implicitementau moment de la compilation tapé varvariables, pas dynamique variables.

Certainement ne pas faire ce que vous avez noté dans votre montage. Il introduit une rupture dans la convention, les conséquences de performance possibles (même légère), et d'importants problèmes de localisation.
5

Comme une propriété, non ce n'est pas possible. Vous pourriez faire des méthodes Get et Set qui sont de types différents, mais pour l'un des biens les types doivent être les mêmes.

EDIT:

Tout:
```
private DateTime m_internalDateTime;
public object DateTimeProperty
{
   get { return m_internalDateTime.ToString(); } //Return a string
   set { m_internalDateTime = (DateTime)value; } //here value is of type DateTime
}
```
est syntaxiquement correct, de compiler et vous permet d'accepter DateTime comme entrée et renvoie une chaîne de caractères, ce ne serait pas un bon plan. Cela fonctionne, mais il fait de vous et de toute personne accédant à ce code, procédez inutile de validation. En outre, il est vulnérable à un autre développeur dans l'avenir, de ne pas savoir, ou de concrétiser les règles implicites, pour qui vous avez perdu le temps de compilation de sécurité. En outre, son à peine plus de code pour créer deux propriétés, ou les deux méthodes qui permettent d'atteindre le même objectif, dans un typage fort.

Personnellement, je recommande l'utilisation de deux méthodes (voir Jeff Yates commentaire pour une bonne explication pourquoi).
```
private DateTime m_internalDateTime;
public string GetDateTime()
{
    return m_internalDateTime.ToString();
}

public void SetDateTime(DateTime dateTime)
{
    m_internalDateTime = dateTime;
}
```
3

Pas de cette façon, mais vous pouvez certainement avoir une deuxième propriété qui accède à la m_internalDateTime champ.
```
public string DateTimeString
{
   get { return m_internalDateTime.ToString(); }
}
```

Peut-être qui aide

public class TDecimal
{
    private decimal? m_value;
    public bool HasValue { get { return m_value.HasValue; } }
    public decimal Value { get { return m_value.Value; } }

    public static implicit operator TDecimal(string a_value)
    {
        decimal d;
        if (decimal.TryParse(a_value, out d))
        {
            return new TDecimal() {m_value = d};
        }

        return new TDecimal() {m_value = null};
    }

    public static implicit operator decimal(TDecimal a_value)
    {
        if(a_value.HasValue)
        {
            return a_value.Value;
        }

        throw new ArgumentNullException("a_value");
    }
}

public class A
{
    public TDecimal Prop { get; set; }
}

A a = new A();

a.Prop = "123";
if (a.Prop.HasValue)
{
    decimal d = a.Prop;
}

0

Réponse Simple est non, à votre code extérieur de votre propriété va se comporter exactement de la même façon qu'un champ, vous ne pouvez pas avoir une propriété ayant différents set/get types tout comme vous ne pouvez pas avoir un déposées être réglé avec un type et quand vous le demande la valeur d'obtenir un autre type de retour.

comment sur:

private DateTime intDT;
public string DateTimeProperty
{   
      get { return intDT.ToString(); } //Return a string   
      set 
      { 
         DateTime dt;
         if (DateTime.TryParse(value, out dt))
             intDT = dt;
         else throw new ArgumentException(string.Format(
           "{0} cannot be converted to a DateTime.", value);           
      } 
}

Vous devez vous connecter pour publier un commentaire.