nullable string in C#

Kenne ich einen string in C# kann sein, 'nullable', indem Sie einfach mit null.

Ist aber, dass der Punkt der null-Arten ist, dass ich Hilfe aus dem compiler [edit : aka, in der Art error : kann nicht hinzufügen von apple-bananas]

Und mit Hilfe dieser 'Typ system hack-ish' der 'null-Zulässigkeit hängt von den zugrunde liegenden Typ' Pausen', was ich garantiert haben könnte (das ist keine geringe Leistung, wie das scheint der springende Punkt bei der Verwendung eines Typ-system in den ersten Platz..)

Welche sind die standard-Weg, um mit dieser in C#, wenn man will ?
Soll ich nur roll meine eigene 'nullable' Klasse ?

Bearbeiten

Lassen Sie mich anders formulieren Sie die Frage :

Was ist der standard-Weg, in C#, um sicherzustellen, dass eine variable, die Sie annotiert werden als null-Werte zulässt, nicht einer Variablen zugewiesen, die Sie nicht kommentieren, wie null-Werte zu.

Ist :
was ist der standard-Weg, um für alle Arten, genau das, was die ? Schlüsselwort gibt, die Sie für Wert geben.

  • Ich verstehe nicht, Ihre Frage.
  • Warum die f# tag?
  • Welche spezifischen problem erleben Sie?
  • Die Frage ist : wie haben ein explizit nullable-Typ, das heißt, eine, die ompiler bekannt ist, so, dass ich einen Weg nicht weisen, die durch Irrtum eine "nicht-nullwertfähige' Zeichenkette, um eine null-Zeichenfolge.
  • verstehen Sie nullable-Typen ?
  • Tun Sie? Oder, besser geeignet, wissen Sie eigentlich, was Sie wollen in der Lage sein zu tun, dass Sie derzeit nicht, weil wir keine Ahnung haben, was Sie für Fragen basierend auf Ihre Frage. Vielleicht können Sie ein code-Beispiel, was nicht funktioniert und so konnten wir helfen Ihnen bei der Bewältigung Ihrer Probleme.
  • denn dies ist ein ärgernis, dass man nicht in F#. So Stelle ich mir die meisten f# - Programmierer konfrontiert wurde und auf diese.
  • Wie gesagt, ich versuche, die nullable-annotation für jeden Typ. also, wenn Sie nicht verstehen, entnehmen Sie bitte nullable-Typen.
  • nicht, dass es furchtbar schwer, nur Rollen Sie Ihre eigenen, aber ich dachte mir die Menschen gegeben hatte, einige Gedanken auf die vor-und Nachteile von verschiedenen Optionen, die ich vielleicht nicht sehen.
  • Die nullable-annotation ist nur der Wert für Arten, die nicht bereits null-Werte zulässt, nämlich Strukturen. Es gibt keine Möglichkeit für Sie, wenden Sie die annotation in einer Art, die bereits eine nullable-Typ. Es ist nicht möglich für Sie zu Rollen Sie Ihre eigenen nullable-Typ; zumindest bis zu dem Punkt, dass Nullable funktioniert. Mehrere Aspekte, die die Funktionalität benötigen, die compiler-Unterstützung, so dass Sie Ihre eigenen Nullable können nicht immer als feature-rich.
  • Diese Frage ist wahrscheinlich zu verwechseln mit C# Programmierer mit kein F# - Erfahrung, denn die zwei Sprachen Adresse, die null-Zulässigkeit auf sehr unterschiedliche Weise. Wenn die Frage wieder eröffnet, ich bin froh, in der post eine Antwort.
  • Bei der hand, ich habe eine Reihe von DBNull.Wert, null, leere Zeichenketten, nullables, die sich alle definieren, die Nichtigkeit im Rahmen dieses c# - Programm. sehr interessant, mit zu arbeiten !
  • Die Frage wurde wieder geöffnet. Ich wäre interessiert an Ihre Antwort, denn ich glaube nicht, dass es möglich ist, dies zu erreichen. Ich wies die Antwort selbst erklären meine Gedanken.

