groupdocs

Active member
Joined
Mar 8, 2016
Messages
33
Location
Aspose Pty Ltd, Suite 163, 79 Longueville Road, NS
Programming Experience
10+
What?s new in this release?

GroupDocs team is pleased to announce the new release of GroupDocs.Conversion for .NET 3.0.0. It includes a large variety of document formats. Document conversion was never so easy. The legacy 1.1.0 version of GroupDocs.Conversion for .NET supported less document formats and required some effort to use. The GroupDocs team reconsidered and revamped the whole architecture, simplified the API and introduced more document and image formats for conversion. This release includes plenty of new features as listed below


  • Over 50 document formats are supported for conversion
  • No dependency of Web.UI based classes.
  • Simplified API, requires less lines of code
  • Easy integration in your .NET apps by using a single DLL for all types of documents
  • Convert most common image formats to document formats
  • Fast conversion
  • Less coding effort

Newly added documentation pages and articles


Some new articles have now been added into GroupDocs.Conversion for .NET documentation that may guide users briefly how to perform document conversion.

Overview: GroupDocs.Conversion for .NET

GroupDocs.Conversion for .NET is an advanced document conversion API developed to convert document formats from within any .NET application. This features-rich library empowers you to work with document conversion operations back and forth over 50 documents and image file formats. Using the document converter API is very simple as it used just one method with set of options to convert between different formats.

Pdf to Word Conversion.jpg

More about GroupDocs.Conversion for .NET

- Homepage of GroupDocs.Conversion for .NET: C# .NET Document Conversion API ? Convert Docs and Images Formats
- Download GroupDocs.Conversion for .NET: GroupDocs.Conversion for .NET - .NET Libraries - Files
- Online documentation of GroupDocs.Conversion for .NET: Home - GroupDocs Conversion for .NET Library - GroupDocs Product Documentation
- Video Tutorials for GroupDocs.Conversion for .NET: https://www.youtube.com/channel/UCNHpIBspxU4tXrOmpsYUXKQ/playlists
- Post your technical questions/queries to GroupDocs.Conversion for .NET Forums: GroupDocs.Conversion Product Family - Forums

Contact Information
Suite 163, 79 Longueville Road,
Lane Cove, NSW 2066, Australia.
Your Document Collaboration APIs | GroupDocs
sales@groupdocs.com
Phone: +1 (214) 329-9760
 
Multi format document viewer APIs for your cross platform .NET and Java apps

Augment your document rendering ability by creating cross platform .NET and Java apps for mobile, web or desktop interfaces with the help of the document viewer APIs in GroupDocs.Viewer Product Family suite. Application developers can rasterize documents and images, convert them to SVG-HTML-CSS to get high fidelity true text file rendering. Render over 50 business document formats and image files as HTML5, PDF or Image using predefined rendering options like whole document, page by page or custom range of pages. Conveniently obtain document information, rotate or reorder pages and watermark resultant documents together with extracting email attachments in their HTML or image representations.


Download your free trial today – https://bit.ly/2r8xMHj


Subscribe to GroupDocs on YouTube – https://bit.ly/2Q3bBwY
 
Read, Edit and Delete Metadata in FLV Files using C# .NET API

Most recent monthly release of the .NET document metadata API brings together a number of important enhancements and new features. Using version 18.11, app developers can work with missing metadata properties in Microsoft Excel XLSX documents together with the ability to read, update or remove metadata in DotNet based FLV files. Detect FLV files, read headers or manipulate XMP metadata conveniently with the help of the latest release, which also includes reduced memory consumption process while loading or saving spreadsheets and PDF files.

Following code snippet shows how to read the header in a FLV file:
C#:
//For complete examples and data files, please go to https://github.com/groupdocs-metadata/GroupDocs.Metadata-for-.NET
using (FlvFormat format = new FlvFormat(Common.MapSourceFilePath(filePath)))
{
    Console.WriteLine(format.Header.Version);
    Console.WriteLine(format.Header.HasVideoTags);
    Console.WriteLine(format.Header.HasAudioTags);
    Console.WriteLine(Convert.ToString(format.Header.TypeFlags, 2).PadLeft(8, '0'));
}


