### launchSettings.json Configuration

Source: https://github.com/packtpublishing/.net-maui-cookbook.git/blob/main/Chapter05/c5-AuthenticationServiceAndClient/Readme.md

Example configuration from launchSettings.json specifying the server's HTTPS port.

```json
{
  "profiles": {
    "https": {
      "commandName": "Project",
      "dotnetRunMessages": true,
      "launchBrowser": true,
      "launchUrl": "swagger",
      "applicationUrl": "https://localhost:7158;http://localhost:5158",
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development"
      }
    }
  }
}
```

--------------------------------

### Install Dev Tunnel CLI (Windows)

Source: https://github.com/packtpublishing/.net-maui-cookbook.git/blob/main/Chapter05/c5-AuthenticationServiceAndClient/Readme.md

Installs the Dev Tunnel command-line interface on Windows using the Windows Package Manager.

```shell
winget install Microsoft.devtunnel
```

--------------------------------

### Install Dev Tunnel CLI (macOS)

Source: https://github.com/packtpublishing/.net-maui-cookbook.git/blob/main/Chapter05/c5-AuthenticationServiceAndClient/Readme.md

Installs the Dev Tunnel command-line interface on macOS using Homebrew.

```shell
brew install --cask devtunnel
```

--------------------------------

### Run .NET MAUI Server

Source: https://github.com/packtpublishing/.net-maui-cookbook.git/blob/main/Chapter05/c5-AuthenticationServiceAndClient/Readme.md

Starts the .NET MAUI server application using the 'https' launch profile.

```shell
dotnet run --launch-profile https
```

--------------------------------

### Signing in with a Google Account

Source: https://github.com/packtpublishing/.net-maui-cookbook.git/blob/main/README.md

Guides on integrating Google Sign-In for authentication in .NET MAUI applications, typically involving OAuth 2.0 flows and platform-specific configurations.

```C#
// Requires setup with Google Cloud Console and platform-specific configurations
// Example using a library like IdentityModel.OidcClient
var authenticator = new PublicClientApplication("YOUR_GOOGLE_CLIENT_ID");
var result = await authenticator.AcquireTokenInteractive(new[] { "profile", "email" }).ExecuteAsync();
// Use result.AccessToken to authenticate with your backend
```

--------------------------------

### OpenAI API Key Setup

Source: https://github.com/packtpublishing/.net-maui-cookbook.git/blob/main/Chapter06/c6-OpenAITextAssistant/Readme.md

Instructions on obtaining and setting up your OpenAI API key within the .NET MAUI application. Replace the placeholder string with your actual API key.

```csharp
In the [MainViewModel](/Chapter06/c6-OpenAITextAssistant/c6-OpenAITextAssistant/MainViewModel.cs) class, replace the *[Your API Key](/Chapter06/c6-OpenAITextAssistant/c6-OpenAITextAssistant/MainViewModel.cs#L13C61-L13C73)* string with your OpenAI key.
```

--------------------------------

### Building a Chat Bot with Ollama Deployed to a Self-Hosted Server

Source: https://github.com/packtpublishing/.net-maui-cookbook.git/blob/main/README.md

Guides on creating a .NET MAUI chat interface that communicates with an Ollama instance running on a local or remote server for AI-powered conversations.

```C#
using HttpClient;

var client = new HttpClient();
var requestBody = new { prompt = "User: Hello!", model = "llama2" };
var response = await client.PostAsJsonAsync("http://localhost:11434/api/generate", requestBody);
// Process response.Content
```

--------------------------------

### Host Dev Tunnel

Source: https://github.com/packtpublishing/.net-maui-cookbook.git/blob/main/Chapter05/c5-AuthenticationServiceAndClient/Readme.md

Starts hosting the configured Dev Tunnel, making the service accessible externally. Provides URLs for browser access and inspection.

```shell
devtunnel host mytunnel
```

--------------------------------

### Creating an Authentication Service with ASP.NET Core Identity

Source: https://github.com/packtpublishing/.net-maui-cookbook.git/blob/main/README.md

Details the setup of an ASP.NET Core Web API project using Identity for user authentication and authorization.

