8000 C# 8.0 nullable references · Issue #4036 · NLog/NLog · GitHub
[go: up one dir, main page]
More Web Proxy on the site http://driver.im/
Skip to content

C# 8.0 nullable references #4036

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom
Closed
snakefoot opened this issue Jul 6, 2020 · 6 comments
Closed

C# 8.0 nullable references #4036

snakefoot opened this issue Jul 6, 2020 · 6 comments
Labels
breaking change Breaking API change (different to semantic change) up-for-grabs
Milestone
6.0

Comments

@snakefoot
Copy link
Contributor

Nullable references makes use of method-attributes to signal if references should have been null-checked first before calling.

<PropertyGroup>
    <LangVersion>8.0</LangVersion>
    <Nullable>enable</Nullable>
</PropertyGroup>

The "funny" part is that LangVersion=8.0 is only fully supported for NetCoreApp3. And if targeting NetCoreApp3 then it is enabled by default.

But these features also works out of the box on older platforms:

  • Async enumerables
  • Index and Range support
  • Default Implementations
  • Nullable Annotations in first-party libraries.

But if you try to use other language features of C# 8.0 while targeting .NET Standard 2.0, all bets are off!
@snakefoot snakefoot added the breaking change Breaking API change (different to semantic change) label Jul 6, 2020
@snakefoot snakefoot added this to the 5.0 (new) milestone Jul 6, 2020
@snakefoot
Copy link
Contributor Author

The special annotation attributes are only included with NetCoreApp3 and NetStandard21. Other platforms have to do like with JetBrains-attributes (clone as internal classes):

#if !NETSTANDARD2_1
namespace System.Diagnostics.CodeAnalysis
{
    /// <summary>Specifies that null is allowed as an input even if the corresponding type disallows it.</summary>
    [AttributeUsage(AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.Property, Inherited = false)]
    internal sealed class AllowNullAttribute : Attribute { }

    /// <summary>Specifies that null is disallowed as an input even if the corresponding type allows it.</summary>
    [AttributeUsage(AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.Property, Inherited = false)]
    internal sealed class DisallowNullAttribute : Attribute { }

    /// <summary>Specifies that an output may be null even if the corresponding type disallows it.</summary>
    [AttributeUsage(AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.Property | AttributeTargets.ReturnValue, Inherited = false)]
    internal sealed class MaybeNullAttribute : Attribute { }

    /// <summary>Specifies that an output will not be null even if the corresponding type allows it. Specifies that an input argument was not null when the call returns.</summary>
    [AttributeUsage(AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.Property | AttributeTargets.ReturnValue, Inherited = false)]
    internal sealed class NotNullAttribute : Attribute { }

