Wie kann ich eine Klasse sinnvoll aufbauen ?

[TMC]

Danke, aber was ich hier nicht kapiere:

Public Function getInstance(item As NotesItem) As HistoryField

Ich sehe da eine Factory, die sozusagen übergeordnet mir ein Haufen Objekte erstellt.

Den Aufruf hätt ich mir jetzt so gedacht:

Class FieldFactory
   Private m_HistoryFieldRT as RTHistoryFieldRT
   Private m_HistoryFieldText as RTHistoryFieldText
   Private m_HistoryFieldDatum as RTHistoryFieldDatum

  Sub new(item As NotesItem)
      Select Case item.Type
        Case 1:
            Set m_HistoryFieldRT = New RTHistoryFieldRT(item)
        Case Else:
            Set m_HistoryFieldText = New m_HistoryFieldText(item)
      End Select
  End Sub

End Class

Warum macht man / machst Du das über eine Function? Warum steht da "As HistoryField" ?

[animate]

schwierig zu erklären (weil das im Moment für mich offensichtlich ist und ich mir diese Frage noch nie gestellt habe)

naja, was für ein Objekt brauchst du denn?
eine Instanz der Klasse HistoryField bzw. einer Subklasse davon.
von dem möchtest du ja dann mal die Unterschiede erfragen.
deshalb lassen wir uns von der Factory eins geben und arbeiten damit weiter.

es gibt nur ein einziges Factory-Objekt.
aber viele HistoryField-Objekte.
die Factory hat wirklich nur die Aufgabe, Objekte zu erzeugen und dem Aufrufer zurückzugeben.
Eine Factory nimmst du, damit das Wissen, unter welchen Umständen welches HistoryField-Objekt erzeugt werden muss, an einer Stelle ist.
Du hast ja schon erkannt, dass es evtl. nicht so geschickt ist, dieses Wissen auch noch in die History-Klasse zu packen bzw. dass es logisch gesehen nicht dort hingehört.

[TMC]

Sorry, checke es noch überhaupt nicht.

es gibt nur ein einziges Factory-Objekt.
aber viele HistoryField-Objekte.

Vielleicht macht es das einfacher:
Mit welchem Code würdest Du den das Factory-Objekt erzeugen?

Rufst Du dann n mal die Public Function getInstance auf?

[animate]

Ja genau.

Anstelle des
Set oHistoryFeld = New RTHistoryFeld(item)

das du jetzt machst,

machst du

Set oHistoryFeld = oFactory.getInstance(item)

vorher musst du einmal die Factory erstellen.

[TMC]

Verstehe es noch nicht:

Wir haben hier das History-Objekt (gibt’s nur einmal).
Das History-Objekt erzeugen wir beim Öffnen des Dokumentes (PostOpen).

Im Konstruktor (sub new()) des HistoryObjektes
 - machen wir ein Set HistoryFactory = New HistoryFactory()
 - Pro Feld machen wir ein “HistoryFactory.getInstance(item(i))”

Dann hab ich jetzt meine Objekte erzeugt.

War es das was Du meintest?
Ich habe doch damit gar nicht meine HistoryField - Objekte in einem Array?

Ich sehe wohl den Wald vor lauter Bäumen nicht....

[animate]

die Objekte musst du selber noch in das Array packen.
In einer Schleife (die, die du schon vorher benutzt hast, um die Objekte zu erzeugen)
In der History-Klasse.
Wenn du den Code der History-Klasse postest, kann ich dir zeigen wo.

[TMC]

Wenn du den Code der History-Klasse postest, kann ich dir zeigen wo.

Prima, ich mach erstmal die Klassen alle fertig und poste dann den Code bzw. die nsf ....

[TMC]

OK, habe den aktuellen Stand angehängt.
Aufgrund des R5-Debug-Problems entwickle ich das jetzt in ND6 (versuche aber R5-kompatibel zu bleiben).

Hier noch die HistoryMain-Klasse als Code:

