added support for loading from byte array or System.IO.Stream

jochenwezel · jochenwezel · commit 90a973cfa40a · 2025-08-19T19:13:56.000+02:00
diff --git a/ExcelOps-EpplusFreeFixCalcsEdition/EpplusFreeExcelDataOperations.vb b/ExcelOps-EpplusFreeFixCalcsEdition/EpplusFreeExcelDataOperations.vb
@@ -22,6 +22,22 @@ Namespace ExcelOps
             MyBase.New(file, mode, False, True, [readOnly], passwordForOpening)
         End Sub
 
+        Public Sub New(data As Byte(), passwordForOpening As String)
+            MyBase.New(data, False, True, passwordForOpening)
+        End Sub
+
+        Public Sub New(data As Byte(), passwordForOpening As String, disableInitialCalculation As Boolean)
+            MyBase.New(data, Not disableInitialCalculation, True, passwordForOpening)
+        End Sub
+
+        Public Sub New(data As System.IO.Stream, passwordForOpening As String)
+            MyBase.New(data, False, True, passwordForOpening)
+        End Sub
+
+        Public Sub New(data As System.IO.Stream, passwordForOpening As String, disableInitialCalculation As Boolean)
+            MyBase.New(data, Not disableInitialCalculation, True, passwordForOpening)
+        End Sub
+
         Public Sub New()
             Me.New(Nothing)
         End Sub
diff --git a/ExcelOps-EpplusPolyform/EpplusPolyformExcelDataOperations.vb b/ExcelOps-EpplusPolyform/EpplusPolyformExcelDataOperations.vb
@@ -49,6 +49,26 @@ Namespace ExcelOps
             ValidateLicenseContext(Me)
         End Sub
 
+        Public Sub New(data As Byte(), passwordForOpening As String)
+            MyBase.New(data, True, False, passwordForOpening)
+            ValidateLicenseContext(Me)
+        End Sub
+
+        Public Sub New(data As Byte(), passwordForOpening As String, disableInitialCalculation As Boolean)
+            MyBase.New(data, Not disableInitialCalculation, False, passwordForOpening)
+            ValidateLicenseContext(Me)
+        End Sub
+
+        Public Sub New(data As System.IO.Stream, passwordForOpening As String)
+            MyBase.New(data, True, False, passwordForOpening)
+            ValidateLicenseContext(Me)
+        End Sub
+
+        Public Sub New(data As System.IO.Stream, passwordForOpening As String, disableInitialCalculation As Boolean)
+            MyBase.New(data, Not disableInitialCalculation, False, passwordForOpening)
+            ValidateLicenseContext(Me)
+        End Sub
+
         Public Sub New()
             Me.New(Nothing)
         End Sub
diff --git a/ExcelOps-FreeSpireXls/FreeSpireXlsDataOperations.vb b/ExcelOps-FreeSpireXls/FreeSpireXlsDataOperations.vb
@@ -51,6 +51,22 @@ Namespace ExcelOps
             MyBase.New(file, mode, True, False, [readOnly], passwordForOpening)
         End Sub
 