    /// <summary>Specifies that when a method returns <see cref="ReturnValue"/>, the parameter may be null even if the corresponding type disallows it.</summary>
    [AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
    internal sealed class MaybeNullWhenAttribute : Attribute
    {
        /// <summary>Initializes the attribute with the specified return value condition.</summary>
        /// <param name="returnValue">
        /// The return value condition. If the method returns this value, the associated parameter may be null.
        /// </param>
        public MaybeNullWhenAttribute(bool returnValue) => ReturnValue = returnValue;

        /// <summary>Gets the return value condition.</summary>
        public bool ReturnValue { get; }
    }

    /// <summary>Specifies that when a method returns <see cref="ReturnValue"/>, the parameter will not be null even if the corresponding type allows it.</summary>
    [AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
    internal sealed class NotNullWhenAttribute : Attribute
    {
        /// <summary>Initializes the attribute with the specified return value condition.</summary>
        /// <param name="returnValue">
        /// The return value condition. If the method returns this value, the associated parameter will not be null.
        /// </param>
        public NotNullWhenAttribute(bool returnValue) => ReturnValue = returnValue;

        /// <summary>Gets the return value condition.</summary>
        public bool ReturnValue { get; }
    }

    /// <summary>Specifies that the output will be non-null if the named parameter is non-null.</summary>
    [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Property | AttributeTargets.ReturnValue, AllowMultiple = true, Inherited = false)]
    internal sealed class NotNullIfNotNullAttribute : Attribute
    {
        /// <summary>Initializes the attribute with the associated parameter name.</summary>
        /// <param name="parameterName">
        /// The associated parameter name.  The output will be non-null if the argument to the parameter specified is non-null.
        /// </param>
        public NotNullIfNotNullAttribute(string parameterName) => ParameterName = parameterName;

        /// <summary>Gets the associated parameter name.</summary>
        public string ParameterName { get; }
    }

    /// <summary>Applied to a method that will never return under any circumstance.</summary>
    [AttributeUsage(AttributeTargets.Method, Inherited = false)]
    internal sealed class DoesNotReturnAttribute : Attribute { }

    /// <summary>Specifies that the method will not return if the associated Boolean parameter is passed the specified value.</summary>
    [AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
    internal sealed class DoesNotReturnIfAttribute : Attribute
    {
        /// <summary>Initializes the attribute with the specified parameter value.</summary>
        /// <param name="parameterValue">
        /// The condition parameter value. Code after the method will be considered unreachable by diagnostics if the argument to
        /// the associated parameter matches this value.
        /// </param>
        public DoesNotReturnIfAttribute(bool parameterValue) => ParameterValue = parameterValue;

        /// <summary>Gets the condition parameter value.</summary>
        public bool ParameterValue { get; }
    }

    /// <summary>Specifies that the method or property will ensure that the listed field and property members have not-null values.</summary>
    [AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
    internal sealed class MemberNotNullAttribute : Attribute
    {
        /// <summary>Initializes the attribute with a field or property member.</summary>
        /// <param name="member">
        /// The field or property member that is promised to be not-null.
        /// </param>
        public MemberNotNullAttribute(string member) => Members = new[] { member };

        /// <summary>Initializes the attribute with the list of field and property members.</summary>
        /// <param name="members">
        /// The list of field and property members that are promised to be not-null.
        /// </param>
        public MemberNotNullAttribute(params string[] members) => Members = members;

        /// <summary>Gets field or property member names.</summary>
        public string[] Members { get; }
    }

    /// <summary>Specifies that the method or property will ensure that the listed field and property members have not-null values when returning with the specified return value condition.</summary>
    [AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
    internal sealed class MemberNotNullWhenAttribute : Attribute
    {
        /// <summary>Initializes the attribute with the specified return value condition and a field or property member.</summary>
        /// <param name="returnValue">
        /// The return value condition. If the method returns this value, the associated parameter will not be null.
        /// </param>
        /// <param name="member">
        /// The field or property member that is promised to be not-null.
        /// </param>
        public MemberNotNullWhenAttribute(bool returnValue, string member)
        {
            ReturnValue = returnValue;
            Members = new[] { member };
        }

        /// <summary>Initializes the attribute with the specified return value condition and list of field and property members.</summary>
        /// <param name="returnValue">
        /// The return value condition. If the method returns this value, the associated parameter will not be null.
        /// </param>
        /// <param name="members">
        /// The list of field and property members that are promised to be not-null.
        /// </param>
        public MemberNotNullWhenAttribute(bool returnValue, params string[] members)
        {
            ReturnValue = returnValue;
            Members = members;
        }

        /// <summary>Gets the return value condition.</summary>
        public bool ReturnValue { get; }

        /// <summary>Gets field or property member names.</summary>
        public string[] Members { get; }
    }
}
#endif

See also: https://github.com/dotnet/runtime/blob/master/src/libraries/System.Private.CoreLib/src/System/Diagnostics/CodeAnalysis/NullableAttributes.cs
See also: https://www.thinktecture.com/en/net-core/c-8-nullable-reference-types-in-net-standard-21-and-net-4x/
See also: https://www.meziantou.net/how-to-use-nullable-reference-types-in-dotnet-standard-2-0-and-dotnet-.htm

@304NotModified 304NotModified mentioned this issue Feb 27, 2021
Merged
@NLog NLog deleted a comment from snakefoot Feb 28, 2021
@NLog NLog deleted a comment from snakefoot Feb 28, 2021
@NLog NLog deleted a comment from snakefoot Feb 28, 2021
@NLog NLog deleted a comment from snakefoot Feb 28, 2021
@304NotModified
Copy link
Member

VS2019 build had been fixed and removed out-to-date discussion. Up for grabs again :)

@snakefoot snakefoot modified the milestones: 5.0 (new), 6.0 May 19, 2021
@snakefoot
Copy link
Contributor Author

With help from Nullable-nuget-package, then all platforms can feel the happiness (Ensure PrivateAssets="All")

@snakefoot snakefoot mentioned this issue Sep 3, 2022
Closed
@snakefoot
Copy link
Contributor Author
snakefoot commented Mar 29, 2023 •
edited
Loading

Alternative package PolySharp is now available, that also enables support for InterpolatedStringHandler

@snakefoot snakefoot mentioned this issue Dec 31, 2024
Closed
This was referenced May 6, 2025
Merged
Merged
Merged
Merged
Merged
Merged
@snakefoot
Copy link
Contributor Author
snakefoot commented May 11, 2025 •
edited
Loading

Interesting challenge is the NLog-attribute [Required] which says that class-reference must be assigned.

If class-reference is required, then it should not be marked as nullable but be assigned initial-value. But when never null, then [Required] gives little value.

Unless the initial-dummy-value is a special value that is recognized by the [required]-validation, as not correctly assigned.

Alternative stop relying on [required]-attribute together with the reflection logic (would be nice with less reflection), and instead expect users to validate as part of initialization when necessary.

This was referenced May 11, 2025
Closed
Merged
Merged
This was referenced May 19, 2025
Merged
Merged
This was referenced May 22, 2025
Merged
Merged
Merged
Merged
@snakefoot
Copy link
Contributor Author

Nullable references have now been added to all nuget-package-projects in this repository.

Guess the adventure will continue in the other repositories.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Assignees
No one assigned
Labels
breaking change Breaking API change (different to semantic change) up-for-grabs
Projects
None yet
Milestone
6.0
Development

No branches or pull requests
2 participants
@304NotModified @snakefoot
0