CodeCompiled

C#,.NET and Azure insights for developers

ashish

Getting Started with .NET MAUI on macOS

by Leave a Comment

.NET MAUI framework for cross platform development

.NET Multi-platform App UI commonly known as MAUI ,is a cross platform framework that allows developers to create applications which run on multiple operating systems and uses the same codebase across the platforms. Since it supports Android, iOS, macOS, and Windows, this makes it a powerful app development framework for building applications. With MAUI, you can leverage the .NET ecosystem and C# to develop native applications.

Differences between .NET MAUI on Windows and macOS

While .NET MAUI is designed to provide a unified development experience, there are some differences between its implementations on Windows and macOS:

  1. Windows-Specific Features  While in Windows, MAUI uses the Windows UI Library (WinUI) for rendering, on macOS, it uses Mac Catalyst to bridge iOS and macOS development.
  2. Development Environment While Windows users can use Visual Studio 2022 with full debugging and hot reload support, macOS users require command line and VS Code,   as VS for mac has been discontinued by Microsoft.
  3. Device Emulation  While Android emulators are available on both Windows and macOS, but for iOS development a Mac system is required.
  4. Native API Integration  macOS apps can integrate with Apple’s APIs via Mac Catalyst, whereas Windows applications rely on Windows-specific APIs.

Even though there are these differences across the platforms, most of the MAUI application logic remains unchanged across platforms.

Installing .NET MAUI on macOS

You can use these steps to install and set up .NET MAUI on a Mac:

1. Install Homebrew (if not already installed)

Homebrew is a package manager for macOS that simplifies software installation. Open the Terminal and run:

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

2. Install .NET SDK

Download and install the latest .NET SDK (at least .NET 8) from Microsoft’s official site. You can also install it via Homebrew:

brew install dotnet

3. Install Xcode and Command Line Tools

Since MAUI requires Xcode for macOS and iOS development, install it from the Mac App Store or via the command line:

xcode-select --install

After installation, agree to the license:

sudo xcodebuild -license accept

4. Install MAUI Workload

Once .NET SDK is installed, install the MAUI workload using the following command:

dotnet workload install maui

5. Verify the Installation

Run the following command to ensure everything is set up correctly:

dotnet --list-sdks
dotnet workload list

At this step you should be able to see .NET MAUI listed among the installed workloads.

6. Set Up an IDE (Visual Studio Code or JetBrains Rider)

Since Visual Studio for Mac is discontinued, you can use Visual Studio Code with the C# Dev Kit extension or JetBrains Rider as alternatives.

  • Download VS Code from here.
  • Install the C# extension from the marketplace.

7. Create and Run a .NET MAUI Project

Now, create a new MAUI project using the terminal:

dotnet new maui -n MyMauiApp
cd MyMauiApp
dotnet build
dotnet run

This will build and launch your .NET MAUI application on macOS.

.NET MAUI allows both windows and mac developers to build cross platform apps using C# and .NET. While there are some differences in how MAUI runs on Windows vs. macOS, the core development experience remains same.

Follow on:Facebooktwitter

Exploring .NET MAUI for Cross-Platform Development

by Leave a Comment

Overview

Often developers use different technologies when developing apps for different platforms. Also developing apps which work across multiple platforms is quite challenging. Whether its handling different UI frameworks, managing separate codebases, or dealing with platform-specific quirks, developers often find themselves go through a painful and time consuming process. Assume if you could write your code once and run it on different platforms from Windows, macOS, iOS, to Android.That’s possible with .NET MAUI .

What is .NET MAUI?

.NET MAUI  stands for Multi-platform App UI.It is Microsoft’s evolution of Xamarin.Forms and is designed to provide a single codebase for creating cross-platform applications. It enables developers to build native apps using C# and .NET while sharing UI and business logic across platforms. It is a unified framework that abstracts the complexities of platform-specific development.

For .NET developers is one of the alternatives for developing cross platform apps. It integrates tightly with .NET 8 and beyond, supports hot reload for faster development, and leverages MVU (Model-View-Update) architecture as well as the traditional MVVM architecture. If you have some experience working with Xamarin or WPF, you will find familiarity working with MAUI.

Some of the important features of  MAUI

  • Single Codebase: Write once, run on multiple platforms.
  • Native Performance: Unlike web-based cross-platform solutions, MAUI apps run natively.
  • Unified UI and Logic: No need to maintain separate UI implementations for each platform.
  • Seamless Integration with .NET: Leverage existing .NET libraries and tooling.
  • Future-Proof: Microsoft is actively investing in MAUI, making it the future of cross-platform development in the .NET ecosystem.

Use cases of .NET MAUI

