/// <summary> /// 写入 /// </summary> /// <param name="path">地址</param> /// <param name="data">数据</param> /// <param name="fileFormatType">文件类型</param> /// <param name="encryptModeType">加密类型</param> public static void Write(string path, byte[] data, FileFormatType fileFormatType = FileFormatType.txt, EncryptModeType encryptModeType = EncryptModeType.None) { switch (fileFormatType) { case FileFormatType.txt: txtFileSave.WriteData(path, data, encryptModeType); break; case FileFormatType.json: jsonFileSave.WriteData(path, data, encryptModeType); break; case FileFormatType.xml: xmlFileSave.WriteData(path, data, encryptModeType); break; case FileFormatType.png: pngFileSave.WriteData(path, data, encryptModeType); break; case FileFormatType.jpg: jpgFileSave.WriteData(path, data, encryptModeType); break; case FileFormatType.exr: exrFileSave.WriteData(path, data, encryptModeType); break; default: break; } }
/// <summary> /// 读取 /// </summary> /// <typeparam name="T">返回类型</typeparam> /// <param name="path">地址</param> /// <param name="fileFormatType">文件类型</param> /// <param name="encryptModeType">加密类型</param> /// <returns></returns> public static FileObject Read(string path, FileFormatType fileFormatType = FileFormatType.txt, EncryptModeType encryptModeType = EncryptModeType.None) { FileObject fileObject = default(FileObject); switch (fileFormatType) { case FileFormatType.txt: fileObject = txtFileSave.ReadData(path, encryptModeType); break; case FileFormatType.json: fileObject = jsonFileSave.ReadData(path, encryptModeType); break; case FileFormatType.xml: fileObject = xmlFileSave.ReadData(path, encryptModeType); break; case FileFormatType.png: fileObject = pngFileSave.ReadData(path, encryptModeType); break; case FileFormatType.jpg: fileObject = jpgFileSave.ReadData(path, encryptModeType); break; case FileFormatType.exr: fileObject = exrFileSave.ReadData(path, encryptModeType); break; default: break; } return(fileObject); }
/// <summary> /// 异步读取 /// </summary> /// <typeparam name="T">返回类型</typeparam> /// <param name="path">地址</param> /// <param name="fileFormatType">文件类型</param> /// <param name="encryptModeType">加密类型</param> /// <returns></returns> public static void ReadAsync(string path, System.Action <FileObject> OnCall, FileFormatType fileFormatType = FileFormatType.txt, EncryptModeType encryptModeType = EncryptModeType.None) { switch (fileFormatType) { case FileFormatType.txt: txtFileSave.ReadAsyncData(path, encryptModeType, OnCall); break; case FileFormatType.json: jsonFileSave.ReadAsyncData(path, encryptModeType, OnCall); break; case FileFormatType.xml: xmlFileSave.ReadAsyncData(path, encryptModeType, OnCall); break; case FileFormatType.png: pngFileSave.ReadAsyncData(path, encryptModeType, OnCall); break; case FileFormatType.jpg: jpgFileSave.ReadAsyncData(path, encryptModeType, OnCall); break; case FileFormatType.exr: exrFileSave.ReadAsyncData(path, encryptModeType, OnCall); break; default: break; } }
public FileContainer(FileType fileType, FileFormatType fileFormatType, string name, string description, IEnumerable <string> extensions) { this.FileType = fileType; this.FileFormatType = fileFormatType; this.Name = name; this.Description = description; this.Extensions = new ReadOnlyCollection <string>(extensions.ToList()); }
/// <summary> /// Constructor. /// </summary> /// <param name="config">SMWriterBaseConfig to configure how to write the Chart.</param> /// <param name="logger">ILogger for logging.</param> /// <param name="fileFormatType">FileFormatType of file being written.</param> protected SMWriterBase(SMWriterBaseConfig config, ILogger logger, FileFormatType fileFormatType) { Config = config; Logger = logger; FileFormatType = fileFormatType; PerformStartupChecks(); DetermineChartDifficultyTypes(); }
/// <summary> /// Create an object using the contents of the corresponding MzIdentML object /// </summary> /// <param name="ff"></param> /// <param name="idata"></param> public FileFormatInfo(FileFormatType ff, IdentDataObj idata) : base(idata) { _cvParam = null; if (ff.cvParam != null) { _cvParam = new CVParamObj(ff.cvParam, IdentData); } }
public static void DataSet2Excel(string filePath, DataSet ds, bool[] showColumnNameArray = null, int[,] positionArray = null) { FileFormatType fileFormatType = FileFormatType.Xlsx; if (filePath.EndsWith("xlsx", StringComparison.InvariantCultureIgnoreCase)) { fileFormatType = FileFormatType.Xlsx; } else if (filePath.EndsWith("xls", StringComparison.InvariantCultureIgnoreCase)) { fileFormatType = FileFormatType.Xlsx; } Workbook workbook = new Workbook(fileFormatType: fileFormatType); for (int index = 0; index < ds.Tables.Count; index++) { Worksheet workSheet = workbook.Worksheets[index]; DataTable dt = ds.Tables[index]; if (dt.TableName.IsNullOrEmpty() == true) { workSheet.Name = "Sheet{0}".FormatWith(index + 1); } else { workSheet.Name = dt.TableName; } bool isFieldNameShown = true; if (showColumnNameArray != null) { isFieldNameShown = showColumnNameArray[index]; } int tmpFirstRow = 0; int tmpFirstColumn = 0; if (positionArray != null) { tmpFirstRow = positionArray[index, 0]; tmpFirstColumn = positionArray[index, 1]; } workSheet.Cells.ImportDataTable ( dataTable: dt, isFieldNameShown: isFieldNameShown, firstRow: tmpFirstRow, firstColumn: tmpFirstColumn ); } workbook.Save(filePath); }
/// <summary> /// Creates a new workbook within a "standard" environment which ensures that /// the range of write-related helper methods in this library behave as expected. /// </summary> /// <param name="fileFormatType">The file format type to use.</param> /// <returns> /// A new workbook. /// </returns> public static Workbook CreateStandardWorkbook( FileFormatType fileFormatType = FileFormatType.Xlsx) { AsposeCellsLicense.ThrowIfNotRegistered(); EnsureSizingOperationsHonorPixelsSpecified(); var result = new Workbook(fileFormatType); return(result); }
private void ConvertH3D(System.IO.Stream stream) { CanSave = true; System.IO.BinaryReader Reader = new System.IO.BinaryReader(stream); using (FileReader reader = new FileReader(stream, true)) { uint magicNumber = reader.ReadUInt32(); switch (magicNumber) { case 0x15122117: FormatType = FileFormatType.GFModel; H3DFile = new H3D(); H3DFile.Models.Add(new SPICA.Formats.GFL2.Model.GFModel(Reader, "Model").ToH3DModel()); break; } string mbnPath = FilePath.Replace("bch", "mbn"); if (reader.CheckSignature(3, "BCH")) { H3DFile = H3D.Open(stream.ToBytes()); FormatType = FileFormatType.BCH; return; } else if (reader.CheckSignature(4, "CGFX")) { H3DFile = SPICA.Formats.CtrGfx.Gfx.Open(stream); FormatType = FileFormatType.BCRES; } else if (GFPackage.IsValidPackage(stream)) { GFPackage.Header PackHeader = GFPackage.GetPackageHeader(stream); switch (PackHeader.Magic) { case "PC": H3DFile = GFPkmnModel.OpenAsH3D(stream, PackHeader, null); break; } } else if (System.IO.File.Exists(mbnPath)) { var ModelBinary = new SPICA.Formats.ModelBinary.MBn(new System.IO.BinaryReader( System.IO.File.OpenRead(mbnPath)), H3DFile); H3DFile = ModelBinary.ToH3D(); FormatType = FileFormatType.MBN; } else { H3DFile = H3D.Open(stream.ToBytes()); } } }
public static void Run() { //ExStart: PreserveEmbeddedMSGFormatDuringLoad string dataDir = RunExamples.GetDataDir_Email(); MailMessage mail = MailMessage.Load(dataDir + "tnefWithMsgInside.eml", new EmlLoadOptions() { PreserveEmbeddedMessageFormat = true }); FileFormatType fileFormat = FileFormatUtil.DetectFileFormat(mail.Attachments[0].ContentStream).FileFormatType; Console.WriteLine("Embedded message file format: " + fileFormat); //ExEnd: PreserveEmbeddedMSGFormatDuringLoad }
public static FileFormatType ResolveFileType(byte[] fileBytes) { var rg = FileFormatType.GetAll().ToArray(); foreach (var fileType in rg) { foreach (byte[] sig1 in fileType.Signature) { if (fileBytes.StartsWith(sig1)) { return(fileType); } } } return(FileFormatType.Unknown); }
public static byte[] ConvertFormat(Workbook workbook, FileFormatType format) { using (var streamForDoc = new MemoryStream()) { //Start magic. After new build we get an exception 'Unsupported sfnt version' on first load //On seccond request It works well. try { workbook.Save(streamForDoc, format); return(streamForDoc.ToArray()); } catch (Exception) { workbook.Save(streamForDoc, format); return(streamForDoc.ToArray()); } //End magic } }
public static byte[] ConvertFormat(Workbook workbook, FileFormatType format) { if (format == FileFormatType.Pdf) { workbook.Worksheets[0].PageSetup.Orientation = PageOrientationType.Landscape; } using (var streamForDoc = new MemoryStream()) { try { workbook.Save(streamForDoc, format); return(streamForDoc.ToArray()); } catch (Exception) { workbook.Save(streamForDoc, format); return(streamForDoc.ToArray()); } } }
/// <summary> /// Updates the Recorder file format and codec. /// Invokes "FileFormatUpdated" to other application's modules. /// </summary> /// <param name="item">Setting new value indicator.</param> public void UpdateRecorderFileFormat(FileFormatType item) { var oldCodec = _recorder.AudioCodec; var oldFileFormat = _recorder.FileFormat; try { _recorder.Unprepare(); _recorder.SetFormatAndCodec(FILE_FORMATS_DICTIONARY[item].Item2, FILE_FORMATS_DICTIONARY[item].Item1); _recorder.Prepare(); } catch (Exception exception) { _recorder.SetFormatAndCodec(oldCodec, oldFileFormat); _recorder.Prepare(); ErrorHandler(exception.Message); return; } FileFormatUpdated?.Invoke(this, item); }
private void CutFile(Worksheet sheet,FileFormatType saveFileType,string outputFolder) { string filePre = txtFilePrefix.Text.Trim(); int headerLastLine = (int) nudHeaderLastLine.Value; int count = sheet.Cells.Rows.Count; int num = (int)nudLines.Value;//每个文件的行数(不包括表头) int pages = (int)Math.Ceiling( (count-headerLastLine) * 1.0 / num );//计算切割成几个文件 List<Workbook> books = new List<Workbook>(); for (int i = 0; i < pages; i++) { int start = i * num + headerLastLine; int end = start + num; if (end > count) end = count; Workbook b = new Workbook(); Worksheet s = b.Worksheets[0]; //拷贝表头 for (int r = 0; r < headerLastLine; r++) { s.Cells.CopyRow(sheet.Cells, r, r); } //拷贝数据 for (int r = start, m = headerLastLine; r < end; r++, m++) { s.Cells.CopyRow(sheet.Cells,r,m); } books.Add(b); } for (int i = 0; i < books.Count;i++ ) { string f = string.Format(@"{0}\{1}{2}.{3}", outputFolder, filePre, i, FileFormatDesc(saveFileType)); books[i].Save(f, saveFileType); } }
/// <summary> /// Handles "FileFormatUpdated" of the IVoiceRecorderService object. /// Invokes "FileFormatUpdated" to other application's modules. /// </summary> /// <param name="sender">Instance of the VoiceRecorderService class.</param> /// <param name="newValue">New value of the recorder file format setting.</param> private void FileFormatUpdatedEventHandler(object sender, FileFormatType newValue) { FileFormatUpdated?.Invoke(sender, newValue); }
/// <summary> /// Updates recorder file format setting. /// </summary> /// <param name="item">New file format value to set.</param> public void UpdateRecorderFileFormat(FileFormatType item) { _service.UpdateRecorderFileFormat(item); }
private string FileFormatDesc(FileFormatType format) { foreach (var type in dicFileType) { if (type.Value == format) return type.Key; } return string.Empty; }
public static void WriteExcel(string fileName, string sheetName, DataTable dataTable, bool createFileAndSheet, bool exportColumnName, FileFormatType fileFormatType) { Workbook workbook = new Workbook(); if (!File.Exists(fileName)) { if (createFileAndSheet) { if (!workbook.Worksheets.OfType <Worksheet>().Select(w => w.Name).Contains(sheetName)) { workbook.Worksheets.Add(sheetName); } workbook.Save(fileName); } } workbook = new Workbook(); workbook.Open(fileName); int column = 0; foreach (DataColumn dataColumn in dataTable.Columns) { workbook.Worksheets[sheetName].Cells[0, column++].Value = dataColumn.Caption; } Style style = workbook.CreateStyle(); style.Number = 49; // TEXT format int row = 1; column = 0; foreach (DataRow dataRow in dataTable.Rows) { foreach (object item in dataRow.ItemArray) { Cell cell = workbook.Worksheets[sheetName].Cells[row, column]; cell.SetStyle(style); cell.Value = dataRow[column] + ""; column++; } column = 0; row++; } workbook.Save(fileName, fileFormatType); }
public FileContainer(FileType fileType, FileFormatType fileFormatType, string name, string description, string extension) : this(fileType, fileFormatType, name, description, new string [] { extension }) { }
Task<AppConfig.ReturnCode> ICatalogReader.Parse(System.Windows.Forms.OpenFileDialog ofd, FileFormatType formatType, MainFormViewModel viewModel) { throw new NotImplementedException(); }
public FileContainer(FileType fileType, FileFormatType fileFormatType, string name, string description, params string [] extensions) : this(fileType, fileFormatType, name, description, extensions as IEnumerable <string>) { this.Extensions = new ReadOnlyCollection <string>(extensions); }
public static bool IsFileTypeDocument(FileFormatType fileFormatType) { return(DocumentUtilities.FileFormatFileTypes [fileFormatType] == FileType.Document); }
/// <summary> /// Main parsing method implementing ICatalogReader interface. /// </summary> /// <param name="ofd"></param> /// <param name="formatType"></param> /// <param name="viewModel"></param> /// <returns></returns> public async Task<ReturnCode> Parse(OpenFileDialog ofd, FileFormatType formatType, MainFormViewModel viewModel = null) { if (ofd == null) { return ReturnCode.ModulesImportDefaultParseEmptyStream; } if (formatType == FileFormatType.ExcelWorkbook || formatType == FileFormatType.ExcelXml2003) { _fileFormatType = formatType; } else { return ReturnCode.ModulesImportDefaultParseUnknownFormat; } switch (_fileFormatType) { case FileFormatType.ExcelWorkbook: _excelLastRow = new Dictionary<String, int>(); _excelLastColumn = new Dictionary<String, int>(); if (String.IsNullOrEmpty(ofd.FileName)) { return ReturnCode.ModulesImportDefaultParseEmptyStream; } _excelApplication = new Excel.Application(); _excelDocument = _excelApplication.Workbooks.Open(ofd.FileName); if (_excelDocument == null) { return ReturnCode.ModulesImportDefaultParseEmptyStream; } break; case FileFormatType.ExcelXml2003: try { Stream s = ofd.OpenFile(); _xmlDocument = new XmlDocument(); _xmlDocument.Load(s); break; } catch (Exception ex) { Debug.WriteLine(this, "TemplatedCatalogReader.Parse, case=FileFormatType.ExcelXml2003, exception=" + ex.Message); Notify("The XML parsing failed."); return ReturnCode.ModulesImportDefaultParseEmptyStream; } } if (viewModel != null) { _mainFormViewModel = viewModel; _mainFormViewModel.InputProgressBarValue = 0; _mainFormViewModel.InputProgressBarMax = InitPayload + 1; // initial payload and 'symbolic' last bit of payload before last return } if (!(await IsValidWorkbook())) { Notify("Invalid Workbook."); return ReturnCode.ModulesImportDefaultParseInvalidWorkbook; } if (_mainFormViewModel != null) { if (_langs != null) _mainFormViewModel.InputProgressBarMax += _langs.Count; if (_tags != null) _mainFormViewModel.InputProgressBarMax += _tags.Count; if (_roles != null) _mainFormViewModel.InputProgressBarMax += _roles.Count; if (_qualities != null) _mainFormViewModel.InputProgressBarMax += _qualities.Count; if (_artists != null) _mainFormViewModel.InputProgressBarMax += _artists.Count; if (_works != null) _mainFormViewModel.InputProgressBarMax += _works.Count; if (_assets != null) _mainFormViewModel.InputProgressBarMax += _assets.Count; if (_albums != null) _mainFormViewModel.InputProgressBarMax += _albums.Count; if (_tracks != null) _mainFormViewModel.InputProgressBarMax += _tracks.Count; // Init phase 'completed' _mainFormViewModel.InputProgressBarValue = InitPayload; // Langs were already parsed if (_langs != null) _mainFormViewModel.InputProgressBarValue += _langs.Count; } await ParseTags(); await ParseRoles(); await ParseQualities(); await ParseArtists(); await ParseWorks(); await ParseAssets(); await ParseAlbums(); await ParseTracks(); Notify("Finalization..."); FinalizeAlbums(); FinalizeAssets(); if (_mainFormViewModel != null) { if (_mainFormViewModel.FilterArtistChecked) { CatalogContext.Instance.FilterUnusedArtists(); } else if (_mainFormViewModel.FilterWorkChecked) { CatalogContext.Instance.FilterUnusedWorks(); } _mainFormViewModel.InputProgressBarValue = _mainFormViewModel.InputProgressBarMax; } CatalogContext.Instance.Initialized = true; Notify("Parsing completed."); return ReturnCode.Ok; }
private FileFormat(FileFormatType type, string extension) { Type = type; Extension = extension; ExtensionWithSeparator = "." + extension; }
private int SetupResultPcm(AudioData from, out AudioData to, FileFormatType toFileFormat) { to = new AudioData(); to.fileFormat = toFileFormat; var fmt = FilterSetup(from, mFilters); to.meta = new WWFlacRWCS.Metadata(from.meta); to.meta.sampleRate = fmt.SampleRate; to.meta.totalSamples = fmt.NumSamples; to.meta.channels = fmt.Channels; switch (toFileFormat) { case FileFormatType.FLAC: #if true to.meta.bitsPerSample = 24; #endif break; case FileFormatType.DSF: to.meta.bitsPerSample = 1; break; } if (from.picture != null) { to.picture = new byte[from.picture.Length]; System.Array.Copy(from.picture, to.picture, to.picture.Length); } // allocate "to" pcm data to.pcm = new List<AudioDataPerChannel>(); for (int ch=0; ch < to.meta.channels; ++ch) { byte [] data; // set silent sample values to output buffer switch (toFileFormat) { case FileFormatType.DSF: if (0x7FFFFFC7 < (to.meta.totalSamples + 7) / 8) { return (int)WWFlacRWCS.FlacErrorCode.OutputFileTooLarge; } data = new byte[(to.meta.totalSamples + 7) / 8]; for (long i=0; i < data.LongLength; ++i) { data[i] = 0x69; } break; case FileFormatType.FLAC: if (0x7FFFFFC7 < to.meta.totalSamples * (to.meta.bitsPerSample / 8)) { return (int)WWFlacRWCS.FlacErrorCode.OutputFileTooLarge; } data = new byte[to.meta.totalSamples * (to.meta.bitsPerSample / 8)]; break; default: System.Diagnostics.Debug.Assert(false); data = null; break; } var adp = new AudioDataPerChannel(); adp.data = data; adp.bitsPerSample = to.meta.bitsPerSample; adp.totalSamples = to.meta.totalSamples; to.pcm.Add(adp); } return 0; }
public static Workbook SetFileFormat(this Workbook wb, FileFormatType fileFormat) { wb.FileFormat = fileFormat; return(wb); }
private int SetupResultPcm(AudioData from, List <FilterBase> filters, out AudioData to, FileFormatType toFileFormat) { to = new AudioData(); to.fileFormat = toFileFormat; var fmt = FilterSetup(from, 0, filters); to.meta = new WWFlacRWCS.Metadata(from.meta); to.meta.sampleRate = fmt.SampleRate; to.meta.totalSamples = fmt.NumSamples; to.meta.channels = fmt.NumChannels; switch (toFileFormat) { case FileFormatType.FLAC: #if true to.meta.bitsPerSample = 24; #endif break; case FileFormatType.DSF: to.meta.bitsPerSample = 1; break; } if (from.picture != null) { to.picture = new byte[from.picture.Length]; System.Array.Copy(from.picture, to.picture, to.picture.Length); } // allocate "to" pcm data to.pcm = new List <AudioDataPerChannel>(); for (int ch = 0; ch < to.meta.channels; ++ch) { byte[] data; // set silent sample values to output buffer switch (toFileFormat) { case FileFormatType.DSF: if (0x7FFFFFC7 < (to.meta.totalSamples + 7) / 8) { return((int)WWFlacRWCS.FlacErrorCode.OutputFileTooLarge); } data = new byte[(to.meta.totalSamples + 7) / 8]; for (long i = 0; i < data.LongLength; ++i) { data[i] = 0x69; } break; case FileFormatType.FLAC: if (0x7FFFFFC7 < to.meta.totalSamples * (to.meta.bitsPerSample / 8)) { return((int)WWFlacRWCS.FlacErrorCode.OutputFileTooLarge); } data = new byte[to.meta.totalSamples * (to.meta.bitsPerSample / 8)]; break; default: System.Diagnostics.Debug.Assert(false); data = null; break; } var adp = new AudioDataPerChannel(); adp.data = data; adp.bitsPerSample = to.meta.bitsPerSample; adp.totalSamples = to.meta.totalSamples; to.pcm.Add(adp); } return(0); }
protected override void Execute(NativeActivityContext context) { try { String workbookFullName = FilePath.Get(context); String newFileName = NewFileName.Get(context); string newfilePath = NewFilePath.Get(context); string fileFormat = ToDescriptionString(FileFormatType); String[] fileFormatTypeStr = FileFormatType.ToString().TrimStart().Split('_'); String extension = String.Concat(".", fileFormatTypeStr[0]); string newFileNameWithExtension = String.Concat(newFileName, extension); string workbookName = string.Empty; dynamic xlWorkbook = null; bool excelFileVisible = false; if (true == NeedToOpen) { excelFileVisible = true; } // Combine 2 path parts. string workbooknameas = Path.Combine(newfilePath, newFileName); string workbooknameasWithExtension = Path.Combine(newfilePath, newFileNameWithExtension); if (File.Exists(workbookFullName)) { ExcelHelper.Shared.Close_OpenedFile(workbookFullName); workbookName = Path.GetFileName(workbookFullName); ExcelHelper.Shared.GetApp(excelFileVisible).DisplayAlerts = false; xlWorkbook = ExcelHelper.Shared.GetApp(excelFileVisible).Workbooks.Open(workbookFullName); if (File.Exists(workbooknameasWithExtension)) { if (true == IsOverride) { // xlWorkbook.SaveAs(workbooknameas, FileFormatType, Missing.Value, Missing.Value, false, false, XlSaveAsAccessMode.xlNoChange, XlSaveConflictResolution.xlUserResolution, true, Missing.Value, Missing.Value, Missing.Value); XlFileFormat fm = (XlFileFormat)Enum.Parse(typeof(XlFileFormat), fileFormat); xlWorkbook.SaveAs(workbooknameas, fm, Missing.Value, Missing.Value, false, false, XlSaveAsAccessMode.xlNoChange, XlSaveConflictResolution.xlUserResolution, true, Missing.Value, Missing.Value, Missing.Value); } else { Log.Logger.LogData("The file \"" + newFileName + "\" is already exists in activity Excel_Workbook_SaveAs", LogLevel.Error); if (!ContinueOnError) { context.Abort(); } } } else { // xlWorkbook.SaveAs(workbooknameas, XlFileFormat.xlWorkbookDefault, Missing.Value, Missing.Value, false, false, XlSaveAsAccessMode.xlNoChange, XlSaveConflictResolution.xlUserResolution, true, Missing.Value, Missing.Value, Missing.Value); //xlWorkbook.SaveAs(workbooknameas, FileFormatType, Missing.Value,Missing.Value, false, false, XlSaveAsAccessMode.xlNoChange,XlSaveConflictResolution.xlUserResolution, true, Missing.Value, Missing.Value, Missing.Value); XlFileFormat fm = (XlFileFormat)Enum.Parse(typeof(XlFileFormat), fileFormat); xlWorkbook.SaveAs(workbooknameas, fm, Missing.Value, Missing.Value, false, false, XlSaveAsAccessMode.xlNoChange, XlSaveConflictResolution.xlUserResolution, true, Missing.Value, Missing.Value, Missing.Value); } if (true == NeedToClose) { xlWorkbook.Close(); } if (false == NeedToClose && false == NeedToOpen) { xlWorkbook.Close(); } if (false == NeedToClose && true == NeedToOpen) { xlWorkbook.Close(); ExcelHelper.Shared.GetApp(excelFileVisible).Workbooks.Open(workbookFullName); } if (ExcelHelper.Shared.GetApp(excelFileVisible).Workbooks.Count == 0) { ExcelHelper.Shared.Dispose(); } } else { Log.Logger.LogData("Excel file does not exist:\"" + workbookFullName + "\" in activity Excel_Workbook_SaveAs", LogLevel.Error); if (!ContinueOnError) { context.Abort(); } } } catch (Exception ex) { Log.Logger.LogData(ex.Message + " in activity Excel_Workbook_SaveAs", LogLevel.Error); if (!ContinueOnError) { context.Abort(); } } }