Convertir des ticks .NET en date et heure ISO
La valeur de ticks 638712864000000000 correspond à minuit le 1er janvier 2025, en UTC. Collez un nombre de pas de 100 nanosecondes depuis le début de l'an 1 et obtenez la date et l'heure exactes, aussi affichées séparément. Gratuit dans votre navigateur.
- Gratuit
- Fonctionne dans votre navigateur
- Sans inscription
- Vos données restent sur votre appareil
Lancer gratuitement
Exemple résolu
- Ticks
- 638712864000000000
- Date et heure ISO
- 2025-01-01T00:00:00.0000000Z
- Date
- 2025-01-01
- Temps
- 00:00:00.0000000Z
Convertissez une valeur de ticks DateTime . NET en date et heure ISO UTC sans dépendre du fuseau local ni de l’analyseur de dates de la machine. Le service compte les intervalles de 100 nanosecondes depuis le 1er janvier de l’an 1 dans le calendrier grégorien proleptique. Il renvoie les ticks normalisés, une date ISO complète à sept décimales ainsi que des champs date et heure séparés. Vous pouvez ainsi contrôler des bases anciennes, des journaux et des échanges tout en conservant la précision d’origine.
Comprendre ce que représente un tick .NET
Un tick DateTime . NET vaut 100 nanosecondes : dix millions font une seconde et 864 milliards font une journée. Son origine est 0001-01-01 à 00:00:00, et non l’époque Unix.
Le convertisseur sépare l’entier exact en journées grégoriennes et en reste journalier, puis détermine l’année, le mois et le jour selon les règles des années bissextiles de DateTime. Le résultat finit par Z, car le calcul est présenté en UTC de façon déterministe. Les sept chiffres après la seconde préservent toute la résolution, sans arrondi à la milliseconde.
Les zéros initiaux sont admis, puis retirés dans le champ normalisé pour faciliter les comparaisons.
Convertir sans surprise liée au fuseau horaire
Le calcul ne consulte ni l’horloge, ni les paramètres régionaux, ni le fuseau du système, ni l’heure d’été, ni un analyseur natif. Une même valeur produit donc les mêmes éléments dans un navigateur, un serveur ou un poste situé ailleurs. Le Z final exprime l’interprétation UTC demandée ; il ne provient pas d’une propriété DateTime Kind cachée, car un nombre de ticks seul ne la contient pas.
Si l’application source considérait la valeur comme locale ou non spécifiée, déterminez le fuseau prévu avant d’en faire un instant absolu. Aucun décalage local vers UTC n’est appliqué : le nombre est directement rapporté à l’époque de l’an 1. Les jours bissextiles, changements de siècle, minuits et valeurs maximales restent ainsi stables.
Valider et intégrer la date ISO renvoyée
La plage admise va de 0 à 3155378975999999999, soit toute l’étendue DateTime de l’an 1 à la dernière fraction de 100 nanosecondes de l’an 9999. Seuls les chiffres décimaux sont autorisés. Les signes, fractions, exposants, séparateurs et dépassements sont rejetés plutôt que devinés ou arrondis.
Ce contrat strict révèle immédiatement les enregistrements défectueux pendant une migration. Certaines bases et bibliothèques JavaScript ne gardent que les millisecondes ou microsecondes ; vérifiez la destination si les derniers chiffres comptent. Les champs date et time conviennent respectivement aux partitions et à l’heure quotidienne.
Cas d’usage
Examiner une base de données ancienne
Transformez une colonne de ticks opaque en dates UTC lisibles pendant une migration.
Normaliser des échanges applicatifs
Convertissez les chaînes DateTime avant leur envoi vers un système utilisant des horodatages textuels.
Déboguer des valeurs .NET sérialisées
Vérifiez l’instant représenté dans des journaux, caches ou états exportés.
Questions fréquentes
Quelle est l’époque des ticks DateTime .NET ?
Le comptage débute à 0001-01-01T00:00:00.0000000 dans le calendrier grégorien proleptique.
Les ticks contiennent-ils un fuseau horaire ?
Non. Ils ne portent ni DateTime Kind ni décalage local. Le résultat est calculé et marqué en UTC sans correction.
Quelle précision est conservée ?
Les sept décimales de seconde sont gardées, soit la résolution de 100 nanosecondes d’un tick.
Quelles valeurs sont acceptées ?
Les entiers décimaux de 0 à 3155378975999999999 ; signes, fractions, exposants et dépassements sont refusés.
Combien de temps dure un tick .NET ?
Un tick vaut 100 nanosecondes. Dix millions de ticks font une seconde et 864 milliards font une journée, comptés depuis minuit au début de l'an 1, et non depuis l'époque Unix.
Outils associés
Pour les développeurs — accès API
Tout sur cette page est disponible par programmation. Cette section s'adresse aux équipes qui veulent l'intégrer à leurs systèmes ; les autres peuvent simplement utiliser l'outil ci-dessus.
Endpoint
Authentification par jeton Bearer : un seul POST met la tâche en file d’attente, et le résultat vous parvient par webhook ou lien signé.
Appeler depuis votre stack
curl -X POST https://api.kit.forhosting.com/date/dotnet-ticks-to-date \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"ticks":"638712864000000000"}'const res = await fetch("https://api.kit.forhosting.com/date/dotnet-ticks-to-date", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"ticks": "638712864000000000"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/date/dotnet-ticks-to-date",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"ticks": "638712864000000000"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/date/dotnet-ticks-to-date", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"ticks":"638712864000000000"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"ticks":"638712864000000000"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/date/dotnet-ticks-to-date", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Exemple de requête
{
"ticks": "638712864000000000"
}Exemple de réponse
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "date.dotnet_ticks_to_date",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}L’API est asynchrone : chaque appel renvoie un task_id immédiatement, puis vous interrogez l’état à raison d’une requête par seconde.
Tarifs
Le prix est publié, sans tokens ni crédits. Une tâche qui échoue n’est pas facturée.
Erreurs
| HTTP | Code | Signification |
|---|---|---|
401 | unauthorized | Clé API absente ou invalide : vérifiez l’en-tête Authorization. |
402 | insufficient_balance | Solde insuffisant : rechargez votre compte pour lancer cette tâche. |
404 | unknown_type | Type de tâche inconnu : vérifiez le champ type de votre requête. |
429 | rate_limited | Trop de requêtes : ralentissez la cadence, puis réessayez. |
Notes techniques
Comprendre ce que représente un tick .NET
Envoyez les ticks sous forme de texte décimal afin d’éviter la perte de précision des grands nombres JSON.
Valider et intégrer la date ISO renvoyée
Utilisez iso_datetime pour une exportation ou une charge API acceptant sept décimales.
Questions techniques
Pourquoi fournir les ticks sous forme de texte ?
Les grandes valeurs dépassent la précision entière de nombreux parseurs JSON ; le texte décimal conserve chaque chiffre.
Quel est le prix d’une conversion API ?
Chaque conversion coûte $0.002.