facundo-giuliani

Facundo is a Systems Engineer from Buenos Aires, Argentina with 15+ years of experience in software development. Full Stack Developer. Auth0 Ambassador. GitKraken Ambassador. Cloudinary Media Developer Expert. He is also an open-source contributor.

Systems Engineer, Full Stack Developer

Facundo Giuliani

Most languages and frameworks support asynchronous programming. But, what is it exactly? Learn about async programming and how to implement it in C#.

You probably already read about asynchronous programming. `async` and `await` words are used everywhere, no matter which programming language we choose. Talking about .NET framework, and C# in particular, we have some native functions, classes, and reserved words that we can use to implement asynchronous tasks and workflows in our projects.

In this article, we will talk about synchronism, parallelism, concurrency, and how to implement asynchronous algorithms in our C# applications.

## Synchronous and Asynchronous Tasks

As a developer, you surely faced scenarios where certain actions or operations took a considerable amount of time to execute. We regularly have to do long-running tasks such as reading a file, calling an API, or downloading a big file. We could wait for one of these tasks to be finished before executing another task. If that's the case, we say we are working in a "synchronous" way. By doing this, the whole application gets blocked and stops responding until the whole task is completed, and we can move on to a new one.

In some cases, we don't have any alternative. If we have Task1 and Task2 that depend on the result of the first action, we will have to wait until Task1 finishes executing to start Task2. But we could have the scenario where the subsequent tasks (or some of them) don't depend on the result of the previous long-running task. If that's the case, we have different strategies and approaches that we could take to make our application faster and in a more performant way.

For example, we could have an application that runs concurrent tasks internally. There is a button and a task executed when it is clicked. Right after the user clicks on the button, the application can trigger a separate thread to run the requested task. In the meantime, the main thread becomes available to execute other actions while the button's task is executed in the background. Doing this, we keep the UI responsive in case the user wants to interact with it.

Another scenario would be needing to run multiple copies of a certain group of actions or instructions. An example of this would be uploading many files at the same time. In this case, our application could trigger one thread per file and execute the necessary code inside of them. Doing this, we would be processing the files in a "parallel" way. In a nutshell, here is the difference between the two concepts: concurrency means the application is making progress on more than one task at the same time, while parallelism is about running multiple tasks simultaneously.

But let's say we have to read a big file, call an API, and do some complex calculations. There is no dependency between the three tasks, but we need the result of all of them to continue the execution of our application and update the UI. In this case, we could execute our tasks "asynchronously" with the three ones running simultaneously and wait for their result to do the subsequent tasks.

## What Is Asynchronous Programming?

We could define asynchronous programming as the way of executing programming code in a thread without having to wait for an I/O-bound or CPU-bound task to finish. I/O-bound operations could be file-system accesses, HTTP requests, API calls, or database queries. And CPU-bound operations would be actions like encrypting data, complex calculations, image or document management.

One of the ideas of asynchronous programming is to divide our logic into *awaitable* tasks so that we don't block the execution of our application. We can call an async method and get a task object that represents it. In the meantime, we can do some not related and not dependant work. After we execute those operations, we await the async task, which may already be finished or not. If the execution is finished, we will get the resulting value from the task and use it in the next dependant operations.

### Benefits

Some of the benefits we have working with asynchronous tasks are:

