define - declare constant in c#




Definizione della variabile locale const vs Class const (4)

Se sto usando una costante che è necessaria solo in un metodo , è meglio dichiarare la const all'interno dell'ambito del metodo o nell'ambito della classe? C'è una migliore performance dichiarandola nel metodo? Se ciò è vero, penso che sia più normale definirli nell'ambito della classe (parte superiore del file) per modificare il valore e ricompilare più facilmente.

public class Bob
{
   private const int SomeConst = 100; // declare it here?
   public void MyMethod()
   {
      const int SomeConst = 100; // or declare it here?
      // Do soemthing with SomeConst
   }
}

Cerco di definire costanti / variabili solo nel minimo ambito di cui ho bisogno. In questo caso, se lo stai usando solo all'interno di MyMethod , lascialo lì.

Rende più chiaro allora, dove si applica la costante / variabile e salva anche il dover controllare (anche se si tratta di un controllo di compilazione) se la costante è riferita altrove.

Un'eccezione a questa potrebbe essere qualcosa che è "costoso" (in termini di tempo) per creare / calcolare, quindi potrei volere che abbia definito un'istanza o un campo statico, quindi devo calcolarlo una sola volta.


Dipende da dove vuoi usarlo, se vuoi usarlo in altri modi definirlo nella classe, se lo userai solo in un metodo definirlo nel metodo che stai per usarlo :)


Ecco un piccolo benchmark che ho fatto per valutare gli scenari;

Il codice:

using System;
using System.Diagnostics;

namespace TestVariableScopePerformance
{
    class Program
    {
        static void Main(string[] args)
        {
            TestClass tc = new TestClass();
            Stopwatch sw = new Stopwatch();

            sw.Start();
            tc.MethodGlobal();
            sw.Stop();

            Console.WriteLine("Elapsed for MethodGlobal = {0} Minutes {1} Seconds {2} MilliSeconds", sw.Elapsed.Minutes, sw.Elapsed.Seconds, sw.Elapsed.Milliseconds);
            sw.Reset();

            sw.Start();
            tc.MethodLocal();
            sw.Stop();

            Console.WriteLine("Elapsed for MethodLocal = {0} Minutes {1} Seconds {2} MilliSeconds", sw.Elapsed.Minutes, sw.Elapsed.Seconds, sw.Elapsed.Milliseconds);

            Console.WriteLine("Press any key to continue...");
            Console.ReadKey();
        }


    }

    class TestClass
    {
        const int Const1 = 100;

        internal void MethodGlobal()
        {
            double temp = 0d;
            for (int i = 0; i < int.MaxValue; i++)
            {
                temp = (i * Const1);
            }
        }

        internal void MethodLocal()
        {
            const int Const2 = 100;
            double temp = 0d;
            for (int i = 0; i < int.MaxValue; i++)
            {
                temp = (i * Const2);
            }
        }
    }
}

I risultati di 3 iterazioni:

Elapsed for MethodGlobal = 0 Minutes 1 Seconds 285 MilliSeconds
Elapsed for MethodLocal = 0 Minutes 1 Seconds 1 MilliSeconds
Press any key to continue...

Elapsed for MethodGlobal = 0 Minutes 1 Seconds 39 MilliSeconds
Elapsed for MethodLocal = 0 Minutes 1 Seconds 274 MilliSeconds
Press any key to continue...

Elapsed for MethodGlobal = 0 Minutes 1 Seconds 305 MilliSeconds
Elapsed for MethodLocal = 0 Minutes 1 Seconds 31 MilliSeconds
Press any key to continue...

Immagino che l'osservazione concluda @ risposta jnm2.

Esegui lo stesso codice dal tuo sistema e facci sapere il risultato.


Lo metterei nel metodo stesso. Non sono un fan delle variabili che sono in giro quando non hanno bisogno di essere lì.





jit