{"id":667,"date":"2011-12-01T04:03:32","date_gmt":"2011-12-01T04:03:32","guid":{"rendered":"http:\/\/www.ericwhite.com\/home2\/bm8qcmjy\/public_html\/blog\/?page_id=667"},"modified":"2019-09-29T16:21:55","modified_gmt":"2019-09-29T16:21:55","slug":"functional-programming-expanded","status":"publish","type":"page","link":"https:\/\/www.ericwhite.com\/blog\/functional-programming-expanded\/","title":{"rendered":"Functional Programming"},"content":{"rendered":"<h2 style=\"font-size: small;\"><a href=\"https:\/\/www.ericwhite.com\/blog\/toc-expanded\">Back to TOC<\/a><a style=\"position: relative; left: 1em;\" href=\"https:\/\/www.ericwhite.com\/blog\/functional-programming-video-expanded\">Just Videos<\/a><span style=\"position: relative; left: 2em;\"><a href=\"https:\/\/www.ericwhite.com\/blog\/functional-programming-condensed\">Condensed TOC<\/a><\/span><\/h2>\n<p>Language Integrated Query, when used properly, enables you to build powerful applications in the functional programming style. Pure functional transformations are my recommended approach to document manipulation.<\/p>\n<ul>\n<li class=\"ericListItem\"><a class=\"ericListItem broken_link\" href=\"http:\/\/blogs.msdn.com\/b\/ericwhite\/archive\/2006\/10\/04\/fp-tutorial.aspx\" target=\"_blank\" rel=\"noopener\">Query Composition using Functional Programming Techniques in C# 3.0<\/a><\/li>\n<\/ul>\n<div style=\"margin-left: 2em; margin-bottom: 1em;\">Functional Programming (FP) has the potential to reduce program line count by 20% to 50%, reduce bugs and increase robustness, and move us in the direction of taking advantage of multiple core CPUs. But perhaps due to the learning curve, and unfamiliarity, many developers are not taking advantage of the potential that LINQ and FP offers.<span style=\"color: #2b91af;\"> (Article)<\/span><\/p>\n<div style=\"vertical-align: text-top; margin-top: .5em;\"><span style=\"color: #2b91af;\">Keywords:\u00a0\u00a0<\/span><a href=\"https:\/\/www.ericwhite.com\/blog\/functional-programming-expanded\">Functional Programming<\/a><\/div>\n<\/div>\n<ul>\n<li class=\"ericListItem\"><a class=\"ericListItem broken_link\" href=\"http:\/\/blogs.msdn.com\/b\/ericwhite\/archive\/2007\/12\/06\/performance-of-chained-queries.aspx\" target=\"_blank\" rel=\"noopener\">Performance of Chained Queries<\/a><\/li>\n<\/ul>\n<div style=\"margin-left: 2em; margin-bottom: 1em;\">One of the most important aspects of LINQ (and LINQ to XML) is that performance of chained queries can be effectively the same as if you write one larger, more complicated query.<span style=\"color: #2b91af;\"> (Article)<\/span><\/p>\n<div style=\"vertical-align: text-top; margin-top: .5em;\"><span style=\"color: #2b91af;\">Keywords:\u00a0\u00a0<\/span><a href=\"https:\/\/www.ericwhite.com\/blog\/functional-programming-expanded\">Functional Programming<\/a>\u00a0\u00a0<a href=\"https:\/\/www.ericwhite.com\/blog\/linq-to-xml-expanded\">LINQ to XML<\/a><\/div>\n<\/div>\n<ul>\n<li class=\"ericListItem\"><a class=\"ericListItem broken_link\" href=\"http:\/\/blogs.msdn.com\/b\/ericwhite\/archive\/2007\/12\/06\/atomized-xname-and-xnamespace-objects.aspx\" target=\"_blank\" rel=\"noopener\">Atomized XName and XNamespace Objects<\/a><\/li>\n<\/ul>\n<div style=\"margin-left: 2em; margin-bottom: 1em;\">XName and XNamespace objects are atomized. This yields performance benefits for queries: comparing two atomized names for equality means that the underlying intermediate language (IL) only needs to determine if the two references point to the same object. The underlying system does not need to do any string comparisons, which would be time consuming.<span style=\"color: #2b91af;\"> (Article)<\/span><\/p>\n<div style=\"vertical-align: text-top; margin-top: .5em;\"><span style=\"color: #2b91af;\">Keywords:\u00a0\u00a0<\/span><a href=\"https:\/\/www.ericwhite.com\/blog\/functional-programming-expanded\">Functional Programming<\/a>\u00a0\u00a0<a href=\"https:\/\/www.ericwhite.com\/blog\/linq-to-xml-expanded\">LINQ to XML<\/a><\/div>\n<\/div>\n<ul>\n<li class=\"ericListItem\"><a class=\"ericListItem broken_link\" href=\"http:\/\/blogs.msdn.com\/b\/ericwhite\/archive\/2007\/12\/06\/preatomization-of-xname-objects.aspx\" target=\"_blank\" rel=\"noopener\">Preatomization of XName Objects<\/a><\/li>\n<\/ul>\n<div style=\"margin-left: 2em; margin-bottom: 1em;\">One approach that you can take to gain some performance is to pre-atomize XName objects. This would yield performance benefits when creating a large XML tree where specific names are repeated. The approach is to declare and initialize XName objects before the construction of the XML tree, and then to use the XName objects rather than specifying strings for the element and attribute names.<span style=\"color: #2b91af;\"> (Article)<\/span><\/p>\n<div style=\"vertical-align: text-top; margin-top: .5em;\"><span style=\"color: #2b91af;\">Keywords:\u00a0\u00a0<\/span><a href=\"https:\/\/www.ericwhite.com\/blog\/functional-programming-expanded\">Functional Programming<\/a>\u00a0\u00a0<a href=\"https:\/\/www.ericwhite.com\/blog\/linq-to-xml-expanded\">LINQ to XML<\/a><\/div>\n<\/div>\n<ul>\n<li class=\"ericListItem\"><a class=\"ericListItem broken_link\" href=\"http:\/\/blogs.msdn.com\/b\/ericwhite\/archive\/2007\/12\/06\/statically-compiled-queries.aspx\" target=\"_blank\" rel=\"noopener\">Statically Compiled Queries<\/a><\/li>\n<\/ul>\n<div style=\"margin-left: 2em; margin-bottom: 1em;\">One of the most important performance benefits that you will note when comparing LINQ to XML and XmlDocument is that queries in LINQ to XML are statically compiled, whereas XPath queries must be interpreted at runtime.<span style=\"color: #2b91af;\"> (Article)<\/span><\/p>\n<div style=\"vertical-align: text-top; margin-top: .5em;\"><span style=\"color: #2b91af;\">Keywords:\u00a0\u00a0<\/span><a href=\"https:\/\/www.ericwhite.com\/blog\/functional-programming-expanded\">Functional Programming<\/a>\u00a0\u00a0<a href=\"https:\/\/www.ericwhite.com\/blog\/linq-to-xml-expanded\">LINQ to XML<\/a><\/div>\n<\/div>\n<ul>\n<li class=\"ericListItem\"><a class=\"ericListItem broken_link\" href=\"http:\/\/blogs.msdn.com\/b\/ericwhite\/archive\/2007\/12\/06\/performance-of-linq-to-xml.aspx\" target=\"_blank\" rel=\"noopener\">Performance of LINQ to XML<\/a><\/li>\n<\/ul>\n<div style=\"margin-left: 2em; margin-bottom: 1em;\">There are a number of issues and dynamics that we can talk about with regards to performance of LINQ to XML. <span style=\"color: #2b91af;\"> (Article)<\/span><\/p>\n<div style=\"vertical-align: text-top; margin-top: .5em;\"><span style=\"color: #2b91af;\">Keywords:\u00a0\u00a0<\/span><a href=\"https:\/\/www.ericwhite.com\/blog\/functional-programming-expanded\">Functional Programming<\/a>\u00a0\u00a0<a href=\"https:\/\/www.ericwhite.com\/blog\/linq-to-xml-expanded\">LINQ to XML<\/a><\/div>\n<\/div>\n<ul>\n<li class=\"ericListItem\"><a class=\"ericListItem broken_link\" href=\"http:\/\/blogs.msdn.com\/b\/ericwhite\/archive\/2008\/04\/21\/the-groupadjacent-extension-method.aspx\" target=\"_blank\" rel=\"noopener\">The GroupAdjacent Extension Method<\/a><\/li>\n<\/ul>\n<div style=\"margin-left: 2em; margin-bottom: 1em;\">This post introduces a GroupAdjacent generic extension method that groups elements in a collection with adjacent elements based on a common key.<span style=\"color: #2b91af;\"> (Article)<\/span><\/p>\n<div style=\"vertical-align: text-top; margin-top: .5em;\"><span style=\"color: #2b91af;\">Keywords:\u00a0\u00a0<\/span><a href=\"https:\/\/www.ericwhite.com\/blog\/functional-programming-expanded\">Functional Programming<\/a>\u00a0\u00a0<a href=\"https:\/\/www.ericwhite.com\/blog\/linq-expanded\">LINQ<\/a><\/div>\n<\/div>\n<ul>\n<li class=\"ericListItem\"><a class=\"ericListItem broken_link\" href=\"http:\/\/blogs.msdn.com\/b\/ericwhite\/archive\/2008\/07\/10\/how-to-create-hierarchy-from-flat-data-using-linq.aspx\" target=\"_blank\" rel=\"noopener\">How to Create Hierarchy from Flat Data using LINQ<\/a><\/li>\n<\/ul>\n<div style=\"margin-left: 2em; margin-bottom: 1em;\">Sometimes you have flat data where there is hierarchy expressed in the data, but the form of the data is flat. You may need to transform this data into a hierarchy, such as an XML tree.<span style=\"color: #2b91af;\"> (Article)<\/span><\/p>\n<div style=\"vertical-align: text-top; margin-top: .5em;\"><span style=\"color: #2b91af;\">Keywords:\u00a0\u00a0<\/span><a href=\"https:\/\/www.ericwhite.com\/blog\/functional-programming-expanded\">Functional Programming<\/a>\u00a0\u00a0<a href=\"https:\/\/www.ericwhite.com\/blog\/linq-expanded\">LINQ<\/a><\/div>\n<\/div>\n<ul>\n<li class=\"ericListItem\"><a class=\"ericListItem broken_link\" href=\"http:\/\/blogs.msdn.com\/b\/ericwhite\/archive\/2008\/07\/14\/writing-robust-linq-to-xml-code-that-performs-well.aspx\" target=\"_blank\" rel=\"noopener\">Writing Robust LINQ to XML Code that Performs Well<\/a><\/li>\n<\/ul>\n<div style=\"margin-left: 2em; margin-bottom: 1em;\">Lists some important posts about LINQ to XML that explains approaches that you can take to write LINQ to XML code that has fewer bugs.<span style=\"color: #2b91af;\"> (Article)<\/span><\/p>\n<div style=\"vertical-align: text-top; margin-top: .5em;\"><span style=\"color: #2b91af;\">Keywords:\u00a0\u00a0<\/span><a href=\"https:\/\/www.ericwhite.com\/blog\/functional-programming-expanded\">Functional Programming<\/a>\u00a0\u00a0<a href=\"https:\/\/www.ericwhite.com\/blog\/linq-to-xml-expanded\">LINQ to XML<\/a><\/div>\n<\/div>\n<ul>\n<li class=\"ericListItem\"><a class=\"ericListItem broken_link\" href=\"http:\/\/blogs.msdn.com\/b\/ericwhite\/archive\/2008\/07\/24\/are-developers-using-linq.aspx\" target=\"_blank\" rel=\"noopener\">Are Developers Using LINQ?<\/a><\/li>\n<\/ul>\n<div style=\"margin-left: 2em; margin-bottom: 1em;\">I had an interesting conversation with my nephew the other day. He is a very bright CS student working as a summer intern at a software company (not Microsoft). He is programming in C# using Visual Studio 2008. I asked him if developers at his company were using LINQ, and he said, &#8220;No, that the folks in charge had basically forbidden it, because no one understands it.&#8221; <span style=\"color: #2b91af;\"> (Article)<\/span><\/p>\n<div style=\"vertical-align: text-top; margin-top: .5em;\"><span style=\"color: #2b91af;\">Keywords:\u00a0\u00a0<\/span><a href=\"https:\/\/www.ericwhite.com\/blog\/functional-programming-expanded\">Functional Programming<\/a>\u00a0\u00a0<a href=\"https:\/\/www.ericwhite.com\/blog\/linq-expanded\">LINQ<\/a><\/div>\n<\/div>\n<ul>\n<li class=\"ericListItem\"><a class=\"ericListItem broken_link\" href=\"http:\/\/blogs.msdn.com\/b\/ericwhite\/archive\/2008\/07\/26\/are-developers-using-linq-part-2.aspx\" target=\"_blank\" rel=\"noopener\">Are Developers Using LINQ? (Part 2)<\/a><\/li>\n<\/ul>\n<div style=\"margin-left: 2em; margin-bottom: 1em;\">There are four basic scenarios where developers use LINQ.<span style=\"color: #2b91af;\"> (Article)<\/span><\/p>\n<div style=\"vertical-align: text-top; margin-top: .5em;\"><span style=\"color: #2b91af;\">Keywords:\u00a0\u00a0<\/span><a href=\"https:\/\/www.ericwhite.com\/blog\/functional-programming-expanded\">Functional Programming<\/a>\u00a0\u00a0<a href=\"https:\/\/www.ericwhite.com\/blog\/linq-expanded\">LINQ<\/a><\/div>\n<\/div>\n<ul>\n<li class=\"ericListItem\"><a class=\"ericListItem broken_link\" href=\"http:\/\/blogs.msdn.com\/b\/ericwhite\/archive\/2008\/08\/03\/linq-reduces-line-counts-and-makes-code-pop.aspx\" target=\"_blank\" rel=\"noopener\">Generating a LINQ to XML Tree from Anonymous Types<\/a><\/li>\n<\/ul>\n<div style=\"margin-left: 2em; margin-bottom: 1em;\">Shows how to write code to generate an XML tree from a hierarchy of anonymous types. In addition, it compares and contrasts writing code in the imperative style to writing code in the declarative style.<span style=\"color: #2b91af;\"> (Article)<\/span><\/p>\n<div style=\"vertical-align: text-top; margin-top: .5em;\"><span style=\"color: #2b91af;\">Keywords:\u00a0\u00a0<\/span><a href=\"https:\/\/www.ericwhite.com\/blog\/functional-programming-expanded\">Functional Programming<\/a>\u00a0\u00a0<a href=\"https:\/\/www.ericwhite.com\/blog\/linq-to-xml-expanded\">LINQ to XML<\/a><\/div>\n<\/div>\n<ul>\n<li class=\"ericListItem\"><a class=\"ericListItem broken_link\" href=\"http:\/\/blogs.msdn.com\/b\/ericwhite\/archive\/2008\/08\/19\/chunking-a-collection-into-groups-of-three.aspx\" target=\"_blank\" rel=\"noopener\">Chunking a Collection into Groups of Three<\/a><\/li>\n<\/ul>\n<div style=\"margin-left: 2em; margin-bottom: 1em;\">Sometimes you need to group a collection into a set of groups, each with n members.<span style=\"color: #2b91af;\"> (Article)<\/span><\/p>\n<div style=\"vertical-align: text-top; margin-top: .5em;\"><span style=\"color: #2b91af;\">Keywords:\u00a0\u00a0<\/span><a href=\"https:\/\/www.ericwhite.com\/blog\/functional-programming-expanded\">Functional Programming<\/a>\u00a0\u00a0<a href=\"https:\/\/www.ericwhite.com\/blog\/linq-expanded\">LINQ<\/a><\/div>\n<\/div>\n<ul>\n<li class=\"ericListItem\"><a class=\"ericListItem broken_link\" href=\"http:\/\/blogs.msdn.com\/b\/ericwhite\/archive\/2008\/08\/19\/use-a-lambda-expression-for-an-event-handler.aspx\" target=\"_blank\" rel=\"noopener\">Use a Lambda Expression for an Event Handler<\/a><\/li>\n<\/ul>\n<div style=\"margin-left: 2em; margin-bottom: 1em;\">You can use lambda expressions to write an event handler, even for classes that predate C# 3.0 and the latest version of the framework. This can shorten your code, and make it easier to read. <span style=\"color: #2b91af;\"> (Article)<\/span><\/p>\n<div style=\"vertical-align: text-top; margin-top: .5em;\"><span style=\"color: #2b91af;\">Keywords:\u00a0\u00a0<\/span><a href=\"https:\/\/www.ericwhite.com\/blog\/functional-programming-expanded\">Functional Programming<\/a>\u00a0\u00a0<a href=\"https:\/\/www.ericwhite.com\/blog\/linq-expanded\">LINQ<\/a><\/div>\n<\/div>\n<ul>\n<li class=\"ericListItem\"><a class=\"ericListItem broken_link\" href=\"http:\/\/blogs.msdn.com\/b\/ericwhite\/archive\/2008\/08\/19\/find-duplicates-using-linq.aspx\" target=\"_blank\" rel=\"noopener\">Find Duplicates using LINQ<\/a><\/li>\n<\/ul>\n<div style=\"margin-left: 2em; margin-bottom: 1em;\">Sometimes you need to find the duplicates in a list.<span style=\"color: #2b91af;\"> (Article)<\/span><\/p>\n<div style=\"vertical-align: text-top; margin-top: .5em;\"><span style=\"color: #2b91af;\">Keywords:\u00a0\u00a0<\/span><a href=\"https:\/\/www.ericwhite.com\/blog\/functional-programming-expanded\">Functional Programming<\/a>\u00a0\u00a0<a href=\"https:\/\/www.ericwhite.com\/blog\/linq-expanded\">LINQ<\/a><\/div>\n<\/div>\n<ul>\n<li class=\"ericListItem\"><a class=\"ericListItem broken_link\" href=\"http:\/\/blogs.msdn.com\/b\/ericwhite\/archive\/2008\/09\/12\/closures.aspx\" target=\"_blank\" rel=\"noopener\">Closures<\/a><\/li>\n<\/ul>\n<div style=\"margin-left: 2em; margin-bottom: 1em;\">Closures are one of the key components in C# 3.0 that makes functional programming easy, and results in clean syntax.<span style=\"color: #2b91af;\"> (Article)<\/span><\/p>\n<div style=\"vertical-align: text-top; margin-top: .5em;\"><span style=\"color: #2b91af;\">Keywords:\u00a0\u00a0<\/span><a href=\"https:\/\/www.ericwhite.com\/blog\/functional-programming-expanded\">Functional Programming<\/a>\u00a0\u00a0<a href=\"https:\/\/www.ericwhite.com\/blog\/linq-expanded\">LINQ<\/a><\/div>\n<\/div>\n<ul>\n<li class=\"ericListItem\"><a class=\"ericListItem broken_link\" href=\"http:\/\/blogs.msdn.com\/b\/ericwhite\/archive\/2008\/09\/30\/linq-to-text-and-linq-to-csv.aspx\" target=\"_blank\" rel=\"noopener\">LINQ to TEXT and LINQ to CSV<\/a><\/li>\n<\/ul>\n<div style=\"margin-left: 2em; margin-bottom: 1em;\">LINQ is a great tool for writing ad-hoc queries and transforms, and occasionally I need to write queries or transforms on text files.<span style=\"color: #2b91af;\"> (Article)<\/span><\/p>\n<div style=\"vertical-align: text-top; margin-top: .5em;\"><span style=\"color: #2b91af;\">Keywords:\u00a0\u00a0<\/span><a href=\"https:\/\/www.ericwhite.com\/blog\/functional-programming-expanded\">Functional Programming<\/a>\u00a0\u00a0<a href=\"https:\/\/www.ericwhite.com\/blog\/linq-expanded\">LINQ<\/a><\/div>\n<\/div>\n<ul>\n<li class=\"ericListItem\"><a class=\"ericListItem broken_link\" href=\"http:\/\/blogs.msdn.com\/b\/ericwhite\/archive\/2008\/10\/06\/formatting-linq-code.aspx\" target=\"_blank\" rel=\"noopener\">Formatting LINQ Code<\/a><\/li>\n<\/ul>\n<div style=\"margin-left: 2em; margin-bottom: 1em;\">Over time, I&#8217;ve adjusted my code formatting style &#8211; changing the white space that I insert, or where I place the parentheses. In this post, I detail some aspects of my current code formatting approach, focusing only on formatting LINQ queries that are written in the &#8216;method syntax&#8217;, not using LINQ query expressions (from &#8212; select &#8212;).<span style=\"color: #2b91af;\"> (Article)<\/span><\/p>\n<div style=\"vertical-align: text-top; margin-top: .5em;\"><span style=\"color: #2b91af;\">Keywords:\u00a0\u00a0<\/span><a href=\"https:\/\/www.ericwhite.com\/blog\/functional-programming-expanded\">Functional Programming<\/a>\u00a0\u00a0<a href=\"https:\/\/www.ericwhite.com\/blog\/linq-expanded\">LINQ<\/a><\/div>\n<\/div>\n<ul>\n<li class=\"ericListItem\"><a class=\"ericListItem broken_link\" href=\"http:\/\/blogs.msdn.com\/b\/ericwhite\/archive\/2008\/10\/12\/using-linq-to-xml-events-and-annotations-to-track-if-an-xml-tree-has-changed.aspx\" target=\"_blank\" rel=\"noopener\">Using LINQ to XML Events and Annotations to Track if an XML Tree has Changed<\/a><\/li>\n<\/ul>\n<div style=\"margin-left: 2em; margin-bottom: 1em;\">You may optionally be making a number of modifications to a very large XDocument object. Because of a complicated algorithm, you may not necessarily know ahead of time whether you will be making changes. If you don&#8217;t make any changes, then you don&#8217;t want to unnecessarily serialize the tree and save it to disk, or send it over the wire. This post presents a simple technique to determine if an XDocument has ever been modified since deserialization or creation.<span style=\"color: #2b91af;\"> (Article)<\/span><\/p>\n<div style=\"vertical-align: text-top; margin-top: .5em;\"><span style=\"color: #2b91af;\">Keywords:\u00a0\u00a0<\/span><a href=\"https:\/\/www.ericwhite.com\/blog\/functional-programming-expanded\">Functional Programming<\/a>\u00a0\u00a0<a href=\"https:\/\/www.ericwhite.com\/blog\/linq-to-xml-expanded\">LINQ to XML<\/a><\/div>\n<\/div>\n<ul>\n<li class=\"ericListItem\"><a class=\"ericListItem broken_link\" href=\"http:\/\/blogs.msdn.com\/b\/ericwhite\/archive\/2008\/10\/24\/comparing-linq-to-xml-and-xpath.aspx\" target=\"_blank\" rel=\"noopener\">Comparing LINQ to XML and XPath<\/a><\/li>\n<\/ul>\n<div style=\"margin-left: 2em; margin-bottom: 1em;\">Provides an overview of the similarities and differences between XPath and LINQ to XML<span style=\"color: #2b91af;\"> (Article)<\/span><\/p>\n<div style=\"vertical-align: text-top; margin-top: .5em;\"><span style=\"color: #2b91af;\">Keywords:\u00a0\u00a0<\/span><a href=\"https:\/\/www.ericwhite.com\/blog\/functional-programming-expanded\">Functional Programming<\/a>\u00a0\u00a0<a href=\"https:\/\/www.ericwhite.com\/blog\/linq-to-xml-expanded\">LINQ to XML<\/a>\u00a0\u00a0<a href=\"https:\/\/www.ericwhite.com\/blog\/xml-expanded\">XML<\/a><\/div>\n<\/div>\n<ul>\n<li class=\"ericListItem\"><a class=\"ericListItem broken_link\" href=\"http:\/\/blogs.msdn.com\/b\/ericwhite\/archive\/2008\/10\/29\/anders-hejlsberg-introduces-c-4-0-at-pdc-2008.aspx\" target=\"_blank\" rel=\"noopener\">Anders Hejlsberg Introduces C# 4.0 at PDC 2008<\/a><\/li>\n<\/ul>\n<div style=\"margin-left: 2em; margin-bottom: 1em;\">Anders Hejlsberg presented a fascinating and entertaining session at PDC 2008 on C# 4.0. He talked about dynamic typing, optional and named parameters, improved COM interoperability, and improved support for co-variance and contra-variance. These language improvements are very cool &#8211; they enable us to write code that more closely expresses our intent, with less syntactic noise.<span style=\"color: #2b91af;\"> (Article)<\/span><\/p>\n<div style=\"vertical-align: text-top; margin-top: .5em;\"><span style=\"color: #2b91af;\">Keywords:\u00a0\u00a0<\/span><a href=\"https:\/\/www.ericwhite.com\/blog\/functional-programming-expanded\">Functional Programming<\/a>\u00a0\u00a0<a href=\"https:\/\/www.ericwhite.com\/blog\/linq-expanded\">LINQ<\/a><\/div>\n<\/div>\n<ul>\n<li class=\"ericListItem\"><a class=\"ericListItem broken_link\" href=\"http:\/\/blogs.msdn.com\/b\/ericwhite\/archive\/2008\/11\/07\/debugging-linq-queries.aspx\" target=\"_blank\" rel=\"noopener\">Debugging LINQ Queries<\/a><\/li>\n<\/ul>\n<div style=\"margin-left: 2em; margin-bottom: 1em;\">Debugging LINQ queries can be problematic. One of the reasons is that quite often, you write a large query as a single expression, and you can&#8217;t set a breakpoint mid-expression. Writing large queries in expression context is particularly powerful when using functional construction to form XML (or using the strongly typed DOM in Open XML SDK V2). This post presents a little trick that makes it easier to use the debugger with LINQ queries that are written using &#8216;method syntax&#8217;.<span style=\"color: #2b91af;\"> (Article)<\/span><\/p>\n<div style=\"vertical-align: text-top; margin-top: .5em;\"><span style=\"color: #2b91af;\">Keywords:\u00a0\u00a0<\/span><a href=\"https:\/\/www.ericwhite.com\/blog\/functional-programming-expanded\">Functional Programming<\/a>\u00a0\u00a0<a href=\"https:\/\/www.ericwhite.com\/blog\/linq-expanded\">LINQ<\/a><\/div>\n<\/div>\n<ul>\n<li class=\"ericListItem\"><a class=\"ericListItem broken_link\" href=\"http:\/\/blogs.msdn.com\/b\/ericwhite\/archive\/2008\/11\/14\/the-skiplast-extension-method.aspx\" target=\"_blank\" rel=\"noopener\">The SkipLast Extension Method<\/a><\/li>\n<\/ul>\n<div style=\"margin-left: 2em; margin-bottom: 1em;\">When writing queries, just as you sometimes want to skip the first n items in a collection, on occasion you want to skip the last n items. You could certain count the items remaining in the collection, and use the Take operator to take all but the last, but this would mean iterating the collection twice, and would result in uglier code.<span style=\"color: #2b91af;\"> (Article)<\/span><\/p>\n<div style=\"vertical-align: text-top; margin-top: .5em;\"><span style=\"color: #2b91af;\">Keywords:\u00a0\u00a0<\/span><a href=\"https:\/\/www.ericwhite.com\/blog\/functional-programming-expanded\">Functional Programming<\/a>\u00a0\u00a0<a href=\"https:\/\/www.ericwhite.com\/blog\/linq-expanded\">LINQ<\/a><\/div>\n<\/div>\n<ul>\n<li class=\"ericListItem\"><a class=\"ericListItem broken_link\" href=\"http:\/\/blogs.msdn.com\/b\/ericwhite\/archive\/2008\/11\/24\/fp-tutorial-vb.aspx\" target=\"_blank\" rel=\"noopener\">Query Composition using Functional Programming Techniques in VB 9.0<\/a><\/li>\n<\/ul>\n<div style=\"margin-left: 2em; margin-bottom: 1em;\">Functional Programming (FP) has the potential to reduce program line count by 20% to 50%, reduce bugs and increase robustness, and move us in the direction of taking advantage of multiple core CPUs. But perhaps due to the learning curve, and unfamiliarity, many developers are not taking advantage of the potential that LINQ and FP offers.<span style=\"color: #2b91af;\"> (Article)<\/span><\/p>\n<div style=\"vertical-align: text-top; margin-top: .5em;\"><span style=\"color: #2b91af;\">Keywords:\u00a0\u00a0<\/span><a href=\"https:\/\/www.ericwhite.com\/blog\/functional-programming-expanded\">Functional Programming<\/a><\/div>\n<\/div>\n<ul>\n<li class=\"ericListItem\"><a class=\"ericListItem broken_link\" href=\"http:\/\/blogs.msdn.com\/b\/ericwhite\/archive\/2009\/01\/28\/equality-semantics-of-linq-to-xml-trees.aspx\" target=\"_blank\" rel=\"noopener\">Equality Semantics of LINQ to XML Trees<\/a><\/li>\n<\/ul>\n<div style=\"margin-left: 2em; margin-bottom: 1em;\">In certain scenarios, it is important to be able to compare two XML trees for equivalence. For example, if you are writing a web service that serves results of queries, and you want to cache query results so that duplicate queries use previously cached results instead of always accessing the underlying database. However, the senders of those queries may potentially be using a variety of tools to generate the queries, and these tools may introduce trivial differences into the XML.<span style=\"color: #2b91af;\"> (Article)<\/span><\/p>\n<div style=\"vertical-align: text-top; margin-top: .5em;\"><span style=\"color: #2b91af;\">Keywords:\u00a0\u00a0<\/span><a href=\"https:\/\/www.ericwhite.com\/blog\/functional-programming-expanded\">Functional Programming<\/a>\u00a0\u00a0<a href=\"https:\/\/www.ericwhite.com\/blog\/linq-to-xml-expanded\">LINQ to XML<\/a>\u00a0\u00a0<a href=\"https:\/\/www.ericwhite.com\/blog\/xml-expanded\">XML<\/a><\/div>\n<\/div>\n<ul>\n<li class=\"ericListItem\"><a class=\"ericListItem broken_link\" href=\"http:\/\/blogs.msdn.com\/b\/ericwhite\/archive\/2009\/01\/28\/manually-cloning-linq-to-xml-trees.aspx\" target=\"_blank\" rel=\"noopener\">Manually Cloning LINQ to XML Trees<\/a><\/li>\n<\/ul>\n<div style=\"margin-left: 2em; margin-bottom: 1em;\">There are a variety of circumstances where you want to clone a LINQ to XML tree while making modifications to the cloned tree. It&#8217;s possible to write a very small amount of recursive code to do this.<span style=\"color: #2b91af;\"> (Article)<\/span><\/p>\n<div style=\"vertical-align: text-top; margin-top: .5em;\"><span style=\"color: #2b91af;\">Keywords:\u00a0\u00a0<\/span><a href=\"https:\/\/www.ericwhite.com\/blog\/functional-programming-expanded\">Functional Programming<\/a>\u00a0\u00a0<a href=\"https:\/\/www.ericwhite.com\/blog\/linq-to-xml-expanded\">LINQ to XML<\/a>\u00a0\u00a0<a href=\"https:\/\/www.ericwhite.com\/blog\/xml-expanded\">XML<\/a><\/div>\n<\/div>\n<ul>\n<li class=\"ericListItem\"><a class=\"ericListItem broken_link\" href=\"http:\/\/blogs.msdn.com\/b\/ericwhite\/archive\/2009\/02\/18\/the-composability-thought-process-for-linq.aspx\" target=\"_blank\" rel=\"noopener\">The Composability Thought Process for LINQ<\/a><\/li>\n<\/ul>\n<div style=\"margin-left: 2em; margin-bottom: 1em;\">This post demonstrates the thought process of developing a somewhat more involved query.<span style=\"color: #2b91af;\"> (Article)<\/span><\/p>\n<div style=\"vertical-align: text-top; margin-top: .5em;\"><span style=\"color: #2b91af;\">Keywords:\u00a0\u00a0<\/span><a href=\"https:\/\/www.ericwhite.com\/blog\/openxml-expanded\">OpenXML<\/a>\u00a0\u00a0<a href=\"https:\/\/www.ericwhite.com\/blog\/functional-programming-expanded\">Functional Programming<\/a>\u00a0\u00a0<a href=\"https:\/\/www.ericwhite.com\/blog\/linq-to-xml-expanded\">LINQ to XML<\/a><\/div>\n<\/div>\n<ul>\n<li class=\"ericListItem\"><a class=\"ericListItem broken_link\" href=\"http:\/\/blogs.msdn.com\/b\/ericwhite\/archive\/2009\/02\/20\/ease-of-maintenance-of-linq-code.aspx\" target=\"_blank\" rel=\"noopener\">Ease of Maintenance of LINQ Code<\/a><\/li>\n<\/ul>\n<div style=\"margin-left: 2em; margin-bottom: 1em;\">I believe that it is easier to maintain code that is written in the functional style. For one thing, this is the very reason for many of the characteristics of functional code. No state is maintained, so we don&#8217;t have to worry about corrupting any state. If a variable is in scope, then the variable has its value, and it will never have another value. And the idea of composability is all about being able to inject\/surround\/refactor code without making it brittle. In this post, I&#8217;m going to show the process of maintaining and modifying a somewhat more involved query.<span style=\"color: #2b91af;\"> (Article)<\/span><\/p>\n<div style=\"vertical-align: text-top; margin-top: .5em;\"><span style=\"color: #2b91af;\">Keywords:\u00a0\u00a0<\/span><a href=\"https:\/\/www.ericwhite.com\/blog\/openxml-expanded\">OpenXML<\/a>\u00a0\u00a0<a href=\"https:\/\/www.ericwhite.com\/blog\/functional-programming-expanded\">Functional Programming<\/a>\u00a0\u00a0<a href=\"https:\/\/www.ericwhite.com\/blog\/linq-to-xml-expanded\">LINQ to XML<\/a><\/div>\n<\/div>\n<ul>\n<li class=\"ericListItem\"><a class=\"ericListItem broken_link\" href=\"http:\/\/blogs.msdn.com\/b\/ericwhite\/archive\/2009\/02\/21\/computing-deep-hash-codes-using-linq-to-xml.aspx\" target=\"_blank\" rel=\"noopener\">Computing Deep Hash Codes using LINQ to XML<\/a><\/li>\n<\/ul>\n<div style=\"margin-left: 2em; margin-bottom: 1em;\">In some scenarios, it is useful to compute a &#8216;deep&#8217; hash code using LINQ to XML. If you are writing a server-side application that caches queries expressed in XML, then you may want to store these queries in a hash table.<span style=\"color: #2b91af;\"> (Article)<\/span><\/p>\n<div style=\"vertical-align: text-top; margin-top: .5em;\"><span style=\"color: #2b91af;\">Keywords:\u00a0\u00a0<\/span><a href=\"https:\/\/www.ericwhite.com\/blog\/functional-programming-expanded\">Functional Programming<\/a>\u00a0\u00a0<a href=\"https:\/\/www.ericwhite.com\/blog\/linq-to-xml-expanded\">LINQ to XML<\/a><\/div>\n<\/div>\n<ul>\n<li class=\"ericListItem\"><a class=\"ericListItem broken_link\" href=\"http:\/\/blogs.msdn.com\/b\/ericwhite\/archive\/2009\/02\/22\/ease-of-maintenance-of-linq-code-2.aspx\" target=\"_blank\" rel=\"noopener\">Ease of Maintenance of LINQ Code (2)<\/a><\/li>\n<\/ul>\n<div style=\"margin-left: 2em; margin-bottom: 1em;\">In two previous posts, I developed a somewhat involved query to search through a word processing document for style names and\/or paragraph content. This is a query that I&#8217;m developing for the PowerTools for Open XML project. In those posts, as I evolved the query, I showed each iteration of it, highlighting the changes I made. This post continues modifying that query.<span style=\"color: #2b91af;\"> (Article)<\/span><\/p>\n<div style=\"vertical-align: text-top; margin-top: .5em;\"><span style=\"color: #2b91af;\">Keywords:\u00a0\u00a0<\/span><a href=\"https:\/\/www.ericwhite.com\/blog\/openxml-expanded\">OpenXML<\/a>\u00a0\u00a0<a href=\"https:\/\/www.ericwhite.com\/blog\/functional-programming-expanded\">Functional Programming<\/a>\u00a0\u00a0<a href=\"https:\/\/www.ericwhite.com\/blog\/linq-to-xml-expanded\">LINQ to XML<\/a><\/div>\n<\/div>\n<ul>\n<li class=\"ericListItem\"><a class=\"ericListItem broken_link\" href=\"http:\/\/blogs.msdn.com\/b\/ericwhite\/archive\/2009\/04\/08\/why-i-don-t-use-the-foreach-extension-method.aspx\" target=\"_blank\" rel=\"noopener\">Why I Don&#8217;t Use the ForEach Extension Method<\/a><\/li>\n<\/ul>\n<div style=\"margin-left: 2em; margin-bottom: 1em;\">In my first version of my functional programming tutorial, I discussed a ForEach extension method, but I removed the topic from the second version. I no longer recommend using a ForEach extension method. This post explains why.<span style=\"color: #2b91af;\"> (Article)<\/span><\/p>\n<div style=\"vertical-align: text-top; margin-top: .5em;\"><span style=\"color: #2b91af;\">Keywords:\u00a0\u00a0<\/span><a href=\"https:\/\/www.ericwhite.com\/blog\/functional-programming-expanded\">Functional Programming<\/a>\u00a0\u00a0<a href=\"https:\/\/www.ericwhite.com\/blog\/linq-expanded\">LINQ<\/a><\/div>\n<\/div>\n<ul>\n<li class=\"ericListItem\"><a class=\"ericListItem broken_link\" href=\"http:\/\/blogs.msdn.com\/b\/ericwhite\/archive\/2009\/07\/20\/a-tutorial-in-the-recursive-approach-to-pure-functional-transformations-of-xml.aspx\" target=\"_blank\" rel=\"noopener\">Recursive Approach to Pure Functional Transformations of XML<\/a><\/li>\n<\/ul>\n<div style=\"margin-left: 2em; margin-bottom: 1em;\">Writing pure functional transformations a in a recursive style enables us to put together interesting transformations in a very small amount of code. Using some specific techniques that allow us to write this code very concisely, this approach takes advantage of some perhaps obscure semantics of LINQ to XML.<span style=\"color: #2b91af;\"> (Article)<\/span><\/p>\n<div style=\"vertical-align: text-top; margin-top: .5em;\"><span style=\"color: #2b91af;\">Keywords:\u00a0\u00a0<\/span><a href=\"https:\/\/www.ericwhite.com\/blog\/functional-programming-expanded\">Functional Programming<\/a>\u00a0\u00a0<a href=\"https:\/\/www.ericwhite.com\/blog\/linq-to-xml-expanded\">LINQ to XML<\/a>\u00a0\u00a0<a href=\"https:\/\/www.ericwhite.com\/blog\/xml-expanded\">XML<\/a><\/div>\n<\/div>\n<ul>\n<li class=\"ericListItem\"><a class=\"ericListItem broken_link\" href=\"http:\/\/blogs.msdn.com\/b\/ericwhite\/archive\/2009\/12\/13\/implementing-inheritance-in-xml.aspx\" target=\"_blank\" rel=\"noopener\">Implementing &#8216;Inheritance&#8217; in XML<\/a><\/li>\n<\/ul>\n<div style=\"margin-left: 2em; margin-bottom: 1em;\">Some XML vocabularies implement a powerful XML pattern that is analogous to inheritance in programming language type systems. Open XML WordprocessingML has these semantics around styles. When you define a new style, you can base this style on another style, and if the new style doesn&#8217;t explicitly define some aspect of the style, the new style &#8216;inherits&#8217; this aspect from its base style. This post presents some code that uses one approach for implementing inheritance semantics.<span style=\"color: #2b91af;\"> (Article)<\/span><\/p>\n<div style=\"vertical-align: text-top; margin-top: .5em;\"><span style=\"color: #2b91af;\">Keywords:\u00a0\u00a0<\/span><a href=\"https:\/\/www.ericwhite.com\/blog\/openxml-expanded\">OpenXML<\/a>\u00a0\u00a0<a href=\"https:\/\/www.ericwhite.com\/blog\/open-xml-sdk-expanded\">Open XML SDK<\/a>\u00a0\u00a0<a href=\"https:\/\/www.ericwhite.com\/blog\/wordprocessingml-expanded\">WordprocessingML<\/a>\u00a0\u00a0<a href=\"https:\/\/www.ericwhite.com\/blog\/powertools-for-open-xml-expanded\">PowerTools for Open XML<\/a>\u00a0\u00a0<a href=\"https:\/\/www.ericwhite.com\/blog\/xml-expanded\">XML<\/a>\u00a0\u00a0<a href=\"https:\/\/www.ericwhite.com\/blog\/functional-programming-expanded\">Functional Programming<\/a><\/div>\n<\/div>\n<ul>\n<li class=\"ericListItem\"><a class=\"ericListItem broken_link\" href=\"http:\/\/blogs.msdn.com\/b\/ericwhite\/archive\/2010\/02\/15\/rollup-extension-method-create-running-totals-using-linq-to-objects.aspx\" target=\"_blank\" rel=\"noopener\">Rollup Extension Method: Create Running Totals using LINQ to Objects<\/a><\/li>\n<\/ul>\n<div style=\"margin-left: 2em; margin-bottom: 1em;\">This post introduces the Rollup extension method, which enables you to write LINQ code to produce a running total. In addition, it enables you to write the equivalent of a state machine using LINQ and Functional Programming.<span style=\"color: #2b91af;\"> (Article)<\/span><\/p>\n<div style=\"vertical-align: text-top; margin-top: .5em;\"><span style=\"color: #2b91af;\">Keywords:\u00a0\u00a0<\/span><a href=\"https:\/\/www.ericwhite.com\/blog\/functional-programming-expanded\">Functional Programming<\/a>\u00a0\u00a0<a href=\"https:\/\/www.ericwhite.com\/blog\/linq-expanded\">LINQ<\/a><\/div>\n<\/div>\n<ul>\n<li class=\"ericListItem\"><a class=\"ericListItem broken_link\" href=\"http:\/\/blogs.msdn.com\/b\/ericwhite\/archive\/2010\/03\/10\/ad-hoc-string-concatenation-using-linq.aspx\" target=\"_blank\" rel=\"noopener\">Ad-Hoc String Concatenation using LINQ<\/a><\/li>\n<\/ul>\n<div style=\"margin-left: 2em; margin-bottom: 1em;\">Presents a small idiom to concatenate a set of strings.<span style=\"color: #2b91af;\"> (Article)<\/span><\/p>\n<div style=\"vertical-align: text-top; margin-top: .5em;\"><span style=\"color: #2b91af;\">Keywords:\u00a0\u00a0<\/span><a href=\"https:\/\/www.ericwhite.com\/blog\/functional-programming-expanded\">Functional Programming<\/a>\u00a0\u00a0<a href=\"https:\/\/www.ericwhite.com\/blog\/linq-expanded\">LINQ<\/a><\/div>\n<\/div>\n<ul>\n<li class=\"ericListItem\"><a class=\"ericListItem broken_link\" href=\"http:\/\/blogs.msdn.com\/b\/ericwhite\/archive\/2010\/03\/12\/hex-dump-using-linq-in-7-lines-of-code.aspx\" target=\"_blank\" rel=\"noopener\">Hex Dump using LINQ (in 7 Lines of Code)<\/a><\/li>\n<\/ul>\n<div style=\"margin-left: 2em; margin-bottom: 1em;\">Presents a bit of LINQ code to do a hex dump of a byte array.<span style=\"color: #2b91af;\"> (Article)<\/span><\/p>\n<div style=\"vertical-align: text-top; margin-top: .5em;\"><span style=\"color: #2b91af;\">Keywords:\u00a0\u00a0<\/span><a href=\"https:\/\/www.ericwhite.com\/blog\/functional-programming-expanded\">Functional Programming<\/a>\u00a0\u00a0<a href=\"https:\/\/www.ericwhite.com\/blog\/linq-expanded\">LINQ<\/a><\/div>\n<\/div>\n<ul>\n<li class=\"ericListItem\"><a class=\"ericListItem broken_link\" href=\"http:\/\/blogs.msdn.com\/b\/ericwhite\/archive\/2010\/06\/29\/writing-a-recursive-descent-parser-using-c-and-linq.aspx\" target=\"_blank\" rel=\"noopener\">Writing a Recursive Descent Parser using C# and LINQ<\/a><\/li>\n<\/ul>\n<div style=\"margin-left: 2em; margin-bottom: 1em;\">Recursive descent parsers are one of the easier types of parsers to implement. Given a properly defined grammar, you write a class for each production in the grammar, and you write one fairly simple method in each class. This post is the first in a series on using LINQ to write a recursive-descent parser for SpreadsheetML formulas.<span style=\"color: #2b91af;\"> (Article)<\/span><\/p>\n<div style=\"vertical-align: text-top; margin-top: .5em;\"><span style=\"color: #2b91af;\">Keywords:\u00a0\u00a0<\/span><a href=\"https:\/\/www.ericwhite.com\/blog\/functional-programming-expanded\">Functional Programming<\/a><\/div>\n<\/div>\n<ul>\n<li class=\"ericListItem\"><a class=\"ericListItem broken_link\" href=\"http:\/\/blogs.msdn.com\/b\/ericwhite\/archive\/2010\/07\/06\/recursive-descent-parser-using-linq-the-augmented-backus-naur-form-grammar.aspx\" target=\"_blank\" rel=\"noopener\">Recursive Descent Parser using LINQ: The Augmented Backus-Naur Form Grammar<\/a><\/li>\n<\/ul>\n<div style=\"margin-left: 2em; margin-bottom: 1em;\">A grammar is a device to define syntax for a language. A grammar is made up of rules, sometimes called productions. Each rule defines a symbol, when can then be further used in other rules. Grammars are not hard to understand; most developers instinctively understand grammars when they see them. When you learn a new programming language, almost without thinking about it, you assemble some version of the grammar in your head. One of the benefits of reading the grammar of a language is to make sure that the conceptual grammar you&#8217;ve mentally assembled matches the actual grammar of the language.<span style=\"color: #2b91af;\"> (Article)<\/span><\/p>\n<div style=\"vertical-align: text-top; margin-top: .5em;\"><span style=\"color: #2b91af;\">Keywords:\u00a0\u00a0<\/span><a href=\"https:\/\/www.ericwhite.com\/blog\/functional-programming-expanded\">Functional Programming<\/a><\/div>\n<\/div>\n<ul>\n<li class=\"ericListItem\"><a class=\"ericListItem broken_link\" href=\"http:\/\/blogs.msdn.com\/b\/ericwhite\/archive\/2010\/07\/13\/recursive-descent-parser-a-simple-grammar.aspx\" target=\"_blank\" rel=\"noopener\">Recursive Descent Parser: A Simple Grammar<\/a><\/li>\n<\/ul>\n<div style=\"margin-left: 2em; margin-bottom: 1em;\">To learn how recursive descent parsers work, it is helpful to implement a very simple grammar, so for pedagogical purposes, I&#8217;ve defined a grammar for simple arithmetic expressions.<span style=\"color: #2b91af;\"> (Article)<\/span><\/p>\n<div style=\"vertical-align: text-top; margin-top: .5em;\"><span style=\"color: #2b91af;\">Keywords:\u00a0\u00a0<\/span><a href=\"https:\/\/www.ericwhite.com\/blog\/functional-programming-expanded\">Functional Programming<\/a><\/div>\n<\/div>\n<ul>\n<li class=\"ericListItem\"><a class=\"ericListItem broken_link\" href=\"http:\/\/blogs.msdn.com\/b\/ericwhite\/archive\/2010\/07\/15\/creating-a-collection-from-singletons-and-collections-using-linq.aspx\" target=\"_blank\" rel=\"noopener\">Creating a Collection from Singletons and Collections using LINQ<\/a><\/li>\n<\/ul>\n<div style=\"margin-left: 2em; margin-bottom: 1em;\">A key operation when doing pure functional transformations is the process of creating complex hierarchies of objects. We see this when transforming some data source (such as an Open XML WordprocessingML document) to a LINQ to XML tree, and we see this when writing a recursive descent parser.<span style=\"color: #2b91af;\"> (Article)<\/span><\/p>\n<div style=\"vertical-align: text-top; margin-top: .5em;\"><span style=\"color: #2b91af;\">Keywords:\u00a0\u00a0<\/span><a href=\"https:\/\/www.ericwhite.com\/blog\/functional-programming-expanded\">Functional Programming<\/a><\/div>\n<\/div>\n<ul>\n<li class=\"ericListItem\"><a class=\"ericListItem broken_link\" href=\"http:\/\/blogs.msdn.com\/b\/ericwhite\/archive\/2010\/07\/30\/building-a-simple-recursive-descent-parser.aspx\" target=\"_blank\" rel=\"noopener\">Building a Simple Recursive Descent Parser<\/a><\/li>\n<\/ul>\n<div style=\"margin-left: 2em; margin-bottom: 1em;\">In this post, I present the start of a recursive descent parser that will parse the simple grammar that I presented previously in this series. I&#8217;ll point out some key features of the code so that it is easy to see how the code works.<span style=\"color: #2b91af;\"> (Article)<\/span><\/p>\n<div style=\"vertical-align: text-top; margin-top: .5em;\"><span style=\"color: #2b91af;\">Keywords:\u00a0\u00a0<\/span><a href=\"https:\/\/www.ericwhite.com\/blog\/functional-programming-expanded\">Functional Programming<\/a><\/div>\n<\/div>\n<ul>\n<li class=\"ericListItem\"><a class=\"ericListItem\" href=\"https:\/\/www.ericwhite.com\/blog\/screen-cast-functional-programming-utility-methods-and-classes-for-open-xml\/\" target=\"_blank\" rel=\"noopener\">Screen-Cast: Functional Programming Utility Methods and Classes for Open XML<\/a><\/li>\n<\/ul>\n<div style=\"margin-left: 2em; margin-bottom: 1em;\">In the process of developing the PowerTools for Open XML, over the years, I have developed some needed core functionality and utility methods, particularly for writing LINQ to XML code that queries and transforms Open XML documents.<span style=\"color: #2b91af;\"> (Video)<\/span><\/p>\n<div style=\"vertical-align: text-top; margin-top: .5em;\"><span style=\"color: #2b91af;\">Keywords:\u00a0\u00a0<\/span><a href=\"https:\/\/www.ericwhite.com\/blog\/openxml-expanded\">OpenXML<\/a>\u00a0\u00a0<a href=\"https:\/\/www.ericwhite.com\/blog\/powertools-for-open-xml-expanded\">PowerTools for Open XML<\/a>\u00a0\u00a0<a href=\"https:\/\/www.ericwhite.com\/blog\/functional-programming-expanded\">Functional Programming<\/a>\u00a0\u00a0<a href=\"https:\/\/www.ericwhite.com\/blog\/linq-expanded\">LINQ<\/a>\u00a0\u00a0<a href=\"https:\/\/www.ericwhite.com\/blog\/linq-to-xml-expanded\">LINQ to XML<\/a><\/div>\n<\/div>\n<ul>\n<li class=\"ericListItem\"><a class=\"ericListItem\" href=\"https:\/\/www.ericwhite.com\/blog\/open-xml-specific-utility-methods-and-classes-in-powertools-for-open-xml\/\" target=\"_blank\" rel=\"noopener\">Open XML Specific Utility Methods and Classes in PowerTools for Open XML<\/a><\/li>\n<\/ul>\n<div style=\"margin-left: 2em; margin-bottom: 1em;\">Screen-cast that introduces a number of OpenXML specific utility methods and classes in PowerTools for Open XML. These classes and methods are in the PtOpenXmlUtil.cs module.<span style=\"color: #2b91af;\"> (Video)<\/span><\/p>\n<div style=\"vertical-align: text-top; margin-top: .5em;\"><span style=\"color: #2b91af;\">Keywords:\u00a0\u00a0<\/span><a href=\"https:\/\/www.ericwhite.com\/blog\/openxml-expanded\">OpenXML<\/a>\u00a0\u00a0<a href=\"https:\/\/www.ericwhite.com\/blog\/powertools-for-open-xml-expanded\">PowerTools for Open XML<\/a>\u00a0\u00a0<a href=\"https:\/\/www.ericwhite.com\/blog\/wordprocessingml-expanded\">WordprocessingML<\/a>\u00a0\u00a0<a href=\"https:\/\/www.ericwhite.com\/blog\/functional-programming-expanded\">Functional Programming<\/a><\/div>\n<\/div>\n","protected":false},"excerpt":{"rendered":"<p>Back to TOCJust VideosCondensed TOC Language Integrated Query, when used properly, enables you to build powerful applications in the functional programming style. Pure functional transformations are my recommended approach to document manipulation. Query Composition using Functional Programming Techniques in C# 3.0 Functional Programming (FP) has the potential to reduce program line count by 20% to [&hellip;]<\/p>\n","protected":false},"author":1,"featured_media":0,"parent":0,"menu_order":0,"comment_status":"open","ping_status":"open","template":"","meta":{"_bbp_topic_count":0,"_bbp_reply_count":0,"_bbp_total_topic_count":0,"_bbp_total_reply_count":0,"_bbp_voice_count":0,"_bbp_anonymous_reply_count":0,"_bbp_topic_count_hidden":0,"_bbp_reply_count_hidden":0,"_bbp_forum_subforum_count":0,"_s2mail":"","footnotes":""},"class_list":["post-667","page","type-page","status-publish","hentry"],"_links":{"self":[{"href":"https:\/\/www.ericwhite.com\/blog\/wp-json\/wp\/v2\/pages\/667","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.ericwhite.com\/blog\/wp-json\/wp\/v2\/pages"}],"about":[{"href":"https:\/\/www.ericwhite.com\/blog\/wp-json\/wp\/v2\/types\/page"}],"author":[{"embeddable":true,"href":"https:\/\/www.ericwhite.com\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.ericwhite.com\/blog\/wp-json\/wp\/v2\/comments?post=667"}],"version-history":[{"count":9,"href":"https:\/\/www.ericwhite.com\/blog\/wp-json\/wp\/v2\/pages\/667\/revisions"}],"predecessor-version":[{"id":8034,"href":"https:\/\/www.ericwhite.com\/blog\/wp-json\/wp\/v2\/pages\/667\/revisions\/8034"}],"wp:attachment":[{"href":"https:\/\/www.ericwhite.com\/blog\/wp-json\/wp\/v2\/media?parent=667"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}