C # creating a nullable string. Is it possible? Somehow?
Thus, you cannot inherit string
. You cannot do non-nullable string
. But I want to do it. I want a class, let it nString, which returns a default value when it would otherwise be null. I have JSON objects that can have, who knows how many null strings or even null objects. I want to create structures that have strings that will never return null.
public struct Struct
{
public nString value;
public nString value2;
}
I suppose I could do something like this:
public struct Struct
{
public string val { get { return val ?? "N/A"; } set { val = value; } }
public string val2 { get { return val2 ?? "N/A"; } set { val2 = value; } };
}
But it works a lot more. Is there a way to do this?
source to share
You can of course have the following structure nString
:
public struct nString
{
public nString(string value)
: this()
{
Value = value ?? "N/A";
}
public string Value
{
get;
private set;
}
public static implicit operator nString(string value)
{
return new nString(value);
}
public static implicit operator string(nString value)
{
return value.Value;
}
}
...
public nString val
{
get;
set;
}
obj.val = null;
string x = obj.val; // <-- x will become "N/A";
This will allow you to drop inside and out string
. Under the hood, it does the same things as your example, you just don't have to type it in for every property. I am really wondering what this does for maintainability for your application.
source to share
To make my nString structure fully functional, I added every string method to it, including overloads. If anyone comes across this problem, feel free to copy this code and go crazy. I'll probably add the following documentation to it.
/// <summary>
/// Non-nullable string.
/// </summary>
public struct nString
{
public nString(string value)
: this()
{
Value = value ?? "";
}
public nString(char[] value)
{
Value = new string(value) ?? "";
}
public nString(char c, int count)
{
Value = new string(c, count) ?? "";
}
public nString(char[] value, int startIndex, int length)
{
Value = new string(value, startIndex, length) ?? "";
}
public string Value
{
get;
private set;
}
public static implicit operator nString(string value)
{
return new nString(value);
}
public static implicit operator string(nString value)
{
return value.Value ?? "";
}
public int CompareTo(string strB)
{
Value = Value ?? "";
return Value.CompareTo(strB);
}
public bool Contains(string value)
{
Value = Value ?? "";
return Value.Contains(value);
}
public void CopyTo(int sourceIndex, char[] destination, int destinationIndex, int count)
{
Value = Value ?? "";
Value.CopyTo(sourceIndex, destination, destinationIndex, count);
}
public bool EndsWith(string value)
{
Value = Value ?? "";
return Value.EndsWith(value);
}
public bool EndsWith(string value, StringComparison comparisonType)
{
Value = Value ?? "";
return Value.EndsWith(value, comparisonType);
}
public override bool Equals(object obj)
{
Value = Value ?? "";
return Value.Equals(obj);
}
public bool Equals(string value)
{
Value = Value ?? "";
return Value.Equals(value);
}
public bool Equals(string value, StringComparison comparisonType)
{
Value = Value ?? "";
return Value.Equals(value, comparisonType);
}
public override int GetHashCode()
{
Value = Value ?? "";
return Value.GetHashCode();
}
public new Type GetType()
{
return typeof(string);
}
public int IndexOf(char value)
{
Value = Value ?? "";
return Value.IndexOf(value);
}
public int IndexOf(string value)
{
Value = Value ?? "";
return Value.IndexOf(value);
}
public int IndexOf(char value, int startIndex)
{
Value = Value ?? "";
return Value.IndexOf(value, startIndex);
}
public int IndexOf(string value, int startIndex)
{
Value = Value ?? "";
return Value.IndexOf(value, startIndex);
}
public int IndexOf(string value, StringComparison comparisonType)
{
Value = Value ?? "";
return Value.IndexOf(value, comparisonType);
}
public int IndexOf(char value, int startIndex, int count)
{
Value = Value ?? "";
return Value.IndexOf(value, startIndex, count);
}
public int IndexOf(string value, int startIndex, int count)
{
Value = Value ?? "";
return Value.IndexOf(value, startIndex, count);
}
public int IndexOf(string value, int startIndex, StringComparison comparisonType)
{
Value = Value ?? "";
return Value.IndexOf(value, startIndex, comparisonType);
}
public int IndexOf(string value, int startIndex, int count, StringComparison comparisonType)
{
Value = Value ?? "";
return Value.IndexOf(value, startIndex, count, comparisonType);
}
public int IndexOfAny(char[] anyOf)
{
Value = Value ?? "";
return Value.IndexOfAny(anyOf);
}
public int IndexOfAny(char[] anyOf, int startIndex)
{
Value = Value ?? "";
return Value.IndexOfAny(anyOf, startIndex);
}
public int IndexOfAny(char[] anyOf, int startIndex, int count)
{
Value = Value ?? "";
return Value.IndexOfAny(anyOf, startIndex, count);
}
public string Insert(int startIndex, string value)
{
Value = Value ?? "";
return Value.Insert(startIndex, value);
}
public int LastIndexOf(char value)
{
Value = Value ?? "";
return Value.LastIndexOf(value);
}
public int LastIndexOf(string value)
{
Value = Value ?? "";
return Value.LastIndexOf(value);
}
public int LastIndexOf(char value, int startIndex)
{
Value = Value ?? "";
return Value.LastIndexOf(value, startIndex);
}
public int LastIndexOf(string value, int startIndex)
{
Value = Value ?? "";
return Value.LastIndexOf(value, startIndex);
}
public int LastIndexOf(string value, StringComparison comparisonType)
{
Value = Value ?? "";
return Value.LastIndexOf(value, comparisonType);
}
public int LastIndexOf(char value, int startIndex, int count)
{
Value = Value ?? "";
return Value.LastIndexOf(value, startIndex, count);
}
public int LastIndexOf(string value, int startIndex, int count)
{
Value = Value ?? "";
return Value.LastIndexOf(value, startIndex, count);
}
public int LastIndexOf(string value, int startIndex, StringComparison comparisonType)
{
Value = Value ?? "";
return Value.LastIndexOf(value, startIndex, comparisonType);
}
public int LastIndexOf(string value, int startIndex, int count, StringComparison comparisonType)
{
Value = Value ?? "";
return Value.LastIndexOf(value, startIndex, count, comparisonType);
}
public int LastIndexOfAny(char[] anyOf)
{
Value = Value ?? "";
return Value.LastIndexOfAny(anyOf);
}
public int LastIndexOfAny(char[] anyOf, int startIndex)
{
Value = Value ?? "";
return Value.LastIndexOfAny(anyOf, startIndex);
}
public int LastIndexOfAny(char[] anyOf, int startIndex, int count)
{
Value = Value ?? "";
return Value.LastIndexOfAny(anyOf, startIndex, count);
}
public int Length
{
get
{
Value = Value ?? "";
return Value.Length;
}
}
public string PadLeft(int totalWidth)
{
Value = Value ?? "";
return Value.PadLeft(totalWidth);
}
public string PadLeft(int totalWidth, char paddingChar)
{
Value = Value ?? "";
return Value.PadLeft(totalWidth, paddingChar);
}
public string PadRight(int totalWidth)
{
Value = Value ?? "";
return Value.PadRight(totalWidth);
}
public string PadRight(int totalWidth, char paddingChar)
{
Value = Value ?? "";
return Value.PadRight(totalWidth, paddingChar);
}
public string Remove(int startIndex)
{
Value = Value ?? "";
return Value.Remove(startIndex);
}
public string Remove(int startIndex, int count)
{
Value = Value ?? "";
return Value.Remove(startIndex, count);
}
public string Replace(char oldChar, char newChar)
{
Value = Value ?? "";
return Value.Replace(oldChar, newChar);
}
public string Replace(string oldValue, string newValue)
{
Value = Value ?? "";
return Value.Replace(oldValue, newValue);
}
public string[] Split(params char[] separator)
{
Value = Value ?? "";
return Value.Split(separator);
}
public string[] Split(char[] separator, StringSplitOptions options)
{
Value = Value ?? "";
return Value.Split(separator, options);
}
public string[] Split(string[] separator, StringSplitOptions options)
{
Value = Value ?? "";
return Value.Split(separator, options);
}
public bool StartsWith(string value)
{
Value = Value ?? "";
return Value.StartsWith(value);
}
public bool StartsWith(string value, StringComparison comparisonType)
{
Value = Value ?? "";
return Value.StartsWith(value, comparisonType);
}
public string Substring(int startIndex)
{
Value = Value ?? "";
return Value.Substring(startIndex);
}
public string Substring(int startIndex, int length)
{
Value = Value ?? "";
return Value.Substring(startIndex, length);
}
public char[] ToCharArray()
{
Value = Value ?? "";
return Value.ToCharArray();
}
public string ToLower()
{
Value = Value ?? "";
return Value.ToLower();
}
public string ToLowerInvariant()
{
Value = Value ?? "";
return Value.ToLowerInvariant();
}
public override string ToString()
{
Value = Value ?? "";
return Value.ToString();
}
public string ToUpper()
{
Value = Value ?? "";
return Value.ToUpper();
}
public string ToUpperInvariant()
{
Value = Value ?? "";
return Value.ToUpperInvariant();
}
public string Trim()
{
Value = Value ?? "";
return Value.Trim();
}
public string Trim(params char[] trimChars)
{
Value = Value ?? "";
return Value.Trim(trimChars);
}
public string TrimEnd(params char[] trimChars)
{
Value = Value ?? "";
return Value.TrimEnd(trimChars);
}
public string TrimStart(params char[] trimChars)
{
Value = Value ?? "";
return Value.TrimStart(trimChars);
}
}
source to share
You are on the right track because you can create a value type ( struct
) to wrap a .NET primitive type and add some rules around the type without adding any real overhead.
The only problem is that value types can be default initialized just like a string can be default initialized. Therefore, you cannot avoid the existence of an "invalid" or "empty" or "null" value.
Here is a class that wraps a string with the added rule that a string cannot be empty or empty. For lack of a better name, I decided to call it Text
:
struct Text : IEquatable<Text> {
readonly String value;
public Text(String value) {
if (!IsValid(value))
throw new ArgumentException("value");
this.value = value;
}
public static implicit operator Text(String value) {
return new Text(value);
}
public static implicit operator String(Text text) {
return text.value;
}
public static Boolean operator ==(Text a, Text b) {
return a.Equals(b);
}
public static Boolean operator !=(Text a, Text b) {
return !(a == b);
}
public Boolean Equals(Text other) {
return Equals(this.value, other.value);
}
public override Boolean Equals(Object obj) {
if (obj == null || obj.GetType() != typeof(Text))
return false;
return Equals((Text) obj);
}
public override Int32 GetHashCode() {
return this.value != null ? this.value.GetHashCode() : String.Empty.GetHashCode();
}
public override String ToString() {
return this.value != null ? this.value : "N/A";
}
public static Boolean IsValid(String value) {
return !String.IsNullOrEmpty(value);
}
public static readonly Text Empty = new Text();
}
You don't need to implement the interface IEquatable<T>
, but it's a nice addition because you have to override anyway Equals
.
I decided to create two implicit translation operators, so this type can be used interchangeably with regular strings. However, implicit casting can be a bit subtle, so you can change one or both to explicit casting operators. If you choose to use implicit casts, you should probably also override the ==
and operator !=
to avoid using the ==
string operator when you really want to use Equals
for that type.
You can use the class like this:
var text1 = new Text("Alpha");
Text text2 = "Beta"; // Implicit cast.
var text3 = (Text) "Gamma"; // Explicit cast.
var text4 = new Text(""); // Throws exception.
var s1 = (String) text1; // Explicit cast.
String s2 = text2; // Implicit cast.
However, you still have the value "null" or "empty":
var empty = new Text();
Console.WriteLine(Equals(text, Text.Empty)); // Prints "True".
Console.WriteLine(Text.Empty); // Prints "N/A".
This concept can easily be extended to more complex "strings", for example. phone numbers or other structured strings. This will allow you to write code that is easier to understand. For example, instead of
public void AddCustomer(String name, String phone) { ... }
you can change it to
public void AddCustomer(String name, PhoneNumber phone) { ... }
The second function does not need to confirm the phone number, as it is already there PhoneNumber
, which should be valid. Compare this to a string that can contain any content and in every call that you need to check. While most seasoned developers will probably agree that it is bad practice to use strings for strings such as social security numbers, phone numbers, country codes, currencies, etc.
Note that this approach has no overhead in terms of heap allocation. It's just a line with some additional verification code.
source to share
You can use something like extension method
public static class StringExtensions
{
public static string GetValueOrNotAvailable(this string value)
{
return value ?? "N/A";
}
}
then you will be able to call it like this
string s = (some variable that could be null)
Console.WriteLine(s.GetValueOrNotAvailable());
Unfortunately, you cannot override the get get method, you can create a new type that keeps track of the inner string like you did above.
source to share
"" (*) struct
, , a String
, , , null
. String
Object
, String
, , , , String
, , null, ToString()
. String
, (String)this
. .
(*) All value types that can contain any value that differs markedly from their default are mutable, since the struct1 = struct2;
instance stored in struct1 will mutate, overwriting all of its public and private fields with the content of the corresponding fields in type2, and there there is nothing the struct type can do to prevent this.
While in most cases you would like such a type to simply contain a reference to String
, there are times when it might be useful to it otherwise. For example, you can define one or more immutable "CompositeString" classes that contain multiple strings, and have a method ToString
to concatenate them and cache the result. Using types like this one could create a loop like:
for (i=0; i<100000; i++)
st = st + something;
gives near-order performance StringBuilder
without having to use any mutable class semantics (each iteration of the loop will generate a new object CompositeString
, but there can be a lot of information shared between objects).
Even if initially nothing but is stored in the data field String
, using Object
and calling ToString()
on it will allow for the need for other implementations.
source to share
No, you cannot do this.
The only way to create a non-empty type is to declare struct
- structs, however, cannot inherit or be inherited from.
Using properties as you see fit is most likely the best way or zero coalescence during deserialization as suggested earlier, but C # is simply designed to handle values null
.
source to share
With the release of C # 8 in April 2019 and nullable reference types, this is now a feature of the language.
source to share