GoneDotNet

GoneDotNet

By Jonathan Dick, Allan RitchieTechnologyEducationHow To
Download on the App Store

GoneDotNet episodes

  • 91: ListViews and CollectionViews

    In this episode, Jon and Allan discuss the challenges and history of implementing lists in mobile apps. They start by addressing a listener question about the difference between CLI commands in MAUI and other UI frameworks. They then dive into the topic of dealing with lists in mobile apps, including the challenges of performance and dynamic sizing. They explore the history of list implementations on different platforms and the limitations of the current CollectionView in MAUI. They also discuss alternative list view controls and the misuse of observable collections in list views. In this episode, Allan and Jon discuss various aspects of building performant lists in mobile apps. They cover topics such as using observable collections for data in motion, optimizing list performance, choosing the right list control, and introduce the Virtualized List View plugin.

    Takeaways

    Implementing lists in mobile apps can be challenging due to performance and dynamic sizing issues.

    The history of list implementations on different platforms, such as ListView, RecyclerView, and UICollectionView, has influenced the current state of CollectionView in MAUI.
    The current CollectionView in MAUI tries to do too much and can be complex to use in certain scenarios.
    Alternative list view controls, such as Sharpnado and Syncfusion, provide different approaches and features for handling lists in mobile apps.
    Observable collections are often misused in list views, leading to performance issues. It is important to use them appropriately and consider using a regular list when the data is not changing frequently. Observable collections are useful for handling data in motion, such as real-time updates or changing distances.
    Optimizing list performance should be done based on actual needs and user behavior, rather than prematurely optimizing for potential issues.
    Consider the specific requirements of your app when choosing a list control, and don't be afraid to explore alternative solutions like Blazor or web technologies.
    The Virtualized List View plugin by Jon is a powerful tool for building performant lists in Xamarin.Forms and can be a great solution for complex scenarios.

    People
    • Hosts: Jon Dick, Allan Ritchie
    • Audio Engineer: Jim Heath
    • Chapters

      00:00 Introduction and Weather

      01:14 Listener Question: CLI Command in MAUI
      05:36 Topic: Dealing with Lists in Mobile Apps
      19:35 History of List Implementations
      25:51 Challenges with Collection View in MAUI
      30:17 Alternative List View Controls
      35:38 Observable Collections and List Views
      39:18 Observable Collection and Data in Motion
      46:11 Optimizing List Performance
      52:26 Choosing the Right List Control
      56:25 Virtualized List View Plugin
      01:00:53 Optimizing List Performance (Continued)
      01:04:08 Conclusion and Plug-in of the Week

      Links:

      • Redth's MAUI VirtualListView
    • Sharpnado CollectionView
    • 1 hr 7 min
    • 90: Push Notifications are Hard!
      Summary

      In this episode, Jon and Allan discuss the complexities of implementing push notifications on iOS and Android. They delve into the history of push notifications and the challenges developers face in tackling this topic. They explore the setup and configuration process for both platforms, including the use of certificates and entitlements on iOS and the use of Firebase on Android. They also discuss the lifecycle of notifications, handling background execution, and the differences between iOS and Android in terms of permissions and notification handling. In this episode, Jon and Allan discuss various aspects of push notifications on Android, including permissions and changes, setting up notifications, specifying intents in notification payloads, silent notifications, sending notifications to tags, handling multiple devices, and the Shiny Push library. They also touch on source generators and boilerplate code. Overall, the conversation provides valuable insights into the complexities and best practices of implementing push notifications on Android.

      Takeaways

      Push notifications are a complex topic that require careful setup and configuration on both iOS and Android.

      Developers face challenges in implementing push notifications due to the differences between platforms and the evolving nature of the technology.
      The setup and configuration process involves obtaining certificates and entitlements on iOS and using Firebase on Android.
      The lifecycle of notifications and the handling of background execution differ between iOS and Android.
      Permissions and changes in Android, such as the introduction of post-notifications, add another layer of complexity to push notification implementation. Permissions and changes in Android can impact the implementation of push notifications.
      Notifications on Android can be set up to route directly to an activity by specifying an intent in the notification payload.
      Silent notifications on Android can be used to wake up the app and perform background tasks.
      Sending notifications to tags allows for logical grouping and targeted delivery on Android.
      Handling multiple devices and ensuring notifications are received on all devices can be challenging.
      The Shiny Push library simplifies the implementation of push notifications on Android.
      Source generators can help reduce boilerplate code and make implementation easier.

      People
      • Hosts: Jon Dick, Allan Ritchie
      • Audio Engineer: Jim Heath
      • Chapters
        • 00:00 Introduction
        • 01:09 Tackling Hard Problems
        • 04:00 History of Push Notifications
        • 08:30 Setup and Configuration on iOS
        • 13:02 Registering for Notifications on iOS
        • 15:22 Lifecycle of Notifications on iOS
        • 17:43 Silent Notifications on iOS
        • 19:27 Handling Background Execution on iOS
        • 22:06 Complexity of Cross-Platform Implementation
        • 24:19 Setup and Configuration on Android
        • 28:35 Handling Notifications on Android
        • 32:19 Permissions and Changes in Android
        • 33:16 Permissions and Changes
        • 35:27 Setting Up Notifications on Android
        • 36:43 Specifying Intents in Notification Payloads
        • 38:19 Silent Notifications on Android
        • 41:48 Sending Notifications to Tags on Android
        • 44:29 Handling Multiple Devices on Android
        • 49:15 Shiny Push Library
        • 52:21 Server-to-Server Notifications
        • 56:08 Source Generators and Boilerplate
        • 57:44 Plugin Pick: Shiny Push
        • Links:

          • Shiny Push Notifications
          1 hr 1 min
        • 89: Bound for greater Bindings

          This conversation discusses the concept of bindings in a mobile.NET, Maui world. Bindings are used to integrate native libraries into the.NET ecosystem. The conversation covers the challenges and complexities of creating bindings for Android and iOS platforms. It explores the differences between Android X libraries and platform APIs. The concept of slim bindings is introduced, which involves creating a simplified interface for interacting with native libraries. The conversation also touches on the use of platform channels for message passing between.NET and native code. The future of bindings and the need for improved tools and processes are discussed. The conversation discusses the challenges and considerations when integrating platform channels in Xamarin projects. It explores the difficulties of referencing native frameworks and dependencies in Xcode projects and suggests the need for improved tooling to simplify the process. The conversation also delves into the complexities of handling AndroidX dependencies and the potential issues with duplicate libraries. Additionally, it highlights the concept of platform channels in Maui and the potential for creating a seamless integration experience. The recommended plugin for this episode is Xamarin Binding Helpers.

          Plugins, Packages, and Products

          This week we're talking about Xamarin.Binding.Helpers which helps make it easier to create slim bindings on Android, as well as Platform Channels which is an experiment for creating a message passing interface between native code and .NET MAUI apps.

          People
          • Hosts: Jon Dick, Allan Ritchie
          • Audio Engineer: Jim Heath
          • Chapters
            • 00:00 Introduction
            • 01:09 Understanding Bindings in a Mobile.NET, Maui World
            • 02:00 Projections of Native APIs into the Managed.NET World
            • 03:41 The Evolution of Bindings
            • 04:06 The Challenge of Android X Libraries
            • 05:00 Dealing with Bindings in Xamarin
            • 06:07 The Complexity of Android Libraries
            • 07:03 Creating Android Bindings
            • 07:30 The Process of Android Binding
            • 08:16 Challenges with Java and Kotlin Libraries
            • 09:08 Handling Complex Inheritance in Java and Kotlin Libraries
            • 10:22 The Sprawl of Android X Libraries
            • 11:31 The Challenges of Binding Android X Libraries
            • 12:09 The Simplicity of Binding Platform APIs
            • 13:16 The Differences Between iOS and Android Bindings
            • 14:22 Creating iOS Bindings
            • 15:48 The Challenges of Objective-C and Swift Libraries
            • 18:36 The Need for Slim Bindings
            • 20:00 The Challenge of Dependency Chains
            • 21:54 The Concept of Slim Bindings
            • 23:46 The Advantages of Slim Bindings
            • 27:11 Determining When to Bind the Whole Library
            • 29:34 Debugging Slim Bindings
            • 34:52 The Concept of Platform Channels
            • 38:58 Performance Considerations of Platform Channels
            • 40:37 The Future of Bindings
            • 40:46 Integration with Xcode Project
            • 42:41 Challenges with Tooling
            • 46:48 Handling AndroidX Dependencies
            • 50:15 Platform Channels in Maui
            • 53:00 Plugin Recommendation: Xamarin Binding Helpers
            • Links:

              • Objective Sharpie
            • Xamarin.Binding.Helpers
            • Platform Channels
            • 54 min
            • 88: Return of Gone Mobile and the State of .NET MAUI
              Summary

              In this episode, Jon and Allan discuss the state of .NET Maui, the challenges of mobile development, and the benefits of using Blazor WebView in Maui apps. They also talk about the evolution of the Mono runtime, the use of handlers in Maui, and the transition from custom renders to source generators. Overall, they highlight the improvements and advancements in the .NET Maui framework and its potential for creating cross-platform mobile apps. In this episode, Jon and Allan discuss app profiling and performance optimization, highlighting the use of tools like DS router and DS dotnet trace to profile apps and identify performance issues. They emphasize the importance of measuring and optimizing early in the development process to avoid potential problems. The conversation then shifts to the introduction of a new segment called 'Plugin Package or Product,' where they showcase a library called compiled bindings that enhances the XAML experience by providing additional operators and reducing verbosity. They express their interest in incorporating such concepts into the core product. The episode concludes with a call to action for listeners to subscribe, leave reviews, and provide topic suggestions for future episodes.

              Takeaways

              The .NET Maui framework has made significant progress, with improvements in tooling, performance, and support for modern mobile app development.

              Blazor WebView in Maui allows developers to leverage their existing Blazor skills and codebase to build hybrid mobile apps.
              The transition from custom renders to handlers in Maui simplifies the development process and improves performance.
              Source generators in Maui enable automatic code generation, reducing the need for manual coding and improving productivity. App profiling and performance optimization are crucial for identifying and resolving performance issues in apps.
              Tools like DS router and DS dotnet trace can be used to profile apps and gather trace files and speed scope logs for analysis.
              Early measurement and optimization can help prevent performance issues and improve the overall user experience.
              Compiled bindings is a library that enhances the XAML experience by providing additional operators and reducing verbosity, making it easier to work with XAML.

              Plugins, Packages, and Products

              This week we're talking about Compiled Bindings: https://github.com/levitali/CompiledBindings which provides {x:Bind} Markup Extension for WPF, MAUI and Xamarin Forms.

              Chapters
              • 00:00 Introduction and Changes to the Podcast
              • 06:17 State of .NET Maui
              • 09:24 Dependency Injection in .NET Maui
              • 11:12 Evolution of the Mono Runtime
              • 13:14 Challenges of Mobile Development
              • 19:22 Long-Term Release of .NET Maui
              • 21:20 Blazor Hybrid App
              • 23:43 Benefits of Blazor WebView
              • 25:49 Mixing Blazor and Maui
              • 31:35 Handlers in .NET Maui
              • 35:13 Porting Custom Renders to Handlers
              • 37:03 Source Generators in .NET Maui
              • 38:56 App Profiling and Performance Optimization
              • 41:29 Plugin Package or Product: Compiled Bindings
              • 47:04 Closing Remarks and Call to Action
              • Links:

                • CompiledBindings.Maui
                49 min
              • 87: Couchbase Mobile Update with Robert Hedgpeth

                It's been a few years since we've talked Couchbase on the show, so with their recent release of Couchbase Mobile 2.5 we thought we'd bring Robert Hedgpeth on to catch us up!

                Special Guest: Robert Hedgpeth.

                Sponsored By:

                • Telerik: Capitalizing on the innate benefits of the native UI while exposing all objects and properties in C#, Telerik UI for Xamarin is a collection of Xamarin.Forms controls and Xamarin wrappers which offer fast loading, excellent drawing capabilities and pixel-perfection while providing “no-compromise” customization, flexibility and stunning UI. Telerik UI for Xamarin. .NET Tools for .NET Ninjas. Download a trial today!

                Links:

                • Couchbase Mobile 2.5 Released
              • Couchbase Mobile
              • Gone Mobile 10: Couchbase Lite
              • 51 min
              • 86: Building PepTown with Eric Sink

                You may know Eric Sink from the database syncing product Zumero, or perhaps the source control versioning system SourceGear. Now, Eric is building a platform for High School sports fundraising, and he's doing it in .NET.

                Special Guest: Eric Sink.

                Sponsored By:

                • Raygun: Spot every bug. Discover every performance issue. Ship new features faster and deliver flawless user experiences. Raygun enables you to build stronger, faster and more resilient web and mobile applications for your customers. Get setup in minutes!

                Links:

                • Building PepTown with .NET: App Overview
              • Eric Sink's Blog
              • Zumero - SQL data sync for mobile apps
              • SourceGear | Vault
              • 45 min
              • 85: Creating Low-Code Apps Using OutSystems with Stacey Levine

                OutSystems allows you to do some pretty amazing things with Low to No Code. We talk to Stacey Levine about their platform to see just how much you an accomplish without coding!

                Special Guest: Stacey Levine.

                Sponsored By:

                • Telerik: Capitalizing on the innate benefits of the native UI while exposing all objects and properties in C#, Telerik UI for Xamarin is a collection of Xamarin.Forms controls and Xamarin wrappers which offer fast loading, excellent drawing capabilities and pixel-perfection while providing “no-compromise” customization, flexibility and stunning UI. Telerik UI for Xamarin. .NET Tools for .NET Ninjas. Download a trial today!

                Links:

                • The #1 Low-Code Platform for Digital Transformation | OutSystems | OutSystems
                49 min
              • 84: Creating Apps From Spreadsheets Using Glide with Jason Smith and Mark Probst

                Creating apps from spreadsheets? You bet! In this episode we're joined by Jason Smith and Mark Probst, formerly of Xamarin/Microsoft, to talk about their new endeavor called Glide. Glide's goal is to let you build beautiful, data-powered apps quickly and easily, so tune in to learn what it's all about!

                Special Guests: Jason Smith and Mark Probst.

                Sponsored By:

                • Raygun: Spot every bug. Discover every performance issue. Ship new features faster and deliver flawless user experiences. Raygun enables you to build stronger, faster and more resilient web and mobile applications for your customers. Get setup in minutes!

                Links:

                • Glide – Amazing apps from Google Sheets
              • Glide Samples
              • Gone Mobile 28: Behind the Scenes of Xamarin.Forms with Jason Smith
              • Gone Mobile 13: Xamarin.Forms
              • 49 min
              • 83: Diving into GrialKit and Gorilla Player with UXDivers

                We finally sit down with Leonardo and Diego from UXDivers to talk about their products GrialKit and Gorilla Player.

                GrialKit is a collection of Xamarin.Forms user controls, templates, pages, and basically a really simple way to make your app look great.

                Gorilla Player lets you live preview and hot reload XAML from your Xamarin.Forms products on a device or simulator.

                Special Guests: Diego Rivero and Leonardo Rodriguez.

                Sponsored By:

                • Telerik: Capitalizing on the innate benefits of the native UI while exposing all objects and properties in C#, Telerik UI for Xamarin is a collection of Xamarin.Forms controls and Xamarin wrappers which offer fast loading, excellent drawing capabilities and pixel-perfection while providing “no-compromise” customization, flexibility and stunning UI. Telerik UI for Xamarin. .NET Tools for .NET Ninjas. Download a trial today!

                Links:

                • UXDivers
              • GrialKit
              • Gorilla Player
              • Gorilla Player: A Tool to Craft Beautiful XAML UIs for Xamarin.Forms | Xamarin Blog
              • Getting Started · UXDivers/Gorilla-Player-Support Wiki
              • 46 min
              • 82: Building Fabulous Apps Using F# with Jim Bennett

                It's been awhile since we've had a good F# discussion, so for our final episode of 2018 we decided to fix that. Join us as we talk to Jim Bennett about the latest and greatest in the world of F# and how it's becoming a better option than ever before for building mobile apps!

                Special Guest: Jim Bennett.

                Sponsored By:

                • Telerik: Capitalizing on the innate benefits of the native UI while exposing all objects and properties in C#, Telerik UI for Xamarin is a collection of Xamarin.Forms controls and Xamarin wrappers which offer fast loading, excellent drawing capabilities and pixel-perfection while providing “no-compromise” customization, flexibility and stunning UI. Telerik UI for Xamarin. .NET Tools for .NET Ninjas. Download a trial today!

                Links:

                • Fabulous
              • Fabulous on GitHub
              • Awesome-Fabulous
              • Build cross-platform mobile apps using Fabulous - NDC London 2019
              • Gone Mobile 7: The F# is for Frank Krueger
              • Gone Mobile 44: Fluxing Up Your Xamarin Apps with Alex Dunn
              • Gone Mobile 47: Building Reactive Apps with Xamarin.Forms and F# with Rob Lyndon
              • 53 min

              About GoneDotNet

              From the publisher's feed

              All the latest in .NET Development ranging from Mobile to Server YouTube: https://www.youtube.com/@GoneDotNet