DEV Community: James Montemagno

An Introduction to the World of Containers with .NET 8

James Montemagno — Fri, 16 Feb 2024 19:19:47 +0000

Containers are a popular way of packaging and distributing applications in today’s Cloud Native landscape – but what are they, and how can .NET developers integrate them into their workflows? Today, let's talk about what containers are, how they relate to Docker, and how the .NET tooling makes it easy for developers to easily streamline the process of creating containers with .NET.

Containers with .NET For Beginners

Follow along with this blog and our new Beginner's series on containers and Docker for .NET.

What are Containers?

A container is a standard unit of software that packages up code and all its dependencies. It allows applications to run consistently across different computing environments. You'll find containers supported by all major cloud providers with various ways to run your containers, ranging from serverless options to fully managed Kubernetes services.

Containers provide a flexible choice for application packaging, making it a valuable skill to master. That's why .NET invests in making containers easy to use for developers.

The Benefits of Containers

So why should you use containers? The answer lies in a uniform deployment and uniform execution of applications. Containers make the job of maintaining and operating your services much easier in the long term. In addition, the whole world of automated DevOps, tooling, alerting, and monitoring can be integrated into your solution.

Developer Setup

The first step is to install the .NET SDK. You can use the .NET CLI to create containers which by default creates Linux containers. You can create these containers on any operating system; Windows, Mac, Linux, or the Windows Subsystem for Linux. The choice is yours however you enjoy developing. Additionally, having Docker Desktop installed will enable you to run your containers after you create them with the .NET SDK.

Making Containers with .NET

Now, let's take a look at just how easy it can be to create containers with .NET. To start, let's first create a new web app with the following .NET CLI command:



dotnet new web -o container-webapp

Then we can navigate to the new directory that it was created in:



cd container-webapp

You can now run the application locally with dotnet run, but let's go ahead and create a container by publishing the app with the following command:



dotnet publish -t:PublishContainer

By running a single command, you can create a container of your web app. This is the same publish command you're already familiar with for publishing your web application, but now it's being used for containerization. The .NET SDK will provide you with information about the container it just created, such as the container name, the tag, and the base image it chose.

Speaking of the base image, it's like the operating system and software configuration that your application will be deployed onto. In this example, as a web app targeting .NET 8, the SDK chose an ASP.NET image from Microsoft with the 8.0 tag. You will see output from the command similar to the following that highlights this:



Building image 'conainer-webapp' with tag 'latest' on top of the base image 'mcr.microsoft.com/dotnet/aspnet:8.0'.
Pushed image 'conainer-webapp:latest' to local registry via 'docker'.

To get a closer look at the image we just built, we can use Docker Desktop. It's fascinating to see how the image is composed of different layers, each representing a portion of the file system or a change to the operating environment. These layers come together to create a runnable container.

Let's run the container with a docker run command that specifies the container name:



docker run -P container-webapp

Optionally, we could run the container directly from Docker Desktop instead of using the command. If we open Docker Desktop, we can access our running application by clicking on the port link next to our container:

And there you have it, a browser will open up with our new web app running in a container!

Next Steps: Deep Dive into Tooling & Publishing to the cloud

That wraps up our quick taste of containers and how .NET makes it easy to get started with them. This is only the first step, and I have a full beginner's series that dives deeper into the tooling experiences available on the command line as well as in Visual Studio and Visual Studio Code. Then I go into how you can take your containers and publish them to container registries. In addition, we have full training on Microsoft Learn for containers, microservices, and cloud-native development with .NET that I highly recommend you checkout.

Thanks for joining me on this quick introduction to containers with .NET.

AI-assisted content. This article was partially created with the help of AI. An author reviewed and revised the content as needed.

Leveraging Existing Web Content to Build Hybrid Apps with .NET MAUI

James Montemagno — Fri, 04 Aug 2023 16:20:55 +0000

Are you a web developer intrigued by the idea of building native mobile & desktop applications? If you've been developing with Angular, React, or even just HTML and JavaScript, there's good news for you! In this post, we'll explore how you can leverage your existing web content to build native iOS, Android, Mac, and Windows apps using .NET MAUI and the experimental HybridWebView.

Why Reuse Web Content?

Imagine being able to reuse all the goodness you've created with your chosen web frameworks in your native mobile apps. By leveraging your existing web development skills, you can save time and effort by not starting from scratch with native mobile development. Plus, you can bring the power of your web components, designs, and functionality to the native world.

Additionally, building native apps with .NET MAUI enables you to access native APIs and controls, giving you the best of both worlds. You can mix and match UI components, create a seamless user experience, and even access platform-specific features. The possibilities are practically endless.

Introducing .NET MAUI

.NET MAUI is a powerful framework that builds on top of .NET for iOS, Android, Mac, and Windows (WinUI3), allowing you to create native apps with a unified API. I provides a single robust framework to make cross-platform app development easier than ever before.

