[英]Should this immutable struct be a mutable class?
我向同事程序员展示了这个结构,他们认为它应该是一个可变类。 他们觉得没有空引用和根据需要改变对象的能力是不方便的。 我真的想知道是否有任何其他原因使这个变成一个可变类。
[Serializable]
public struct PhoneNumber : IEquatable<PhoneNumber>
{
private const int AreaCodeShift = 54;
private const int CentralOfficeCodeShift = 44;
private const int SubscriberNumberShift = 30;
private const int CentralOfficeCodeMask = 0x000003FF;
private const int SubscriberNumberMask = 0x00003FFF;
private const int ExtensionMask = 0x3FFFFFFF;
private readonly ulong value;
public int AreaCode
{
get { return UnmaskAreaCode(value); }
}
public int CentralOfficeCode
{
get { return UnmaskCentralOfficeCode(value); }
}
public int SubscriberNumber
{
get { return UnmaskSubscriberNumber(value); }
}
public int Extension
{
get { return UnmaskExtension(value); }
}
public PhoneNumber(ulong value)
: this(UnmaskAreaCode(value), UnmaskCentralOfficeCode(value), UnmaskSubscriberNumber(value), UnmaskExtension(value), true)
{
}
public PhoneNumber(int areaCode, int centralOfficeCode, int subscriberNumber)
: this(areaCode, centralOfficeCode, subscriberNumber, 0, true)
{
}
public PhoneNumber(int areaCode, int centralOfficeCode, int subscriberNumber, int extension)
: this(areaCode, centralOfficeCode, subscriberNumber, extension, true)
{
}
private PhoneNumber(int areaCode, int centralOfficeCode, int subscriberNumber, int extension, bool throwException)
{
value = 0;
if (areaCode < 200 || areaCode > 989)
{
if (!throwException) return;
throw new ArgumentOutOfRangeException("areaCode", areaCode, @"The area code portion must fall between 200 and 989.");
}
else if (centralOfficeCode < 200 || centralOfficeCode > 999)
{
if (!throwException) return;
throw new ArgumentOutOfRangeException("centralOfficeCode", centralOfficeCode, @"The central office code portion must fall between 200 and 999.");
}
else if (subscriberNumber < 0 || subscriberNumber > 9999)
{
if (!throwException) return;
throw new ArgumentOutOfRangeException("subscriberNumber", subscriberNumber, @"The subscriber number portion must fall between 0 and 9999.");
}
else if (extension < 0 || extension > 1073741824)
{
if (!throwException) return;
throw new ArgumentOutOfRangeException("extension", extension, @"The extension portion must fall between 0 and 1073741824.");
}
else if (areaCode.ToString()[1] == '9')
{
if (!throwException) return;
throw new ArgumentOutOfRangeException("areaCode", areaCode, @"The second digit of the area code cannot be greater than 8.");
}
else
{
value |= ((ulong)(uint)areaCode << AreaCodeShift);
value |= ((ulong)(uint)centralOfficeCode << CentralOfficeCodeShift);
value |= ((ulong)(uint)subscriberNumber << SubscriberNumberShift);
value |= ((ulong)(uint)extension);
}
}
public override bool Equals(object obj)
{
return obj != null && obj.GetType() == typeof(PhoneNumber) && Equals((PhoneNumber)obj);
}
public bool Equals(PhoneNumber other)
{
return this.value == other.value;
}
public override int GetHashCode()
{
return value.GetHashCode();
}
public override string ToString()
{
return ToString(PhoneNumberFormat.Separated);
}
public string ToString(PhoneNumberFormat format)
{
switch (format)
{
case PhoneNumberFormat.Plain:
return string.Format(@"{0:D3}{1:D3}{2:D4}{3:#}", AreaCode, CentralOfficeCode, SubscriberNumber, Extension).Trim();
case PhoneNumberFormat.Separated:
return string.Format(@"{0:D3}-{1:D3}-{2:D4} {3:#}", AreaCode, CentralOfficeCode, SubscriberNumber, Extension).Trim();
default:
throw new ArgumentOutOfRangeException("format");
}
}
public ulong ToUInt64()
{
return value;
}
public static PhoneNumber Parse(string value)
{
var result = default(PhoneNumber);
if (!TryParse(value, out result))
{
throw new FormatException(string.Format(@"The string ""{0}"" could not be parsed as a phone number.", value));
}
return result;
}
public static bool TryParse(string value, out PhoneNumber result)
{
result = default(PhoneNumber);
if (string.IsNullOrEmpty(value))
{
return false;
}
var index = 0;
var numericPieces = new char[value.Length];
foreach (var c in value)
{
if (char.IsNumber(c))
{
numericPieces[index++] = c;
}
}
if (index < 9)
{
return false;
}
var numericString = new string(numericPieces);
var areaCode = int.Parse(numericString.Substring(0, 3));
var centralOfficeCode = int.Parse(numericString.Substring(3, 3));
var subscriberNumber = int.Parse(numericString.Substring(6, 4));
var extension = 0;
if (numericString.Length > 10)
{
extension = int.Parse(numericString.Substring(10));
}
result = new PhoneNumber(
areaCode,
centralOfficeCode,
subscriberNumber,
extension,
false
);
return result.value != 0;
}
public static bool operator ==(PhoneNumber left, PhoneNumber right)
{
return left.Equals(right);
}
public static bool operator !=(PhoneNumber left, PhoneNumber right)
{
return !left.Equals(right);
}
private static int UnmaskAreaCode(ulong value)
{
return (int)(value >> AreaCodeShift);
}
private static int UnmaskCentralOfficeCode(ulong value)
{
return (int)((value >> CentralOfficeCodeShift) & CentralOfficeCodeMask);
}
private static int UnmaskSubscriberNumber(ulong value)
{
return (int)((value >> SubscriberNumberShift) & SubscriberNumberMask);
}
private static int UnmaskExtension(ulong value)
{
return (int)(value & ExtensionMask);
}
}
public enum PhoneNumberFormat
{
Plain,
Separated
}
操纵电话号码的程序是过程的模型。
因此,在进程中使不可变的东西在代码中不可变。 在过程中使可变的东西在代码中变得可变。
例如,一个过程可能包括一个人。 一个人有一个名字。 一个人可以在保留身份的同时更改姓名。 因此,person对象的名称应该是可变的。
一个人有一个电话号码。 一个人可以在保留身份的同时更改他们的电话号码。 因此,一个人的电话号码应该是可变的。
电话号码具有区号。 电话号码不能更改其区号并保留其身份; 您更改区号,现在有一个不同的电话号码。 因此,电话号码的区号应该是不可变的。
我认为保持它是一个不可变的结构是很好的 - 但我个人只是为每个逻辑字段使用单独的变量,除非你一次在内存中有大量的这些变量。 如果你坚持使用最合适的类型(例如3-4个数字的ushort
)那么它应该不那么昂贵 - 并且代码将更加清晰。
我同意这应该是一个不可变的类型。 但是为什么这个结构应该实现ICLoneable和IEquatable接口呢? 它是一种价值类型。
就个人而言,我觉得把它作为一个不可变的结构是一件非常好的事情。 我不建议将其更改为可变类。
大多数时候,根据我的经验,人们想要避免不可改变的结构是通过懒惰来做到这一点。 不可变的结构强制你重新创建结构将完整的参数,但良好的构造函数重载可以在这里有很大的帮助。 (例如,看看这个Font构造函数 - 即使它是一个类,它实现了“克隆除此变量之外的所有内容”模式,您可以为需要更改的公共字段复制该模式。)
除非必要,否则创建可变类会引入其他问题和开销。
也许您的同事可以通过一组方法来满足,以允许单个字段轻松“更改”(导致新实例具有与第一个实例相同的值,除了新字段)。
public PhoneNumber ApplyAreaCode(int areaCode)
{
return new PhoneNumber(
areaCode,
centralOfficeCode,
subscriberNumber,
extension);
}
此外,您可以为“未定义”的电话号码设置一个特殊情况:
public static PhoneNumber Empty
{ get {return default(PhoneNumber); } }
public bool IsEmpty
{ get { return this.Equals(Empty); } }
“Empty”属性提供比“default(PhoneNumber)或new PhoneNumber()”更自然的语法,并允许使用“foo == PhoneNumber.Empty”或foo.IsEmpty等效的null检查。
另外......在你的TryParse中你不是故意的
return result.value != 0;
将要分段可变的数据持有者应该是结构,而不是类。 . 虽然人们可以辩论结构是否应该是分段可变的,但是 。
问题是每个类对象都有效地包含两种信息:
如果一个类对象是不可变的,那么通常对它存在哪些引用都无关紧要。 但是,当数据保持类对象是可变的时,对它的所有引用都有效地相互“附着”; 在其中一个上执行的任何突变都将有效地执行。
如果PhoneNumber
是可变结构,则可以更改PhoneNumber
类型的一个存储位置的字段,而不会影响该类型的任何其他存储位置中的任何字段。 如果有人说var temp = Customers("Fred").MainPhoneNumber; temp.Extension = "x431"; Customers("Fred").MainPhoneNumber = temp;
var temp = Customers("Fred").MainPhoneNumber; temp.Extension = "x431"; Customers("Fred").MainPhoneNumber = temp;
这将改变弗雷德的扩展,而不会影响其他任何人。 相反,如果PhoneNumber
是一个可变类,上面的代码将为MainPhoneNumber
持有对同一对象的引用的每个人设置扩展,但不影响MainPhoneNumber
持有相同数据但不是同一对象的任何人的扩展。 恶心。
可以通过PhoneNumber轻松处理可空性?
声明:本站的技术帖子网页,遵循CC BY-SA 4.0协议,如果您需要转载,请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.