Code

'HistoryMainClass:

Option Declare
'--------------------------------------------------------------------
Use "HistoryAuxiliaryRoutines"
Use "HistoryFieldClass"
Use "HistoryEntryClass"
'--------------------------------------------------------------------
'Konstanten
Const MAX_SIZE# = 5000 'Maximale Größe in Bytes des History-Feldes
Const FIELDNAME_HISTORY$ = "History"  'Feldname des History-Feldes
'--------------------------------------------------------------------
Public Class HistoryMain

   Private m_doc As NotesDocument
   Private m_strHistoryFieldNames As String
   Private m_vaHistoryFieldNames As Variant
   Private m_strHistoryFieldTitles As String
   Private m_vaHistoryFieldTitles As Variant
   Private m_iHistoryFieldAmount As Integer 'Anzahl zu überwachender Felder
   Private m_iMaxEntryAmount As Integer
   Private m_strTextNew As String
   Private m_HistoryFields() As HistoryField
   Private m_strDifferences() As String
   Private m_strHistoryFieldname As String
   '--> Klasse 'HistoryEntry'
   Private m_HistoryEntry As HistoryEntry 'Neuer Eintrag
   Private m_HistoryEntries() As HistoryEntry 'Array aller History-Einträge
   Private m_EntryCount As Integer 'Anzahl der Einträge des HistoryFeldes
   '<---

   '-------------------------------------------------------------------------------------------------------------------------
   Public Sub new(doc As NotesDocument, strHistoryFieldNames As String, strHistoryFieldTitles As String, iMaxEntryAmount As Integer, strTextNew As String)
      Dim iLB As Integer
      Dim iUB As Integer

      '---> Setze Membervariablen
      Set m_doc = doc
      m_strHistoryFieldNames = strHistoryFieldNames
      m_strHistoryFieldTitles = strHistoryFieldTitles
      m_iMaxEntryAmount = iMaxEntryAmount
      m_strTextNew = strTextNew
      '<---

      '---> Die zu prüfenden Felder ermitteln
      m_vaHistoryFieldNames = AuxExplode(m_strHistoryFieldNames, "##")
      m_vaHistoryFieldTitles = AuxExplode(m_strHistoryFieldTitles, "##")
      'Prüfen ob beide Arrays die gleiche Anzahl an Einträgen haben; falls nicht werden als Titel die Feldnamen übernommen.
      iLB = Lbound(m_vaHistoryFieldNames) - Lbound(m_vaHistoryFieldTitles)
      iUB = Ubound(m_vaHistoryFieldNames) - Ubound(m_vaHistoryFieldTitles)
      If (iLB <> 0) Or (iUB <> 0) Then
         m_vaHistoryFieldTitles = m_vaHistoryFieldNames
      End If
      'Ermitteln der Anzahl zu überwachender Felder
      m_iHistoryFieldAmount = Ubound(m_vaHistoryFieldNames) - Lbound(m_vaHistoryFieldNames) + 1
      'So, nun haben wir:
      '                      m_vaHistoryFieldNames = die zu überwachenden Item-Namen in Array
      '                      m_vaHistoryFieldTitles = die Titel der Felder
      '                      m_iHistoryFieldAmount = die Anzahl der Felder
      '<---

      'Erstellen der HistoryField - Objekte in einem Array
      Call initHistoryFields()
      'Nun erzeugen wir noch die HistoryEntry-Objekte. Pro bisherigen Eintrag im History-Feld erzeugen wir 1 HistoryEntryObjekt
      Call initHistoryEntries()
   End Sub
   '-------------------------------------------------------------------------------------------------------------------------
   Private Sub initHistoryFields()
      'Erstellen der HistoryField - Objekte in einem Array
      Dim itmField As NotesItem
      Dim i As Integer
      For i = 0 To m_iHistoryFieldAmount - 1
         Set itmField = m_doc.GetFirstItem(m_vaHistoryFieldNames(i))
         Redim Preserve m_HistoryFields(i)
         Set m_HistoryFields(i) = New HistoryField(itmField, m_vaHistoryFieldTitles(i))
      Next
   End Sub
   '-------------------------------------------------------------------------------------------------------------------------
   Private Sub initHistoryEntries()
      'Erstellt HistoryEntry - Objekte. Pro History-Eintrag wird ein HistoryEntry-Objekt erzeugt
      'Ergebnis steht im Array  'm_HistoryEntries'
      Dim Entry As HistoryEntry
      Dim iContinue As Integer
      m_EntryCount = 0

      iContinue = True
      Do
         Set Entry = New HistoryEntry
         Call Entry.readFromDoc(m_doc, m_EntryCount)
         If Entry.size > 0 Then
            Redim Preserve m_HistoryEntries(m_EntryCount)
            Set m_HistoryEntries(m_EntryCount) = Entry
            m_EntryCount = m_EntryCount + 1
         Else
            iContinue = False
         End If
      Loop While (iContinue = True)
   End Sub
   '-------------------------------------------------------------------------------------------------------------------------
   Public Sub save()
      'Wir schreiben hier die Änderungen in das History-Feld
      '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
      'Änderungen in das Array 'm_strDifferences'
      Call getHistoryDifferences()

      'History schreiben
      If Not (m_strDifferences(0) = "NOCHANGES") Then  'History nur schreiben wenn Änderungen stattgefunden haben
         Call writeHistory()
         Call m_doc.Save(True, True)
      End If

      'Aufräumen und neu initiieren
      Call CleanupAndInitiate()

   End Sub
   '-------------------------------------------------------------------------------------------------------------------------
   Private Sub getHistoryDifferences()
      Dim i As Integer
      Dim iCount As Integer
      Dim strDifference As String

      If m_doc.IsNewNote Then 'Falls es sich um ein neues Doc handelt
         Redim m_strDifferences(0)
         m_strDifferences(0) = m_strTextNew
         Exit Sub
      End If

      'Wir bekommen die Unterschiede in das Array "m_strDifferences"
      iCount = -1
      For i = 0 To m_iHistoryFieldAmount - 1
         strDifference = m_HistoryFields(i).difference
         If Not strDifference = "" Then
            iCount = iCount + 1
            Redim Preserve m_strDifferences(iCount)
            m_strDifferences(iCount) = strDifference
         End If
      Next
      If iCount = -1 Then 'Es gab keine Unterschiede
         Redim m_strDifferences(0)
         m_strDifferences(0) = "NOCHANGES" 'Es gab keine Änderung !
      End If

      'Nun stehen die Änderungen in "m_strDifferences"
   End Sub
   '-------------------------------------------------------------------------------------------------------------------------
   Private Sub writeHistory()

      'Klasse für Historyeintrag
      Set m_HistoryEntry = New HistoryEntry
      Redim Preserve m_HistoryEntries(m_EntryCount)
      Set m_HistoryEntries(m_EntryCount) = m_HistoryEntry
      m_EntryCount = m_EntryCount + 1


     'Werte vergleichen und Ergebnisse an den HistoryEntry geben
      m_HistoryEntry.Action = m_strDifferences

      Dim nHowManyEntries As Integer
      Dim nStart As Integer
      Dim i As Integer

      Call clear()

      nHowManyEntries = getMaxEntries()

      nStart = (Ubound(m_HistoryEntries)+1) - nHowManyEntries
      For i = nStart To Ubound(m_HistoryEntries)
            'History-Eintrag ins Dokument schreiben
         Set m_HistoryEntry = m_HistoryEntries(i)
         Call m_HistoryEntry.write(m_doc)
      Next

   End Sub
   '-------------------------------------------------------------------------------------------------------------------------
   Private Sub clear()
      Call m_doc.ReplaceItemValue(FIELDNAME_HISTORY, "")
   End Sub
   '-------------------------------------------------------------------------------------------------------------------------
   Private Function getMaxEntries() As Integer
      Dim i As Integer
      Dim entry As HistoryEntry
      Dim iTotalSize As Integer
      getMaxEntries = 0

      For i = Ubound(m_HistoryEntries) To Lbound(m_HistoryEntries) Step -1
         Set entry = m_HistoryEntries(i)
         iTotalSize = iTotalSize + entry.size
         If iTotalSize > MAX_SIZE Then
            Msgbox "Maximal erlaubte Größe in Bytes (" & Cstr(MAX_SIZE) & ") wurde überschritten"
            Exit For 'Exit Function
         End If
         getMaxEntries = getMaxEntries + 1
      Next
      'Nun prüfen wir ob die Anzahl erlaubter Einträge dadurch nicht überschritten wird
      If   getMaxEntries > m_iMaxEntryAmount Then
         Print "Max. Anzahl Einträge (" & Cstr(m_iMaxEntryAmount) & ") wurde überschritten"
         getMaxEntries = m_iMaxEntryAmount
      End If
   End Function
   '-------------------------------------------------------------------------------------------------------------------------
   Private Sub CleanupAndInitiate()
   'Neue Werte in als InitialValue schreiben, für den Fall dass erneut gespeichert wird
      Dim i As Integer
      For i = 0 To m_iHistoryFieldAmount - 1
         Call m_HistoryFields(i).setInitialValue
      Next

   'HistoryEntries neu initiieren
      Erase m_HistoryEntries
      Call initHistoryEntries()

   End Sub
   '-------------------------------------------------------------------------------------------------------------------------
