[c# Feature Request] CallerUniqueIdAttribute

[jcouv]

@ramoneeza commented on Fri Dec 01 2017

The Caller(Members/File/Line) Attributes are very useful in "restricted to class" scenarios like "INotifyChanged" interfaces or exceptions.

But It is not complete in a "per application/library" scenario. (Example "Static variables", "Persistent Variables", etc.)

Stackoverflow has an example of "StaticLocal" implementation showing the problem:
https://stackoverflow.com/questions/2393156/does-c-sharp-support-the-use-of-static-local-variables

public static class StaticLocal<T>
{
    static StaticLocal()
    {
        dictionary = new Dictionary<int, Dictionary<string, Access>>();
    }

    public class Access
    {
        public T Value { get; set; }

        public Access(T value)
        {
            Value = value;
        }

    }

    public static Access Init(T value, [CallerFilePath]string callingFile = "",
                                       [CallerMemberName]string callingMethod = "",
                                       [CallerLineNumber]int lineNumber = -1)
    {
        var secondKey = callingFile + '.' + callingMethod;
        if (!dictionary.ContainsKey(lineNumber))
            dictionary.Add(lineNumber, new Dictionary<string, Access>());
        if (!dictionary[lineNumber].ContainsKey(secondKey))
            dictionary[lineNumber].Add(secondKey, new Access(value));
        return dictionary[lineNumber][secondKey];
    }

    private static Dictionary<int, Dictionary<string, Access>> dictionary;

}
//It can be implemented within a method like this:

var myVar = StaticLocal<int>.Init(1);
Console.Writeline(++myVar.Value);

A real solution with a "CallerUniqueIdAttribute" simplifies that kind of variables:

public static class StaticLocal<T>
{
    private static Dictionary<int,Access> dictionary=new Dictionary<int,Access>();
    public class Access
    {
        public T Value { get; set; }
        public Access(T value)
        {
            Value = value;
        }
    }
    public static Access Init(T value, [CallerUniqueId]int callingUniqueId = -1)
    {
        if (!dictionary.ContainsKey(callingUniqueId))
            dictionary.Add(callingUniqueId,new Access(value));
        return dictionary[callingUniqueId];
    }
}

[...]
var myVar = StaticLocal<int>.Init(1);
Console.Writeline(myVar.Value);
[..]

I think, it is very simple to the compiler to have a simple counter giving an unique interger value for each [CallerUniqueId] attribute instance when appears.

---

@CyrusNajmabadi commented on Fri Dec 01 2017

I'm confused. You have a working solution that doesn't need this new attribute. So why would we need to add this new attribute?

---

@CyrusNajmabadi commented on Fri Dec 01 2017

I think, it is very simple to the compiler to have a simple counter giving an unique interger value for each [CallerUniqueId] attribute instance when appears.

It's wouldn't be. Furthermore, it wouldn't be sufficient. Take a simple example:

You have this code in your Util.dll library:

    public static Access Init(T value, [CallerUniqueId]int callingUniqueId = -1)
    {
        if (!dictionary.ContainsKey(callingUniqueId))
            dictionary.Add(callingUniqueId,new Access(value));
        return dictionary[callingUniqueId];
    }

Then you have two projects ProjectA and ProjectB that reference that dll. In each of those projects you do:

var myVar = StaticLocal<int>.Init(1);
Console.Writeline(myVar.Value);

The compiler will use the uniqueId '0' for each of these since you've only specified "a simple counter". And now ProjectA and ProjectB will both be updating the same variable, violating the desire for this to represent a static local.

---

@ramoneeza commented on Fri Dec 01 2017

CallerUniqueId must be a "GUID" or a Hash calculated from Module Hash ^ Method.Hash

Implementation of Static Variables ( C++ Style) for Regex, Timers, etc... should be fast enough.

Using several string attributes is not fast.

There are several algorithms and structures (not only static variables) that can make use of this Member Attribute. (And avoid reflection)

---

@ramoneeza commented on Fri Dec 01 2017

AS easy as make [CallerUniqueId] = [CallerFilePath].Hash ^ [CallerMemberName].Hash ^ [CallerLineNumber] at compiler time.

Or enable [CallerFilePath] and [CallerMemberName] as long type (it implies hash calculation at compile time)

---

@jcouv commented on Sun Dec 03 2017

I'll go ahead and move to csharplang since this is a language design discussion, not a compiler bug. Thanks

[CyrusNajmabadi]

Still not understanding why the existing solution is insufficient.

[yaakov-h]

Pulling code off Stack Overflow and using that as a shining example of code isn't a good idea in general 😄

The existing solution is based off caller location in source code, so it doesn't work for generics.

For example:

using System;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
					
public class Program
{
	public static void Main()
	{
		Console.WriteLine(GenericThing<int>.GetValue());
		Console.WriteLine(GenericThing<short>.GetValue());
		Console.WriteLine(GenericThing<bool>.GetValue());
	}

	public static class GenericThing<T>
	{
		public static int GetValue()
		{
			var myVar = StaticLocal<int>.Init(1);
			return ++myVar.Value;
		}
	}

	public static class StaticLocal<T>
	{
		static StaticLocal()
		{
			dictionary = new Dictionary<int, Dictionary<string, Access>>();
		}

		public class Access
		{
			public T Value { get; set; }

			public Access(T value)
			{
				Value = value;
			}

		}

		public static Access Init(T value, [CallerFilePath]string callingFile = "",
										   [CallerMemberName]string callingMethod = "",
										   [CallerLineNumber]int lineNumber = -1)
		{
			var secondKey = callingFile + '.' + callingMethod;
			if (!dictionary.ContainsKey(lineNumber))
				dictionary.Add(lineNumber, new Dictionary<string, Access>());
			if (!dictionary[lineNumber].ContainsKey(secondKey))
				dictionary[lineNumber].Add(secondKey, new Access(value));
			return dictionary[lineNumber][secondKey];
		}

		private static Dictionary<int, Dictionary<string, Access>> dictionary;

	}
}

The output of this program I would think should be 2 2 2, but it's 2 3 4 (I have removed newlines to keep it simple).

I feel like the entire premise for this feature request is off, though. If you had static local variables, you could just do:

void Foo()
{
    readonly static MyUniqueKeyForThisScope = Guid.NewGuid();

    // Hey look, now I have a caller unique ID... and even better, I don't need StaticLocal<T>
}

[ramoneeza]

This is not about to have an UniqueId... this is about have an uniqueid for the CALLER to a function.

C# lacks of "static variables" or "persistent variables" and the implementation NEEDs a real automatic UNIQUEID for the caller.

In that scenario, Generics is not a problem.

[yaakov-h]

C# lacks of "static variables" or "persistent variables" and the implementation NEEDs a real automatic UNIQUEID for the caller.

Or, alternatively, C# could get static function-local variables...

[yaakov-h]

Also, if another (there's got to be a proper name for these) callsite-compiler-modified attribute was added like you're suggesting, how would it handle generics?

[ramoneeza]

Each StaticLocal has his own Dictionary... So...

var a=StaticLocal<int>(1);
var b=StaticLocal<Mygeneric<int>>(default);
var c=StaticLocal<Another<int,double>>(default);

"a, b, c" goes to different Dictionaries

(Different StaticLocal instances with different static dictionary instances)

[yaakov-h]

Yes, but if you had a look at the code I posted above, you would see why a callsite-generated static identifier doesn't help when you have a generic caller.

[ramoneeza]

Don't forget the aim of this post... "Static / Persistent local variables".

If addition of new caller attributes (I think it is useful fingerprinting caller attributes to long) is not enough change the compiler syntax can be an option:

public int GetValue(){
     static int data=1;
    return data++;
}
public static int AnotherValue(){
     static int stvalue=1;
    return stvalue++;
}

it is compiled as:

public int GetValue(){
    return _getvalue_data++;
}
private int _getvalue_data=1;

public static int AnotherValue(){
    return _anothervalue_stvalue++;
}
private static int _anothervalue_stvalue=1;

[yaakov-h]

@ramoneeza If that was the actual aim, you have a lot of room for improvement in your communications skills.

The original issue was named "CallerUniqueIdAttribute".

You also said:

A real solution with a "CallerUniqueIdAttribute"...