+        Public Sub New(data As Byte(), passwordForOpening As String)
+            MyBase.New(data, True, False, passwordForOpening)
+        End Sub
+
+        Public Sub New(data As Byte(), passwordForOpening As String, disableInitialCalculation As Boolean)
+            MyBase.New(data, Not disableInitialCalculation, False, passwordForOpening)
+        End Sub
+
+        Public Sub New(data As System.IO.Stream, passwordForOpening As String)
+            MyBase.New(data, True, False, passwordForOpening)
+        End Sub
+
+        Public Sub New(data As System.IO.Stream, passwordForOpening As String, disableInitialCalculation As Boolean)
+            MyBase.New(data, Not disableInitialCalculation, False, passwordForOpening)
+        End Sub
+
         ''' <summary>
         ''' Create a new excel engine instance (reminder: set System.Threading.Thread.CurrentThread.CurrentCulture as required BEFORE creating the instance to ensure the engine uses the correct culture later on)
         ''' </summary>
diff --git a/ExcelOps-SpireXls/SpireXlsDataOperations.vb b/ExcelOps-SpireXls/SpireXlsDataOperations.vb
@@ -42,6 +42,22 @@ Namespace ExcelOps
             If AllowInstancingForNonLicencedContextForTestingPurposesOnly = False AndAlso IsLicensedContext = False Then Throw New LicenseException(GetType(Spire.License.LicenseProvider), Nothing, "Correct licensing required, see Spire.License.LicenseProvider and https://www.e-iceblue.com/")
         End Sub
 
+        Public Sub New(data As Byte(), passwordForOpening As String)
+            MyBase.New(data, True, False, passwordForOpening)
+        End Sub
+
+        Public Sub New(data As Byte(), passwordForOpening As String, disableInitialCalculation As Boolean)
+            MyBase.New(data, Not disableInitialCalculation, False, passwordForOpening)
+        End Sub
+
+        Public Sub New(data As System.IO.Stream, passwordForOpening As String)
+            MyBase.New(data, True, False, passwordForOpening)
+        End Sub
+
+        Public Sub New(data As System.IO.Stream, passwordForOpening As String, disableInitialCalculation As Boolean)
+            MyBase.New(data, Not disableInitialCalculation, False, passwordForOpening)
+        End Sub
+
         ''' <summary>
         ''' Create a new excel engine instance (reminder: set System.Threading.Thread.CurrentThread.CurrentCulture as required BEFORE creating the instance to ensure the engine uses the correct culture later on)
         ''' </summary>
diff --git a/ExcelOpsTest-FreeSpireXls/ExcelOpsTests.Engines/FreeSpireXlsOpsTest.vb b/ExcelOpsTest-FreeSpireXls/ExcelOpsTests.Engines/FreeSpireXlsOpsTest.vb
@@ -23,6 +23,14 @@ Namespace ExcelOpsTests.Engines
             MyBase.TestInCultureContext_AssignCurrentThreadCulture()
         End Sub
 
+        Protected Overrides Function _CreateInstance(data() As Byte, passwordForOpening As String, disableCalculationEngine As Boolean) As ExcelOps.FreeSpireXlsDataOperations
+            Return New ExcelOps.FreeSpireXlsDataOperations(data, passwordForOpening, disableCalculationEngine)
+        End Function
+
+        Protected Overrides Function _CreateInstance(data As IO.Stream, passwordForOpening As String, disableCalculationEngine As Boolean) As ExcelOps.FreeSpireXlsDataOperations
+            Return New ExcelOps.FreeSpireXlsDataOperations(data, passwordForOpening, disableCalculationEngine)
+        End Function
+
     End Class
 
 End Namespace
diff --git a/ExcelOpsTest-SpireXls/ExcelOpsTests.Engines/SpireXlsOpsTest.vb b/ExcelOpsTest-SpireXls/ExcelOpsTests.Engines/SpireXlsOpsTest.vb
@@ -50,6 +50,14 @@ Namespace ExcelOpsTests.Engines
             Assert.False(CompuMaster.Excel.ExcelOps.Utils.IsLicensedContext)
         End Sub
 
+        Protected Overrides Function _CreateInstance(data() As Byte, passwordForOpening As String, disableCalculationEngine As Boolean) As ExcelOps.SpireXlsDataOperations
+            Return New ExcelOps.SpireXlsDataOperations(data, passwordForOpening, disableCalculationEngine)
+        End Function
+
+        Protected Overrides Function _CreateInstance(data As IO.Stream, passwordForOpening As String, disableCalculationEngine As Boolean) As ExcelOps.SpireXlsDataOperations
+            Return New ExcelOps.SpireXlsDataOperations(data, passwordForOpening, disableCalculationEngine)
+        End Function
+
     End Class
 
 End Namespace