```C#
// Startup.cs or Program.cs
builder.Services.AddIdentity<ApplicationUser, IdentityRole>()
    .AddEntityFrameworkStores<ApplicationDbContext>()
    .AddDefaultTokenProviders();

builder.Services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
    .AddJwtBearer(options => {
        // Configure JWT options
    });
```

--------------------------------

### Creating Motion Graphics with Lottie Animations

Source: https://github.com/packtpublishing/.net-maui-cookbook.git/blob/main/README.md

Guides on integrating Lottie animations into .NET MAUI applications for smooth, vector-based motion graphics. Requires a third-party library.

```XAML
<lottie:AnimationView Animation="{Binding AnimationName}" 
                          IsAnimationPlaying="True" 
                          Loop="True" />
```

--------------------------------

### Running the Authentication Service

Source: https://github.com/packtpublishing/.net-maui-cookbook.git/blob/main/Chapter05/c5-AuthenticationService/Readme.md

Provides instructions on how to run the ASP.NET Core authentication service project. It covers both Visual Studio and VS Code environments, including the necessary commands to start the server and access the Swagger UI.

```bash
cd c5-AuthenticationService
dotnet run --launch-profile https
```

--------------------------------

### Implementing a Custom Arranging Algorithm in .NET MAUI

Source: https://github.com/packtpublishing/.net-maui-cookbook.git/blob/main/README.md

Guides on creating custom layout containers in .NET MAUI by inheriting from Layout<T> and implementing a custom arranging algorithm. This allows for unique layout behaviors.

```C#
public class CustomLayout : Layout<View>
{
    protected override Size ArrangeChildren(Rect bounds)
    {
        // Custom arrangement logic here
        return bounds.Size;
    }
}
```

--------------------------------

### Running Web API Server (VS Code)

Source: https://github.com/packtpublishing/.net-maui-cookbook.git/blob/main/Chapter04/c4-WebApiComplete/Readme.md

Starts the Web API server using the 'https' profile in VS Code. The server typically runs on port 7197.

```bash
cd c4-WebApiServer
dotnet run --launch-profile https
```

--------------------------------

### Implementing Detail and Edit Forms

Source: https://github.com/packtpublishing/.net-maui-cookbook.git/blob/main/README.md

Guides on creating UI forms for displaying item details and editing existing data in .NET MAUI, often involving data binding to ViewModel properties.

```XAML
<VerticalStackLayout>
    <Label Text="Name:" />
    <Entry Text="{Binding Item.Name}" />
    <Label Text="Description:" />
    <Editor Text="{Binding Item.Description}" />
    <Button Text="Save" Command="{Binding SaveCommand}" />
</VerticalStackLayout>
```

--------------------------------

### Connecting to a Remote Web API Service

Source: https://github.com/packtpublishing/.net-maui-cookbook.git/blob/main/README.md

Guides on how to establish a connection and consume data from a remote Web API service using `HttpClient` in .NET MAUI applications.

```C#
public async Task<List<MyItem>> GetItemsFromApiAsync()
{
    using (var client = new HttpClient())
    {
        client.BaseAddress = new Uri("https://api.example.com/");
        var response = await client.GetAsync("items");
        response.EnsureSuccessStatusCode();
        var json = await response.Content.ReadAsStringAsync();
        var items = JsonSerializer.Deserialize<List<MyItem>>(json);
        return items;
    }
}
```

--------------------------------

### Decorator Pattern for Caching in Repository

Source: https://github.com/packtpublishing/.net-maui-cookbook.git/blob/main/Chapter04/c4-DataCaching/Readme.md

This example illustrates how to implement data caching using the decorator pattern for a repository. It shows how to wrap an existing repository with a caching layer to intercept data retrieval and storage operations.

