Come verificare se un gruppo è stato costruito utilizzando la configurazione di debug o di uscita?

Question

sto iniziando l'implementazione della mia applicazione web e ho bisogno di garanzia che tutti i gruppi che stanno per essere distribuito sono stati costruiti utilizzando la configurazione di uscita. Il nostro sistema è stato sviluppato utilizzando C # /. Net 3.5.

Esiste un modo per raggiungere questo obiettivo?

Answer 1

questo . L'idea è che si ottiene la lista di assemblea attributi utilizzando Assembly.GetCustomAttributes() e cercare DebuggableAttribute e poi trovare se tale attributo ha insieme di proprietà IsJITTrackingEnabled.

    public bool IsAssemblyDebugBuild(Assembly assembly)
    {
        return assembly.GetCustomAttributes(false).OfType<DebuggableAttribute>().Any(da => da.IsJITTrackingEnabled);
    }

Answer 2

Ho amato che David suggerimento, ma si potrebbe anche andare in questo modo (AssemblyInfo.cs):

#if DEBUG
[assembly: AssemblyDescription("Your application assembly (DEBUG version)")]
#else if RELEASE
[assembly: AssemblyDescription("Your application assembly (RELEASE version)")]
#endif

Questo è più umana amichevole, come chiunque può fare clic destro che il montaggio, per selezionare Properties e andare alla scheda Details.

Answer 3

Se è il vostro assemblaggio Credo che utilizzando il attributo AssemblyConfiguration è l'approccio migliore. E 'documentato come "specifica la configurazione di generazione, come ad esempio al dettaglio o di debug, per un assieme."

A seconda delle configurazioni di build si potrebbe avere codice come questo:

#if DEBUG
[assembly: AssemblyConfiguration("Debug")]
#else
[assembly: AssemblyConfiguration("Release")]
#endif

Poi controlla l'attributo di assembly:

public static bool IsAssemblyConfiguration(Assembly assembly, string configuration)
{
    var attributes = assembly.GetCustomAttributes(typeof(AssemblyConfigurationAttribute), false);
    if (attributes.Length == 1)
    {
        var assemblyConfiguration = attributes[0] as AssemblyConfigurationAttribute;
        if (assemblyConfiguration != null)
        {
            return assemblyConfiguration.Configuration.Equals(configuration, StringComparison.InvariantCultureIgnoreCase);
        }
    }
    return true;
}

(lo so R. Schreurs commento a Rubens Farias dice la stessa, ma ho trovare queste informazioni da qualche altra parte prima di vedere il commento quindi credo che questo richiede una voce più importante come una risposta completa al posto di un commento)

Answer 4

Se avete installato Reflector è possibile anche fare clic sul gruppo e il look per l'attributo debuggable ([assembly: debuggable ()]). Nel riquadro Disassemblatore

Answer 5

Supponendo solo configurazione di debug e di uscita, il simbolo DEBUG è definita per impostazione predefinita con configurazione di debug, in modo che il codice qui sotto in AssemblyInfo.cs (sotto cartella Proprietà).

#if DEBUG
[assembly: AssemblyTitle("Debug")]
#else
[assembly: AssemblyTitle("Release")]
#endif

Io uso AssemblyTitle sopra AssemblyDescription come apparirà sul mio Windows 7 immobili Esplora file:

Per chi come Davide e la risposta di stevieg, qui è uno script LINQPad scritto in C #. Per utilizzare lo script, è necessario scaricare LINQPad 5 e assicurarsi che C # programma viene selezionato come mostrato in screenshot qui sotto.

Basta sostituire DLL_FOLDER_PATH al punto da cartella che contiene le DLL da ispezionare.

// TODO - Specify your folder containing DLLs to inspect
static string DLL_FOLDER_PATH = @"C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.0";
void Main()
{
    (from dllPath in Directory.GetFiles(DLL_FOLDER_PATH, "*.dll")
    let assembly = dllPath.SafeLoad()
    let build = assembly == null ? "Error" : (dllPath.SafeLoad().IsAssemblyDebugBuild() ? "Debug" : "Release")
    select new {
        Assembly_Path = dllPath,
        Build = build,
    }).Dump();
}
static class Extensions {
    public static bool IsAssemblyDebugBuild(this Assembly assembly)
    {
        return assembly.GetCustomAttributes(false).OfType<DebuggableAttribute>().Select(da => da.IsJITTrackingEnabled).FirstOrDefault();
    }
    public static Assembly SafeLoad(this string path){
        try{
            return Assembly.LoadFrom(path);
        }
        catch {
            return null;
        }
    }
}

LINQPad 5 può essere scaricato qui .

Answer 6

Non distribuire alla produzione tramite Visual Studio. Se vuoi in Continuous Integration e sceneggiato costruisce (ad esempio con NAnt , o forse qualcosa di più leggibile come FALSO ).

Il F5 chiave non è un processo di compilazione

Per i detrattori che credono che questo non risponde alla domanda, il PO ha scritto:

  

... Ho bisogno di garanzia che tutti i gruppi che stanno per essere   distribuito sono state costruite utilizzando la configurazione di uscita.

garanzia che, utilizzare un server di build, come TeamCity e, eventualmente, uno strumento di gestione delle release come Octopus Deploy . Bloccare i sistemi di produzione in modo che gli sviluppatori devono passare attraverso il processo di build ufficiale.