diff --git a/ExcelOpsTest/ExcelOpsTests.Engines/EpplusFreeFixCalcsEditionOpsTest.vb b/ExcelOpsTest/ExcelOpsTests.Engines/EpplusFreeFixCalcsEditionOpsTest.vb
@@ -8,6 +8,7 @@ Namespace ExcelOpsTests.Engines
         Public Overrides ReadOnly Property ExpectedEngineName As String = "Epplus 4 (LGPL)"
 
         Protected Overrides Function _CreateInstance(file As String, mode As ExcelOps.ExcelDataOperationsBase.OpenMode, [readOnly] As Boolean, passwordForOpening As String, disableInitialCalculation As Boolean) As ExcelOps.EpplusFreeExcelDataOperations
+            'disableCalculationEngine not required since always disabled calc-module by engine
             Return New ExcelOps.EpplusFreeExcelDataOperations(file, mode, [readOnly], passwordForOpening)
         End Function
 
@@ -19,6 +20,16 @@ Namespace ExcelOpsTests.Engines
             Assert.Throws(Of NotSupportedException)(Sub() MyBase.CopySheetContent())
         End Sub
 
+        Protected Overrides Function _CreateInstance(data() As Byte, passwordForOpening As String, disableCalculationEngine As Boolean) As ExcelOps.EpplusFreeExcelDataOperations
+            'disableCalculationEngine not required since always disabled calc-module by engine
+            Return New ExcelOps.EpplusFreeExcelDataOperations(data, passwordForOpening)
+        End Function
+
+        Protected Overrides Function _CreateInstance(data As IO.Stream, passwordForOpening As String, disableCalculationEngine As Boolean) As ExcelOps.EpplusFreeExcelDataOperations
+            'disableCalculationEngine not required since always disabled calc-module by engine
+            Return New ExcelOps.EpplusFreeExcelDataOperations(data, passwordForOpening)
+        End Function
+
     End Class
 
 End Namespace
diff --git a/ExcelOpsTest/ExcelOpsTests.Engines/EpplusPolyformEditionOpsTest.vb b/ExcelOpsTest/ExcelOpsTests.Engines/EpplusPolyformEditionOpsTest.vb
@@ -27,6 +27,14 @@ Namespace ExcelOpsTests.Engines
             Assert.Throws(Of NotSupportedException)(Sub() MyBase.CopySheetContent())
         End Sub
 
+        Protected Overrides Function _CreateInstance(data() As Byte, passwordForOpening As String, disableCalculationEngine As Boolean) As ExcelOps.EpplusPolyformExcelDataOperations
+            Return New ExcelOps.EpplusPolyformExcelDataOperations(data, passwordForOpening, disableCalculationEngine)
+        End Function
+
+        Protected Overrides Function _CreateInstance(data As IO.Stream, passwordForOpening As String, disableCalculationEngine As Boolean) As ExcelOps.EpplusPolyformExcelDataOperations
+            Return New ExcelOps.EpplusPolyformExcelDataOperations(data, passwordForOpening, disableCalculationEngine)
+        End Function
+
     End Class
 
 End Namespace
diff --git a/ExcelOpsTest/ExcelOpsTests.Engines/ExcelOpsTestBase.vb b/ExcelOpsTest/ExcelOpsTests.Engines/ExcelOpsTestBase.vb
@@ -21,6 +21,8 @@ Namespace ExcelOpsTests.Engines
 
 #Disable Warning CA1716 ' Bezeichner dürfen nicht mit Schlüsselwörtern übereinstimmen
         Protected MustOverride Function _CreateInstance(file As String, mode As ExcelOps.ExcelDataOperationsBase.OpenMode, [readOnly] As Boolean, passwordForOpening As String, disableCalculationEngine As Boolean) As T
