Discussion :

[camer12]

Salut ,
j'aimerai calculer dans mon code le temps qu'un avion fait de l'aeroport A à l'aeropor B connaissant la distance de A à B et la vitesse de l'avion. En realité la distance est en km et la vitesse en km/h, donc je devrais avoir temps en heure. Au depart j'ai pri la distance en "int" et la vitesse aussi en "int" donc temps que je trouve est en "int", pour la suite de mon programme j'ai besoin du temps en "heure". Il y a t-il une correspondace du km et du km/h en c#?

[Nathanael Marchand]

Bon déjà manipuler des entiers c'est pas super genial pour la précision... Je conseille des float ou des double.
Ensuite, si tu divises des km par des km/h alors tu auras des heures... Ton entier et donc le nombre d'heures.

[camer12]

ca veut dire que le double que j'obtiens je le transforme en DateTime?

[giova_fr]

non

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

new SpanTime(resultat, 0,0);

0 car tu travaille avec des entiers, donc tu ne semble pas etre à la minute ou seconde pres

[tomlev]

Au depart j'ai pri la distance en "int" et la vitesse aussi en "int" donc temps que je trouve est en "int", pour la suite de mon programme j'ai besoin du temps en "heure".

J'ai l'impression que tu mélanges 2 concepts... int est un type de données qui représente un nombre entier sur 32 bits. heure est une unité de mesure, pas un type ; il n'y a pas de type particulier pour représenter des heures (bien qu'on pourrait le créer). Dans le code tu représentes le nombre d'heures par un nombre (int, double...), mais ce nombre ne contient pas d'information sur l'unité, c'est à toi de savoir que ce sont des heures.

A noter que certains langages, comme F#, intègrent le principe des unités ; par exemple si on divise des km par des km/h, on obtient bien des heures... une fonctionnalité que j'aimerais bien avoir en C#

EDIT: exemple en F# :

Code F# :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
[<Measure>] type km
[<Measure>] type h
 
let speed = 200.0<km/h>
let distance = 1500.0<km>
let time = distance / speed

[theMonz31]

bonjour

Pour adresser un tel problème, je travaillerais tout en unité SI (système international), donc, pour moi, les vitesses seraient en m/s, les distances en mètres et tous les calculs fait en double ou float.

Ce n'est que pour la représentation et l'affichage des données que je basculerais dans un affichage plus approprié (Heure/Minute/seconde (si pertinent)..

En règle général, il est plus "logique" de travailler avec la "plus" petite unité quand on fait des calculs pour avoir un maximum de précision et uniquement à l'affichage, d'arrondir pour rentrer dans les unités usuelles d'affichage.

Maintenant, c'est ma vision des choses, elle n'est ni unique, ni forcément parfaite.. juste le fruit d'une "intense" réflexion et d'un peu d'expérience

[Bluedeep]

J
A noter que certains langages, comme F#, intègrent le principe des unités ; par exemple si on divise des km par des km/h, on obtient bien des heures... une fonctionnalité que j'aimerais bien avoir en C#

Ben, en C# on peut faire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
MeterPerSecond mps = 100.0;
Meter distance = 10.0;
TimeSpan temps = mps / distance;

Suffit de rajouter un peu de code dans un coin
:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
  class MeterPerSecond
{
	private double _value;
	public MeterPerSecond(double value)
	{
		_value = value;
	}
	public static Meter operator /(MeterPerSecond vitesse, TimeSpan time)
	{
		return new Meter(vitesse._value / time.TotalSeconds);
	}
	public static TimeSpan operator /(MeterPerSecond vitesse, Meter distance)
	{
		return new TimeSpan(0, 0, (int)(vitesse._value / distance.Value));
	}
 
	public static implicit operator MeterPerSecond(double val)
	{
		return new MeterPerSecond(val);
	}
	public static implicit operator double(MeterPerSecond val)
	{
		return val._value;
	}
 
}
 
class Meter
{
	private double _value;
	public double Value
	{
		get { return _value; }
	}
 
	public Meter(double value)
	{
		_value = value;
	}
 
	public static implicit operator Meter(double val)
	{
		return new Meter(val);
	}
	public static implicit operator double(Meter meters)
	{
		return meters.Value;
	}
	public static MeterPerSecond operator /(Meter meter, TimeSpan time)
	{
		return new MeterPerSecond(meter.Value / time.TotalSeconds);
	}
}