Out of the box, .NET MAUI enables you to use C# and XAML to build native UIs from shared code and access the underlying native APIs from C#. You have the flexibility to create apps that run on multiple platforms without sacrificing the performance and user experience provided by native controls and APIs.

Building Hybrid Apps with Blazor Hybrid

If you're a Blazor developer, you're in luck! Blazor developers can easily reuse their Blazor components between their web applications and .NET MAUI applications. This powerful capability is included "in the box" which allows you to blend native and web UI components seamlessly.

You can mix Blazor and native controls to create a unified and consistent user interface. This means you can build your UIs once and use them across different platforms, reducing development effort and ensuring a consistent user experience. The hybrid web view experiment offers great potential for Blazor developers looking to extend their apps to the native mobile world.

Building Hybrid Apps with HTML, JavaScript, Angular, or React

.NET MAUI doesn't limit you to just Blazor. You can also leverage your skills in HTML, JavaScript, Angular, or React to build hybrid apps with .NET Maui. This is made possible by the introduction of the experimental HybridWebView, which enables you to incorporate web content into your native apps seamlessly.

To get started, you'll need to add the Ejl.MauiHybridWebView NuGet package to your MAUI app. This package provides all the necessary functionality for integrating web content. Once added, you can create your HTML, JavaScript, and CSS files to define the web user interface.

The hybrid web view works by embedding a native web view control into your app, allowing it to display your web content using the platform's native rendering capabilities. This ensures a consistent look and feel across different platforms, while still giving you the freedom to use your preferred web technologies.

Take It Further - Full React Application

If you want to take it a step further, you can even embed an entire React application within your .NET MAUI app. This is made possible by the flexibility and power of the HybridWebView to incorporate complex web applications into native apps seamlessly and communicate between JavaScript and C#.

By embedding a React application, you can bring the full power of React's component-centric approach to your native app development. This allows you to create highly interactive and dynamic user interfaces, leveraging the extensive React ecosystem of libraries and components. All while access native APIs and business logic written in C#.

With the capability to integrate web technology like React into your .NET MAUI apps, the possibilities for creating rich, engaging, and performant mobile experiences are virtually limitless.

Conclusion

Building native apps doesn't have to mean starting from scratch. With .NET MAUI, you can leverage your existing web development skills and components to create powerful and feature-rich native apps. Whether you're using Blazor, Angular, React, or just HTML and JavaScript, .NET MAUI provides a unified platform to build cross-platform apps that deliver native performance and access to native features.

So, why not explore the possibilities of reusing your existing web content with .NET MAUI? Start building your native mobile apps today and discover the countless opportunities to create amazing experiences for your users.

References

This article was partially created with the help of AI. James reviewed and revised the content as needed.

Let's Learn .NET - Blazor Hybrid - July 28th 2022 - Free Live Stream Event

James Montemagno — Wed, 27 Jul 2022 17:44:00 +0000

Let's Learn .NET is a monthly beginner series that walks through the fundamentals of using C# and .NET. This month, we are looking at Blazor Hybrid and how to use it to build hybrid apps for desktop and mobile with .NET MAUI completely in C# using modern web technologies.

In a Blazor Hybrid app, Razor components run natively on the device. Components render to an embedded Web View control through a local interop channel. Components don't run in the browser, and WebAssembly isn't involved. Razor components load and execute code quickly, and components have full access to the native capabilities of the device through the .NET platform. Join us as we explore Blazor Hybrid together!

When

Thursday, July 28th at 8:30 AM - 10:30 AM Pacific

Where

Streaming live for FREE on Microsoft Learn TV or on YouTube. Sign-in, ask questions, and learn how to start building accessible apps.

What

Come learn something new and leave with something that we all built, together, live with experts. Here is the agenda for the event:

Introductions (5 mins):

Meet the team!

Fundamentals (20 mins):

Blazor Hybrid 101
- What is Blazor?
- What is Blazor Hybrid
- What is .NET MAUI
Pre-requisites & installation

Workshop (60 mins):

Build a mobile & desktop app with Blazor Hybrid

Q&A (10 mins):

Get your questions answered live!

RSVP Today

Head to aka.ms/letslearndotnet to RSVP today!

Looking for more?

Open-source .NET MAUI Workshop - Multi-platform apps with C#

James Montemagno — Wed, 30 Mar 2022 16:25:00 +0000

The .NET Foundation helps organize "Presentations in a Box" including workshops, demos, presentations, eBooks, and a lot more from the .NET team and the .NET community. In recent months, the ASP.NET Core Beginners, Blazor, and C# workshops have been fully updated to .NET 6 and C# 10! If you are looking to learn or teach .NET and C#, these are great resources to start at.

Personally, I contributed the Xamarin.Forms workshop to the .NET Foundation resources, and with .NET MAUI around the corner, I thought it was time to update this workshop to the latest and greatest tech. So, today, I am pleased to announce the launch of the .NET MAUI workshop available right now today! This full day workshop walks through everything .NET MAUI and has you building a full application from scratch that grabs and displays information from web API, navigates to details, and adds native platform features.

