table of content

Part 1 Apache Thrift Overview

1 Introduction to Apache Thrift

1.1 Polyglotism, the pleasure and the pain

1.2 Application integration with Apache Thrift

1.2.1 Type serialization

1.2.2 Service implementation

1.3 Building a simple service

1.3.1 The Hello IDL

1.3.2 The Hello server

1.3.3 A Python client

1.3.4 A C++ client

1.3.5 A Java client

1.4 The communications toolkit landscape

1.4.1 SOAP

1.4.2 REST

1.4.3 Protocol Buffers

1.4.4 Apache Avro

1.4.5 Strengths of Apache Thrift

1.4.6 Take away

Summary

2 Apache Thrift architecture

2.1 Transports

2.1.1 The Transport interface

2.1.2 End point transports

2.1.3 Layered transports

2.1.4 Server transports

2.2 Protocols

2.3 Apache Thrift IDL

2.3.1 User-defined types and serialization

2.3.2 RPC services

2.4 Servers

2.5 Security

Summary

3 Building, testing, and debugging

3.1 Installing the Apache Thrift IDL Compiler

3.1.1 Platform installers

3.1.2 VMs and containers

3.1.3 Building from source

3.2 The Apache Thrift source tree

3.3 Apache Thrift tests

3.4 Debugging RPC services

3.4.1 Examining packets on the wire

3.4.2 Unbuffered interfaces

3.4.3 Interface misalignment

3.4.4 I/O stack misalignment

3.4.5 Instrumenting code

3.4.6 Additional techniques

Summary

Part 2 Programming Apache Thrift

4 Moving bytes with transports

4.1 End point transports — part 1: memory & disk

4.1.1 Programming with memory transports

4.1.2 Programming with file transports

4.2 The transport interface

4.2.1 Basic transport operations

4.3 End point transports — Part 2: networks

4.3.1 Network programming with TSocket

4.4 Server transports

4.4.1 Programming network servers with server transports

4.4.2 The Server Transport interface

4.5 Layered transports

4.5.1 Message framing

Summary

5 Serializing data with protocols

5.1 Basic serialization with the binary protocol

5.1.1 Using the C++ TBinaryProtocol

5.1.2 Using the Java TBinaryProtocol

5.1.3 Using the Python TBinaryProtocol

5.1.4 Takeaway

5.2 The TProtocol interface

5.2.1 Apache Thrift serialization

5.2.2 C++ TProtocol

5.2.3 Java TProtocol

5.2.4 Python TProtocolBase

5.3 Serializing objects

5.3.1 Struct serialization

5.3.2 Struct deserialization

5.3.3 Struct evolution

5.4 TCompactProtocol

5.5 TJSONProtocol

5.6 Selecting a protocol

Summary

6 Apache Thrift IDL

6.1 Interfaces

6.2 Apache Thrift IDL

6.2.1 IDL file names

6.2.2 Element names

6.2.3 Keywords

6.3 The IDL compiler

6.3.1 Compilation phases and error messages

6.3.2 Command line switches

6.4 Comments and documentation

6.5 Namespaces

6.6 Built-in types

6.6.1 Base types

6.6.2 Container types

6.6.3 Literals

6.7 Constants

6.7.1 C++ interface constant implementation

6.7.2 Java interface constant implementation

6.7.3 Python interface constant implementation

6.8 Typedefs

6.9 Enum

6.10 Structures, unions, exceptions, and argument-lists

6.10.1 Structs

6.10.2 Fields

6.10.3 Exceptions

6.10.4 Unions

6.11 Services

6.12 Including external files track.MusicTrack bonusTrack ) }

6.13 Annotations

Summary

7 User-defined types

7.1 A simple user-defined type example

7.2 Type design

7.2.1 Namespaces

7.2.2 Constants

7.2.3 Structs

7.2.4 Base types

7.2.5 Typedefs

7.2.6 Field Ids and retiring fields

