Discussion :

[popo]

Bonsoir,

Dans l'objectif de migrer des clients vers du Saas, je dois fournir un outil qui copie des fichiers vers un Azure Storage.
Ensuite les équipes techniques prennent le relais à partir de ces données.

Pour m'aider, j'utilise la librairie Azure.Storage.Files.Share
Sachant que ces fichiers seront principalement :
- des bases de données SQL Serveur (donc MDF et LDF),
- quelques documents Office (Word, Excel principalement)
- quelques fichier TXT


Je ne sais pas trop comment obtenir une IHM pour voir ce qui se passe réellement mais le code suivant me permet de
- regarder ce qu'il y a dans mon espace
- uploader un fichier
- regarder à nouveau mon espace pour vérifier que le fichier est bien créé
- supprimer le fichier de l'espace
- regarder à nouveau mon espace pour vérifier que le fichier est bien supprimé

Code C# :

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
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
private void AzureCkeck(String azureStorageConnectionString)
{
    String filename = @"C:\Test\Popo.mdf";
    ShareClient share = new ShareClient(azureStorageConnectionString, "popo");
    share.CreateIfNotExists();
 
    if (share.Exists())
    {
        ShareDirectoryClient directory = share.GetDirectoryClient("Data");
        directory.CreateIfNotExists();
 
        GetAzureSnapshot(share);
 
        if (directory.Exists())
        {
            Stopwatch watch = new Stopwatch();
            watch.Start();
 
            ShareFileClient file = directory.GetFileClient(Path.GetFileName(filename));
            using (FileStream stream = File.OpenRead(filename))
            {
                Int64 length = stream.Length;
                file.Create(length);
 
                Int64 offset = 0;
                Int32 size = 3000 * 1024;
                using (BinaryReader reader = new BinaryReader(stream))
                {
                    while (true)
                    {
                        Byte[] buffer = reader.ReadBytes(size);
                        if (buffer.Length == 0)
                        {
                            break;
                        }
 
                        MemoryStream chunk = new MemoryStream();
                        chunk.Write(buffer, 0, buffer.Length);
                        chunk.Position = 0;
 
                        file.UploadRange(new HttpRange(offset, buffer.Length), chunk);
                        offset += buffer.Length;
 
                        Application.DoEvents();
                        ElpasedTime.Text = watch.Elapsed.ToString();
                        Application.DoEvents();
                    }
                }
            }
            watch.Stop();
 
            GetAzureSnapshot(share);
 
            file.DeleteIfExists();
 
            GetAzureSnapshot(share);
        }
 
    }
}
 
private void GetAzureSnapshot(ShareClient share)
{
    ShareDirectoryClient root = share.GetRootDirectoryClient();
    GetAzureSnapshotDirectory(root);
}
 
private void GetAzureSnapshotDirectory(ShareDirectoryClient directory)
{
    foreach (ShareFileItem item in directory.GetFilesAndDirectories())
    {
        if (item.IsDirectory)
        {
            MessageBox.Show($"Directory: {item.Name}");
            ShareDirectoryClient subDirectory = directory.GetSubdirectoryClient(item.Name);
            GetAzureSnapshotDirectory(subDirectory);
        }
        else
        {
            MessageBox.Show($"File: {directory.Name}\\{item.Name}");
        }
    }
}

Et cela semble fonctionner.
Mais j'aimerai m'en assurer car je vois le fichier arriver dans mes MessageBox mais je ne sais pas dans quel état.
Edit : Parlé trop vite, je peux faire un download du fichier depuis l'espace et essayer de rattacher la base.

Déjà est-ce la bonne librairie car j'ai vu qu'il existait Azure.Storage.Blobs (qui semblait plus compliquée) ?

Ensuite, j'aimerai calculer le débit montant théorique avant de procéder au véritable upload.
J'ai déjà le stopwWatch qui me donne le temps écoulé mais je ne sais pas trop avec quoi le coupler pour avoir le débit théorique.

Je suis en Winform, Framework 4.8

Merci.

[popo]

J'ai pu avancer.

Au final, j'ai pu rattacher ma base sans problème et à priori sans perte de données.
Donc la question de la librairie ne se pose plus. Je vais conserver Azure.Storage.Files.Shares.

Concernant le débit j'ai converti le temps renvoyé par le watcher en seconde, j'ai récupérer la taille du fichier et j'ai simplement divisé cette taille par le nombre de secondes.

Code C# :

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

1
2
3
4
5
class FileSize
{
    public Double Value { get; set; }
    public String Unity { get; set; }
}

Code C# :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
FileSize ComputeFileSize()
{
    Int32 order = 0;
    String[] sizes = { "o", "Ko", "Mo", "Go", "To" };
 
    FileInfo info = new FileInfo(filename);
    Double length = info.Length;
    while (length >= 1024 && order < sizes.Length - 1)
    {
        order++;
        length = length / Convert.ToDouble(1024);
    }
 
    return new FileSize { Value = length, Unity = sizes[order] };
}

Code C# :

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

1
2
3
Int64 seconds = watch.ElapsedMilliseconds / 1000;
Double speed = size.Value / Convert.ToDouble(seconds);
UplinkSpeed.Text = String.Format(CultureInfo.CurrentCulture, "{0:0.##} {1}/s", speed, size.Unity);

Cela m'a paru tellement évident en m'y replongeant que je me demande pourquoi j'ai éprouvé la nécessiter d'ouvrir un post.