Here is a full outline of the workshop:

Part 0 - 30 Min Session - Introduction to .NET MAUI Session & Setup Help
Part 1 - Single Page List of Data
Part 2 - MVVM & Data Binding
Part 3 - Navigation
Part 4 - Implementing Platform Features
Part 5 - CollectionView & Beyond
Part 6 - Theming the app

There is a slide deck presentation for each part of the workshop alongside a full readme walkthrough of completing the exercise. I am super excited to release this and I am super open to feedback as well. I am presenting this at a few upcoming conferences and then plan to do a full recording on my YouTube!

Implementing In-App Subscriptions in iOS & Android with no backend servers

James Montemagno — Mon, 07 Feb 2022 21:00:17 +0000

Over the years I have created several apps that I am super proud of, and for the most part, I have always put them out for free onto the app stores. More recently I have been experimenting with different monetization strategies for the apps so users can unlock features or just leave a tip. For the longest time I kept things simple with a "non-consumable" one-time purchase. The strategy is straight forward, they either purchased the item or they didn't. Based on this information you would unlock the features in the app. My nifty InAppBilling .NET plugin for iOS, Android, macOS, and Windows comes in super handy and makes it just a few lines of code to implement this logic. Over the holiday break I decided to take things a step further and dip my toes into the world of subscriptions, and what I found left my code in a complete state of madness! Before I go into details on how I decided to implement subscriptions, I recommend listening to our recent Merge Conflict episode all about subscriptions!

One of my goals of this was to not use any backend servers or accounts at all as I didn't want to add additional costs to management. That leads to even more complexity, but for me it was worth it, so let's get into it!

Setting up subscriptions

The first thing that you are going to need to do is setup your subscriptions in the App Store and Google Play. Each store has the concept of "Groups" that have multiple subscription options in them that users can upgrade/downgrade from. I am just offering a single subscription to keep things simple. The settings are straight forward:

How long is a subscription (1 week, 1 month, 2 months, 3 months, 6 months, 1 year)
How much is the subscription (as low as 0.49)
Name, Description, and Product ID

It is important you select the correct subscription length as you can't change this after it is approved. Additionally, you should set a unique Product ID across your apps and try to name them the same between iOS and Android for simplicity later. You can change the price later if you desire, but note that lowering it will affect all users, but if you increase you have the option to make it for all users or just for new subscriptions. I prefer to make it a bit higher to start and then adjust later as needed.

Apple and Google have great documentation if you need more information.

Purchasing subscriptions

Now that we have setup the subscription information, we can start our implementation. I mean technically you could skip the step ahead as well if you haven't prepped the app store yet, but of course you won't be able to test out things.

Purchase screen for subscription

Purchasing is straight forward, and for this blog I am going to use my InAppBilling plugin that under the hood uses StoreKit and the Android Billing Library. Making the purchase is the same as any other purchase using the SDK, but the information that is returned is the most important part.

async Task PurchaseSubscription()
{
    if (IsBusy)
        return;

    IsBusy = true;
    try
    {

        // check internet first with Essentials
        if (Connectivity.NetworkAccess != NetworkAccess.Internet)
            return;            

        // connect to the app store api
        var connected = await CrossInAppBilling.Current.ConnectAsync();
        if (!connected)
            return;

        var productIdSub = "mysubscriptionid";

        //try to make purchase, this will return a purchase, empty, or throw an exception
        var purchase = await CrossInAppBilling.Current.PurchaseAsync(productIdSub, ItemType.Subscription);

        if (purchase == null)
        {
            //nothing was purchased
            return;
        }

        if (purchase.State == PurchaseState.Purchased)
        {
            Settings.SubExpirationDate = DateTime.UtcNow.AddSubTime();
            Settings.HasPurchasedSub = true;
            Settings.CheckSubStatus = true;

            // Update UI if necessary if they have 
            SetPro();

            try
            {
                // It is required to acknowledge the purchase, else it will be refunded
                if (DeviceInfo.Platform == DevicePlatform.Android)
                    await CrossInAppBilling.Current.AcknowledgePurchaseAsync(purchase.PurchaseToken);
            }
            catch (Exception ex)
            {
                Logger.AppendLine("Unable to acknowledge purcahse: " + ex);
            }
        }
        else
        {
            throw new InAppBillingPurchaseException(PurchaseError.GeneralError);
        }
    }
    catch (InAppBillingPurchaseException purchaseEx)
    {
        // Handle all the different error codes that can occure and do a pop up
    }
    catch (Exception ex)
    {
        // Handle a generic exception as something really went wrong
    }
    finally
    {
        await CrossInAppBilling.Current.DisconnectAsync();
        IsBusy = false;

    }
}

This looks like a lot of code, but it is only four calls to the billing service itself: Connect, buy, acknowledge (on Android), disconnect. And funny enough, on iOS you don't even need to really connect or disconnect as it doesn't do anything.