Download your free trial today – https://bit.ly/2xCKOjX


Watch YouTube video tutorials of the GroupDocs API – https://bit.ly/2DBUwa9
 
Change the orientation of document pages using C# ASP.NET API

New monthly release of the .NET document merger API helps app developers to programmatically change the orientation of document pages from portrait to landscape (or vice versa) across all available documents formats. In addition to this feature, version 18.11 also includes two new productive API methods offering the functionality of obtaining a list of all file formats supported by GroupDocs.Merger for .NET alongside the ability to rotate the pages of various types of documents complete with different rotation options.

Change Page Orientation
A new method ChangeOrientation is added, allowing developers to alter page orientation as needed.
C#:
public DocumentResult ChangeOrientation(Stream documentStream, OrientationOptions orientationOptions);

Get Supported Formats

GetSupportedFormats lets you extract the list of all supported API file formats.
C#:
public Dictionary GetSupportedFormats();

Rotate Pages

Finally, the RotatePages method would let you rotate the document pages.
C#:
public DocumentResult RotatePages(Stream documentStream, RotateOptions rotateOptions);

Start your free trial today and try these features at your end – https://bit.ly/2DYrTnC


Follow GroupDocs on YouTube – https://bit.ly/2Q3bBwY
 
HTML Based Document Editing APIs Native to C# .NET and Java

Edit your Word DOCX, Excel XLSX, OpenDocument, HTML and TXT documents with high accuracy using your favourite HTML editor by availing the cross platform .NET and Java document editing APIs from GroupDocs.Editor Product Family suite. App developers can create different types of DotNet or Java applications to integrate with any HTML editor of their choice, load the source file into the editor, perform desired manipulation and proficiently transform the processed document back to its original format. You also have access to all embedded resources of the loaded document such as images, fonts and CSS together with the ability to secure the resultant document by applying passwords.


Start editing your files by downloading a free trial today – https://bit.ly/2rj97jn


Subscribe to GroupDocs on YouTube – https://bit.ly/2Q3bBwY

dotnet-and-java-document-editor-apis-for-html-based-file-transformations-using-groupdocs-editor-.png
 
Convert EPS, PCL and TSV files, record document conversion time in your C# .NET apps

Newest release of the .NET document conversion API includes many enhancements and new features for application developers to take advantage of. This release supports converting EPS, PCL and TSV files and lets you measure conversion time of your multi format DotNet documents. Seamlessly rotate your converted PDF documents and image files or flatten form fields in PDF files with the help of version 18.11 of the .NET file converter. Other important additions in this release are the ability to set default font while converting Microsoft OneNote documents or Diagram files as well as the feature to include hidden Slides in output files.

Setting Default Font and Font Substitution Options

When Converting OneNote Document
C#:
const string source = "source.one";
var loadOptions = new OneLoadOptions
{
    DefaultFont = "Helvetica",
};
loadOptions.FontSubstitutes.Add(new KeyValuePair("Arial", "Helvetica"));
loadOptions.FontSubstitutes.Add(new KeyValuePair("Harriet", "Transcript"));
Set default font when converting from Diagram
const string source = "source.vsd";
var loadOptions = new DiagramLoadOptions
{
    DefaultFont = "Helvetica",
};
Measure Conversion Time
Measure conversion time and return it as a property of ConvertedDocument class
C#:
var convertedDocument = conversionHandler.Convert(source, saveOptions);
Console.WriteLine("Elapsed time: {0}ms", convertedDocument.Elapsed);

Rotation Feature

When Converting to PDF Format
Implement rotation feature when converting to PDF
C#:
var saveOptions = new PdfSaveOptions {
    Rotate = PdfSaveOptions.Rotation.On90
};