7.2.7 Enums

7.2.8 Collections

7.2.9 Unions

7.2.10 Requiredness and optional fields

7.3 Serializing objects to disk

7.4 Under the type serialization hood

7.4.1 Serializing with write()

7.4.2 Deserializing with read()

7.5 Type evolution

7.5.1 Renaming fields

7.5.2 Adding fields

7.5.3 Deleting fields

7.5.4 Changing a field’s type

7.5.5 Changing a field’s requiredness

7.5.6 Changing a field’s default value

7.6 Using Zlib compression

7.6.1 Using Zlib with C++

7.6.2 Using Zlib with Python

Summary

8 Implementing services

8.1 Declaring IDL services

8.1.1 Parameter identifiers

8.1.2 Parameter Requiredness

8.1.3 Default parameter values

8.1.4 Function and parameter types

8.2 Building a simple service

8.2.1 Interfaces

8.2.2 Coding service handlers and test harnesses

8.2.3 Coding RPC servers

8.2.4 Coding RPC clients

8.3 Service interface evolution

8.3.1 Adding features to a service

8.4 RPC services in depth

8.4.1 Under the hood

8.4.2 Oneway functions

8.4.3 Service inheritance

8.4.4 Asynchronous clients

Summary

9 Handling exceptions

9.1 Apache Thrift exceptions

9.2 TTransportException

9.2.1 C++ Exception Processing

9.2.2 Java exception processing

9.2.3 Python exception processing

9.2.4 Error processing without exceptions

9.3 TProtocolException

9.4 TApplicationException

9.5 User-defined exceptions

9.5.1 User-defined exception IDL example

9.5.2 C++ user-defined exception client

9.5.3 C++ user-defined exception server

9.5.4 Java user-defined exception client

9.5.5 Python user-defined exception client

Summary

10 Servers

10.1 Building a Simple Server from Scratch

10.2 Using Multithreaded Servers

10.3 Server Concurrency Models

10.3.1 Connection Based Processing

10.3.2 Task Based Processing

10.3.3 Multithreading vs. Multiprocessing

10.3.4 Server Summary by Language

10.4 Using Factories

10.4.1 Building I/O Stacks with Factories

10.4.2 Processor and Handler Factories

10.4.3 In/Out Factories

10.4.4 Building Servers with Custom Factories and Transports

10.5 Server Interfaces and Event Processing

10.5.1 TServer

10.5.2 TServerEventHandler

10.5.3 Building a C++ Thread Pool Server with Server Events

10.6 Servers and Services

10.6.1 Building Multiservice Servers

10.6.2 Building a Multiplexed Java Threaded Selector Server

Summary

Part 3 Apache Thrift Languages

11 Building Clients and Servers with C++

11.1 Setting up Apache Thrift for C++ Development

11.1.1 Apache Thrift C++ Versions and Boost

11.1.2 Building Apache Thrift C++ Libraries

11.1.3 Building Apache Thrift C++ Libraries on Windows

11.2 A Simple Client and Server

11.2.1 The Hello IDL

11.2.2 Building a Simple C++ Client

11.2.3 Creating a Simple RPC Server

11.3 C++ Transports, Protocols and Servers

11.3.1 C++ Transports

11.3.2 C++ Protocols

11.3.3 Runtime versus Compile Time Polymorphism

11.3.4 C++ Servers

11.4 The C++ TNonBlockingServer

Summary

12 Building Clients and Servers with Java

12.1 Setting up Apache Thrift for Java Development

12.1.1 Apache Thrift and SLF4J

12.2 A Simple Client and Server

12.2.1 The Hello IDL

12.2.2 Building a Simple Java Client

12.2.3 Creating a Simple RPC Server

12.2.4 Building with Ant

12.2.5 Building with Maven

12.3 Using Apache Thrift in other JVM languages

12.4 Java Transports, Protocols and Servers

12.4.1 Java Transports

12.4.2 Java Protocols