Here are some of the use cases:

  • Enterprise Apps: Internal business applications that need to run on multiple devices.
  • E-commerce & Retail: Shopping apps with consistent experiences on mobile and desktop.
  • Healthcare & Telemedicine: Cross-platform apps for patient management and virtual consultations.
  • IoT & Smart Devices: Apps that interact with hardware across different platforms.
  • Gaming & Media: Lightweight interactive applications with native performance.

How Does .NET MAUI Work?

.NET MAUI simplifies cross-platform development by unifying UI and application logic under a single project structure. Here’s a high-level overview of how it works:

  1. Single Project Structure: Unlike Xamarin, which required separate projects for different platforms, MAUI consolidates everything into a single project. Platform-specific tweaks are still possible but kept minimal.
  2. Cross-Platform UI with Handlers: MAUI introduces “Handlers” instead of the old “Renderers” from Xamarin.Forms. Handlers map UI controls directly to native elements, resulting in better performance and flexibility.
  3. Shared Business Logic: The app logic is written once using C# and .NET and shared across all platforms.
  4. Native Access: While MAUI abstracts platform differences, it still allows developers to write platform-specific code when needed using dependency services and partial classes.
  5. Hot Reload & Live Preview: Developers can see changes instantly without recompiling the entire app, speeding up development.
  6. Blazor Hybrid: MAUI supports Blazor, allowing developers to reuse web UI components inside a native app—great for those already working with Razor and .NET web development.

So as we have looked into some of the features of .NET MAUI , it is a powerful toolkit which brings the enables cross-platform development for .NET developers.

Microsoft’s official documentation and GitHub repositories have excellent resources. for getting started with MAUI.

Follow on:Facebooktwitter

Getting started with Machine Learning using ML.NET

by Leave a Comment

Machine Learning for .NET Developers

What Is Machine Learning?

You might have some basic idea about Machine Learning. Machine learning (ML) is a sub field of artificial intelligence (AI). In Machine Learning  software is able to learn from data without being explicitly programmed. Rather than writing code for every possible scenario, you give the machine data, and allow it to find patterns in that data. A common example of ML is Netflix recommendations system which displays shows you might watch next or the email spam filters.

At its core, Machine Learning is the process of training a model that makes predictions or decisions. Once trained, this model can be deployed to solve real-world problems like image recognition, fraud detection or weather forecasting.

Machine Learning Options in Microsoft’s Ecosystem

For Machine learning, Microsoft offers a rich ecosystem. You might have hear dof Azure Machine Learning, which is Azure based platform for building, deploying, and managing ML models. Azure also provides Cognitive Services, which is a suite of prebuilt APIs for tasks like language understanding, vision, and speech. Azure Machine Learning require Python skills or deep knowledge of data science.

ML.NET is a open source framework designed specifically for .NET developers who want to integrate ML into their applications using the C# and F#. There’s not that steep learning curve for .NET developers compared to other platforms.

Why ML.NET Matters for .NET Developers

As .NET developers we don’t need to learn and use programming languages such as Python or use new libraries. ML.NET is fully integrated into the .NET ecosystem, which means we can work seamlessly with our existing tools, projects, and codebases.

ML.NET is a production-ready framework used by companies to solve real-world problems. ML.NET  can be used for different Machine Learning tasks such as recommendation systems, detecting anomalies, or adding sentiment analysis.

Key Features of ML.NET

Here are some of the important features of ML.NET:

  • AutoML: Automatically finds the best ML model for your data with minimal effort.
  • Custom ML Models: Build models tailored to your business needs.
  • Cross-Platform: Works on Windows, Linux, and macOS.
  • Integration with .NET: Use your favorite .NET languages like C# or F#.
  • ONNX Support: Load and run pre-trained models from other ML frameworks like TensorFlow.
  • Data Processing: Includes tools for data transformation, feature engineering, and normalization.
  • Scalability: Deploy models to cloud, on-premises, or even IoT devices.

Real-World Use Cases

ML.NET allows .NET developers to implement various machine learning tasks in our applications. Here are some practical use cases:

  • Sentiment Analysis: Determine whether customer feedback is positive, negative, or neutral.
  • Fraud Detection: Identify suspicious transactions in financial systems.
  • Recommendation Systems: Suggest products or content to users based on their preferences.
  • Anomaly Detection: Monitor system performance and detect unusual behaviors.
  • Image Classification: Classify images for tasks like quality control or facial recognition.
  • Predictive Maintenance: Anticipate equipment failures before they happen.

How ML.NET Works

ML.NET has a pipeline-based architecture.This mean we need to stack components like data loading, transformations, and algorithms to create a workflow. This makes it simple to use and is yet powerful to create real world applications.

  • NuGet Packages:  For integrating ML.NET functionality in our application we Start with Microsoft.ML for the core library. For deep learning we can add Microsoft.ML.TensorFlow or Microsoft.ML.OnnxRuntime.
  • Model Builder: This is a visual tool inside Visual Studio which walks you through building ML models step by step even without writing any code.
  • CLI:  Finally if you prefer command line the you can use ML.NET CLI for generating the code quickly.