When Converting to Image
C#:
var saveOptions = new ImageSaveOptions {
    RotateAngle = 45
};
Flatten all Form Fields
Option to flatten all form fields when converting PDF documents
C#:
var loadOptions = new PdfLoadOptions
{
    FlattenAllFields = true
};
Include Hidden Slides in Converted Document
Include hidden Slides in converted document when converting from Slides


var loadOptions = new SlidesLoadOptions
{
    ShowHiddenSlides = true
};


Download a free trial of GroupDocs.Conversion for .NET and start converting your documents today – https://bit.ly/2nAxgjw


Watch YouTube video tutorials of the GroupDocs API – https://bit.ly/2RcR0Xh
 
Add form field esignatures to your PDF documents with C# .NET API

Most recent monthly release of the .NET esigning API comes with a number of new features and enhancements. You can now include and search checkbox, text or digital form field e-signatures in your PDF document pages on .NET platform. Version 18.11 of GroupDocs.Signature for .NET API lets you electronically add or find metadata signatures in Microsoft PowerPoint slides together with the capability of verifying digital signatures in Microsoft Word DOCX documents.

Sign PDF Document with a Form-Field Signature

Following example demonstrates how to add Checkbox in a PDF document:
C#:
// instantiate check-box form field signature
FormFieldSignature checkboxSignature = new PdfCheckboxFormFieldSignature("FieldCheckbox", true);
// instantiate options based on check-box form field signature
PdfFormFieldSignOptions checkboxOptions = new PdfFormFieldSignOptions(checkboxSignature)
{
    HorizontalAlignment = HorizontalAlignment.Left,
    VerticalAlignment = VerticalAlignment.Top,
    Margin = new Padding(120, 20, 0, 0),
    Height = 10,
    Width = 10
};
// sign document
string signedPath = handler.Sign("02_pages.pdf", checkboxOptions,
    new SaveOptions { OutputType = OutputType.String, OutputFileName = "Pdf_FormFields" });

API allows you to search for Form-Field Signatures like Text, Checkbox or Digital within the document.

Following example demonstrates how to search Form-Field Signature in PDF document:
C#:
// setup search options
PdfSearchFormFieldOptions searchOptions = new PdfSearchFormFieldOptions();
searchOptions.SearchAllPages = true;
searchOptions.NamePattern = @"Field";
searchOptions.Value = @"Value1";
// search document
SearchResult result = handler.Search("Pdf_FormFields_Signed.pdf", searchOptions);

Metadata Signatures for Slides document

Following example demonstrates how to compose Metadata Signature options for Slides document:
C#:
// setup options with text of signature
SlidesMetadataSignOptions signOptions = new SlidesMetadataSignOptions();
// Specify different Metadata Signatures and add them to options sigature collection
// setup Author property
SlidesMetadataSignature mdSign_Author = new SlidesMetadataSignature("Author", "Mr.Scherlock Holmes");
signOptions.MetadataSignatures.Add(mdSign_Author);
// setup data of document id
SlidesMetadataSignature mdSign_DocId = new SlidesMetadataSignature("DocumentId", Guid.NewGuid().ToString());
signOptions.MetadataSignatures.Add(mdSign_DocId);
// setup data of sign date
SlidesMetadataSignature mdSign_Date = new SlidesMetadataSignature("SignDate", DateTime.Now);
signOptions.MetadataSignatures.Add(mdSign_Date);
// setup some integer value
SlidesMetadataSignature mdSign_Days = new SlidesMetadataSignature("DocDays", 12345);
signOptions.MetadataSignatures.Add(mdSign_Days);
// setup data of sign date
SlidesMetadataSignature mdSign_Koeff = new SlidesMetadataSignature("SignKoeff", 2.345M);
signOptions.MetadataSignatures.Add(mdSign_Koeff);
// sign document
string signedPath = handler.Sign("test.pptx", signOptions,
    new SaveOptions { OutputType = OutputType.String, OutputFileName = "Slides_Documents_Metadata" });

