How to create simple reports with PrintDocument in C#

Document

Reporting is a common task in business applications, and for that, ComponentOne includes a specialized FlexReport library that allows you to make complex reports. But sometimes, using specialized tools can be too tricky or not flexible enough.

For example, if you wanted to generate a report “from scratch” by printing text to a document word by word, a reporting library would not be the best tool.

Reporting libraries are over-engineered by design to make it quick and easy. For more flexible and from-the-ground-up solutions, ComponentOne includes another component: C1PrintDocument.

About C1PrintDocumentt — An Extended C# PrintDocument Component

C1PrintDocument provides an extensive and feature-rich document object model (DOM), with support for various layouts (inline, stacked), ambient and hierarchical styles, infinitely nested tables, table of contents, detailed control over pagination (orphan/widow, page size/headers/footers, etc.), etc. On top of all that, it also has a data binding layer.

You can download the C1PrintDocument component as part of the C1.Win.Printing NuGet package (WinForms version) or C1.Xaml.WPF.PrintDocument (WPF version). It supports .NET 6 and higher with C# or VB.NET code.

Once you are familiar with it, you can relatively easily in code create pretty complex and flexible documents that then can be viewed, printed, saved, or exported in PDF (Portable Document Format), RTF (Rich Text File), MS Excel, and other formats.

If you need to print arbitrary text with pagination and different layout options, you can start using this simple code:

Hello World” with C1PrintDocument

// create C1PrintDocument instance
var doc = new C1.C1Preview.C1PrintDocument();

// insert content
doc.Body.Children.Add(new C1.C1Preview.RenderText(doc, "Hello World!"));

//force document generation
doc.Generate();

// preview what you got with RibbonPreviewDialog
var preview = new C1.Win.RibbonPreview.C1RibbonPreviewDialog();
preview.Document = doc;
preview.ShowDialog();

That’s it. You can play with page settings in the preview dialog to see that your content reflows and can be paginated without any code from your side.

If you need a more complex report-like application, you need to define the layout of elements and use data binding to generate elements according to your data. To show how you can do that, we SimpleReports sample that can be downloaded as a zip file. Now let’s talk about some individual samples and technics.

Create the Simple Report

The most uncomplicated “Customer Labels” sample shows labels flowing in the left to the right direction, as many labels on a single page as can fit.

To compose C1PrintDocument, you should use elements derived from the RenderObject class and add them to the C1PrintDocument.Body.

Children collection in the same way as you add the controls to control.Controls collection in WinForms application. Elements can be nested and use parent object binding as a data source.

RenderArea is a render object that is specifically a container for child objects. By default, when a new RenderArea is created, its width is equal to the width of its parent area.

For RenderArea, specifying the width or height as “Unit.Auto” means that the size of the children determines the appropriate size.

Within their container (parent object or document body), render objects by default are placed according to the stacking rules, determined by the value of the Stacking property of the container (document for top-level objects).

This value can be one of the following StackingRulesEnum enumeration members:

BlockTopToBottom: Objects are placed one beneath the other within the container. When the bottom edge of the current page is reached, a new page is added. This is the default;
BlockLeftToRight: Objects are placed one next to another, from left to right. When the right edge of the current page is reached, a new “horizontal” page is added (a horizontal page logically extends the preceding page to the right;
InlineLeftToRight: Objects are placed inline, one next to another, from left to right. When the right edge of the current page is reached, the sequence wraps to the next line. A new page is added when the bottom of the current page is reached.

The layout of the “Customer Labels” document consists of several key elements:

The outer RenderArea object “raContainer” serves as a container for all labels.
The RenderArea object “raItem” representing a single label.
The RenderText object “rt” representing label content.

Here is what it should look like:

Customer Labels

Let me show you some code with more details:

Customer Labels Code

// create outer render area
RenderArea raContainer = new RenderArea();

// define left-to-right flow for child elements
raContainer.Stacking = StackingRulesEnum.InlineLeftToRight;

_printDocument.Body.Children.Add(raContainer);

// define data schema
DataSource ds = CreateDemoDataSource();
DataSet dsCustomers = new DataSet(ds, "SELECT CompanyName, Address, City, PostalCode, Country FROM Customers ORDER BY CompanyName");

// add data set to the document
_printDocument.DataSchema.DataSets.Add(dsCustomers);

// create render area representing single label
RenderArea raItem = new RenderArea();

// set right and bottom borders as light gray dotted lines 0.1 point wide
raItem.Style.Borders.Right = new LineDef("0.1pt", Color.LightGray, System.Drawing.Drawing2D.DashStyle.Dot);
raItem.Style.Borders.Bottom = new LineDef("0.1pt", Color.LightGray, System.Drawing.Drawing2D.DashStyle.Dot);

// set size in millimeters
raItem.Width = "40mm";
raItem.Height = "20mm";

// do not split the label into different pages
raItem.SplitVertBehavior = SplitBehaviorEnum.Never;

// set the data source
raItem.DataBinding.DataSource = dsCustomers;

// add label as a child to outer container
raContainer.Children.Add(raItem);

// define text which should be printed inside label
RenderText rt = new RenderText();
rt.Text = "[Fields!CompanyName.Value]\r\n[Fields!Address.Value]\r\n[Fields!City.Value] [Fields!PostalCode.Value]\r\n[Fields!Country.Value]";

// Add the text as a child of label
raItem.Children.Add(rt);

// generate document
_printDocument.Generate();

In the above code text of each label is composed of data-bound fields using the scripting language. During document generation, the C1PrintDocument will calculate these fields and print actual values. You can read more about text expressions here.

Using the Groups

C1PrintDocument allows you to use expressions to group your data. The “Alphabetical List of Products” sample groups products by the first letter of the product name. It allows you to show a nice formatted list of products:

Alphabetical List of Products

This sample layouts data in a table form. The table is created using the RenderTable class. The size of tables is not limited and determined at render time by the cell with the highest row and column numbers whose contents have been set.

Row and column indices start at zero. By default, the size of the table is equal to the width of the parent element’s client area. Row heights are set automatically to match the largest content height in a row.

Alphabetical List of Products Code

// Define data schema
DataSource ds = CreateDemoDataSource();

// Create DataSet containing data selected from database
// "FirstLetter" field is the first letter of product name
DataSet dsProducts = new DataSet(ds,
        "SELECT Left(p.ProductName, 1) AS FirstLetter, p.ProductName, p.QuantityPerUnit, p.UnitsInStock, c.CategoryName " +
        "FROM Categories c, Products p " +
        "WHERE c.CategoryID = p.CategoryID " +
        "ORDER BY p.ProductName");

// Add data source and data set to the document:
// this will preserve the data binding if the document is saved as c1d/c1dx
_printDocument.DataSchema.DataSources.Add(ds);
_printDocument.DataSchema.DataSets.Add(dsProducts);

// RenderTable class is used to create a table
RenderTable rt = new RenderTable();

// TableVectorGroup collection is used to group the data by "FirstLetter" field.
// The RowGroups property accepts two integers.
// The first value is the index of the first row included in the group (0).
// The second value is the count of rows in the group (3).
TableVectorGroup tvg = rt.RowGroups[0, 3];

// Using the DataBinding property in the TableVectorGroup, which is the base class for table row and column groups, a RenderTable can be data bound.
tvg.DataBinding.DataSource = dsProducts;

// Group by “FirstLetter” query result field
tvg.DataBinding.Grouping.Expressions.Add("Fields!FirstLetter.Value");

// Set header row
rt.Cells[0, 0].Text = "[Fields!FirstLetter.Value]";

// Merge cells from [0, 1] to [0, 4]
rt.Cells[0, 1].SpanCols = 4;

// Set sub-header row
rt.Cells[1, 1].Text = "Product Name:";
rt.Cells[1, 2].Text = "Category Name:";
rt.Cells[1, 3].Text = "Quantity Per Unit:";
rt.Cells[1, 4].Text = "Units In Stock:";

// Set data row
// "[Fields!ProductName.Value]" means to take the value of the "ProductName" field from the query result
rt.Cells[2, 1].Text = "[Fields!ProductName.Value]";
rt.Cells[2, 2].Text = "[Fields!CategoryName.Value]";
rt.Cells[2, 3].Text = "[Fields!QuantityPerUnit.Value]";
rt.Cells[2, 4].Text = "[Fields!UnitsInStock.Value]";

// Create a nested (second) group of rows
tvg = rt.RowGroups[2, 1];
tvg.DataBinding.DataSource = dsProducts;

// Add table to the document
_printDocument.Body.Children.Add(rt);

// Generate document
_printDocument.Generate();

Note: ranges of groups must not overlap.

Using the Expressions

Expressions (or scripts) are used in C1PrintDocument to extract, calculate, display, group, sort, filter, parameterize, and format the contents, and extend a report’s functionality. You can read more about scripts here.

Visual Basic is used as the expression language by default. To use c# change ScriptingOptions.Language property.

The “Employees” sample uses scripts to insert photos into the generated document:

Employees

The sample uses the FormatDataBindingInstanceScript property to set a script executed each time a new instance of the current RenderObject is created due to data binding resolving.

Employees Code

// define data set
DataSet dsEmployers = new DataSet(ds,
     "SELECT EmployeeID, LastName, FirstName, Title, TitleOfCourtesy, BirthDate, HireDate, Address, City, Region, PostalCode, Country, HomePhone, Extension, Notes, ReportsTo, Photo " +
     "FROM Employees " +
     "ORDER BY Country, City, FirstName, LastName");

// add data source and data set to the document: this will preserve the data binding if the document is saved as c1d/c1dx
_printDocument.DataSchema.DataSources.Add(ds);
_printDocument.DataSchema.DataSets.Add(dsEmployers);

// create table
RenderTable rt = new RenderTable();

// set header row
rt.Cells[0, 0].Text = "Country";
rt.Cells[0, 1].Text = "City";
rt.Cells[0, 2].Text = "Address";
rt.Cells[0, 3].Text = "Home Phone";

// set country row
rt.Cells[1, 0].Text = "[Fields!Country.Value]";

// set city row
rt.Cells[2, 1].Text = "[Fields!City.Value]";

// set data rows
rt.Cells[3, 0].Text = "[Fields!FirstName.Value] [Fields!LastName.Value]";
rt.Cells[3, 0].SpanCols = 2;

rt.Cells[3, 2].Text = "[Fields!Address.Value]";
rt.Cells[3, 3].Text = "[Fields!HomePhone.Value]";

RenderImage ri = new RenderImage(_printDocument);

// show all exceptions and warnings for script debug
_printDocument.ThrowExceptionOnError = true;
_printDocument.AddWarningsWhenErrorInScript = true;

// using the VB script to extract an image from query resault
ri.FormatDataBindingInstanceScript = @"
     ' get ri object
     Dim ri as RenderImage = DirectCast(RenderObject, RenderImage)

     ' get DB BLOB object as byte array
     Dim picData as Byte() = DirectCast(RenderObject.Original.DataBinding.Parent.Fields!Photo.Value, Byte())
     Const bmData As Integer = 78
     Dim ms as IO.MemoryStream = New IO.MemoryStream(picData, bmData, picData.Length - bmData)

     ' create image from stream
     ri.Image = Image.FromStream(ms)
     ";

// set image parameters
ri.Width = "30mm";
ri.Height = "30mm";
ri.Style.ImageAlign.AlignHorz = ImageAlignHorzEnum.Center;
ri.Style.ImageAlign.AlignVert = ImageAlignVertEnum.Center;

rt.Cells[4, 0].RenderObject = ri;
rt.Cells[4, 0].SpanCols = 2;
rt.Cells[4, 0].SpanRows = 2;

rt.Cells[4, 2].Text = "[Fields!Title.Value]";
rt.Cells[4, 2].Style.Parents = dataStyle;

rt.Cells[4, 3].Text = "[FormatDateTime(Fields!BirthDate.Value, DateFormat.ShortDate)]    [FormatDateTime(Fields!HireDate.Value, DateFormat.ShortDate)]";
rt.Cells[4, 3].Style.Parents = dataStyle;

// add area for notes
RenderArea raNotes = new RenderArea();

var rtNoteTitle = new RenderText();
rtNoteTitle.Text = "[Fields!FirstName.Value]`s notes:";

// add note text
var rtNote = new RenderText();
rtNote.Text = "[Fields!Notes.Value]";

// do not split the area into different pages
raNotes.SplitVertBehavior = SplitBehaviorEnum.Never;

raNotes.Children.Add(rtNoteTitle);
raNotes.Children.Add(rtNote);

rt.Cells[5, 2].RenderObject = raNotes;

// create group by city
TableVectorGroup tvg = rt.RowGroups[2, 6];
tvg.DataBinding.DataSource = dsEmployers;
tvg.DataBinding.Grouping.Expressions.Add("Fields!City.Value");

// create group by country
tvg = rt.RowGroups[0, 8];
tvg.DataBinding.DataSource = dsEmployers;
tvg.DataBinding.Grouping.Expressions.Add("Fields!Country.Value");

// add data rows
tvg = rt.RowGroups[3, 5];
tvg.DataBinding.DataSource = dsEmployers;
tvg.SplitBehavior = SplitBehaviorEnum.Never;

// add table to the document
_printDocument.Body.Children.Add(rt);

// define a cell group style for the rectangular area of table cells, you can set the style rt.UserCellGroups.Add(new UserCellGroup(new Rectangle(0, 3, 4, 3)));
rt.UserCellGroups[0].Style.Borders.All = new LineDef("0.5pt", Color.Black);

// generate document
_printDocument.Generate();

Different objects in the C1PrintDocument hierarchy have properties accepting scripts that allow changing appearance on the fly depending on data. For example, you can use style to highlight orders worth $1000 or more with blue color using the .TextColorExpr expression:

Text Color by Condition

rt.Cells[3, 4].Style.TextColorExpr = "iif(Fields!UnitPrice.Value * Fields!Quantity.Value >= 1000, Colors.Blue, Colors.Black)";

Using the Styles

The C1PrintDocument Style property is the root style of the document with which you can set the default appearance of visual components: borders, font, line spacing of a text, etc.

The C1PrintDocument PageLayout. PageSettings property helps set page options for printing to select the size of the paper, page orientation, etc.

For document pages, you can adjust settings using the Style property of the RenderObject class: content margins, page size, etc. This property cannot be assigned. Set the Parent to that other style to use another style as the base for the current object’s style.

Setting Styles

// set default style for document
_printDocument.Style.FontName = "Verdana";
_printDocument.Style.FontSize = 10;

// set margin to pages in millimeters
_printDocument.PageLayout.PageSettings.LeftMargin = "12mm";
_printDocument.PageLayout.PageSettings.RightMargin = "12mm";
_printDocument.PageLayout.PageSettings.TopMargin = "12mm";
_printDocument.PageLayout.PageSettings.BottomMargin = "12mm";

// set group header style
// for large documents it is better to create a named style for reuse
C1.C1Preview.Style headerStyle = _printDocument.Style.Children.Add();
headerStyle.FontSize = 9;
headerStyle.FontBold = true;
headerStyle.GridLines.Bottom = new LineDef("1pt", Color.Black);

// set country header style
C1.C1Preview.Style countryStyle = _printDocument.Style.Children.Add();
countryStyle.FontSize = 11;
countryStyle.FontBold = true;

// set city header style
C1.C1Preview.Style cityStyle = _printDocument.Style.Children.Add();
cityStyle.FontSize = 10;
cityStyle.FontUnderline = true;

// set document caption
var rtCaption = new RenderText();
rtCaption.Text = "Employees";

// set style parameters directly is fine for small documents or styles used just once
rtCaption.Style.FontName = "Tahoma";
rtCaption.Style.FontSize = 16;
rtCaption.Style.Padding.All = "2mm";
rtCaption.Style.BackColor = Color.LightGray;

_printDocument.Body.Children.Add(rtCaption);

// create table
RenderTable rt = new RenderTable();

// set top, left, bottom, right padding of content within the cell to 1 millimeter
rt.CellStyle.Padding.All = "1mm";

// set header row
rt.Cells[0, 0].Text = "Country";
rt.Cells[0, 0].Style.Spacing.Top = "2mm";
rt.Cells[0, 0].Style.Parents = headerStyle;

rt.Cells[0, 1].Text = "City";
rt.Cells[0, 1].Style.Parents = headerStyle;

rt.Cells[0, 2].Text = "Address";
rt.Cells[0, 2].Style.Parents = headerStyle;

rt.Cells[0, 3].Text = "Home Phone";
rt.Cells[0, 3].Style.Parents = headerStyle;

// set country row
rt.Cells[1, 0].Text = "[Fields!Country.Value]";
rt.Cells[1, 0].Style.Parents = countryStyle;

// set city row
rt.Cells[2, 1].Text = "[Fields!City.Value]";
rt.Cells[2, 1].Style.Parents = cityStyle;

// define style for the rectangular area of table cells from cell where row = 0, column = 3, the 4 cells width and the 3 cells height
rt.UserCellGroups.Add(new UserCellGroup(new Rectangle(0, 3, 4, 3)));

// add to cell the black border of 0.5 point width
rt.UserCellGroups[0].Style.Borders.All = new LineDef("0.5pt", Color.Black);

Using the Aggregates

For the average report, just grouping data is not enough. People usually want to see some aggregate values at the bottom. Let’s see how you can add aggregates in the “Employee Sales by Country” sample:

Employee Sales by Country

Employee Sales by Country Code

// set dates
var date1 = new DateTime(2015, 9, 7, 0, 0, 0);
var date2 = new DateTime(2016, 5, 5, 0, 0, 0);

var dsSales = new DataSet(dataSource, string.Format(
      "SELECT o.ShipCountry, e.EmployeeID, e.FirstName, e.LastName, o.ShippedDate, o.Freight " +
      "FROM Employees e, Orders o " +
      "WHERE e.EmployeeID = o.EmployeeID AND o.ShippedDate IS NOT NULL AND o.ShippedDate BETWEEN #{0} 00:00:00# AND #{1} 00:00:00# " +
      "ORDER BY o.ShipCountry, e.FirstName, e.LastName, o.ShippedDate", date1.ToString(@"MM\/dd\/yyyy"), date2.ToString(@"MM\/dd\/yyyy")));

// add data source and data set to the document: this will preserve the data binding if the document is saved as c1d/c1dx
_printDocument.DataSchema.DataSources.Add(dataSource);
_printDocument.DataSchema.DataSets.Add(dsSales);

// add caption
var raCaption = new RenderArea();

var header1 = new RenderText();
header1.Text = "Employee sales by country";

var header2 = new RenderText();
header2.Text = string.Format("Between {0} and {1}", date1.ToShortDateString(), date2.ToShortDateString());

raCaption.Children.Add(header1);
raCaption.Children.Add(header2);

_printDocument.Body.Children.Add(raCaption);

// create table
var rt = new RenderTable();

// header: country
rt.Cells[0, 0].Text = "[Fields!ShipCountry.Value]";
rt.Cells[0, 2].Text = "$[Aggregates!SumByCountry.Value]";

// data
rt.Cells[1, 0].Text = "[Fields!FirstName.Value] [Fields!LastName.Value]";
rt.Cells[1, 1].Text = "[Math.Round(Aggregates!SumByEmployee.Value / Aggregates!SumByCountry.Value * 100, 1)]%";
rt.Cells[1, 2].Text = "$[Aggregates!SumByEmployee.Value]";

// create a group by ship country to be repeated for each group
TableVectorGroup tvg = rt.RowGroups[0, 2];
tvg.DataBinding.DataSource = dsSales;

// data is grouped by the "ShipCountry" field
tvg.DataBinding.Grouping.Expressions.Add("Fields!ShipCountry.Value");

// Create an aggregate that will calculate the sum of "Freight" fields within each grouping by the "ShipCountry" field
 _printDocument.DataSchema.Aggregates.Add(new Aggregate("SumByCountry", "Fields!Freight.Value", tvg.DataBinding, RunningEnum.Group, AggregateFuncEnum.Sum));

tvg = rt.RowGroups[1, 1];
tvg.DataBinding.DataSource = dsSales;
tvg.DataBinding.Grouping.Expressions.Add("Fields!EmployeeID.Value");

// add total sum by employee aggregate value: data grouped by the "EmployeeID" field, the sum of the "Freight" field values is calculated
_printDocument.DataSchema.Aggregates.Add(new Aggregate("SumByEmployee", "Fields!Freight.Value", tvg.DataBinding, RunningEnum.Group, AggregateFuncEnum.Sum));

// add data rows
tvg = rt.RowGroups[1, 1];
tvg.DataBinding.DataSource = dsSales;

// add table to the document
_printDocument.Body.Children.Add(rt);

// generate document
_printDocument.Generate();

In the above code, the aggregate is constructed with this method call: new Aggregate(“SumByCountry”, “Fields!Freight.Value”, tvg.DataBinding, RunningEnum.Group, AggregateFuncEnum.Sum). Parameters are:

“SumByCountry” is the aggregate name.
“Fields!Freight.Value” is the expression for calculating the sum.
“tvg.DataBinding” is the data source for the aggregate.
“RunningEnum.Group” means that the aggregate has a group scope.
“AggregateFuncEnum.Sum” means the aggregate returns the sum of values of the expression within the scope.

The C1PrintDocument.DataSchema.Aggregates.Add method adds Aggregate object to Aggregates collection. Then, the aggregate with “SumByCountry” name can be used in any place of document like this: rt.Cells[0, 2].Text = “$[Aggregates!SumByCountry.Value]”.

Adding aggregate to document.Aggregates collection is not obligatory. You can use aggregate functions directly in any expression, as shown here.

Drawing the Charts

Very often, people want to see a visual representation of their data. The “Sales by Category” sample generates charts using FlexChart control and then inserts images into the document.

Here is how it looks when previewed:

Sales by Category

To use some arbitrary assembly in the C1PrintDocument scripts, it should be added to the C1PrintDocument.ScriptingOptions.ExternalAssemblies collection. To use FlexChart, we should add references to FlexChart and its dependencies.

Sales by Category Code

// adding assemblies referenced in script

_printDocument.ScriptingOptions.ExternalAssemblies.Add(typeof(Form).Assembly.ManifestModule.Name);
_printDocument.ScriptingOptions.ExternalAssemblies.Add(typeof(C1.Win.Chart.FlexChart).Assembly.ManifestModule.Name);
_printDocument.ScriptingOptions.ExternalAssemblies.Add("System.Data.dll");
_printDocument.ScriptingOptions.ExternalAssemblies.Add("System.Xml.dll");

// create DataTable and assign it to document tag as data source for charts

// the "dataTable" tag will be used to pass the DataTable value to the RenderImage object

Tag newTag = new Tag("dataTable", GetDataSource(), typeof(System.Data.DataTable));
_printDocument.Tags.Add(newTag);

// define data schema
var dataSource = CreateDemoDataSource();

var dsCategories = new DataSet(dataSource,
      "SELECT c.CategoryName, p.ProductName, p.UnitPrice, p.UnitsInStock " +
      "FROM Products p, Categories c " +
      "WHERE p.CategoryID = c.CategoryID " +
      "ORDER BY c.CategoryName, p.ProductName");

// add data source and data set to the document: this will preserve the data binding if the document is saved as c1d/c1dx
_printDocument.DataSchema.DataSources.Add(dataSource);
_printDocument.DataSchema.DataSets.Add(dsCategories);

var rt = new RenderTable();

// set header 1
rt.Cells[1, 0].Text = "[Fields!CategoryName.Value]";

// set header 2
rt.Cells[2, 0].Text = "Product:";
rt.Cells[2, 1].Text = "Sales:";

// set data row
rt.Cells[3, 0].Text = "[Fields!ProductName.Value]";
rt.Cells[3, 1].Text = "[string.Format(\"{0:C}\",Fields!UnitPrice.Value * Fields!UnitsInStock.Value)]";

// create group by category name
TableVectorGroup tvg = rt.RowGroups[0, 4];
tvg.DataBinding.DataSource = dsCategories;
tvg.DataBinding.Grouping.Expressions.Add("Fields!CategoryName.Value");

// add data rows
tvg = rt.RowGroups[3, 1];
tvg.DataBinding.DataSource = dsCategories;

var raLeft = new RenderArea();
raLeft.Children.Add(rt);

RenderArea raContainer = new RenderArea();

// arrange areas side-by-side
raContainer.Stacking = StackingRulesEnum.InlineLeftToRight;

// try to keep single category on a single page
raContainer.SplitVertBehavior = SplitBehaviorEnum.SplitIfLarge;

// set data bindings
raContainer.DataBinding.DataSource = dsCategories;
raContainer.DataBinding.Grouping.Expressions.Add("Fields!CategoryName.Value");

RenderImage ri = new RenderImage(_printDocument);

// show all exceptions and warnings for script debug
_printDocument.ThrowExceptionOnError = true;
_printDocument.AddWarningsWhenErrorInScript = true;

ri.FormatDataBindingInstanceScript = @"! see VB script below !";

RenderArea raRight = new RenderArea();
raRight.Children.Add(ri);
raContainer.Children.Add(raLeft);
raContainer.Children.Add(raRight);
_printDocument.Body.Children.Add(raContainer);

// generate document
_printDocument.Generate();

The Visual Basic script (used in FormatDataBindingInstanceScript in the above code) creates a chart object, assigns a data source to it, and then converts the chart to an image:

Visual Basic Script to Create the Chart

' create chart
Dim chart as C1.Win.Chart.FlexChart = New C1.Win.Chart.FlexChart()

' set chart parameters
chart.BindingX = ""ProductName""  ' assign the name of the property that contains X values for the series
chart.Binding = ""UnitPrice""            ' assign the name of the property for the DataSource property to use in axis labels
chart.BindingContext = New System.Windows.Forms.BindingContext()
chart.AxisX.Style.Font = new System.Drawing.Font(""Tahoma"", 7, System.Drawing.FontStyle.Regular)
chart.ChartType = C1.Chart.ChartType.Column  ' show vertical bars
chart.BackColor = Color.White
chart.AxisX.OverlappingLabels = C1.Chart.OverlappingLabels.Auto  ' hide overlapping labels
chart.AxisX.LabelAngle = 90  ' the rotation angle of the axis labels

Dim series = new C1.Win.Chart.Series()
chart.Series.Add(series)

' set chart size
Dim size as Size = New Size(340, 270)

' assign data source
Dim documentTag = DirectCast(Document.Tags, TagCollection)
Dim dt = DirectCast(documentTag!dataTable.Value, System.Data.DataTable) ' get the "dataTable" tag
Dim dv as System.Data.DataView = New System.Data.DataView(dt)
Dim filter as String = ""CategoryName = "" & RenderObject.Original.Parent.DataBinding.Parent.Fields!CategoryName.Value & ""'""
dv.RowFilter = filter
chart.DataSource = dv

' create the chart image
Dim ms as IO.MemoryStream = New IO.MemoryStream()
chart.SaveImage(ms, C1.Win.Chart.ImageFormat.Png, size.Width, size.Height)

' assign the image to RenderImage object
Dim ri as RenderImage = DirectCast(RenderObject, RenderImage)

ri.Image = Image.FromStream(ms)

Similarly, you can add your custom assemblies to references and use your classes in document scripts.

The structure of the C1PrintDocument is hierarchical and relatively simple. The data is set using bindings and displaying in groups that define the appearance of data.

Each element inherited from RenderObject supports the execution of scripts that extend the functionality. It’s a great tool to create simple reports or print some unbound text with different layout options.

We will continue supporting C1PrintDocument in the .NET 4.5.2 version and in .NET 5, .NET 6, and beyond.

Get the complete sample code.