+        Protected MustOverride Function _CreateInstance(data As Byte(), passwordForOpening As String, disableCalculationEngine As Boolean) As T
+        Protected MustOverride Function _CreateInstance(data As System.IO.Stream, passwordForOpening As String, disableCalculationEngine As Boolean) As T
 #Enable Warning CA1716 ' Bezeichner dürfen nicht mit Schlüsselwörtern übereinstimmen
 
         ''' <summary>
@@ -63,6 +65,88 @@ Namespace ExcelOpsTests.Engines
             Return Me.CreateInstance(file, mode, [readOnly], passwordForOpening, False)
         End Function
 
+        ''' <summary>
+        ''' Create a new excel engine instance (reminder: set System.Threading.Thread.CurrentThread.CurrentCulture as required BEFORE creating the instance to ensure the engine uses the correct culture later on)
+        ''' </summary>
+        ''' <param name="data"></param>
+        ''' <param name="passwordForOpening"></param>
+        ''' <returns></returns>
+        Protected Function CreateInstance(data As Byte(), passwordForOpening As String) As T
+            Return Me.CreateInstance(data, passwordForOpening, False)
+        End Function
+
+        ''' <summary>
+        ''' Create a new excel engine instance (reminder: set System.Threading.Thread.CurrentThread.CurrentCulture as required BEFORE creating the instance to ensure the engine uses the correct culture later on)
+        ''' </summary>
+        ''' <param name="data"></param>
+        ''' <param name="passwordForOpening"></param>
+        ''' <param name="disableCalculationEngine"></param>
+        ''' <returns></returns>
+        Protected Function CreateInstance(data As Byte(), passwordForOpening As String, disableCalculationEngine As Boolean) As T
+            Try
+                Return _CreateInstance(data, passwordForOpening, disableCalculationEngine)
+            Catch ex As Exception
+                If ex.GetType() Is GetType(PlatformNotSupportedException) Then
+                    Throw
+                ElseIf ex.GetType() Is GetType(CompuMaster.ComInterop.ComApplicationNotAvailableException) Then
+                    Throw
+                Else
+                    Dim InnerEx As Exception = ex.InnerException
+                    Do While InnerEx IsNot Nothing
+                        If InnerEx.GetType() Is GetType(PlatformNotSupportedException) Then
+                            Throw InnerEx
+                        ElseIf InnerEx.GetType() Is GetType(CompuMaster.ComInterop.ComApplicationNotAvailableException) Then
+                            Throw InnerEx
+                        Else
+                            InnerEx = InnerEx.InnerException
+                        End If
+                    Loop
+                End If
+                Throw
+            End Try
+        End Function
+
+        ''' <summary>
+        ''' Create a new excel engine instance (reminder: set System.Threading.Thread.CurrentThread.CurrentCulture as required BEFORE creating the instance to ensure the engine uses the correct culture later on)
+        ''' </summary>
+        ''' <param name="data"></param>
+        ''' <param name="passwordForOpening"></param>
+        ''' <returns></returns>
+        Protected Function CreateInstance(data As System.IO.Stream, passwordForOpening As String) As T
+            Return Me.CreateInstance(data, passwordForOpening, False)
+        End Function
+
+        ''' <summary>
+        ''' Create a new excel engine instance (reminder: set System.Threading.Thread.CurrentThread.CurrentCulture as required BEFORE creating the instance to ensure the engine uses the correct culture later on)
+        ''' </summary>
+        ''' <param name="data"></param>
+        ''' <param name="passwordForOpening"></param>
+        ''' <param name="disableCalculationEngine"></param>
+        ''' <returns></returns>
+        Protected Function CreateInstance(data As System.IO.Stream, passwordForOpening As String, disableCalculationEngine As Boolean) As T
+            Try
+                Return _CreateInstance(data, passwordForOpening, disableCalculationEngine)
+            Catch ex As Exception
+                If ex.GetType() Is GetType(PlatformNotSupportedException) Then
+                    Throw
+                ElseIf ex.GetType() Is GetType(CompuMaster.ComInterop.ComApplicationNotAvailableException) Then
+                    Throw
+                Else
+                    Dim InnerEx As Exception = ex.InnerException
+                    Do While InnerEx IsNot Nothing
+                        If InnerEx.GetType() Is GetType(PlatformNotSupportedException) Then
+                            Throw InnerEx
+                        ElseIf InnerEx.GetType() Is GetType(CompuMaster.ComInterop.ComApplicationNotAvailableException) Then
+                            Throw InnerEx
+                        Else
+                            InnerEx = InnerEx.InnerException
+                        End If
+                    Loop
+                End If
+                Throw
+            End Try
+        End Function
+
         ''' <summary>
         ''' Create a new excel engine instance (reminder: set System.Threading.Thread.CurrentThread.CurrentCulture as required BEFORE creating the instance to ensure the engine uses the correct culture later on)
         ''' </summary>