You can search for Metadata Signatures within the Slides document.

Following example demonstrates how to search Metadata Signatures in Slides document:
C#:
// setup search options
SlidesSearchMetadataOptions searchOptions = new SlidesSearchMetadataOptions();
// set if we need built-in signatures
searchOptions.IncludeBuiltinProperties = true;
// search document
SearchResult result = handler.Search("SignedMetadata.pptx", searchOptions);

This latest version of the API provides few additional properties to verify Digital Signatures of Words document.
C#:
// setup digital verification options
WordsVerifyDigitalOptions verifyOptions = new WordsVerifyDigitalOptions("SherlockHolmes.cer");
verifyOptions.Comments = "Test1";
verifyOptions.SubjectName = "Signature";
verifyOptions.IssuerName = "GroupDocs";
verifyOptions.SignDateTimeFrom = new DateTime(2017, 1, 26, 14, 55, 57);
verifyOptions.SignDateTimeTo = new DateTime(2017, 1, 26, 14, 55, 59);        
//verify document
VerificationResult result = handler.Verify("digital signatures.docx", verifyOptions);

Download a free trial and start digitally signing your documents today – https://bit.ly/2NNGmIl

Watch YouTube video tutorials of the GroupDocs API – https://bit.ly/2F6yONN
 
Native .NET and Java APIs to Perform Document Search and Indexing

Perform advanced document search operations by with the help of cross platform .NET and Java text search APIs in GroupDocs.Search Product Family suite. It also equips application developers with the ability to create, update or merge multiple indices as well as smart index search functionality to use simple, Boolean, Fuzzy and Regular Expression (regex) search queries across a range of popular document formats. Build different types of feature rich search and indexing apps to fetch and manipulate data according to your specific business requirements.


Download your free trial today – http://bit.ly/2QNC05G


Watch video tutorials about GroupDocs APIs on YouTube – http://bit.ly/2PwqUNK
 
Compare charts, detect styles in PowerPoint Slides using C# .NET API

New monthly release of the document comparison .NET API includes some key enhancements and an important bug fix. With the latest release, application developers can compare charts and detect styles while working with Microsoft PowerPoint presentations within their .NET apps. A bug related to the use of auto shapes has been fixed for Slides files thus offering a refined usage experience. Comparison tester feature improvement in Microsoft Word documents is another highlight of version 18.11 of GroupDocs.Comparison for .NET – http://bit.ly/2SRtb8s


YouTube video tutorials of the GroupDocs API – http://bit.ly/2RZOfcG

improved-style-detection-and-charts-comparison-in-powerpoint-slides-using-groupdocs-comparison-f.png
 
Export Annotations with Additional Options using C# .NET Annotator API

Most recent monthly release of the .NET document annotator API includes some key feature additions, enhancements and bug fixes. With the help of the latest release, applications developers can redeem document pages with or without the annotations, export specific annotation type and range of pages while annotating documents or images on .NET platform. Other highlights from version 18.12 of GroupDocs.Annotation for .NET are important enhancements such as adding text replacement for grouped shapes and a number of fixed issues – http://bit.ly/2BIcJAa

Following code sample illustrates how you can obtain annotations from a JSON file and export them to a PDF document:
C#:
// Create instance of annotator. 
AnnotationConfig cfg = CommonUtilities.GetConfiguration();
                
AnnotationImageHandler annotator = new AnnotationImageHandler(cfg);
 
// Get file stream
Stream manifestResourceStream = new FileStream(CommonUtilities.MapSourceFilePath(filePath), FileMode.Open, FileAccess.ReadWrite);
List<AnnotationInfo> annotations = new List<AnnotationInfo>();
                
Stream stream = annotator.ExportAnnotationsToDocument(manifestResourceStream,annotations, DocumentType.Pdf);


