"ClickOnce non supporta il livello di esecuzione della richiesta 'requireAdministrator.'"

Quindi stavo scrivendo un'applicazione che richiede l'accesso al registro. Non avevo toccato alcuna impostazione di build, volendo far funzionare la cosa prima di aggiungere gli altri tocchi, come una descrizione o un nome.

Di punto in bianco, ottengo un errore che non andrà via. ClickOnce does not support the request execution level 'requireAdministrator'.Ora, non avevo toccato ClickOnce in questa applicazione. Tutto quello che avevo fatto era includere un file manifest che richiede queste autorizzazioni.

Il mio problema ora è che questo errore non scompare e non posso compilare il mio programma. Qualche consiglio su cosa fare? (Nota a margine: sto per andare a letto, quindi controllerò domani pomeriggio).

Modifica: anche questo commento fornisce una buona risposta.

Fare clic una volta per attivare l'attivazione ogni volta che si fa clic su "Pubblica", che lo si desideri o meno! Se stai usando "requireAdministrator", sembra che non puoi usare ClickOnce, e quindi non puoi "pubblicare" il tuo progetto.

Originale:

Si scopre che nella scheda Sicurezza, "Abilita impostazioni di sicurezza ClickOnce" è stato selezionato. Anche se non l'ho controllato. Ad ogni modo, deselezionando quel ClickOnce mi ha interrotto dando errori. Ci è voluto un po 'per trovare ...

So che questa è una vecchia domanda ma sono venuto qui due anni dopo, quindi:

È possibile disabilitare ClicKOnce dalla scheda Sicurezza nelle proprietà del progetto per risolvere il problema; vedi sotto:

Se utilizzi mai la procedura guidata di pubblicazione o "Pubblica ora", la casella di controllo con un clic viene selezionata automaticamente ...

So che questo è vecchio ma mi sono imbattuto in esso alla ricerca di risposte. Nel mio caso, sto utilizzando la funzione di pubblicazione e devo continuare a utilizzarla. Ho anche bisogno di accedere alle funzionalità di amministrazione. Quindi, per questo motivo, nessuna delle risposte precedenti ha funzionato per me.

Ho finito per aggiungere un metodo all'inizio della mia applicazione che controlla se viene eseguito come amministratore e, in caso contrario, riavvia se stesso come amministratore. Per fare ciò, è necessario aggiungere i seguenti riferimenti.

using System;
using System.Diagnostics;
using System.Reflection;
using System.Security.Principal;

Quindi dovrai metterlo da qualche parte a cui il tuo metodo principale abbia un comodo accesso. Sto usando WPF, quindi l'ho aggiunto a MainWindow.xaml.cs ma puoi aggiungerlo ovunque all'inizio del codice. Ricorda solo di aggiungere "statico" a questi metodi se ne hai bisogno.

private void AdminRelauncher()
{
    if (!IsRunAsAdmin())
    {
        ProcessStartInfo proc = new ProcessStartInfo();
        proc.UseShellExecute = true;
        proc.WorkingDirectory = Environment.CurrentDirectory;
        proc.FileName = Assembly.GetEntryAssembly().CodeBase;

        proc.Verb = "runas";

        try
        {
            Process.Start(proc);
            Application.Current.Shutdown();
        }
        catch(Exception ex)
        {
            Console.WriteLine("This program must be run as an administrator! \n\n" + ex.ToString());
        }
    }
}

private bool IsRunAsAdmin()
{
    try
    {
        WindowsIdentity id = WindowsIdentity.GetCurrent();
        WindowsPrincipal principal = new WindowsPrincipal(id);
        return principal.IsInRole(WindowsBuiltInRole.Administrator);
    }
    catch (Exception)
    {
        return false;
    }
}

Infine, all'inizio del programma, aggiungi un riferimento al metodo. Nel mio caso, l'ho aggiunto a MainWindow ma aggiungendolo anche a Main funziona.

public MainWindow()
{
    InitializeComponent();
    AdminRelauncher(); //This is the only important line here, add it to a place it gets run early on.
}

Spero che questo ti aiuti!

Questa azione può essere ottenuta selezionando "Abilita impostazioni di sicurezza ClickOnce" (poiché non può essere "deselezionata" durante una pubblicazione, come indicato) e quindi selezionando "Questa è un'applicazione attendibile parziale". "Intranet locale" verrà selezionato automaticamente nel menu a discesa, il che va benissimo.

