c# declare - Definizione della variabile locale const vs Class const



constant #define (6)

Dipende se vuoi usarlo durante la tua lezione. La dichiarazione superiore sarà utilizzabile per tutta la classe, mentre l'altra sarà disponibile solo in MyMethod . Non otterrai alcun incremento delle prestazioni, in entrambi i casi.

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

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.


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 :)


Non vi è alcun guadagno in termini di prestazioni nel trasferire la costante nella classe. Il CLR è abbastanza intelligente da riconoscere costanti come costanti, quindi per quanto riguarda le prestazioni i due sono uguali. Ciò che accade in realtà quando si compila in IL è che i valori delle costanti sono codificati nel programma dal compilatore come valori letterali.

In altre parole, una costante non è una posizione di memoria referenziata. Non è come una variabile, è più come un letterale. Una costante è un letterale sincronizzato su più posizioni nel tuo codice. Quindi spetta a te - anche se è la programmazione più ordinata per limitare l'ambito della costante a dove è rilevante.


A partire da PHP 5.3 ci sono due modi per definire le costanti : usando la parola chiave const o usando la funzione define() :

const FOO = 'BAR';
define('FOO', 'BAR');

La differenza fondamentale tra questi due modi è che const definisce le costanti in fase di compilazione, mentre define definisce in fase di esecuzione. Questo causa la maggior parte degli svantaggi di const . Alcuni svantaggi di const sono:

  • const non può essere utilizzato per definire in modo condizionale le costanti. Per definire una costante globale, deve essere utilizzata nell'ambito più esterno:

    if (...) {
        const FOO = 'BAR';    // invalid
    }
    // but
    if (...) {
        define('FOO', 'BAR'); // valid
    }
    

    Perché vorresti farlo comunque? Un'applicazione comune è verificare se la costante è già definita:

    if (!defined('FOO')) {
        define('FOO', 'BAR');
    }
    
  • const accetta uno scalare statico (numero, stringa o altra costante come true , false , null , __FILE__ ), mentre define() accetta qualsiasi espressione. Poiché PHP 5.6 le espressioni costanti sono consentite anche in const :

    const BIT_5 = 1 << 5;    // valid since PHP 5.6, invalid previously
    define('BIT_5', 1 << 5); // always valid
    
  • const assume un nome semplice e costante, mentre define() accetta qualsiasi espressione come nome. Questo permette di fare cose come questa:

    for ($i = 0; $i < 32; ++$i) {
        define('BIT_' . $i, 1 << $i);
    }
    
  • const è sempre case sensitive, mentre define() consente di definire le costanti insensitive del maiuscolo passando true come terzo argomento:

    define('FOO', 'BAR', true);
    echo FOO; // BAR
    echo foo; // BAR
    

Quindi, quello era il lato negativo delle cose. Ora diamo un'occhiata al motivo per cui personalmente uso sempre const se non si verifica una delle situazioni sopra descritte:

  • const legge semplicemente più bello. È un costrutto linguistico anziché una funzione ed è anche coerente con il modo in cui definisci le costanti nelle classi.
  • const , essendo un costrutto linguistico, può essere analizzato staticamente mediante strumenti automatizzati.
  • const definisce una costante nello spazio dei nomi corrente, mentre define() deve essere passato il nome completo dello spazio dei nomi:

    namespace A\B\C;
    // To define the constant A\B\C\FOO:
    const FOO = 'BAR';
    define('A\B\C\FOO', 'BAR');
    
  • Dal PHP 5.6 le costanti const possono anche essere array, mentre define() non supporta ancora gli array. Tuttavia, gli array saranno supportati per entrambi i casi in PHP 7.

    const FOO = [1, 2, 3];    // valid in PHP 5.6
    define('FOO', [1, 2, 3]); // invalid in PHP 5.6, valid in PHP 7.0
    

Infine, si noti che const può essere utilizzato anche all'interno di una classe o di un'interfaccia per definire una costante di classe o una costante di interfaccia. define non può essere utilizzato a questo scopo:

class Foo {
    const BAR = 2; // valid
}
// but
class Baz {
    define('QUX', 2); // invalid
}

Sommario

A meno che non sia necessario alcun tipo di definizione condizionale o espressiva, utilizzare const s invece di define() s - semplicemente per motivi di leggibilità!





c# .net const jit