Question: How can I bind a `Datagrid` with two columns (`DataGridTextColumn` and `DataGridComboBoxColumn`) to an `ObservableCollection<Team> Teams`?

The `DataGridTextColumn` is bound correctly. But nothing is displayed in `DataGridComboBoxColumn`.

***Code-behind***

```
   public class Team
   {
      public string Name { get; set; }
      public List<string> Members { get; set; }
   }

   public class ViewModel : INotifyPropertyChanged
   {
      public event PropertyChangedEventHandler PropertyChanged;

      private ObservableCollection<Team> teams = new ObservableCollection<Team>
      {
         new Team()
         {
            Name = "A", Members = new List<string> {"John", "Jack"},
         },
         new Team()
         {
            Name = "B", Members = new List<string> {"Sarah", "Anna"},
         }
      };
      public ObservableCollection<Team> Teams
      {
         get { return teams; }
         set
         {
            teams = value;
            RaisePropertyChanged("Teams");
         }
      }

      private void RaisePropertyChanged(string propertyName)
      {
         var handler = PropertyChanged;
         if (handler == null) return;

         handler(this, new PropertyChangedEventArgs(propertyName));
      }
   }

```

***XAML***

```
<DataGrid ItemsSource="{Binding Path=Teams}"
          AutoGenerateColumns="False">
    <DataGrid.Columns>

        <DataGridTextColumn Header="Team" 
                                    IsReadOnly="True"
                                    Width="*"
                                    Binding="{Binding Name}"/>

        <DataGridComboBoxColumn Header="Members" 
                                        Width="*"
                                        />

    </DataGrid.Columns>
</DataGrid>

```

Answer: 
AWS recently announced support for regional API endpoints using which you can achieve this.

Below is an AWS Blog which explains how to achieve this:

[Building a Multi-region Serverless Application with Amazon API Gateway and AWS Lambda](https://aws.amazon.com/blogs/compute/building-a-multi-region-serverless-application-with-amazon-api-gateway-and-aws-lambda/)

Excerpt from the blog:

> 
> The default API endpoint type in API Gateway is the edge-optimized API
>  endpoint, which enables clients to access an API through an Amazon
>  CloudFront distribution. This typically improves connection time for
>  geographically diverse clients. By default, a custom domain name is
>  globally unique and the edge-optimized API endpoint would invoke a
>  Lambda function in a single region in the case of Lambda integration.
>  You can’t use this type of endpoint with a Route 53 active-active
>  setup and fail-over.
> 
> 
> The new regional API endpoint in API Gateway moves the API endpoint
>  into the region and the custom domain name is unique per region. This
>  makes it possible to run a full copy of an API in each region and then
>  use Route 53 to use an active-active setup and failover.
> 
> 
>
Checkout [Lambda@Edge](https://aws.amazon.com/lambda/edge/)

> 
> Q: What is Lambda@Edge? Lambda@Edge allows you to run code across AWS
>  locations globally without provisioning or managing servers,
>  responding to end users at the lowest network latency. You just upload
>  your Node.js code to AWS Lambda and configure your function to be
>  triggered in response to Amazon CloudFront requests (i.e., when a
>  viewer request lands, when a request is forwarded to or received back
>  from the origin, and right before responding back to the end user).
>  The code is then ready to execute across AWS locations globally when a
>  request for content is received, and scales with the volume of
>  CloudFront requests globally. Learn more in our documentation.
> 
> 
> 

Usecase, minimizing latency for globally distributed users

> 
> Q: When should I use Lambda@Edge? Lambda@Edge is optimized for latency
>  sensitive use cases where your end viewers are distributed globally.
>  Ideally, all the information you need to make a decision is available
>  at the CloudFront edge, within the function and the request. This
>  means that use cases where you are looking to make decisions on how to
>  serve content based on user characteristics (e.g., location, client
>  device, etc) can now be executed and served right from the edge in
>  Node.js-6.10 without having to be routed back to a centralized server.
> 
> 
>