```csharp
public interface IRepository<T>
{
    T GetById(int id);
    void Add(T entity);
    void Update(T entity);
    void Delete(int id);
}

public class CachingRepositoryDecorator<T> : IRepository<T>
{
    private readonly IRepository<T> _innerRepository;
    private readonly MemoryCacheService _cacheService;
    private readonly string _cacheKeyPrefix;

    public CachingRepositoryDecorator(IRepository<T> innerRepository, MemoryCacheService cacheService, string cacheKeyPrefix)
    {
        _innerRepository = innerRepository;
        _cacheService = cacheService;
        _cacheKeyPrefix = cacheKeyPrefix;
    }

    public T GetById(int id)
    {
        string key = $"{_cacheKeyPrefix}_{id}";
        T cachedItem = _cacheService.Get<T>(key);
        if (cachedItem != null)
        {
            return cachedItem;
        }

        T item = _innerRepository.GetById(id);
        if (item != null)
        {
            _cacheService.Set(key, item, TimeSpan.FromMinutes(5)); // Cache for 5 minutes
        }
        return item;
    }

    public void Add(T entity)
    {
        _innerRepository.Add(entity);
        // Invalidate cache or update based on strategy
        // For simplicity, we might remove related cached items or re-cache on next read
    }

    public void Update(T entity)
    {
        _innerRepository.Update(entity);
        // Invalidate cache or update based on strategy
        // Example: Remove the specific item from cache
        // _cacheService.Remove($"{_cacheKeyPrefix}_{entity.Id}"); 
    }

    public void Delete(int id)
    {
        _innerRepository.Delete(id);
        // Invalidate cache
        // _cacheService.Remove($"{_cacheKeyPrefix}_{id}");
    }
}
```

--------------------------------

### Navigate to Server Directory

Source: https://github.com/packtpublishing/.net-maui-cookbook.git/blob/main/Chapter05/c5-AuthenticationServiceAndClient/Readme.md

Changes the current directory to the server project folder.

```shell
cd c5-AuthenticationService
```

--------------------------------

### Building a Client Application Connected to the Authentication Service

Source: https://github.com/packtpublishing/.net-maui-cookbook.git/blob/main/README.md

Shows how to create a .NET MAUI client application that interacts with an ASP.NET Core authentication service for user registration, login, and token management.

```C#
public async Task<bool> LoginAsync(string email, string password)
{
    var loginModel = new { Email = email, Password = password };
    var json = JsonSerializer.Serialize(loginModel);
    var content = new StringContent(json, Encoding.UTF8, "application/json");

    using (var client = new HttpClient())
    {
        var response = await client.PostAsync("https://api.example.com/Account/Login", content);
        if (response.IsSuccessStatusCode)
        {
            var resultJson = await response.Content.ReadAsStringAsync();
            // Process token and user info
            return true;
        }
        return false;
    }
}
```

--------------------------------

### Running Ollama Model

Source: https://github.com/packtpublishing/.net-maui-cookbook.git/blob/main/Chapter06/c6-DeployedAiAssistant/Readme.md

Command to download Ollama and run the llama3.1 model. This is a prerequisite for the chat bot functionality.

```shell
ollama run llama3.1
```

--------------------------------

### Creating an AI Assistant that Enhances Text with OpenAI

Source: https://github.com/packtpublishing/.net-maui-cookbook.git/blob/main/README.md

Demonstrates how to integrate with OpenAI's API (e.g., GPT-3/4) from a .NET MAUI application to perform text enhancement, summarization, or generation tasks.

```C#
using OpenAI_API;

var client = new OpenAIAPI("YOUR_OPENAI_API_KEY");
var result = await client.Completions.CreateCompletionAsync(
    prompt: "Enhance this text: 'The quick brown fox.'",
    model: "text-davinci-003",
    max_tokens: 50
);
// Process result.ToString()
```

--------------------------------

### AsyncRelayCommand Example

Source: https://github.com/packtpublishing/.net-maui-cookbook.git/blob/main/Chapter02/c2-AsyncCommands/Readme.md

Demonstrates the usage of AsyncRelayCommand for executing asynchronous operations without blocking the UI thread. It also shows how to bind an ActivityIndicator to the command's IsRunning property.

```csharp
public class AsyncCommandViewModel : ObservableObject
{
    [ObservableProperty]
    bool isRunning;

    public AsyncRelayCommand LoadDataCommand { get; }

    public AsyncCommandViewModel()
    {
        LoadDataCommand = new AsyncRelayCommand(LoadData);
    }

    private async Task LoadData(CancellationToken cancellationToken)
    {
        IsRunning = true;
        try
        {
            // Simulate a long-running operation
            await Task.Delay(3000, cancellationToken);
            // Process data or update UI
        }
        finally
        {
            IsRunning = false;
        }
    }
}
```

