Créer des classe string

Vous pourrez, avec un implicite de conversion:

public class EMailAddress
{
    private string _address;

    public EMailAddress(string address)
    {
        _address = address;
    }

    public static implicit operator EMailAddress(string address)
    {
        //While not technically a requirement; see below why this is done.
        if (address == null)
            return null;

        return new EMailAddress(address);
    }
}

Conversions implicites doit être utilisé uniquement si aucune donnée n'est perdue lors de la conversion. Même alors, je vous recommandons d'utiliser cette fonction avec parcimonie, car il peut rendre votre code plus difficile à lire.

Dans cet exemple, l'opérateur implicite renvoie null lorsqu'un null chaîne est passée. Comme Jon Hanna correctement commenté, il n'est pas souhaitable d'avoir ces deux extraits de code se comportent différemment:

//Will assign null to the reference
EMailAddress x = null;

//Would create an EMailAddress object containing a null string
string s = null;
EMailAddress y = s;

Je pense que cette question est un cas particulier d'une question plus générale sur la création de type de sécurité à travers une application en C#. Mon exemple est ici avec 2 types de données: les Prix et le Poids. Ils ont des unités de mesure différentes, donc on ne devrait jamais essayer un attribuer un prix à un poids ou vice versa. Les deux sous les couvertures sont vraiment des valeurs décimales. (Je suis ignorant le fait qu'il pourrait y avoir des conversions de livres en kg, etc.) Cette même idée pourrait être appliquée à des chaînes de caractères avec des types spécifiques comme Adresse de courrier électronique et UserLastName.

Avec assez de chaudière plaque de code, on peut faire une conversion explicite ou implicite, de conversions et-vient entre les types spécifiques: le Prix et le Poids, et le sous-jacent de type Decimal.

public class Weight
{
    private readonly Decimal _value;

    public Weight(Decimal value)
    {
        _value = value;
    }

    public static explicit operator Weight(Decimal value)
    {
        return new Weight(value);
    }

    public static explicit operator Decimal(Weight value)
    {
        return value._value;
    }
};


 public class Price {
    private readonly Decimal _value;

    public Price(Decimal value) {
        _value = value;
    }

    public static explicit operator Price(Decimal value) {
        return new Price(value);
    }

    public static explicit operator Decimal(Price value)
    {
        return value._value;
    }
};

Avec le "explicite" de l'opérateur remplace, on obtient un jeu plus restrictif de choses qu'on peut faire avec ces classes. Vous devez être manuellement chaque fois que vous changez de type de l'un à l'autre. Par exemple:

    public void NeedsPrice(Price aPrice)
    {
    }

    public void NeedsWeight(Weight aWeight)
    {
    }

    public void NeedsDecimal(Decimal aDecimal)
    {
    }
  public void ExplicitTest()
    {

        Price aPrice = (Price)1.23m;
        Decimal aDecimal = 3.4m;
        Weight aWeight = (Weight)132.0m;

        //ok
        aPrice = (Price)aDecimal;
        aDecimal = (Decimal)aPrice;

        //Errors need explicit case
        aPrice = aDecimal;
        aDecimal = aPrice;

        //ok
        aWeight = (Weight)aDecimal;
        aDecimal = (Decimal) aWeight;

        //Errors need explicit cast
        aWeight = aDecimal;
        aDecimal = aWeight;

        //Errors (no such conversion exists)
        aPrice = (Price)aWeight;
        aWeight = (Weight)aPrice;

        //Ok, but why would you ever do this.
        aPrice = (Price)(Decimal)aWeight;
        aWeight = (Weight)(Decimal)aPrice;

        NeedsPrice(aPrice);   //ok
        NeedsDecimal(aPrice); //error
        NeedsWeight(aPrice);  //error

        NeedsPrice(aDecimal);   //error
        NeedsDecimal(aDecimal); //ok
        NeedsWeight(aDecimal);  //error

        NeedsPrice(aWeight);   //error
        NeedsDecimal(aWeight); //error
        NeedsWeight(aWeight);  //ok
    }

Simplement de changer le "explicite" opérateurs "implicite" des opérateurs en remplaçant les mots "explicite" avec "implicite" dans le code, on peut convertir en arrière et en avant de la sous-classe Decimal sans travail supplémentaire. De ce fait le Prix et le Poids se comportent plus comme une Virgule, mais vous ne pouvez toujours pas de changement de Prix pour un Poids. C'est généralement le niveau de sécurité de type je suis à la recherche d'.

 public void ImplicitTest()
    {
        Price aPrice = 1.23m;
        Decimal aDecimal = 3.4m;
        Weight aWeight = 132.0m;

        //ok implicit cast
        aPrice = aDecimal;
        aDecimal = aPrice;

        //ok implicit cast
        aWeight = aDecimal;
        aDecimal = aWeight;

        //Errors 
        aPrice = aWeight;
        aWeight = aPrice;


        NeedsPrice(aPrice);   //ok
        NeedsDecimal(aPrice); //ok
        NeedsWeight(aPrice);  //error

        NeedsPrice(aDecimal);   //ok
        NeedsDecimal(aDecimal); //ok
        NeedsWeight(aDecimal);  //ok

        NeedsPrice(aWeight);   //error
        NeedsDecimal(aWeight); //ok
        NeedsWeight(aWeight);  //ok
    }    

Lorsque vous faites cela pour la Chaîne, au lieu de la Virgule. J'aime l'idée Thorarin, en réponse à la vérification de la valeur null et en passant null retour dans la conversion. par exemple,

public static implicit operator EMailAddress(string address)
{
    //Make
    //     EmailAddress myvar=null 
    //and
    //     string aNullString = null;
    //     EmailAddress myvar = aNullString;
    //give the same result.
    if (address == null)
        return null;

    return new EMailAddress(address);
}

Pour obtenir ces classes de travail que les clés de Dictionnaire des collections, vous aurez également besoin de mettre en œuvre des Égaux, GetHashCode, l'opérateur = = et l'opérateur !=

Pour rendre tout cela plus facile, j'ai fait une classe ValueType qui je peux prolonger, Le ValueType classe appelle le type de base pour tout, mais les opérateurs de conversion.

Comme vous l'avez remarqué que vous ne pouvez pas hériter de la chaîne, mais vous pouvez l'étendre avec des méthodes d'extension.

De sorte que vous pouvez faire de courriel spécifique de l'extension des méthodes pour gérer tout ce que vous pensiez de la mise dans l'e-mail de classe.