Salvare le modifiche, pubblicare l'applicazione, sci fatto. :-)

Dai un'occhiata al tuo file app.Manifest e vedrai questo:

 <requestedExecutionLevel  level="requireAdministrator" uiAccess="false" />

Ci sono istruzioni lì nei commenti, ma semplicemente eliminando "requireAdministrator" e inserendolo nel posto ho risolto il problema:

 <requestedExecutionLevel  level="asInvoker" uiAccess="false" />

Ho lo stesso problema s Lo risolvo deselezionando " Abilita impostazioni di sicurezza ClickOnce" Per trovare questa opzione in Visual Studio Fai clic con il pulsante destro del mouse sul tuo progetto ==> proprietà ==> Seleziona Sicurezza ==> Abilita impostazioni di sicurezza ClickOnce (Questa opzione era già selezionato, quindi l'ho deselezionato e il mio problema viene risolto).

Ecco lo snippet di codice per VB.NET

If Not New WindowsPrincipal(WindowsIdentity.GetCurrent).IsInRole(WindowsBuiltInRole.Administrator) Then
            Process.Start(New ProcessStartInfo With { _
                                                     .UseShellExecute = True, _
                                                     .WorkingDirectory = Environment.CurrentDirectory, _
                                                     .FileName = Assembly.GetEntryAssembly.CodeBase, _
                                                     .Verb = "runas"})

EDIT: Ma se distribuisci in questo modo, alcuni software AV bloccano il tuo codice.

Per coloro che utilizzano deselezionare "Abilita impostazioni di sicurezza ClickOnce" non può funzionare, per provare il metodo che trovo.

Innanzitutto, lascia il tuo elemento app.manifest requestExecutionLevel così com'è:

<requestedExecutionLevel level="asInvoker" uiAccess="false" />

E poi modifichi il tuo file Program.cs in questo modo:

using System;
using System.Diagnostics;
using System.Reflection;
using System.Security.Principal;
using System.Windows.Forms;

ristrutturare il metodo principale come:

    static void Main()
        {
            var wi = WindowsIdentity.GetCurrent();
            var wp = new WindowsPrincipal(wi);

            bool runAsAdmin = wp.IsInRole(WindowsBuiltInRole.Administrator);

            if (!runAsAdmin)
            {
                // It is not possible to launch a ClickOnce app as administrator directly,
                // so instead we launch the app as administrator in a new process.
                var processInfo = new ProcessStartInfo(Assembly.GetExecutingAssembly().CodeBase);

                // The following properties run the new process as administrator
                processInfo.UseShellExecute = true;
                processInfo.Verb = "runas";

                // Start the new process
                try
                {
                    Process.Start(processInfo);
                }
                catch (Exception)
                {
                    // The user did not allow the application to run as administrator
                    MessageBox.Show("Sorry, but I don't seem to be able to start " + 
                       "this program with administrator rights!");
                }

                // Shut down the current process
                Application.Exit();
            }
            else
            {
                // We are running as administrator
                Application.EnableVisualStyles();
                Application.SetCompatibleTextRenderingDefault(false);
                Application.Run(new Form1());
            }
        }

Funziona su Windows 10 e Visual Studio 2019!

Per chiunque si sia imbattuto in questo, ho pensato di contribuire con ciò che alla fine ha funzionato per me.

Sì, l'opzione "Abilita impostazioni di sicurezza ClickOnce" viene ricontrollata automaticamente, se la deselezioni, quando esegui Compila> Pubblica .

Per me, non ho bisogno di "pubblicare": è un file .exe semplice e portatile che crea attività pianificate per i miei utenti e dovevo assicurarmi che fosse elevato, anche quando si accedeva come amministratore.

Quindi ho appena preso il mio ultimo .exe da \ bin \ Release ed è quello che viene distribuito sui sistemi dei miei clienti.

Ha funzionato come previsto, ovvero quando lo metto su un sistema con UAC abilitato / alla sua impostazione più alta, il file .exe ha lo "scudo" su di esso e quando lo eseguo, anche se ho effettuato l'accesso come amministratore, si eleva e ottengo il prompt UAC.

La mia piccola app di pianificazione delle attività è ora in grado di creare l'attività senza ricevere un errore di "Accesso negato" (che in precedenza poteva essere aggirato solo facendo clic con il pulsante destro del mouse su .exe e facendo clic su Esegui come amministratore).

appena

Imports System.security

e U non riceverà alcun errore e la tua applicazione verrà eseguita come amministratore