TPL Dataflow is a library in C# provided by the Task Parallel Library (TPL) that enables developers to build asynchronous, concurrent, and data-driven applications. It simplifies the process of creating pipelines for processing data by allowing you to define dataflow networks where data can flow through various processing stages asynchronously and concurrently.

Key components of TPL Dataflow include:

Dataflow Blocks: These are the building blocks of a dataflow network. They encapsulate the logic for processing data. There are various types of dataflow blocks available such as BufferBlock, TransformBlock, ActionBlock, BroadcastBlock, etc.

Dataflow Networks: These are the connections between different dataflow blocks. You can link blocks together to create a flow of data from one block to another.

Dataflow Options: TPL Dataflow provides options to configure how the dataflow blocks behave, such as maximum degree of parallelism, bounded capacity, cancellation, and error handling.

Dataflow Scheduler: TPL Dataflow uses the underlying Task Parallel Library scheduler to manage the execution of dataflow blocks.

Here's a basic example of using TPL Dataflow:

using System.Threading.Tasks.Dataflow;

public static class TplDataFlow
{
    public static async Task DemoBufferTransformAction()
    {
        // initialize buffer
        var bufferBlock = new BufferBlock<int>();

        // initialize transfer
        var transformBlock = new TransformBlock<int, string>(async num =>
        {
            await Task.Delay(1000); // Simulating some processing time
            return $"Transform block processed: {num} sent from buffer";
        });

        // initialize action
        var actionBlock = new ActionBlock<string>(result =>
        {
            Console.WriteLine($"Action consumes: {result} sent from transform");
        });

        // link them
        bufferBlock.LinkTo(transformBlock);
        transformBlock.LinkTo(actionBlock);

        // action
        for (int i = 0; i < 10; i++)
        {
            Console.WriteLine($"buffer will receive: {i}");
            await bufferBlock.SendAsync(i); // Send data to the buffer block
        }

        bufferBlock.Complete(); // Signal that no more data will be sent
        await actionBlock.Completion; // Wait for all processing to complete
    }
}

In a console app, at Program.cs run this: 

await TplDataFlow.DemoBufferTransformAction();

In this example, BufferBlock receives integer data, TransformBlock processes it, and ActionBlock consumes the processed data. The LinkTo method is used to connect blocks together. Finally, SendAsync is used to send data to the buffer block, Complete is called to signal the completion of data, and await actionBlock.Completion is used to wait for all processing to finish.