我正在寻找一种方法来允许C＃对象中的属性只设置一次。编写代码很容易，但我宁愿使用标准机制（如果存在）。
public OneShot<int> SetOnceProperty { get; set; }
我想要发生的是，如果属性尚未设置，则可以设置该属性，但如果之前已设置，则抛出异常。它应该像Nullable值一样运行，我可以检查它是否已经设置。
答案 0 :(得分：46)
在.NET 4.0的TPL中直接支持这一点;
（编辑：上面的句子写的是预期System.Threading.WriteOnce<T>，它存在于当时可用的“预览”位中，但这似乎在TPL命中RTM / GA之前已经消失了）
直到那时才自己做检查......从我记得的内容来看并不是很多......
类似的东西：
public sealed class WriteOnce<T>
{
private T value;
private bool hasValue;
public override string ToString()
{
return hasValue ? Convert.ToString(value) : "";
}
public T Value
{
get
{
if (!hasValue) throw new InvalidOperationException("Value not set");
return value;
}
set
{
if (hasValue) throw new InvalidOperationException("Value already set");
this.value = value;
this.hasValue = true;
}
}
public T ValueOrDefault { get { return value; } }
public static implicit operator T(WriteOnce<T> value) { return value.Value; }
}
然后使用，例如：
readonly WriteOnce<string> name = new WriteOnce<string>();
public WriteOnce<string> Name { get { return name; } }
答案 1 :(得分：28)
您可以自己推送（请参阅答案的结尾，以获得更强大的线程安全实现并支持默认值）。
public class SetOnce<T>
{
private bool set;
private T value;
public T Value
{
get { return value; }
set
{
if (set) throw new AlreadySetException(value);
set = true;
this.value = value;
}
}
public static implicit operator T(SetOnce<T> toConvert)
{
return toConvert.value;
}
}
您可以像这样使用它：
public class Foo
{
private readonly SetOnce<int> toBeSetOnce = new SetOnce<int>();
public int ToBeSetOnce
{
get { return toBeSetOnce; }
set { toBeSetOnce.Value = value; }
}
}
下更强大的实施方案
public class SetOnce<T>
{
private readonly object syncLock = new object();
private readonly bool throwIfNotSet;
private readonly string valueName;
private bool set;
private T value;
public SetOnce(string valueName)
{
this.valueName = valueName;
throwIfGet = true;
}
public SetOnce(string valueName, T defaultValue)
{
this.valueName = valueName;
value = defaultValue;
}
public T Value
{
get
{
lock (syncLock)
{
if (!set && throwIfNotSet) throw new ValueNotSetException(valueName);
return value;
}
}
set
{
lock (syncLock)
{
if (set) throw new AlreadySetException(valueName, value);
set = true;
this.value = value;
}
}
}
public static implicit operator T(SetOnce<T> toConvert)
{
return toConvert.value;
}
}
public class NamedValueException : InvalidOperationException
{
private readonly string valueName;
public NamedValueException(string valueName, string messageFormat)
: base(string.Format(messageFormat, valueName))
{
this.valueName = valueName;
}
public string ValueName
{
get { return valueName; }
}
}
public class AlreadySetException : NamedValueException
{
private const string MESSAGE = "The value \"{0}\" has already been set.";
public AlreadySetException(string valueName)
: base(valueName, MESSAGE)
{
}
}
public class ValueNotSetException : NamedValueException
{
private const string MESSAGE = "The value \"{0}\" has not yet been set.";
public ValueNotSetException(string valueName)
: base(valueName, MESSAGE)
{
}
}
答案 2 :(得分：11)
这可以通过摆弄旗帜来完成：
private OneShot<int> setOnce;
private bool setOnceSet;
public OneShot<int> SetOnce
{
get { return setOnce; }
set
{
if(setOnceSet)
throw new InvalidOperationException();
setOnce = value;
setOnceSet = true;
}
}
这不好，因为您可能会收到运行时错误。在编译时强制执行此行为要好得多：
public class Foo
{
private readonly OneShot<int> setOnce;
public OneShot<int> SetOnce
{
get { return setOnce; }
}
public Foo() :
this(null)
{
}
public Foo(OneShot<int> setOnce)
{
this.setOnce = setOnce;
}
}
然后使用任一构造函数。
答案 3 :(得分：4)
正如Marc所说，默认情况下在.Net中无法做到这一点，但是自己添加一个并不太难。
public class SetOnceValue<T> {
private T m_value;
private bool m_isSet;
public bool IsSet { get { return m_isSet; }}
public T Value { get {
if ( !IsSet ) {
throw new InvalidOperationException("Value not set");
}
return m_value;
}
public T ValueOrDefault { get { return m_isSet ? m_value : default(T); }}
public SetOnceValue() { }
public void SetValue(T value) {
if ( IsSet ) {
throw new InvalidOperationException("Already set");
}
m_value = value;
m_isSet = true;
}
}
然后，您可以将其用作特定媒体资源的支持。
答案 4 :(得分：3)
C＃中没有这样的功能（从3.5开始）。你必须自己编写代码。
答案 5 :(得分：3)
这是我对此的看法：
public class ReadOnly<T> // or WriteOnce<T> or whatever name floats your boat
{
private readonly TaskCompletionSource<T> _tcs = new TaskCompletionSource<T>();
public Task<T> ValueAsync => _tcs.Task;
public T Value => _tcs.Task.Result;
public bool TrySetInitialValue(T value)
{
try
{
_tcs.SetResult(value);
return true;
}
catch (InvalidOperationException)
{
return false;
}
}
public void SetInitialValue(T value)
{
if (!TrySetInitialValue(value))
throw new InvalidOperationException("The value has already been set.");
}
public static implicit operator T(ReadOnly<T> readOnly) => readOnly.Value;
public static implicit operator Task<T>(ReadOnly<T> readOnly) => readOnly.ValueAsync;
}
Marc's answer建议TPL提供此功能，我认为 TaskCompletionSource<T>可能就是他的意思，但我无法确定。
我的解决方案的一些不错的属性：
TaskCompletionSource<T>是一个官方支持的MS类，它简化了实现。答案 6 :(得分：2)
您是否认为只读？ http://en.csharp-online.net/const,_static_and_readonly
它只能在初始化期间设置，但可能正是您要找的。
答案 7 :(得分：2)
/// <summary>
/// Wrapper for once inizialization
/// </summary>
public class WriteOnce<T>
{
private T _value;
private Int32 _hasValue;
public T Value
{
get { return _value; }
set
{
if (Interlocked.CompareExchange(ref _hasValue, 1, 0) == 0)
_value = value;
else
throw new Exception(String.Format("You can't inizialize class instance {0} twice", typeof(WriteOnce<T>)));
}
}
public WriteOnce(T defaultValue)
{
_value = defaultValue;
}
public static implicit operator T(WriteOnce<T> value)
{
return value.Value;
}
}
答案 8 :(得分：0)
interface IFoo {
int Bar { get; }
}
class Foo : IFoo {
public int Bar { get; set; }
}
class Program {
public static void Main() {
IFoo myFoo = new Foo() {
Bar = 5 // valid
};
int five = myFoo.Bar; // valid
myFoo.Bar = 6; // compilation error
}
}
请注意，myFoo被声明为IFoo，但实例化为Foo。
这意味着可以在初始化程序块中设置Bar，但不能通过稍后对myFoo的引用进行设置。
答案 9 :(得分：0)
答案假设将来接收对象引用的对象不会尝试更改它。如果要防止这种情况，则需要使一次性写入代码仅适用于实现ICloneable或原语的类型。例如，String类型实现了ICloneable。那么你将返回数据的克隆或原语的新实例而不是实际数据。
仅限原语的泛型： T GetObject其中T：struct;
如果您知道获取数据引用的对象永远不会覆盖它，则不需要这样做。
另外，请考虑ReadOnlyCollection是否适用于您的应用程序。每当尝试对数据进行更改时，都会抛出异常。
答案 10 :(得分：0)
虽然接受和评价最高的答案最直接地回答了这个（较旧的）问题，但另一个策略是建立一个类层次结构，以便您可以通过父母构建子项，以及新属性：
public class CreatedAtPointA
{
public int ExamplePropOne { get; }
public bool ExamplePropTwo { get; }
public CreatedAtPointA(int examplePropOne, bool examplePropTwo)
{
ExamplePropOne = examplePropOne;
ExamplePropTwo = examplePropTwo;
}
}
public class CreatedAtPointB : CreatedAtPointA
{
public string ExamplePropThree { get; }
public CreatedAtPointB(CreatedAtPointA dataFromPointA, string examplePropThree)
: base(dataFromPointA.ExamplePropOne, dataFromPointA.ExamplePropTwo)
{
ExamplePropThree = examplePropThree;
}
}
依靠构造函数，你可以在代码气味上喷上一些尽头，虽然它仍然是单调乏味的，也是一种可能很昂贵的策略。
答案 11 :(得分：0)
我创建了一个类型，该类型允许在构造中设置值， 然后，该值只能设置/覆盖一次， 否则会引发异常。
public class SetOnce<T>
{
bool set;
T value;
public SetOnce(T init) =>
this.value = init;
public T Value
{
get => this.value;
set
{
if (this.set) throw new AlreadySetException($"Not permitted to override {this.Value}.");
this.set = true;
this.value = value;
}
}
public static implicit operator T(SetOnce<T> setOnce) =>
setOnce.value;
class AlreadySetException : Exception
{
public AlreadySetException(string message) : base(message){}
}
}
答案 12 :(得分：0)
public DateTime RecordedAt { get; init; }
答案 13 :(得分：-1)