Now, the real thing to pay attention to is what we do when the user makes a successful purchase. I store 3 values that I store in preferences using Essentials:

   Settings.SubExpirationDate = DateTime.UtcNow.AddSubTime();
   Settings.HasPurchasedSub = true;
   Settings.CheckSubStatus = true;

SubExpirationDate : This value lets me check if the subscription is still valid and when to refresh the subscription status next.
HasPurchasedSub : A simple value to determine if they have EVER purchased a subscription. Just valuable information that I will use later.
CheckSubStatus : This value I use to determine if I have prompted the user to refresh the subscription status, it is true if the subscription is valid, and I have never prompted them.

That AddSubTime is a nice little extension method I made throughout my app to make it easier when checking if subscriptions are valid or not.

public static DateTime AddSubTime(this DateTime dateTime)
            => dateTime.AddMonths(1).AddDays(5);

I decided to add not only a month, but also five extra days just in case there is some weird billing issue. I figure what an extra five days anyway.

Now throughout my app I can run a single check to see if they have purchased a subscription and if it is valid:

public static bool IsSubValid => HasPurchasedSub && SubExpirationDate > DateTime.UtcNow;

Handling subscription renewals and cancelations

At this point, the user now has access to the subscription for a full month (and 5 days)! What happens when it is time to refresh that subscription status? I went with a simple approach on launch of the application that notifies the user that the subscription status needs to be refreshed. I could do this in the background, but I made it very transparent to the users.

if(Settings.CheckSubStatus && Settings.HasPurchasedSub && !Settings.IsSubValid)
{
    Settings.CheckSubStatus = false;
    if(await DisplayAlert("Subcription Status Refresh", "Looks like it is time to update your subscription status. If you canceled and resumed, you can always refresh your status on the settings page by restoring purchases.", "Refresh status", "Maybe Later"))
    {
        if (Connectivity.NetworkAccess != NetworkAccess.Internet)
        {
            Settings.CheckSubStatus = true;
            await DisplayAlert("No internet", "Please check internet connection and try restore purchases again in settings.", "OK");
            return;
        }
        //refresh status here
        await RestorePurchases();
    }
}

Here, I check to see if they ever purchased a subscription, if it is no longer valid, and if I should check the subcription status with a prompt. If they want to refresh the status, I call the RestorePurchase method.

Now, this is where things get FUNKY and weird because iOS and Android differ so much.

iOS : returns every single transaction including the original purchase and all renewals with proper transaction date time stamps!
Android : Only returns current valid subscriptions and the time stamp is always the original purchase date of the subscription, not the renewals.

I personally prefer the iOS mechanism for this as it makes the code much cleaner. All you must do is order the purchases descending by transaction date and compare dates to see if a subscription is valid. On Android, if it returns a subscription then it is valid and you must figure out the expiration date manually by adding time over and over to the original transaction date, which seems problematic. However, after much testing, here is what I came up with to check to see if the subscription has been renewed:

async Task RestorePurchases()
{
    if (IsBusy)
        return;
    IsBusy = true;

    try
    {

        var connected = await CrossInAppBilling.Current.ConnectAsync();
        if (!connected)
            return;

        var foundStuff = false;

        var subs = await CrossInAppBilling.Current.GetPurchasesAsync(ItemType.Subscription);

        if (subs?.Any(p => p.ProductId == productIdSub) ?? false)
        {
            var sorted = subs.Where(p => p.ProductId == productIdSub).OrderByDescending(i => i.TransactionDateUtc).ToList();
            var recentSub = sorted[0];
            if (recentSub != null)
            {
                // On Android as long as you have one here then it is valid subscription
                if (DeviceInfo.Platform == DevicePlatform.Android)
                {
                    foundStuff = true;
                    Settings.HasTippedSub = true;
                    Settings.CheckSubStatus = true;

                    //loop through transactions and keep adding a month until valid
                    var date = recentSub.TransactionDateUtc;
                    while (date < DateTime.UtcNow)
                        date = date.AddMonths(1);

                    Settings.SubExpirationDate = date.AddDays(5);

                    SetPro();
                }
                else
                {
                    if (recentSub.TransactionDateUtc.AddSubTime() > DateTime.UtcNow)
                    {
                        foundStuff = true;
                        Settings.HasTippedSub = true;
                        Settings.CheckSubStatus = true;
                        Settings.SubExpirationDate = recentSub.TransactionDateUtc.AddSubTime();
                        SetPro();
                    }
                }

                if (DeviceInfo.Platform == DevicePlatform.Android && !recentSub.IsAcknowledged)
                {
                    try
                    {
                        await CrossInAppBilling.Current.AcknowledgePurchaseAsync(recentSub.PurchaseToken);
                    }
                    catch (Exception ex)
                    {
                        Logger.AppendLine("Unable to acknowledge purchase: " + ex);
                    }
                }
            }
        }

        if (!foundStuff)
        {
            await DisplayAlert("Hmmmm!", $"Looks like we couldn't find any subscription renewals, check your purchases and restore them in settings. Don't worry, all of your ride data will be saved.", "OK");
        }
        else
        {
            await DisplayAlert("Status Refreshed!", $"Thanks for being awesome and subscribing for another month of My Cadence Pro!", "OK");
        }

    }
    catch (Exception ex)
    {
        Debug.WriteLine("Issue connecting: " + ex);
        await DisplayAlert("Uh Oh!", $"Looks like something has gone wrong, please check connection and restore in the settings. Code: {ex.Message}", "OK");
    }
    finally
    {
        IsBusy = false;
        SetPro();
        await CrossInAppBilling.Current.DisconnectAsync();
    }
}

