Beste Möglichkeit zur Versionskontrolle für MS Excel

Welche Versionskontrollsysteme haben Sie mit MS Excel (2003/2007) verwendet? Was würden Sie empfehlen und warum? Welche Einschränkungen haben Sie bei Ihrem bestbewerteten Versionskontrollsystem festgestellt?

Um dies ins rechte Licht zu rücken, hier einige Anwendungsfälle:

1. Versionskontrolle für VBA-Module
2. Mehrere Personen arbeiten an einer Excel-Tabelle und nehmen möglicherweise Änderungen an demselben Arbeitsblatt vor, das sie zusammenführen und integrieren möchten. Dieses Arbeitsblatt kann Formeln, Daten, Diagramme usw. Enthalten
3. Die Benutzer sind nicht zu technisch und je weniger Versionskontrollsysteme verwendet werden, desto besser
4. Platzbeschränkungen sind eine Überlegung. Im Idealfall werden nur inkrementelle Änderungen gespeichert und nicht die gesamte Excel-Tabelle.

Ich habe gerade eine Tabelle eingerichtet, die Bazaar verwendet, mit manuellem Ein- und Auschecken über TortiseBZR. Da mir das Thema beim Speichern geholfen hat, wollte ich meine Lösung hier veröffentlichen.

Die Lösung für mich bestand darin, eine Tabelle zu erstellen, die alle Module beim Speichern exportiert und die Module beim Öffnen entfernt und erneut importiert. Ja, dies kann möglicherweise gefährlich für die Konvertierung vorhandener Tabellenkalkulationen sein.

Auf diese Weise kann ich die Makros in den Modulen über Emacs (ja, Emacs) oder nativ in Excel bearbeiten und mein BZR-Repository nach größeren Änderungen festschreiben. Da alle Module Textdateien sind, funktionieren die Standardbefehle im Diff-Stil in BZR für meine Quellen mit Ausnahme der Excel-Datei selbst.

Ich habe ein Verzeichnis für mein BZR-Repository eingerichtet: X: \ Data \ MySheet. Im Repo befinden sich MySheet.xls und eine .vba-Datei für jedes meiner Module (dh: Module1Macros). In meiner Tabelle habe ich ein Modul hinzugefügt, das vom Export- / Importzyklus ausgenommen ist und "VersionControl" heißt. Jedes Modul, das exportiert und erneut importiert werden soll, muss mit "Makros" enden.

Inhalt des Moduls "VersionControl":

Sub SaveCodeModules()

'This code Exports all VBA modules
Dim i%, sName$

With ThisWorkbook.VBProject
    For i% = 1 To .VBComponents.Count
        If .VBComponents(i%).CodeModule.CountOfLines > 0 Then
            sName$ = .VBComponents(i%).CodeModule.Name
            .VBComponents(i%).Export "X:\Tools\MyExcelMacros\" & sName$ & ".vba"
        End If
    Next i
End With

End Sub

Sub ImportCodeModules()

With ThisWorkbook.VBProject
    For i% = 1 To .VBComponents.Count

        ModuleName = .VBComponents(i%).CodeModule.Name

        If ModuleName <> "VersionControl" Then
            If Right(ModuleName, 6) = "Macros" Then
                .VBComponents.Remove .VBComponents(ModuleName)
                .VBComponents.Import "X:\Data\MySheet\" & ModuleName & ".vba"
           End If
        End If
    Next i
End With

End Sub

Als nächstes müssen wir Event-Hooks für open / save einrichten, um diese Makros auszuführen. Klicken Sie im Code-Viewer mit der rechten Maustaste auf "ThisWorkbook" und wählen Sie "Code anzeigen". Möglicherweise müssen Sie das Auswahlfeld oben im Codefenster herunterziehen, um von der Ansicht "(Allgemein)" zur Ansicht "Arbeitsmappe" zu wechseln.

Inhalt der Ansicht "Arbeitsmappe":

Private Sub Workbook_Open()

ImportCodeModules

End Sub