// Save result stream to file.
using (FileStream fileStream = new FileStream(CommonUtilities.MapDestinationFilePath("Annotated.pdf"), FileMode.Create))
{
    byte[] buffer = new byte[stream.Length];
    stream.Seek(0, SeekOrigin.Begin);
    stream.Read(buffer, 0, buffer.Length);
    fileStream.Write(buffer, 0, buffer.Length);
    fileStream.Close();
}


YouTube video tutorials of the .NET API – http://bit.ly/2Sod3vn
 
Retrieve Folders Contained in Outlook Data Files using C# .NET API

Get the list of folders and sub-folders from your OST and PST Outlook data files; render the messages from these folders to PDF, HTML and Image formats with the help of the latest release of the .NET document rendering API. Ignore empty columns while rendering Microsoft Excel worksheets within your .NET apps to reduce processing time and optimize memory usage when working with large files using GroupDocs.Viewer for .NET – http://bit.ly/2UNFCDL

Following code snippet shows how you can retrieve the list of folders:
C#:
// Setup GroupDocs.Viewer config
ViewerConfig config = Utilities.GetConfigurations();


// Create image handler
ViewerImageHandler imageHandler = new ViewerImageHandler(config);
string guid = DocumentName;


// Get Outlook document info
OutlookDocumentInfoContainer documentInfoContainer = imageHandler.GetDocumentInfo(guid) as OutlookDocumentInfoContainer;


foreach (string folderName in documentInfoContainer.Folders)
    Console.WriteLine("Folder name: {0}", folderName);

Here's how you can retrieve sub-folders list:
C#:
// Setup GroupDocs.Viewer config
ViewerConfig config = Utilities.GetConfigurations();


// Create image handler
ViewerImageHandler imageHandler = new ViewerImageHandler(config);
string guid = DocumentName;


// Create option object with specified folder name
DocumentInfoOptions options = new DocumentInfoOptions();
options.OutlookOptions.FolderName = "Inbox";
// Get outlook document info
OutlookDocumentInfoContainer documentInfoContainer = imageHandler.GetDocumentInfo(guid, options) as OutlookDocumentInfoContainer;


foreach (string folderName in documentInfoContainer.Folders)
    Console.WriteLine("Folder name: {0}", folderName);

Below code snippet demonstrates how an email message from any of the retrieved folders can be rendered as an image:
C#:
// Setup GroupDocs.Viewer config
ViewerConfig config = Utilities.GetConfigurations();


// Create image handler
ViewerImageHandler imageHandler = new ViewerImageHandler(config);
string guid = DocumentName;


// Create image options with specified folder name (use HtmlOptions to render into HTML)
ImageOptions options = new ImageOptions();
options.OutlookOptions.FolderName = "Inbox\\Sub Folder 1";


// Render document into image (List<PageHtml> is returned when rendering into HTML)
List<PageImage> pages = imageHandler.GetPages(guid, options);


foreach (PageImage page in pages)
{
    // Save each image at disk
    Utilities.SaveAsImage(page.PageNumber + "_" + DocumentName, page.Stream);
}

To render a message as PDF, refer to following code example:
C#:
// Setup GroupDocs.Viewer config
ViewerConfig config = Utilities.GetConfigurations();


// Create image handler
ViewerImageHandler imageHandler = new ViewerImageHandler(config);
string guid = DocumentName;


// Create pdf options with specified folder name
PdfFileOptions options = new PdfFileOptions();
options.OutlookOptions.FolderName = "Inbox";


// Get pdf document
FileContainer fileContainer = imageHandler.GetPdfFile(guid, options);


//Save file
Utilities.SaveFile(guid, fileContainer.Stream);



YouTube video tutorials of the GroupDocs API – http://bit.ly/2UKFx3L
 
Extract Metadata from Presentation Templates using .NET Parsing API

