DISABILITARE ADBLOCK

ADBlock sta bloccando alcuni contenuti del sito

ADBlock errore
risultati trovati: 

DOMANDA

Voglio usare una barra di traccia per cambiare l'opacità di un modulo.

Questo è il mio codice:

decimal trans = trackBar1.Value / 5000;
this.Opacity = trans;

Quando creo l'applicazione, viene visualizzato il seguente errore:

  

Impossibile convertire implicitamente il tipo 'decimale' in 'double' .

Ho provato a usare trans e double ma poi il controllo non funziona. Questo codice ha funzionato bene in un precedente progetto VB.NET.

SOLUZIONE

Un cast esplicito per raddoppiare in questo modo non è necessario:

double trans = (double) trackBar1.Value / 5000.0;

Identificare la costante come 5000.0 (o come 5000d ) è sufficiente:

double trans = trackBar1.Value / 5000.0;
double trans = trackBar1.Value / 5000d;

Se ti va lasciaci una tua opinione

L'articolo ti è stato utile ed è tradotto correttamente?

ALTRI SUGGERIMENTI

Una risposta più generica per la domanda generica "Decimale vs Doppio?": Decimale per i calcoli monetari per preservare la precisione, Doppio per i calcoli scientifici che non essere influenzato da piccole differenze. Poiché Double è un tipo nativo della CPU (la rappresentazione interna è memorizzata in base 2 ), i calcoli effettuati con Double hanno prestazioni migliori di Decimal (che è rappresentato in base 10 internamente).

Il tuo codice ha funzionato bene in VB.NET perché implica implicitamente qualsiasi cast, mentre C # ha sia impliciti che espliciti.

In C # la conversione da decimale a doppio è esplicita man mano che si perde precisione. Ad esempio 1.1 non può essere espresso con precisione come doppio, ma come decimale (vedi " Numeri in virgola mobile - più imprecisi di quanto pensi " per il motivo per cui).

In VB la compilazione è stata aggiunta per te dal compilatore:

decimal trans = trackBar1.Value / 5000m;
this.Opacity = (double) trans;

Quel (doppio) deve essere esplicitamente dichiarato in C #, ma può essere implicito dal compilatore più "tollerante" di VB.

Perché stai dividendo per 5000? Basta impostare i valori minimo e massimo della trackbar tra 0 e 100 e quindi dividere il valore per 100 per la percentuale di opacità. L'esempio di seguito minimo 20 impedisce al modulo di diventare completamente invisibile:

private void Form1_Load(object sender, System.EventArgs e)
{
    TrackBar1.Minimum = 20;
    TrackBar1.Maximum = 100;

    TrackBar1.LargeChange = 10;
    TrackBar1.SmallChange = 1;
    TrackBar1.TickFrequency = 5;
}

private void TrackBar1_Scroll(object sender, System.EventArgs e)
{
    this.Opacity = TrackBar1.Value / 100;
}

Hai due problemi. Innanzitutto, Opacity richiede un valore doppio, non decimale. Il compilatore ti sta dicendo che mentre c'è una conversione tra decimale e doppio, è una conversione esplicita che devi specificare affinché funzioni. Il secondo è che TrackBar.Value è un valore intero e dividendo un int per un int si ottiene un int indipendentemente dal tipo di variabile a cui lo si assegna. In questo caso c'è un cast implicito da int a decimale o doppio - perché non c'è perdita di precisione quando esegui il cast - quindi il compilatore non si lamenta, ma il valore che ottieni è sempre 0, presumibilmente, poiché trackBar.Value è sempre inferiore a 5000. La soluzione è cambiare il codice per usare il doppio (il tipo nativo per Opacity) e fare l'aritmetica in virgola mobile rendendo esplicitamente la costante un doppio - il che avrà l'effetto di promuovere l'aritmetica o raddoppiare trackBar.Value , il che farà la stessa cosa - o entrambi. Oh, e non hai bisogno della variabile intermedia a meno che non sia usata altrove. Suppongo che il compilatore lo ottimizzerebbe comunque,

trackBar.Opacity = (double)trackBar.Value / 5000.0;

A mio avviso, è auspicabile essere il più esplicito possibile. Ciò aggiunge chiarezza al codice e aiuta i tuoi colleghi programmatori che potrebbero eventualmente leggerlo.

Oltre a (o invece di) aggiungere un .0 al numero, puoi usare decimal.ToDouble () .

Ecco alcuni esempi:

// Example 1
double transperancy = trackBar1.Value/5000;
this.Opacity = decimal.ToDouble(transperancy);

// Example 2 - with inline temp
this.Opacity = decimal.ToDouble(trackBar1.Value/5000);

Sembra this.Opacity è un doppio valore e al compilatore non piace che tu provi a inserire un valore decimale in esso.

Dovresti usare 5000.0 invece di 5000 .

La proprietà Opacity è di doppio tipo:

double trans = trackBar1.Value / 5000.0;
this.Opacity = trans;

o semplicemente:

this.Opacity = trackBar1.Value / 5000.0;

o

this.Opacity = trackBar1.Value / 5000d;

Nota che sto usando 5000.0 (o 5000d ) per forzare una doppia divisione perché trackBar1.Value è un numero intero che eseguirà una divisione di numeri interi e il risultato sarebbe essere un numero intero.

Supponendo che tu stia utilizzando WinForms, < code> Form.Opacity è di tipo double , quindi dovresti usare:

double trans = trackBar1.Value / 5000.0;
this.Opacity = trans;

A meno che non sia necessario il valore altrove, è più semplice scrivere:

this.Opacity = trackBar1.Value / 5000.0;

Il motivo per cui il controllo non funziona quando hai cambiato il tuo codice per essere semplicemente un doppio era perché avevi:

double trans = trackbar1.Value / 5000;

che ha interpretato il 5000 come intero, e poiché trackbar1.Value è anche un numero intero il tuo valore trans era sempre zero. Rendendo esplicitamente il valore numerico un valore in virgola mobile aggiungendo il .0 il compilatore può ora interpretarlo come un doppio ed eseguire il calcolo corretto.

La soluzione migliore è:

this.Opacity = decimal.ToDouble(trackBar1.Value/5000);

Dato che Opacity è un doppio valore, userò solo un doppio fin dall'inizio e non lo farei per niente, ma assicurati di usare un doppio durante la divisione in modo da non perdere alcuna precisione

Opacity = trackBar1.Value / 5000.0;

this.Opacity = trackBar1.Value / 5000d;

Licensed under: CC-BY-SA with attribution
Not affiliated with StackOverflow