Out of the box it can render reports to Excel, PDF, HTML, and CSV – fully pluggable of course. I designed the project to provide reporting output over the LINQ queries we had already written for the application, but maybe you can find other uses for it.
For updates and other topics please visit my blog at http://www.matthidinger.com or follow@matthidinger
DoddleReport has been split into multiple packages to support more users’ needs. See their Descriptions within NuGet for more on the differences
The following samples are generated live in real-time (notice the data will change every time you open the report)
Excel Report (OpenXML)
| Excel Report (HTML)
|
| |
PDF Report (iTextSharp)
| PDF Report (ABCpdf)
|
CSV/Delimited
| HTML Report
|
// Get the data for the report (any IEnumerable will work)var query = ProductRepository.GetAll();var totalProducts = query.Count;var totalOrders = query.Sum(p => p.OrderCount);// Create the report and turn our query into a ReportSourcevar report = new Report(query.ToReportSource());// Customize the Text Fieldsreport.TextFields.Title = "Products Report"; report.TextFields.SubTitle = "This is a sample report showing how Doddle Report works"; report.TextFields.Footer = "Copyright 2011 © The Doddle Project"; report.TextFields.Header = string.Format(@" Report Generated: {0} Total Products: {1} Total Orders: {2} Total Sales: {3:c}", DateTime.Now, totalProducts, totalOrders, totalProducts * totalOrders);// Render hints allow you to pass additional hints to the reports as they are being renderedreport.RenderHints.BooleanCheckboxes = true;// Customize the data fieldsreport.DataFields["Id"].Hidden = true; report.DataFields["Price"].DataFormatString = "{0:c}"; report.DataFields["LastPurchase"].DataFormatString = "{0:d}";
A Report relies on 2 distinct (and entirely extensible) mechanisms:
DoddleReport ships with all the Report Sources you should need, but even if it doesn't, you can write your own very easily by implementing a simple interface.
The DoddleReport assembly ships with 3 types of Report Writers. The Extended report writers are included in stand-alone assemblies because they require additional libraries to function. You can write of course your own ReportWriters very easily by implementing a simple interface - and we would love if you could contribute them back to the project if so!
Default Report Writers
Extended Report Writers (provided via stand-alone assemblies)
OpenXML / Excel
this ExcelReportWriter uses OpenXML instead of the default ExcelReportWriter which uses HTML. This writer is also more robust than the default, but requires 2 additional assemblies to function (which will be included automatically if you use the NuGet install mechanism)
A Report relies on 2 distinct (and entirely extensible) mechanisms:
DoddleReport ships with all the Report Sources you should need, but even if it doesn't, you can write your own very easily by implementing a simple interface.
The DoddleReport assembly ships with 3 types of Report Writers. The Extended report writers are included in stand-alone assemblies because they require additional libraries to function. You can write of course your own ReportWriters very easily by implementing a simple interface - and we would love if you could contribute them back to the project if so!
Default Report Writers
Extended Report Writers (provided via stand-alone assemblies)
OpenXML / Excel
The simplest way to add reporting to an ASP.NET application is to add a "Generic Handler (.ashx)" to your project. If you are unfamiliar with .ashx files, they are basic HTTP handlers like .aspx, but they do not have the overhead of building a Page object
and a control heirarchy. They are for serving any kind of content over the web, including HTML, binary data like PDF, images, etc. They are accessed via URL just like a regular .aspx, and can be passed querystrings the same way.
WebReport will handle all serving of the report for you. It will determine what type of report to send based on the?ReportType querystring.
Configuration
Check out the Configuring DoddleReport documentation to map the ReportType parameter to specific Report Writers.
When you create your ashx you can replace all the code inside as follows, you just need to implement a few basic abstract members.
publicclass ProductsReport : WebReport {publicoverridestring FileName {get { return"ProductsReport"; } }publicoverride IReportSource ReportSource {get {// LINQ queryvar query = from p in db.Productsselect p;return query.ToReportSource(); } }publicoverridevoid CustomizeReport(Report report) {// Text Fields report.TextFields.Title = "Products Report"; report.TextFields.Footer = "Copyright 2009 © The Doddle Project"; report.TextFields.Header = string.Format("Report Generated: {0}", DateTime.Now);// Data Fields report.DataFields["ProductID"].Hidden = true; report.DataFields["CategoryID"].Hidden = true; report.DataFields["SupplierID"].Hidden = true; } }
And for my MVC friends I have provided a ReportResult to use as an Action Result that will serve up the report.
The ReportResult will actually read the extension of the request on the controller and return the correct type of report.
Configuration
Check out the Configuring DoddleReport documentation to map the URL extension with a specific Report Writer.
routes.MapReportingRoute();
Next simply create your report like you normally would and return it inside an instance of ReportResult. DoddleReport will handle the rest.
public ReportResult ProductReport() {// Get the data for the report (any IEnumerable will work)var query = ProductRepository.GetAll();var totalProducts = query.Count;var totalOrders = query.Sum(p => p.OrderCount);// Create the report and turn our query into a ReportSourcevar report = new Report(query.ToReportSource());// Customize the Text Fieldsreport.TextFields.Title = "Products Report"; report.TextFields.SubTitle = "This is a sample report showing how Doddle Report works"; report.TextFields.Footer = "Copyright 2011 © The Doddle Project"; report.TextFields.Header = string.Format(@" Report Generated: {0} Total Products: {1} Total Orders: {2} Total Sales: {3:c}", DateTime.Now, totalProducts, totalOrders, totalProducts * totalOrders);// Render hints allow you to pass additional hints to the reports as they are being renderedreport.RenderHints.BooleanCheckboxes = true;// Customize the data fieldsreport.DataFields["Id"].Hidden = true; report.DataFields["Price"].DataFormatString = "{0:c}"; report.DataFields["LastPurchase"].DataFormatString = "{0:d}";// Return the ReportResult // the type of report that is rendered will be determined by the extension in the URL (.pdf, .xls, .html, etc)return new ReportResult(report); }
The simplest way to add reporting to an ASP.NET application is to add a "Generic Handler (.ashx)" to your project. If you are unfamiliar with .ashx files, they are basic HTTP handlers like .aspx, but they do not have the overhead of building a Page object
and a control heirarchy. They are for serving any kind of content over the web, including HTML, binary data like PDF, images, etc. They are accessed via URL just like a regular .aspx, and can be passed querystrings the same way.
WebReport will handle all serving of the report for you. It will determine what type of report to send based on the?ReportType querystring.
Configuration
Check out the Configuring DoddleReport documentation to map the ReportType parameter to specific Report Writers.
When you create your ashx you can replace all the code inside as follows, you just need to implement a few basic abstract members.
publicclass ProductsReport : WebReport {publicoverridestring FileName {get { return"ProductsReport"; } }publicoverride IReportSource ReportSource {get {// LINQ queryvar query = from p in db.Productsselect p;return query.ToReportSource(); } }publicoverridevoid CustomizeReport(Report report) {// Text Fields report.TextFields.Title = "Products Report"; report.TextFields.Footer = "Copyright 2009 © The Doddle Project"; report.TextFields.Header = string.Format("Report Generated: {0}", DateTime.Now);// Data Fields report.DataFields["ProductID"].Hidden = true; report.DataFields["CategoryID"].Hidden = true; report.DataFields["SupplierID"].Hidden = true; } }
And for my MVC friends I have provided a ReportResult to use as an Action Result that will serve up the report.
The ReportResult will actually read the extension of the request on the controller and return the correct type of report.
Configuration
Check out the Configuring DoddleReport documentation to map the URL extension with a specific Report Writer.
routes.MapReportingRoute();
Next simply create your report like you normally would and return it inside an instance of ReportResult. DoddleReport will handle the rest.
public ReportResult ProductReport() {// Get the data for the report (any IEnumerable will work)var query = ProductRepository.GetAll();var totalProducts = query.Count;var totalOrders = query.Sum(p => p.OrderCount);// Create the report and turn our query into a ReportSourcevar report = new Report(query.ToReportSource());// Customize the Text Fieldsreport.TextFields.Title = "Products Report"; report.TextFields.SubTitle = "This is a sample report showing how Doddle Report works"; report.TextFields.Footer = "Copyright 2011 © The Doddle Project"; report.TextFields.Header = string.Format(@" Report Generated: {0} Total Products: {1} Total Orders: {2} Total Sales: {3:c}", DateTime.Now, totalProducts, totalOrders, totalProducts * totalOrders);// Render hints allow you to pass additional hints to the reports as they are being renderedreport.RenderHints.BooleanCheckboxes = true;// Customize the data fieldsreport.DataFields["Id"].Hidden = true; report.DataFields["Price"].DataFormatString = "{0:c}"; report.DataFields["LastPurchase"].DataFormatString = "{0:d}";// Return the ReportResult // the type of report that is rendered will be determined by the extension in the URL (.pdf, .xls, .html, etc)return new ReportResult(report); }
The simplest way to add reporting to an ASP.NET application is to add a "Generic Handler (.ashx)" to your project. If you are unfamiliar with .ashx files, they are basic HTTP handlers like .aspx, but they do not have the overhead of building a Page object
and a control heirarchy. They are for serving any kind of content over the web, including HTML, binary data like PDF, images, etc. They are accessed via URL just like a regular .aspx, and can be passed querystrings the same way.
WebReport will handle all serving of the report for you. It will determine what type of report to send based on the?ReportType querystring.
Configuration
Check out the Configuring DoddleReport documentation to map the ReportType parameter to specific Report Writers.
When you create your ashx you can replace all the code inside as follows, you just need to implement a few basic abstract members.
publicclass ProductsReport : WebReport {publicoverridestring FileName {get { return"ProductsReport"; } }publicoverride IReportSource ReportSource {get {// LINQ queryvar query = from p in db.Productsselect p;return query.ToReportSource(); } }publicoverridevoid CustomizeReport(Report report) {// Text Fields report.TextFields.Title = "Products Report"; report.TextFields.Footer = "Copyright 2009 © The Doddle Project"; report.TextFields.Header = string.Format("Report Generated: {0}", DateTime.Now);// Data Fields report.DataFields["ProductID"].Hidden = true; report.DataFields["CategoryID"].Hidden = true; report.DataFields["SupplierID"].Hidden = true; } }
And for my MVC friends I have provided a ReportResult to use as an Action Result that will serve up the report.
The ReportResult will actually read the extension of the request on the controller and return the correct type of report.
Configuration
Check out the Configuring DoddleReport documentation to map the URL extension with a specific Report Writer.
DoddleReport can automatically determine which IReportWriter to use based on the file extension of the route. To enable this, you must do the following:
// Add using DoddleReport.Web; // put this line at the _top_ of your route configuration routes.MapReportingRoute();
Next simply create your report like you normally would and return it inside an instance of ReportResult. DoddleReport will handle the rest.
public ReportResult ProductReport() {// Get the data for the report (any IEnumerable will work)var query = ProductRepository.GetAll();var totalProducts = query.Count;var totalOrders = query.Sum(p => p.OrderCount);// Create the report and turn our query into a ReportSourcevar report = new Report(query.ToReportSource());// Customize the Text Fieldsreport.TextFields.Title = "Products Report"; report.TextFields.SubTitle = "This is a sample report showing how Doddle Report works"; report.TextFields.Footer = "Copyright 2011 © The Doddle Project"; report.TextFields.Header = string.Format(@" Report Generated: {0} Total Products: {1} Total Orders: {2} Total Sales: {3:c}", DateTime.Now, totalProducts, totalOrders, totalProducts * totalOrders);// Render hints allow you to pass additional hints to the reports as they are being renderedreport.RenderHints.BooleanCheckboxes = true;// Customize the data fieldsreport.DataFields["Id"].Hidden = true; report.DataFields["Price"].DataFormatString = "{0:c}"; report.DataFields["LastPurchase"].DataFormatString = "{0:d}";// Return the ReportResult // the type of report that is rendered will be determined by the extension in the URL (.pdf, .xls, .html, etc)return new ReportResult(report); }
The simplest way to add reporting to an ASP.NET application is to add a "Generic Handler (.ashx)" to your project. If you are unfamiliar with .ashx files, they are basic HTTP handlers like .aspx, but they do not have the overhead of building a Page object
and a control heirarchy. They are for serving any kind of content over the web, including HTML, binary data like PDF, images, etc. They are accessed via URL just like a regular .aspx, and can be passed querystrings the same way.
WebReport will handle all serving of the report for you. It will determine what type of report to send based on the?ReportType querystring.
Configuration
Check out the Configuring DoddleReport documentation to map the ReportType parameter to specific Report Writers.
When you create your ashx you can replace all the code inside as follows, you just need to implement a few basic abstract members.
publicclass ProductsReport : WebReport {publicoverridestring FileName {get { return"ProductsReport"; } }publicoverride IReportSource ReportSource {get {// LINQ queryvar query = from p in db.Productsselect p;return query.ToReportSource(); } }publicoverridevoid CustomizeReport(Report report) {// Text Fields report.TextFields.Title = "Products Report"; report.TextFields.Footer = "Copyright 2009 © The Doddle Project"; report.TextFields.Header = string.Format("Report Generated: {0}", DateTime.Now);// Data Fields report.DataFields["ProductID"].Hidden = true; report.DataFields["CategoryID"].Hidden = true; report.DataFields["SupplierID"].Hidden = true; } }
And for my MVC friends I have provided a ReportResult to use as an Action Result that will serve up the report.
The ReportResult will actually read the extension of the request on the controller and return the correct type of report.
Configuration
Check out the Configuring DoddleReport documentation to map the URL extension with a specific Report Writer.
DoddleReport can automatically determine which IReportWriter to use based on the file extension of the route. To enable this, you must do the following:
// Add using DoddleReport.Web;// put this line at the _top_ of your route configuration routes.MapReportingRoute();
Next simply create your report like you normally would and return it inside an instance of ReportResult. DoddleReport will handle the rest.
public ReportResult ProductReport() {// Get the data for the report (any IEnumerable will work)var query = ProductRepository.GetAll();var totalProducts = query.Count;var totalOrders = query.Sum(p => p.OrderCount);// Create the report and turn our query into a ReportSourcevar report = new Report(query.ToReportSource());// Customize the Text Fieldsreport.TextFields.Title = "Products Report"; report.TextFields.SubTitle = "This is a sample report showing how Doddle Report works"; report.TextFields.Footer = "Copyright 2011 © The Doddle Project"; report.TextFields.Header = string.Format(@" Report Generated: {0} Total Products: {1} Total Orders: {2} Total Sales: {3:c}", DateTime.Now, totalProducts, totalOrders, totalProducts * totalOrders);// Render hints allow you to pass additional hints to the reports as they are being renderedreport.RenderHints.BooleanCheckboxes = true;// Customize the data fieldsreport.DataFields["Id"].Hidden = true; report.DataFields["Price"].DataFormatString = "{0:c}"; report.DataFields["LastPurchase"].DataFormatString = "{0:d}";// Return the ReportResult // the type of report that is rendered will be determined by the extension in the URL (.pdf, .xls, .html, etc)return new ReportResult(report); }
The simplest way to add reporting to an ASP.NET application is to add a "Generic Handler (.ashx)" to your project. If you are unfamiliar with .ashx files, they are basic HTTP handlers like .aspx, but they do not have the overhead of building a Page object
and a control heirarchy. They are for serving any kind of content over the web, including HTML, binary data like PDF, images, etc. They are accessed via URL just like a regular .aspx, and can be passed querystrings the same way.
WebReport will handle all serving of the report for you. It will determine what type of report to send based on the?ReportType querystring.
Configuration
Check out the Configuring DoddleReport documentation to map the ReportType parameter to specific Report Writers.
When you create your ashx you can replace all the code inside as follows, you just need to implement a few basic abstract members.
publicclass ProductsReport : WebReport {publicoverridestring FileName {get { return"ProductsReport"; } }publicoverride IReportSource ReportSource {get {// LINQ queryvar query = from p in db.Productsselect p;return query.ToReportSource(); } }publicoverridevoid CustomizeReport(Report report) {// Text Fields report.TextFields.Title = "Products Report"; report.TextFields.Footer = "Copyright 2009 © The Doddle Project"; report.TextFields.Header = string.Format("Report Generated: {0}", DateTime.Now);// Data Fields report.DataFields["ProductID"].Hidden = true; report.DataFields["CategoryID"].Hidden = true; report.DataFields["SupplierID"].Hidden = true; } }
And for my MVC friends I have provided a ReportResult to use as an Action Result that will serve up the report.
The ReportResult will actually read the extension of the request on the controller and return the correct type of report.
Configuration
Check out the Configuring DoddleReport documentation to map the URL extension with a specific Report Writer.
DoddleReport can automatically determine which IReportWriter to use based on the file extension of the route. To enable this, you must do the following:
// Add using DoddleReport.Web;// put this line at the _top_ of your route configuration routes.MapReportingRoute();
Next simply create your report like you normally would and return it inside an instance of ReportResult. DoddleReport will handle the rest.
public ReportResult ProductReport() {// Get the data for the report (any IEnumerable will work)var query = ProductRepository.GetAll();var totalProducts = query.Count;var totalOrders = query.Sum(p => p.OrderCount);// Create the report and turn our query into a ReportSourcevar report = new Report(query.ToReportSource());// Customize the Text Fieldsreport.TextFields.Title = "Products Report"; report.TextFields.SubTitle = "This is a sample report showing how Doddle Report works"; report.TextFields.Footer = "Copyright 2011 © The Doddle Project"; report.TextFields.Header = string.Format(@" Report Generated: {0} Total Products: {1} Total Orders: {2} Total Sales: {3:c}", DateTime.Now, totalProducts, totalOrders, totalProducts * totalOrders);// Render hints allow you to pass additional hints to the reports as they are being renderedreport.RenderHints.BooleanCheckboxes = true;// Customize the data fieldsreport.DataFields["Id"].Hidden = true; report.DataFields["Price"].DataFormatString = "{0:c}"; report.DataFields["LastPurchase"].DataFormatString = "{0:d}";// Return the ReportResult // the type of report that is rendered will be determined by the extension in the URL (.pdf, .xls, .html, etc)return new ReportResult(report); }
DoddleReport automatically picks up on certain attributes on your model, specifically the Data Annotationsattributes.
If you put a [Display(Name = "Product Name")] on top on your property, DoddleReport will use that customized name when rendering the property on the report.
Additionally, there are 3 ways to further customize your reports.
// Render Hints report.RenderHints.Orientation = ReportOrientation.Landscape; report.RenderHints.BooleanCheckboxes = true;// Text Fields report.TextFields.Title = "Products Report"; report.TextFields.Footer = "Copyright 2009 © The Doddle Project"; report.TextFields.Header = string.Format("Report Generated: {0}", DateTime.Now); report.TextFields["HtmlLogo"] = "<img src='http://www.matthidinger.com/doddlelogo.jpg' />";// Data Fields report.DataFields["ProductID"].Hidden = true; report.DataFields["CategoryID"].Hidden = true; report.DataFields["SupplierID"].Hidden = true; report.DataFields["ProductName"].HeaderText = "Product"; report.DataFields["UnitPrice"].DataFormatString = "{0:C}"; report.DataFields["UnitPrice"].ShowTotals = true; report.DataFields[0].DataStyle.BackColor = Color.Maroon; report.DataFields[0].DataStyle.ForeColor = Color.White;
// Advanced customization with a callback delegate
report.DataFields["OutOfStock"].FormatAs<bool>(value => value ? "Yes" : "No");
Text Fields will be used by the Report Writers to supply key textual fields to a report writer.
The default TextFields are as follows:
All Report Writers should understand how to write those 3 primary fields, but they can also go beyond that. The TextFields property also supports an indexer overload to set custom TextFields that only certain ReportWriters will interpret. This will allow you
to use the same Report for a variety of writers.
In the example above you will notice I used a report.TextFields["HtmlLogo"] = "<img src='http://www.matthidinger.com/doddlelogo.jpg' />"; -- this is a custom TextField named "HtmlLogo" that only the HtmlReportWriter will be looking for.
When the HtmlReportWriter begins render a report that specifies a custom HtmlLogo TextField it will append the image URL to its HTML output, allowing simple and flexible customization of the rendering with minimal work.
Data Fields represent the columns of data written to the report. They are accesses via an indexer and allow customization via the following properties:
Render Hints are used to supply custom data that will be passed to ReportWriters giving them some additional insight in how you want your report to appear.
The default RenderHints are as follows:
The RenderHints property behaves exactly like the TextFields property in that it supports an indexer to pass in custom RenderHints to the report writers.
In the example above you will notice I used a report.RenderHints["HtmlStyle"] = "p { font-size: 14px; }"; -- this is a custom RenderHint that only the HtmlReportWriter will be looking for, and when it writes a report that specifies a custom
HtmlStyle it will append that style declaration to its HTML output, allowing simple and flexible customization of the rendering with minimal work.
For maximum flexibility you can subscribe to the RenderingRow event and add per-row rendering logic to your report.
// Subscribe report.RenderingRow += new EventHandler<ReportRowEventArgs>(report_RenderingRow);// Add logicvoid report_RenderingRow(object sender, ReportRowEventArgs e) {if (e.Row.RowType == ReportRowType.DataRow) {decimal unitPrice = (decimal) e.Row["UnitPrice"];if (unitPrice < 10) { e.Row.Fields["UnitPrice"].DataStyle.Bold = true; } } }
DoddleReport automatically picks up on certain attributes on your model, specifically the Data Annotationsattributes.
If you put a [Display(Name = "Product Name")] on top on your property, DoddleReport will use that customized name when rendering the property on the report.
Additionally, there are 3 ways to further customize your reports.
// Render Hints report.RenderHints.Orientation = ReportOrientation.Landscape; report.RenderHints.BooleanCheckboxes = true;// Text Fields report.TextFields.Title = "Products Report"; report.TextFields.Footer = "Copyright 2009 © The Doddle Project"; report.TextFields.Header = string.Format("Report Generated: {0}", DateTime.Now); report.TextFields["HtmlLogo"] = "<img src='http://www.matthidinger.com/doddlelogo.jpg' />";// Data Fields report.DataFields["ProductID"].Hidden = true; report.DataFields["CategoryID"].Hidden = true; report.DataFields["SupplierID"].Hidden = true; report.DataFields["ProductName"].HeaderText = "Product"; report.DataFields["UnitPrice"].DataFormatString = "{0:C}"; report.DataFields["UnitPrice"].ShowTotals = true; report.DataFields[0].DataStyle.BackColor = Color.Maroon; report.DataFields[0].DataStyle.ForeColor = Color.White;
// Advanced customization with a callback delegate
report.DataFields["OutOfStock"].FormatAs<bool>(value => value ? "Yes" : "No");
Text Fields will be used by the Report Writers to supply key textual fields to a report writer.
The default TextFields are as follows:
All Report Writers should understand how to write those 3 primary fields, but they can also go beyond that. The TextFields property also supports an indexer overload to set custom TextFields that only certain ReportWriters will interpret. This will allow you
to use the same Report for a variety of writers.
In the example above you will notice I used a report.TextFields["HtmlLogo"] = "<img src='http://www.matthidinger.com/doddlelogo.jpg' />"; -- this is a custom TextField named "HtmlLogo" that only the HtmlReportWriter will be looking for.
When the HtmlReportWriter begins render a report that specifies a custom HtmlLogo TextField it will append the image URL to its HTML output, allowing simple and flexible customization of the rendering with minimal work.
Data Fields represent the columns of data written to the report. They are accesses via an indexer and allow customization via the following properties:
Render Hints are used to supply custom data that will be passed to ReportWriters giving them some additional insight in how you want your report to appear.
The default RenderHints are as follows:
The RenderHints property behaves exactly like the TextFields property in that it supports an indexer to pass in custom RenderHints to the report writers.
In the example above you will notice I used a report.RenderHints["HtmlStyle"] = "p { font-size: 14px; }"; -- this is a custom RenderHint that only the HtmlReportWriter will be looking for, and when it writes a report that specifies a custom
HtmlStyle it will append that style declaration to its HTML output, allowing simple and flexible customization of the rendering with minimal work.
For maximum flexibility you can subscribe to the RenderingRow event and add per-row rendering logic to your report.
// Subscribe report.RenderingRow += new EventHandler<ReportRowEventArgs>(report_RenderingRow);// Add logicvoid report_RenderingRow(object sender, ReportRowEventArgs e) {if (e.Row.RowType == ReportRowType.DataRow) {decimal unitPrice = (decimal) e.Row["UnitPrice"];if (unitPrice < 10) { e.Row.Fields["UnitPrice"].DataStyle.Bold = true; } } }
DoddleReport automatically picks up on certain attributes on your model, specifically the Data Annotationsattributes.
If you put a [Display(Name = "Product Name")] on top on your property, DoddleReport will use that customized name when rendering the property on the report.
Additionally, there are 3 ways to further customize your reports.
// Render Hints report.RenderHints.Orientation = ReportOrientation.Landscape; report.RenderHints.BooleanCheckboxes = true;// Text Fields report.TextFields.Title = "Products Report"; report.TextFields.Footer = "Copyright 2009 © The Doddle Project"; report.TextFields.Header = string.Format("Report Generated: {0}", DateTime.Now); report.TextFields["HtmlLogo"] = "<img src='http://www.matthidinger.com/doddlelogo.jpg' />";// Data Fields report.DataFields["ProductID"].Hidden = true; report.DataFields["CategoryID"].Hidden = true; report.DataFields["SupplierID"].Hidden = true; report.DataFields["ProductName"].HeaderText = "Product"; report.DataFields["UnitPrice"].DataFormatString = "{0:C}"; report.DataFields["UnitPrice"].ShowTotals = true; report.DataFields[0].DataStyle.BackColor = Color.Maroon; report.DataFields[0].DataStyle.ForeColor = Color.White;// Advanced customization with a callback delegate report.DataFields["OutOfStock"].FormatAs<bool>(value => value ? "Yes" : "No");
Text Fields will be used by the Report Writers to supply key textual fields to a report writer.
The default TextFields are as follows:
All Report Writers should understand how to write those 3 primary fields, but they can also go beyond that. The TextFields property also supports an indexer overload to set custom TextFields that only certain ReportWriters will interpret. This will allow you
to use the same Report for a variety of writers.
In the example above you will notice I used a report.TextFields["HtmlLogo"] = "<img src='http://www.matthidinger.com/doddlelogo.jpg' />"; -- this is a custom TextField named "HtmlLogo" that only the HtmlReportWriter will be looking for.
When the HtmlReportWriter begins render a report that specifies a custom HtmlLogo TextField it will append the image URL to its HTML output, allowing simple and flexible customization of the rendering with minimal work.
Data Fields represent the columns of data written to the report. They are accesses via an indexer and allow customization via the following properties:
Render Hints are used to supply custom data that will be passed to ReportWriters giving them some additional insight in how you want your report to appear.
The default RenderHints are as follows:
The RenderHints property behaves exactly like the TextFields property in that it supports an indexer to pass in custom RenderHints to the report writers.
In the example above you will notice I used a report.RenderHints["HtmlStyle"] = "p { font-size: 14px; }"; -- this is a custom RenderHint that only the HtmlReportWriter will be looking for, and when it writes a report that specifies a custom
HtmlStyle it will append that style declaration to its HTML output, allowing simple and flexible customization of the rendering with minimal work.
For maximum flexibility you can subscribe to the RenderingRow event and add per-row rendering logic to your report.
// Subscribe report.RenderingRow += new EventHandler<ReportRowEventArgs>(report_RenderingRow);// Add logicvoid report_RenderingRow(object sender, ReportRowEventArgs e) {if (e.Row.RowType == ReportRowType.DataRow) {decimal unitPrice = (decimal) e.Row["UnitPrice"];if (unitPrice < 10) { e.Row.Fields["UnitPrice"].DataStyle.Bold = true; } } }
DoddleReport automatically picks up on certain attributes on your model, specifically the Data Annotationsattributes.
If you put a [Display(Name = "Product Name")] on top on your property, DoddleReport will use that customized name when rendering the property on the report.
Additionally, there are 4 ways to further customize your reports.
// Render Hints report.RenderHints.Orientation = ReportOrientation.Landscape; report.RenderHints.BooleanCheckboxes = true;// Text Fields report.TextFields.Title = "Products Report"; report.TextFields.Footer = "Copyright 2009 © The Doddle Project"; report.TextFields.Header = string.Format("Report Generated: {0}", DateTime.Now); report.TextFields["HtmlLogo"] = "<img src='http://www.matthidinger.com/doddlelogo.jpg' />";// Data Fields report.DataFields["ProductID"].Hidden = true; report.DataFields["CategoryID"].Hidden = true; report.DataFields["SupplierID"].Hidden = true; report.DataFields["ProductName"].HeaderText = "Product"; report.DataFields["UnitPrice"].DataFormatString = "{0:C}"; report.DataFields["UnitPrice"].ShowTotals = true; report.DataFields[0].DataStyle.BackColor = Color.Maroon; report.DataFields[0].DataStyle.ForeColor = Color.White;// Advanced customization with a callback delegate report.DataFields["OutOfStock"].FormatAs<bool>(value => value ? "Yes" : "No");
Text Fields will be used by the Report Writers to supply key textual fields to a report writer.
The default TextFields are as follows:
All Report Writers should understand how to write those 3 primary fields, but they can also go beyond that. The TextFields property also supports an indexer overload to set custom TextFields that only certain ReportWriters will interpret. This will allow you
to use the same Report for a variety of writers.
In the example above you will notice I used a report.TextFields["HtmlLogo"] = "<img src='http://www.matthidinger.com/doddlelogo.jpg' />"; -- this is a custom TextField named "HtmlLogo" that only the HtmlReportWriter will be looking for.
When the HtmlReportWriter begins render a report that specifies a custom HtmlLogo TextField it will append the image URL to its HTML output, allowing simple and flexible customization of the rendering with minimal work.
Data Fields represent the columns of data written to the report. They are accesses via an indexer and allow customization via the following properties:
Render Hints are used to supply custom data that will be passed to ReportWriters giving them some additional insight in how you want your report to appear.
The default RenderHints are as follows:
The RenderHints property behaves exactly like the TextFields property in that it supports an indexer to pass in custom RenderHints to the report writers.
In the example above you will notice I used a report.RenderHints["HtmlStyle"] = "p { font-size: 14px; }"; -- this is a custom RenderHint that only the HtmlReportWriter will be looking for, and when it writes a report that specifies a custom
HtmlStyle it will append that style declaration to its HTML output, allowing simple and flexible customization of the rendering with minimal work.
For maximum flexibility you can subscribe to the RenderingRow event and add per-row rendering logic to your report.
// Subscribe report.RenderingRow += new EventHandler<ReportRowEventArgs>(report_RenderingRow);// Add logicvoid report_RenderingRow(object sender, ReportRowEventArgs e) {if (e.Row.RowType == ReportRowType.DataRow) {decimal unitPrice = (decimal) e.Row["UnitPrice"];if (unitPrice < 10) { e.Row.Fields["UnitPrice"].DataStyle.Bold = true; } } }
DoddleReport automatically picks up on certain attributes on your model, specifically the Data Annotationsattributes.
If you put a [Display(Name = "Product Name")] on top on your property, DoddleReport will use that customized name when rendering the property on the report.
Additionally, there are 4 ways to further customize your reports.
// Render Hints report.RenderHints.Orientation = ReportOrientation.Landscape; report.RenderHints.BooleanCheckboxes = true;// Text Fields report.TextFields.Title = "Products Report"; report.TextFields.Footer = "Copyright 2009 © The Doddle Project"; report.TextFields.Header = string.Format("Report Generated: {0}", DateTime.Now); report.TextFields["HtmlLogo"] = "<img src='http://www.matthidinger.com/doddlelogo.jpg' />";// Data Fields report.DataFields["ProductID"].Hidden = true; report.DataFields["CategoryID"].Hidden = true; report.DataFields["SupplierID"].Hidden = true; report.DataFields["ProductName"].HeaderText = "Product"; report.DataFields["UnitPrice"].DataFormatString = "{0:C}"; report.DataFields["UnitPrice"].ShowTotals = true; report.DataFields[0].DataStyle.BackColor = Color.Maroon; report.DataFields[0].DataStyle.ForeColor = Color.White;// Advanced customization with a callback delegate report.DataFields["OutOfStock"].FormatAs<bool>(value => value ? "Yes" : "No");
Text Fields will be used by the Report Writers to supply key textual fields to a report writer.
The default TextFields are as follows:
All Report Writers should understand how to write those 3 primary fields, but they can also go beyond that. The TextFields property also supports an indexer overload to set custom TextFields that only certain ReportWriters will interpret. This will allow you
to use the same Report for a variety of writers.
In the example above you will notice I used a report.TextFields["HtmlLogo"] = "<img src='http://www.matthidinger.com/doddlelogo.jpg' />"; -- this is a custom TextField named "HtmlLogo" that only the HtmlReportWriter will be looking for.
When the HtmlReportWriter begins render a report that specifies a custom HtmlLogo TextField it will append the image URL to its HTML output, allowing simple and flexible customization of the rendering with minimal work.
Data Fields represent the columns of data written to the report. They are accesses via an indexer and allow customization via the following properties:
Render Hints are used to supply custom data that will be passed to ReportWriters giving them some additional insight in how you want your report to appear.
The default RenderHints are as follows:
The RenderHints property behaves exactly like the TextFields property in that it supports an indexer to pass in custom RenderHints to the report writers.
In the example above you will notice I used a report.RenderHints["HtmlStyle"] = "p { font-size: 14px; }"; -- this is a custom RenderHint that only the HtmlReportWriter will be looking for, and when it writes a report that specifies a custom
HtmlStyle it will append that style declaration to its HTML output, allowing simple and flexible customization of the rendering with minimal work.
For maximum flexibility you can subscribe to the RenderingRow event and add per-row rendering logic to your report.
// Subscribe report.RenderingRow += new EventHandler<ReportRowEventArgs>(report_RenderingRow);// Add logicvoid report_RenderingRow(object sender, ReportRowEventArgs e) {if (e.Row.RowType == ReportRowType.DataRow) {decimal unitPrice = (decimal) e.Row["UnitPrice"];if (unitPrice < 10) { e.Row.Fields["UnitPrice"].DataStyle.Bold = true; } } }
Out of the box it can render reports to Excel, PDF, HTML, and CSV – fully pluggable of course. I designed the project to provide reporting output over the LINQ queries we had already written for the application, but maybe you can find other uses for it.
For updates and other topics please visit my blog at http://www.matthidinger.com or follow@matthidinger
DoddleReport has been split into multiple packages to support more users’ needs. See their Descriptions within NuGet for more on the differences
The following samples are generated live in real-time (notice the data will change every time you open the report)
Excel Report (OpenXML)
| Excel Report (HTML)
|
| |
PDF Report (iTextSharp)
| PDF Report (ABCpdf)
|
CSV/Delimited
| HTML Report
|
// Get the data for the report (any IEnumerable will work)var query = ProductRepository.GetAll();var totalProducts = query.Count;var totalOrders = query.Sum(p => p.OrderCount);// Create the report and turn our query into a ReportSourcevar report = new Report(query.ToReportSource());// Customize the Text Fieldsreport.TextFields.Title = "Products Report"; report.TextFields.SubTitle = "This is a sample report showing how Doddle Report works"; report.TextFields.Footer = "Copyright 2011 © The Doddle Project"; report.TextFields.Header = string.Format(@" Report Generated: {0} Total Products: {1} Total Orders: {2} Total Sales: {3:c}", DateTime.Now, totalProducts, totalOrders, totalProducts * totalOrders);// Render hints allow you to pass additional hints to the reports as they are being renderedreport.RenderHints.BooleanCheckboxes = true;// Customize the data fieldsreport.DataFields["Id"].Hidden = true; report.DataFields["Price"].DataFormatString = "{0:c}"; report.DataFields["LastPurchase"].DataFormatString = "{0:d}";