preserve retain variable between function calls

[ctw1000]

Is there (I'd like) an easy way to preserve a variable value between function calls ?

not a class variable declared outside the function.
And not wrapped in something like a mini class.

But something simple and non-verbose.

Like

class MyClass
{
void AddFunction()
{
preserved int thisIntKeepsItsValue = 1;
//
thisIntKeepsItsValue++;
}
}

Because I want the scope of it limited to the function.

My invented 'preserved' keyword here would give it the life-time of the class too,
ie it wouldn't be 'static'

[foxesknow]

What's wrong with just having a class level static variable?

[ctw1000]

Yes - sure - that would work.

but
I write in a mix of C / C++ / C# depending on the month.
In C or C++ we can happily put a static variable in a function.

C# disallows this but we can make a class variable instead.
(it can be 'static' but it doesn't even need to be so long as its
got the lifetime of the class instance).

But isn't this a forum for saying we want more??!

In a large class I don't want the confusion of
"which function uses this variable".
Where I've made a class variable ONLY because the language
has forced me to do it and its only relevant to this single
function that wants to retain a value between calls.
ie I want the scope limited.

In C# I always end up sticking it below the function like this:

class MyClass
{
void FirstFunction()
{
}

void SecondFunction()
{
m_variableThatKeepsItsValue++;
}
//--- this stuff used in the above function only ---
int m_variableThatKeepsItsValue = 1;
//---
}

.... and to edit my own writings... having a static is not the same as
giving it class lifetime so the static-var-inside-a-function that you can
have in C or C++ is still not as nice as it could be with a say
void MyFunc()
{
preserved int thisVarHasLifeTimeOfTheOwningClassInCplusplusOrCsharp___orIsBasicallyStaticIfItsIn_C = 1;
}

(what if you want multiple instances of the class, each with one of these....)

So I want this feature in C++ as well !

[ufcpp]

#832

[TahirAhmadov]

Specifically, there is discussion in that thread about method-local instance fields, which is what I think the OP is asking for.

[MillKaDe]

... And not wrapped in something like a mini class. ...

Try a mini struct instead: code at SharpLab

using static System.Console;

var mc1 = new MyClass ();
var mc2 = new MyClass ();
mc1.SecondFunction ();
mc1.SecondFunction ();
mc1.SecondFunction ();
mc2.SecondFunction ();
mc2.SecondFunction ();
var vmc1 = mc1.GetVar;
var vmc2 = mc2.GetVar;
WriteLine ($"mc1 should be 3: {vmc1}");
WriteLine ($"mc2 should be 2: {vmc2}");

public class MyClass {
  public void FirstFunction () { }
  struct SecondFunctor {
    int varThatKeepsItsValueBetweenCalls;
    internal void SecondFunction () {
      varThatKeepsItsValueBetweenCalls++;
    } 
    public int GetVar => varThatKeepsItsValueBetweenCalls;
  }
  SecondFunctor sf;  
  public void SecondFunction () => sf.SecondFunction ();
  public int GetVar => sf.GetVar;
}

This wraps the 'SecondFunction' and its 'varThatKeepsItsValueBetweenCalls' in an embedded struct 'SecondFunctor'.
Since it is a struct, there will be no extra heap allocation.

If you check out the generated code (click SharpLab link above) in release mode, you will notice that the Jitter inlined the mini struct 'SecondFunctor', its variable 'varThatKeepsItsValueBetweenCalls' and the struct member function 'SecondFunction'.
The generated code is pretty much the same that would have been generated without that inner struct 'SecondFunctor', so there is no runtime penalty.

But in the source, you have full control about who has access to what.

And in C/C++ it should work too.

[ctw1000]

Yes you've solved the problem of a variable keeping its value.

But why is this any improvement on having a private integer class member?

The problem I want the answer to
besides being a short non-verbose solution, ie 'not wrapping' something up)

• is to prevent anything else from inside of the class accessing this integer.

In your example I can still change the variable
'varThatKeepsItsValueBetweenCalls'
from anywhere in the class through 'sf'.

as I've done now in 'FirstFunction' below

public class MyClass
{
public void FirstFunction ()
{
sf.SecondFunction(); //<---- ##### we can still access sf' from here. #####
}

struct SecondFunctor
{
int varThatKeepsItsValueBetweenCalls;
internal void SecondFunction () {
varThatKeepsItsValueBetweenCalls++;
}
public int GetVar => varThatKeepsItsValueBetweenCalls;
}

SecondFunctor sf;

public void SecondFunction () => sf.SecondFunction ();

public int GetVar => sf.GetVar;
}

Perhaps your solution makes it visually clear that I shouldn't be accessing
it from elsewhere as you have to access something called 'secondFunctor'.
(suggesting it is related to secondFunction)

• ok.
  And also I can only do to it what the SecondFunctor() func can do to it - in this
  case add 1. - ok

But it still doesn't STOP anyone from calling this func and effecting it.

[HaloFour]

If you want to create a new form of accessibility you can use an analyzer to do so.

[MillKaDe]

... is to prevent anything else from inside of the class accessing this integer.
In your example I can still change the variable
'varThatKeepsItsValueBetweenCalls'
from anywhere in the class through 'sf'.

No, you cannot.
'varThatKeepsItsValueBetweenCalls' is a private field in (nested) struct 'SecondFunctor', so only member functions or properties of struct 'SecondFunctor' are able to read or write that field.
See SharpLab

  public void ThirdFunction () {
    var x = sf.varThatKeepsItsValueBetweenCalls;
    // error CS0122: 'MyClass.SecondFunctor.varThatKeepsItsValueBetweenCalls' is inaccessible due to its protection level
  }

public class MyClass { public void FirstFunction () { sf.SecondFunction(); //<---- ##### we can still access sf' from here. ##### }

That is an indirect access through struct member function 'SecondFunctor.SecondFunction ()', so it is a controlled access.
You can neither read nor write 'varThatKeepsItsValueBetweenCalls' directly.
Of course, you can trigger incrementing it as a side effect of calling 'MyClass.SecondFunction ()', exactly as in your original code.

Perhaps your solution makes it visually clear that I shouldn't be accessing it from elsewhere as you have to access something called 'secondFunctor'. (suggesting it is related to secondFunction)
But it still doesn't STOP anyone from getting at it.

No, its not only visual - the compiler blocks any access from outside of nested struct 'secondFunctor'.

[ctw1000]

Um.
The large font was an accident in the above case.
I thought it weird when it appeared large but then maybe it was because
it does this with the most recent comment not because of my font.

But it seems I did it somehow. I am not shouting!

(that is a calm and quiet exclamation mark too. haha).

[ctw1000]

Ah! Just experimented. if you put a single dash character between the paragraphs it makes everything bold.
Markup etc. Accident.

[CyrusNajmabadi]

Thanks very much for fixing it! :)

[TahirAhmadov]

@ctw1000 if you add your voice to #832 asking for method-scope instance locals, it would raise the chances of that proposal becoming championed, albeit it wouldn't guarantee it obviously.
Also it would be great if you proposed answers to some of the detail questions, such as, when is the local initialized, what happens if the same method is called from multiple threads, etc.

[ctw1000]

OK - just done it. :)
(at the bottom)