@@ -202,6 +286,40 @@ Namespace ExcelOpsTests.Engines
 
         End Sub
 
+        <Test> Public Sub LoadFileFromByteArray()
+            Dim Wb As T
+            'Testfile without password
+            Dim TestFile As String = TestEnvironment.FullPathOfExistingTestFile("test_data", "ExcelOpsGrund01.xlsx")
+            Dim Data As Byte() = System.IO.File.ReadAllBytes(TestFile)
+            If GetType(T) Is GetType(MsExcelDataOperations) Then
+                'known to fail because no support for reading files from in-memory
+                Assert.Throws(Of NotSupportedException)(Sub()
+                                                            Me.CreateInstance(Data, "")
+                                                        End Sub)
+            Else
+                Wb = Me.CreateInstance(Data, "")
+                Assert.AreEqual("Grunddaten", Wb.SheetNames(0))
+                Assert.That(Wb.ReadOnly, [Is].True)
+            End If
+        End Sub
+
+        <Test> Public Sub LoadFileFromStream()
+            Dim Wb As T
+            'Testfile without password
+            Dim TestFile As String = TestEnvironment.FullPathOfExistingTestFile("test_data", "ExcelOpsGrund01.xlsx")
+            Dim Data As System.IO.Stream = New System.IO.FileStream(TestFile, System.IO.FileMode.Open)
+            If GetType(T) Is GetType(MsExcelDataOperations) Then
+                'known to fail because no support for reading files from in-memory
+                Assert.Throws(Of NotSupportedException)(Sub()
+                                                            Me.CreateInstance(Data, "")
+                                                        End Sub)
+            Else
+                Wb = Me.CreateInstance(Data, "")
+                Assert.AreEqual("Grunddaten", Wb.SheetNames(0))
+                Assert.That(Wb.ReadOnly, [Is].True)
+            End If
+        End Sub
+
         <Test> Public Sub PasswordForOpening()
             Dim Wb As T
             'Testfile without password
@@ -518,23 +636,23 @@ Namespace ExcelOpsTests.Engines
             End If
 
             eppeo.SelectSheet(0)
