net6 Archives - XABLU

5 things for .NET MAUI devs to look forward to in 2022

Sebastián Pérez — Tue, 28 Dec 2021 16:21:49 +0000

The year 2021 has brought us a lot of news related to .NET 6. However, we are going to highlight some milestones that must be taken into account for next year:

1. .NET MAUI release: This year we had a working preview of .NET MAUI and a lot of announcements. However, we will have the release of this long-awaited framework for mobile cross-platform development by the middle of next year. If you can’t wait, stay tuned because a release candidate will be out very soon

2. Visual Studio 2022 for Mac: This tool, which was once known as Xamarin Studio, is used by developers who use MacOS environments. For this version 2022 a new version was created using native components to achieve an improvement in performance. The bad news are that we don’t have currently a stable version, but we will soon in 2022. If you want to try, you can find a preview version that can be downloaded here.

3. C#11: Although there is no official announcement of what will come in the next version of this programming language, some issues have already appeared in the Github repository that give us some clues. For example, the keyword field and list patterns, features that were left out of version 10. When ? Probably at .NET 7 release.

4. Microsoft Build 2022: Starting in Q2 2022 we will find Microsoft’s most important developer-oriented event: Microsoft Build. This event, that used to be face-to-face, adopted full-remote in recent years due to the pandemic and although there is no official announcement of the event, we can imagine that it will continue in the same way. In this event the releases roadmap is usually announced for the rest of the year, will it be the chance to see the stable version of .NET MAUI?

5. .NET 7 release: Although .NET 6 is a long support version, the roadmap for this technology tells us that in 2022 we will have version 7 available. This version will be very important for the integration of .NET MAUI, since it will be the first version that supports it from the beginning. When ? November 2022, and as expected a new edition of the .NET Conf will accompany this release.

What are you looking forward the most? I definitely vote .NET MAUI release !

On behalf of the Xablu team, we wish you a great 2022!

The post 5 things for .NET MAUI devs to look forward to in 2022 appeared first on XABLU.

.NET Conf 2021: 5 videos you have to see

Sebastián Pérez — Thu, 18 Nov 2021 04:22:01 +0000

The new version of .NET was released and the best place to present it is the most important conference that this platform has: .NET Conf. The conference was held over 3 days and had more than 100 speakers from around the world. And as I mentioned in the last post, I had the honor of being as a speaker

The conference had several topics of interest related to the launch of .NET 6 of which I will recommend 5 videos you have to see:

Keynote: General overview on what’s new including some very interesting metrics.

2. What’s new on C#: Details on this new version of the most used language in .NET.

3. .NET Hot Reload: Something familiar to Xamarin developers now applied to .NET.

4. Minimal API: Don’t forget to read this post before !

5. Creating NFT with .NET: My talk about implementing NFT on blockchain using .NET

You can see more videos on .NET playlist: dotNET – YouTube

Unlike the previous version (.NET 5) this new version shows a remarkable level of improvement and stability. I’m really excited about the idea of starting to develop with this platform. What do you think? Are you excited?

The post .NET Conf 2021: 5 videos you have to see appeared first on XABLU.

.NET Conf 2021 is coming

Sebastián Pérez — Tue, 09 Nov 2021 16:58:32 +0000

As every year there will be a new edition of the most important .NET conference in the world: .NET Conf. This year will feature two tasty ingredients: the release of .NET 6 and … my first participation in the event

The conference will be held from November 9th to 11th and will focus mainly on what is new that introduces .NET 6. Also, it will introduce Visual Studio 2022 that has been recently released and we can see some news about .NET MAUI (preview 10). If you want to know more about the topics that will be presented I invite you to read these posts:

You can follow all the news of the event in the following link: .NET Conf 2021 (dotnetconf.net)

Finally, I invite you to be part of my presentation on “Creating NFT with .NET” next Thursday 11th at 6 am (PT) / 10 am (ARG) / 2 pm (NT). See you there !

The post .NET Conf 2021 is coming appeared first on XABLU.

.NET MAUI: Implementing platform behavior

Ruud Kobes — Fri, 17 Sep 2021 15:16:07 +0000

.NET MAUI is right around the corner. Like its predecessor it offers sharing most code while building for multiple platforms. This includes the UI part. Of course there are still elements that require access to the platform, like accessing the camera, or something less common like customizing HttpMessageHandler behavior on iOS.

For common use-cases Xamarin.Essentials was offered to Xamarin Forms users. Now with MAUI this library will be included in your application by default (named MAUI Essentials), making it easy to use SecureStorage or implement permissions on Android and iOS. Additionally there is a MAUI Community Toolkit which, as the name implies, provides free tools: effects, converters, controls and more.

Manual platform implementation

In some apps .NET MAUI with the Essentials pack and the Xamarin Community Toolkit can be sufficient. For most apps though, there is a point where some custom adjustment is necessary. A good example would be control adjustment using Handlers or Effects. We’ll describe Handlers and their value in more detail in a future blogpost.

There are several ways to go about defining platform specific behavior in MAUI. Because of multi-targeting the code will be in the single shared project. With Xamarin Forms this was also possible using the Shared Project architecture, but the recommended and most common approach was using a PCL and implementing platform behavior using dependency injection. Let’s run through some options!