It is not pretty, but totally working well. Note that for iOS I take the most recent subscription, add time, and compare it with the current UTC time: recentSub.TransactionDateUtc.AddSubTime() > DateTime.UtcNow and if it is still valid then I update the expiration date.

Verifying & restoring a subscription

One important feature that your app must implement is a "Restore Purchases" feature for in-app purchases and subscriptions. This is important if your user gets a new device, has multiple devices, or uninstalls and re-installs the app. I add a button directly on the settings/upgrade screen to do this. The application logic is actually the same as the renewal check above! Code re-use to the max!!! You may have other in-app purchases that you may want to put in there as well, so be sure to restore all your purchases!

Receipt validation

At this point we have finished all the in-app code for subscriptions, renewals, and restoration. See, it wasn't that bad :).... well except that we haven't done any receipt validation, which means the user could have cancelled, asked for a refund, paused a subscription, or who knows what else. Oh, and receipt validation also ensures that users haven't hacked your app in some way to intercept the calls to get free stuff. Look how easy this looks:

Receipt validation is super important, and I recommend you checkout my documentationwith tons of links to other important resources including how to use Azure Functions as a receipt validation service. For this blog, and in my apps currently I am not doing receipt validation. I haven't personally had any issues, but my apps are only downloaded a few thousand times, not millions of times. So, I am going to leave this up to you based on your application.

Testing subscriptions

Now is the fun part of testing!!!!!!!

This is the worst part because when you test everything is different in a sandbox, and each platform is different. I ended up using TestFlight and Google Play Internal rings for testing with my normal account. When you subscribe on iOS and Android you aren't charged anything during testing, but they do renew differently for testing purposes. Android will just continue to renew every 5 minutes (for a 1 month sub, longer for others) and then you have to manually cancel the subscription. I like this approach a lot as it doesn't clutter up all my transactions and lets me do more realistic world testing. iOS is a bit of an interesting one as it also will renew the subscription every 5 minutes but will do it up to 12 times and then stop renewing. This is a fine approach, but I just wish they worked the same.

I could write for days on testing and all the complexity, but there is an amazing blog for iOS testing from RevenueCat that saved my life and outlines everything you need to know. Google actually has pretty good documenation for this and really helped me get through the process. Take your time on testing and make sure to test all of the different scenarios. One pro tip that I can offer is to change the amount of time for a valid subscription to 5 minutes (instead of my 1 month & 5 days) so you can test out the duration that Apple/Google renew on. Once you have validated that you can change it back and ship to the store.

In-App Subscriptions SaaS... RevenueCat

Implementing in-app subscriptions can be extremely complicated and can get even more complicated when you throw in user accounts, third party integrations, and subscriptions on the web. After reading the testing blog on RevenueCat, I realized that it was an entire SaaS solution for in-app subscriptions and is genius.

If you are really looking for a full solution this may be a good option for you to investigate. I have still decided to roll my own and use the raw APIs of the platform, but I have to say RevenueCat is pretty awesome and just shows how complex these APIs and testing matrixes are.

Other Considerations

In-app subscriptions are pretty neat as they offer a lot of flexibility over a single IAP or up-front app purchase. For example you can:

Offer a free trial for a month
Offer discounted rate for the first X months
Offer discounts for longer subscriptions
Promote them in the app store as another entry (iOS)

It is true that we are becoming a subscription based society and some people hate subscriptions. However, if you have great features and want to help your long-term development it is a great option to generate revenue. One option that I have in my apps is the option to do a "life time" subscription purchase. This is actually not a subscription, but a non-consumable in-app purchase. This adds a bit of complexity to the mix, but I think it is worth it at the end of the day. I hope that you found this blog a bit interesting and helpful on your IAP journey!

Celebrate the .NET 20th Anniversary with the Community!

James Montemagno — Wed, 02 Feb 2022 19:18:32 +0000

Did you know that this month marks .NET's 20th anniversary! That's right, .NET launched 20 years ago on February 13th, 2002, alongside Visual Studio .NET. We are celebrating all month long and you can get join in on the fun.

20th Anniversary Celebration.

The .NET team is throwing a huge celebration on February 14th at 9AM Pacific. This 30-minute event will feature:

Interviews with luminaries & Microsoft alumni
Stories from customers and developers building amazing things
Memories of building .NET with Scott Hunter, Scott Hanselman, and special guests
…and so much ❤ from OSS contributors, MVPs, and .NET team members