--------------------------------

### Theme Selector with Picker and Singleton Pattern

Source: https://github.com/packtpublishing/.net-maui-cookbook.git/blob/main/Chapter03/c3-DarkAndLightThemes/Readme.md

Demonstrates how to create a theme selector using the Picker element and bind the current theme to the UI via the Singleton pattern. This allows users to switch between light and dark themes dynamically.

```XAML
<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             xmlns:local="clr-namespace:YourAppNamespace"
             x:Class="YourAppNamespace.ThemePage">

    <StackLayout>
        <Label Text="Select Theme:" />
        <Picker SelectedItem="{Binding CurrentTheme, Mode=TwoWay}">
            <Picker.ItemsSource>
                <x:Array Type="{x:Type x:String}">
                    <x:String>Light</x:String>
                    <x:String>Dark</x:String>
                </x:Array>
            </Picker.ItemsSource>
        </Picker>

        <Label Text="This is a themed label." AppThemeBinding="{AppThemeBinding Light=Black, Dark=White}" />
    </StackLayout>

</ContentPage>
```

```C#
public class ThemeManager
{
    private static ThemeManager instance;
    public static ThemeManager Instance => instance ?? (instance = new ThemeManager());

    public string CurrentTheme { get; set; } = "Light"; // Default theme

    private ThemeManager() { }
}

public partial class ThemePage : ContentPage
{
    public ThemePage()
    {
        InitializeComponent();
        BindingContext = ThemeManager.Instance;
    }
}
```

--------------------------------

### Implementing the Unit of Work and Repository Patterns

Source: https://github.com/packtpublishing/.net-maui-cookbook.git/blob/main/README.md

Explains how to implement the Unit of Work and Repository patterns for abstracting data access operations, improving testability and maintainability.

```C#
public interface IRepository<T> { T GetById(int id); void Add(T entity); /* ... */ }
public interface IUnitOfWork { IRepository<MyItem> Items { get; } void SaveChanges(); }

public class UnitOfWork : IUnitOfWork
{
    // Implementation using DbContext
}
```

--------------------------------

### Access Raw Assets in .NET MAUI

Source: https://github.com/packtpublishing/.net-maui-cookbook.git/blob/main/Chapter08/c8-SimplifiedItemTemplate/c8-SimplifyItemTemplate/Resources/Raw/AboutAssets.txt

This C# code snippet shows how to load and read the content of a raw asset included in the .NET MAUI application package. It uses `FileSystem.OpenAppPackageFileAsync` to get a stream to the asset and `StreamReader` to read its contents.

```C#
async Task LoadMauiAsset()
{
	using var stream = await FileSystem.OpenAppPackageFileAsync("AboutAssets.txt");
	using var reader = new StreamReader(stream);

	var contents = reader.ReadToEnd();
}
```

--------------------------------

### Implementing Device-Specific Layouts in .NET MAUI

Source: https://github.com/packtpublishing/.net-maui-cookbook.git/blob/main/README.md

Covers techniques for creating layouts that adapt to different device screen sizes and orientations in .NET MAUI. This ensures a consistent user experience across devices.

```XAML
<ContentPage.Resources>
    <Style TargetType="Label">
        <Setter Property="FontSize" Value="16" />
    </Style>
    <Style x:Key="LargeLabel" TargetType="Label">
        <Setter Property="FontSize" Value="24" />
    </Style>
</ContentPage.Resources>

<Label Text="Adaptive Text" Style="{StaticResource LargeLabel}" />
```

--------------------------------

### Access Raw Assets in .NET MAUI

Source: https://github.com/packtpublishing/.net-maui-cookbook.git/blob/main/Chapter08/c8-OptimizedImages/c8-OptimizedImages/Resources/Raw/AboutAssets.txt

This C# code snippet shows how to load and read the content of a raw asset included in the .NET MAUI application package. It uses `FileSystem.OpenAppPackageFileAsync` to get a stream to the asset and `StreamReader` to read its contents.

```C#
async Task LoadMauiAsset()
{
	using var stream = await FileSystem.OpenAppPackageFileAsync("AboutAssets.txt");
	using var reader = new StreamReader(stream);

	var contents = reader.ReadToEnd();
}
```