Using #if

To add a few lines of platform-specific code to an otherwise shared class we can use compiler directives like #if __IOS__. This is a quick and easy solution and keeps the related code close together, in the same file. For smaller handler mappings this could be a nice and easy to manage approach. It could also make Effects easier, because we don’t need the routed effects and DI registration of every platform implementation. With larger sections of platform-specific code this can get messy and harder to read though.

				
					//SecureSettingsProvider.cs

namespace MyApp.Settings;

public class SecureSettingsProvider
{
    public string GetSecureSetting(string context, string key)
    {
        return GetLocalSetting($"{context}-{key}");
    }

    private string GetLocalSetting(string contextSpecificKey)
    {
        #if __IOS__
        // retrieve value from secure storage / keychain
        #elif __ANDROID__
        // do the same for android
        #endif
    }
}

Using platform folders

MAUI projects using the single project structure will provide platform folders out-of-the-box. They will be compiled conditionally by default, e.g. the Android folder will only be included when building for Android. Within this option there are still 2 distinctive approaches:

Dependency injection using interfaces

Like the old-school Xamarin Forms pattern, using an interface in the cross-platform code, and explicit implementations in each platform folder. Any logic that could be shared will have to be copied between the implementations, although to make it slightly more complex, one could also define a cross-platform base class.

Partial classes

Partial classes are not a new concept in C#. Check the docs if you want to read more about them. We can define one cross-plaform partial class and another partial class with the same name and namespace in each platform folder. This is a pretty clean alternative to using #if directives when working with larger classes/code sections. A potential disadvantage of this approach is that both partial classes live quite far-away from each other, which could hinder discoverability and increase cognitive load, if there is a lot of shared code. If the partial class has little shared code, the experience is a lot like using interfaces.

				
					//SecureSettingsProvider.cs in shared code

namespace MyApp.Settings;
public partial class SecureSettingsProvider.cs
{
    public string GetSecureSetting(string context, string key)
    {
        var settingValue = GetLocalSetting($"{context}-{key}");

        // do some work that's shared between implementations
        if(String.IsNullOrEmtpy(something))
          return "nothing";
        else
          return settingValue;
    }
}

				
					//SecureSettingsProvider.cs in Android platform folder

namespace MyApp.Settings;
public partial class SecureSettingsProvider.cs
{
    private string GetLocalSetting(string contextSpecificKey)
    {
        // retrieve secure setting value for Android
    }
}

Using filename based conditional compiling

This pattern is used in the MAUI github repository itself. Concretely this again means using partial classes, but this time the platform specific implementation is defined in the same folder in a separate file. For example for our SecureSettingsProvider, we would have a partial class in SecureSettingsProvider.cs and another one in SecureSettingsProvider.Android.cs, SecureSettingsProvider.iOS.cs , etc.
A potential advantage of this is that platform implementations are directly next to the shared part, which improves discoverability and can reduce cognitive load.

This approach is not supported out of the box though. The compiler needs to be informed which files to include or more accurately, which NOT to include, so we need to add this information to our project file. For an example of how this could look, see the first +-30 lines in MultiTargeting.targets file in the MAUI repository. The following sample is taken from line 2-7 there and slightly adjusted:

				
					<ItemGroup Condition="$(TargetFramework.StartsWith('Xamarin.iOS')) != true AND $(TargetFramework.StartsWith('net6.0-ios')) != true AND $(TargetFramework.StartsWith('net6.0-maccatalyst')) != true ">
  <Compile Remove="**\**\*.iOS.cs" />
  <None Include="**\**\*.iOS.cs" Exclude="$(DefaultItemExcludes);$(DefaultExcludesInProjectFolder)" />
</ItemGroup>

This ItemGroup definition informs the compiler to ignore all *.iOS.cs files in the project unless the current build target is Xamarin.iOS, net6.0-ios or .net6.0-maccatalyst. Similar project configuration can also be used to allow for custom platform folders thoughout the code:

				
					  <Compile Remove="**\iOS\**\*.cs" />
  <None Include="**\iOS\**\*.cs" Exclude="$(DefaultItemExcludes);$(DefaultExcludesInProjectFolder)" />

Which option is best?

As always in software development, the answer here is “it depends”. For multitargeting libraries, like MAUI itself, it is likely a good option to look at the the filename or nested folder approach we discussed. With a little project setup this allows you to group code by functionality, keeping related code close together.

For apps, it depends on how much platform-specific code really needs to be written. For some apps only a few adjustments may be needed using Effects, Behaviors and handler mappings. It is very possible for these to be only a few lines which allows for keeping everying in one file using #if directives. If these grow it is convenient to use the existing platform folders. In both these alternatives you can forego the need to use interfaces and register the platform services for dependency injection which can be convenient.

Please note that we’ve been looking at these patterns fairly strictly from MAUI perspective. Of course it is possible that you prefer to use interfaces to making testing and mocking easier. In that case you will be setting up the DI container anyway. It may still be easier to register one implementation and use above options, instead of registering every platform service separately, but keep in mind your overall architecture before choosing any of these patterns.

The post .NET MAUI: Implementing platform behavior appeared first on XABLU.