Head over to https://dotnet.microsoft.com/ for more information about the event, but it is never too early to start celebrating! And while you are there, checkout new homepage redesign and the awesome .NET timeline!

Digital Swag (wallpapers, cake designs, and more!)

The .NET design team has put together an awesome array of digital goodies for you to celebrate including wallpapers, Teams backgrounds, cake designs, e-mail signature images, and a whole lot more. They are high-res and customizable with SVGs, here is my current wallpaper on my ultra-wide:

Head over to https://github.com/dotnet-presentations/dotNET20th to grab all of the goodies and start celebrating!

Mod the dotnet-bot

The dotnet-bot is the mascot for the .NET community. Create your coding companion by modding the dotnet-bot and then share your creation with the world.

Celebrate on social

Celebrate with the community throughout the month of February on social media. Have a fond memory? Still have that PDC conference badge? Did you build something amazing? Share your stories, memorabilia, favorite features, etc. in picture or video form on Twitter using the hashtag #dotNETLovesMe. Microsoft, the .NET Foundation, and ecosystem partners are joining the celebration with digital swag, trivia games and more.

Don't forget to add the 20th anniversary event to your calendar over at https://dotnet.microsoft.com/!

Learn F# this week with Free Events & Live Streams

James Montemagno — Tue, 27 Jul 2021 22:18:35 +0000

There are several upcoming events and live streams focus on all things F#, an open-source language that makes it easy to write succinct, robust, and performant code. Check them out!

.NET Conf - Focus on F#

.NET Conf: Focus on F# is a free, one-day livestream event that features speakers from the community and Microsoft teams working on and using the F# language. Learn how F# lets you write succinct, performant, and robust code backed by a powerful type system and the .NET runtime you can trust to build mission-critical software.

Hear from language designers and experts using F# in a variety of ways from building minimal web APIs to performing data manipulation, interactive programming, machine learning, and data science.

When

Thursday July 29th 08:00 (PT) | 15:00 (UTC)

Where

Tune in at https://focus.dotnetconf.net/ on July 29, ask questions live, and learn about what F# can do.

Agenda

Browse the full agenda for the 8 hours event at https://focus.dotnetconf.net/agenda

Let's Learn .NET - F#

Let's Learn .NET is a monthly beginner series that walk through the fundamentals of F# (pronounced “F-sharp”). F# is a functional programming language that runs on .NET and supports object-oriented programming. The type system and unique features of this language make a great fit for data science and ML. Come learn something new and leave with something that we all built together, live with experts. Streaming LIVE on Learn TV!

When

Friday, July 30th at 8:30 AM - 10:30 AM (PT) | 15:30 - 17:30 (UTC)

Where

Streaming live for FREE on Microsoft Learn TV. Sign-in, ask questions, and learn how to start building accessible apps.

Agenda

Come learn something new and leave with something that we all built, together, live with experts. Here is the agenda for the event:

Introductions: Meet the team!
Fundamentals: Introduction to F# (20 mins)
Workshop I: F# - Hello World
Q&A (10 mins): Get your questions answered live!
Workshop II (35 mins): Introduction to Funcational Programming
Q&A (10 mins): Get your questions answered live!

RSVP Today

Head to aka.ms/letslearndotnet to RSVP today!

Looking for more?

Let's Learn .NET - Blazor - Free Live Stream Event

James Montemagno — Mon, 21 Jun 2021 19:02:52 +0000

Let's Learn .NET is a monthly beginner series that walks through the fundamentals of using C# and .NET. This month, we are looking at Blazor and how to use it to build web apps completely in C#.

Blazor lets you build interactive web UIs using C# instead of JavaScript. Blazor apps are composed of reusable web UI components implemented using C#, HTML, and CSS. Both client and server code is written in C#, allowing you to share code and libraries. Together, we will learn all about Blazor and why you would use it to build web apps, and then we will build our first client web app with Blazor and .NET.

When

Friday, June 25th at 8:30 AM - 10:30 AM Pacific

Where

Streaming live for FREE on Microsoft Learn TV. Sign-in, ask questions, and learn how to start building accessible apps.

What

Come learn something new and leave with something that we all built, together, live with experts. Here is the agenda for the event:

Introductions (5 mins):

Meet the team!

Fundamentals (20 mins):

Blazor101
- What is ASP.NET Core? How does Blazor fit in?
- Why would I build apps with Blazor?
- How does Blazor Work?
Pre-requisites & installation

Workshop I (35 mins):

Build a web app with Blazor

Q&A (10 mins):

Get your questions answered live!

Workshop II (35 mins):

Publish a Blazor web app

Q&A (10 mins):

Get your questions answered live!

RSVP Today

Head to aka.ms/letslearndotnet to RSVP today!

Looking for more?

Let's Learn .NET - Accessibility - Free Live Stream Event

James Montemagno — Tue, 18 May 2021 21:42:53 +0000