--------------------------------

### Implementing Dark/Light Theme Switching

Source: https://github.com/packtpublishing/.net-maui-cookbook.git/blob/main/README.md

Shows how to implement theme switching (dark mode/light mode) in .NET MAUI applications, typically by changing resource dictionaries or applying styles based on a theme setting.

```XAML
<Application.Resources>
    <ResourceDictionary>
        <Color x:Key="BackgroundColor">White</Color>
        <Color x:Key="TextColor">Black</Color>
    </ResourceDictionary>
    <ResourceDictionary Source="Resources/Styles/DarkTheme.xaml" />
</Application.Resources>

<!-- In DarkTheme.xaml -->
<ResourceDictionary>
    <Color x:Key="BackgroundColor">Black</Color>
    <Color x:Key="TextColor">White</Color>
</ResourceDictionary>
```

--------------------------------

### Access Raw Assets in .NET MAUI

Source: https://github.com/packtpublishing/.net-maui-cookbook.git/blob/main/Chapter08/c8-DebugVsRelease/c8-DebugVsRelease/Resources/Raw/AboutAssets.txt

This C# code snippet shows how to load and read the content of a raw asset included in the .NET MAUI application package. It uses `FileSystem.OpenAppPackageFileAsync` to get a stream to the asset and `StreamReader` to read its contents.

```C#
async Task LoadMauiAsset()
{
	using var stream = await FileSystem.OpenAppPackageFileAsync("AboutAssets.txt");
	using var reader = new StreamReader(stream);

	var contents = reader.ReadToEnd();
}
```

--------------------------------

### Access Raw Assets in .NET MAUI

Source: https://github.com/packtpublishing/.net-maui-cookbook.git/blob/main/Chapter08/c8-CompiledBindings/c8-CompiledBindings/Resources/Raw/AboutAssets.txt

This C# code snippet shows how to load and read the content of a raw asset included in the .NET MAUI application package. It uses `FileSystem.OpenAppPackageFileAsync` to get a stream to the asset and `StreamReader` to read its contents.

```C#
async Task LoadMauiAsset()
{
	using var stream = await FileSystem.OpenAppPackageFileAsync("AboutAssets.txt");
	using var reader = new StreamReader(stream);

	var contents = reader.ReadToEnd();
}
```

--------------------------------

### Injecting an Application Service into a ViewModel Using Dependency Injection

Source: https://github.com/packtpublishing/.net-maui-cookbook.git/blob/main/README.md

Demonstrates how to use dependency injection (DI) to provide services (e.g., data access, navigation) to ViewModels, promoting loose coupling and testability.

```C#
public class MyViewModel
{
    private readonly IMyService _myService;

    public MyViewModel(IMyService myService)
    {
        _myService = myService;
    }

    // Use _myService in methods
}
```

--------------------------------

### Access Raw Assets in .NET MAUI

Source: https://github.com/packtpublishing/.net-maui-cookbook.git/blob/main/Chapter08/c8-AsyncLoading/c8-AsyncLoading/Resources/Raw/AboutAssets.txt

This C# code snippet shows how to load and read the content of a raw asset included in the .NET MAUI application package. It uses `FileSystem.OpenAppPackageFileAsync` to get a stream to the asset and `StreamReader` to read its contents.

```C#
async Task LoadMauiAsset()
{
	using var stream = await FileSystem.OpenAppPackageFileAsync("AboutAssets.txt");
	using var reader = new StreamReader(stream);

	var contents = reader.ReadToEnd();
}
```

--------------------------------

### Implementing Auto-Generated View Models

Source: https://github.com/packtpublishing/.net-maui-cookbook.git/blob/main/README.md

Explains how to use code generation or specific frameworks to automatically create ViewModels, reducing boilerplate code. This can speed up development.

```C#
// Example using a hypothetical code generation approach
[GenerateViewModel]
public class MyDataModel
{
    public string Name { get; set; }
    public int Age { get; set; }
}
```

--------------------------------

### Access Raw Assets in .NET MAUI

Source: https://github.com/packtpublishing/.net-maui-cookbook.git/blob/main/Chapter07/c7-PlatformViewCustomization/c7-PlatformViewCustomization/Resources/Raw/AboutAssets.txt