Now let’s look into the workflow we need to use while working with ML.NET

  1. Load Data: You start by loading your dataset, which can come from a file, a database, or even an in-memory collection.
  2. Define a Pipeline: This is where you specify data transformations (like normalizing values) and the type of ML task (e.g., classification or regression).
  3. Train the Model: ML.NET takes your data and pipeline, then trains a model by finding patterns in the data.
  4. Evaluate the Model: Before deploying, you evaluate the model’s accuracy using metrics like precision, recall, or mean squared error.
  5. Make Predictions: Once trained and tested, the model is ready to make predictions on new, unseen data.
  6. Deploy: Finally, you integrate the trained model into your application and deploy it to production.

As you can realize ML.NET abstracts much of the complexity allowing us to focus on solving problems rather than directly work with ML algorithms.

So as we have seen with ML.NET, we can leverage our existing .NET skills to build intelligent ML applications.

Follow on:Facebooktwitter

Considering time zones in DateTime in c#

by Leave a Comment

Understanding DateTime in C#

The DateTime type in C# is used for working with dates and times. It represents an instant in time used for tasks such as logging events, scheduling tasks, or measuring durations. For instance:

DateTime now = DateTime.Now;
Console.WriteLine($"Current Date and Time: {now}");

In this example we are retrieving the current date and time on the system running the code.We can use DateTime for formatting, comparisons, or arithmetic operations.

Considering Time Zones in DateTime

While  using DateTime in real-world applications we may require considering the user’s time zone to ensure accurate scheduling, communication, or logging. For example, if you’re building an international application, the server may use UTC, but you’ll need to display the local time for your users. Ignoring time zones can lead to wrong datetime values.

Handling Time Zones in C#

To consider time zones, you can use the TimeZoneInfo class, which provides methods for conversions:

  DateTime utcNow = DateTime.UtcNow;

TimeZoneInfo localZone = TimeZoneInfo.Local;
DateTime localTime = TimeZoneInfo.ConvertTimeFromUtc(utcNow, localZone);
Console.WriteLine($"UTC Time: {utcNow}");
Console.WriteLine($"Local Time: {localTime}");

Here, DateTime.UtcNow retrieves the current time in UTC, while TimeZoneInfo.Local adjusts it to the user’s machine time zone.

By combining DateTime and TimeZoneInfo, we can handle time zone-sensitive scenarios, ensuring that our application delivers accurate and user-friendly results.

Follow on:Facebooktwitter

Filed Under: C#

Finding matching elements in two lists in C#

by Leave a Comment

As.NET developers, often we work with data from various sources. Suppose you are working on some HR application where you have some employee IDs within your database list and employee information coming through some API. Now you want to find out whether data from this API contains some of the employees in your database or not. In such a scenario we need to combine data from multiple sources.

Matching Elements in Two Lists in C#

To implement this, we can loop through the list of employees and check if any employee’s `Id` is matching with any of the IDs in the list of Ids We can convert the string list into a set for fast lookups: If found – return the corresponding Employee object; otherwise return null.


public class Employee
{
public string FirstName { get; set; }
public string LastName { get; set; }
public int Id { get; set; }
}

//Search Employee by Id in a list
public class FindEmployee
{
public static Employee? FindMatchingEmployee(List<string> listOfEmployeeIds, List<Employee> listOfEmployees)
{
// Convert string list to a HashSet for faster lookups
HashSet<int> employeeIdsSet = listOfEmployeeIds.Select(id => int.Parse(id)).ToHashSet();

// Iterate through the employee list
foreach (var employee in listOfEmployees)
{
if (employeeIdsSet.Contains(employee.Id))
{
return employee; // Return the matching employee
}
}

return null; // Return null if not found
}
}

 

Following is the above implementation step by step:

1. Define the Employee Class: The Employee class has three properties: FirstName,LastName, and Id. These represent the details of each employee.
2. Convert the String List to a HashSet: The list of employee IDs (as strings) is converted to a HashSet<int> after parsing each string to an integer. The HashSet provides faster lookup times for comparison.
3. Iterate Through the Employees: Loop through each Employee object in the listOfEmployees to check if its Id is present in the HashSet of IDs.
4. Return the Result:
If a match is found, return the Employee object.
If no match is found after the loop, return null
5. Usage of the Method: Call this method by passing `listOfEmployeeIds` and `listOfEmployees` to find a matching employee or confirm that no matches exist.

This approach ensures readability and efficiency, making it suitable for scenarios where performance and clarity are both essential.


Follow on:Facebooktwitter
Filed Under: C#