-                eppeo.SaveAs(TestEnvironment.FullPathOfDynTestFile(eppeo, "SelectedSheet.Grunddaten.0.xlsx"), ExcelDataOperationsBase.SaveOptionsForDisabledCalculationEngines.NoReset)
-                System.Console.WriteLine("OUT: " & eppeo.FilePath)
-                Assert.That(eppeo.SelectedSheetName, [Is].EqualTo("Grunddaten"))
-
-                eppeo = Me.CreateInstance(TestFileName, ExcelDataOperationsBase.OpenMode.OpenExistingFile, True, Nothing)
-                eppeo.SelectSheet(1)
-                eppeo.SaveAs(TestEnvironment.FullPathOfDynTestFile(eppeo, "SelectedSheet.Ausgewählt.1.xlsx"), ExcelDataOperationsBase.SaveOptionsForDisabledCalculationEngines.NoReset)
-                System.Console.WriteLine("OUT: " & eppeo.FilePath)
-                Assert.That(eppeo.SelectedSheetName, [Is].EqualTo("Ausgewählt"))
-
-                eppeo = Me.CreateInstance(TestFileName, ExcelDataOperationsBase.OpenMode.OpenExistingFile, True, Nothing)
-                eppeo.SelectSheet(2)
-                eppeo.SaveAs(TestEnvironment.FullPathOfDynTestFile(eppeo, "SelectedSheet.Kostenplanung.2.xlsx"), ExcelDataOperationsBase.SaveOptionsForDisabledCalculationEngines.NoReset)
-                System.Console.WriteLine("OUT: " & eppeo.FilePath)
-                Assert.That(eppeo.SelectedSheetName, [Is].EqualTo("Kostenplanung"))
-
-                eppeo.SelectSheet("Grunddaten")
+            eppeo.SaveAs(TestEnvironment.FullPathOfDynTestFile(eppeo, "SelectedSheet.Grunddaten.0.xlsx"), ExcelDataOperationsBase.SaveOptionsForDisabledCalculationEngines.NoReset)
+            System.Console.WriteLine("OUT: " & eppeo.FilePath)
+            Assert.That(eppeo.SelectedSheetName, [Is].EqualTo("Grunddaten"))
+
+            eppeo = Me.CreateInstance(TestFileName, ExcelDataOperationsBase.OpenMode.OpenExistingFile, True, Nothing)
+            eppeo.SelectSheet(1)
+            eppeo.SaveAs(TestEnvironment.FullPathOfDynTestFile(eppeo, "SelectedSheet.Ausgewählt.1.xlsx"), ExcelDataOperationsBase.SaveOptionsForDisabledCalculationEngines.NoReset)
+            System.Console.WriteLine("OUT: " & eppeo.FilePath)
+            Assert.That(eppeo.SelectedSheetName, [Is].EqualTo("Ausgewählt"))
+
+            eppeo = Me.CreateInstance(TestFileName, ExcelDataOperationsBase.OpenMode.OpenExistingFile, True, Nothing)
+            eppeo.SelectSheet(2)
+            eppeo.SaveAs(TestEnvironment.FullPathOfDynTestFile(eppeo, "SelectedSheet.Kostenplanung.2.xlsx"), ExcelDataOperationsBase.SaveOptionsForDisabledCalculationEngines.NoReset)
+            System.Console.WriteLine("OUT: " & eppeo.FilePath)
+            Assert.That(eppeo.SelectedSheetName, [Is].EqualTo("Kostenplanung"))
+
+            eppeo.SelectSheet("Grunddaten")
             eppeo.SaveAs(TestEnvironment.FullPathOfDynTestFile(eppeo, "SelectedSheet.Grunddaten.xlsx"), ExcelDataOperationsBase.SaveOptionsForDisabledCalculationEngines.NoReset)
             System.Console.WriteLine("OUT: " & eppeo.FilePath)
             Assert.That(eppeo.SelectedSheetName, [Is].EqualTo("Grunddaten"))
diff --git a/ExcelOpsTest/ExcelOpsTests.Engines/MsExcelOpsTest.vb b/ExcelOpsTest/ExcelOpsTests.Engines/MsExcelOpsTest.vb
@@ -119,6 +119,13 @@ Namespace ExcelOpsTests.Engines
             MsExcelInstance.SetCultureContext(System.Threading.Thread.CurrentThread.CurrentCulture)
         End Sub
 
+        Protected Overrides Function _CreateInstance(data() As Byte, passwordForOpening As String, disableCalculationEngine As Boolean) As ExcelOps.MsExcelDataOperations
+            Throw New NotSupportedException
+        End Function
+
+        Protected Overrides Function _CreateInstance(data As IO.Stream, passwordForOpening As String, disableCalculationEngine As Boolean) As ExcelOps.MsExcelDataOperations
+            Throw New NotSupportedException
+        End Function
     End Class
 
 End Namespace
