Inline Constant Strings

[danatcofo]

local constants are wonderful, they allow me to keep my value close to its use case. For most types, the versatility of the local constants is sufficient. However I would propose the ability to declare an inline const string.

For example.

I have a usecase where I am doing a db query against a local sqlite database to provide metrics and the query looks something like this.

SELECT COUNT(1) AS Value FROM MyTable

And this is done several times. Due to this being done inside a synchronous action used by the CreateObservableGuage method, I wrote a local function that looks something like this.

int ExecuteCount(string sql)
{
    var task = Policies.AttemptAndRetryLockedDb(() => provider
        .ExecuteSqlReaderAsync<CountRecord>(sql)
        .FirstOrDefaultAsync().AsTask());
    if (task.Status != TaskStatus.RanToCompletion) task.RunSynchronously();
    return task.Result?.Value ?? 0;
}

Now my calls to CreateObservableGuage look like this.

Meter.CreateObservableGauge("metric.name",
  () =>
  {
      const string sql = "SELECT COUNT(1) AS Value FROM MyTable";
      return ExecuteCount(sql);
  });

Ideally I would like it to be something. more like this however but using an inline const.

Meter.CreateObservableGauge("metric.name",  
   () => ExecuteCount("SELECT COUNT(1) AS Value FROM MyTable"));

Now strings already have some modifiers you can add to them such as verbatim @ & interpolated $ so I propose that a constant modifier or format is added. Some ideas that come to mind are.

• back tick formatting

  `SELECT COUNT(1) AS Value FROM MyTable`
  $`SELECT COUNT(1) AS Value FROM {nameof(DbContext.MyTable)}`
  

• hashtag

  #"SELECT COUNT(1) AS Value FROM MyTable"
  #$"SELECT COUNT(1) AS Value FROM {nameof(DbContext.MyTable)}"
  

This would allow me to do this for example

Meter.CreateObservableGauge("metric.name",  
   () => ExecuteCount(#"SELECT COUNT(1) AS Value FROM MyTable"));

Meter.CreateObservableGauge("metric.name",  
   () => ExecuteCount(#$"SELECT COUNT(1) AS Value FROM {nameof(DbContext.MyTable)}"));
   
Meter.CreateObservableGauge("metric.name",  
   () => ExecuteCount(`SELECT COUNT(1) AS Value FROM MyTable`));

Meter.CreateObservableGauge("metric.name",  
   () => ExecuteCount($`SELECT COUNT(1) AS Value FROM {nameof(DbContext.MyTable)}`));

[HaloFour]

The compiler is already capable of treating simple string literal concatenation or interpolation as a constant, without any additional syntax:

const string sql1 = "SELECT COUNT(1) AS Value FROM " + nameof(DbContext.MyTable);
const string sql2 = $"SELECT COUNT(1) AS Value FROM {nameof(DbContext.MyTable)}";

[HaloFour]

Can you explain what you mean by "inline constant" and how that differs from normal constants today?

[danatcofo]

I provided a usecase to explain this.

Meter.CreateObservableGauge("metric.name",  
   () => ExecuteCount(#"SELECT COUNT(1) AS Value FROM MyTable"));

Meter.CreateObservableGauge("metric.name",  
   () => ExecuteCount(#$"SELECT COUNT(1) AS Value FROM {nameof(DbContext.MyTable)}"));
   
Meter.CreateObservableGauge("metric.name",  
   () => ExecuteCount(`SELECT COUNT(1) AS Value FROM MyTable`));

Meter.CreateObservableGauge("metric.name",  
   () => ExecuteCount($`SELECT COUNT(1) AS Value FROM {nameof(DbContext.MyTable)}`));

note- updated the original to include this example at the end.

[HaloFour]

Those are already literals/constants, though. Why do you need a different syntax?

These produce identical IL byte code:

public void M1() {
    const string sql = "SELECT COUNT(1) AS Value FROM MyTable";
    Test(sql);
}

public void M2() {
    Test($"SELECT COUNT(1) AS Value FROM {nameof(DbContext.MyTable)}");
}

[danatcofo]

oh, nice... I think I just misunderstood how the compiler treated all of that then. Thanks so much!