Gibt es eine Möglichkeit, eine Eigenschaft nur einmal in C # festzulegen?

Ich suche nach einer Möglichkeit, eine Eigenschaft in einem C # -Objekt nur einmal festzulegen. Es ist einfach, den Code dafür zu schreiben, aber ich würde lieber einen Standardmechanismus verwenden, falls einer existiert.

public OneShot <int> SetOnceProperty {get; einstellen; }}

Was ich passieren möchte, ist, dass die Eigenschaft festgelegt werden kann, wenn sie nicht bereits festgelegt ist, aber eine Ausnahme auslösen kann, wenn sie zuvor festgelegt wurde. Es sollte wie ein Nullable-Wert funktionieren, bei dem ich überprüfen kann, ob er festgelegt wurde oder nicht.

Dies wird in der TPL in .NET 4.0 direkt unterstützt.

(Bearbeiten: Der obige Satz wurde in Erwartung System.Threading.WriteOnce<T>dessen geschrieben, was in den zu diesem Zeitpunkt verfügbaren "Vorschau" -Bits vorhanden war, aber dies scheint verdunstet zu sein, bevor die TPL RTM / GA traf.)

bis dahin mach den Check einfach selbst ... es sind nicht viele Zeilen, soweit ich mich erinnere ...

etwas wie:

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; }
}

Dann verwenden Sie zum Beispiel:

readonly WriteOnce<string> name = new WriteOnce<string>();
public WriteOnce<string> Name { get { return name; } }

Sie können Ihre eigenen rollen (siehe das Ende der Antwort für eine robustere Implementierung, die threadsicher ist und Standardwerte unterstützt).

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;
    }
}

Sie können es so verwenden:

public class Foo
{
    private readonly SetOnce<int> toBeSetOnce = new SetOnce<int>();

    public int ToBeSetOnce
    {
        get { return toBeSetOnce; }
        set { toBeSetOnce.Value = value; }
    }
}

Robustere Implementierung unten

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)
    {
    }
}

Dies kann entweder mit der Flagge geschehen:

private OneShot<int> setOnce;
private bool setOnceSet;

public OneShot<int> SetOnce
{
    get { return setOnce; }
    set
    {
        if(setOnceSet)
            throw new InvalidOperationException();

        setOnce = value;
        setOnceSet = true;
    }
}

Das ist nicht gut, da Sie möglicherweise einen Laufzeitfehler erhalten können. Es ist viel besser, dieses Verhalten beim Kompilieren durchzusetzen:

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;
    }
}

und verwenden Sie dann einen der beiden Konstruktoren.

Keine solche Funktion in C # (ab 3.5). Sie müssen es selbst codieren.

Wie Marc sagte, gibt es in .Net standardmäßig keine Möglichkeit, dies zu tun, aber es ist nicht allzu schwierig, selbst eine hinzuzufügen.

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;
  }
}

Sie können dies dann als Hintergrund für Ihre bestimmte Eigenschaft verwenden.

Hier ist meine Meinung dazu:

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 Antwort legt nahe, dass die TPL diese Funktionalität bietet, und ich denke, TaskCompletionSource<T> dass dies das war, was er meinte, aber ich kann nicht sicher sein.

Einige schöne Eigenschaften meiner Lösung:

• TaskCompletionSource<T> ist eine offiziell unterstützte MS-Klasse, die die Implementierung vereinfacht.
• Sie können wählen, ob der Wert synchron oder asynchron abgerufen werden soll.
• Eine Instanz dieser Klasse konvertiert implizit in den Wertetyp, den sie speichert. Dies kann Ihren Code ein wenig aufräumen, wenn Sie den Wert weitergeben müssen.

Hast du nur darüber nachgedacht? http://en.csharp-online.net/const,_static_and_readonly

Es kann nur während der Initialisierung eingestellt werden, ist aber möglicherweise das, wonach Sie suchen.

/// <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;
    }
}

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
    }
}

Beachten Sie, dass myFoo als IFoo deklariert, aber als Foo instanziiert ist.

Dies bedeutet, dass Bar innerhalb des Initialisierungsblocks festgelegt werden kann, jedoch nicht durch einen späteren Verweis auf myFoo.

Die Antworten gehen davon aus, dass Objekte, die in Zukunft einen Verweis auf ein Objekt erhalten, nicht versuchen, es zu ändern. Wenn Sie sich davor schützen möchten, müssen Sie dafür sorgen, dass Ihr einmaliger Schreibcode nur für Typen funktioniert, die ICloneable implementieren oder primitiv sind. Der String-Typ implementiert beispielsweise ICloneable. Dann würden Sie einen Klon der Daten oder eine neue Instanz des Grundelements anstelle der tatsächlichen Daten zurückgeben.

Generika nur für Grundelemente: T GetObject wobei T: struct;

Dies ist nicht erforderlich, wenn Sie wissen, dass Objekte, die einen Verweis auf die Daten erhalten, diese niemals überschreiben.

Überlegen Sie auch, ob die ReadOnlyCollection für Ihre Anwendung funktioniert. Eine Ausnahme wird ausgelöst, wenn versucht wird, die Daten zu ändern.

Während die akzeptierten und am besten bewerteten Antworten diese (ältere) Frage am direktesten beantworten, besteht eine andere Strategie darin, eine Klassenhierarchie so zu erstellen, dass Sie Kinder über Eltern sowie die neuen Eigenschaften erstellen können:

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;
    }
}

Wenn Sie sich auf Konstruktoren verlassen, können Sie Febreeze auf den Codegeruch sprühen, obwohl dies immer noch mühsam und eine potenziell teure Strategie ist.

Ich habe einen Typ erstellt, mit dem ein Wert bei der Erstellung festgelegt werden kann. Danach kann der Wert nur einmal festgelegt / überschrieben werden, andernfalls wird eine Ausnahme ausgelöst.

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){}
    }
}

In C # 9 ist diese Funktion integriert. Sie wird nur als Init-Setter bezeichnet

public DateTime RecordedAt { get; init; }

Sie können dies tun, dies ist jedoch keine klare Lösung, und die Lesbarkeit des Codes ist nicht die beste. Wenn Sie Code-Design ausführen, können Sie sich die Singleton- Realisierung zusammen mit AOP ansehen , um Setter abzufangen . Die Realisierung ist nur 123 :)