Develop applications for extracting text and metadata from many different text and presentation templates on .NET platform with the help of the latest version of the document text extraction API. Another important feature is the ability to programmatically fetch tables from PDF documents within your .NET apps. While working with this functionality, you can create table bounds manually or let the API identify the layout in automatic mode.


In addition to this, you have access to the features of detecting media type of your password-protected Office OpenXML documents and batch document processing in GroupDocs.Parser for .NET API – http://bit.ly/2QuFPsr

Following code samples show how to extract text and metadata from templates:
C#:
// Extracting Text
void ExtractText(string fileName)
{
    // Extract a text from the file
    var text = Extractor.Default.ExtractText(fileName);
    // Print an extracted text
    Console.WriteLine(text);
}
// Extracting Metadata 
void ExtractMetadata(string fileName)
{
    // Extract metadata from the file
    var metadata = Extractor.Default.ExtractMetadata(fileName);
    // Print extracted metadata
    foreach (var m in metadata)
    {
        // Print a metadata key
        Console.Write(m.Key);
        Console.Write(": ");
        // Print a metadata value
        Console.WriteLine(m.Value);
    }
}

Below code sample shows how to detect media type in password-protected Office OpenXML documents:
C#:
// Create load options
LoadOptions loadOptions = new LoadOptions();
// Set a password
loadOptions.Password = "password";
// Get a default composite media type detector
var detector = CompositeMediaTypeDetector.Default;
// Create a stream to detect media type by content (not file extension)                
using (var stream = File.OpenRead(Common.GetFilePath(fileName)))
{
    // Detect a media type
    var mediaType = detector.Detect(stream, loadOptions);
    // Print a detected media type
    Console.WriteLine(mediaType);
}
 
Work with secure PDF, Words, Excel, PowerPoint Documents using C# .NET Metadata API

Manipulate metadata in password-protected Microsoft Word and PDF documents, Excel worksheets and PowerPoint presentations on .NET platform using the latest version of the .NET document metadata API. Application developers can better utilize memory when loading or saving word processing and slides documents within their apps together with the ability to update metadata keys in DOC and DOCX file formats using GroupDocs.Metadata for .NET API – http://bit.ly/2QESWr1

Following code snippet shows how to work with metadata of a password protected PDF document:
C#:
LoadOptions loadOptions = new LoadOptions("password");
using (PdfFormat format = new PdfFormat(Common.MapSourceFilePath(protectedFilePath), loadOptions))
{
    // Working with the password-protected document
    format.CleanMetadata();
    format.Save(Common.MapDestinationFilePath(protectedFilePath));
}


This .NET API supports working with Word formats with less memory consumption. Please note that the DocFormat class implements the IDisposable interface and it's necessary to call the Dispose() method when you're done working with its instance.


Check following code snippets to use less memory while working with Word documents.
C#:
using (DocFormat format = new DocFormat(@"d:\input.docx"))
{
    // Working with metadata
}


If you are loading a Word document from a stream, it's up to you to close the stream when the file is not needed anymore.


C#:
using (Stream stream = File.Open(@"d:\input.doc", FileMode.Open, FileAccess.ReadWrite))
{
    using (DocFormat format = new DocFormat(stream))
    {
        // Working with metadata
    }
    // The stream is still open here
}


Similarly, when saving the output file to a stream:
C#:
using (Stream stream = File.Open(@"d:\output.docx", FileMode.OpenOrCreate, FileAccess.ReadWrite))
{
    using (DocFormat format = new DocFormat(@"d:\input.docx"))
    {
        // Working with metadata
  
        format.Save(stream);
    }
    // The stream is still open here
}


Watch YouTube video tutorials of the GroupDocs API – http://bit.ly/2skUjRO
 
Utilize blended characters and wildcard search in your apps using .NET API

If you are looking for a text search API offering you a diverse set of features to build search and indexing applications on .NET platform proficiently while working with Microsoft Office, OpenOffice, PDF, ZIP archives and different other types of documents, look no further than GroupDocs.Search for .NET.