12.4.3 Java Servers

12.5 Asynchronous Java RPC

Summary

13 Building C# Clients and Servers with .Net and Windows

13.1 Setting up Apache Thrift on Windows

13.2 A Simple Client and Server

13.2.1 Creating a Visual Studio RPC Solution

13.2.2 Creating the Interface Library

13.2.3 Creating the RPC Server

13.2.4 Creating the RPC Client

13.2.5 Testing the RPC Application

13.3 C# Transports, Protocols and Servers

13.3.1 C# Transports

13.3.2 C# Protocols

13.3.3 C# Servers

13.4 Long Polling with Named Pipes

13.4.1 A Long Polling Interface

13.4.2 Installing Apache Thrift Support through NuGet

13.4.3 Creating a Named Pipe Server

13.4.4 Building the Long Polling Server

13.4.5 Building a Named Pipe Client

Summary

14 Building Node.js Clients and Servers

14.1 A Simple Client and Server

14.1.1 Generating the Client/Server Stubs

14.1.2 Creating a Node.js Server

14.1.3 Creating a Node.js Client

14.2 Q

14.3 Node.js Servers

14.4 Multiplexed Services

14.5 Apache Thrift IDL and Node.js

14.5.1 Creating full featured IDL handlers

14.5.2 Creating a full featured Node.js Client

Summary

15 Apache Thrift and JavaScript

15.1 Apache Thrift JavaScript Quick Start

15.2 A Simple Client and Server

15.2.1 Installing Apache Thrift for JavaScript

15.2.2 The Hello World IDL

15.2.3 The Hello World Node.js Server

15.2.4 The Hello World Web Client

15.2.5 Running the Hello World Example

15.2.6 Debugging

15.2.7 Node.js HTTP Clients

15.3 Asynchronous Browser Client Calls

15.4 RPC Error Handling

15.5 Browser RPC and jQuery

15.6 Apache Thrift and Web Security

15.6.1 Cross-Origin Resource Sharing (CORS)

15.6.2 Content Security Policy (CSP)

15.6.3 X-Frame-Options

15.6.4 Transport Security

15.7 Using the Web Socket Transport

Summary

16 Scripting Apache Thrift

16.1 Apache Thrift and Ruby

16.1.1 A Ruby Server

16.1.2 A Ruby Client

16.1.3 Ruby Features

16.2 Apache Thrift and PHP

16.2.1 A PHP Program

16.2.2 A PHP Apache Thrift Client

16.2.3 PHP Features

16.3 Apache Thrift and Perl

16.4 Apache Thrift Perl Clients

16.5 Apache Thrift Perl Servers

16.5.1 Apache Thrift Perl Features

16.6 Apache Thrift and Python

Summary

17 Thrift in the Enterprise

17.1 Polyglot Development

17.2 Apache Thrift in the Distributed Landscape

17.2.1 Services

17.2.2 Interface Definition

17.2.3 REST and RPC

17.3 Messaging

17.4 Best Practices

17.4.1 IDL

17.4.2 Interface Evolution

17.4.3 Service Design

17.4.4 Type Design

17.4.5 Coding Practices

Summary

Overview

13 Building C# Clients and Servers with .Net and Windows

This chapter introduces how Apache Thrift enables polyglot, cross-platform RPC in the .NET/CLR ecosystem, parallel to the Java/JVM world, with a focus on building C# clients and servers on Windows. It guides you through configuring a Windows development environment, using Visual Studio and NuGet, and shows how Thrift’s language-agnostic IDL and generated code simplify interop between C# and many other languages. Beyond setup and a first working example, the chapter surveys the C# transport, protocol, and server options, and culminates with a practical long‑polling design built on named pipes.

