Accéder aux métadonnées d'un fichier

**Laur3nT** · 27/05/2008, 11h43

Bonjour à tous,
J'aimerai pouvoir lire la valeur de la métadonnée : "Modifié le :" d'un fichier X à partir d'un logiciel en vb.net.
J'aimerai aussi savoir s'il est possible de créer ses propres médadonnées sur un fichier et de les remplir comme bon nous semble.

(vista et windows xp et windows 2000)

Merci

**neptune** · 27/05/2008, 11h51

Jette un oeil à la class FileInfo.

**Laur3nT** · 28/05/2008, 15h16

Merci à toi. A partir de cette classe, j'ai créé un système qui vérifie régulièrement si un fichier a été modifié depuis l'ouverture de mon logiciel. Si c'est le cas il lance un événement

Si cela peut aider quelqu'un, voici le code :

Première classe contenant l'objet qui permet de surveiller un fichier :

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
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
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
 
Imports System.Threading
 
''' <summary>
''' Enumération contenant la liste des fichiers suceptible d'être vérifié dans le logiciel
''' </summary>
''' <remarks></remarks>
Enum CheckFile
    Operation
End Enum
 
Friend Class CheckFileModify
 
#Region "Gestion de l'événement"
 
    ''' <summary>
    ''' Lancement de l'événement
    ''' </summary>
    ''' <param name="sender"></param>
    ''' <param name="e"></param>
    ''' <remarks></remarks>
    Public Delegate Sub FileModifyEventHandler(ByVal sender As Object, ByVal e As ModifyFileEventArgs)
    Public Event OnFileModify As FileModifyEventHandler
 
    Private Sub FileModified(ByVal Chemin As String, ByVal Type As CheckFile)
        Dim e As ModifyFileEventArgs = New ModifyFileEventArgs(Chemin, Type)
        If Not (e Is Nothing) Then
            RaiseEvent OnFileModify(Me, e)
        End If
    End Sub
 
