define - declare constant in c#




Definizione della variabile locale const vs Class const (4)

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.

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
   }
}

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