Let's Learn .NET is a monthly beginner series that walks through the fundamentals of using C# and .NET. This month, we are taking a look at how to make our mobile, desktop, and web apps more accessible.

Technology can empower people to achieve more, help strengthen education opportunities, and make the workplace more inviting and inclusive for people with disabilities. With more than 1 billion people with disabilities in the world, accessibility and inclusion are essential to empowering every person and organization to achieve more. Let’s learn about building web and mobile applications with accessibility in mind. Together, we will understand what it means to be “accessible”, how to get started directly from your browser, and then what tools you can use to learn more!

When

Friday, May 21st at 8:30 AM - 10:30 AM Pacific

Where

Streaming live for FREE on Microsoft Learn TV. Sign-in, ask questions, and learn how to start building accessible apps.

What

Come learn something new and leave with something that we all built, together, live with experts. Here is the agenda for the event:

Introductions (5 mins):

Meet the team!

Fundamentals (20 mins):

Accessibility 101
- What does it mean to be “accessible”?
- How can you build with accessibility in mind?
- What tools can you use to build inclusively?
Pre-requisites & installation

Workshop I (35 mins):

Create accessible apps with Xamarin.Forms

Q&A (10 mins):

Get your questions answered live!

Workshop II (35 mins):

Create accessible web apps with ASP.NET Core

Q&A (10 mins):

Get your questions answered live!

RSVP Today

Head to aka.ms/letslearndotnet to RSVP today!

Looking for more?

Let's Learn .NET - C# - Free Live Stream Event

James Montemagno — Thu, 22 Apr 2021 22:59:21 +0000

Let's Learn .NET is a monthly beginner series that walks through the fundamentals of using C# and .NET. This month, let’s start at the beginning with learning a modern, productive, and evolving programming language C#. C# (pronounced See-Sharp) is an open-source type-safe programming language that is part of .NET That enables you to build any type of application including mobile, web, cloud, desktop, IoT, and more. Together, we will learn what C# is, how to get started learning directly from the browser, and then what tools you can install to learn more!

This fun, beginner's series will teach you all about the fundamentals of everyday technologies and how you can master them using C# and .NET.

When

Friday, April 30th at 8:30 AM - 10:30 AM Pacific

Where

Streaming live for FREE on Microsoft Learn TV. Sign-in, ask questions, and learn how to start programming with C#.

What

Come learn something new and leave with something that we all built, together, live with experts. Here is the agenda for the event:

Introductions (5 mins):

Meet the team!

Fundamentals (20 mins):

C# 101
- What is C#?
- What can you build with C#?
- How can you contribute to C#?
Pre-requisites & installation

Workshop I (35 mins):

Take your first steps with C#

Q&A (10 mins):

Get your questions answered live!

Workshop II (35 mins):

Continuing first steps with C#

Q&A (10 mins):

Get your questions answered live!

Special Guest (10 mins):

Special guest appearance to share some awesome updates about education!

RSVP Today

Head to aka.ms/letslearndotnet to RSVP today!

Looking for more?

Code Generation from XAML in Visual Studio is Mind-blowing Awesome

James Montemagno — Sat, 27 Mar 2021 18:57:22 +0000

The more and IDE or code editor can do for you the better I say. Visual Studio has been crushing it with new refactorings, IntelliSense, and IntelliCode, one of my favorite features ever. One thing that I have always been hoping for as a XAML developer is deeper connectivity between the XAML and the View-Model. We have seen increased IntelliSense in this area, but with the release of Visual Studio 2019 v16.9 comes code generation from XAML! That is right, you can now have Visual Studio automatically create your properties, commands, and more!

I will walk through this awesome feature for Xamarin.Forms, WPF, and UWP, but if you just want to see it in action, I made an entire video:

Enabling Code Generation

The first thing to do is to create your ViewModel and implement INotifyPropertyChanged (or inherit from something that does). Then just create a control with a Binding associated with it. For example:

<StackLayout>
    <Label Text="{Binding Text}"/>
</StackLayout>