End Class

[TMC]

Hier noch das aktuelle UML-Diagramm (-> ist-Stand):


Und so - oder so ähnlich - glaub ich sollte das dann mal ausschauen (rechts sind die methods und properties noch nicht gefüllt):

[TMC]

in dem Link, den du im Tipps Bereich gepostet hast
(http://www.lotusgeek.com/SapphireOak/LotusGeekBlog.nsf/plinks/ROLR-5UV6YM)
da ist ein Posting von mir, dass zeigt, wie du das machen kannst.
Da sind zwei Klassen (AbstractImportFactory und ExcelFactory).
In der AbstractImportFactory ist die Methode init(), allerdings nur die Signatur.
In der Excel Factory gibts die Methode auch, hier ist die wirkliche Funktionalität implementiert.

Ich hab den Code von Dir mal in eine ND6 - DB kopiert zur besseren Übersicht.

[TMC]

Habe gerade noch einen Bug in der history_06.nsf entdeckt:

Wird ein Zahlenfeld zur Überwachung herangezogen, und man speichert das Dok 1mal, ändert danach das Zahlenfeld aber nicht und macht erneut Ctrl+s, dann wird immer und immer wieder eine Zeile geschrieben, dass sich Zahlenfeld geändert.
Die unterstützende Function "AuxCompareValues" hab ich schon getestet, die erkennt zuverlässig Unterschiede auch von Zahlenfeldern. Muss also an was anderem liegen.....

[TMC]

** Update **

+ Bug entfernt (Zahlenfelder)

+ Klassen teilweise dokumentiert (siehe View "Class Documentation")

+ Zu überwachende Felder werden als String-Array übergeben

+ Erweiterung der History-Klasse
   -> Nun können auch manuell Einträge hinzugefügt werden (z.B. über Workflow-
       anwendung)

[animate]

kann ich leider im Moment net bestaunen. Hab kein Notes zur Hand.
Sobald ich kann, gebe ich Feedback.

[TMC]

Sobald ich kann, gebe ich Feedback.

OK, prima.

Ich habe mittlerweile das Gefühl, dass die "HistoryMain" - Klasse viel zu aufgebläht ist. Vielleicht sollte man die nochmal auftrennen.

[-Michael-]

Ich habe mal versucht, Eurem Thread ansatzweise zu folgen. (obwohl dies mehr überflogen war aufgrund 10 Seiten Thread).

Was mir aufgefallen ist:

Eigentlich ist ein Objekt immer klar.

Ein Flugzeug ist eben ein Flugzeug.
Ein Auto ein Auto.

Das HistoryMain - Objekt (zumindest lt. dem obigen Code) ist als Objekt nicht mehr transparent für mich.

Was genau ist ein HistoryMain-Objekt? Was ist es im Vergleich zu einem Auto?

Aber ich will Euch hier nicht weiter stören..... Ist mir halt nur als "Außenstehenden" so aufgefallen. Die HistoryField-Klasse und die HistoryEntry-Klasse ist mir klar und wurde auch entsprechend sauber abgegrenzt definiert.

Michael

[Semeaphoros]

Au Michael, wie wäre die Welt schön, wenn Deine Behauptung stimmte:

Eigentlich ist ein Objekt immer klar.

In der Praxis ist genau das eines der grössten Probleme: die genaue und logische Abgrenzung der Objekte untereinander. Beispiel, das mal von einem Hörer in einem meiner Vorträge aufgebracht wurde: Eingabevalidierungen: gehören die jetzt in die Frontend-Klasse oder in die Backend-Klasse?

Tja, lässt sich nicht allgemein beantworten. Die Sicherstellung der Datenkonsistenz (wovon die Validierung ein Teil ist) gehört ins Backend spätestens dann, wenn neben der direkten Eingabe auch andere Datenquellen wie Import in Frage kommen. Hingegen das Mitteilen eines fehlenden/falschen Wertes ist Sache des Frontends, schlimmstenfalls muss man das  in so einem Fall offensichtlich auf 2 Objekte verteitlen - das heisst, wenn man überhaupt dem Objektmodell folgt, so wie es Notes selber vorgibt (man könnte das auch anders machen)

[animate]

Was genau ist ein HistoryMain-Objekt? Was ist es im Vergleich zu einem Auto?

Aber ich will Euch hier nicht weiter stören..... Ist mir halt nur als "Außenstehenden" so aufgefallen. Die HistoryField-Klasse und die HistoryEntry-Klasse ist mir klar und wurde auch entsprechend sauber abgegrenzt definiert.

Du störst nicht.

vielleicht kannst du mit folgender Analogie was anfangen:

HistoryMain zu HistoryEntry - Klasse verhält sich so wie eine Liste zu ihren Einträgen (z.B. Rechnung - Rechnungsposition)

Hilft das schon?

[koehlerbv]

Oder - um bei Deiner Analogie zu bleiben, Michi: HistoryMain ist "Fortbewegungsmittel", HistoryEntry wäre dann "Auto".
Und ein Auto ist ein Auto und ein Fortbewegungsmittel.

Cu koFr (hoffentlich),
Bernhard

[-Michael-]

vielleicht kannst du mit folgender Analogie was anfangen:

HistoryMain zu HistoryEntry - Klasse verhält sich so wie eine Liste zu ihren Einträgen (z.B. Rechnung - Rechnungsposition)

Hilft das schon?

Danke, das erklärt einiges.

@Bernhard: Deine Erklärung bestätigt mir das, danke.
Schön dass Du mal wieder bei uns vorbeischaust  

[-Michael-]

Au Michael, wie wäre die Welt schön, wenn Deine Behauptung stimmte:

Eigentlich ist ein Objekt immer klar.

Stimmt wohl was Du sagst. Es fehlte mir als Außenstehenden auch etwas der Zusammenhang. Wobei: Ein Blick auf die UML-Diagramme hätte mir die Zusammenhänge gezeigt....

Jedenfalls bin ich froh darüber, dass es diesen Thread hier gibt. Ich werde versuchen den weiter (zumindest passiv) zu verfolgen - gerade Dinge wie abstrakte Klassen, Factory-Klassen etc. finde ich sehr interessant.

Michael