This C# code snippet shows how to load and read the content of a raw asset included in the .NET MAUI application package. It uses `FileSystem.OpenAppPackageFileAsync` to get a stream to the asset and `StreamReader` to read its contents.

```C#
async Task LoadMauiAsset()
{
	using var stream = await FileSystem.OpenAppPackageFileAsync("AboutAssets.txt");
	using var reader = new StreamReader(stream);

	var contents = reader.ReadToEnd();
}
```

--------------------------------

### Detecting a Face on an Image with a Local ONNX Model Deployed to the Device

Source: https://github.com/packtpublishing/.net-maui-cookbook.git/blob/main/README.md

Explains how to use the ONNX Runtime library in .NET MAUI to perform machine learning inference, such as face detection, using a locally deployed ONNX model.

```C#

```

--------------------------------

### Access Raw Assets in .NET MAUI

Source: https://github.com/packtpublishing/.net-maui-cookbook.git/blob/main/Chapter07/c7-DerivedHandler/c7-DerivedHandler/Resources/Raw/AboutAssets.txt

This C# code snippet shows how to load and read the content of a raw asset included in the .NET MAUI application package. It uses `FileSystem.OpenAppPackageFileAsync` to get a stream to the asset and `StreamReader` to read its contents.

```C#
async Task LoadMauiAsset()
{
	using var stream = await FileSystem.OpenAppPackageFileAsync("AboutAssets.txt");
	using var reader = new StreamReader(stream);

	var contents = reader.ReadToEnd();
}
```

--------------------------------

### Log in to Dev Tunnel

Source: https://github.com/packtpublishing/.net-maui-cookbook.git/blob/main/Chapter05/c5-AuthenticationServiceAndClient/Readme.md

Logs the user into the Dev Tunnel service using various account types.

```shell
devtunnel user login
```

--------------------------------

### Connecting to a Local SQLite Database via Entity Framework Core

Source: https://github.com/packtpublishing/.net-maui-cookbook.git/blob/main/README.md

Provides steps to set up and connect to a local SQLite database using Entity Framework Core in a .NET MAUI application for data persistence.

```C#
public class AppDbContext : DbContext
{
    public DbSet<MyItem> Items { get; set; }

    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        var dbPath = Path.Combine(FileSystem.AppDataDirectory, "items.db");
        optionsBuilder.UseSqlite($"Filename={dbPath}");
    }
}
```

--------------------------------

### Access Raw Assets in .NET MAUI

Source: https://github.com/packtpublishing/.net-maui-cookbook.git/blob/main/Chapter07/c7-CrossPlatformApi/c7-CrossPlatformApi/Resources/Raw/AboutAssets.txt

This C# code snippet shows how to load and read the content of a raw asset included in the .NET MAUI application package. It uses `FileSystem.OpenAppPackageFileAsync` to get a stream to the asset and `StreamReader` to read its contents.

```C#
async Task LoadMauiAsset()
{
	using var stream = await FileSystem.OpenAppPackageFileAsync("AboutAssets.txt");
	using var reader = new StreamReader(stream);

	var contents = reader.ReadToEnd();
}
```

--------------------------------

### Access Raw Assets in .NET MAUI

Source: https://github.com/packtpublishing/.net-maui-cookbook.git/blob/main/Chapter07/c7-ConditionalCompilation/c7-ConditionalCompilation/Resources/Raw/AboutAssets.txt

This C# code snippet shows how to load and read the content of a raw asset included in the .NET MAUI application package. It uses `FileSystem.OpenAppPackageFileAsync` to get a stream to the asset and `StreamReader` to read its contents.

```C#
async Task LoadMauiAsset()
{
	using var stream = await FileSystem.OpenAppPackageFileAsync("AboutAssets.txt");
	using var reader = new StreamReader(stream);

	var contents = reader.ReadToEnd();
}
```

--------------------------------

### Accessing Swagger UI

Source: https://github.com/packtpublishing/.net-maui-cookbook.git/blob/main/Chapter04/c4-WebApiComplete/Readme.md

Opens the Swagger UI for the running Web API service in a browser. This allows for testing and exploring the API endpoints.

```bash
https://localhost:7197/swagger
```

