Comment créer une Interface incluant du code

Version imprimable

10/08/2011, 15h17
Passepoil

Comment créer une Interface incluant du code

Bonjour,

L'interface IDisposable implémente du code et des commentaires dans la classe où il est implémenter.

Comment créer une telle interface incluant du code et des commentaires ?

Merci d'avance,

Pascal
10/08/2011, 18h05
hunteshiva

Bonjour,

en regardant du coté MSDN, tu trouvera p-e des réponses:
http://msdn.microsoft.com/fr-fr/libr...isposable.aspx

;)

Une interface n'implémente jamais de code. Pour référence, voici le contenu de IDisposable:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 using System; using System.Runtime.InteropServices; namespace System { /// <summary>Defines a method to release allocated resources.</summary> /// <filterpriority>2</filterpriority> [ComVisible(true)] public interface IDisposable { /// <summary>Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.</summary> /// <filterpriority>2</filterpriority> void Dispose(); } }
Le concept le plus proche de ce que tu appelles "une interface avec du code" est la classe abstraite. Les classes qui en héritent doivent implémenter les membres marqués MustInherit. Mais une classe abstraite peux aussi contenir des membres concrêts dont vont bénéficier les classes qui en héritent.

Plus d'info ici: http://mbenzeghiba.developpez.com/tu...heritagevbnet/

Exemple:

public abstract class MyBase

hunteshiva,
j'avais déjà regardé de ce côté, MSDN explique plutôt l'implémentation que la conception.

SaumonAgile,
je connais bien les classes abstraites et ce n'est pas du tout ce que je recherche à faire.
L'interface IDisposable insère du code et des commentaires en plus des simples déclarations de méthodes et propriétés. Pour preuve, j'ai créé une classe vide et ajouté la ligne de code: "Implements IDisposable" et voici le résultat :

Code:

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
 
Public Class Class1
    Implements IDisposable
 
#Region "IDisposable Support"
    Private disposedValue As Boolean ' To detect redundant calls
 
    ' IDisposable
    Protected Overridable Sub Dispose(ByVal disposing As Boolean)
        If Not Me.disposedValue Then
            If disposing Then
                ' TODO: dispose managed state (managed objects).
            End If
 
            ' TODO: free unmanaged resources (unmanaged objects) and override Finalize() below.
            ' TODO: set large fields to null.
        End If
        Me.disposedValue = True
    End Sub
 
    ' TODO: override Finalize() only if Dispose(ByVal disposing As Boolean) above has code to free unmanaged resources.
    'Protected Overrides Sub Finalize()
    '    ' Do not change this code.  Put cleanup code in Dispose(ByVal disposing As Boolean) above.
    '    Dispose(False)
    '    MyBase.Finalize()
    'End Sub
 
    ' This code added by Visual Basic to correctly implement the disposable pattern.
    Public Sub Dispose() Implements IDisposable.Dispose
        ' Do not change this code.  Put cleanup code in Dispose(ByVal disposing As Boolean) above.
        Dispose(True)
        GC.SuppressFinalize(Me)
    End Sub
#End Region
 
End Class

D'autres idées ?

Pascal

10/08/2011, 21h33
Nathanael Marchand

Un outils (visual studio? resharper? un autre?) t'as géneré du code pour une implémentation courante de IDisposable. Il n'y a pas de code dans une interface.
10/08/2011, 23h28
SaumonAgile

A mon avis c'est un snippet qui est responsable. C'est simplement un morceau de code configurable associé à un mot-clé.
Fais une recherche sur les code snippets de Visual Studio pour comprendre comment cela fonctionne.

interface imbrique avec un peu de code

bonjour passepoil
Bon avec un peu de ruse ty parviens quoique en soit une interface a ete concue pour eviter d'ecrire du code.....
voici une interface qui contient une classe imbrique quoique il est preferable d'eviter d'ecrire un tel code puisqu'il peut etre reecrit en imbriquant 2 interfaces...

Code:

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
 
Public Class Form1
    Private objComputerAsset As ComputerAsset
    Public Sub New()
 
        ' Cet appel est requis par le Concepteur Windows Form.
        InitializeComponent()
 
        ' Ajoutez une initialisation quelconque après l'appel InitializeComponent().
 
    End Sub
 
    Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click
        objComputerAsset = New ComputerAsset("IBM", 5)
        objComputerAsset.Imbrique.Num = 125
        MessageBox.Show("from Form1 Num :" & objComputerAsset.Imbrique.Num)
        objComputerAsset.Imbrique.sub1(211)
    End Sub
End Class
Interface IAsset
    Event ComittedChange(ByVal Success As Boolean)
    Property Division() As String
    Function GetID() As Integer
    'Cette Classe Imbrique permet d'ecrire du code dans 
    'l'interface IAsset
    Class ClasseImbrique
        Dim INum As Integer = 0
        Sub sub1(ByVal i As Integer)
            ' Insert code here that implements this method.
            MessageBox.Show("from ClasseImbrique sub1 :" & i.ToString)
        End Sub
 
        Public Property Num() As Integer
            Get
                Num = INum
            End Get
            Set(ByVal value As Integer)
                INum = value
                MessageBox.Show("from ClasseImbrique  INum :" & INum.ToString)
            End Set
        End Property
    End Class
    'Permettra d'acceder à ClasseImbrique
    'dans les classes qui implemente l'interfaceIAsset
    Property Imbrique() As ClasseImbrique
 
 
End Interface
'cette classe implement IAsset
Class ComputerAsset
    Implements IAsset
    Private classeimbriqueValue As IAsset.ClasseImbrique
 
    Public Event ComittedChange(ByVal Success As Boolean) _
       Implements IAsset.ComittedChange
    'implemente property Division
    Private divisionValue As String
    Public Property Division() As String _
        Implements IAsset.Division
 
        Get
            Return divisionValue
        End Get
        Set(ByVal value As String)
            divisionValue = value
            RaiseEvent ComittedChange(True)
        End Set
    End Property
    'implemente Function GetID
    Private IDValue As Integer
 
    Public Function GetID() As Integer _
        Implements IAsset.GetID
 
        Return IDValue
    End Function
    'implemente Ctor
    Public Sub New(ByVal Division As String, ByVal ID As Integer)
        Me.divisionValue = Division
        Me.IDValue = ID
        classeimbriqueValue = New IAsset.ClasseImbrique
    End Sub
    'implemente ClasseImbrique GetID
 
    Public Property Imbrique() As IAsset.ClasseImbrique Implements IAsset.Imbrique
        Get
            Return classeimbriqueValue
        End Get
        Set(ByVal value As IAsset.ClasseImbrique)
            classeimbriqueValue = value
        End Set
    End Property
End Class

mais comme dit ci-dessus et pour appuyer ce qu'as dit Nathanael ,il vaudrait mieux definir une 2eme interface nomme IClasseImbrique pour ClasseImbrique
Et ...imbriquer............IClasseImbrique.......
Sur ce comme je jeune je ne dirais pas plus ,par sobriete voulue .........
Bon code....

11/08/2011, 13h18
Passepoil

SaumonAgile,

C'est effectivement un snippet dans Visual Studio qui insère le code et les commentaires.

Merci de votre aide.

Pascal