- We keep the UI of our app responsive.
- We improve the performance of our application.
- We avoid [thread pool starvation](https://medium.com/criteo-engineering/net-threadpool-starvation-and-how-queuing-makes-it-worse-512c8d570527).

### Drawbacks

Although, there are some drawbacks when working with async programming:

- Code gets more complex and harder to maintain.
- There is increased memory allocation, as some objects have to stay alive longer while awaiting other code to be executed.
- It can get hard to find bugs occurring in asynchronous tasks.
- When we're writing an asynchronous piece of code, all our application code tends to become asynchronous.

## Asynchronous Programming Patterns

To perform asynchronous operations in .NET, we can follow three different patterns:

**Asynchronous Programming Model (APM)**: Let's say we have two methods, and we name them `BeginOperation` and `EndOperation`. After calling `BeginOperation`, our application can continue executing tasks on the calling thread while the async task is executed on a different thread. For each call to `BeginOperation`, our app should also call `EndOperation` method to get the results. In .NET, it can be implemented using `IAsyncResult`. Let's see an example of this model:

```csharp
using System;
using System.IO;
using System.Threading;
public sealed class Program
{
    public static void Main()
    {
        var buffer = new byte[100];
        var fs = new FileStream("bigFile.txt", FileMode.Open, FileAccess.Read, FileShare.Read, 1024, FileOptions.Asynchronous);

        IAsyncResult result = fs.BeginRead(buffer, 0, buffer.Length, null, null);

        // Do other things...

        int numBytes = fs.EndRead(result);
        fs.Close();

        Console.WriteLine("Read {0}  Bytes:", numBytes);
    }
}
```

**Event-based Asynchronous Pattern (EAP)**: We start an async method that will trigger a `Completed` event when the task is completed, making the result available to our application. This would be an example of this model:

```csharp
public class ExampleHandler
{
    public event EventHandler OnTriggerCompleted;

    public void Start(int timeout)
    {
        var timer = new Timer(new TimerCallback((state) =>
        {
            OnTriggerCompleted?.Invoke(null, null);
        }));

        timer.Change(timeout, 0);
    }
}

class Program
{
    private static void Main()
    {
        var handler = new ExampleHandler();

        handler.OnTriggerCompleted += (sender, e) =>
        {
            Console.WriteLine($"Triggered at: { DateTime.Now.ToLongTimeString()}");
        };

        handler.Start(3000);

        Console.WriteLine($"Start waiting at {DateTime.Now.ToLongTimeString()}");
        Console.WriteLine($"Processing...");
        Console.ReadLine();
    }
}
```

**Task-based Asynchronous Pattern (TAP)**: We have an `OperationAsync` method that returns a `Task` object, as in the following example:

```csharp
class ClassName
{
    public Task OperationAsync(byte [] buffer, int offset, int count);
}
```

 We can await that method, using `async` and `await` keywords. We will go deeper into this approach in a while.

> Keep in mind that **the APM and EAP approaches are legacy models and they are no longer recommended**. Microsoft recommends using the *Task-based Asynchronous Pattern* to implement async programming in our applications.

## Asynchronous Programming in C#

As we mentioned, async programming in C# can be accomplished by implementing the *Task-based Asynchronous Pattern*. We will have methods that return a `Task` or `Task<T>` object. Defining those methods as async operations will enable us to await them and keep using the same execution thread to run other operations that are not linked to the awaited task.

C# provides us two keywords to handle `Task` objects in an easier way: `async` and `await`. Adding the keyword `async` to a method signature allows us to use the `await` keyword inside the method while instructs the compiler to create a state machine to handle the asynchronicity. On the other hand, the `await` keyword is used to pause the execution of a method and asynchronously wait for a `Task` to finish, while the current thread is sent back to the thread pool instead of keeping it in a blocked state. Everything happens in the background, avoiding us to implement and maintain the complexity of thread management and the state of the calls.

Let's analyze this piece of code:

```csharp
public async Task<User> GetLoggedUserEmailAsync()
{
  int userId = GetId();
  string email = await GetEmailAsync(userId);
  User user = GetUserByEmail(email);
  return user;
}

public async Task<string> GetEmailAsync(int userId)
{
  // Do something
}
```

An async method should return `void`, `Task`, or `Task<T>`, where `T` is the return data type that we need. Returning `void` is normally used for event handlers. The keyword `async` enables us to use the command `await` within the method so that we can wait for the asynchronous method processing as expected.

Notice that the methods end with "Async". Although it is not mandatory, there is a naming convention that an asynchronous method name should end with the word "Async". This convention aims to make it clear to the consumer of the functionality that the method won't complete all of its work synchronously.

In our previous example, `GetId()` is called synchronously. When the execution thread encounters the `await` keyword on `await GetEmailAsync(userId)`, it creates a `Task<User>` that contains the remainder of the `GetLoggedUserEmailAsync` method. This task is executed asynchronously after the `Task<string>` returned by `GetEmailAsync`. So, the `User` object is returned from the `Task<User>` created by the `await` keyword.

## Asynchronous Code in Action

Let's see a short example to review the concepts previously explained. Having the following console application:

```csharp
using System;
using System.IO;
using System.Threading.Tasks;

class Program
{
   static async Task Main(string[] args)
   {
       string filePath = "bigFile.txt";

       // Create a big file
       FileStream fs = new FileStream(filePath, FileMode.CreateNew);
       fs.Seek(1024 * 1024, SeekOrigin.Begin);
       fs.WriteByte(0);
       fs.Close();

       var task = ReadFileAsync(filePath);

       Console.WriteLine("A synchronous message");

       int length = await task;

       Console.WriteLine("Total file length: " + length);
       Console.WriteLine("After reading message");
       Console.ReadLine();
   }

   static async Task<int> ReadFileAsync(string file)
   {
       Console.WriteLine("Start reading file");

       int length = 0;

       using(StreamReader reader = new StreamReader(file))
       {
           string fileContent = await reader.ReadToEndAsync();
           length = fileContent.Length;
       }

       Console.WriteLine("Finished reading file");

       return length;
   }
}
```

In this application, we read a big file, count the number of characters it has, and print different messages in the console. The method that triggers the file reading operation is defined as asynchronous, and it's the one that starts the asynchronous thread reading the text. While the message "A synchronous message" is printed, the reading of the file continues. If we execute the application, we can see how the execution thread behaves based on the output messages:

![Asynchronous sample application output](https://images.ctfassets.net/23aumh6u8s0i/6QF3i0BPAoDOSdF0T1jm07/269b11a895d0f74b415d49aa5b23d106/async-program-console.png)

## Summary

In this article, we talked about how we can manage and organize the tasks in our application based on the dependency and order of execution. We talked about synchronism, parallelism, concurrency, and asynchronism. We described async programming, its benefits, and how we can implement it in our C# applications. You can find the code shown in this article in [this GitHub repository](https://github.com/auth0-blog/c-sharp-async-intro).

If you want to learn more about asynchronous programming in C# and what advanced features we have available, you can go to:

- [Async in depth](https://docs.microsoft.com/en-us/dotnet/standard/async-in-depth) by Microsoft.
- [Asynchronous programming with async and await](https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/concepts/async/) by Microsoft.
- [Asynchronous Programming Guidance](https://github.com/davidfowl/AspNetCoreDiagnosticScenarios/blob/master/AsyncGuidance.md) by David Fowler.
- [Async/Await - Best Practices in Asynchronous Programming](https://docs.microsoft.com/en-us/archive/msdn-magazine/2013/march/async-await-best-practices-in-asynchronous-programming) by Microsoft.

<include src="asides/DotNetCore" />




Introduction to Async Programming in C#

bruno-lorenzo

I'm a software engineer with more than seven years of working experience. I worked for four years in a consultant company designing and implementing scalable and flexible systems. <br>

In 2018 I decided to move on into the iOS world. Currently, I'm working as iOS Tech. Lead at Houlak. I have been involved in several projects of different sizes which gives me the possibility to explore the latest technologies related to the iOS ecosystem.

Software Engineer

Bruno Lorenzo

A guide to fully understand the new concurrency system in Swift.

This year, WWDC came with a bunch of new features and updates. Maybe one of the most expected was the introduction of the new concurrency system by using async/await syntax. This is a huge improvement in the way that we write asynchronous code. 

## Before Async/Await

Imagine that we are working on an app for a grocery store and, we want to display its list of products. We are probably going to have something like this:

```swift
func fetchProducts(_ completion: @escaping([Product]) -> Void) {...}

var products = [Product]()
fetchProducts { [weak self] products in
    guard let strongSelf = self else { return }
    strongSelf.products.append(contentsOf: products)
}
```

A pretty standard and well-known code using completion blocks. Now suppose that the grocery store has, once in a while, some kind of offers for some products (e.g., "Take 2, pay 1"). And, we want to hold a list with these offers. Let's adjust our code by creating a new function to retrieve a String with the promotion text, given a specific product.

```swift
func fetchProducts(_ completion: @escaping([Product]) -> Void) {...}
func getOffer(for product: Int, @escaping(String) -> Void) {...}

typealias ProductOffer = (productId: Int, offer: String)
var products = [Product]()
var offers = [ProductOffer]()

fetchProducts { [weak self] products in
    guard let strongSelf = self else { return }

    for product in products {
        strongSelf.products.append(product)

        getOffer(for: product.id) { [weak self] offerText in
            guard let strongSelf = self else { return }
            let productOffer = ProductOffer(productId: product.id, offer: offerText)
            strongSelf.offers.append(productOffer)
        }
    }
}
```

We only have two nested closures for a simple feature, and you can see that our code starts to get a little messed up.

## Async/Await

From Swift 5.5 onwards, we can start using async/await functions to write asynchronous code without using completion handlers to returns values. Instead, we are allowed to return the values in the return object directly.

To mark a function as asynchronous, we only have to put the keyword **async** before the return type.

```swift
func fetchProducts() async -> [Product] {...}
func getOffer(for product: Int) async -> String {...}
```

This is much easier and simple to read, but the best part comes from the caller's side. When we want to use the result of a function marked as **async,** we need to make sure that its execution is already completed. To make this possible, we need to write the **await** keyword in front of the function call. By doing this, the current execution will be paused until the result is available for its use.

```swift
let products = await fetchProducts()

for product in products {
    let offerText = await getOffer(for: product.id)

    if !offerText.isEmpty {
        let productOffer = ProductOffer(productId: product.id, offer: offerText)
        offers.append(productOffer)
    }
}
```

Although, if we want to execute other tasks while the async function is being executed, we should put the keyword **async** in front of the variable (or let) declaration. In this case, the **await** keyword will need to be placed in front of the variable (or let) where we are accessing the result of the async function.

```swift
async let products = fetchProducts()
...
// Do some work
...
print(await products)
```

### Parallel Asynchronous Functions

Now imagine that in our app, we want to fetch products by category—for example, just the frozen products. Let's go ahead and make the adjustments to our code.

```swift
enum ProductCategory {
    case frozen
    case meat
    case vegetables
    ...
}

func fetchProducts(fromCategory category: ProductCategory) async -> [Product] {...}

let frozenProducts = await fetchProducts(fromCategory: .frozen)
let meatProducts = await fetchProducts(fromCategory: .meat)
let vegetablesProducts = await fetchProducts(fromCategory: .vegetals)
```

This is ok, but the code will run in serial mode,  which means that we won't start fetching the meat products until the frozen products are retrieved. Same for the vegetables. Remember, we write the **await** keyword if we want to pause our execution until the function completes its work. However, in this particular scenario, we could start fetching the three categories at the same time, running in parallel.

In order to accomplish this, we need to write the **async** keyword in front of the var (or let) declaration and use the **await** keyword when we want to use it.

```swift
async let frozenProducts = await fetchProducts(fromCategory: .frozen)
async let meatProducts = await fetchProducts(fromCategory: .meat)
async let vegetablesProducts = await fetchProducts(fromCategory: .vegetables) 

....

let products = await [frozenProducts, meatProducts, vegetablesProducts]
```

### Error handlers

Our fetching functions might have some errors that make it impossible to return the expected data values. How do we handle this in our async/await context?

We have a couple of options. The first one is to return the well-known Result object.

```swift
func fetchProducts() async -> Result<[Product], Error> {...}

let result = try await fetchProducts()
switch result {
    case .success(let products):
        // Handle success
    case .failure(let error):
        // Handle error
}
```

Another one is to use the try/catch approach.

```swift
func fetchProducts() async throws -> [Product[ {...}
...
do {
    let products = try await fetchProducts()
} catch {
    // Handle the error
}
```

The main benefit that we had when using the Result type was to improve our completion handlers. In addition to that, we got a cleaner code at the moment we used the result, being able to switch between success and failure cases.

On the other hand, the use of throw errors adds extra readability in the function's definition because we only need to put the result type that the function will return. The errors handling is hidden in the function's implementation.

### Asynchronous Sequences

Let's say that we have a requirement to load a list of products from some .csv file. A traditional way to do this is to load all the lines at once and then start processing them. But, what happens if we want to start doing some work as soon as we have one of the lines available? We can now do this using an asynchronous sequence.

```swift
let url = URL(string: "http://www.grocery.com/products.csv")
for try await in url.lines {
    // Do some work
}
```

Using this new feature also allows us to handle this particular case (reading a file) in a simpler way than before. You can check this [stackoverflow discussion](https://stackoverflow.com/questions/24581517/read-a-file-url-line-by-line-in-swift) to see how we had to do this and see the advantages that this approach has over the previous one.

### Async/Await vs. Completion Handlers

As we saw in the previous sections, the use of async/await syntax comes with a lot of improvements in contrast with using completion blocks. Let's make a quick recap.

#### Advantages

- Avoid the Pyramid of Doom problem with nested closures
- Reduction of code
- Easier to read
- Safety. With async/await, a result is guaranteed, while completion blocks might or might not be called.

#### Disadvantages

- It's only available from Swift 5.5 and iOS 15 onwards.

## Actors

Take a look at the following example, just a simple Order class in which we will be adding products and eventually make the checkout.

```swift
class Order {
    
    var products = [Product]()
    var finalPrice = 0

    func addProduct(_ product: Product) {
        products.append(product)
        finalPrice += product.price
    }
}
```

If we are in a single-thread application, this code is just fine. But what happens if we have multiple threads that can access our order's final price? 

1. We are on the product list and add some specific products to our order. The app will call the **addProduct** function.
2. The product is added to our order's product list
3. Before the final price gets updated, the user tries to checkout.
4. The app will read the final price of our order
5. The **addProduct** function completes and updates the final price. But the user already checkout and paid less than they should.

This problem is known as [**Data Races**](https://en.wikipedia.org/wiki/Race_condition) when some particular resource could be accessed from multiple parts of the app's code.

Actors, also introduced in Swift 5.5 and iOS 15, resolve this problem for us. An Actor is basically like a class but with a few key differences that make them *thread-safe*:

- Only allow accessing their state by one task at a time
- Stored properties and functions can only be access from outside the Actor if the operation is performed asynchronously.
- Stored properties can't be written from outside the Actor.

<br>
On the downside:

- Actors do not support inheritance

You can think about the Actors like a similar solution of the [semaphores](https://en.wikipedia.org/wiki/Semaphore_(programming)) concept.

To create one, we just need to use the **actor** keyword.

```swift
actor Order {
    
    var products = [Product]()
    var finalPrice = 0

    func addProduct(_ product: Product) {
        products.append(product)
        finalPrice += product.price
    }
}
```

And we can create an instance using the same initializer syntax as structures and classes. If we want to access the final price, we must do it using the keyword await (because outside the actor's scope, we are only allowed to access the properties asynchronously).

```swift
print(await order.finalPrice)
```

## Conclusion

Definitely **async/await** brings to the table an easier way to write asynchronous code, removing the need to use completion blocks. In addition, we get more readable and flexible code if our application starts scaling up. 

However, the minimum iOS deployment target will be an entry barrier for most of us unless you start a project from scratch, in which case is highly recommended to wait until the official release of iOS 15 + Xcode 13 + Swift 5.5  to take full advantage of the new concurrency system.

Async Await in Swift

df6c864847fba9687d962cb80b482764?size=200 avatar

df6c864847fba9687d962cb80b482764?size=200

Martin Gontovnikas, a.k.a Gonto, is a software engineer at heart who moved to the ‘dark side’ and became VP of Marketing at Auth0. He considers himself lucky to have found a way to combine his two passions and apply his engineering thinking model to marketing.<br/><br/> Gonto’s analytical thinking is a huge driver of his data-driven approach to marketing strategy and experimental design. He is based in the Bay area, and in his spare time, can be found eating gourmet food at the best new restaurants, visiting every local brewery he can find, or traveling the globe in search of new experiences.

Former SVP of Marketing and Growth at Auth0

Martin Gontovnikas

New customer acquisitions channels await if you can walk the tightrope between B2B and B2C.


> Customer acquisition costs can make or break a business. 

The more it costs to acquire a customer, the more value businesses have to get from that customer to make a profit. If the value of each customer is less than the money it takes to acquire them, no investor's wallet will be deep enough to sustain the company for the long term. 

Some companies are turning to other businesses to acquire customers, developing business models that tie mutually beneficial links between the companies and their customers. In this model, called B2B2C, one business offers a service to a business that needs it, but the first business retains the customers it gains. 

Grubhub, a popular delivery app, is an example. When you order your dinner through Grubhub, you can access dozens of restaurants in your local area. You're simultaneously the customer of Grubhub and whichever restaurant you choose. GrubHub didn't sell their product to the restaurant (B2B), nor did they make the food you're about to eat (B2C). This is the B2B2C business model in action. 

B2B2C offers a compelling mix of B2B and B2C advantages to startups searching for product-market fit and to established companies looking to acquire new customers. When done right, it's win-win-win for both of the businesses and their customers. 

## What is B2B2C?

B2B2C describes a business model where your company sells a product or service to another business, which gets you access to customers you get to keep and use. Here are the key differentiators for B2B2C:

1. Your business offers a horizontal solution to another business's problem.
2. The other business's customers recognize that they're also your customers.

![Image of Business to business to consumer acronym (B2B2C)](https://images.ctfassets.net/23aumh6u8s0i/u2b5DKGwQGoT0HFSNvDwq/50d62116826610c3c7734a26a9903c40/b2b2c-separator-01.png)

Take another look at Grubhub: It sells a horizontal feature to the restaurants around you. Many of them can't offer delivery, and most of them don't have the funds to build out a consumer-facing app—much less provide customer support for it. 

If a restaurant partners with Grubhub, they get to offer their previous customers a new feature, potentially resulting in more orders and higher customer satisfaction. When Grubhub partners with a restaurant, they get access to those customers and can maintain that relationship as they order from other restaurants in other locations. 

The B2B2C model is more than a mutually beneficial relationship between businesses: It requires that customers develop direct but separable relationships with both brands.  

Your local grocery store didn't form a B2B2C relationship with Coca-Cola to sell soda. This is a vendor relationship: Coca-Cola sells their product at wholesale to another business, which sells it to you for a marked-up price; Coca-Cola doesn't sell soda to you directly. 

Another easy-to-mix-up B2B relationship is white labeling. Take [Bread, for example](https://www.getbread.com/blog/truth-about-white-labeling/). Bread offers a white-labeled product for stores that want to offer financing. You might notice a horizontal value here. But the nature of a white-label relationship is that customers don't know they're using Bread; they just know there's a new button when they check out.  

In a true B2B2C deal, the business you're selling to gets a problem solved, and your business gets access to a new customer base that isn't fixed to the prior business. 

## Why B2B2C Can Create Strategic Customer Growth

B2B2C deals combine two of the best features from B2C and B2B models: network effects and predictable growth plans. 

If you acquire entire customer bases through B2B2C deals, you can use that data to fuel further acquisition and iteration. The more you know about your customers, the better you can find them and serve them. 

Network effects are typically the domain of B2C companies — Facebook and Google being [prime examples](https://stratechery.com/2018/the-moat-map/). Unfortunately for other B2C companies, network effects have discouraging, downstream influences. Google's product improves as it acquires users, which means that any Google competitors have to find ways to improve their product without the same access to feedback. 

With a B2B2C model, you can get around some of those effects. Each B2B2C deal offers you customers and data, but you can build on those network effects in chunks rather than drips. With this kind of acquisition, you can plan for network effects. 

OpenTable, a B2B2C company that offers online reservations with restaurants, builds network effects into its email marketing. Initial user acquisition typically starts with users seeking a reservation to a local restaurant, but once users join the service, they get restaurant recommendations tailored to them based on users in their area. 

![OpenTable web site screenshot](https://images.ctfassets.net/23aumh6u8s0i/4UXoeaHxiRqDirf84Nx5Xm/7759092d29a0a3794befa9da5ea8e1f7/open-table)

With network effects providing a tailwind, OpenTable's horizontal service shows users that they're now OpenTable customers and that there's value in being an active participant in the service.  

By making deals with businesses instead of navigating waves of consumer trends, you can also make a more predictable, long-term growth plan. 

Hero, another company with a B2B2C business model, has this planning potential. Hero enables retail employees in physical stores to connect with online shoppers through chat and live video. 

![Hero live from showroom application](https://images.ctfassets.net/23aumh6u8s0i/2GtFDECEq6H2GISKqnJ3x7/a4acaa4798fc466e589d33721715eaf6/hero-showroom)
*[Source](https://blog.usehero.com/selling-iconic-designs-online-how-jonathan-adler-maximizes-its-stores-potential-with-hero-e344f5c94694)*

Hero provides a digital layer for physical retailers. That way, physical retailers can still interact with online consumers by showing them products and sharing information.

Instead of acquiring users directly, Hero can chart its growth against a much smaller selection of stores and chains. 

This growth plan is advantageous because B2B companies [tend to have less churn](https://www.profitwell.com/blog/how-b2b-and-b2c-companies-solve-churn-for-different-customers) than B2C companies. Consumers have a wide variety of services to turn to, and might churn because they lose interest, find a better product, or decide they could no longer afford it. B2B companies try to solve business problems, so client interest isn't as likely to wane and there might not be many alternatives if the market is niche. 

With B2B sales, you can focus on building a sales team that pursues and maintains fewer, but larger,  accounts. As each B2B client offers a group of customers, you can still [get the data](https://auth0.com/blog/three-tools-to-improve-your-customer-intelligence/) that cultivates successful B2C growth. 

A B2B2C company can iterate its service with each customer but plan its growth with each client. 

## B2B2C Customers Need Identity Infrastructure

B2B2C business models rely on an infrastructure that enables cross-platform user management. With white-labeled [identity infrastructure](https://auth0.com/blog/what-is-identity-infrastructure/) from Auth0, you can make authentication seamless and secure so that customers can focus on using and enjoying your product.

### Single Sign On (SSO)

Asking users to remember another set of credentials is a big request. According to a Digital Guardian survey, [nearly a third of users](https://digitalguardian.com/blog/uncovering-password-habits-are-users-password-security-habits-improving-infographic) already have too many password-protected credentials to count. If they're trying your service out for the first time, you don’t want to create friction.

Look at the identity needs of a [company like GO1](https://auth0.com/learn/go1-adaptable-authentication-service-built-scale/), for instance. GO1 is a B2B2C company that works with learning management system providers to build a repository of compliance and professional development content. With one subscription, end-users get access to this volume of valuable content, and businesses can better enable employee growth. 

Seamless authentication is key for this level of engagement. Self-development isn’t always easy, and users facing a login screen every time they want to view a resource or test a new module could make the experience even harder. GO1’s long-term success rests on consistently showing users the value of new knowledge and making it simple for them to pursue it.

![The Go1 Site screenshot](https://images.ctfassets.net/23aumh6u8s0i/453YMGqqDX01MzeD1ETKmR/0aec12fee74f33cd95e9f24fc5f971a7/go1-site)

[Single Sign On (SSO)](https://auth0.com/blog/what-is-and-how-does-single-sign-on-work/) enables users to log in with one set of credentials — and stay logged in — creating a seamless experience that lets the GO1 product shine through. 

As GO1 expands to new use cases, such as enabling job search companies to prompt their applicants to complete training via GO1 before applying, the authentication experience becomes even more important. Expansion requires integrating with different authentication protocols, such as SAML and LDAP. An outsourced identity provider can help you consistently [scale a high-level authentication experience](https://auth0.com/blog/the-real-roi-of-auth0-part-2-innovation/) without consuming your developer resources. 

### Security and Privacy

A B2B2C business model also relies on the ability to safely manage users. 

If you want to sell another business on your service, the advantages of that deal need to outweigh the risk associated with introducing a third party. The network effects that make a B2B2C deal valuable depend on data, so your customers need to be able to trust you with that data. 

Since B2B2C typically involves one business positioning its service as an add-on to another business's service, a [data breach](https://auth0.com/blog/what-is-a-data-breach/) can be especially dangerous. Users are already getting value from the main service, so if your security practices develop a poor reputation, you'll be easy to avoid. And if the [data breach is high profile](https://auth0.com/blog/11-of-the-worst-data-breaches-in-media/), the main business might drop your service to keep its users safe. 

Auth0 is a trusted, vetted identity provider, as proven by our adherence to best-in-class [compliance frameworks](https://auth0.com/security/). By offering robust security features, you can demonstrate to users, and the business offering them to you, that you can treat their data with care. 

Counterintuitively, adding security also grants you the opportunity to learn more about your users. Auth0 offers [progressive profiling tools](https://auth0.com/blog/how-profile-enrichment-and-progressive-profiling-can-boost-your-marketing/) so that you can learn more about your customers over time. Rather than barrage them with questions all at once, you can get different bits of information every time they log in: their name the first time, their address the second, their industry the third, and so on. 

Security can bolster, not slow down, your network effects. 

### Branding and White Labeling 

An essential feature of a successful B2B2C relationship is that your newly acquired customers actually identify as your customers. If your brand name merely flashes by as customers proceed with their normal flows, then you're not getting the full value of the B2B2C deal. 

The B2B2C relationship is already fairly complex, and customers are liable to confuse which business they need to contact for support in different contexts. If you can white label any of the supporting infrastructures you need to manage users, your relationship with them will be simpler. 

With Auth0's [Guardian](https://auth0.com/multifactor-authentication), you can build a multi-factor authentication application that matches your brand's look and feel. Combined with an extensive JavaScript library, you can further customize Guardian to your specific needs. 

Branding is powerful, and with the right tools, your customers are better able to see your service and remember its value. 

## Is Your Business Right for B2B2C?

B2B2C relies on aligned incentives and on businesses that can maintain that alignment. 

The business you're selling to has to want another brand involved, not just your service or solution. If that business only wants a new feature, a true B2B2C deal will be difficult to strike and hard to maintain. 

Look for these deals by pursuing companies that already offer a range of services or products. They'll likely be more open to adding yours to their portfolio. If you come into the deal with a well-run customer success team, you can [pitch that support](https://blog.getbase.com/sales-support-drive-acquisition). The less that business has to worry about the problems your solution might introduce for their customers, the better.  

B2B2C can be your core business model, or it can be a growth stage. Uber started as a digital, on-demand cab service; now it offers delivery at scale through Uber Eats. Instacart started as a grocery delivery service, but there's speculation it might [pivot to B2C](https://www.forbes.com/sites/brittainladd/2019/02/11/killing-instacart-why-the-company-is-at-risk-of-crashing-to-the-ground/#551d52d536e8) by leveraging user data to open its own grocery stores. 

To strike a B2B2C deal, your service has to offer horizontal value. To succeed with a B2B2C deal, new users have to identify as your customers. 

Getting the deal depends on a good sales team and the right product alignment. Succeeding with the deal depends on supporting users with the right identity infrastructure and the best authentication experience.  

<include src="asides/AboutAuth0" />


B2B2C Customer Acquisition Needs Identity Infrastructure

001c9ddc5ceb9829b6aaf24f5d28502a

I am software developer with a keen interest in open-source technologies, Linux, and native development. I've worked on many different platforms Android, iOS, Win32, Linux, FreeRTOS, the Web, and others. I've gone through the whole stack and I enjoy learning and using the latest technologies. I now work as a full-stack developer at Auth0.

Senior Engineer

Sebastian Peyrott

Take a look at the features from ECMAScript/JavaScript 2015 and learn how they can help you in your projects

"await"