--------------------------------

### Access Raw Assets in .NET MAUI

Source: https://github.com/packtpublishing/.net-maui-cookbook.git/blob/main/Chapter06/c6-SignalRConnection/c6-SignalRConnection/Resources/Raw/AboutAssets.txt

This C# code snippet shows how to load and read the content of a raw asset included in the .NET MAUI application package. It uses `FileSystem.OpenAppPackageFileAsync` to get a stream to the asset and `StreamReader` to read its contents.

```C#
async Task LoadMauiAsset()
{
	using var stream = await FileSystem.OpenAppPackageFileAsync("AboutAssets.txt");
	using var reader = new StreamReader(stream);

	var contents = reader.ReadToEnd();
}
```

--------------------------------

### Include Raw Assets in .NET MAUI Project

Source: https://github.com/packtpublishing/.net-maui-cookbook.git/blob/main/Chapter06/c6-OpenAITextAssistant/c6-OpenAITextAssistant/Resources/Raw/AboutAssets.txt

This XML snippet demonstrates how to configure the `.csproj` file to include raw assets. The `MauiAsset` build action ensures that files in the specified directory are deployed with the application package. The `LogicalName` property preserves the directory structure.

```XML
<MauiAsset Include="Resources\Raw\**" LogicalName="%(RecursiveDir)%(Filename)%(Extension)" />
```

--------------------------------

### Access Raw Assets in .NET MAUI

Source: https://github.com/packtpublishing/.net-maui-cookbook.git/blob/main/Chapter06/c6-OpenAITextAssistant/c6-OpenAITextAssistant/Resources/Raw/AboutAssets.txt

This C# code snippet shows how to load and read the content of a raw asset included in the .NET MAUI application package. It uses `FileSystem.OpenAppPackageFileAsync` to get a stream to the asset and `StreamReader` to read its contents.

```C#
async Task LoadMauiAsset()
{
	using var stream = await FileSystem.OpenAppPackageFileAsync("AboutAssets.txt");
	using var reader = new StreamReader(stream);

	var contents = reader.ReadToEnd();
}
```

--------------------------------

### Include Raw Assets in .NET MAUI Project

Source: https://github.com/packtpublishing/.net-maui-cookbook.git/blob/main/Chapter07/c7-PlatformViewCustomization/c7-PlatformViewCustomization/Resources/Raw/AboutAssets.txt

This XML snippet demonstrates how to configure the `.csproj` file to include raw assets. The `MauiAsset` build action ensures that files in the specified directory are deployed with the application package. The `LogicalName` property preserves the directory structure.

```XML
<MauiAsset Include="Resources\Raw\**" LogicalName="%(RecursiveDir)%(Filename)%(Extension)" />
```

--------------------------------

### Access Raw Assets in .NET MAUI

Source: https://github.com/packtpublishing/.net-maui-cookbook.git/blob/main/Chapter06/c6-OfflineDataSync/c6-OfflineDataSyncClient/Resources/Raw/AboutAssets.txt

This C# code snippet shows how to load and read the content of a raw asset included in the .NET MAUI application package. It uses `FileSystem.OpenAppPackageFileAsync` to get a stream to the asset and `StreamReader` to read its contents.

```C#
async Task LoadMauiAsset()
{
	using var stream = await FileSystem.OpenAppPackageFileAsync("AboutAssets.txt");
	using var reader = new StreamReader(stream);

	var contents = reader.ReadToEnd();
}
```

--------------------------------

### Access Raw Assets using Essentials

Source: https://github.com/packtpublishing/.net-maui-cookbook.git/blob/main/Chapter03/c3-LottieAnimations/c3-LottieAnimations/Resources/Raw/AboutAssets.txt

This C# code snippet shows how to load and read the contents of a raw asset included in your .NET MAUI application. It uses `FileSystem.OpenAppPackageFileAsync` to get a stream to the asset, which is then read using a `StreamReader`. Ensure the asset file name matches the one provided to `OpenAppPackageFileAsync`.

```C#
async Task LoadMauiAsset() {
		using var stream = await FileSystem.OpenAppPackageFileAsync("AboutAssets.txt");
		using var reader = new StreamReader(stream);

		var contents = reader.ReadToEnd();
	}
```