Once you do this, Visual Studio will put little dots under the Text binding and a lightbulb will show up (if you don't see this simply re-compile). The lightbulb will look to assign your x:DataType in Xamarin.Forms or d:DataContext in WPF/UWP.

When I selected this option, it auto added the following code:

xmlns:app1="clr-namespace:App1"
x:DataType="app1:MyViewModel"

What is x:DataType you may be asking? Well, it is a compiled binding, which makes your bindings and apps faster! This is an awesome feature of Xamarin.Forms that you should totally use!

With this code in place, you will now see the dots remain and a new lightbulb show up to create a property called Text for you!

Here, it is recommending adding the property and creating a SetProperty method to invoke PropertyChanged, which is AWESOME!!!! Now, at this point you probably want to refactor the code a little bit and create BaseViewModel that you put this method in and then in future ViewModels it will not attempt to create the code and just add the property. If you are using Mvvm Helpers, you can use this code as your base:

public class ViewModelBase : BaseViewModel
{
    public bool SetProperty<T>(ref T field, T newValue, [CallerMemberName] string propertyName = null) =>
        SetProperty<T>(ref field, newValue, propertyName, null, null);
}

Now, if you add another control with another binding, you will see nice tight code will be generated for you:

Is your mind blown yet?!?!? Mine is! However, it gets even better!

Generating Commands!

Now, let's say we are going to add a Command to a Button we would naturally want that code to be generated as well, correct? Well, you are in luck because it will!

This code is really neat because it not only created the command and the method, but it also brought in the correct namespace to use the Xamarin.Forms Command!

Command Generation on UWP/WPF

If you are over on UWP or WPF you will not see this code generation because the core framework does not have an implementation of ICommand. However, if you are using a framework or library such as Mvvm Helpers then it will be smart enough to figure it out and recommend code for you!

MIND BLOWN!!!! ARE YOU NOT IMPRESSED!?!?!? Amazing!

Cleaner Code with C# 8 & 9!

One of the things you may have noticed is that the code for Xamarin.Forms and WPF/UWP are different in the screenshots. That is because my WPF sample app is using .NET 5, which uses C# 9 by default. The Xamrin.Forms app is using .NET Standard 2.0, which defaults to C# 7. However, you can easily adjust what version of C# is used in your project by adding the LangVersion into your csproj.

<LangVersion>8.0</LangVersion>

Take a look at my previous blog about upgraded a project to C# 9 in a minute.

Once you upgrade to 8.0 or higher the old code:

private ICommand clickCommand;

public ICommand ClickCommand
{
    get
    {
        if (clickCommand == null)
        {
            clickCommand = new Command(Click);
        }

        return clickCommand;
    }
}

private void Click()
{
}

will be upgraded to this lovely clean tight code:

private ICommand clickCommand;
public ICommand ClickCommand => clickCommand ??= new Command(Click);

private void Click()
{
}

Code Generation for Models

So far we have had Visual Studio generate code in our ViewModel classes on our page, but what about our models that are bound to an ItemsSource in a ListView or CollectionView Well no worries, all you need to do is set your x:DataType on your DataTemplate:

<ListView ItemsSource="{Binding Items}">
    <ListView.ItemTemplate>
        <DataTemplate x:DataType="app1:Item">
            <ViewCell>
                <Label Text="{Binding Text}"/>
            </ViewCell>
        </DataTemplate>
    </ListView.ItemTemplate>
</ListView>

Then you will see lightbulbs on any control inside of the DataTemplate!!

Again, this is pretty mind blowing and amazing! I was able to create all of my ViewModels and Models all without leaving the XAML!

Just the start!

This is all from me just playing around with Visual Studio 2019 v16.9 for a few minutes exploring this awesome new feature. There is for sure much more to come as Marco from the XAML Tooling team tweeted about the new feature and discussed with commentors about extending the templates for code that is being generated. Also, as of right now this is just a feature on Visual Studio on Windows, but since Visual Studio for Mac uses pretty much the same engine, we can imagine it will make its way to VSM soon.

This is just one of the many features that was included in Visual Studio 2019 v16.9 so check the release notes and upgrade today!

Let's Learn .NET - Microservices - Free Live Stream Event

James Montemagno — Mon, 22 Mar 2021 17:30:44 +0000

Let's Learn .NET is a monthly beginner series that walks through the fundamentals of using C# and .NET. This month, jumpstart your experience building Microservices with .NET! Learn about what microservices are, why you need them, and how to build them with C# and .NET. You will leave with an understanding of how a container, images, hub, and orchestrator all relate to each other.

This fun, beginner's series will teach you all about the fundamentals of everyday technologies and how you can master them using C# and .NET.

When

Friday, March 26th at 8:30 AM - 10:30 AM Pacific

Where

Streaming live for FREE on Microsoft Learn TV. Sign-in, ask questions, and learn how to build Microservices with .NET, Docker, and Kubernetes.

What

Come learn something new and leave with something that we all built, together, live with experts. Here is the agenda for the event:

Introductions (5 mins):

Meet the team!

Fundamentals (20 mins):

Microservices 101
- What are microservices?
- Why are they important?
- What tooling is needed for development?
Pre-requisites & installation

Workshop I (35 mins):

Learn how to build & deploy your first Microservice

Q&A (10 mins):

Get your questions answered live!

Workshop II (35 mins):

MS Learn - Create & deploy a cloud-native microservice

Q&A (10 mins):

Get your questions answered live!

Open Discussion (10 mins):

Let's discuss the learnings and what else is on your mind.

RSVP Today

Head to aka.ms/letslearndotnet to RSVP today!

Looking for more?

Join the Cloud Skills Challenge on Microsoft Learn!

Microservice architecture is a style that structures an application as a collection of services which are highly maintainable & testable, loosely coupled, independently deployable, organized around business capabilities, and owned by a small team. Follow this challenge to skill up on using .NET and microservices.