InformationsquelleAutor nicolas | 2013-02-19
  1. 4

    Wenn Sie Fragen zu einem Weg, um sicherzustellen, dass der Rückgabetyp einer bestimmten Methode ist nicht null gibt es eine Lösung:
    Diese Methode hat einen Rückgabewert geben. Jede Methode gibt einen Verweis geben kann potenziell zurück null. Es gibt nichts, was Sie dagegen tun können.

    So, Sie konnte erstellen eine struct wie diese in der Lage sein, um einen Wert zurückzugeben Typ:

    public struct SurelyNotNull<T>
{
    private readonly T _value;

    public SurelyNotNull(T value)
    {
        if(value == null)
            throw new ArgumentNullException("value");
        _value = value;
    }

    public T Value
    {
        get { return _value; }
    }
}

    Ihre Methode soll einen string zurückgeben, können nun zurück SurelyNotNull<string>.

    Das problem bei diesem Ansatz ist:

    Es funktioniert nicht. Während der Rückgabewert der Methode ist garantiert nicht null ist, ist der Rückgabewert von SurelyNotNull<T>.Value ist nicht. Auf den ersten Blick sieht es aus wie es ist garantiert nicht null. Aber es kann sein, aufgrund von:

    Jeder struct hat einen impliziten, öffentlichen, parameterlosen Konstruktor, auch wenn ein anderer Konstruktor definiert ist.

    Der folgende code ist gültig und läßt sich mit der struct von oben:

    new SurelyNotNull<string>();

    Fazit:

    In C#, Sie sind nicht in der Lage zu erreichen, was Sie versuchen zu tun.

    Sie können immer noch diese Methode verwenden, Sie brauchen nur zu verstehen, dass jemand könnte diese Art und produzieren immer noch einen null-Wert. Scheitern fallen in diesem Szenario, wäre es eine gute Idee, fügen Sie einen Scheck an die getter der Value und eine Ausnahme werfen, wenn _value null ist.

    • Sie konnten den null-check in bekommen, wie gut. Dieser Weg, die böse null, die dort nicht sein sollen, wäre nicht vermehrt durch ein system und würde gefangen werden, wenn er das erste mal angefasst hat.
    • Interessant. Mit ein bisschen übereinkommens in dem code, das wird gehen, denke ich. Zwar nicht kugelsicher, dies ist sicher eine Verbesserung gegenüber dem, was es derzeit ist (ein mix von vielen Dingen), und ich kann Sie nutzen den compiler zu verbreiten, die nicht zur Nichtigkeit.
    • Sicher. Aber das wäre noch eine exception zur Laufzeit, und nicht ein Fehler der compiler erkennen kann. Und das ist, was das alles ist.
    • Der compiler kann immer noch nicht beweisen, dass Value nicht null, so dass, wenn Sie mit statischer code-checker wie ReSharper oder Code-Verträge würden Sie noch erhalten, eine ganze Reihe von "Möglichen Verwendung von null" - Nachrichten.
    • Ich würde nicht sagen, es ist alles über compile-Zeit. Ja, es ist schön zu compile-Zeit überprüft, aber es kann eine große Verbesserung zur Laufzeit zu fangen, die zufälligen null früh auf, anstatt 3 Minuten später, wenn Sie gehen, um es zu benutzen. Es kann wirklich helfen bei der Fehlerbehebung.
    • natürlich. Ich meine, dass der compiler übertragen würde, der Typ (nullableof T .. und nicht T !), und ich würd 'Garantie' mit meinem Augapfel, die rückblickend sagen, dass ich die Konvention überall.
    • Ich bin damit einverstanden, scheitern schnell sein ist wichtig. Aber compile-Zeit ist sogar schneller als die Laufzeit. Also, wenn Sie haben eine compile-Zeit-Fehler, die bevorzugt über eine Laufzeit-exception, egal wie früh, die auftreten könnten.
    • Offensichtlich habe ich gar nicht versucht, die Aussage zu machen, die run-time error checking ist besser als compile-time-Fehler überprüfen... Die Aussage war einfach, dass es sein könnte, Mehrwert durch das hinzufügen der null-check in der SurelyNotNull<T>.Value getter, wie gut.

    InformationsquelleAutor Daniel Hilgarth
  2. 2

    Als Daniel Hilgarth wies darauf hin, es gibt keine kugelsichere Weg, dies zu erreichen. Mein Vorschlag ist ähnlich zu sein, aber mit einigen zusätzlichen Sicherheit. Sie können selbst entscheiden, ob die Vorteile überwiegen die Kosten für die Verwendung eines wrapper-Typ in Ihrem gesamten Programm.

    struct NonNull<T> where T : class {
    private readonly T _value;
    private readonly bool _isSafe;

    public NonNull(T value) {
        if (value == null)
            throw new ArgumentNullException();
        _value = value;
        _isSafe = true;
    }
    public T Value {
        get {
            if (_isSafe) return _value;
            throw new ArgumentNullException();
        }
    }
    public static implicit operator T(NonNull<T> nonNull) {
        return nonNull.Value;
    }
}