Private Sub Workbook_BeforeSave(ByVal SaveAsUI As Boolean, Cancel As Boolean)

SaveCodeModules

End Sub

Ich werde mich in den nächsten Wochen in diesen Workflow einarbeiten und bei Problemen posten.

Vielen Dank, dass Sie den VBComponent-Code geteilt haben!

TortoiseSVN ist ein erstaunlich guter Windows-Client für das Versionskontrollsystem Subversion. Eine Funktion, die ich gerade entdeckt habe, ist, dass beim Klicken auf einen Unterschied zwischen den Versionen einer Excel-Datei beide Versionen in Excel geöffnet und die geänderten Zellen (rot) hervorgehoben werden. Dies geschieht durch die Magie eines hier beschriebenen vbs-Skripts .

Sie können dies nützlich finden, auch wenn Sie TortoiseSVN NICHT verwenden.

Lassen Sie mich zusammenfassen, was Sie zur Versionskontrolle möchten und warum:

1. Was:

   • Code (VBA)
   • Tabellenkalkulationen (Formeln)
   • Tabellenkalkulationen (Werte)
   • Diagramme
   • ...

2. Warum:

   • Audit-Log
   • Zusammenarbeit
   • Versionsvergleich ("unterschiedlich")
   • Zusammenführen

Wie andere hier gepostet haben, gibt es zusätzlich zu den vorhandenen Versionskontrollsystemen einige Lösungen wie:

• Git
• Mercurial
• Subversion
• Basar