You begin by preparing the essentials: Visual Studio with the .NET Framework SDK, the thrift.exe IDL compiler, and the Thrift C# runtime (built from source or installed via NuGet). A step-by-step “Hello World” solution organizes three projects—client, server, and a shared service library—driven by a simple hello.thrift IDL. Visual Studio is wired to invoke the Thrift compiler via a pre-build event, the generated C# stubs are compiled into the shared library, and both client and server reference that library and Thrift.dll. The server implements a handler and runs over TServerSocket using TSimpleServer, while the client connects with TSocket, layers TBufferedTransport and TBinaryProtocol, and exercises the service end to end.

The chapter then details the .NET Thrift stack: base and server transports (TServerSocket, TTLSServerSocket, TNamedPipeServerTransport), endpoint transports (TSocket, TTLSSocket, THttpClient, TNamedPipeClientTransport, TMemoryBuffer), layered transports (TBufferedTransport, TFramedTransport), protocols (TBinaryProtocol, TCompactProtocol, TJSONProtocol), and servers (TSimpleServer, TThreadedServer, TThreadPoolServer) with trade‑offs for concurrency and throughput. An advanced example models long polling for streaming trade reports: a PNWF TradeStream IDL, NuGet-managed Thrift dependency, a multithreaded named‑pipe server (TThreadedServer + TNamedPipeServerTransport + TCompactProtocol) with a TServerEventHandler to subscribe/unsubscribe clients, and a TradeEventGenerator using ThreadLocal events and concurrent collections. A compact client connects via TNamedPipeClientTransport and repeatedly calls GetNextTrade, demonstrating scalable, asynchronous-style delivery within an RPC architecture.

- Building the C# library with Visual Studio

- Creating a new C# solution

- Creating an RPC client project

- Client, Server and Service Interface Projects

- Adding Apache Thrift IDL to the Solution

- Saving files in ASCII format

- Adding an IDL Compiler pre-build event

- IDL Compiler C# output

- Successful helloService build

- Successful server build

- Testing helloServer.exe

- C# Server Transport Hierarchy

- C# End Point Transport Hierarchy

- C# Layered Transport Hierarchy

- The NuGet Package Manager Console

- The tradeService Project

- Three concurrent clients connected to the named pipe tradeServer

Summary

This chapter has covered:

How to configuring Apache Thrift for use with .Net on Windows.
How to create Apache Thrift applications with Visual Studio.
How to build C# RPC clients and servers with Apache Thrift.
The various End Point Transports available in C#.
The Layered Transports available in C#.
The C# supported Protocols.
How to use C# concurrency features with multithreaded Apache Thrift servers.
How to use long polling to supply asynchronous data feeds to clients.

FAQ

What do I need to set up Apache Thrift for C# on Windows?

- Visual Studio (Community edition is fine) with the .NET Framework SDK installed (not just .NET Core) - .NET Framework v4.5 or higher - The Apache Thrift IDL compiler (thrift.exe) on your PATH - The Apache Thrift C# library (Thrift.dll), via source build or NuGet - Usual build tools included with Visual Studio

How do I get the Thrift IDL compiler on Windows?

- Download the precompiled thrift.exe from http://thrift.apache.org/download - Place thrift.exe on your system PATH (for convenience, many drop it in C:\Windows) - Verify with: dir C:\Windows\thrift.exe (or run thrift --version)

How do I build the Thrift C# library (Thrift.dll) from source?

- Get the Thrift sources (zip from the download page or clone from GitHub) - Open lib/csharp/src/Thrift.sln in Visual Studio - Build the “Thrift” project (Debug or set Configuration to Release) - Output appears under lib/csharp/src/bin/(Debug|Release)/Thrift.dll - Linux/Mono option: xbuild /p:Configuration=Release /p:TargetFrameworkVersion="v4.5" Thrift.csproj (ensure mono-complete installed)

How should I structure a Visual Studio solution for a C# Thrift client/server?

- Create a Blank Solution (e.g., “hellocs”) - Add three projects: - helloClient: Console App (.NET Framework) - helloServer: Console App (.NET Framework) - helloService: Class Library (.NET Framework) for the shared, generated stubs - Define your service in helloService (add hello.thrift) and generate code into this project

