În timp ce aplicăm opacitatea unui formular, ar trebui să folosim o valoare zecimal sau dublă?

Nu este necesară o distribuție explicită care să se dubleze ca aceasta:

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

Identificarea constantei ca 5000.0 (sau ca 5000d ) este suficienta:

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

Un răspuns mai generic pentru întrebarea generică "Decimal vs Double?": Decimal </ strong> pentru calculele monetare pentru a menține precizia, Dublă </ strong> pentru calculele științifice care nu sunt afectate de mici diferențe . Deoarece Double este un tip care este nativ la CPU (reprezentarea internă este stocată în baza 2 </ em>), calculele efectuate cu Double efectuează mai bine decât Decimal (care este reprezentat în baza 10 </ em> intern).

Suna ca this.Opacitate este o valoare dubla, iar compilatorul nu-i place sa incerci sa intarzi o valoare zecimala in ea.

În opinia mea, este de dorit să fie cât mai explicit posibil. Acest lucru adaugă claritate codului și îi ajută pe ceilalți programatori care îl pot citi în cele din urmă.

În plus față de (sau în loc de) adăugarea unui număr .0 la număr, puteți folosi decimal.ToDouble () .

Aici sunt cateva exemple:

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

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

Aveți două probleme. Mai întâi, Opacity necesită o valoare dublă, nu o valoare zecimală. Compilatorul vă spune că în timp ce există o conversie între zecimal și dublu, este o conversie explicită pe care trebuie să o specificați pentru ca aceasta să funcționeze. Al doilea este că TrackBar.Value este o valoare întregă și împărțind un int cu un int rezultă într-un int indiferent de tipul de variabilă pe care îl alocați. În acest caz, există o distribuție implicită de la int la zecimal sau dublu - deoarece nu există o pierdere de precizie atunci când faceți distribuția - astfel încât compilatorul nu se plânge, dar valoarea pe care o obțineți este întotdeauna 0, probabil, deoarece trackBar.Value este întotdeauna mai mică de 5000. Soluția este să vă schimbați codul pentru a utiliza dublu (tipul nativ pentru opacitate) și să faceți aritmetica cu virgulă mobilă făcând în mod explicit o constantă dublă - care va avea efectul promovând aritmetica - sau distribuind trackBar.Value pentru a dubla, ceea ce va face același lucru - sau ambele. Și nu aveți nevoie de variabila intermediară dacă nu este utilizată în altă parte. Cred că compilatorul o va optimiza oricum.

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

Codul vostru a funcționat bine în VB.NET deoarece implicit are orice distribuție, în timp ce C # are atât implicit, cât și explicit.

În C #, conversia de la zecimal la dublu este explicită pe măsură ce pierdeți precizia. De exemplu, 1.1 nu poate fi exprimată cu precizie ca dublă, dar poate ca zecimal (a se vedea " Numerele cu puncte plutitoare - mai inexacte decât crezi " pentru motivul pentru care).

În VB, conversia a fost adăugată pentru dvs. de către compilator:

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

Acest cod (dublu) trebuie să fie specificat explicit în C #, dar poate fi </ em> de către compilatorul VB mai "iertător".

Cea mai bună soluție este:

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

Ar trebui să utilizați 5000.0 în loc de 5000 .

De ce împărțiți 5000? Doar setați valorile Minimă și Maximă ale TrackBar între 0 și 100 și apoi împărțiți Valoarea cu 100 pentru procentul de opacitate. Exemplul minim de 20 de mai jos împiedică completarea formularului de invizibil:

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

Proprietatea Opacitate este de tip dublu :

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

sau pur și simplu:

this.Opacity = trackBar1.Value / 5000.0;

sau:

this.Opacity = trackBar1.Value / 5000d;

Observați că folosesc 5000.0 (sau 5000d ) pentru a forța o divizare dublă deoarece trackBar1.Value este un număr întreg și ar face o diviziune întreg și rezultatul ar fi un număr întreg .

Presupunând că utilizați WinForms, Form.Opacity este de tip dublu , deci ar trebui să utilizați:

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

Dacă nu aveți nevoie de valoarea în altă parte, este mai simplu să scrieți:

this.Opacity = trackBar1.Value / 5000.0;

Motivul pentru care controlul nu funcționează atunci când ți-ai schimbat codul pentru a fi simplu dublu a fost pentru că ai avut:

double trans = trackbar1.Value / 5000;

care a interpretat 5000 ca un număr întreg, deci valoarea trans a fost întotdeauna zero. Determinând în mod explicit valoarea numerică a unei valori în virgulă mobilă adăugând .0 , compilatorul îl poate interpreta acum ca dublu și poate efectua calculul corect.

Deoarece Opacity este o dublă valoare, aș folosi doar un dublu de la început și nu arunc deloc, dar asigurați-vă că utilizați un dublu atunci când împărțiți astfel încât să nu pierdeți nici o precizie

Opacity = trackBar1.Value / 5000.0;

this.Opacity = trackBar1.Value / 5000d;