--------------------------------

### Access Raw Assets in .NET MAUI

Source: https://github.com/packtpublishing/.net-maui-cookbook.git/blob/main/Chapter06/c6-LocalNotifications/c6LocalNotifications/Resources/Raw/AboutAssets.txt

This C# code snippet shows how to load and read the content of a raw asset included in the .NET MAUI application package. It uses `FileSystem.OpenAppPackageFileAsync` to get a stream to the asset and `StreamReader` to read its contents.

```C#
async Task LoadMauiAsset()
{
	using var stream = await FileSystem.OpenAppPackageFileAsync("AboutAssets.txt");
	using var reader = new StreamReader(stream);

	var contents = reader.ReadToEnd();
}
```

--------------------------------

### Access Raw Assets in .NET MAUI

Source: https://github.com/packtpublishing/.net-maui-cookbook.git/blob/main/Chapter06/c6-FileUploading/c6-FileUploadingClient/Resources/Raw/AboutAssets.txt

This C# code snippet shows how to load and read the content of a raw asset included in the .NET MAUI application package. It uses `FileSystem.OpenAppPackageFileAsync` to get a stream to the asset and `StreamReader` to read its contents.

```C#
async Task LoadMauiAsset()
{
	using var stream = await FileSystem.OpenAppPackageFileAsync("AboutAssets.txt");
	using var reader = new StreamReader(stream);

	var contents = reader.ReadToEnd();
}
```

--------------------------------

### Include Raw Assets in .NET MAUI Project

Source: https://github.com/packtpublishing/.net-maui-cookbook.git/blob/main/Chapter03/c3-ThemedImagesAndStatusBar/c3-ThemedImagesAndStatusBar/Resources/Raw/AboutAssets.txt

This XML snippet demonstrates how to configure your .NET MAUI project to include raw assets. The `MauiAsset` build action ensures that files in the specified directory (and its subdirectories) are deployed with the application. The `LogicalName` property ensures the file is accessible with its original path structure.

```XML
<MauiAsset Include="Resources\Raw\**" LogicalName="%(RecursiveDir)%(Filename)%(Extension)" />
```

--------------------------------

### Access Raw Assets in .NET MAUI

Source: https://github.com/packtpublishing/.net-maui-cookbook.git/blob/main/Chapter06/c6-DeployedAiAssistant/c6-AiAssistantClient/Resources/Raw/AboutAssets.txt

This C# code snippet shows how to load and read the content of a raw asset included in the .NET MAUI application package. It uses `FileSystem.OpenAppPackageFileAsync` to get a stream to the asset and `StreamReader` to read its contents.

```C#
async Task LoadMauiAsset()
{
	using var stream = await FileSystem.OpenAppPackageFileAsync("AboutAssets.txt");
	using var reader = new StreamReader(stream);

	var contents = reader.ReadToEnd();
}
```

--------------------------------

### Include Raw Assets in .NET MAUI Project

Source: https://github.com/packtpublishing/.net-maui-cookbook.git/blob/main/Chapter05/c5-AuthenticationServiceAndClient/c5-AuthenticationClient/Resources/Raw/AboutAssets.txt

This XML snippet demonstrates how to configure the `.csproj` file to include raw assets. The `MauiAsset` build action ensures that files in the specified directory are deployed with the application package. The `LogicalName` property preserves the directory structure.

```XML
<MauiAsset Include="Resources\Raw\**" LogicalName="%(RecursiveDir)%(Filename)%(Extension)" />
```

--------------------------------

### Access Raw Assets in .NET MAUI

Source: https://github.com/packtpublishing/.net-maui-cookbook.git/blob/main/Chapter06/c6-AIFaceDetection/c6-AIFaceDetection/Resources/Raw/AboutAssets.txt

This C# code snippet shows how to load and read the content of a raw asset included in the .NET MAUI application package. It uses `FileSystem.OpenAppPackageFileAsync` to get a stream to the asset and `StreamReader` to read its contents.

```C#
async Task LoadMauiAsset()
{
	using var stream = await FileSystem.OpenAppPackageFileAsync("AboutAssets.txt");
	using var reader = new StreamReader(stream);

	var contents = reader.ReadToEnd();
}
```