如何设计表示既不是 null 也不是空格的字符串的类型

Question

Many times we pass strings in the constructor of business entities and we want to be sure that those strings actually carry a value with them. In such a scenario we perform a validation of the constructor parameters and we throw an ArgumentException each time the passed in string is null or white space.

This is an example of what I mean:

public class Person 
{
   public string Name { get; }

   public Person(string name)
   {
      if (string.IsNullOrWhiteSpace(name))
      {
         throw new ArgumentException("A person name cannot be null or white space", nameof(name));
      }

      this.Name = name;
   }
}

Tired of repeting myself I decided to design an auto safe type representing a string neither null nor white space. This way I can directly use instances of that type in my business code and avoid any validation, because each instance of the type is auto safe (in other words the validation code is now in one place, the code for the type itself).

This is the NonEmptyString struct (original code is here ):

using System;

namespace Deltatre.Utils.Types
{
  /// <summary>
  /// This type wraps a string which is guaranteed to be neither null nor white space
  /// </summary>
  public struct NonEmptyString
  {
    /// <summary>
    /// Implicit conversion from <see cref="NonEmptyString"/> to <see cref="string"/>
    /// </summary>
    /// <param name="nonEmptyString">The instance of <see cref="NonEmptyString"/> to be converted</param>
    public static implicit operator string(NonEmptyString nonEmptyString)
    {
      return nonEmptyString.Value;
    }

    /// <summary>
    /// Explicit conversion from <see cref="string"/> to <see cref="NonEmptyString"/>
    /// </summary>
    /// <param name="value">The instance of <see cref="string"/> to be converted</param>
    /// <exception cref="InvalidCastException">Throws <see cref="InvalidCastException"/> when <paramref name="value"/> is null or white space</exception>
    public static explicit operator NonEmptyString(string value)
    {
      try
      {
        return new NonEmptyString(value);
      }
      catch (ArgumentException ex)
      {
        throw new InvalidCastException($"Unable to convert the provided string to {typeof(NonEmptyString).Name}", ex);
      }
    }

    /// <summary>
    /// Creates new instance of <see cref="NonEmptyString"/>
    /// </summary>
    /// <param name="value">The string to be wrapped</param>
    /// <exception cref="ArgumentException">Throws <see cref="ArgumentException"/> when parameter <paramref name="value"/> is null or white space</exception>
    public NonEmptyString(string value)
    {
      if (string.IsNullOrWhiteSpace(value))
        throw new ArgumentException($"Parameter {nameof(value)} cannot be null or white space", nameof(value));

      this.Value = value;
    }

    /// <summary>
    /// Gets the wrapped string
    /// </summary>
    public string Value { get; }

    /// <summary>Indicates whether this instance and a specified object are equal.</summary>
    /// <param name="obj">The object to compare with the current instance. </param>
    /// <returns>
    ///     <see langword="true" /> if <paramref name="obj" /> and this instance are the same type and represent the same value; otherwise, <see langword="false" />. </returns>
    public override bool Equals(object obj)
    {
      if (!(obj is NonEmptyString))
      {
        return false;
      }

      var other = (NonEmptyString)obj;
      return this.Value == other.Value;
    }

    /// <summary>Returns the hash code for this instance.</summary>
    /// <returns>A 32-bit signed integer that is the hash code for this instance.</returns>
    public override int GetHashCode()
    {
      unchecked
      {
        int hash = 17;
        hash = (hash * 23) + (this.Value == null ? 0 : this.Value.GetHashCode());
        return hash;
      }
    }

    /// <summary>
    /// Compares two instances of <see cref="NonEmptyString"/> for equality
    /// </summary>
    /// <param name="left">An instance of <see cref="NonEmptyString"/></param>
    /// <param name="right">An instance of <see cref="NonEmptyString"/></param>
    /// <returns></returns>
    public static bool operator ==(NonEmptyString left, NonEmptyString right)
    {
      return left.Equals(right);
    }

    /// <summary>
    /// Compares two instances of <see cref="NonEmptyString"/> for inequality
    /// </summary>
    /// <param name="left">An instance of <see cref="NonEmptyString"/></param>
    /// <param name="right">An instance of <see cref="NonEmptyString"/></param>
    /// <returns></returns>
    public static bool operator !=(NonEmptyString left, NonEmptyString right)
    {
      return !(left == right);
    }
  }
}

Using my new type I can change the previous code this way:

public class Person 
{
  public NonEmptyString Name { get; }

  public Person(NonEmptyString name)
  {          
    this.Name = name;
  }
}

The only issue with this design is represented by the default constructor which is always available because my type is a struct .

If anyone using my code writes var myString = new NonEmptyString(); he gets an instance of the type which encapsulates a null reference: this is something I would like to avoid because doing so the entire purpose of my auto safe type is invalidated. In other words I don't want to rely on the programmer not calling the default constructor, I would like to make it impossible to misuse this type.

I came up with a couple of ideas:

• provide a default value for the read only property Value , something such as "NA". This way even when the default constructor is called the instance obtained encapsulates a non null and non white space value.

• adding a flag indicating whether the type has been initialized, having a default value of false . This state is read only and it is changed to true only in the constructor overload receiving a string parameter. This way a guard can be added to any member of the type, so that an InvalidOperationException can be raised each time a programmer tries to use a non initialized instance of the type (that is, an instance of the type obtained by calling the default constructor).

Do you have any suggestion? What approach do you prefer?

Answer 1

Instead of using auto property, you can use backing field _value and implement getter for Value property instead. like

public string Value => _value ?? "";

Then make every function works when _value is null;

Answer 2

I'm not sure if I understand your question well but I assume from

The idea of providing a meaningless default value just to avoid a null reference is a trick. Probably throwing at runtime it's better. That's the same approach Microsoft has used with Nullable. in that case you are free to access the Value of an instance even when the value itself is missing

public class Person 
{
    private string _name;
    public string Name
    {
        get { return _name; }
        set
        {
            if(String.IsNullOrWhiteSpace(value) || String.IsNullOrEmpty(value))
            {
                value = "NA";
            }
            _name = value;
        }
    }

   public Person(string name)
   {
      this.Name = name;
   }
}

This probably might help you. The code is untested, It is just to give you a glimpse of what you might be looking for.