One of the notable features of this .NET API is the use of blended characters within your apps. These characters help you reduce search terms and when indexed, blended characters get simultaneously interpreted as valid letters as well as separators.


Another prominent feature is that of searching words containing wildcards; supporting two forms, a single wildcard arbitrary character, or a range of characters - http://bit.ly/2AT9qXi
 
Dynamically Assemble External Documents using C# .NET API

If you are a software developer, and you are looking to programmatically incorporate document automation functionality into your applications on .NET platform, there are not many APIs which offer you the convenience of use bundled with a proven feature set and seamless processing. Of the few APIs you could trust, GroupDocs.Assembly for .NET is surely one to consider.


It envelops a range of very useful functions giving you the edge when assembling various types of commonly used documents formats, from different data sources such as database, JSON, XML, OData and Custom .NET Objects. An important feature of this automation API is the ability to dynamically assemble external documents. This feature is currently available for Microsoft Word and Email formats.


You can work with doc tags, which are placeholders within templates, allowing you to absorb documents at run-time. Using these doc tags, programmers can insert documents dynamically into their reports with the .NET API. Learn more – http://bit.ly/automate-external-documents

Following code snippet shows how to insert external document in Word Processing format:
C#:
//Setting up source open document template
const String strDocumentTemplate = "Word Templates/Nested External Document.docx";
//Setting up destination open document report 
const String strDocumentReport = "Word Reports/Nested External Document.docx";
try
{
    //Instantiate DocumentAssembler class
    DocumentAssembler assembler = new DocumentAssembler();
    //Call AssembleDocument to generate  Report in open document format
    assembler.AssembleDocument(CommonUtilities.GetSourceDocument(strDocumentTemplate),
                               CommonUtilities.SetDestinationDocument(strDocumentReport),
                               new DataSourceInfo(DataLayer.GetCustomerData(), "customer"));
}
catch (Exception ex)
{
    Console.WriteLine(ex.Message);
}


Similarly, here's how to insert an external document in Email format:
C#:
//Setting up source open document template
const String strDocumentTemplate = "Email Templates/Nested External Document.msg";
//Setting up destination open document report 
const String strDocumentReport = "Email Reports/Nested External Document.msg";
try
{
    //Instantiate DocumentAssembler class
    DocumentAssembler assembler = new DocumentAssembler();
    //Call AssembleDocument to generate  Report in open document format
    assembler.AssembleDocument(CommonUtilities.GetSourceDocument(strDocumentTemplate),
                               CommonUtilities.SetDestinationDocument(strDocumentReport),
                               new DataSourceInfo(DataLayer.GetCustomerData(), "customer"));
}
catch (Exception ex)
{
    Console.WriteLine(ex.Message);
}
 
Edit your Documents in Multi-threaded Environment using C# .NET API

Editing different types of documents programmatically on different development platforms is almost a given when talking about document manipulation in general. Most basic requirement is to modify file contents, then re-convert the file to original or even a different format too. Add to it some other perks like multiple sources for loading documents, securing the resultant documents and so on.


So, an API offering document editing features plus the document we wish to edit is all we need to get started. If .NET platform is your forte, you can try GroupDocs.Editor for .NET API, which is a feature rich file editor helping you in developing simple, scalable C# and ASP.NET apps which integrate with different HTML based editors to modify your Microsoft Word, Excel, OpenDocument, Text, HTML and other types of documents.


Latest release of this .NET API supports a refined set of lists and paragraphs to use in HTML editors. Additionally, you have access to a more stable multi-threading environment thus allowing you to further enhance your document editing experience. Try free today – http://bit.ly/2DZY99S


Follow GroupDocs on YouTube – http://bit.ly/2UPmVPr

build-document-editing-apps-on-dotnet-platform-in-multi-threading-environment-using-groupdocs-ed.png
 
Back
Top Bottom