#End Region
 
    ''' <summary>
    ''' Thread qui va vérifier régulièrement si le fichier a été modifié
    ''' </summary>
    ''' <remarks></remarks>
    Private _threadCheck As Thread
 
    ''' <summary>
    ''' Classe qui permet de passer des données au thread ci-dessus
    ''' </summary>
    ''' <remarks></remarks>
    Private Class ThreadCheck
 
        ''' <summary>
        ''' Le chemin de mon fichier
        ''' </summary>
        ''' <remarks></remarks>
        Private sChemin As String
 
        ''' <summary>
        ''' Le type du fichier
        ''' </summary>
        ''' <remarks>Dans un autre projet que le mien cela est très certainement inutile</remarks>
        Private eType As CheckFile
 
        Private fiFile As IO.FileInfo
 
        ''' <summary>
        ''' La date de dernière modification
        ''' </summary>
        ''' <remarks></remarks>
        Private LastDate As Date
 
        ''' <summary>
        ''' L'objet parent. (Celui qui à lancé le thread)
        ''' </summary>
        ''' <remarks>Il est utilisé pour déclencher l'événement</remarks>
        Private Parent As CheckFileModify
 
        ''' <summary>
        ''' Un booléen qui me permet de savoir si je doit arrêter de vérifier la mise à jour du fichier 
        ''' </summary>
        ''' <remarks></remarks>
        Private boolEnd As Boolean
 
        ''' <summary>
        ''' Méthode qui indique à l'objet d'arrêter de surveiller le fichier
        ''' Cela permettra au thread de sortir de sa boucle infinie et de s'arrêter proprement
        ''' </summary>
        ''' <remarks></remarks>
        Friend Sub Terminer()
            Me.boolEnd = False
        End Sub
 
 
        ''' <summary>
        ''' Constructeur de mon objet.
        ''' </summary>
        ''' <param name="Chemin">Chemin de mon fichier</param>
        ''' <param name="Type">Type de mon fichier (probablement inutile dans un autre projet</param>
        ''' <param name="Parent">L'objet parent à celui-ci pour lui dire de déclencher l'événement qui indiquera au reste du monde (:p) que le fichier a été modifié</param>
        ''' <remarks></remarks>
        Public Sub New(ByVal Chemin As String, ByVal Type As CheckFile, ByVal Parent As CheckFileModify)
            Me.sChemin = Chemin
            Me.eType = Type
            Me.Parent = Parent
            Me.boolEnd = True
        End Sub
 
        ''' <summary>
        ''' Fonction du thread
        ''' </summary>
        ''' <remarks></remarks>
        Public Sub ThrFunc()
            fiFile = New IO.FileInfo(sChemin)
            'On récupére la date de dernière modification du fichier
            LastDate = fiFile.LastWriteTimeUtc
            'Tant qu'on ne lui a pas dit de s'arrêter le thread continu.
            While Me.boolEnd
                'On fait dormir le thread 2 secondes
                Thread.Sleep(2000)
                'On est obligé de recréer l'objet fiFile. L'appel de LastWriteTimeUtc ne va pas chercher la valeur dans le descripteur de fichier mais celle en mémoire dans l'objet...
                fiFile = New IO.FileInfo(sChemin)
                'Si la date actuellement indiqué sur le fichier est différente de celle sauvegardé la première fois on déclenche l'événement
                If fiFile.LastWriteTimeUtc <> LastDate Then
                    Me.Parent.FileModified(Me.sChemin, Me.eType)
                    'On sors de la boucle, le thread va s'arrêter
                    Exit While
                End If
            End While
        End Sub
    End Class
 
 
    ''' <summary>
    ''' Objet de la classe ci-dessus.
    ''' Il sert à transmettre des données au thread
    ''' </summary>
    ''' <remarks></remarks>
    Private myThreadObj As ThreadCheck
 
    ''' <summary>
    ''' On lance le thread
    ''' </summary>
    ''' <param name="Chemin">Chemin du fichier à surveiller</param>
    ''' <param name="Type">Type de mon fichier (probablement inutile dans un autre projet</param>
    ''' <remarks></remarks>
    Public Sub StartThread(ByVal Chemin As String, ByVal Type As CheckFile)
        myThreadObj = New ThreadCheck(Chemin, Type, Me)
        _threadCheck = New Thread(AddressOf myThreadObj.ThrFunc)
        _threadCheck.Name = "ThreadCheck"
        _threadCheck.Start()
    End Sub
 
    ''' <summary>
    ''' Pour arrêter de surveiller le fichier
    ''' </summary>
    ''' <remarks></remarks>
    Public Sub EndThread()
        Me.myThreadObj.Terminer()
    End Sub
 
End Class

Deuxième classe contenant l'objet inhérent à l'événement

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
54
55
56
Imports System
 
Friend Class ModifyFileEventArgs
    Inherits EventArgs
 
    ''' <summary>
    ''' Le chemin du fichier
    ''' </summary>
    ''' <remarks></remarks>
    Private sChemin As String = Nothing
 
    ''' <summary>
    ''' Le type du fichier, probablement inutile dans un autre projet
    ''' </summary>
    ''' <remarks></remarks>
    Private eType As CheckFile
 
    ''' <summary>
    ''' Constructeur de l'événement
    ''' </summary>
    ''' <param name="Chemin">Le chemin du fichier</param>
    ''' <param name="Type">Le type du fichier, probablement inutile dans un autre projet</param>
    ''' <remarks></remarks>
    Public Sub New(ByVal Chemin As String, ByVal Type As CheckFile)
        If Chemin Is Nothing Then
            Throw New NullReferenceException()
        End If
        Me.sChemin = Chemin
        Me.eType = Type
    End Sub
 
    ''' <summary>
    ''' Indique le chemin du fichier qui a été modifié
    ''' </summary>
    ''' <value></value>
    ''' <returns></returns>
    ''' <remarks></remarks>
    Public ReadOnly Property Chemin() As String
        Get
            Return Me.sChemin
        End Get
    End Property
 
    ''' <summary>
    ''' Indique le type du fichier modifié
    ''' </summary>
    ''' <value></value>
    ''' <returns></returns>
    ''' <remarks></remarks>
    Public ReadOnly Property Type() As CheckFile
        Get
            Return Me.eType
        End Get
    End Property
 
End Class

C'est cool tous sa, mais on l'utilise comment se truc ?

Quelque part dans votre projet, vous déclarez dans un objet l'attribut suivant :

Code :

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

1
2
3
4
5
6
 
    ''' <summary>
    ''' Objet qui permettra de controler les modifications sur un fichier
    ''' </summary>
    ''' <remarks></remarks>
    Friend WithEvents CheckOperationFile As CheckFileModify

Voici le code qui sera exécuté quand l'événement apparaitra :

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
 
    ''' <summary>
    ''' Sub qui se lancera quand le fichier sera modifié
    ''' </summary>
    ''' <param name="sender"></param>
    ''' <param name="e"></param>
    ''' <remarks></remarks>
    Private Sub CheckOperationFile_OnFileModify(ByVal sender As Object, ByVal e As ModifyFileEventArgs) Handles CheckOperationFile.OnFileModify
        'On vérifie le type du fichier modifié. (Hors de mon projet, cela ne sert à rien)
        If e.Type = CheckFile.Operation Then
            'On affiche une boîte de dialogue demande à l'utilisateur s'il veut recharger le fichier
            If MsgBox("Le fichier d'opération viens d'être modifié." & vbCrLf & "Voulez vous le recharger ?", MsgBoxStyle.YesNo) = MsgBoxResult.Yes Then
                'S'il dit oui on arrête la surveillance du fichier. (le thread va se terminer dans les deux secondes)
                CheckOperationFile.EndThread()
                'Vous faites votre traitement...
                '...
                'On relance une nouvelle surveillance sur le fichier
                '(sOperationDataPath est un attribut contenant le chemin du fichier)
                CheckOperationFile = New CheckFileModify
                CheckOperationFile.StartThread(sOperationDataPath, CheckFile.Operation)
            Else
                'Si l'utilisateur ne tiens pas compte de notre avertissement, on a pas besoin de surveiller le fichier, donc on arrête.
                CheckOperationFile.EndThread()
            End If
        End If
    End Sub

Puis, après au moment ou vous chargez le fichier dans votre logiciel :

Code :

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

1
2
3
 
CheckOperationFile = New CheckFileModify()
CheckOperationFile.StartThread(sOperationDataPath, CheckFile.Operation)

C'est une bonne idée d'arrêter le thread de surveillance en cas de fermeture de l'application. (Sinon elle ferme pas)

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
 
Namespace My
 
    ' Les événements suivants sont disponibles pour MyApplication :
    ' 
    ' Startup : déclenché lors du démarrage de l'application, avant la création du formulaire de démarrage.
    ' Shutdown : déclenché après la fermeture de tous les formulaires de l'application. Cet événement n'est pas déclenché si l'application se termine de façon anormale.
    ' UnhandledException : déclenché si l'application rencontre une exception non gérée.
    ' StartupNextInstance : déclenché lors du lancement d'une application à instance unique et si l'application est déjà active. 
    ' NetworkAvailabilityChanged : déclenché lorsque la connexion réseau est connectée ou déconnectée.
    Partial Friend Class MyApplication
 
        Private Sub MyApplication_Shutdown(ByVal sender As Object, ByVal e As System.EventArgs) Handles Me.Shutdown
            If m_main.CheckOperationFile IsNot Nothing Then
                m_main.CheckOperationFile.EndThread()
            End If
        End Sub
    End Class
 
End Namespace

C'est pas forcément le code le plus simple, ni le plus efficace et encore moins le mieux écris possible, je le met pour celles et ceux qui aurais ce type de truc à faire dans leurs logiciel.

Cela peut être utile si vous ne voulez pas écraser des données écrites sur un fichier entre le moment où vous l'avez chargé en mémoire et le moment où vous écrivez dedans.

**neptune** · 28/05/2008, 15h27

Pas mal, mais est-ce que cela ne fait pas double emploi avec FileSystemWatcher?

**Laur3nT** · 28/05/2008, 16h05

mais qu'est-ce que FileSystemWatcher

Public Class FileSystemWatcher
Inherits System.ComponentModel.Component
Membre de : System.IO
Résumé :
Écoute les notifications de modifications du système de fichiers et déclenche un événement lorsqu'un répertoire ou un fichier d'un répertoire est modifié.

Et merde j'ai ré-inventé la roue :'(

Je n'ai que quelques mois de développement à mon CV et il m'est très fréquent de développer moi même des choses déjà présente dans le framework

J'ai pas encore trouvé de méthode efficace pour éviter ce genre de problème.

L'expérience ?

**neptune** · 28/05/2008, 16h11

Expérience: oui. Mais si tu avais mieux expliqué pourquoi tu cherchais à connaitre quand ton fichier à été modifié la dernière fois, je t'aurais déjà aiguiller sur FileSystemWatcher ;-)

Mais ne t'en fait pas, c'est un excellent exercice néanmoins!

**Laur3nT** · 28/05/2008, 16h35

Oui

**Laur3nT** · 29/05/2008, 09h55

Aurais-tu une solution ou une astuce qui me permettrai de comprendre l'architecture du framework, son organisation, le but des classes etc mais sans lire entièrement la doc classe par classe ?

Une sorte de tutoriel avec pleins de trucs mnémotechniques ?

Merci

**neptune** · 29/05/2008, 09h59

Si tu découvre le framework, ce qui pourrait être intéressant est de faire des mini-applications exercice pour les besoins courants.

Exemple d'application type:
gestion de fichier: un event logger
accès base de donnée: mini gestion de livre
etc...

Je pense que ce type d'effort te pousseras à chercher quelles classes utiliser. Et puis, bien sur, lire ce forum, meme les threads dont le sujet ne t'évoque rien, parfois lire le problème et quelques lignes plus bas la solution, te fera découvrir des classes très utiles du framework.

Accéder aux métadonnées d'un fichier

Windows Forms

Discussions similaires

Partager

Partager