static class NonNull {
    public static NonNull<T> Create<T>(T value) where T : class {
        return new NonNull<T>(value);
    }
}

    Den wrapper-Typ ist in Erster Linie, um Ihren Vorsatz selbst dokumentieren, also ist es unwahrscheinlich, dass Sie würde es umgehen mit null initialisiert struct, aber es hält eine Flagge, um anzuzeigen, dass es initialisiert wurde, trotzdem richtig. In dieser zugegebenermaßen ungewöhnlichen Fall, wird es werfen eine ArgumentNullException beim Zugriff auf den Wert.

    class Program {
    static void Main(string[] args) {
        IsEmptyString(NonNull.Create("abc")); //false
        IsEmptyString(NonNull.Create("")); //true
        IsEmptyString(null); //won't compile
        IsEmptyString(NonNull.Create<string>(null)); //ArgumentNullException 
        IsEmptyString(new NonNull<string>()); //bypassing, still ArgumentNullException
    }

    static bool IsEmptyString(NonNull<string> s) {
        return StringComparer.Ordinal.Equals(s, "");
    }
}

    Nun, ist das besser als eine gelegentliche NRE? Vielleicht. Es kann sparen eine Menge boilerplate-arg-Prüfung. Sie müssen entscheiden, ob es sich lohnt für Ihre situation. Kurz compiler-Unterstützung, wie F# bietet, gibt es keine Möglichkeit, compile-time-null Sicherheit, aber man kann (wohl) einfache Laufzeit-Sicherheit.

    Möchten Sie vielleicht, um up-Abstimmung in dieser Frage auf Microsoft ' s Kunden-feedback Ort: Hinzufügen null-Referenz-Typen in C#

    • interessant ! mich beruhigen : hatte Sie, dass in den backburner für eine langjährige Recht ?
    • Ich habe nicht verwendet diese in der Produktion code, sondern vor allem, weil ich habe Frieden gemacht mit diesem Manko in C# (und viele andere Sprachen). F# hat einen großen Sprung vorwärts, indem Sie die Bewältigung dieser Milliarden-dollar-Fehler, auch wenn sein Versuch war begrenzt durch die Notwendigkeit der Interoperabilität. Dennoch können Sie erstellen, so etwas wie eine null-sichere ummauerten Garten für die meisten F# - code.
    • Daniel, ich hoffte, Sie hatte etwas anderes im Sinn, wenn Sie veröffentlicht Ihr Kommentar auf die Frage. Ich glaube wirklich, dass null ist eines der größeren Probleme in den aktuellen Sprachen. Zu deinem code: Deine implizite Betreiber von T zu NonNull entfernt viel compile-Zeit geben Sicherheit, denn Sie ermöglicht IsEmptyString(null) zu kompilieren. Ich denke, es wäre besser, Sie nicht.
    • Du hast Recht. Ich habe versucht zu machen es einfach zu bedienen und stolperte über mich. Ich habe es entfernt.
    • Tut mir Leid zu enttäuschen. Ich hatte die gleiche Idee im Kopf. Möchten Sie vielleicht, um up-Abstimmung ein ähnliches Problem auf User-Voice (link ist in meiner Antwort).
    • wäre das schlecht zum hinzufügen von code für value-Typen haben einen einheitlichen Typ ** private static bool IsValueType<S>(S obj) { return typeof(En).IsValueType; } public nicht-Null - (T Wert) { if (!IsValueType(Wert) && value == null) throw new ArgumentNullException(); _value = value; _isSafe = true; }**
    • value kann nicht ein ValueType aufgrund der Einschränkung where T : class. Plus, dieses Problem gilt nur für Referenz-Typen.
    • der person wer schrieb das Zitat, das Sie erwähnen, ist 10 Meter entfernt. grrrrr ....
    • Naja, da er schrieb quicksort, können Sie ihm Gnade.
    • Von Ihnen positiv bewertet werden.
    • Nicht nur der Handel eine Laufzeit-exception für einen anderen? Kann jemand bitte markieren Sie hier der Vorteil?

    InformationsquelleAutor Daniel
  3. 2

    Du willst so etwas wie eine NotNull Attribut. Mit diesen wird Ihnen der Kompilierung Warnungen und Fehler und in einigen Fällen IDE-feedback über das zuweisen von NULL-Werten zu NotNull-Attribute.

    Siehe diese Frage :C#: Wie zu Implementieren und zu verwenden eine NotNull und CanBeNull Attribut

    InformationsquelleAutor Jason Hernandez
  4. 0

    Alle Referenz-Typen null-Werte zulassen. String ist ein Referenztyp.

    • genau. so Frage ich mich, wie man dem compiler explizit bewusst, dass dieser Wert möglicherweise null-Werte zulässt, die von Bau-VS potenziell null, weil ein bug
    • Wenn der Typ, dass Sie die Zuweisung an eine Referenz geben, dann können Sie zuordnen null. Wenn es ein struct (andere als Nullable<T>, die spezielle compiler-Unterstützung), dann kann man nicht. Wenn Sie eine generische Methode und so nicht wissen, die Art, können Sie entweder default(T) werden null für alle nullable-Typen, oder where T : class um sicherzustellen, dass nur Referenztypen gültig sind Allgemeine Argumente.
    • wenn die Möglichkeit zum zuweisen von null ist, was auf dem Spiel steht für Euch Jungs, ich verstehe, warum Sie nicht bekommen, die Frage.. Der Punkt ist, isolieren null -, und verfolgen, wo Sie gehen können, genießen Sie nicht die Freiheit der null-Zuweisung alles...
    • Sie sind also vorgeschlagen, dass C# eine Sprache hinzufügen-Funktion zu sagen, dass ein Typ auf null gesetzt werden? Wenn ja, ist dies nicht der geeignete Ort für eine solche Anfrage, das ist nicht, wo Microsoft geht, zu schauen, feature-requests für C# -, und die Frage ist also off-topic.
    • Ich Stimme zu, es wäre sehr gut, wenn Sie erklären können Referenz-Typen als nicht null-Werte zu. Derzeit werden alle Referenz-Typen, die null-Werte zulassen, so dass keine Besondere Erklärung vorhanden ist, zu sagen, der compiler Sie null-Werte zulassen, weil Sie alle sind.
    • Fragen Sie für ein Sprach-feature, oder nicht? Bis jetzt hat niemand eine Ahnung, was Sie eigentlich Fragen.
    • das ist keine bitte, das ist ein Hinweis auf wie Sie sollten wahrscheinlich betrachten, null-Werte zu.
    • Sie sollten wirklich aufhören, Ihre Zeit verbringen, sagen alle, dass Sie nicht wissen, was Sie reden, und verbringen mehr Zeit damit, zu erklären, was es ist, dass Sie gefragt haben. Die Beleidigung des Menschen, der Sie um Hilfe bittet, ist nicht besonders produktiv.
    • genau, aber ich konnte irgendwie faken, indem Sie die folgenden die Konvention, zum Beispiel, dass ich nur instantiieren Mynullable<T> und stellen Sie sicher, dass jede Aufgabe, die von Wert ist, die mit nicht-null-Verweise. natürlich ist es garantiert nicht, dass mich irgendetwas an die Grenzen, aber ich könnte noch einige Prüfungen da. nach dieser Konvention, ich würde einen compiler-check (Mynullable<T> ist nicht übertragbar von T) etc.. ich könnte noch eine null Mynullable<T> aber zumindest werde ich loszuwerden, einige Klasse von bugs, die mit diesem semantischen überprüft beim kompilieren
    • es ist nicht eine Beleidigung an alle, es ist wirklich wie sollte man es betrachten...
    • das scheint die meisten leichtgewichtigen Ansatz, in der Tat...
    • Bitte siehe meine Antwort. Leider, das funktioniert auch nicht.

    InformationsquelleAutor Tom Squires
Schreibe einen Kommentar