Wenn Sie sich nur um den VBA-Code in Ihren Arbeitsmappen kümmern, schlägt der oben vorgeschlagene Ansatz von Demosthenex vor oder VbaGit ( https://github.com/brucemcpherson/VbaGit ) funktioniert sehr gut und ist relativ einfach zu implementieren. Die Vorteile sind, dass Sie sich auf bewährte Versionskontrollsysteme verlassen und eines entsprechend Ihren Anforderungen auswählen können (siehe https://help.github.com/articles/what-are-the-differences-between-svn-and -git / für einen kurzen Vergleich zwischen Git und Subversion).

Wenn Sie sich nicht nur um Code, sondern auch um die Daten in Ihren Blättern kümmern ("fest codierte" Werte und Formelergebnisse), können Sie eine ähnliche Strategie anwenden: Serialisieren Sie den Inhalt Ihrer Blätter in ein Textformat (über Range.Value). und verwenden Sie ein vorhandenes Versionskontrollsystem. Hier ist ein sehr guter Blog-Beitrag dazu: https://wiki.ucl.ac.uk/display/~ucftpw2/2013/10/18/Using+git+for+version+control+of+spreadsheet+models+-+part + 1 + von + 3

Der Tabellenkalkulationsvergleich ist jedoch ein nicht triviales algorithmisches Problem. Es gibt einige Tools, z. B. Microsoft Spreadsheet Compare ( https://support.office.com/en-us/article/Overview-of-Spreadsheet-Compare-13fafa61-62aa-451b-8674-242ce5f2c986 ), Exceldiff ( http://exceldiff.arstdesign.com/ ) und DiffEngineX ( https://www.florencesoft.com/compare-excel-workbooks-differences.html ). Es ist jedoch eine weitere Herausforderung, diesen Vergleich in ein Versionskontrollsystem wie Git zu integrieren.

Schließlich müssen Sie sich auf einen Workflow festlegen, der Ihren Anforderungen entspricht. Einen einfachen, maßgeschneiderten Git for Excel-Workflow finden Sie unter https://www.xltrail.com/blog/git-workflow-for-excel .

Es hängt davon ab, ob Sie über Daten oder den in einer Tabelle enthaltenen Code sprechen. Ich habe zwar eine starke Abneigung gegen Microsoft Visual Sourcesafe und würde es normalerweise nicht empfehlen, aber es lässt sich problemlos in Access und Excel integrieren und bietet Quellcodeverwaltung für Module.

[Tatsächlich umfasst die Integration in Access Abfragen, Berichte und Module als einzelne Objekte, die versioniert werden können.]

Der MSDN-Link ist hier .

Mir ist kein Tool bekannt, das dies gut macht, aber ich habe eine Vielzahl von selbst entwickelten Lösungen gesehen. Der rote Faden dabei ist, die unter Versionskontrolle stehenden Binärdaten zu minimieren und die Textdaten zu maximieren, um die Leistung herkömmlicher scc-Systeme zu nutzen. Um dies zu tun:

• Behandeln Sie die Arbeitsmappe wie jede andere Anwendung. Separate Logik, Konfiguration und Daten.
• Trennen Sie den Code von der Arbeitsmappe.
• Erstellen Sie die Benutzeroberfläche programmgesteuert.
• Schreiben Sie ein Build-Skript, um die Arbeitsmappe zu rekonstruieren.

Bei der Arbeit an @ Demosthenex arbeiten @Tmdean und @ Jon Crowell von unschätzbarem Wert! (+1 ihnen)

Ich speichere Moduldateien in git \ dir neben dem Speicherort der Arbeitsmappe. Ändern Sie das nach Ihren Wünschen.

Dadurch werden KEINE Änderungen am Arbeitsmappencode verfolgt. Es liegt also an Ihnen, sie zu synchronisieren.

Sub SaveCodeModules()

'This code Exports all VBA modules
Dim i As Integer, name As String

With ThisWorkbook.VBProject
    For i = .VBComponents.count To 1 Step -1
        If .VBComponents(i).Type <> vbext_ct_Document Then
            If .VBComponents(i).CodeModule.CountOfLines > 0 Then
                name = .VBComponents(i).CodeModule.name
                .VBComponents(i).Export Application.ThisWorkbook.Path & _
                                            "\git\" & name & ".vba"
            End If
        End If
    Next i
End With

End Sub

Sub ImportCodeModules()
Dim i As Integer
Dim ModuleName As String

With ThisWorkbook.VBProject
    For i = .VBComponents.count To 1 Step -1

        ModuleName = .VBComponents(i).CodeModule.name

        If ModuleName <> "VersionControl" Then
            If .VBComponents(i).Type <> vbext_ct_Document Then
                .VBComponents.Remove .VBComponents(ModuleName)
                .VBComponents.Import Application.ThisWorkbook.Path & _
                                         "\git\" & ModuleName & ".vba"
            End If
        End If
    Next i
End With

End Sub

Und dann im Arbeitsmappenmodul:

Private Sub Workbook_Open()

    ImportCodeModules

End Sub

Private Sub Workbook_BeforeSave(ByVal SaveAsUI As Boolean, Cancel As Boolean)

    SaveCodeModules

End Sub

Wenn Sie die Antwort von @Demosthenex noch einen Schritt weiter gehen, müssen Sie ein wenig knifflig werden, wenn Sie auch den Code in Ihren Microsoft Excel-Objekten und UserForms verfolgen möchten.

Zuerst habe ich meine SaveCodeModules()Funktion geändert , um die verschiedenen Codetypen zu berücksichtigen, die ich exportieren möchte:

Sub SaveCodeModules(dir As String)

'This code Exports all VBA modules
Dim moduleName As String
Dim vbaType As Integer

With ThisWorkbook.VBProject
    For i = 1 To .VBComponents.count
        If .VBComponents(i).CodeModule.CountOfLines > 0 Then
            moduleName = .VBComponents(i).CodeModule.Name
            vbaType = .VBComponents(i).Type

            If vbaType = 1 Then
                .VBComponents(i).Export dir & moduleName & ".vba"
            ElseIf vbaType = 3 Then
                .VBComponents(i).Export dir & moduleName & ".frm"
            ElseIf vbaType = 100 Then
                .VBComponents(i).Export dir & moduleName & ".cls"
            End If

        End If
    Next i
End With

End Sub

Die UserForms können wie VBA-Code exportiert und importiert werden. Der einzige Unterschied besteht darin, dass beim Exportieren eines Formulars zwei Dateien erstellt werden (Sie erhalten für jede UserForm eine .frmund eine .frxDatei). Eine davon enthält die von Ihnen geschriebene Software und die andere ist eine Binärdatei, die (da bin ich mir ziemlich sicher) das Layout des Formulars definiert.

Microsoft Excel - Objekte (MEOs) ( im Sinne Sheet1, Sheet2, ThisWorkbooketc.) können als exportiert werden .clsDatei. Wenn Sie diesen Code jedoch wieder in Ihre Arbeitsmappe aufnehmen möchten und versuchen, ihn wie ein VBA-Modul zu importieren, wird eine Fehlermeldung angezeigt, wenn dieses Blatt bereits in der Arbeitsmappe vorhanden ist.

Um dieses Problem zu umgehen, habe ich beschlossen, nicht zu versuchen, die CLS-Datei in Excel zu importieren, sondern die .clsDatei stattdessen als Zeichenfolge in Excel zu lesen und diese Zeichenfolge dann in das leere MEO einzufügen. Hier sind meine ImportCodeModules:

Sub ImportCodeModules(dir As String)

Dim modList(0 To 0) As String
Dim vbaType As Integer

' delete all forms, modules, and code in MEOs
With ThisWorkbook.VBProject
    For Each comp In .VBComponents

        moduleName = comp.CodeModule.Name

        vbaType = .VBComponents(moduleName).Type

        If moduleName <> "DevTools" Then
            If vbaType = 1 Or _
                vbaType = 3 Then

                .VBComponents.Remove .VBComponents(moduleName)

            ElseIf vbaType = 100 Then

                ' we can't simply delete these objects, so instead we empty them
                .VBComponents(moduleName).CodeModule.DeleteLines 1, .VBComponents(moduleName).CodeModule.CountOfLines

            End If
        End If
    Next comp
End With

' make a list of files in the target directory
Set FSO = CreateObject("Scripting.FileSystemObject")
Set dirContents = FSO.getfolder(dir) ' figure out what is in the directory we're importing

' import modules, forms, and MEO code back into workbook
With ThisWorkbook.VBProject
    For Each moduleName In dirContents.Files

        ' I don't want to import the module this script is in
        If moduleName.Name <> "DevTools.vba" Then

            ' if the current code is a module or form
            If Right(moduleName.Name, 4) = ".vba" Or _
                Right(moduleName.Name, 4) = ".frm" Then

                ' just import it normally
                .VBComponents.Import dir & moduleName.Name

            ' if the current code is a microsoft excel object
            ElseIf Right(moduleName.Name, 4) = ".cls" Then
                Dim count As Integer
                Dim fullmoduleString As String
                Open moduleName.Path For Input As #1

                count = 0              ' count which line we're on
                fullmoduleString = ""  ' build the string we want to put into the MEO
                Do Until EOF(1)        ' loop through all the lines in the file

                    Line Input #1, moduleString  ' the current line is moduleString
                    If count > 8 Then            ' skip the junk at the top of the file

                        ' append the current line `to the string we'll insert into the MEO
                        fullmoduleString = fullmoduleString & moduleString & vbNewLine

                    End If
                    count = count + 1
                Loop

                ' insert the lines into the MEO
                .VBComponents(Replace(moduleName.Name, ".cls", "")).CodeModule.InsertLines .VBComponents(Replace(moduleName.Name, ".cls", "")).CodeModule.CountOfLines + 1, fullmoduleString

                Close #1

            End If
        End If

    Next moduleName
End With

End Sub

Falls Sie durch die dirEingabe dieser beiden Funktionen verwirrt sind, ist dies nur Ihr Code-Repository! Sie würden diese Funktionen also wie folgt aufrufen:

SaveCodeModules "C:\...\YourDirectory\Project\source\"
ImportCodeModules "C:\...\YourDirectory\Project\source\"

Ich benutze git und habe dies heute (git-xlsx-textconv) nach Python portiert , da mein Projekt auf Python-Code basiert und mit Excel-Dateien interagiert. Dies funktioniert mindestens für XLSX- Dateien, aber ich denke, es funktioniert auch für XLS- Dateien . Hier ist der Github-Link. Ich habe zwei Versionen geschrieben, eine mit jeder Zeile in einer eigenen Zeile und eine andere, in der sich jede Zelle in einer eigenen Zeile befindet (letztere wurde geschrieben, weil git diff zumindest hier unter Windows standardmäßig keine langen Zeilen umbrechen möchte).

Dies ist meine .gitconfig- Datei (dies ermöglicht es dem unterschiedlichen Skript, sich im Repo meines Projekts zu befinden):

[diff "xlsx"]
    binary = true
    textconv = python `git rev-parse --show-toplevel`/src/util/git-xlsx-textconv.py

Wenn Sie möchten, dass das Skript für viele verschiedene Repos verfügbar ist, verwenden Sie Folgendes:

[diff "xlsx"]
    binary = true
    textconv = python C:/Python27/Scripts/git-xlsx-textconv.py

meine .gitattributes- Datei:

*.xlsx diff=xlsx

Eine Sache, die Sie tun können, ist, das folgende Snippet in Ihrer Arbeitsmappe zu haben:

Sub SaveCodeModules()

'This code Exports all VBA modules
Dim i%, sName$

    With ThisWorkbook.VBProject
        For i% = 1 To .VBComponents.Count
            If .VBComponents(i%).CodeModule.CountOfLines > 0 Then
                sName$ = .VBComponents(i%).CodeModule.Name
                .VBComponents(i%).Export "C:\Code\" & sName$ & ".vba"
            End If
        Next i
    End With
End Sub

Ich habe diesen Ausschnitt im Internet gefunden.

Anschließend können Sie Subversion verwenden, um die Versionskontrolle aufrechtzuerhalten. Zum Beispiel durch Verwenden der Befehlszeilenschnittstelle von Subversion mit dem Befehl 'shell' in VBA. Das würde es tun. Ich denke sogar daran, das selbst zu machen :)

Ich möchte ein großartiges Open-Source-Tool namens Rubberduck empfehlen , in das die Versionskontrolle des VBA-Codes integriert ist. Probieren Sie es aus!

Wenn Sie sich eine Büroumgebung mit regulären, nicht technischen Bürobenutzern ansehen, ist Sharepoint eine praktikable Alternative. Sie können Dokumentordner mit aktivierter Versionskontrolle und Ein- und Auschecken einrichten. Macht es für reguläre Büronutzer einfacher.

Als Antwort auf die Antwort von mattlant funktioniert Sharepoint nur dann als Versionskontrolle, wenn die Versionskontrollfunktion in der Dokumentbibliothek aktiviert ist. Beachten Sie außerdem, dass Code, der andere Dateien über relative Pfade aufruft, nicht funktioniert. und schließlich werden alle Links zu externen Dateien unterbrochen, wenn eine Datei in Sharepoint gespeichert wird.

Verwenden Sie eines der Standard-Tools zur Versionskontrolle wie SVN oder CVS. Einschränkungen würden davon abhängen, was das Ziel ist. Abgesehen von einer kleinen Vergrößerung des Repositorys hatte ich keine Probleme

Sie sollten DiffEngineX ausprobieren. Es kann programmgesteuert und auch über die Befehlszeile mit Befehlszeilenargumenten aufgerufen werden. Es werden nicht nur die Excel-Tabellenzellen verglichen, sondern auch die in die Arbeitsmappen eingebetteten Visual Basic-Makros. Vergleicht auch in Excel definierte Namen und Kommentare, die bei vielen Freeware-Tools fehlen. Es kann von heruntergeladen werden

http://www.florencesoft.com/excel-differences-download.html

Ich bin sicher, Ihr Versionskontrollsystem verfügt über eine Option oder ein Feld, sodass Sie DiffEngineX automatisch mit Ihren ursprünglichen und geänderten Excel-Arbeitsmappen aufrufen können.

Ich habe mich auch damit befasst. Es scheint, dass der neueste Team Foundation Server 2010 möglicherweise über ein Excel-Add-In verfügt.

Hier ist ein Hinweis:

http://team-foundation-server.blogspot.com/2009/07/tf84037-there-was-problem-initializing.html

Nachdem ich lange gesucht und viele verschiedene Tools ausprobiert habe, habe ich hier meine Antwort auf das Problem mit der vba-Versionskontrolle gefunden: https://stackoverflow.com/a/25984759/2780179

Es ist ein einfaches Excel-Add-In, für das der Code hier zu finden ist

Nach dem Import sind keine doppelten Module vorhanden. Es exportiert Ihren Code automatisch, sobald Sie Ihre Arbeitsmappe speichern, ohne vorhandene Arbeitsmappen zu ändern . Es kommt zusammen mit einem VBA-Code-Formatierer.

Tatsächlich gibt es nur eine Handvoll Lösungen, um Änderungen im Makrocode zu verfolgen und zu vergleichen - die meisten davon wurden hier bereits benannt. Ich habe im Internet gesurft und bin auf dieses neue Tool gestoßen, das es wert ist, erwähnt zu werden:

XLTools-Versionskontrolle für VBA-Makros

• Versionskontrolle für Excel-Tabellen und VBA-Module
• Vorschau- und Diff-Änderungen vor dem Festschreiben einer Version
• ideal für die Zusammenarbeit mehrerer Benutzer an derselben Datei (verfolgen, wer was / wann / Kommentare geändert hat)
• Vergleichen Sie die Versionen und markieren Sie zeilenweise Änderungen im Code
• Geeignet für Benutzer, die nicht technisch versiert oder Excel-versiert sind
• Der Versionsverlauf wird im Git-Repository auf Ihrem eigenen PC gespeichert - jede Version kann problemlos wiederhergestellt werden

VBA-Codeversionen nebeneinander, Änderungen werden visualisiert

Möglicherweise haben Sie versucht, Microsoft Excel XML im Zip-Container (.xlsx und .xslm) für die Versionskontrolle zu verwenden, und festgestellt, dass die vba in vbaProject.bin gespeichert ist (was für die Versionskontrolle unbrauchbar ist).

Die Lösung ist einfach.

1. Öffnen Sie die Excel-Datei mit LibreOffice Calc
2. In LibreOffice Calc
   1. Datei
   2. Speichern als
   3. Als Typ speichern: ODF-Tabelle (.ods)
3. Schließen Sie LibreOffice Calc
4. Benennen Sie die Dateierweiterung der neuen Datei von .ods in .zip um
5. Erstellen Sie einen Ordner für die Tabelle in einem von GIT verwalteten Bereich
6. Extrahieren Sie die Zip-Datei in den GIT-Ordner
7. verpflichten sich zu GIT

Wenn Sie dies mit der nächsten Version der Tabelle wiederholen, müssen Sie sicherstellen, dass die Dateien des Ordners genau mit denen im Zip-Container übereinstimmen (und keine gelöschten Dateien zurücklassen).

Es gibt auch ein Programm namens Beyond Compare , das einen sehr schönen Excel-Dateivergleich bietet. Ich habe einen Screenshot auf Chinesisch gefunden, der dies kurz zeigt:

Originalbildquelle

Es gibt eine 30-Tage-Testversion auf ihrer Seite

Ich habe eine sehr einfache Lösung für diese Frage gefunden, die meinen Bedürfnissen entspricht. Ich füge eine Zeile am Ende aller meiner Makros hinzu, die *.txtbei jeder Ausführung eine Datei mit dem gesamten Makrocode exportieren . Der Code:

ActiveWorkbook.VBProject.VBComponents("moduleName").Export"C:\Path\To\Spreadsheet\moduleName.txt"

(In Toms Tutorials zu finden , in denen auch einige Einstellungen behandelt werden, die möglicherweise erforderlich sind, damit dies funktioniert.)

Da ich das Makro immer ausführen werde, wenn ich am Code arbeite, ist mir garantiert, dass git die Änderungen übernimmt. Der einzige ärgerliche Teil ist, dass ich, wenn ich eine frühere Version auschecken muss, manuell aus *.txtder Tabelle kopieren / einfügen muss .

Es hängt davon ab, welchen Integrationsgrad Sie möchten. Ich habe Subversion / TortoiseSVN verwendet, was für die einfache Verwendung in Ordnung zu sein scheint. Ich habe auch Schlüsselwörter hinzugefügt, aber es scheint das Risiko einer Dateibeschädigung zu bestehen. In Subversion gibt es eine Option, um die Keyword-Ersetzungen auf eine feste Länge festzulegen. Soweit ich weiß, funktioniert dies, wenn die feste Länge gerade, aber nicht ungerade ist. Auf jeden Fall erhalten Sie keine nützliche Diff-Funktionalität. Ich denke, es gibt kommerzielle Produkte, die "Diff" ausführen. Ich habe etwas gefunden, das sich davon unterscheidet, Dinge in einfachen Text umzuwandeln und zu vergleichen, aber es war nicht sehr schön.

Es sollte mit den meisten VCS funktionieren (abhängig von anderen Kriterien können Sie SVN, CVS, Darcs, TFS usw. wählen), es wird jedoch tatsächlich die vollständige Datei (da es sich um ein Binärformat handelt), was bedeutet, dass die Frage "Was hat sich geändert?" nicht so einfach zu beantworten.

Sie können sich weiterhin auf Protokollnachrichten verlassen, wenn Benutzer diese ausfüllen. Sie können jedoch auch die neuen XML-basierten Formate von Office 2007 ausprobieren, um mehr Transparenz zu erhalten (obwohl es immer noch schwierig ist, die Tonnen von XML und AFAIK die XML-Datei zu durchsuchen wird auf der Festplatte komprimiert, sodass Sie einen Pre-Commit-Hook benötigen, um ihn zu entpacken, damit Textdifferenz ordnungsgemäß funktioniert.

Ich habe eine revisionsgesteuerte Tabelle mit VBA geschrieben. Es ist eher auf technische Berichte ausgerichtet, bei denen mehrere Personen an einer Stückliste oder einem Zeitplan arbeiten und dann zu einem bestimmten Zeitpunkt eine Snapshot-Revision erstellen möchten, die das Hinzufügen, Löschen und Aktualisieren der vorherigen Revision anzeigt.

Hinweis: Es handelt sich um eine makrofähige Arbeitsmappe, die Sie zum Herunterladen von meiner Website anmelden müssen (Sie können OpenID verwenden).

Der gesamte Code ist entsperrt.

Rev Controlled Spreadsheet

Mein Unternehmen arbeitet sehr viel an der Automatisierung von Microsoft Office-Lösungen. Daher habe ich eine DLL geschrieben, die die Quelle einer Lösung jedes Mal exportiert, wenn eine Vorlage gespeichert wird. Es erstellt einen Ordner mit dem Namen Source als untergeordnetes Element des Ordners, in dem die Vorlage gespeichert ist, und unter Source wird ein Ordner mit demselben Namen wie das VBA-Projekt erstellt. Im Projektordner wird der gesamte Quellcode für Module, Klassen und Benutzerformulare exportiert. Diese Anordnung wurde gewählt, um die Verwaltung der Quelle für große Sammlungen von Vorlagen zu vereinfachen. Die DLL kann gesperrte Projekte entsperren, um Zugriff auf das VBA-Projekt zu erhalten, wenn eine lokale Konfigurationsdatei oder eine globale Konfigurationsdatei verfügbar ist. Mit diesem Tool können die Entwickler Vorlagen nach Herzenslust bearbeiten und ihre Arbeit mit ihrem bevorzugten Tool zur Revisionskontrolle verwalten.