Générer un id unique

Je suis un étudiant à l'université, et notre tâche est de créer un moteur de recherche. J'ai de la difficulté à générer un id unique à attribuer à chaque url, lorsqu'il est ajouté à la frontière. J'ai essayé en utilisant le hachage SHA-256 de l'algorithme ainsi que les Guid. Voici le code que j'ai utilisé pour mettre en œuvre le guid:

public string generateID(string url_add)
{
    long i = 1;

    foreach (byte b in Guid.NewGuid().ToByteArray())
    {
        i *= ((int)b + 1);
    }

    string number = String.Format("{0:d9}", (DateTime.Now.Ticks / 10) % 1000000000);

    return number;
}

Un GUID est lié à être unique au monde (d'où le nom), donc je ne comprends pas le problème.
Je pense que son souci est qu'il veut que l'IDENTIFIANT unique basé sur l'URL, donc un one-way hash de l'URL d'un ID unique. Dans ce cas, SHA1 serait de travailler.
Il y a toujours objet.GetHashCode(). Bien que je ne pense pas que la garantie unique.
c'est à peu près garanti de ne pas être unique
la réponse est facile: return url_add;
Comme mentionné dans les réponses, découvrez Guid.NewGuid().

InformationsquelleAutor strange_developer | 2012-07-03

.net asp.net c#uniqueidentifier

81

Pourquoi ne pas simplement utiliser ToString?
```
public string generateID()
{
    return Guid.NewGuid().ToString("N");
}
```
Si vous souhaitez qu'il soit basé sur une URL, il vous suffit d'effectuer les opérations suivantes:
```
public string generateID(string sourceUrl)
{
    return string.Format("{0}_{1:N}", sourceUrl, Guid.NewGuid());
}
```
Si vous voulez cacher l'URL, vous pouvez utiliser une certaine forme de SHA1 sur le sourceURL, mais je ne suis pas sûr de ce que pourrait atteindre.
- Cela a fonctionné... j'ai d'abord voulu l'identité, basée sur l'url, mais cela semble bien fonctionner. Il sera en mesure de produire de grandes quantités de clés uniques? Parce que le moteur de recherche sera de travailler avec une grande quantité d'url
- Ce sera en mesure de produire environ 5,316,911,983,139,663,491,615,228,241,121,400,000 les valeurs uniques.
- Merci beaucoup! C'est plus que suffisant parce que les url sont récupérées à partir de la frontière, ils sont ensuite retirés
- Merci! En se basant sur l'url travaillé aussi bien! Je suppose que, en se basant sur l'url, il sera plus unique et un moins de chance de collision! Merci beaucoup!!!
- OH non! testé le code sur la base de l'url de nouveau et ça n'a pas fonctionné... Mais le premier fonctionne parfaitement bien!
- Je n'ai, à tort, avoir comme une chaîne de caractères.format au lieu de string.Format de... est que la source de votre problème?
- Noh j'ai corrigé...
- En ce qui concerne la génération de l'id sans se baser l'id dans l'url, les personnages ont toujours une longueur fixe? Enquêter pour le but de la structure db
- Oui, un guid est une structure bien définie. La longueur totale de la chaîne de Guid.ToString("N") sera de 32 caractères de long.
- Pour la justice, l'utilisation String.Format("{0}_{1:N}", sourceUrl, Guid.NewGuid())
InformationsquelleAutor Jaime Torres
23

Pourquoi ne pas utiliser GUID?
```
Guid guid = Guid.NewGuid();
string str = guid.ToString();
```
InformationsquelleAutor abatishchev

Ici est un "YouTube-video-id' comme id du générateur par exemple "UcBKmq2XE5a"

StringBuilder builder = new StringBuilder();
Enumerable
   .Range(65, 26)
    .Select(e => ((char)e).ToString())
    .Concat(Enumerable.Range(97, 26).Select(e => ((char)e).ToString()))
    .Concat(Enumerable.Range(0, 10).Select(e => e.ToString()))
    .OrderBy(e => Guid.NewGuid())
    .Take(11)
    .ToList().ForEach(e => builder.Append(e));
string id = builder.ToString();

Il crée aléatoire id de taille 11 caractères. Vous pouvez augmenter/diminuer le aussi, il suffit de changer le paramètre de la méthode de Prendre.

À 0,001% de doublons dans 100 millions de dollars.

InformationsquelleAutor Ashraf Ali

3

Si vous souhaitez utiliser sha-256 (guid serait plus rapide) alors vous devez faire quelque chose comme
```
SHA256 shaAlgorithm = new SHA256Managed();
byte[] shaDigest = shaAlgorithm.ComputeHash(ASCIIEncoding.ASCII.GetBytes(url));
return BitConverter.ToString(shaDigest);
```
Bien sûr, il n'a pas à ascii et il peut être tout autre type d'algorithme de hachage ainsi
- J'aimerais éviter ASCII en faveur de certains de codage unicode. Il est trivial de trouver des collisions donné votre code.
- Je sais, c'est parce que je suis en train de travailler avec un système d'héritage pour le moment je suis câblé pour ascii 🙂
- Je veux l'identifiant unique basé sur l'url. C'est la façon que j'ai pensé de générer le code
InformationsquelleAutor daz-fuller
3

Pourquoi ne pouvons-nous pas faire une id unique en tant que ci-dessous.

Nous pouvons utiliser DateTime.Maintenant.Les tiques et les Guid.NewGuid().ToString() de combiner ensemble et de faire une id unique.

Comme DateTime.Maintenant.Les tiques est ajouté, nous pouvons trouver la Date et le Temps en secondes pendant lequel l'identifiant unique est créé.

Veuillez voir le code.
```
var ticks = DateTime.Now.Ticks;
var guid = Guid.NewGuid().ToString();
var uniqueSessionId = ticks.ToString() +'-'+ guid; //guid created by combining ticks and guid

var datetime = new DateTime(ticks);//for checking purpose
var datetimenow = DateTime.Now;    //both these date times are different.
```
On peut même faire la part des tiques en identifiant unique et vérifiez la date et le temps plus tard pour référence future.

InformationsquelleAutor Jineesh Uvantavida
1

Cette question semble être répondu, cependant, pour être complet, je voudrais ajouter une autre approche.

Vous pouvez utiliser un numéro d'identification unique générateur qui est basé sur Twitter Flocon de neige id du générateur. C# de la mise en œuvre peut être trouvé ici.
```
var id64Generator = new Id64Generator();

//...

public string generateID(string sourceUrl)
{
    return string.Format("{0}_{1}", sourceUrl, id64Generator.GenerateId());
}
```
Noter que l'une des caractéristiques très agréable de cette approche est la possibilité d'avoir de multiples générateurs de nœuds indépendants (probablement quelque chose d'utile pour un moteur de recherche) de générer en temps réel, globally unique identifiers.
```
//node 0
var id64Generator = new Id64Generator(0);

//node 1
var id64Generator = new Id64Generator(1);

//... node 10
var id64Generator = new Id64Generator(10);
```
- Merci pour l'astuce! Exactement ce que je cherchais.
- Il y a un NuGet avec le code dans le github.com/RobThree/IdGen qui fait aussi similaire de flocon de neige en fonction de l'ids. Est le codeplex code pour FlakeId vous appartenant? Je voudrais arriver à github et faire un nuget si c'est ok?
- oui, je possède qu'un. Bien sûr, vous pouvez suivre avec github de la migration et de package nuget.
InformationsquelleAutor Tom

Vous devez vous connecter pour publier un commentaire.