Always initialized (not null) reference types (fields, props, parameters, returned values)

[andrey-messi]

Sometimes it is necessary that a parameter of reference type passed to a function always be initialized. For example see here sources of List:
https://github.com/Microsoft/referencesource/blob/master/mscorlib/system/collections/generic/list.cs

public List(IEnumerable<T> collection) {
	if (collection==null)
		ThrowHelper.ThrowArgumentNullException(ExceptionArgument.collection);
	//then do something with the collection

Or I think it can be so:

public List(IEnumerable<T> collection) {
	if (collection==null)
		throw new ArgumentNullException(nameof(collection));
	//then do something with the collection

It throws an exception every time when the parameter 'collection' is null.

I think it would be good to simplify this code with a feature that requires a type to be guaranteed initialized. Just add a symbol '!' at the end of a type. For example, this code:

public MyClass(string! parameter) {
	//do something with the parameter
}
public static MyClass CreateNewMyClass()
{
	return new MyClass(null);
}

should show an error at compile-time. But this code:

public MyClass(string parameter) {
	//do something with the parameter
}
public static MyClass CreateNewMyClass()
{
	return new MyClass("a");
}

should be compiled successfully.
When a constructor
public MyClass(string! parameter)
is a part of API available for third-party applications and developers then it becomes even more important to have a possibility to mark a type as '!' because other developers that will use my API will see that a parameter type is "string!" and not "string", so they know that they can't pass null.

Another examples:

interface MyInterface
{
	string! GetMoreLong(string! one, string! another);
}
class MyClass: MyInterface
{
	string! MyInterface.GetMoreLong(string! one, string! another)
	{
		// Compile-time error 
		return null;
		// This works
		return one.Length > another.Length ? one : another;
	}
}

and

    class MyClass
    {
        public string! Prop { set; get; }
        public string GetInitialized()
        {
            // there is a bug in GetInitialized function and it accidentally returns null
            return null;
        }
    }

    internal static class Program
    {
        private static void Func1(MyClass! obj)
        {
            // Compile-time error
            obj.Prop = null;
            // Compile-time error if analyzer can find out that GetInitialized always returns null, in other case run-time exception
            var! initialized = obj.GetInitialized();
        }
    }

and

    class MyClass
    {
        public string! Prop { set; get; }
        public string! Prop2 { set; get; } = "Initialized";
		public MyClass()
		{			
		}
		public MyClass(string! par)
		{
			Prop = par;
		}
    }

    internal static class Program
    {
        private static void Func1()
        {
            // Compile-time error because because Propobj.Prop is not initialized after object have been constructed 
			var! obj = new MyClass();
            // Working
			var! obj2 = new MyClass(){ Prop = "Initialized" };
            // Working
			var! obj3 = new MyClass("Initialized");
        }
    }

When it can't be checked at compile-time then it should throw a run-time exception. For example, ArgumentNullException(nameof(p)) in this function:
public Func1(string! p)

[Joe4evr]

#36

To be clear, what you're asking for is going to be the default behavior of an un-annotated reference type when you opt-in to Nullable Reference Types. You can play around with this today.

[MgSam]

I suggest that you read the C# Blog and use the GitHub search before opening new feature requests.

[andrey-messi]

@MgSam Ok I will. I just didn't realize that I'm too late with my proposals. I stored in a txt-file all proposals, improvements and bugs I found over the years and now at last I have time to ask for them in github :)

[MkazemAkhgary]

This is very nice, I think warning is not enough. assigning string to string! should also cause compile time error. unless its cast to string!. this will make method contracts much simpler. you don't have to null check every input. because its guaranteed reference is not null.

this will also make programs less error prone and slightly faster.