Why does the Thrift compiler complain about my .thrift file from Visual Studio?

By default, Visual Studio saves text files as UTF-8 with a byte-order mark (BOM), which the Thrift compiler treats as garbage. Save the file as US-ASCII (File → “Save As…” → “Save with Encoding…” → US-ASCII).

How do I integrate thrift.exe into the VS build so stubs regenerate automatically?

- In the helloService project, add a Pre-build event command line like: thrift -out "../../" -gen csharp "$(ProjectDir)hello.thrift" - Ensure thrift.exe is on PATH - Add the generated .cs files to the project (prefer “Add as link” when generating into subfolders)

What references do my projects need?

- helloService: reference Thrift.dll (from your build or via NuGet) - helloServer and helloClient: - Reference the helloService project - Reference Thrift.dll - After adding references, IntelliSense errors in generated code (e.g., Thrift.* namespaces) should disappear

How do I run and test the simple client/server in Visual Studio?

- Set helloServer as the Startup Project - Debug → “Start Without Debugging” to run the server in its own console (allow firewall if prompted) - Right-click helloClient → Debug → “Start New Instance” to run the client - You should see the server log the received name and the client print the greeting

Which transports, protocols, and servers are available in the C# Thrift library?

- Transports: - Endpoint: TSocket, TTLSSocket, THttpClient, TNamedPipeClientTransport, TMemoryBuffer - Server: TServerSocket, TTLSServerSocket, TNamedPipeServerTransport - Layered: TBufferedTransport, TFramedTransport - Protocols: TBinaryProtocol, TCompactProtocol, TJSONProtocol - Servers: TSimpleServer, TThreadedServer, TThreadPoolServer - Note: client and server must use compatible transport/protocol combos

How does the named pipes long‑polling TradeStream example work?

- Server: - TNamedPipeServerTransport("TradeStream") + TCompactProtocol - TThreadedServer with a TServerEventHandler to subscribe/unsubscribe clients - TradeEventGenerator (ThreadLocal + ConcurrentDictionary + ConcurrentQueue) feeds per-connection trade queues - Client: - TNamedPipeClientTransport("TradeStream") + TCompactProtocol - Calls GetNextTrade() in a loop; each call may block until new trades are available - Notes: - Named pipes are Windows-native and performant; test Mono environments if planning cross‑platform - Long‑polling reduces new infrastructure but adds repeated request overhead

pro $24.99 per month

access to all Manning books, MEAPs, liveVideos, liveProjects, and audiobooks!
choose one free eBook per month to keep
exclusive 50% discount on all purchases
renews monthly, pause or cancel renewal anytime

lite $19.99 per month

access to all Manning books, including MEAPs!

team

5, 10 or 20 seats+ for your team - learn more

eBook

pdf, ePub, online

$64.99 $32.49

you save $32.50 (50%)

include audio $24.99 $12.49

pro $24.99 per month

access to all Manning books, MEAPs, liveVideos, liveProjects, and audiobooks!
choose one free eBook per month to keep
exclusive 50% discount on all purchases
renews monthly, pause or cancel renewal anytime

lite $19.99 per month

access to all Manning books, including MEAPs!

team

5, 10 or 20 seats+ for your team - learn more

eBook

$64.99 $32.49

you save $32.50 (50%)

include audio $24.99 $12.49

eBook

pdf, ePub, online

$64.99 $32.49

you save $32.50 (50%)

include audio $24.99 $12.49

pro $24.99 per month

access to all Manning books, MEAPs, liveVideos, liveProjects, and audiobooks!
choose one free eBook per month to keep
exclusive 50% discount on all purchases
renews monthly, pause or cancel renewal anytime

lite $19.99 per month

access to all Manning books, including MEAPs!

team

5, 10 or 20 seats+ for your team - learn more