Convertir une date en ticks .NET
Le 29 février 2024 à 12:34:56.1234567 avec un décalage de +02:30 vaut 638447978961234567 ticks, comptés en UTC. Saisissez date, heure et décalage pour obtenir les ticks .NET exacts et l'instant UTC qu'ils représentent. Gratuit dans votre navigateur.
- Gratuit
- Fonctionne dans votre navigateur
- Sans inscription
- Vos données restent sur votre appareil
Lancer gratuitement
Exemple résolu
- Date et heure
- 2024-02-29T12:34:56.1234567+02:30
- Date et heure UTC
- 2024-02-29T10:04:56.1234567Z
- Ticks .NET
- 638447978961234567
- Unité de ticks
- 100 nanoseconds
Convertissez une date et heure ISO 8601 complète en nombre exact de ticks utilisé par les valeurs DateTime . NET. Le convertisseur exige un indicateur UTC ou un décalage numérique explicite, valide la date et l'heure grégoriennes, conserve les fractions jusqu'à cent nanosecondes et effectue tous les calculs en UTC.
Saisissez une date ISO sans ambiguïté
Saisissez une date et heure du calendrier grégorien au format YYYY-MM-DDTHH:mm:ssZ, ou remplacez Z par un décalage numérique tel que +02:30 ou -05:00. Les secondes sont obligatoires, car une conversion en ticks . NET représente un instant précis et non une date approximative.
Vous pouvez ajouter entre un et sept chiffres après le point décimal. Sept chiffres correspondent exactement à la résolution de cent nanosecondes d'un tick DateTime ; les fractions plus courtes sont complétées à droite, de sorte que .5 signifie cinq dixièmes de seconde et non cinq ticks. Le fuseau horaire est obligatoire.
Cette exigence empêche un même texte de produire des réponses différentes sur des ordinateurs configurés dans des zones locales distinctes. Le convertisseur refuse les dates impossibles, les secondes intercalaires, l'heure 24, les décalages hors de la plage ISO et les instants qui, une fois normalisés en UTC, sortent des années 0001 à 9999. Ce contrat strict convient aux migrations, jeux de test, contrôles de bases de données et diagnostics de protocoles.
Utilisez Z en majuscule et le séparateur littéral T pour une représentation compacte et vérifiable de l'instant voulu.
Comprenez le calcul de la valeur en ticks
Un tick DateTime . NET est un intervalle de cent nanosecondes depuis 0001-01-01T00:00:00 dans le calendrier grégorien proleptique. Le calcul valide d'abord l'année, le mois, le jour, l'heure, la minute et la seconde.
Il compte ensuite les jours complets précédant l'année fournie, en appliquant les règles grégoriennes des années bissextiles, ajoute les jours complets de l'année en cours et convertit l'heure de la journée en secondes. Le décalage numérique indiqué est soustrait afin d'obtenir UTC avant de former le nombre de ticks. Enfin, les secondes sont multipliées par dix millions et la composante fractionnaire à sept chiffres est ajoutée.
Ni l'horloge système, ni le fuseau de la machine, ni une requête réseau, ni une valeur aléatoire, ni l'analyseur Date intégré n'interviennent. Le résultat reste donc identique dans un worker serveur et dans un navigateur, quel que soit le fuseau.
Vérifiez vos intégrations avec le résultat UTC normalisé
Le champ UTC normalisé constitue une preuve utile : avant d'accepter l'entier, vous pouvez vérifier que le décalage fourni a déplacé l'heure et, si nécessaire, la date calendaire dans le sens attendu. En C#, la valeur numérique correspond aux ticks de l'heure UTC normalisée, avec une époque située en l'an un ; elle n'inclut pas les indicateurs binaires de type DateTime. Gardez cette distinction à l'esprit lorsque vous examinez DateTime.ToBinary, les conventions de stockage DateTimeOffset ou des époques propres à une application.
Leur association facilite le diagnostic : un UTC erroné indique le traitement du décalage, tandis qu'un UTC identique associé à un autre entier indique l'époque, la précision ou l'arrondi numérique.
Cas d’usage
Examinez d'anciens horodatages
Convertissez un instant ISO connu avant de le comparer aux ticks stockés dans des journaux, des exports ou d'anciennes tables applicatives.
Diagnostiquez les erreurs de décalage et de précision
Contrôlez la date UTC canonique à côté du nombre de ticks afin de distinguer une erreur de fuseau d'un problème de fraction ou d'arrondi d'entier.
Questions fréquentes
Que représente un tick .NET ?
Un tick équivaut à cent nanosecondes. Une seconde contient dix millions de ticks.
Un fuseau horaire est-il obligatoire ?
Oui. Utilisez Z ou un décalage tel que +01:00. Les dates sans fuseau sont ambiguës et sont refusées plutôt qu'interprétées selon la machine.
Les sept chiffres fractionnaires sont-ils acceptés ?
Oui. Le convertisseur accepte entre un et sept chiffres fractionnaires et complète les fractions courtes jusqu'à la précision DateTime de sept chiffres.
Le résultat inclut-il les indicateurs de type DateTime ?
Non. Il renvoie le nombre de ticks UTC depuis l'an un, sans les indicateurs supplémentaires de représentations telles que DateTime.ToBinary.
Quelles dates peut-on convertir ?
Tout instant dont l'heure UTC se situe entre les années 0001 et 9999. Les dates impossibles, les secondes intercalaires et l'heure 24 sont refusées, tout comme les décalages hors de la plage habituelle.
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/date-to-dotnet-ticks \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"datetime":"2024-02-29T12:34:56.1234567+02:30"}'const res = await fetch("https://api.kit.forhosting.com/date/date-to-dotnet-ticks", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"datetime": "2024-02-29T12:34:56.1234567+02:30"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/date/date-to-dotnet-ticks",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"datetime": "2024-02-29T12:34:56.1234567+02:30"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/date/date-to-dotnet-ticks", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"datetime":"2024-02-29T12:34:56.1234567+02:30"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"datetime":"2024-02-29T12:34:56.1234567+02:30"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/date/date-to-dotnet-ticks", 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
{
"datetime": "2024-02-29T12:34:56.1234567+02:30"
}Exemple de réponse
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "date.date_to_dotnet_ticks",
"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
Le résultat est renvoyé sous forme de chaîne décimale afin que même les très grandes valeurs restent exactes dans JavaScript, JSON, les tableurs, les outils en ligne de commande et les tests d'intégration multilangages.
Comprenez le calcul de la valeur en ticks
Comme presque toutes les valeurs utiles dépassent la limite des entiers exacts de JavaScript, dotnet_ticks est volontairement renvoyé sous forme de chaîne décimale. Traitez-la comme un entier dans un langage prenant en charge les entiers 64 bits, ou conservez-la comme texte dans les systèmes JSON susceptibles d'arrondir les grands nombres.
Vérifiez vos intégrations avec le résultat UTC normalisé
La réponse contient le datetime d'origine, un utc_datetime canonique comportant exactement sept chiffres fractionnaires, la chaîne exacte dotnet_ticks et une description claire de l'unité du tick. Cette vérification est particulièrement utile pour comparer une charge API avec des journaux C#, des exports SQL, des données de télémétrie ou d'anciens fichiers dont les horodatages ont été sérialisés en ticks.
Cas d'intégration
Préparez des jeux de test multilangages
Créez des chaînes de ticks attendues exactes pour les tests d'intégration JavaScript, C#, base de données et API, sans dépendre du fuseau de la machine.
Questions techniques
Pourquoi dotnet_ticks est-il renvoyé comme chaîne ?
La plupart des valeurs DateTime dépassent la plage des entiers sûrs de JavaScript. Une chaîne décimale préserve chaque chiffre dans JSON et le navigateur.
Quel est le coût d'une requête API ?
Chaque requête API coûte $0.002. La version pour navigateur emploie la même logique de conversion déterministe.