If you are a Xamarin developer, you will probably be interested in knowing the details around its future. Exactly two years after the announcement for the general availability of its successor, .NET MAUI, Microsoft will end support for Xamarin this May. But what does this mean for you?

The first thing you need to be sure of is that you will not be left behind. Your existing applications will continue to work in their current state. After the date of the last release of Xamarin (or a little while after), you most likely won’t be able to publish the updated version of your application in Google Store or Apple App Store. This is due to the fact that these stores will have a minimum version requirement of the respective SDK, which will not be released by Microsoft for Xamarin.

Besides, it’s not best practice to fall behind with updates at times when security is of great importance. At some point the stores themselves will require that only apps that meet the latest security standards will be published. This means that you will need to take a step toward an upgrade.

Before proceeding further, it is important to highlight our commitment to our Progress Telerik UI for Xamarin product. We currently have no intention of discontinuing it and we will persist in offering technical support and bug fixes to our clients.

The easiest and most logical choice for a framework that comes as a natural evolution of Xamarin is .NET MAUI. And just as it is an evolution, .NET MAUI has many advantages compared to Xamarin such as better performance, a simplified project structure for easier management, and many more. You can read more details on this topic in our blog post—“Should We Migrate from Xamarin.Forms to .NET MAUI? When?”

UI for .NET MAUI at a Glance

As your partner in .NET developer productivity, we moved in pace with the .NET MAUI technology, and we developed our Telerik UI for .NET MAUI controls in harmony with the Microsoft product releases. We are proud that the suite is packed with more than 60 components—which, by the way, is already more than those we have in UI for Xamarin. But since the number is not the most important, we focused on improvements and adding even more functionalities in the components than their equivalents in our Xamarin suite:

• You can check out some of our .NET MAUI components in the blog post “5 .NET MAUI Components That Will Ensure You Never Ask ‘How Do I Build That’.”
• The essence of almost every line-of-business (LOB) application is a DataGrid, thus we are constantly improving it. You can explore Sam Basu’s blog post that showcases some of the most important functionalities of the .NET MAUI DataGrid.
• Additionally, .NET MAUI has added a lot of features to the framework to support desktop functionality. Telerik UI for .NET MAUI supports a lot of desktop-friendly features as well—like mouse-keyboard support, full-featured Grid, advanced data visualization, etc.

If you’re not yet familiar with our product, you can explore our demo applications.

Migration to .NET MAUI?

.NET MAUI could present a great opportunity to migrate your current Xamarin app or to build your next cross-platform app. Migration can be easy, especially if you’re already using Xamarin.Forms to develop your cross-platform applications. Microsoft just shared a great tool that could simplify your migration efforts. We can also help you with a good migration blogpost.

Much of your existing code can be reused or easily adapted for .NET MAUI. With the right tools and resources, you can quickly upgrade to the new framework and take advantage of its features and benefits. This guide shows you how to convert your Xamarin application, built with Telerik UI for Xamarin to a .NET MAUI app with Telerik UI for .NET MAUI controls.

Moreover, we managed to migrate one of our Xamarin sample applications—Telerik CRM—to .NET MAUI. Lance McCarthy shows the migration process for this store app with a large codebase in a livestream series, so you can explore a real-world migration and hear his great recommendations.

With the CRM example, we have shown you the migration in action. As a next step, we plan to modernize the CRM app, and eventually to also add more functionality to the app. So, stay tuned for the next steps in the migration journey.

Conclusion

Every change is a new opportunity. Start now and have enough time to safely migrate your app and even consider expanding it with desktop and web support. As a conclusion, I believe the natural path of every Xamarin.Forms app is .NET MAUI, but the final decision is yours.

If you are our Xamarin customer and plan a migration to .NET MAUI, the DevCraft bundle is the right option for you, because you will keep the legacy library and will get the new one, plus all updates, resources and support.

If you are still not sure, need more information or don’t have migration plans, I’d be glad to hear your reasons and see how we can help you. Don’t hesitate to get in touch.

Hello there! Are you ready to learn some exciting tips for best practices in .NET MAUI? Whether you’re experienced with developing applications using Xamarin Forms or just starting out in .NET MAUI, the following content will be useful to you.

In this article, I’ll provide you with tips to improve your .NET MAUI app development practices. These insights are based on updates from the official documentation, which includes interesting improvements. The goal is for our apps to maintain their quality while enhancing performance and simplifying our work as developers. ️ I’m here to share tips that will keep you ahead in the .NET MAUI field. Ready to explore?

1. Want to Add a Border? Don’t Use Frame—Use Border

In Xamarin Forms, the Frame is mainly used to add borders. However, in .NET MAUI, a new control named Border has been introduced specifically for this purpose.

So, when is it appropriate to use Border, and when should you use Frame? The official documentation indicates that Frame is maintained for users transitioning their applications from Xamarin.Forms to .NET MAUI. For new developments, it’s recommended to use the Border control.

Here are a few reasons why I prefer using Border over Frame:

• Flexibility in rounding: If you want to set a value to round each edge separately, you have the ability to do so.
• Freedom in the border shape: You have control over the edge’s shape. For example, you can use shapes like RoundRectangle (as shown in the explanatory image), or experiment with others such as Polyline, among other shapes you can see here.

As shown in the main image of this tip, the Border is quite straightforward to use. To gain a more in-depth understanding of the Border, I recommend reading the article Border in .NET MAUI.

2. Use Horizontal/VerticalStackLayout Instead of StackLayout

If you’re familiar with Xamarin Forms, then you already know how the StackLayout works. By default, the orientation is vertical, but you can set it to horizontal using the Orientation property. In .NET MAUI, the same concept applies to StackLayout.

In addition to the existing layout, there are new ones where you don’t need to use the Orientation property. You can directly use VerticalStackLayout or HorizontalStackLayout instead. Depending on your preferred orientation, I recommend considering one of these new layouts!

I encourage you to learn more about these layouts by reading the article Exploring Layout Options in .NET MAUI.

3. Avoid Using AndExpand in the Horizontal/VerticalStackLayout

In Xamarin Forms, we use expansion properties such as Horizontal/VerticalOptions. These properties define alignment preferences and contain a set of values, some of which end with the “AndExpand” suffix. For instance, we have CenterAndExpand, Start and StartEndExpand, among others.

However, in .NET MAUI, the “AndExpand” suffix no longer exists. It will only respond to values without the suffix, like Center or Start.

What happens if you use a value with an “AndExpand” suffix? .NET MAUI simply ignores the suffix and considers the root word. For instance, if you write:

<VerticalStackLayout HorizontalOptions="CenterAndExpand">
      ...
</VerticalStackLayout>

.NET MAUI will interpret it as Center.

4. Don’t Use RelativeLayout

If you’ve been using RelativeLayout in Xamarin Forms, prepare for a change. RelativeLayout does not exist in .NET MAUI. Say goodbye.

You might wonder what to do if you’re migrating your app from Xamarin Forms to .NET MAUI and you use RelativeLayout. Microsoft has provided a solution with a compatibility namespace that can be found in the Microsoft.Maui.Controls.Compatibility namespace. For more information, you can refer to the article Xamarin.Forms to .NET MAUI: How Layout Behavior Has Evolved.

However, I personally recommend refactoring your code as soon as you complete the migration. The Grid layout is an ideal replacement, achieving the same behavior as the RelativeLayout.

5. Desktop Apps: Need More Info? Enhance with Tooltips

Consider a registration form that requires additional information. Typically, placeholders are used for this purpose. But what if more detailed information is needed? This is where tooltips come in handy. Tooltips allow you to add detailed information without affecting your UI design, as they only appear when the user directly interacts with the visual element (the Entry, for this example).

This is just one example. You can add tooltips to many other controls, not just entry! This is one of the new features of .NET MAUI that doesn’t exist in Xamarin Forms.

For more information about Tooltips, I invite you to read the article Improving Your Desktop Applications With ToolTips in .NET MAUI.

6. Using the Same Hex Colors in Various Places? Add Them to Color.xaml

Branding colors are an integral part of app development. Suppose your branding has three colors, and you need to use them across 10 pages. A common approach might be to simply repeat the same hexadecimal codes as needed on each screen. This works, but it can complicate the maintenance of our app and increase the risk of errors when changing a color. It also makes our app less scalable.

Creating a color palette in a single file is a more efficient method. This allows us to reference these colors with an alias in other files. If the branding colors change, we only need to update one file rather than the whole codebase. (In fact, the app’s default predefined colors are already set up this way).

Here are the steps to accomplish this:

1. Identify the colors to use and navigate to Your Project ➡️ Resources ➡️ Styles ➡️ Colors.xaml.

Add as many color lines as needed in the following format:

<Color x:Key="GrayPrimaryColor">#6E6E6E</Color>

In this context, GrayPrimaryColor is the alias of the color, and #6E6E6E is its hexadecimal representation.

2. Use the StaticResource to refer to the color.

<Label BackgroundColor="{StaticResource GrayPrimaryColor}" Text=".."/>

Future color updates will be much easier to implement!

Conclusion

‍ And that’s all for today! I hope the tips in this article will help you uphold best practices in .NET MAUI. Remember, great code originates from small and intelligent modifications! ️ Thank you for taking the time to read! See you in the next article!

Happy coding!

Since Microsoft Build 2023 has already occurred, it is important to stay informed of the latest news. This will help you learn about and implement new features in your applications.

This article provides an overview of Microsoft Build, with a focus on summarizing Maddy Montaquilla’s session titled “Upgrading Xamarin to .NET MAUI.” Together, we will develop step by step with Maddy’s plan for migration, so that you can start your own migration with ease!

First, let’s get a quick understanding of Microsoft Build and .NET MAUI.

What is Microsoft Build?

Microsoft Build is a great annual event created by Microsoft, where new tools and updates are presented, and we learn about services that developers can use now and in the future and other super valuable information for developers.

It took place on May 23, 24 and 25, 2023. You can explore the Microsoft Build portal here. Also, if you did not have the opportunity to attend, either virtually or in person, you can see all the recorded sessions about .NET accessing the .NET at Microsoft Build 2023 video playlist.

What is .NET MAUI?

Before starting the migration, Maddy, who is a Senior Product Manager at Microsoft, gave a brief overview of what .NET MAUI is. This is for people who are hearing of Xamarin or .NET MAUI for the first time.

.NET Multi-platform App UI (.NET MAUI) is an evolution of Xamarin designed to be a cross-platform native UI. It features a single-project architecture that allows for a single codebase instead of separate ones for each platform. With this architecture, you can deploy to all the different platforms, including Windows and macOS, in addition to Android and iOS.

A great definition that Maddy gave us for .NET MAUI is:

“.NET MAUI is the most productive way to develop native apps that perform great on any device that runs Android, iOS, macOS or Windows from a single codebase.”

Upgrading Xamarin to .NET MAUI

In this session, Maddy gives us some tips and tricks to keep in mind before migrating our applications made in Xamarin. She also teaches us to use the Upgrade Assistant tool available in Visual Studio to finally migrate from Xamarin to .NET MAUI.

Why Should You Upgrade?

To get into real situations, you may find yourself in one of these two scenarios: you have a stable Xamarin app that does not require updates, or you have an app that needs to receive updates. Let’s explore how to handle both of these scenarios:

➖ You have a stable Xamarin app that does not require updates: If you are not planning to add updates to your app, you do not have to take any additional steps immediately. However, at some point, the app may stop being compatible with iOS or Android, and you will need to compile it on the latest operating systems, requiring a migration. It may be a long time before this becomes a problem, but it is still important to be aware of it.

➖ You have an app that needs to receive updates: Migrating to .NET MAUI will help your project benefit from the features of the new framework. For example, the one that stands out the most is the improvement in performance, and a lot of that comes from decoupling the platform controls with cross-platform controls. This means that instead of every function being tightly coupled to platform-specific controls (like Android buttons, iOS buttons or Windows buttons), we can use the more flexible .NET MAUI controls (assigning one button control).

There is also better support for desktop applications, with many super cool features such as multi-window, pointer, click and gestures.

In addition to the improvements mentioned above, there are many others, as shown in the image below:

Progress on Performance

We can see big changes in startup time between MAUI and Xamarin. Maddy shows us an example in which these great changes can be perceived. It’s almost 35% faster on startup, which is pretty significant. In a heavy real-world application, the startup time is still estimated to be less than a second, which is an amazing startup time.

Frequently Asked Questions

Maddy made a summary of the most common questions in this transition, which are the following:

• Do I need to rewrite my apps? No! You can make the migration with your existing code, using the tools that you will see below.
• What happens to Xamarin.Android and Xamarin.iOS? If you wrote something that doesn’t use Xamarin Forms, then you might not want a cross-platform UI with MAUI. That’s okay. We have .NET for Android and .NET for iOS. .NET can target those platforms. So, those things will upgrade and work perfectly fine.
• When do I start trying to upgrade? Get up to date and start evaluating now. The Xamarin end of life is May 2024, which is a year out from Microsoft Build 2023.

Tips and Tricks

The most important things for you to do are to get rid of anything unnecessary. There are a lot of new controls and properties in both Xamarin and MAUI, so some of the custom renderers you wrote back in the day might not even be needed anymore.

Also, take inventory of your NuGet packages. If there are packages that you really depend on, that are core to your app, you should check if they have a MAUI-compatible version. You should also check if they will need to be recompiled for MAUI. If there are alternatives, you can switch them out.

In the image below, you can see in more detail other tips and tricks that Maddy shared with us:

And here’s a little bit more about NuGet, libraries and packages:

Let’s See the Demo

Visual Studio Upgrade Assistant

This Visual Studio Upgrade Assistant allows you to migrate your Xamarin applications to .NET MAUI. This supports Windows and iOS migrations.

To help you learn how to use this demo, we will use an example Xamarin Forms application. Your app may have different features, and that’s OK. This is just a general guide to assist you with the migration process.

Availability

• Windows: We have the Upgrade Assistant as a Visual Studio extension. (We will focus on this explanation.)
• Mac: Although it is not currently available in Visual Studio for Mac, you can still use an existing version for the command line. The source code is available on GitHub, so feel free to download it and follow the instructions provided. You can take a look at the repository here.

Let’s Start Using the Upgrade Assistant

Step 1: Add the Upgrade Assistant extension.

It’s a separate extension, so you can add it in Visual Studio like this:

• Go to the top menu bar, click on Extensions ➡ Manage extension.

• Download the extension: Find the .NET Upgrade Assistant and download it.

When you start the download you will see a scenario like the one in the following image:

Once installed, you will see a message that says: “Your changes will be scheduled. The modifications will begin when all Microsoft Visual Studio windows are closed.” ⚠ This is why you should close and start your Visual Studio again.

Step 2: How to use the assistant?

To use the Upgrade Assistant, you just have to right-click on your project, and an option that says “Upgrade” will appear. Please click it.

You will see a user interface like this:

As you can see, we have two migration options available:

• In-place project upgrade: In order to upgrade the project and its components, apply transformations that are suitable for the project while keeping everything in place. If you want to keep the main project, this option is recommended.
• Side-by-side project up: Utilize transformations that are relevant to the project to upgrade the project and its components in a copy.

There are different ways to do the migration. In this case, we will start by migrating the Android and iOS projects and then the main project. Let’s start by right-clicking on Android to start the migration.

The demonstration will be using the “In-place” option, so you must click on that option. An interface, like the one pictured below, will appear, asking you for your preferred target framework for the migration. I will click on .NET 7 and then click on “Next.”

Once you have clicked “Next,” you will be able to select the individual components that you wish to update (if necessary). Then, click on “Upgrade selection.”

While it is updating, you will see the updates presented to you in the bottom bar. Every time changes are made to the project, it will download and reload things in the solution explorer, which is why you will see it blink.

At the end of the whole process, everything that was updated is shown, along with the things that it verified did not need to be updated—as you can see in the image attached below.

After this, you can continue with the iOS application with the same process.

To finish, let’s continue with the Xamarin Forms application (the main one). Repeat the same process: Right-click and then Upgrade.

You will see the same options we saw previously: “In-place” and “Side-by-side.” Now you need to decide where you want your updated project to be placed. It can either be in the same location or side-by-side, which allows you to move everything to a new .NET MAUI project. This is probably one of the best ways to accomplish it. So, for this example, you should choose the side-by-side option.

Next, two options will appear:

• New project: A new project will be created from specified template and associated with current project as an upgrade target.
• Existing project: An existing project of a supported type can be chosen as an upgrade target project.

We will use the new project option in this example. Click on it and the following screen will appear:

You can change the name (I put “ContactMessageUIMAUI”) and then click “Next.”

Then the same options that we saw before will appear:

• Choose the preferred target (we will choose .NET 7 for this case).
• Then choose the components to update. Then click the Upgrade selection.

The process is extremely fast! Once completed, you will have a new project in your solution with a .NET MAUI app that has transformed your application code, which was previously in Xamarin.Forms.

In the following image you can see the “ContactMessageUIMAUI” project already migrated to .NET MAUI!

⚠ Sometimes you have to reload your Solution Explorer to be able to visualize the new project.

What’s Next?

If you were to build your app right now, there would likely be some bugs. This is because the Upgrade Assistance tool provides a large percentage of help, but as a developer, you must complete a few tasks to fully migrate your app. I recommend that after you use the assistant, you build your app and check for errors. Correct any errors, and then build it again.

Wrapping up

And that’s all! I invite you to continue exploring about the Upgrade Assistant to migrate your Xamarin and .NET MAUI applicationsI! I hope you liked this summary!

Let me know in the comments when you are starting your migrations!

See you next time! ‍♀️

Want to Continue Exploring?

• Take a look at the “All things client and mobile app development with .NET MAUI” Session.
• Read more blog posts about whether you should migrate from Xamarin to .NET MAUI, including more things to consider and tips and tricks.
• Check out the .NET MAUI controls from Progress Telerik—the best-in-class suite of 60+ .NET MAUI UI controls to meet all cross-platform app requirements for data handling, performance, UX, design, accessibility and so much more.
• If you're already a Progress Telerik user, you may find this guide helpful: Xamarin to .NET MAUI migration.

References

• https://www.youtube.com/watch?v=yCtkjz51bJ8&list=PLdo4fOcmZ0oV0mbay2wxFS_ZVRg6cxjdM&index=4

We are thrilled to share the exciting features and improvements that await you in R2 2023 from our Progress Telerik mobile and desktop UI component libraries. So, sit back, relax and keep reading to stay in the loop!

• Telerik UI for .NET MAUI
• Telerik UI for WPF
• Telerik UI for WinForms
• Telerik UI for WinUI
• Telerik UI for Xamarin
• Telerik Document Processing Libraries
• Details for webinar June 8

Telerik UI for .NET MAUI

Prepare for an exhilarating update in R2 2023 as Telerik UI for .NET MAUI unveils a series of exciting enhancements. I am thrilled to introduce six brand-new controls: Calendar, PDF Viewer, Chat, SlideView, RichTextEditor and TreeView, each designed to empower your app development journey. In addition, we have taken steps to refine and enrich our powerful DataGrid control, unlocking even more possibilities. Let’s have a sneak peek at the most interesting stuff we have for you in this release.

Calendar

The new addition to the UI for .NET MAUI family is the Calendar component. It allows you to select single or multiple dates by navigating easily between decades, years and months. The control is culture-aware by providing globalization support. It also provides support for scrolling and navigation, blackout dates and much more.

Here is a list of the main features of the control:

• Different display modes: Calendar features year, month, decade and century display modes.
• Date Ranges: Restrict the visible/selectable dates in the Calendar by utilizing MinDate and MaxDate properties.
• Different selection modes: The component provides different types of selection—Single, Multiple, Range or disabling the selection.
• Buttons for navigation in the current view: You can easily navigate in the current view by using the buttons in the calendar header.
• Hide the names of the display days in month view.
• Format the header text for the corresponding view.
• Templates support: For customizing the days, months, years and decades in the corresponding views.
• Commands support: For navigating in the current view or between the views.
• Styling API: You can style the Calendar border, header border and text, navigation buttons and the content of the corresponding view.

For more information on getting started with the Telerik UI for .NET MAUI Calendar control, visit the documentation.

PDF Viewer Component

One of the highly requested components for our UI for .NET MAUI suite was the PDF viewer. I am happy to share that it is now available with our latest release. This component empowers the users of your application to directly open and view PDF documents within their mobile or desktop app, eliminating the need for any external software installation or switching between different applications. You can visualize PDF documents that include images, shapes, different colors, ordered and bulleted lists and more.

Here are some of the key features to look for:

• Various document source options: You can load the PDF document from a stream, from a file added as an embedded resource or a file located on the device, etc.
• Zooming functionality: The component provides an option for zooming in and zooming out the content of the document.
• Commands support: The PDF Viewer component offers support for a variety of commands, such as ZoomIn, ZoomOut, NavigateTo (NextPage, PreviousPage, Page) and FitToWidth.
• Single page and Continuous Scrolling support: You can choose between two layout modes that allow the document to be scrolled in the viewer.
• Flexible styling API: You can easily style the toolbar per your requirements.

For more information on getting started with the PDF Viewer control, visit the documentation.

Chat Component (Conversational UI)

The Chat control in Telerik UI for .NET MAUI empowers you to build contemporary chat experiences in your .NET MAUI apps. It smoothly integrates with popular chatbot frameworks and effortlessly facilitates peer-to-peer conversations.

The component offers a diverse range of customizable message formats like cards, pickers and suggestions. It also enables you to effortlessly replace forms with an instinctive conversational UI. You can modify messages and cards to include text, images and other elements or incorporate details such as message timestamps, sender/recipient names, avatars and much more.

For more information on getting started with the Telerik UI for .NET MAUI Chat control, visit the documentation.

SlideView Component

The new SlideView component provides a visually appealing and interactive way to present information or showcase visual content. Whether your goal is to create an image gallery or improve navigation within your .NET MAUI application, the SlideView component offers a comprehensive set of features and customizable options to fulfill your requirements.

Here are some of the key features to look for:

• Item Template: Allows you to present the data in the views in the most suitable way for your scenario.
• Control Template support: You can change the appearance of the SlideView component through a Control Template.
• Customizable indicators and slide buttons: The SlideView allows you to customize the appearance of the indicators and slide buttons.
• Commands support
• UI virtualization

For more information on getting started with the Telerik UI for .NET MAUI SlideView control, visit the documentation.

Rich Text Editor Component

The Telerik UI for .NET MAUI RichTextEditor control empowers users to generate rich textual content using a comprehensive array of tools. These tools simplify the creation, editing and formatting of text, paragraphs, lists, hyperlinks and various other elements.

The Telerik UI for .NET MAUI RichTextEditor control comes with a multitude of editing capabilities, including:

• Text formatting, such as bold, italic, underline and strikethrough
• Font manipulations, such as size, family and color
• Text selection
• Hyperlink manipulations such as creating, editing and removing hyperlinks
• Read-only state that does not allow text editing
• Copy/Paste/Undo/Redo editing actions

It also has an integrated ToolBar, which effortlessly connects to the commonly used commands provided by the control.

For more information on getting started, visit the Telerik UI for .NET MAUI RichTextEditor control documentation.

TreeView

The new TreeView component in UI for .NET MAUI allows you to visually represent hierarchical data in a collapsible and expandable tree structure. It provides users with an intuitive way to navigate and explore complex information, such as folder structures, organizational charts or category hierarchies.

Here are some of the key features to look for:

• Hierarchical navigation
• Expand/Collapse items
• Commands support
• CheckBox support
• UI virtualization
• Single and multiple selection modes
• Empty template support
• Flexible styling API

For more information on getting started, visit the Telerik UI for .NET MAUI TreeView control documentation.

DataGrid Empty Template Support

The Telerik UI for .NET MAUI DataGrid control introduces the Empty Template functionality. This feature enables you to inform your end users when the control has no data to display.

DataGrid DataTable support

You can bind your .NET MAUI DataGrid to a DataTable and have access to all the cool features. You can add, remove, select, edit item(s) and update DataGrid’s ItemsSource. You can also perform commands and operations like filtering, sorting, grouping and selection.

.NET 6 & .NET 8 Support

As you may be aware, Microsoft officially discontinued .NET 6 support for .NET MAUI back in May. We are announcing that our plans align with this change, and we will be ending our support for .NET MAUI in .NET 6 in November—this should give you extra time to get off .NET 6 and onto .NET 7/8.

This transition marks an exciting milestone as we prepare to welcome the arrival of .NET 8, which will bring a host of new features and enhancements. Rest assured that during this period, we are actively working to ensure a seamless transition and guarantee an official and robust support system for .NET 8, which we will be ready to launch alongside its official release.

Check out the Detailed Release Notes

To get an overview of all the latest components, features and improvements we’ve made, check out the release notes for the product: Telerik UI for .NET MAUI (Release Notes).

Telerik UI for WPF

RadSlideView and RadPipsPager components

RadSlideView is a flexible navigation control that allows you to slide between different views, thus providing an interactive navigation. With it, you can build a gallery display to show your images and content efficiently.

RadPipsPager lets the user navigate a linearly paginated collection using glyphs also known as pips.

The two controls work seamlessly with one another to enhance the navigation experience in your applications.

They also share some of their main features:

• Navigation: The controls allow you to navigate through the data either in a loop or from end to end.
• Orientation: They can be oriented vertically or horizontally.
• Customizing navigation buttons: The navigation buttons can be easily customized.

You can find more information about the new components in their respective documentation sections:

• RadSlideView
• RadPipsPager

Windows 11 Compact Theme

Get ready to elevate your app’s aesthetics and create a masterpiece with the most innovative addition to the R2 2023 Release—a new, high-density (or compact) layout option for the Windows 11 theme. Designed for information rich UI and similar specialized scenarios, this new theme mode brings a stunning and sleek look to your WPF apps.

While functionality and behavior have not changed and remain consistent across the two size and density options, the default heights and offsets have been updated for all controls to support both density options.

For more information on getting started with our latest theme, visit the Telerik UI for WPF theme documentation.

RadDocking: Move Panes Between Multiple Docking Instances

No more moving pane restrictions between docking instances. Users can now create a group of dockings in which moving and docking panes are not limited, no matter if dockings are nested or side by side. This enables powerful UI rearrangement abilities in applications with multiple dockings in a single view.

For more information on getting started with this powerful feature, visit the Telerik UI for WPF RadDocking documentation.

SyntaxEditor: Search UI Enhancements

To better cover well-known scenarios in text or code editing from VisualStudio or NotePad++, we added more search options in the search panel. MatchCase, MatchWholeWord and Regex settings will give your users the powerful search experience they expect.

RadPivotGrid LocalDataSourceProvider Hierarchies

The LocalDataSourceProvider now allows you to display nested properties of the objects in its ItemsSource in a hierarchy similar to how DateTime properties are visualized in the RadPivotFieldList.

Nested properties can be utilized to create a report in the same manner as non-nested ones.

You can enable this functionality by setting the new EnableHierarchy property of the LocalDataSourceProvider to True. Then you will be able to provide a nested property path as the PropertyName of a group description.

<pivot:LocalDataSourceProvider x:Key="dataProvider" EnableHierarchy="True">         
       <pivot:LocalDataSourceProvider.RowGroupDescriptions>
              <pivot:PropertyGroupDescription PropertyName="Customer.Company.Industry" />
              <pivot:PropertyGroupDescription PropertyName="Promotion" />
      </pivot:LocalDataSourceProvider.RowGroupDescriptions>
</pivot:LocalDataSourceProvider>

To see this in action, check out the PivotFieldList demo in the WPF Examples application.

Here is also a list of other popular features we updated for you in this release:

• TreeView: Ability to perform selection on mouse up
• GridView: ExactMatch functionality in search-as-you-type feature
• PropertyGrid: Allow searching for property fields that are not expanded initially

Support for .NET 8 Preview

We are excited to announce that we are extending our support to include the preview versions of .NET 8. While .NET 8 is still in the preview phase, we understand the eagerness to explore its capabilities. We have thoroughly tested our components and have made sure they are compatible with the latest preview releases.

Telerik UI for WinForms

The R2 2023 release comes with a brand-new Heat Map control, a dark Visual Studio 2022 theme, modernized Scheduler appointments, LineNumbering in the RichTextEditor and a ton of other improvements.

Heat Map

RadHeatMap is here to help you visualize numeric data in a meaningful and straightforward way. It uses a two-dimensional layout with indicative colors to represent data. Each entity is represented by a colored rectangle and the applied color maps to the magnitude of its numeric value. At a glimpse, you can spot trends and easily compare different data items.

The component comes with many features like intuitive API, databinding, unbound mode, different colorizers, labels, selection, tooltips and screentips, and custom painting.

For more information on getting started with the HeatMap control, visit the WinForms HeatMap documentation.

Visual Studio 2022 Dark Theme

Yet another member of our family of dark themes is coming. We are expanding this collection because we know that many of you are fans of the dark side. As its name suggests, the theme is inspired by Visual Studio 2022 and its dark mode.

For more information on getting started with our latest theme, visit the Telerik UI for WinForms themes documentation.

Scheduler Appointment Styles

We’ve always strived to create modern components and designs. It was about time for the RadScheduler look to completely change. New appointment styles are coming to RadScheduler—they are fresh, bold and modern. The styles vary from one theme to another, matching its general look and feel.

Line Numbering in RichTextEditor

RadRichTextEditor has a new handy feature—line numbers. The numbers are displayed at the beginning of each line and, if needed, can work independently in different paragraphs, sections or pages. They are quite popular in legal documents, scripts or medical records.

For more information on getting started with this powerful feature, visit the WinForms Line Numbering in RichTextEditor documentation.

Support for .NET 8 Preview

.NET 8 is still in preview but it’s getting increasingly stable. We’ve also played with this new runtime and so far, could not isolate issues with the components. If you are adventurous enough or want to experiment, Telerik UI for WinForms has you covered.

Other Improvements

Besides the highlights above, the 2023 R2 release comes with plenty of other enhancements. I will name just a few that will improve your Telerik UI for WinForms experience:

• Major performance gains in our Visual Studio extensions. Now we are using new APIs allowing us to offload the UI thread. This is an ongoing effort, so expect more in this regard with our next releases.
• We’ve decided to update our distribution with assemblies that are digitally signed. So, if you need those, now you can download them straight from your Telerik account.
• Many fixes and improvements related to importing, printing and copying documents inside the RadRichTextEditor control.

Telerik UI for WinUI

New TimeBar Component

RadTimeBar is a time-bound DataVisualization control. Its chief purpose is to allow lightweight scrolling and navigation through large periods of time. Additionally, the control exposes intuitive API which allows for both declarative and programmatic manipulation of the control.

The component provides the following features:

• Intervals: The control allows you to define the available intervals that will be visualized when you zoom in/out on the control.
• Selection: A time interval can be easily selected via the mouse or by setting a couple of properties of the control.
• Special slots: This feature can be used to highlight different time intervals in the control.
• Custom intervals and formats: The intervals can be customized by implementing a couple of interfaces. This way you can modify the intervals and the date-time formats used to define the appearance of the periods.
• Localization: As all controls in the suite, the RadTimeBar supports several languages. The strings that are localized are the date labels (month, week, etc.).

For more information on getting started, visit the Telerik UI for WinUI TimeBar control documentation.

Telerik UI for Xamarin

In the R2 2023 release, our main focus revolved around Telerik UI for .NET MAUI. However, we are delighted to share that we fulfilled one of the most highly requested features for our Xamarin’s DataGrid component.

Xamarin DataGrid Enchantment: Empty Template Support

This powerful addition allows you to effectively communicate with end-users when the DataGrid control contains no data to display. By utilizing the Empty Template feature, you can provide informative and visually appealing messages (or even images!), enhancing the user experience and ensuring clarity.

Telerik Document Processing Libraries

With the highly anticipated R2 2023 release, we are thrilled to present a plethora of enhancements that span the entire suite. Let’s dive into the highlights of the Telerik Document Processing Libraries, where exciting improvements await:

New PDFProcessing Improvements: Multiple Image-Related Enhancements

In the latest update, the PDF Processing library introduces a valuable addition: an image compression setting. This setting empowers you to define the desired compression level when exporting images. You now have the flexibility to choose between Default, None and FlateDecode compression options, ensuring optimal output quality.

Moreover, we are pleased to announce a new default implementation for the ImageUtils’ JpegImageConverter and ImagePropertiesResolver, leveraging the powerful capabilities of the SkiaSharp library.

New SpreadStreamProcessing Improvements: Support for Importing Rich Text as Plain Text

Now, you have the ability to import rich text and seamlessly extract it as plain text, eliminating any formatting elements. This enhancement simplifies your data processing workflows, allowing you to focus solely on the textual content. Say goodbye to complex formatting concerns and embrace the ease of extracting and working with plain text using the SpreadStreamProcessing library.

Document Processing Libraries: Fixes and Quality Improvements

In the R2 2023 release, the Document Processing team prioritized an extensive range of bug fixes, aiming to deliver a higher level of quality for the library and enhance overall performance. There were 20+ bug fixes in the PDF Processing library alone.

Join Us for Release Webinar (and More)

Progress Telerik .NET Web, Desktop & Mobile Products R2 2023 Release Webinar | June 8

Discover all updates across Telerik UI for Blazor, UI for ASP.NET Core, UI for ASP.NET MVC, UI for ASP.NET AJAX, UI for WPF, UI for WinForms, UI for WinUI, UI for .NET MAUI and UI for Xamarin and ThemeBuilder.

Save Your Seat

Join Us on Twitch

Join the  Livestream Release Party on release day, June 7, 11 a.m. – 12:30 p.m. ET to hear the release news and hang out with dev friends.

The live webinars and Twitch sessions are a great opportunity for you to ask questions before and during the webinars. We’ll be waiting to hear from you on Twitter—just use the #heyTelerik and #heyKendoUI hashtags. Another great option is the live chat during our release session on CodeItLive, our Twitch channel.

One of the comments that I usually hear or read when working with XAML in Xamarin Forms or .NET MAUI is: XAML is difficult or complicated to learn. In this article, I’ll show you that it’s really the opposite—we will see how easy XAML is to handle when making your favorite UIs!

We will be replicating a dating profile UI step by step, inspired by a Dribbble design.

Let’s Start!

First of all, it’s important that you are clear about how to start. I recommend that you do it in a set of steps to maintain organization. That is why we will divide our UI into steps, which compose the structure that we are going to develop during the explanation.

In the image shown below, you will see a set of numbers. Each number is a “step” and we will explain it in detail.

Let’s see the structure:

Starting with the Code: Selecting the Main Layout

To build our screen, we need to add the main layout that will help us place the visual elements of the page. This time, let’s select the Grid, on which we will define three columns and eight rows.

How can I know the correct number of columns and rows to define in my Grid?

Let’s see it in a graphic explanation:

Now let’s see how to translate it to XAML:

<ScrollView Margin="0,-90,0,-40" VerticalScrollBarVisibility="Never">
  <Grid RowDefinitions="Auto,Auto,Auto,Auto,Auto,Auto,Auto,Auto" RowSpacing="15" Margin="30,0,30,30"
  ColumnDefinitions="*,*,*">
      <!-- Add the code from steps one here -- >
      <!-- Add the code from steps two here -- >
      <!-- Add the code from steps three here -- >
    </Grid>
</ScrollView>

We also added a ScrollView so that the design can be scrolled to any size device. If you want to know more information about the Grid, you can access it here. If you want to practice, I also recommend the .NET MAUI Challenge 1: Simple Grid in .NET MAUI.

Now let’s continue with the development of each step of the UI structure presented above.

Main Image and Floating Buttons

We will divide the explanation into substeps:

Main Image

As you can see, the main image has rounded bottom edges. How do we do that? We have two options which are the following:

• Borders: You can use Borders in .NET MAUI. If you want to know more information about Borders, you can enter here.
• Frame: You can also use the Frame to adapt the image to its shape. The key points to round off here are setting the IsClippedToBounds property to True, Padding to 0, and adding a value for the CornerRadius property.

In this case, we will use the Frame. The code looks as follows:

<!-- Rounded main picture-->
<Frame Grid.Column="0" Grid.Row="0" Grid.ColumnSpan="3" Margin="-30,-25,-30,-30" CornerRadius="40" IsClippedToBounds="True" Padding="0">
  <Image Aspect="AspectFill" Source="model.jpeg" HorizontalOptions="FillAndExpand" HeightRequest="410" />
</Frame>
<!-- Add the code explained in the next step here -->

Floating Buttons

Here we have three floating buttons. Let’s see which factors are important to highlight:

• Make the Button float: To get this effect, I used the Margin property. Setting the top value to Negative causes the effect of overlapping with the main image.
• Shadows: The buttons also have shadows. This helps so that even though the start and end buttons have the same background color than the screen, they can be differentiated. You can see more information about Shadows here.

Now let’s convert this to code:

<!-- Floating Buttons-->

<!-- Delete Button-->
<Button Grid.Column="0" Grid.Row="1" Margin="0,-50,0,0" HeightRequest="80" WidthRequest="80" CornerRadius="40" ImageSource="delete" BackgroundColor="White">
  <Button.Shadow>
     <Shadow Brush="#bcbcbc"
   Offset="5,5"
   Opacity="0.6"/>
  </Button.Shadow>
</Button>

<!-- Like Button-->
<Button Grid.Column="1" Grid.Row="1" Margin="0,-50,0,0" HeightRequest="110" WidthRequest="110" CornerRadius="55" ImageSource="heartt" BackgroundColor="#f858a4">
  <Button.Shadow>
    <Shadow Brush="#f8bcd9"
    Offset="5,5"
    Opacity="0.6"/>
  </Button.Shadow>
</Button>

<!-- Rate Button-->
<Button Grid.Column="2" Grid.Row="1" Margin="0,-50,0,0" HeightRequest="80" WidthRequest="80" CornerRadius="40" ImageSource="star" BackgroundColor="White">
  <Button.Shadow>
    <Shadow Brush="#bcbcbc"
    Offset="5,5"
    Opacity="0.6"/>
  </Button.Shadow>
</Button>

<!-- Add the code explained in the next step here -->

Now let’s see the result of this first step:

Details

This step is composed of the following elements:

Name & Role Description and Telegram Button

For the name and role description, we will use a simple Label. And for the Telegram button, we will also use shadows to highlight the button.

<!-- Details-->

<Label Grid.Column="0" Grid.ColumnSpan="2" Grid.Row="2" Text="Madeline, 20" FontAttributes="Bold" Margin="0,20,0,0" FontSize="22"/>

<Label Grid.Column="0" Grid.ColumnSpan="2" Grid.Row="3" Text="Graphic Designer" FontAttributes="Bold" FontSize="16" TextColor="#a3a3a3"/>

<Button Grid.Column="2" Grid.Row="2" Grid.RowSpan="2" HorizontalOptions="End" VerticalOptions="Center" HeightRequest="55" WidthRequest="55" CornerRadius="10" ImageSource="telegram" BackgroundColor="White">
  <Button.Shadow>
    <Shadow Brush="#bcbcbc"
    Offset="5,5"
    Opacity="0.6"/>
  </Button.Shadow>
</Button>

<!-- Add the code explained in the next step here -->

About: Title & Description and Read More Text

<Label Grid.Column="0" Grid.ColumnSpan="2" Grid.Row="4" Text="About" FontAttributes="Bold" FontSize="16" Margin="0,20,0,0"/>

<Label Grid.Column="2" Grid.Row="4" Text="Read more" FontAttributes="Bold" FontSize="15" TextColor="#c0bebe" HorizontalTextAlignment="End" Margin="0,20,0,0"/>

<Label Grid.Column="0" Grid.ColumnSpan="4" Grid.Row="5" Text="My name is Madeline and I enjoy meet new people and finding ways to help them have an uplifting experience ..." FontAttributes="Bold" FontSize="16" TextColor="#a3a3a3"/>

<!-- Add the code explained in the next step here -->

Now let’s see the result of this second step:

Interest List

Finally, let’s add a label for the title and a CollectionView to present the different interests of the profile.

<!-- Interests list-->

<!-- Title-->
<Label Grid.Column="0" Grid.ColumnSpan="2" Grid.Row="6" Text="Interest" FontAttributes="Bold" FontSize="16" Margin="0,20,0,0"/>

<!-- List -->
<CollectionView Grid.Column="0" Grid.ColumnSpan="3" Grid.Row="7" HorizontalScrollBarVisibility="Never"
  ItemsSource="{Binding profile}"
  HeightRequest="120"
  VerticalOptions="FillAndExpand">
    <CollectionView.ItemsLayout>
      <GridItemsLayout Orientation="Horizontal"
      Span="2" />
    </CollectionView.ItemsLayout>
  <CollectionView.ItemTemplate>
    <DataTemplate>
      <StackLayout Padding="0,0,20,0">
        <Button Text="{Binding Description}" TextColor="Black" BackgroundColor="{Binding BgColor}" HorizontalOptions="StartAndExpand" CornerRadius="20" />
      </StackLayout>
    </DataTemplate>
  </CollectionView.ItemTemplate>
</CollectionView>

Let’s see the result:

Conclusion

And done! Our dating profile UI is ready!

If you want to see the complete code, you can go to the GitHub repository.

Thanks for reading!

Use a component library in sync with .NET MAUI’s release cadence. Try Telerik UI for .NET MAUI for free.

If you’re reading this post after the post describing our experience with Telerik ERP app, some of these tips will make even more sense.

Tip for Starting: Use Upgrade Assistant and a Blank New Project

You can make the first step to your migration by using the Upgrade Assistant VS extension as part of VS 2022 or install it separately with cmd. My suggestion is to use it from the cmd, as there you have more visibility over what happens. The extension also does not create backup folder, so have this in mind and back up your project manually.

Also, a nice trick is to use the --non-interactive parameter of the Upgrade Assistant as this saves you time from manually choosing the next step.

The assistant will help by doing these steps for you:

• Update your project file to be SDK-style
• Update Microsoft namespaces
• Address some API changes

After that, you will still have a good number of manual changes to do, such as updating any third-party libraries and API changes.

Some advice I suggest is to use the converted files but to add them manually piece by piece to a newly created blank .NET MAUI app. This will give you a nice shell navigation and a clean, ready-to-build project to start from.

Tip for Namespaces: Use XAML Schemes When Possible

All Xamarin.Forms namespaces are now renamed to match the appropriate MAUI naming. So you can do a mass replace from Xamarin.Forms* to Microsoft.MAUI* or just use the XAML scheme.

Change http://xamarin.com/schemas/2014/forms to http://schemas.microsoft.com/dotnet/2021/maui

This is also true when replacing Telerik UI for Xamarin with Telerik UI for .NET MAUI. Do a mass replace from Telerik.XamarinForms.* to Telerik.MAUI.Controls or just use the XAML scheme: xmlns:telerik="http://schemas.telerik.com/2022/xaml/maui".

For more changes in the Telerik API, you can follow the articles below for Xamarin-to-MAUI migration guides for Telerik UI controls:

• Common migration
• Accordion
• AutoComplete
• CheckBox
• ComboBox
• DataForm
• DatePicker
• DateTimePicker
• Entry
• ImageEditor
• ListPicker
• ListView
• MaskedEntry
• ProgressBar
• SignaturePad
• TemplatedPicker
• TimePicker
• TimeSpanPicker

Tip for Azure Mobile Services

If your mobile app already uses Azure, an important note is that Microsoft.WindowsAzure.MobileServices are now rebranded as Microsoft Datasync.Client.

There are also a lot of API changes, so be sure to read the MS docs before using them.

Tip for Checking the Device: Use the New DeviceInfo and DevicePlatform Classes

Xamarin.Forms has a Xamarin.Forms.Device class that helps you to interact with the device and platform the app is running on. .NET MAUI has several classes to be used instead and not just one to replace it. The most important are Microsoft.Maui.Devices.DeviceInfo.Idiom and DevicePlatform.

Refer to MS doc for the detailed use cases: Device information - .NET MAUI | Microsoft Learn.

A Simple Example of Replacing the Code

Xamarin.Forms code:

if (Device.Idiom == TargetIdiom.Phone)
{

}

.NET MAUI code:

if (DeviceInfo.Idiom == DeviceIdiom.Phone)
  {
  
  }

Tip If Using Microsoft ListView: Replace ListView with CollectionView

.NET MAUI is coming with a better architecture successfully implemented in more of the existing Xamarin components. However, it is completely understandable that not all of the old code can inherit the new changes.

That is why although MAUI ListView has a lot of features and it is completely possible to use it in the same way as in Xamarin, it is recommended to consider its replacement with CollectionView.

Tip for Colors: With 2 New Classes, CommunityToolkit.Maui Is Here to Help

In Xamarin.Forms, the Xamarin.Forms.Color is a struct and lets you construct Color objects using double values, and provides named colors, such as Xamarin.Forms.Color.AliceBlue.

In .NET MAUI, this functionality has been separated into the Microsoft.Maui.Graphics.Color class and the Microsoft.Maui.Graphics.Colors class. So to find the AliceBlue in MAUI, you can use the Colors class which defines 148 public static read-only fields for common colors.

Note also that Xamarin.Forms.Color.Default has no .NET MAUI equivalent. Microsoft.Maui.Graphics.Color objects default to null.

When you convert colors, a nice tool is to look at CommunityToolkit.Maui and the converters that convert colors to and from hex, RBG, etc.

Read more: Converters - .NET MAUI Community Toolkit - .NET Community Toolkit | Microsoft Learn.

Layout Behavior Changes from Xamarin.Forms

The new architecture of .NET MAUI brings changes in the layout too. Look below at some of the layout behavior changes in Xamarin vs MAUI:

These are just the major changes that you will meet when migrating your Xamarin.Forms app to .NET MAUI—but remember, rewriting and improving code cannot come without such changes, and they are a result of a new and better functionality which .NET MAUI brings to the table.

If you meet any other interesting changes, please share them in the comments below and how and whether you managed to resolve it. You can also browse the Telerik KB portal, where we try to describe our experience too.

Telerik UI for .NET MAUI is also here with all the components needed and documentation to ease the journey of apps including Telerik controls, including a guide for how to migrate from Xamarin to MAUI. Try it for FREE. 

If you are reading this, you are already on track to porting your Xamarin project to .NET MAUI and now the topic of platforms customization is what bothers you.

In Xamarin.Forms, one of the main tools you have used is custom renderers. So how do you achieve the same functionality in .NET MAUI? Let’s see:

• What are the options?
• Which one to choose?
• Details for both options

What are the Options?

Currently, we can either:

1. Option 1: Move the code – transfer our old code with some modifications but using the same renderers
2. Option 2: Rewrite renderers to handlers – use the new API and architecture that .NET MAUI offers us, handlers and mappers

So, How to Choose?

The first approach is faster when we are talking about dev time, so choose this as an entry point if you want quick results or if you still have not used handlers.

But have in mind that keeping renderers is not a good solution in the long term as the new approach is there for a purpose and to stay. Handlers and mappers are the result of the new and better architecture of .NET MAUI which brings us performance improvements and easy support for new platforms.

However, one important thing to consider also—not all Microsoft custom renderers are ported to the new technology as a Cell or ListView. In this case, if you use them, you simply do not have a choice—your custom renderer must stay for now. However, such components are rarer and rarer—check them in the Microsoft article here.

Now, let’s review both options in detail.

Option 1: Continue to Use the Same Renderers

With some modification, the custom renderers from your Xamarin app can be reused and are still supported in .NET MAUI. However, note that this will not be the case in the long term, so this is a short-term solution and the recommended way is to scroll to the second option.

Still, here are the main steps to add the custom renderers from your Xamarin project to .NET MAUI. It is important to know that you can still use your renderers almost without change. To do that you need to:

1. Move the Files to the Right Place

Every new .NET MAUI project has a Platforms folder with a subfolder for the respective platforms. Move your renderers there.

For example, if we want to customize the entry control, we will have the same custom MyEntry.cs class to inherit the Entry and custom renderer for every affected platform:

Xamarin vs .NET MAUI files

2. Modify the Code a Little Bit

If you still haven’t changed the namespaces, now it is the time.

Any reference to Xamarin.Forms.* namespaces need to be removed, and then you can resolve the related types to Microsoft.Maui.*.

You should also remove any ExportRenderer attributes as they won’t be needed in .NET MAUI. For example, the following should be removed for a UWP-specific renderer:

[assembly: ExportRenderer(typeof(MyEntry), typeof(XamarinRendererProject.UWP.MyEntryRenderer))]

namespace XamarinRendererProject.UWP

{

}

3. Register the Renderers

Open MauiProgram.cs.

Add a using statement for the Microsoft.Maui.Controls.Compatibility.Hosting namespace.

Call UseMauiCompatibility on the MauiAppBuilder object in the CreateMauiApp method, and configure each renderer using conditional compilation per platform:

using Microsoft.Maui.Controls.Compatibility.Hosting;  
public static class MauiProgram  
{  
  public static MauiApp CreateMauiApp()  
  {  
    var builder = MauiApp.CreateBuilder();  
    builder .UseMauiApp<App>()  
    .UseMauiCompatibility()  
    .ConfigureFonts(fonts => { fonts.AddFont("OpenSans-Regular.ttf", "OpenSansRegular"); fonts.AddFont("OpenSans-Semibold.ttf", "OpenSansSemibold"); }) 
    .ConfigureMauiHandlers((handlers) => {  
      #if Windows handlers.AddHandler(typeof(MyEntry), typeof(MyMauiProject.Windows.Renderers. MyEntryRenderer));  

      #elif IOS...... 
      #endif  
    });  
    return builder.Build(); 
  }  
} 

So it is working. Then why are we talking about migration? Renderers are one of the architectural changes that bring us performance improvement in .NET MAUI compared to Xamarin.Form. Also, although renderers are currently supported, Microsoft does not claim that this will be true in the upcoming version of .NET.

Option 2: Using Handlers and Mappers

This new handler concept is one of the key aspects of evolving Xamarin to .NET MAUI and in the improved performers and ability to support more platforms.

So, What are These Handlers?

The handlers are already implemented classes in .NET MAUI that match to every type of control/view that exists in .NET MAUI via an interface.

Note that their scope is global. This means that if we use and modify one handler for a control—let’s say Button—this customization will affect all buttons.

.NET MAUI handlers are accessed through their control-specific interface, such as IButton for a Button. This avoids the cross-platform control having to reference its handler, and the handler having to reference the cross-platform control. Clean architecture, right? 

Some important properties that we need to know to understand the concept:

• PlatformView – Each handler class exposes the native view for the cross-platform control via its PlatformView property. This property can be accessed to set native view properties, invoke native view methods, and subscribe to native view events.
• VirtualView – The cross-platform control implemented by the handler is exposed via its VirtualView property.

What are Mappers?

Handlers can be used and accessed, but when we want to modify how a specific property or behavior to be changed, we actually use mappers.

There are two types of mappers:

• A property mapper defines what Actions to take when a property change occurs in the cross-platform control. It’s a Dictionary that maps the cross-platform control’s properties to their associated Actions. Each platform handler then provides implementations of the Actions, which manipulate the native view API. This ensures that when a property is set on a cross-platform control, the underlying native view is updated as required.
• A command mapper defines what Actions to take when the cross-platform control sends commands to native views.

So, handlers and mappers are great, but how do we use them? For example, how can we port our code and modify the color of Entry component? Here are three ways.

Scenario 1: Access the Handler When You Need to Modify It

This approach is not very difficult, and it is just one of the major scenarios to use handlers. To use this approach, simply add the “Handler” keyword to the component you need to modify (for example, in the constructor of our content page) and you will be good to use it.

When you want to customize the entry, you will need EntryHandler—for a button, ButtonHandler, etc.

Ex: Microsoft.Maui.Handlers.EntryHandler

Then set the right mapping and use the PlatformView to access the native control. (MyCustomization is a sample key name that we put in our mapping.)

void  ModifyEntry()
{
Microsoft.Maui.Handlers.EntryHandler.Mapper.AppendToMapping("**MyCustomization**", (handler, view) =>
{
#if WINDOWS
if (view is MyEntry) //here we check and customize only MyEntry instances and not all entries, without this we can easily customize all entries if we needed it
{
handler.PlatformView.Background = Brush.Cyan;
}
#endif
});
}

Scenario 2: Use Handler Lifecycle Events to Access It and Modify Properties of the Components

Handlers have their lifecycles and set of events that we can listen to. For example, we can subscribe to the Entry instance and listen for HandlerChanged and HandlerChanging and change the properties that we need there.

A complete example can be found in MS docs .NET MAUI control customization with handlers - .NET MAUI | Microsoft Learn and in Telerik docs showing this approach with RadListView.

Scenario 3: Create a Custom Component and Create a Whole New Handler

The process for this approach is based on six steps:

1. Create an interface, implementing IView.
2. Create a subclass of the ViewHandler
3. In the ViewHandler subclass, override the CreatePlatformView method that renders the platform control.
4. Create the PropertyMapper dictionary, which handles what actions to take when property changes occur.
5. Create a custom control by subclassing the View class and implementing the control interface.
6. Register the handler using the AddHandler method in the MauiProgram class.

For the full detailed example—please go to the MS docs here.

Conclusion

Handlers are so flexible, they bring performance improvement and their API is more extensible. However, it needs time to get used to the concept, but it is worth it and is one of the major reasons to make .NET MAUI better than Xamarin.Forms. So, go ahead and play with this. You can also consider reading Xamarin to MAUI migration tips on Telerik and Microsoft for more scenarios.

In the previous post, we reviewed the pros and cons of migrating our code from Xamarin.Forms to .NET MAUI. In this post we will highlight the major points of planning the migration.

In short, these are the things that are good to consider before starting:

• Prepare your environment
• Review DataModels
• Choose a navigation pattern
• Analyze third-party libraries
• Benefit from Azure support
• Take a minute to think about Windows UI and the desktop experience
• Leave customization until the end
• Stay tuned for the next posts where we will review more API changes and some manual work you need to do in renaming APIs

1. Install VS 2022 and Set up Your .NET MAUI Environment

This is a basic but very important step for our process. Installing the latest version of VS 2022 or VS for Mac should set up most all that you need to start your development. Still, for Mac there are some additional requirements, such as:

• A Mac that is compatible with the latest version of Xcode. For more information, see Apple’s minimum requirements documentation.
• The latest version of Xcode.
• An Apple ID and paid Apple Developer Program enrollment. An Apple ID is required to deploy apps to devices, and to submit apps to the Apple Store.

Note: Full steps can be found on Microsoft’s documentation site—check it for latest updates.

Once you are ready, you will be able to start with a basic .NET MAUI app—which is a great starting point. Create one and have a look at it as we will use it as reference during the migration.

Another important tool that we will use during the migration is .NET Update Assistant. You can now download it too from VS MarketPlace, but I still recommend it to use it via cmd as the extension has some limitations. You can install it simply with the following command:

dotnet tool install -g --add-source "https://api.nuget.org/v3/index.json" --ignore-failed-sources upgrade-assistant

2. Review Data Models and Patterns of Your Existing App

Now is a good time to review how the code separation is handled in your app and to decide whether to migrate it directly or consider changing it as .NET MAUI support improved MVVM support and a new MVU pattern is also added.

If you already using MVVM in your app, it is more natural to stay on it. It’s a great and widely used pattern. But if this is the case, there are some other important notes to consider if you use one of the popular MVVM helper libraries:

MVVM cross is popular for Xamarin, but currently not supported with .NET MAUI. As an alternative, you can rely purely on the built-in MVVM MAUI support or consider using MVVM Community toolkit.

3. Choose a Navigation Pattern

.NET MAUI supports great shell navigation and every sample .NET MAUI app contains a template ready to start with. If you do not use shell navigation, consider this change as a step in the migration plan: .NET MAUI Shell navigation - .NET MAUI | Microsoft Learn. Using basic page navigation is also an option: FlyoutPage, TabbedPage and NavigationPage.

4. Check Whether Your Third-Party Libraries Support .NET MAUI

This is an important step in preparation. Check this in advance and find alternatives of your APIs if not.

One such library is Progress Telerik UI for Xamarin—don’t worry, we’ve got you covered. You can replace it safely with Telerik UI for .NET MAUI, and comes with helpful documentation for migrating from Xamarin to .NET MAUI.

5. Azure Support

Where is your data service published? What kind of login authentication do you have? Take a step to consider the usage of Azure for all of these if you still haven’t.

If your mobile already uses Azure, an important note is that Microsoft.WindowsAzure.MobileServices are now rebranded as Microsoft Datasync.Client. Read a full explanation and sample in Microsoft docs: Build a .NET MAUI app with Azure Mobile Apps | Microsoft Learn—or in one of our next posts where we will integrate Telerik .NET MAUI app and Azure mobile .

So plan migration of Azure references as a separate step and read resources before that.

6. Take a Minute to Consider the Future of Windows Support

With .NET MAUI Windows, support is focused more on the desktop side, so now is time to consider whether you need to polish the UI of the Windows version to be a little better for your desktop users. If Windows is not a priority for you, you can still leave this part for debugging and easy development purposes.

7. Have You Used Custom Renderers to Customize the Native Controls?

Consider their migration to .NET MAUI handlers by preparing yourself with handlers architecture and following our series where we will describe the options here—should we use the handlers architecture or migrate the renderers directly?

8. Follow Us for More Guidance

There are some API changes in .NET MAUI vs Xamarin that you should consider when migrating. We will review them in the next two posts explaining how we managed to migrate our ERP app.

Let’s first start with why we decided to focus on the topic of migrating from Xamarin.Forms to .NET MAUI in a whole series of five posts. .NET MAUI is the new hot dotnet technology, but should we consider migrating our existing app right away or is better to hold on with this decision? This is a question that every good PM, team lead and software engineer asks themselves when such a trend appears.

With this post I want to explore the right way to decide whether migration from Xamarin.Forms to .NET MAUI is the right path for your code, team and application and whether you should consider it.

So how to decide? To make an informed decision, let’s answer to the following questions:

• What are the benefits of migrating to .NET MAUI—for the development process and for the app and the end users?
• What are the cons?
• Is the technology mature enough?
• Are there any risks for my code if I do not migrate to .NET MAUI?

What are the Benefits of Migrating to .NET MAUI?

.NET MAUI is a successor of an already existing technology—Xamarin.Forms—so it is designed to improve weaknesses and add more benefits when we are talking about the development of cross-platform apps. There are benefits for both the development experience and the end result. Let’s review all of them:

Easier Development and Benefits for the Team

I will start with the most important part for every dev—the performance and the experience of the development process. With .NET MAUI, this is a way easier than development with Xamarin.Forms. Let’s see why:

1. .NET MAUI is Part of .NET

This is the major change—the architecture of the new framework is designed by Microsoft with the main goal of being integrated into .NET and simply being better than Xamarin.Forms.

.NET Multi-platform App UI (.NET MAUI) is integrated into .NET, while Xamarin is not, although it is still part of .NET Core 3.1. So, due to the integration of .NET 6, 7 and 8, you can use the new C# and .NET features in .NET MAUI for your enterprise development.

Starting with .NET 7, .NET MAUI will align with the .NET release cadence—that is, .NET MAUI 7.0 will ship with .NET 7.0, .NET MAUI 8.0 ships with .NET 8.0, and so on.

2. Better Tooling

VS 2022 and VS 2022 for Mac install the MAUI workloads directly and take care of the smooth dev experience. Coming as part of VS installer, installing and updating .NET MAUI is way easier for engineers.

With VS 2022 there are also AI-assisted code suggestions as IntelliCode, which gives developers a powerful set of automatic code completions that understand .NET MAUI app UI and code. When a dev starts typing, it will understand the code context, variable names, functions, and even provide better IntelliSense and suggest whole line completions.

Other tools that speed the development process are:

• XAML Live Preview – allows when code is changed to see the results immediately.
• XAML Hot Reload – change UI and see them in the running app with your real data right away.
• .NET Hot Reload – the ultimate tool that you can use to make changes to your code, save and see those changes without losing your application state.

3. Frequent Upgrades and Addressing Our Feedback

Currently .NET MAUI is one of the key technologies that Microsoft is focused on and there are a lot of channels that MS is using to gather feedback and address it. This is great because if there is something you do not like, you have power as a developer to let them know—write feedback or contribute to the repo, which is very active.

4. Command Line Support

Another advantage of using .NET MAUI is that it runs on .NET CLI. The .NET command-line interface (CLI) is a cross-platform toolchain for developing, building, running and publishing .NET apps.

5. Simple Project Structure

Honestly, this is my favorite. If you have ever used Xamarin.Forms, you probably know that it uses separate projects for each target platform. With .NET MAUI, you will no longer have this problem, as here, all the platforms can easily be managed in a single project. To create a .NET MAUI project, you can find all necessary features like fonts, app icons, images, styling, raw assets and splash screen in the Resources folder. MAUI will do the rest by optimizing them for each platform’s specific requirements.

This also makes it easier to share not only resources but tests too.

6. Better Customization

.NET MAUI is coming with completely new architecture. It has two main purposes—performance optimizations and decoupling of custom code from the native UI. With this change, adding support of new platforms even when they need custom experience is easier to add.

Let’s try to explain it a little bit more:

MAUI introduces new abstract layer of controls interfaces. And a new concept, called Handlers which depend only on interfaces, but not on the implementation of UI controls:

Xamarin.Forms implementation of renderers architecture

.NET MAUI implementation of handlers architecture

So, to customize the behavior we can now write our own handlers classes and mappers instead of renderers.

This makes the developer’s life easier—we can easily modify the handler to exclude/include more platforms. This is a great feature having in mind that adding a new OS is always an option.

7. Better Handling of Resources in NET MAUI

With .NET MAUI we can manage the resources more easily too. As a result of the SDK style project, there is a folder named Resources, under which SVG images are included and used as the image source and splash screen.

In .NET MAUI, resource files can be tagged into different categories using BuildAction based on the role they play in the project. You can use the table below for reference:

8. Inclusion of Graphics

In Xamarin.Forms, you can’t find any direct APIs for drawing graphics. However, with .NET MAUI, the situation is different: its cross-platform graphics functionality offers a drawing canvas for painting and drawing shapes. Graphics modes such as paint, winding and blend are available. A nice scenario is also the better approach for handling images with Graphics.

9. Unification of Libraries

.NET Multi-platform App UI now includes a lot of open-source APIs as Xamarin.Essentials directly into MAUI. This enables access to features like .NET MAUI secure storage, contacts, photos, device sensors, authentication and other services.

10. Modern Patterns

.NET MAUI is also a one step closer to other modern frameworks introducing MVU and RxUI support together with the favorite of a lot of devs—the MVVM pattern.

Benefits for the App

Now it is the to review possibilities that the new platform brings to the application to make it more attractive to end users—maybe actually bringing you more new users!

11. Continuous Performance Improvements

The Microsoft teams that develop the .NET stack are focused on improving performance. They are committed to this, and .NET MAUI is no exception to this rule. MS improved the performance mostly with the new architecture and introducing the Handlers conception, but the MAUI team is also committed to continuing improvements in this area. Read more about .NET MAUI performance here.

12. Better Accessibility Support

With Semantic properties, developers can define information about which controls should receive accessibility focus and which text should be read aloud to the user. Semantic properties are attached properties that can be added to any element to set the underlying platform accessibility APIs. This will make .NET MAUI app more accessible compared to its Xamarin.Forms version.

13. Multiple Windows and More to Expect

This is just one of the recent features that Microsoft added to .NET MAUI which was really missed and needed for a desktop behavior. This one again shows the commitment in the development of this framework and that it is here to stay.

14. Desktop & Blazor Support is Also Important

Targeting MacOS and Windows desktop users for real. So now it is not just a mobile framework that runs on Windows, but a cross-platform framework focused on desktop experience. Multi-windows, context menus and many more features are added to .NET MAUI to allow this.

With Blazor and .NET MAUI Blazor Hybrid apps, you can really extend your existing code to fit your needs—you can reuse Blazor code and offer a real desktop experience with unified UI to all devices as Blazor components are able to access native APIs from code behind!

Are There Any Cons if I Migrate?

The short answer is no—.NET MAUI is the successor of Xamarin.Forms so it is simply better. However, there are some things to consider before making the final decision.

1. There are some unsupported platforms such as WPF, UWP or Android versions less than 21. They are unsupported for a reason—Windows support now relies on WinUI and the Android version is quicky increasing, but still have this info in mind.

See the table for details about .NET MAUI vs Xamarin platforms support:

2. There is also a learning curve during the migration, but we are here to help—stay tuned for the rest of the posts in this series to understand in detail how you can handle the learning curve.

3. And, of course, consider the cost of time. Should you use the time of your team for migration or for developing new features of the existing Xamarin.Forms app? There is no one answer here as this really depends on your app, but I hope that this series will help you to estimate the migration time and also speed it up with some guidance.

Is .NET MAUI Mature Enough for a Production App?

.NET MAUI is an official technology stack now. It came with .NET 6 to start, and the issues typical for a new tech are addressed in .NET 7, and many more capabilities continue to be added in .NET 8. Some of them you can already see in the preview version.

.NET 7 and VS 2022 provide us with a stable version of the framework to be used. Also Microsoft documentation and the resource hub provide us with a lot of resources that we can use. The .NET MAUI repo is active and devs’ feedback is taken into account in a good amount of time.

Another important area to secure this answer is that a lot of third-party APIs, such as Progress Telerik, now provide their version supporting .NET MAUI. And Progress Telerik makes it easy to migrate, with detailed Xamarin to MAUI documentation to guide you through the process step by step.

All of these make .NET MAUI not just a good choice for a production app, but a “must-do” next step.

Is There Any Risk if I Do Not Migrate or Delay Migration?

Xamarin.Forms support will end on May 1, 2024, and although there is a year, it is not a good idea to wait until the last moment. Start now and have enough time to safely migrate your app and even consider expanding it with desktop and web support.

As a conclusion, I believe the natural path of every Xamarin.Forms app is .NET MAUI, but the final decision is yours.

If you decide to migrate, stay tuned for the next posts where I will describe with more detail how to migrate your current Xamarin.Forms app based on one of our Telerik demo applications or start now following Telerik documentation for migrating from Xamarin to .NET MAUI.

If your decision is not to migrate, please leave a comment and share more why.

Next up: Part 2: Things to Consider When Planning Your Migration from Xamarin.Forms to .NET MAUI

Layouts in .NET MAUI have evolved from what we knew in Xamarin Forms. Developers now need to adapt to these changes that ensure good practices for better user experience and performance.

Although the changes to the layouts are small, they are important to keep in mind. For example, some default values will no longer be present, and some properties must now be explicitly stated. In this article, we’ll cover these changes so that we can continue to build high-quality applications on .NET MAUI.

The explanation will be divided into the following points:

• Layout behavior differences in Xamarin Forms and .NET MAUI
• Changing default layout values from Xamarin Forms to .NET MAUI

Layout Behavior Differences in Xamarin Forms and .NET MAUI

If you are familiar with Xamarin Forms or have a project to migrate, it is important to keep in mind the changes that the Microsoft team has made in .NET MAUI.

To better understand these changes, I will divide this explanation by layout, as you will see below:

Grid Layout

In Xamarin Forms, it was not necessary to declare both rows and columns, as they could be generated automatically based on the controls that the Grid contained. (However, it was still good practice to declare them explicitly.) But in .NET MAUI, it’s mandatory to declare both columns and rows explicitly.

⚠️ If your Grid contains only one row and one column, .NET MAUI creates it by default, and you don’t have to specify it. However, if you need more rows and columns, you must set the ColumnDefinitions and RowDefinitions properties.

HorizontalStackLayout and VerticalStackLayout

If you’ve worked with Xamarin.Forms, you may have come across values that end with AndExpand, such as EndAndExpand. These are known as expansion values, which define alignment preferences. However, in .NET MAUI, they no longer have any effect.

For example, if you include a value with AndExpand (e.g., CenterAndExpand), it will be ignored and only the main prefix will be used (in this case, Center).

StackLayout

In Xamarin Forms, children can fill space in the stacking direction. However, in .NET MAUI, children are stacked and may go beyond the available space. If you need child views to fill space, switch to a Grid.

It’s important that you know that if you use the VerticalStackLayout or the HorizontalStackLayout instead of the StackLayout, you will get the same result and it will give you better performance.

To simplify migration from Xamarin.Forms to .NET MAUI, StackLayout still allows for the AndExpand layout options. However, these options have been marked as obsolete. That’s why I recommend you update your code by removing AndExpand, even if it still works, in order to avoid obsolete code in your project.

Here are some behavior points to consider when using a StackLayout:

• Any properties that conflict with the stacking direction should be removed. For example, if StackLayout has a vertical orientation and a child element has HorizontalAlignment="CenterAndExpand", the latter property will have no effect and should be removed.
• If you have any remaining AndExpand values in the StackLayout, you should convert them to a Grid. A Grid allows for space to be subdivided and will produce the same result as AndExpand in Xamarin.Forms. Let’s see an example of .NET MAUI vs Xamarin Forms:

✍️ Anything marked AndExpand in a StackLayout should be placed on its own row or column in the Grid and given a proportional size (*).

RelativeLayout

This layout is not available and not recommended for use in .NET MAUI. Instead, you can use the Grid, which will allow you to achieve the same result with better performance.

⚠️ If you still need to add RelativeLayout, you must include the compatibility namespace that can be found in Microsoft.Maui.Controls.Compatibility namespace. You can see how to do it in the image attached below.

Namespace

xmlns:compat="clr-namespace:Microsoft.Maui.Controls.Compatibility;assembly=Microsoft.Maui.Controls"

ScrollView

In Xamarin Forms, the ScrollView has certain minimum size limits that are partially dependent on its content, and it’s sometimes compressed to accommodate other elements on the page within a StackLayout. As a result, its behavior can be inconsistent.

In .NET MAUI, the ScrollView can be expanded to any desired size, unless otherwise specified. This means that when placed inside a VerticalStackLayout, which can expand indefinitely, the ScrollView will expand to the full height of the content. If you want to limit your content to a specific space in one direction, you should use a different layout, such as a Grid.

To keep in mind for all the layouts:

• You must be careful when using sizes in .NET MAUI, because the value you send is respected 100% regardless of the device size. For example, if you send a control with a width of 200 yet the device has a width of only 100, it will still be established with a width of 200.

Changing Default Layout Values from Xamarin Forms to .NET MAUI

Xamarin Forms has default values set for some properties. In .NET MAUI, these values are set to zero.

But … Is it possible to keep these values?

• Yes, it’s possible. You can do this by adding implicit styles to your project. For more information about implicit styles, please visit the How to work with Styles XAML article.
• To achieve this, keep in mind that the .NET MAUI template already includes default resource dictionaries that provide styles for almost all controls. Therefore, the ideal approach is to modify these same styles that were previously created by .NET MAUI.

The following are the Layout property values that have changed:

If you want to know more information about Layouts in .NET MAUI, you can read the article Exploring Layout Options in .NET MAUI.

Conclusion

I hope you can easily adapt to these small layout changes and continue building wonderful applications in .NET MAUI! I hope you enjoyed this!

See you next time! ‍♀️

References

This article was based on the official documentation:

• https://learn.microsoft.com/en-us/dotnet/maui/migration/layouts?view=net-maui-7.0

Use a component library in sync with .NET MAUI’s release cadence. Try Telerik UI for .NET MAUI for free.

Telerik UI for WinForms

Hey, hey, hey! WinForms is here! With the R1 2023 release, our Telerik UI for WinForms suite grows stronger—from two new controls and a new theme to new functionalities. We are also happy to share that with this official release of Telerik UI for WinForms, .NET 7 is fully supported. Cool, right?

Now, let’s bring more light to the new goodies which come with R1 2023 release. With the current release, the team targets one of the most important obstacles every developer must overcome: designing a functional interface.

We will start with the new controls, which I think will bring a smile to your face.

Windows 11 Theme

New year, new controls, new look. To be up to date with the latest fashion trends and to look shiny as hell, let’s welcome Windows 11 theme to the Telerik UI for WinForms suite. To see how cool it looks, you can check it out in our Theme Viewer tool, where you can also see all other themes included in Telerik UI for WinForms package.

ToolbarForm

Saving space in large applications is crucial for being user-friendly and staying competitive in the market. The RadToolbarForm extends its non-client area and allows adding various UI elements: buttons, dropdown menus, text boxes and more. The title bar is separated into three sections which can be populated with different controls per your requirements. You can use this form to create modern apps like Visual Studio, Microsoft Word or Excel, Outlook, etc.

TaskbarButton

Let me share a secret with you. You can use the taskbar for more than seeing your apps and checking the time.

The RadTaskbarButton component allows you to interact with the Windows Taskbar and gives developers the proper API to define the style for their application’s taskbar button.

By utilizing the taskbar, you can give the end user a shortcut to your application’s internal commands or show a loading indicator when the application is loading or a long running task is currently in progress.

There are other functionalities like showing a badge on the taskbar icon to show the current status of the application, modifying the jump list by adding shortcuts to other related applications, etc.

These functionalities are only part of the API which you can use. I think you know where you can read more about them, but still I will give you a hint: In our RadTaskbarButton Online Documentation.

Don’t leave your taskbar application icon hanging on the screen like you don’t know what to do with it. Show them that they are wrong!

If you think that is all, let us check some of the other perks.

SyntaxEditor: Word Wrapping

SyntaxEditor control is a great text editor tool which provides built-in syntax highlighting and code editing experience for popular languages. What was missing so far was word wrapping functionality. What is a text editor without word-wrap?

This release, we add this functionality to the control. When the feature is enabled, the horizontal scroll bar is removed, and all the text is horizontally fit in the available space.

We have also included an additional margin that holds the icons and can be removed if needed. I’m sure you have seen this view mode in many editors and IDEs, so I hope it will make your WinForms applications which use our RadSyntaxEditor more useful and user friendly.

To see how to use this functionality, please check the Word Wrap article from the SyntaxEditor help documentation.

.NET 7 Support

During the last year, we’ve implemented and shipped support for the various preview versions of .NET 7. With this release, we are shipping support for the official version of .NET 7. This is the first major release which fully supports .NET 7.

Also, we have removed the .NET 5 support with the .NET 7 introduction, so please consider upgrading your .NET 5 applications to newer .NET. With the R1 2023 release, DLLs targeting .NET 5 will not be available for download from your account nor the NuGet package for .NET 5.

Revamped Icons

The new release and the new theme brought a new glyph font—the TelerikFluentIcons. It contains a similar set of icons to the TelerikWebUI but with a different visual appearance to better match the Windows 11 iconography. The glyphs have been redesigned to embrace a softer geometry and more modern metaphors.

WinUI

Find out what’s new in Telerik UI for WinUI 2.4.0!

Calculator

Announcing the brand-new Calculator control for WinUI! I guess there is no need to explain in detail what Calculator is?! However, let’s say couple words about it. RadCalculator is a useful component that enables your users to perform calculations directly in the WinUI application, without navigating to a different app. The control has an easy-to-use interface providing all basic calculations such as addition, subtraction, multiplication and division, as well as some more complicated ones—reciprocal, square root, negate. Furthermore, all the Memory and Clear features are exposed as well.

Check out the key features below:

• Basic calculations — addition, subtraction, multiplication, division
• Additional calculations — negate, square root, reciprocal
• Memory functionality
• Clear entry, clear all, delete functionality
• Customized functions
• UI automation support

For more information about the control, make sure to check out the Calculator section in our online help documentation.

CalculatorPicker

RadCalculatorPicker is an additional component that provides a quick way to show and use RadCalculator in scenarios where saving space is important. One very useful use case would be to use the Calculator as editor of the cell value of DataGrid (as seen in the screenshot above). I’m sure you will make good use of it! For more details, check out the CalculatorPicker article in our help documentation.

.NET 6 and Windows App Sdk 1.2 Support

With this release we are removing the .NET 5 support and adding .NET 6 with Windows App SDK 1.2 support. So, if you are still on .NET 5, make sure to migrate to .NET 6. And if you have any issues with migration, do not hesitate to contact us.

Check out the Detailed Release Notes

We have a lot more! To get an overview of all the latest features and improvements we’ve made, check out the Telerik UI for WinUI (Release Notes).

Telerik UI for WPF

Let’s take a look at what’s new in Telerik UI for WPF with R1 2023.

OfficeNavigationBar

Our brand new OfficeNavigationBar component is inspired by the MS Outlook Navigation Bar. It allows you to easily navigate between different views and offers the ability to quicky access a minimalistic subset of a view within a popup window.

Here are some of the features it provides:

• DisplayModes – compact or full mode
• Navigation Options Window – allows controlling the order and maximum number of visible items, switching between display modes
• Peek Window – displays a callout over the selected item (or item under mouse) which can host additional info or UserControls (views) associated with the item

For more information about the control, make sure to check out its online help docs.

Map: Vector Tiles Support

We are glad to announce that the most voted Map feature in the latest years—support for vector tiles—is now here!

Vector data consists of mainly geometry and text definitions which is rendered on the client. All data is separated in layers and every layer can be styled with style definition located in JSON file referenced in your application. This brings a new level of flexibility and customization options, allowing users to create various map appearances.

The new map feature consists of several new providers allowing connection to online vector tile services or rendering local vector data:

• MapBoxMapProvider – connects to online MapBox vector tile service via access token
• MbTilesMapProvider – renders local mbtiles data (sql archives which may contain both vector and raster tile layers)
• UriVectorTileMapProvider – renders data from local pbf/mvt vector tile files
• VectorTileMapProvider, VectorTileMapSource, IMapStreamProvider – base public classes / interfaces for developing custom vector providers

Vector tiles are generally a great opportunity to enrich, customize and provide a modern look to your mapping applications, so we would love to hear any feedback you may have on the matter. Please drop us a line about how it goes when you integrate them.

ScheduleView: Improve Performance with a Lot of Resources

This release, we added a highly requested improvement in the rendering of the resource group headers. They are now virtualized, and this enables a smooth user experience, especially when resources come in hundreds or thousands.

You can enable the feature by setting the IsGroupHeadersVirtualizationEnabled property to true.

Previously such heavy UI resulted in thousands of UI elements rendered on load, but now only the resources, special slots and appointments visible in the viewport are generated, allowing smoother scrolling experience.

To get into more details regarding this feature, you can visit its documentation article.

RichTextBox: New Selection Mode

The new selection mode allows you to select whole words similarly to Microsoft Word. It can be enabled by setting the IsAdvancedSelectionEnabled property. The following GIF shows how this works.

PivotGrid: Load Data from OLAP Cube on Demand (Lazy Loading)

The new load on demand feature will increase the performance of your OLAP-based PivotGrid scenarios. It allows you to fetch the needed data only when the associated group gets expanded.

By default, the OLAP data providers (XmlaDataProvider and AdomdDataProvider) will pre-load all the data from the associated cube and display it in the PivotGrid. To change this behavior, set the EnableLoadOnDemand property of the data provider to true.

ChartView: Create Histogram Charts with ScatterRangeBarSeries and ChartHistogramSource

With the new ScatterRangeBarSeries and the ChartHistogramSource, you can now create histogram charts. These types of charts are generally used to visualize continuous data, measured in two directions (values). It is, however, just a use case of the ScatterRangeBarSeries which can handle non-continuous data sets too. Here is a quick set up of a sample scatter range bar chart:

First, we give some data via ScatterBarInfo instances:

public MyUserControl()  
{  
    InitializeComponent();   
 
    var source = new ObservableCollection<ScatterBarInfo>(); 
    source.Add(new ScatterBarInfo(0, 4, 8, 10)); 
    source.Add(new ScatterBarInfo(6, 10, 1, 6)); 
    source.Add(new ScatterBarInfo(1, 1.5, 1, 6.5)); 
    source.Add(new ScatterBarInfo(3, 3.5, 4, 5)); 
    source.Add(new ScatterBarInfo(8, 11, 7, 11)); 
    this.scatterRangeBarSeries.ItemsSource = source;  
}

Then we bind the data via four major range-definition properties:

<telerik:ScatterRangeBarSeries x:Name="scatterRangeBarSeries"  
                  HorizontalLowBinding="HorizontalLow"  
                               HorizontalHighBinding="HorizontalHigh" 
                               VerticalLowBinding="VerticalLow" 
                               VerticalHighBinding="VerticalHigh" 
               ItemsSource="{Binding}" /> 

Please follow the databinding help section to get into more details on how to populate the scatter range bars with data in a MVVM way.

End of .NET 5 Support

As you may know, since May 2022 .NET 5 is out of Microsoft support. Being up to date with the current technology trends, from this release on, we will no longer support .NET 5. This includes assemblies, NuGet packages VS extensions. We generally encourage you to switch your apps to .NET 6 and .NET 7 (you know we have Day-Zero, support for .Net7, right ?) in the near future.

However, if this sounds pressing to you, you can consider using .NET Core 3.1 which we will still ship for several releases (until .NET 8 is released).

Other Features

• Common: Added ValidationErrorTemplateHelper.DisplayMode supporting different kind of visualizations of the error message.
• ChartView: Added API for showing empty content between the axis when there is no data.
• ComboBox: Added option to select partial matches.
• Diagrams: Exposed constant to control minimum distance for which snapping next to shapes is enabled during connection manipulation.
• GridView: Added GridViewAlternateRowStyle which can be used for setting an alternating row background.
• GridView: Implemented an option to change the default number of distinct values shown by setting the DefaultDistinctValuesCount property.
• RichTextBox: Introduced support for East Asian Font attribute when exporting Run fonts.
• TabControl: Added option to allow inverting the scroll direction when using the mouse wheel over the tab strip panel.

Check out the Detailed Release Notes

We have a lot more! To get an overview of all the latest features and improvements we’ve made, check out the release notes for the products below:

Telerik UI for WPF (Release Notes)
Telerik UI for Silverlight (Release Notes)

Telerik Document Processing Libraries

The R1 2023 release brings numerous improvements across the entire suite. Here are some of the highlights of the Telerik Document Processing Libraries:

New Encryption Mode Supported in RadPdfProcessing Library

We have added support for the Encryption Algorithm 5 with AES-256, which was one of the most demanded features. Here are the currently supported algorithms:

• Supported encryption algorithms for import : RC4 (V2), AES-128 (AESV2), AES-256 (AESV3)
• Supported encryption algorithms for export: RC4 (V2), AES-256 (AESV3)

The encryption algorithm is controlled by the EncryptionType property of the export settings. Detailed information is available here: Export settings.

New Search API in the RadPdfProcessing Library

The new search API allows to search for a specific text in the PDF files. It has many methods that allow you to customize the search criteria and even search with regular expressions. The search result returns the page and the location of the searched text. Here is a small example that shows this:

var search =  new  TextSearch(document);
var result = search.FindAll("Lorem",  TextSearchOptions.Default);

Detailed information about this functionality is available in our documentation: Search.

New Fields in RadWordsProcessing

We have added table of contents fields TOC and TC, which allow you to dynamically add a table of contents to your documents using various switches.

The table of authorities fields—TOA and TA—are now supported as well. These fields allow you to add a table of authorities to your document.

In order to make the TOC and TOA fields work, we have added the Sequence field as well.

Our demo application now has an example of these fields.

You can see all supported fields in our documentation as well: Fields Overview.

Telerik UI for .NET MAUI

R1 2023 brings exciting updates to Telerik UI for .NET MAUI, including five brand-new controls—ToolBar, ImageEditor, SignaturePad, ProgressBar and Accordion. We’ve also added some enhancements to our powerful DataGrid control. Let’s have a sneak peek at the most interesting stuff we have for you in this release.

New .NET MAUI ToolBar Control

In today’s world of mobile and desktop apps, it’s important to have a clear and easy-to-use navigation system. That’s why we’re excited to introduce our new Toolbar component for .NET MAUI! This powerful and versatile component allows you to easily create a sleek and professional navigation experience for your app. It can mimic the functionality and behavior of the Visual Studio toolbar with its Strip and Overflow areas.

Here are some of the key features you get in the new ToolBar control:

• Rich collection of toolbar items: navigation button, split button, slider, listpicker, radio buttons and more.
• Support for adding text and image to the toolbar item.
• Horizontal or vertical orientation: RadToolbar supports both horizontal and vertical orientation.
• Overflow menu: when the toolbar items cannot fit in the available space, an overflow button is displayed. The items are added in the overflow menu. You can display them using the different modes of the overflow menu.
• Panning and scrolling through the Toolbar items.
• Options to separate the toolbar items through UI element part of the toolbar items—SeparatorToolbarItem.
• Options to group the toolbar items.

Visit our product documentation for more information on getting started with the Telerik UI for .NET MAUI ToolBar control.

.NET MAUI ImageEditor

You can now easily visualize and edit images in different file formats in your mobile and desktop application with our new ImageEditor control for .NET MAUI. The component comes with convenient image interactions such as zoom and pan, flip and rotate, resize and crop.

It is also packed with a variety of filters which allows you to perform various color adjustments to the image such as adjusting the Hue, Saturation, Brightness and Contrast. If your users are unhappy with an image interaction or the set of interactions, they can go back and forth because the ImageEditor has History support.

Here are some of the key features you get in the new ImageEditor:

• Importing and exporting images: The control allows you to import different image formats such as JPEG, PNG, GIF, BMP, and export images in JPEG, PNG, GIF, BMP formats.
• Various image source options: Load images from a Stream, File (as embedded resource, or image located on the device) and URI.
• Support for undo/redo and reset: RadImageEditor has a history stack with the changes applied to the image. This means that you can reverse and re-apply actions.
• Support for Interactive Pan and Zoom: The control has built-in pan and zoom functionality that will help you interact with the image and display it in a convenient way.
• Built-in Toolbar: the control comes with a ready-to-use toolbar pre-populated with all the items needed to manipulate images.
• Custom Toolbar: RadImageEditor’s Toolbar can be fully customized. You could populate the toolbar with the ToolbarItems needed for editing the image.
• Commands support: The control provides built-in commands and interactive commands. In addition, there are Toolbar commands.
• Support for Image Transformations:
       ◦ Crop
       ◦ Resize
       ◦ Rotate—Left and Right
       ◦ Flip—Horizontal and Vertical
• Built-in Filters:
       ◦ Hue
       ◦ Saturation
       ◦ Brightness
       ◦ Contrast
       ◦ Blur
       ◦ Sharpen

Visit our product documentation for more information on getting started with the Telerik UI for .NET MAUI ImageEditor control.

New SignaturePad Control for .NET MAUI

The Telerik SignaturePad control for .NET MAUI is a user-friendly component that allows you to capture and save signatures within your native mobile and desktop applications.

Upon interacting with it, the component displays the signature path, ensuring that your end user feels a natural pen effect. You can easily customize signature’s stroke and color and save the signature as PNG or JPEG.

Here are some of the key features of the SignaturePad control:

• Configure the stroke thickness and stroke color of the signature to achieve the desired look.
• Exhaustive number of events that are raised when a new stroke is started, completed and an event fired when the surface is cleared.
• Commands Support: Easily clear the signature from the surface using the exposed command.

Visit our product documentation for more information on getting started with the Telerik UI for .NET MAUI SignaturePad control.

RadProgressBar for .NET MAUI

If you need to indicate the progress of a long-running operation in your desktop or mobile application, then our RadProgressBar comes in handy. It can also show multiple forms of progress, such as data loading or a multi-step user action, in which you can visualize how much has been completed and what remains.

Here are some of the key features you get in the new ProgressBar component:

• Value and Progress: Used to set and report the progress of a task inside the ProgressBar control.
• Value range: Define value ranges by setting the minimum and maximum values.
• Different value display modes: The label that shows the current state of the progress can be set to absolute value, percent, text or fully hidden.
• Segments support: RadProgressBar can be divided in segments.
• Indeterminate mode support: A mode that displays an animation indicating an unspecified amount of waiting time.
• Different animations: You can apply different animation easing and animation duration while changing the value of the ProgressBar.
• Flexible styling API: For customizing the progress fill, track fill, indeterminate fill, label text color, font size and more.

Please visit our product documentation for more information on getting started with the Telerik UI for .NET MAUI ProgressBar control.

UI for .NET MAUI Accordion

RadAccordion is a powerful and versatile component that allows you to easily organize and present large amounts of content in a small space. With its intuitive and user-friendly interface, you can quickly and easily expand and collapse sections to view the information you need.

• Collapsed/expanded states: RadAccordion consists of AccordionItems that can host any content. The end users could show or hide this content by interacting with the headers of the control.
• Collapse All Items: You can allow your app users to collapse all items of the RadAccordion.
• Highly customizable items: You have full control over the visual appearance of the Accordion items—you can customize the border style of each item, the border style of items’ headers, as well as the indicator text, font, size, location and color.
• Animation while expanding/collapsing: RadAccordion provides slick customizable animation played while the expandable content is expanded/collapsed.

Visit our product documentation for more information on getting started with the Telerik UI for .NET MAUI Accordion control.

New Feature in DataGrid—Frozen Columns

This powerful feature allows you to “freeze” or “pin” certain columns of your DataGrid so that they remain visible and in place even as the user scrolls through the rest of the columns. This is particularly useful when working with large and complex datasets, as it allows users to easily reference important information while scrolling through the rest of the data.

Telerik UI for Xamarin

With R1 2023 our main focus was on Telerik UI for .NET MAUI; however, we were able to deliver two of the most requested features for UI for Xamarin.

Xamarin DataGrid Enchantment: Support for Scrolling to a Specific Item

Our DataGrid for Xamarin just got a new API that enables you to programmatically scroll a DataGrid so that a specific item is visible on the screen, thus bringing a smoother user experience into your Telerik UI for Xamarin app.

Here is an example of how to scroll to the last item in the DataGrid by using the new ScrollItemIntoView method (the code executes on a button click):

private void Button_Clicked(object sender, System.EventArgs e)
{
    var item = this.vm.Clubs[this.vm.Clubs.Count - 1];
    this.grid.ScrollItemIntoView(item);
}

Visit our product documentation for more information on the Telerik UI for Xamarin DataGrid control ScrollItemIntoView method.

New Functionality in our SideDrawer Component for Xamarin

By default, the SideDrawer Drawer Content area closes when user clicks/taps outside of it. With R1 2023, you can control that behavior by setting using the TapOutsideToClose boolean property. Its default value is True, but when setting it to False, the drawer content area of the component remains open if the end user taps/clicks outside of it and the main content area remains active. Here is it in action:

Visit our product documentation for more information on the Telerik UI for Xamarin SideDrawer control TapOutsideToClose property.

Try Them Out & Share Your Feedback

Head over to the Telerik page and download a free trial. If you are an active license holder you can grab the latest and greatest from the “Your Account” page or update your NuGet package reference to the latest version directly in your .NET solutions.

Share your thoughts with us on our feedback portal and help us shape the future of Telerik UI!

Join Us for Release Webinar (and More)

Progress Telerik .NET Web, Desktop & Mobile Products R1 2023 Release Webinar | January 26

Discover all updates across Telerik UI for Blazor, UI for ASP.NET Core, UI for ASP.NET MVC, UI for ASP.NET AJAX, UI for WPF, UI for WinForms, UI for WinUI, UI for .NET MAUI and UI for Xamarin and ThemeBuilder.

Save Your Seat

Join Us on Twitch

If you can’t wait until the webinar to unpack the new release, join the Livestream Release Party on January 19, 10 a.m. – 11:30 a.m. ET to hear the release highlights across the entire Progress Developer Tools portfolio and hang out with friends.

And for those of you who will be at NDC London on January 25-27, you are welcome at the Progress booth where we can talk about all product developments and the latest release.

Progress Kendo UI R1 2023 Release Webinar | January 31

Discover all updates across KendoReact and Kendo UI for Angular, Vue and jQuery, as well as ThemeBuilder.

Save Your Seat

Progress Telerik Reporting, Mocking and Debugging Tools R1 2023 Release Webinar | February 2

Discover all updates across Telerik Reporting, JustMock, Fiddler Everywhere and Fiddler Jam.

Save Your Seat

Among the most important points of the evolution of Xamarin.Forms to .NET MAUI are the improvements that have been applied based on the learning obtained.

I know that you have worked with custom renderers in Xamarin.Forms and you are probably wondering how you can use them in .NET MAUI. You are in the right place! In this article, we will learn how to migrate custom renderers from Xamarin Forms to .NET MAUI handlers.

Get To Know Handlers

.NET MAUI provides a graphical interface on which we can communicate with the user in a more effective way, displaying and sending data. Each of the controls that we use to build this interface has an interface representation that abstracts the control. The controls that implement this interface are known as native views, which are used on each platform.

Handlers are responsible for instantiating the underlying native view and mapping the cross-platform control API to the native view API. Next, you will see this explanation graphically:

What Are Mappers?

Mappers are a key concept in .NET MAUI handlers, usually providing a property mapper and sometimes a command mapper, which maps the cross-platform control’s API to the native view’s API.

Let’s understand a little more:

• A property mapper is a new concept introduced by handlers. This is a Dictionary responsible for deciding the actions to take when a property change occurs in the multiplatform control. Each platform handler provides implementations of actions that subsequently handle the native view API. That means that when you set a property on a cross-platform control, the underlying native view is updated as required.
• A command mapper defines what actions to take when the cross-platform control sends commands (instructions) to native views. Unlike property mappers, they allow passing additional data.

The advantage of using mappers for updating native views is that they can be unbound from cross-platform controls. This eliminates the need for native views to subscribe and unsubscribe from cross-platform control events.

Evolving From Xamarin Renderers to .NET MAUI Handlers

Let’s highlight some of the most relevant improvements from the evolution of Xamarin renderers to .NET MAUI handlers:

Xamarin Renderers

• Despite the improvements implemented, it is important to know that it’s still possible to use the custom renderer pattern for customization at the platform level familiar to Xamarin.Forms developers. You can take a look at the article “ Using Custom Renderers in .NET MAUI.”
• In Xamarin Forms, each renderer has a reference to the cross-platform element. It generally depends on INotifyPropertyChanged for its operation. .NET MAUI uses a new pattern called a handler.

.NET MAUI Renderers

• Among the main benefits of using handlers are improved performance and extensibility.
• The new handler architecture in .NET MAUI reduces the number of UI controls required to render a view and decouples platform controls from the framework itself by removing view settings.
• In .NET MAUI, handlers invert the relationship between the framework and the platform, so the platform control only needs to handle the needs of the framework. This makes it much easier to extend or override when needed.

Migration to a Handlers Class

For this migration, we will make an example for an EditText control in Android. We will be using an example obtained from the MAUI wiki on GitHub.

We will learn how to do it step by step:

1. Create an interface which implements Iview.

public interface ICustomEntry : IView
{
     public string Text { get; }
     public Color TextColor { get; }
}

2. Create a subclass of the ViewHandler class.

This class renders the platform control.

public partial class CustomEntryHandler : ViewHandler<ICustomEntry, EditText>
{

}

The ViewHandler class provides VirtualView properties that are used to access the cross-platform control from its controller and the PlatformView property that handles accessing the native view on each platform that implements the cross-platform control.

3. Override the CreatePlatformView method.

This method is contained in the ViewHandler subclass, which should create and return the native view that implements the cross-platform control. This method renders the platform control.

public partial class CustomEntryHandler : ViewHandler<ICustomEntry, EditText>
{ 
    protected override EditText CreatePlatformView()
    { 
    return new EditText(Context);
    }
}

4. Create the PropertyMapper dictionary.

This is responsible for defining the action that will be taken when cross-platform property changes.

public partial class CustomEntryHandler : ViewHandler<ICustomEntry, EditText>
{
    public static PropertyMapper<ICustomEntry, CustomEntryHandler> CustomEntryMapper = new PropertyMapper<ICustomEntry, CustomEntryHandler>(ViewHandler.ViewMapper)
    { 
    [nameof(ICustomEntry.Text)] = MapText,
    
    [nameof(ICustomEntry.TextColor)] = MapTextColor,
    
    };
    
    protected override EditText CreatePlatformView()
    {
    return new EditText(Context);
    }
    
    static void MapText(EntryHandler handler, ICustomEntry entry)
    {
    handler.PlatformView?.Text = entry.Text;
    }
    
    static void MapTextColor(EntryHandler handler, ICustomEntry entry)
    {
    handler.PlatformView?.TextColor = entry.TextColor;
    }
}

5. Create a custom control by subclassing the View class and implementing the control interface:

public class CustomEntry : View, ICustomEntry
{
    public string Text { get; set; }
    public Color TextColor { get; set; }
}

6. Register the handlers.

This is accomplished using the AddHandler method specifically on the MauiProgram class.

public static class MauiProgram
{
    public static MauiApp CreateMauiApp()
    {
    var builder = MauiApp.CreateBuilder();
    builder.UseMauiApp<App>();
    builder.ConfigureMauiHandlers(collection =>
    {
    //#if __ANDROID__
    handlers.AddHandler(typeof(CustomEntry), typeof(CustomEntryHandler));
    //#endif
    });
    return builder.Build();
    }
}

And our example is done!!

Event Subscription

The ViewHandler class also has the methods:

• ConnectHandler is the ideal place to initialize and subscribe to events.
• DisconnectHandler is great for disposing of objects and unsubscribe events, as you will see the example below:

public partial class CustomEntryHandler : ViewHandler<ICustomEntry, EditText>
{ 
// ...

 protected override void ConnectHandler(EditText platformView)
 {
  _defaultTextColors = platformView.TextColors;
  _defaultPlaceholderColors = platformView.HintTextColors;
  _watcher.Handler = this;
  platformView.AddTextChangedListener(_watcher);
  base.ConnectHandler(platformView);
 }

 protected override void DisconnectHandler(EditText platformView)
 {
  platformView.RemoveTextChangedListener(_watcher);
  _watcher.Handler = null;
  base.DisconnectHandler(platformView);
 }
}

Wrapping Up

I hope the information in the article has worked for you and is very useful in .NET MAUI!

See you next time! ‍♀️

References

• https://docs.microsoft.com/en-us/dotnet/maui/user-interface/handlers/
• https://github.com/dotnet/maui/wiki/Porting-Custom-Renderers-to-Handlers

See Also

• https://docs.telerik.com/devtools/maui/get-started/migrate-to-net-maui 

As with every release, we are eager to share what the new updates are, so let’s jump right in! Hop to your favorite section:

• Telerik UI for WinUI
• Telerik UI for WPF
• Telerik UI for WinForms
• Telerik Document Processing Libraries
• Telerik UI for .NET MAUI
• Telerik UI for Xamarin
• Terlerik .NET Web, Desktop & Mobile Webinar & Twitch Sessions

What’s New in Telerik UI for WinUI 2.2.0

PropertyGrid

Announcing the RadPropertyGrid component for WinUI! The control provides an easy and versatile approach to processing data objects’ properties. Utilizing its auto-generation features and the intuitive custom editor capabilities, users will be able either to display data in a way that best fits their needs or modify it with minimal effort.

RadPropertyGrid can be bound to an item with just a single line of code, and you may start exploring or editing its properties. The proper editor controls are auto-generated—text fields for string properties, CheckBoxes for Boolean, DateTimePickers for dates, etc. In addition, PropertyGrid allows flexible manual setting and customization of editors and their layout via the standard WinUI styling and templating mechanisms. It is highly customizable, allowing the user to modify the default look in an easy and intuitive manner.

Check out the key features below:

• Automatic property generation – the control generates fields to read/write all public properties of the target object
• Built-in property editors – predefined editors UI for the different data types
• Nested properties support
• Customizable property fields – customize the property definitions and the corresponding data editors
• Keyboard support
• Grouping
• Filtering
• Data validation

For more information about the control, make sure to check out the PropertyGrid section in our online help documentation.

CollectionEditor & CollectionEditorPicker

RadCollectionEditor and RadCollectionEditorPicker are two small components used to visualize the items in a collection and generate editors for each property using the built-in PropertyGrid component. You can use the ItemTemplate of the control to specify how the items from the collection should appear. The difference between them is that the CollectionEditorPicker uses a dropdown to display the CollectionEditor.

For more details, check out the CollectionEditor section in our help documentation.

CollectionNavigator

RadCollectionNavigator is the next new control this release. A light component that provides seamless navigation and editing of a collection, it provides built-in customizable commands, predefined customizable buttons and more. For more details, make sure to check out the CollectionNavigator section from our online help documentation.

DataGrid: Export

Our DataGrid gets export support—thanks to the Telerik Document Processing Libraries that are included in the WinUI distribution. The new functionality provides methods to export the current dataset displayed in the control. You can export in a synchronous or an async manner, modify the exported data and the final document. Currently the built-in export supports the following formats:

• XLS
• XLSX
• PDF
• CSV

Hope this feature will be useful. For more details, check out the Export section from our DataGrid documentation.

RibbonView & Other: Updated Windows 11 Appearance

In this release, we did many improvements in the default styles of many controls to provide a better Windows 11 look and feel. Now I want to focus on the RibbonView control—we completely redesigned it to resemble the new Office 365 Experience! It looks totally awesome and I’m sure it will improve the overall appearance of your modern WinUI application.

Make sure to check out the controls in our refreshed WinUI examples application and play around with them.

Other Features

• SideDrawer: Added DrawerOpening and DrawerClosing
• SideDrawer: Introduced IsOpen property

Check Out the Detailed Release Notes

We have a lot more! To get an overview of all the latest features and improvements we’ve made, check out the release notes for the products below:

Telerik UI for WinUI (Release Notes)

Share Your Feedback

• Get in touch by email – drop us a line, for anything related to product or just to say hi at TelerikWinUI@progress.com
• Feedback Portal – share any feature request (or bug reports) that you might have
• Telerik Forums – if you need any technical assistance with the product, let us know and we will help

Get the Bits

Don’t wait—try out the latest:

Telerik UI for WinUI

In case you missed it, here are some of the updates from our previous release.

What’s New in Telerik UI for WPF With R3 2022

CircularProgressBar

Announcing our brand-new WPF CircularProgressBar component. CircularProgressBar is a control that will allow your customers to track the progress of different tasks in a circular manner. It provides many customization options that will allow you to achieve a lot of different scenarios. You have probably seen such components in many different places—from health tracking smartphone applications to automatic coffee machines. Now you can easily plug it in your Telerik WPF application as well!

Check out the list of the major features of the control below:

• Segments – CircularProgressBar can be split into numerous segments to indicate different types of progress.
• Color Ranges – CircularProgressBar supports defining ranges with different colors.
• Determinate and indeterminate states – The determinate state shows a specific amount of the progress. The indeterminate one plays an animation of the circular progress.
• Customizable content – CircularProgressBar supports complex implementation for the content of its progress.
• Radius manipulation – The control allows you to customize the indicator and track inner and outer radiuses.
• Angles – You can control the beginning and ending angles of the component for a more customized appearance.
• Secondary progress indicator – CircularProgressBar allows you to visualize an additional progress indicator.
• Indeterminate animation customization – You can modify the played animation when CircularProgressBar is in an indeterminate state.

I hope this control will be useful in various types of applications. For more information, check out our online CircularProgressBar help documentation.

PivotGrid: Configuring PivotGrid Without PivotFieldList

The most desired PivotGrid feature is finally here! It allows using the control without the additional PivotFieldList control. The new functionality provides support of all existing PivotFieldList features—directly accessible trough the UI of RadPivotGrid. Your customers will be able to filter, sort, modify the descriptions and more through the built-in dropdown menus, dialogs and buttons. The feature can be enabled by simply setting the attached FieldListBehavior.ShowInline property as shown below:

<pivot:RadPivotGrid  x:Name="pivotGrid"  pivot:FieldListBehavior.ShowInline="True"  />  

For more details, make sure to check out the Inline PivotFieldList section from our online help documentation.

SyntaxEditor: Word Wrapping

A new cool feature for the SyntaxEditor is Word Wrapping! When the feature is enabled, the horizontal scroll bar is removed and all the text is horizontally fit in the available space. We have also included an additional margin that holds the icons and can be removed if needed. I’m sure you have seen this view mode in many editors and IDEs, so I hope it will make your WPF applications more useful and user friendly.

For more info, check out the Word Wrap article from the SyntaxEditor help documentation.

ChartView: ErrorBar Series

We are adding a new ChartView series this release—ErrorBar Series! This type of series visualizes its data points using error bar shapes. The error bar shape allows you to display an error or uncertainty in the plotted data. The shape consists of a single line with caps at the two ends. An additional marker that shows the expected measure can be displayed too.

For more information about all of the setup and customization options of the new series, please check out the ErrorBar Series article from the ChartView help documentation.

Latest .NET 7 Preview Support

As always, we are up to date with the latest technology trends, and we are happy to announce that Telerik UI for WPF provides support for the latest .NET 7 Preview 7. The .NET 7 Preview binaries can be found in a separate zip archive in your account—download it and give it a try! They will be included in the NuGet packages and in full distribution once .NET 7 becomes official. Also we plan to remove the .NET 5 support with the .NET 7 introduction, so please consider upgrading your .NET 5 applications to newer .NET. (If such a change somehow affects your plans, please contact us and share more details.)

RibbonView: New Windows11 Theme Appearance

We improved the default RibbonView styling for the Windows 11 theme in order to resemble the new Office 365 Experience. Looks nice, doesn’t it?

If you want to see the theme in action, make sure to play around with our Color Theme Generator for WPF app! For more details about all the features of the Windows 11 theme, please check out this help article.

RichTextBox: Line Numbering

The latest RichTextBox feature enables you to display the appropriate number beside each line of text—this is useful for specific types of content, such as scripts, legal or medical documents. Through the intuitive API of this feature, you will be able to easily control how the numbering appears. You can change the initial number, the increment number, the distance between the numbering and the document content, and when the numbering should restart. For more information, check out the Line Numbering help article.

Spreadsheet: Repeat Specific Rows or Columns on Every Printed Page

This new Spreadsheet functionality allows you to specify a row or a column that will be repeated on every printed page. This functionality is useful when you need to print or export to PDF data spanning multiple pages and still allows the users to see the important information on the top/left side for better orientation. For more details, check out the Printing section of our Spreadsheet documentation.

Other Features

• SyntaxEditor: FontWeight and FontStyle of the highlighted words
• VirtualGrid: FontWeight and FontStyle of the cells
• RibbonWindow: Windows 11 Theme acrylic effect now can be enabled on all Windows 11 version, not only on the preview ones

Check Out the Detailed Release Notes

We have a lot more! To get an overview of all the latest features and improvements we’ve made, check out the release notes for the products below:

Telerik UI for WPF (Release Notes)
Telerik UI for Silverlight (Release Notes)

Share Your Feedback

Feel free to drop us a comment below sharing your thoughts. Or visit our Feedback Portals about UI for WPF, Silverlight and Document Processing Libraries and let us know if you have any suggestions or if you need any particular features/controls.

Try out the latest:

Telerik UI for WPF Telerik UI for Silverlight

In case you missed it, here are some of the updates from our last major release and previous Service Pack.

What’s New in Telerik UI for WinForms With R3 2022

Spreadsheet Charts

Hold up? Is that true? Yes, you read it right. Charts are coming to RadSpreadsheet control for Telerik WinForms. What could be a better improvement than visualizing your data beyond the RadSpreadsheet grid? Adding charts to a workbook can help you identify important statistics and trends in your data that may not be obvious when only looking at numbers. With RadSpreadsheet you can show charts as well as add, remove and manipulate chart objects in your spreadsheet documents.

Supported Chart Types

Different chart types give you the flexibility that your data requires. From Bar to Line, from Point to Bubble, from Pie to Area, show your users that you care. The Spreadsheet component for WinForms supports more than a dozen different types of charts allowing you to visualize categorical data, numerical data, time series data and more. You can get familiar with all supported types in the RadSpreadsheet Charts help article.

Splash Screen

What could be better to notify the end user that something big is loading than showing a splash screen form? Our newest reinforcement to the Telerik UI for the WinForms suite is here. Splash Screen allows you to display a Telerik themed control that notifies the user that the program is loading. You can customize the image of the splash screen, its animations and loading process visualization per your requirement.

Overlay and Flyout Screens

If you want something more to sample, just to say “give me a second to set up the data,” we have just the things for you. Overlay and Flyout Screens will fit perfectly in a case where you want to dim the content and show the end users to be patient. You could use the Overlay Screen to show only the loading indicator. However, there could be a case where you want to notify the user that he needs to reenter his credentials to continue working on the application. In this case, Flyout Screen is what you need. The Flyout can be used to display some content over the application or be used as an interactive control. The screen can be customized in a way that you can place input controls in it, while the Overlay does not accept such customization.

Overlay

Flyout

Changes to Distribution

As of R3 2022 in Telerik UI for WinForms, the .NET 2.0 distribution is removed. From this release, the suite offers .NET 4.8 distribution. With this release, you not only get the .NET Framework projects of the Telerik source code, but .NET Core projects as well.

Bug Fixes & Improvements

Our development team managed to fix/improve more than ONE HUNDRED bugs reported by our customers. We always listen to feedback and try to produce the top-notch controls on the market.

Share your feedback with us in the Feedback Portal!

Get the Bits

Don’t wait—try out the latest:

Telerik UI for WinForms

What’s New in Telerik Document Processing Libraries With R3 2022

PdfProcessing

Export PDF pages to images: We have added the ability to convert the pages of a PDF document to images. This feature uses the SkiaSharp library. It will work with the .NET Standard version and does not depend on any Windows libraries.

WordsProcessing

Page Numbering Fields: PAGE, PAGEREF, NUMPAGES, SECTIONPAGES and SECTION fields are now supported in our library. These are commonly used fields for inserting page numbering. We have added the ability to update the field values as well.

Shapes support: With this release, we have enabled users to preserve the shapes when importing and exporting a DOCX document. We will continue working on extending the functionality to allow you to insert and manipulate these objects in the next releases.

SpreadStreamProcessing

SpreadStreamProcessing Import: We have added support for reading XLSX and CSV files. This functionality allows you to easily get the data from large files without loading the entire document in the memory. It has great performance as well.

SpreadProcessing

Repeat specific rows or columns on every printed page: This feature allows you to specify a row or a column that will be repeated on every printed page.

What’s New in Telerik UI for .NET MAUI With R3 2022

Aloha, and welcome to another Telerik UI for .NET MAUI release! In addition to the mandatory support for the latest version of .NET MAUI, we are now shipping three brand-new controls as part of our growing Telerik UI for .NET MAUI suite—DataForm, AutoComplete and Expander components! We’ve also added many enhancements to our powerful DataGrid control. Let’s have a sneak peek at the most interesting stuff we have for you in this release.

Latest .NET MAUI & Visual Studio 2022 Support

We follow the Microsoft release cadence closely and have consistently offered early support for all new .NET MAUI versions—including Day-Zero support when the framework was released in General Availability. Since then, cross-platform developers have been able to use Telerik UI for .NET MAUI, the most comprehensive cross-platform development UI library on the market, together with the latest .NET MAUI features and fixes: an unbeatable combination.

Moreover, with .NET MAUI tooling getting formal support in Visual Studio 2022 17.3, Telerik UI for .NET MAUI is now also tightly integrated with the latest VS version. Developers can also take advantage of dedicated Visual Studio Extensions with .NET MAUI templates for project creation and a UI Toolbox.

.NET MAUI DataForm

I’d like to introduce you to the new DataForm control in Telerik UI for .NET MAUI. This powerful control helps you to automatically create a form for collecting or editing data. For example, using the RadDataForm, you can easily create form-over-data UI for both mobile and desktop, like these:

Desktop:

Mobile:

The component supports different commit modes, allowing you to commit property values one by one or to commit the whole form at once. It’s also very easy to add validation to your forms and group UI elements to make large forms more manageable.

With the DataForm control, you can not only build the needed UI by using the rich set of editors that are provided out of the box, but you can easily customize those forms through the flexible styling API.

Here are some of the key features you get in the new DataForm:

• Built-in editors: The DataForm provides a set of built-in editors for the available primitive types such as numeric, string, boolean, enumerations, DateTime and TimeSpan. The control detects the types of the data object’s properties and automatically displays the appropriate editor.
• Validation support: You can use the built-in validation support that gives you full control over the data collected through the control.
• Commit modes: DataForm provides editing support with three types of commit modes to determine when the edited value should be synchronized with the business object.
• Grouping support: This allows you to easily group the form’s editors.
• Data Annotations support: You can decorate the data models using Data Annotations attributes which specify validation conditions to be applied to a specific field in the DataForm. You can use different annotations like Requires, DataType, Display, RegularExpression and more.
• Different layouts: You can arrange the editors and the groups by using different layouts such as stack, grid and more.
• Commands support: You can execute your validation logic or commit/cancel all pending changes in the form by using the built-in commands for these actions.

Visit our product documentation for more information on getting started with the Telerik UI for .NET MAUI DataForm control.

AutoComplete Joins the Family

The AutoComplete component is a popular control for various mobile and desktop applications and use cases. Especially useful when you have to display a long, predefined list to choose from, such as a list of airports or a list of known recipients. Your app users expect this in modern apps, and now you can deliver it out of the box.

Some of the main features of the .NET MAUI AutoComplete are:

• Tokens support: You can enable the users of your application to search for and select several items from the source of the AutoComplete. These items appear as tokens that can easily be deselected using their close button.
• Filtering options: You can define the filtering behavior to display all the matches that either “StartsWith” or “Contains” the typed symbols.
• Different suggest modes support: RadAutoComplete exposes three different modes (Suggest, Append, SuggestAppend) for providing suggestions.
• Placeholder: This is used to give guidance to the end user on what should be entered in the text input.
• NoResults message: NoResults message appears in the popup used for the list of suggestions whenever the control cannot find any matching items. Read more about this here.
• Visualized text formatting: You can modify the displayed details of the selected item by using DisplayTextFormatter property of AutoComplete.
• Custom templates: If any of the default templates do not fit a particular scenario, you can easily define a custom template.
• Highlight customization: This gives you the ability to highlight the text inside the custom template.
• Nested properties support: This allows binding of a complex object to the RadAutoComplete’s TextSearchPath property.

Visit our product documentation for more information on getting started with the Telerik UI for .NET MAUI AutoComplete control.

.NET MAUI Expander

RadExpander is a flexible control that helps you save space and achieve easier navigation through your app. You can place the Expander anywhere on your page and embed any content inside the dropdown area. The Expander control also gives you control over its ExpandDirection to let you adjust the control as per your custom layout.

Here are some of the features the Expander control ships with:

• Collapsed and Expanded States: The control hosts the content in an expandable container that can be easily expanded/collapsed by tapping on its header.
• Animation: The RadExpander control provides a property that allows you to enable or disable the animation when the content is collapsed/expanded. If you want to enable/disable the animation, you need to use the IsAnimationEnabled property.
• Customization Options: The rich API for customization of the Expander component allows you to customize the visual appearance of the control in a variety of ways. You can manipulate the Animation’s duration and easing, the header of the control and its border styles.

Visit our product documentation for more information on getting started with the Telerik UI for .NET MAUI Expander control.

DataGrid Just Got a New Grouping UI

With our latest release, our powerful DataGrid component has evolved. The new enchantment is the so-called Grouping UI.

This area is called the DataGridServicePanel and allows the user to drag and drop column headers into the panel in order to group the data in the RadDataGrid at runtime.

The user is not limited to group just a single column—they are allowed to drag several columns into the panel, or rearrange the grouping. Grouping in this manner gives the user power to control how they want to view the data and reduces the coding part for the developer.

If you want to restrict the user from grouping the data or limit the grouping to certain columns, you can do it by using DataGrid’s intuitive API for that.

More information about this feature can be found in DataGrid’s product documentation.

DataGrid Footers

Column Footers
The new addition to the DataGrid control—the Column Footers functionality—allows you to display additional information which applies to the columns in a specific row placed at the bottom of the control. This row consists of individual footer cells for each column. It is of type object, so you are not limited to just using plain text in it.

By default, column footers are hidden, so if you want to make them visible you have to set the DataGrid’s ShowColumnFooters property to True.

More information about this feature can be found in DataGrid’s product documentation.

Group Footers
DataGrid exposes the Group Footers feature, which provides the option to render a footer under each group in the data grid component. Group footers contain footer cells that correspond to data columns and can display group summaries.

This footer row is also hidden by default. If you want to take advantage of this feature, you will have to enable it by setting the ShowGroupFooters property of the DataGrid to True.

More information about this feature can be found in DataGrid’s product documentation.

DataGrid Aggregate Functions

There are situations when displaying numbers in the DataGrid in which users would like to be able to see the results from aggregate calculations at the bottom of the DataGrid’s groups or columns. Now, this can be easily achieved with the new addition to the DataGrid control—aggregate functions support. It allows you to display aggregated information for the data in the column’s footer, in the group’s header or in the group’s footer.

DataGrid offers built-in support for the most popular aggregate functions: Average, Count, Sum, Min, Max and Count. All you need to do is to add a PropertyAggregateDescriptors into DataGrid’s AggregateDescriptors with the needed function:

<telerikGrid:RadDataGrid>
  <telerikGrid:RadDataGrid.AggregateDescriptors>
    <telerikCore:PropertyAggregateDescriptor  PropertyName="Points" Function=
                                            "Average"/>
                                                </telerikGrid:RadDataGrid.AggregateDescriptors>
                                                </telerikGrid:RadDataGrid>
                                                
                                                        

If you have a more complex scenario, you are also covered—there is an option for creating a custom aggregate function by using a DelegateAggregateDescriptor.

More information about this feature can be found in DataGrid’s product documentation.

Sign Up for a Trial

If you’re interested in starting to play with .NET MAUI, or if you’re already actively working with .NET MAUI to develop applications, I encourage you to check out Telerik UI for .NET MAUI.

To get the bits, you just need to sign up for our free 30-day trial, which gives you access to the components as well as our legendary technical support. Head to the Telerik UI for .NET MAUI overview page or click the button below and sign up for a trial today!

Try Telerik UI For .NET MAUI

Share Your Feedback

Please share your feedback, ideas and suggestions, either by commenting below or by visiting our Feedback Portal about Telerik UI for .NET MAUI. Let us know if you have any suggestions and submit your features/controls requests.

What’s New in Telerik UI for Xamarin With R3 2022

Xamarin DataGrid Aggregates

With the new aggregate functions in the Xamarin DataGrid, you can display aggregated information for the data in the group’s header, or in the group/column’s footer.

The new feature comes with built-in support for the most popular aggregate functions: Average, Count, Sum, Min, Max and Count. You can easily set up the aggregates by adding PropertyAggregateDescriptors into DataGrid’s AggregateDescriptors with the desired function:

<telerikGrid:RadDataGrid>
  <telerikGrid:RadDataGrid.AggregateDescriptors>
    <telerikCore:PropertyAggregateDescriptor  PropertyName="Points"  Function="Average"/>
  </telerikGrid:RadDataGrid.AggregateDescriptors>
</telerikGrid:RadDataGrid>

The aggregates also support multiple types of complex scenarios through the extensibility point for defining a custom descriptor—DelegateAggregateDescriptor.

Visit our product documentation for more information on the Telerik UI for Xamarin Data Grid control and Aggregates.

Xamarin DataGrid Column Footers

The new addition to the DataGrid control—the Column Footers functionality—allows you to display additional information which applies to the columns in a specific row placed at the bottom of the control. This row consists of individual footer cells for each column. It is of type object, so you are not limited to just using plain text in it.

By default, column footers are hidden, so if you want to make them visible, you have to set the DataGrid’s ShowColumnFooters property to True.

Visit our product documentation for more information on the Telerik UI for Xamarin Data Grid control and Column Footers.

Xamarin DataGrid Group Footers

With the current release, you have the ability to render a footer under each group inside the DataGrid component. The footer cells correspond to data columns and you can use them to display group summaries.

All you need to do to use this functionality is set the DataGrid.ShowGroupFooters property to true.

Visit our product documentation for more information on getting started with the Telerik UI for Xamarin Data Grid control.

New IsLooping Property Now Available for All Xamarin Date and Time Pickers

With the latest release of Telerik UI for Xamarin, you can easily stop the looping functionality in the Date, Time, DateTime, Time and TimeSpan Pickers using just a single property—IsLooping. When IsLooping is True, which is by default, the items of each spinner can loop infinitely unless that spinner is restricted to show only a subset of the available values.

Picker with disabled looping                         Picker with enabled looping
    

Visit our product documentation for more information on the Telerik UI for Xamarin DatePicker control IsLooping property.

Get the Latest & Let Us Know Your Feedback

Please share your feedback, ideas and suggestions, either by commenting below or by visiting our Feedback Portal about Telerik UI for Xamarin.

Don’t hesitate to check out the latest:

Try Telerik UI For Xamarin

Telerik .NET Web, Desktop & Mobile Products Webinar & Twitch Session

Wednesday, September 21, 2022 | 11:00 a.m. – 1:00 p.m. ET
Discover all updates across Telerik UI for Blazor, UI for ASP.NET Core, UI for ASP.NET MVC, UI for ASP.NET AJAX, UI for WPF, UI for WinForms, UI for WinUI, UI for Xamarin and UI for .NET MAUI.

Save Your Seat

Join Us on Twitch Today

Live from Devreach’22 @ Progress360: Join the live community session from the Progress360 Streaming Studio on September 14 from 10 a.m. – 11:30 a.m. ET to hear the release highlights and celebrate the DevReach spirit with us at our Livestream Release Party.

And the Best Part About the Release Webinars?

The live webinars and Twitch sessions are a great opportunity for you to ask questions before and during the webinars. We’ll be waiting to hear from you on Twitter—just use the #heyTelerik and #heyKendoUI hashtags.

Another great option is the live chat during our release session on CodeItLive, our Twitch channel.

Telerik UI for Xamarin R2 2022 is here with a brand new control—the Xamarin ProgressBar. This control gives you the option to add a progress indicator to your mobile and UWP applications. A progress bar can be used in various scenarios—to notify the users that some process is in action or to inform the users about the status of ongoing progress such as loading an app and images, downloading files, saving updates, submitting a form request, etc.

Features of the Telerik ProgressBar for Xamarin

Let’s review the features the Telerik UI for Xamarin ProgressBar provides.

✔ Two States Representing Progress—Determinate and Indeterminate

The determinate state represents how long the progress will take, while the indeterminate expresses an unspecified amount of wait time (in cases where the progress cannot be detected or it’s not necessary to indicate how long the activity will take). Of course, you can switch between the two modes using the IsIndeterminate (bool) property. By default, the Xamarin ProgressBar state is determinate.

<telerikPrimitives:RadLinearProgressBar Value="25"
                                        IsIndeterminate="True"/>

✔ Options To Define Progress Value and Range

<telerikPrimitives:RadLinearProgressBar x:Name="progressBar"/> 
<StackLayout Orientation="Horizontal" Spacing="10">
    <Button Text="Update" Clicked="ProgressBarUpdateClicked"/>
    <Label Text="Progress: " VerticalOptions="Center"/>
    <Label Text="{Binding Progress, Source={x:Reference progressBar}}" VerticalOptions="Center"/>
</StackLayout>

And implement updating the progress value on button click with:

private void ProgressBarUpdateClicked(object sender, EventArgs e)
{
    this.progressBar.Value = 75;
}

Use the Minimum and Maximum properties to add a range to the ProgressBar.

✔ Choose Whether To Display the Progress Value

You can decide whether to display the progress value in the Xamarin ProgressBar. The ValueDisplayMode property gives you the option to display the progress as Percent (range from minimum to maximum), Value (progress value) or custom text through the Text option, and, of course, if you do not want to display the text at all— the None option.

✔ Horizontally Align the Label That Shows Progress

Horizontally align the label using the LabelHorizontalOptions(Xamarin.Forms.LayoutOptions) property.

<telerikPrimitives:RadLinearProgressBar Value="55"
                                        LabelHorizontalOptions="Center"/>

✔ Segments Support

Divide the ProgressBar into segments using the SegmentCount(int) property. In addition you can style the segments using the SegmentSeparatorFill(Brush) and SegmentSeparatorThickness(double).

<telerikPrimitives:RadLinearProgressBar Value="25"
                                        SegmentCount="10"
                                        SegmentSeparatorFill="Black"
                                        SegmentSeparatorThickness="2"/>

✔ Customization Options Using the Flexible Styling API

Benefit from the flexible styling API, which the ProgressBar control provides. Customize the progress fill, indeterminate fill, label text color, font size and more.

Styling the ProgressBar for Determinate Mode

• Apply TrackFill(Brush) and ProgressFill(Brush) properties.

<telerikPrimitives:RadLinearProgressBar Value="20"
                                        TrackFill="LightBlue"
                                        ProgressFill="Blue"/>

• Customize the text displayed in the ProgressBar.

<telerikPrimitives:RadLinearProgressBar Value="90"
                                        AlternateTextColor="Black"
                                        TextColor="#019688"
                                        FontSize="20"
                                        HeightRequest="30"/>

Styling for Indeterminate Mode

Use the IndeterminateFill(Brush) property to style the indeterminate indicator.

<telerikPrimitives:RadLinearProgressBar Value="25"
                                        IsIndeterminate="True"
                                        IndeterminateFill="Yellow"/>

✔ Set Animation Easing and Animation Duration During Progress Change

Customize the animation duration and easing through ProgressAnimationDuration and ProgressAnimationEasing properties.

<StackLayout>
    <Label Text="Progress AnimationDuration and AnimationEasing can be viewed when the Value of the ProgressBar changes"/>
    <StackLayout Orientation="Horizontal">
        <Label Text="{Binding Value, Source={x:Reference progressBar}}"/>
        <Stepper Minimum="0"
                 Maximum="180"
                 Increment="20"
                 Value="{Binding Value, Source={x:Reference progressBar}}"/>
    </StackLayout>
    <StackLayout>
        <Label Text="ProgressAnimationDuration = 1000 and ProgressAnimationEasing = CubicIn"/>
        <telerikPrimitives:RadLinearProgressBar x:Name="progressBar"
                                                Minimum="0"
                                                Maximum="180"
                                                Value="20"
                                                ProgressAnimationDuration="1000"
                                                ProgressAnimationEasing="CubicIn"/>
    </StackLayout>
</StackLayout>

What about an Indeterminate state? We have thought about this and provide properties for customizing the animation easing and duration when the control is in an indeterminate state (IndeterminateAnimationDuration and IndeterminateAnimationEasing properties).

<telerikPrimitives:RadLinearProgressBar Value="25"
                                        IndeterminateAnimationDuration="1000"
                                        IndeterminateAnimationEasing="CubicIn"
                                        IsIndeterminate="True"/>

Examples With Telerik ProgressBar for Xamarin

There are various examples with the ProgresBar control inside the Telerik UI for Xamarin Sample Application and SDK Browser Application.

The Telerik Sample App for Xamarin is in the App Store, Google Play Store and Windows Store:

Your Feedback Is Important—Let Us Know What You Think

We hope the new Xamarin ProgressBar control will have its place in your mobile and UWP applications.

As always, we encourage you to share your ideas or opinions on the controls and play a role in shaping our roadmap. You can write in the Telerik UI for Xamarin Feedback Portal or raise a ticket.

If you have not yet tried the Telerik UI for Xamarin suite, take it for a spin with a 30-day free trial, offering all the functionalities and controls at your disposal at zero cost.

Happy coding with our controls! ❤

R2 2022 brings a plethora of new components and features for Telerik mobile and desktop products, support for the latest Preview of .NET 7, ARM64 support and an extremely beautiful new Windows 11 theme for the desktop products. The Telerik UI for .NET MAUI suite also continues to grow with new components and desktop support, making it the largest UI component suite for .NET MAUI out there.

Here are a few links to the different sections in this blog to help you navigate directly to the section of interest.

Table of Contents

• Telerik UI for .NET MAUI
• Telerik UI for WinUI
• Telerik UI for WPF
• Telerik UI for Xamarin
• Telerik UI for WinForms
• Telerik Document Processing Libraries
• Downloads
• Live Webinar and Twitch Session

Telerik UI for .NET MAUI

New DateTimePicker Component

One of the new additions to the Telerik UI for .NET MAUI family is the .NET MAUI DateTimePicker control. It provides users with an easy and intuitive way to pick a date and/or time. The component has several features that allow you to set a date range, date and time format, and fully customize the dialog appearance.

Here are some of the key features to look for:

• Spinner format: The component allows you to use a standard or custom date format string through its SpinnerFormat property. Depending on what format is set, the picker visualizes spinner controls with the prepopulated values ready to be picked.
• Picker mode: You can choose between Popup and DropDown UI for showing the spinner controls with the available date and time values. For desktop, the default picker mode is DropDown, while for mobile it’s Popup.
• Templates: The DateTimePicker provides templates for its header and footer as well as exposes templates for its placeholder and display text.
• DisplayString format: You can choose what text will be displayed when a date is selected by using the DisplayStringFormat property of the DateTimePicker.
• Date ranges: You can also define date ranges by setting minimum and maximum date values and choose a date within that range.
• Flexible styling API: The DateTimePicker provides a number of styling capabilities.

For more information on getting started with the Telerik UI for .NET MAUI DateTimePicker control, visit the documentation.

Desktop Support for All Picker Components

With R2 2022, we are introducing desktop support for the powerful picker components—you can now use them to develop apps for Windows and macOS. The full list of updated controls includes .NET MAUI DatePicker, TimePicker, TimeSpanPicker, ListPicker and TemplatedPicker.

Moreover, with this release, all listed components (plus the DateTimePicker) now have a PickerMode property, which lets you choose what interface to use for picking a value. The default picker mode for mobile is Popup and for desktop—DropDown.

• Popup – Shows the UI for picking a date inside a popup. It’s the default value for mobile (Android and iOS).

• DropDown – Opens the UI for picking a date inside a dropdown. It’s the default value for desktop (Windows, macOS).

Updated NumericInput Component

In line with our commitment to provide the best, most comprehensive .NET MAUI UI library, we work hard to ensure developers can build native applications for Windows, macOS, Android and iOS, taking advantage of the technology’s full power. That’s why one of the main goals of this complete redesign of the NumericInput component was to migrate it from a Xamarin.Forms Renderer to a native .NET MAUI Handler. Beyond that, you can expect mobile-first views on iOS/Android and a desktop-friendly look when running on Windows/MacOS.

New BadgeView Component

The new BadgeView component brings a modern way to notify users or grab their attention to perform a certain activity on your application in a mobile or desktop scenario.

Subtly alerting the users of your .NET MAUI applications for status changes has never been easier! The Telerik UI for .NET MAUI BadgeView control allows you to display notifications or short messages via a set of predefined badges right into your cross-platform application.

Here are some of the key features:

• Badge Position: BadgeView allows you to specify the badge position based on its content.
• Badge Alignment: You can easily align the badge according to its content.
• Badge Animation: You can choose whether to have an animation while displaying the badge. In addition, you can specify the animation duration and animation easing.
• Badge Types: You can choose between various predefined badge types. Also, you have the option to customize and style the badge types.
• Flexible Styling API and Customization Options: The styling capacities of the BadgeView control allow you to apply BackgroundColor, Border Thickness and Color. Also, we have an exposed API, which you can use to fully customize and style the badge indicator.

For more information on getting started with the Telerik UI for .NET MAUI BadgeView control, visit our documentation.

Updated Entry Component

The Telerik UI for .NET MAUI Entry component has evolved. The text entry control that accepts string inputs is now built against the latest UI guidelines and comes with many enhancements in its API. Here are the most important features of the control:

• Password functionality: You can hide the characters that users type for privacy and security reasons.
• Keyboard support: You can add a virtual keyboard and specify its type—for example, Numeric.
• Non-editable (read-only) state: You can define whether users will be able to edit the Entry or not by setting a single property.
• Maximum number of symbols: The Entry component enables you to set a maximum length for its input.
• Text selection: You can specify the starting position of the selected text as well as the number of characters of the selected Entry input.
• Text prediction: Define whether to have a predictive text while typing in the Entry.
• Validation: If the user is entering a value not matching the requirements, the Entry will display an error message, which you can easily customize.
• Clear button: Gives you the option to clear all the text entered in the Entry using a single button.
• Commands support: Use the Return command to implement additional logic when pressing the keyboard return key.
• Various styling options: For applying corner radius, clear button color, placeholder color and more.

For more information on dabbling with the Telerik UI for .NET MAUI Entry control, visit the documentation.

Telerik UI for WinUI

PdfViewer

Announcing the first PdfViewer control in the WinUI world—RadPdfViewer! View PDF documents right within your WinUI application without the need for an external viewer. Allow your users to easily operate with the currently loaded document through the additional PdfViewerToolbar control providing all the common interaction options. Check out the full list with features below:

• Pan and Text Selection view modes
• Zooming
• Smooth scrolling
• Rotation of document
• Save As – option to save the previewed document to new file
• PdfViewerToolbar – predefined Toolbar control providing all the common PdfViewer functionalities
• Fonts – support for TrueType, Type 1, Type 3 and CID fonts
• Virtualization for ensuring great performance with large documents
• Extensible support for different stream compression filters
• Support for documents encrypted with Encryption Algorithm 4 (RC4/AES-128)
• The API provides different options for extending and customizing the control
  
• Uses Windows Composition rendering for native performance

For more information about the control, make sure to check out the WinUI Pdf Viewer section in our online help documentation.

TabControl

RadTabControl is a flexible navigation component, used to build tabbed interfaces in WinUI applications. Thanks to the related RadTabItem control, you can organize your controls into different content pages, thus improving the overall user experience (UX) of your applications. Here are the top feature the control provides:

• Built-in pin and close functionality buttons in the tab headers
• Drag reorder for tabs is available out of the box
• Multi-line tabs support
• Flexible tab headers – tab headers are easy to customize by incorporating content or Data Templates
• Selection – manipulate the selected tab and define the control behavior on tab close
• Data Binding – the control can be data bound to a wide variety of data sources
• Overflow – when the available space is not enough, the tabs will overflow in an overflow area
• Theming – style and customize the control utilizing the rich styling API
• Customization – built in options for defining tabs position, alignment, orientation, size, style and more

For more details, check out the WinUI TabControl section in our help documentation.

HeatMap

RadHeatMap is a control that displays numeric data in a matrix-like manner using two axes. Each value is represented by a colored rectangle, which makes it quite easy for the end user to quickly perceive and compare all values.

Here is a list with the main features of the control:

• Visualization Mechanisms – Categorical and Horizontal/Vertical
• Colorizers – different options colorize the values
• UI Selection – built-in Single and Multiple selection
• Tooltips – specify a Tooltip template and display the details of the item
• Labels – show custom labels in the cells
• Header Customization Options – easily change their appearance
• Customization Options – change the appearance of the control as well as its elements

Make sure to play around with the control in our WinUI examples app and to check the RadHeatMap section in our help documentation.

ChartView: Minor Ticks and Stripes (Breaking Change)

The new minor ticks support will allow you to utilize a more punctual view of the ticks in the axis. With it, you can define the number of minor ticks to be displayed between major ticks. They are heavily customizable with the available APIs to define the number of minor ticks between major ones, the tick length, offset from the major tick, the tick template and style.

With the support for minor ticks, another useful feature is the support for stripes. Stripes are the visual representation of the minor ticks in the chart area and can be used to display where the minor ticks are, for the user to easily spot the value of a certain tick and compare it to a data point on the chart. Stripes support defining the stripe visibility, style, dash array and more.

Important: With the minor ticks feature we renamed some of the already existing properties listed below:

• PolarChartGrid
  • GridLineVisibility -> MajorGridLinesVisibility
  • StripesVisibility -> MajorStripesVisibility
  • PolarLineStyle -> MajorPolarLinesStyle
  • RadialLineStyle -> MajorRadialLinesStyle
• CartesianChartGrid
  • StripLinesVisibility -> MajorStripLinesVisibility

For more details, check out the Minor Ticks and Stripes article from our Chart documentation.

Latest Windows App SDK Support (1.0.3)

As usual we are up to date providing support for latest Windows App SDK version 1.0.3.

Document Processing

For a list of the new features shipped in the Telerik Document Processing Libraries shipped with Telerik UI for WinUI, see below.

Check Out the Detailed Release Notes

We have a lot more! To get an overview of all the latest features and improvements we’ve made, check out the release notes for the products: Telerik UI for WinUI (Release Notes).

Telerik UI for WPF

VirtualKeyboard

Announcing the brand-new WPF VirtualKeyboard component. RadVirtualKeyboard is basically a screen keyboard that mimics the familiar physical device. Users can interact with the Virtual Keyboard via the mouse or a touch device and, for richer experience, the default click or any custom sound can be enabled. The component can be also placed directly in XAML, in a convenient place in your application or it can be shown above the app through the dedicated RadVirtualKeyboardWindow that will allow you to use it for all other applications.

Here is list with major features the control provides:

• Layouts – There are three predefined key layouts and an option load completely custom layout from XML file.
• Display options – The keyboard can be shown inline or in a dedicated window that can be moved.
• Customization – The visualization of each key can easily be changed.
• System synchronization – Tracks system language changes and updates the keys automatically.
• Culture support – The component supports assigning a specific culture that will be applied to the letter keys.
• Native key input – Each button click sends a native key down action that is passed to the currently focused element.

I hope this control will be useful in various types of applications. For more information, check out our online VirtualKeyboard help documentation.

Windows 11 Theme

The newest and most modern Telerik UI for WPF theme is here—welcome the Windows 11 theme! It is inspired by the Windows 11 OS and brings nice smooth round shapes in two color variations—Light and Dark. Enjoy the out-of-the-box native look and feel of RadWindow when the app is running on Windows 11 with the famous Mica backdrop material effect! A couple other cool things about the theme are the System color variation that automatically transforms the theme depending on the systems settings and the option to use the system accent color as accent color of theme.

You can see below how some of most popular controls look wearing the new theme:

>

They look good, don’t they?

As with our other recent WPF themes, you can easily customize the theme colors to suit your taste with the Color Theme Generator for WPF! For more details about all the features of the theme, please check out this help article.

The theme comes with brand-new Telerik font with glyphs—for more details, check out the Font Glyph section from our online help docs.

Latest .NET 7 Preview and ARM64 Support

As always, we are up to date with the latest technology trends, and we are happy to announce that Telerik UI for WPF provides .NET 7 Preview 3 and ARM64 support. The .NET 7 Preview binaries can be found in a separate zip archive in your Telerik account—download it and give it a try!

As for the ARM64 support, this means that your .NET 6 app built with Telerik UI for WPF will run flawlessly on a device like Surface Pro X (with ARM64 processor)—test it if you have such a device and let us know if you have any feedback.

VirtualGrid: Support for UI Elements in the Cells (Cell Templates)

RadVirtualGrid becomes even more powerful with this feature. Now it is possible to apply custom cell template on each cell and show whatever content you want—UI elements, images, other controls—it is up to you. What you need to do is to hook to the CellTemplateNeeded and provide the desired DataTemplate depending on the cell value.

Make sure to check out the Custom Cell Content article for more details.

ChartView: Minor Ticks and Stripes

The new minor ticks support will allow you to utilize a more punctual view of the ticks in the axis. With it, you can define the number of minor ticks to be displayed between major ticks. They are heavily customizable with the available APIs to define the number of minor ticks between major ones, the tick length, offset from the major tick, the tick template and style.

With the support for minor ticks, another useful feature is the support for stripes. Stripes are the visual representation of the minor ticks in the chart area and can be used to display where the minor ticks are, for the user to easily spot the value of a certain tick and compare it to a data point on the chart. Stripes support defining the stripe visibility, style, dash array and more.

For more about those features, see the Minor Tick and Stripes article from the WPF ChartView help documentation.

GridView: Zooming Support & Filtering TextBox for Distinct Values

This release we are adding two highly desired features GridView features:

• Zooming – now the control can be zoomed programmatically or with the Ctrl + MouseWheel combination. To enable zooming with the mouse, you would need to set the EnableMouseWheelScaling property of the control to true. For more details, check out the Zooming article from the WPF GridView documentation.
• Filtering the Distinct Value – you can now easily display filtering TextBox inside of the Filtering Control. Users will no longer have to scroll down the distinct filtering values and can quickly type in a desired value to find it.

DesktopAlert: Show on the Current Display

Until this release, it was only possible to display the DesktopAlert on the main monitor even if your app was on the secondary monitor. With this new feature, you will be able to show the alert depending on the location of your application window (or any window). You need to simply attach the DesktopAlertManager to the desired Window:

var manager = new RadDesktopAlertManager();
manager.Attach(App.Current.MainWindow);

And that’s it—the alerts will be automatically shown on the monitor where the Window is currently located. For more details, check out the Show on Current Screen help article.

Spreadsheet: Conditional Formatting

Based on your feedback, we are happy to introduce a conditional formatting functionality in the Spreadsheet control for WPF. With it, your end users can easily format the entire sheet or section based on either some of the readily available predefined conditions or by utilizing formulas. To learn more visit the Conditional Formatting documentation article.

Spreadsheet: Support for Threaded Comments

After introducing the Notes functionality in the previous release, we have now upgraded the components to enable you to also work with comments and replies. You can check our help topics for more information WPF Spreadsheet Comments.

Spreadsheet: Support for References to Whole Columns and Rows

Now you can use references to whole rows and columns instead of specific cell ranges only. You can use this functionality to include all the values from a row/column to a formula, for example.

Spreadsheet: CONCAT Function

Although the components support 200+ built-in functions, we keep adding more to ensure everything you might need is ready to use. The full list of supported functions is available in the  Functions article.

Document Processing

For a list of the new features shipped in the Telerik Document Processing Libraries shipped with Telerik UI for WPF, see below.

Other Features

• ChartView: Added ability to control the tension of the spline ( link)
• ChartView3D: Added SeriesProvider for dynamic creation of series ( link)
• ContextMenu: Modifier keys can be show without holding Alt when opening the menu via mouse's right button ( link)
• Diagram: Fit-to-page support plus additional setting of the print preview dialog ( link)
• Pivot: Named sets are placed in a correctly named folder, read from a cube’s metadata

Check Out the Detailed Release Notes

We have a lot more! To get an overview of all the latest features and improvements we’ve made, check out the release notes for the products below:

• Telerik UI for WPF (Release Notes)
• Telerik UI for Silverlight (Release Notes)

Telerik UI for Xamarin

The second official release for the year of Telerik UI for Xamarin, namely R2 2022, has just arrived giving you much requested ProgressBar control, as well as DataGrid improvements and a demo for sharing/saving pdf files.

ProgressBar

The ProgressBar control allows you to display to your users the progress of a long-running operation, such as downloading a file, requesting information, etc. The ProgressBar sets a clear expectation of the load time, so it’s quite useful in a number of scenarios when the action takes more than a few seconds. The ProgressBar for Xamarin comes packed with a variety of useful features like indeterminate state, segments support, as well as being fully customizable.

Let’s take a closer look at the features the new ProgressBar for Xamarin provides!

Value, Value Range & Progress

The Value property defines the current progress status of the ProgressBar. There are options for specifying the value range with the Minimum and Maximum properties.

The Progress property, on the other hand, is used to report the current progress status. Progress is updated internally after Value is updated and progress animation is complete.

Indeterminate Mode

ProgressBar is used to visually indicate the progress of a task. Still, there are cases when the progress is unknown—in those scenarios use the indeterminate mode of the control:

<telerikPrimitives:RadLinearProgressBar Value="25" IsIndeterminate="True"/>

Segments Support

Divide ProgressBar into segments in cases the task has predefined number of steps—this is as easy as just applying SegmentCount property:

<telerikPrimitives:RadLinearProgressBar Value="45"
                                        ValueDisplayMode="Value"
                                        SegmentCount="8"/>

Label Customizations Options

In addition to the progress indicator, the ProgressBar control also shows a label to provide more information on the current progress. As the design requirements may vary from case to case, there are various customization options available—you can set the label horizontal alignment, apply string format, as well as use different display modes—display the progress as Value, as percent from the range from minimum to maximum, or use custom text.

Here are some examples of label customization options:

<telerikPrimitives:RadLinearProgressBar  Value="35"
                                        ValueDisplayMode= "Value" />
<telerikPrimitives:RadLinearProgressBar  Value="45"
                                        ValueDisplayMode= "Text"
                                        CustomText= "loading..." />
<telerikPrimitives:RadLinearProgressBar  Value="55"
                                        LabelHorizontalOptions= "Center" />

Styling Options

If you want to customize the ProgressBar color scheme so it matches the design of your app, we’ve handled that as well. ProgressBar provides flexible styling API for customizing the progress fill, track fill, indeterminate fill, label text color, font size and more.

<telerikPrimitives:RadLinearProgressBar Value="90"
TrackFill="LightBlue"
ProgressFill="Blue"
TextColor="Black"
AlternateTextColor="LightBlue"
FontSize="20"
HeightRequest="30"/>

For a full list of the styling properties, visit the ProgressBar: Styling documentation topic.

DataGrid Row Height

DataGrid provides full control over the way its cells are rendered through various Column types—TextColumn, NumericalColumn, BooleanColumn and TemplateColumn, to name a few. Still, there was one missing bit—until now there wasn’t a direct way to explicitly define the height of the grid rows. Now with R2 2022 release, Telerik DataGrid for Xamarin exposes the RowHeight property, which gives you a quick and easy way to control the height of each row. For detailed information on how to use the new property, refer to DataGrid: Row Height documentation topic.

Document Processing

For a list of the new features shipped in the Telerik Document Processing Libraries shipped with Telerik UI for Xamarin, see below.

Demo for Sharing/Saving PDF Documents

We have received many requests to provide options for sharing and saving PDF documents from the PdfViewer’s Toolbar. Then we decided to create a demo that includes these two options. You can find the running demo in our Telerik Xamarin Sample application.

For Pdf Sharing we used the Xamarin.Essentials Share class.

private async Task ShareAsync()
{
    Assembly assembly = typeof(SaveSharePdfView).Assembly;
    string fileName = assembly.GetManifestResourceNames().FirstOrDefault(n => n.Contains("pdfviewer-firstlook.pdf"));
    Stream stream = assembly.GetManifestResourceStream(fileName);
    var cacheFile = Path.Combine(FileSystem.CacheDirectory, "pdfviewer-firstlook.pdf");
    using (var file = new FileStream(cacheFile, FileMode.Create, FileAccess.Write))
    {
        stream.CopyTo(file);
    }

    var fileShareService = DependencyService.Get<IFileShareService>();
    await fileShareService.ShareFileAsync(cacheFile);
}

For Pdf Saving the document visualized in the viewer is saved on the local application data.

private async Task SaveAsync()
{
    var fileName = "pdf-telerik.pdf";
    var localFolder = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
    var filePath = Path.Combine(localFolder, fileName);

    if (this.Document == null)
    {
        return;
    }

    using (Stream output = File.OpenWrite(filePath))
    {
        var provider = new PdfFormatProvider();
        provider.Export(this.Document, output);
    }
    await Application.Current.MainPage.DisplayAlert("Saved on this device as pdf-telerik.pdf.", "Location: " + filePath, "OK");
}

New Features in Telerik Document Processing Library

PdfProcessing: Choose whether the font files to be embedded when exporting PDF documents.

RadPdfPdocessing library provides easy to use API which allows you to choose whether to include the font files while exporting the pdf document.

❗ Removing the fonts from the PDF document makes it dependent on the operating system to provide the needed fonts. If they are not installed on the system, the document will not be successfully opened.

SpreadProcessing: Comments support

Easily insert a comment related to a specific document position. In addition, you can add replies to each comment. A sample runnable demo can be found in Telerik Xamarin Sample application under the SpreadProcessing control section.

Telerik UI for WinForms

Below we will look into what the R2 2022 release of Telerik UI for WinForms brings.

New Component: Office Navigator Bar

With the new Office Navigation Bar control, developers can create intuitive navigation in WinForms applications, similar to the one Microsoft Outlook provides. The control features a list of items represented by text and/or images that the user can select. In addition, there is an overflow functionality for the items that cannot fit in the available space.

My favorite feature of this component is the peek functionality—a popup that is shown above the items on mouse hover. This popup can contain any Windows Forms Control in it and is convenient either for allowing the user to perform a quick action or to display some additional information.

Feature highlights:

• View Modes – Two view modes are available: Compact to display just image or text in the item, and Full where both image and text are displayed.
• Overflow – Items that cannot fit in the control will overflow into a menu for the user to access them.
• Peek Window – A window displayed when the user hovers the item and where any control can be added.
• Options dialog – A built-in dialog with options for configuring Visible items, Display Style and Item order, which the user can access via the overflow menu.
• Design-time support – A convenient designer is available, allowing to configure the main options of the component from its Smart Tag.
• Localization provider – A convenient localization provider allowing translating the control strings into a language of your choice.

New Component: Calculator

We have heard from our users that some LOB applications can take advantage of a calculator component, embedded in the WinForms app. Meet RadCalculator—an easy-to-use component that can be added to Windows Forms applications and enable users to make calculations right in the app, without the need to switch context.

Feature highlights:

• All basic calculations like add, subtract, multiply and divide come out of the box
• More complex calculations are also available – reciprocal, sq root, negate, percentage
• Memory functions – all the memory calculations that you may expect are readily available: M+, M-, MS, MR, MC
• Custom calculations – utilize the flexible API to create your own calculation that the control will execute
• Easy-to-customize UI – the entire UI is highly customizable; you can access every element of the control and amend its look and feel, or add your own elements
• Touch and keyboard support is provided out of the box

Compatibility With Preview 3 of .NET 7

For the enthusiasts who always want to play with the latest .NET version, together with the official bits of R2 2022, we are also shipping bits that target Preview 3 of .NET 7 so you can continue to use your favorite Telerik UI for WinForms controls in your development. Once you install R2 2022, look into the installation folder for assemblies build for .NET 7.

ARM64 Support

With .NET 6, Microsoft has shipped native support for ARM64 on machines that run Windows on ARM devices like Surface Pro X, Samsung Galaxy Book and more. We are happy to confirm that all Telerik UI for WinForms controls are compatible with ARM64 and can be utilized for applications targeting it.

VisualStudio 2022 Theme: Color Blending

In the previous release, we shipped the awesome Visual Studio 2022 theme, and this release we are happy to share that we have also enabled the color blending functionality for it. With color blending, you can easily blend every color used in the theme with another color of your choice, which allows you to quickly change the color scheme used in a particular theme.

More Interactive .NET Core Designer Now With Support for Item Glyphs and Inline Editing

This release marks a major milestone for Telerik UI for WinForms in the adoption of the new Windows Forms designer in Visual Studio. We are excited to share that we are the first and only vendor on the market who now has full feature parity between the old and the new WinForms designer in Visual Studio, and users of Telerik UI for WinForms can now enjoy the full designer experience when crafting their applications.

Improved High DPI Support

This release brings yet another set of improvements in the Telerik UI for WinForms support for high DPI WinForms applications, including dynamically scaling controls added at runtime, scaling improvements to support all combinations of .NET versions and DPI awareness modes, precise scaling in all types of Forms and UserControls, and many other improvements.

Revamped BarCode Component With Support for Reading Barcodes

With this release, we are shipping a fully revamped BarCode component—RadBarCodeView—that brings many improvements to our barcodes story, including a BarCode reader capability, which can be used to decode barcodes from Bitmap images.

Feature highlights:

• Support for one-dimensional barcodes like EAN13, EAN8, UPC-A, UPC-E and Code39 symbologies
• Support for two-dimensional barcodes like QR code, PDF417, and Data Matrix
• BarCodeReader for decoding one dimensional barcodes like Code 11, Code 128, Code 25 Interleaved, Code 25 Standard, Code 39, Code 39 Extended, Code 93, Code 93 Extended, Codabar, Code MSI, EAN 13, GSI 128, EAN 8, Postnet, Planet, Intelligent Mail, UPC A, UPC E, UPC Supplement 2, UPC Supplement 5

Document Processing

For a list of the new features shipped in the Telerik Document Processing Libraries shipped with Telerik UI for WinForms, see below.

Telerik Document Processing Libraries

SpreadProcessing: Support for Threaded Comments

After introducing the Notes functionality in the previous release, we have now upgraded the components to enable you also work with comments and replies. You can check our help topic for the available API.

SpreadProcessing: Support for References to Whole Columns and Rows

Now you can use references to whole rows and columns instead to specific cell ranges only. You can use this functionality to include all the values from a row/column to a formula, for example. All types of references and examples of how you can use them are available in the Reference Ranges topic.

SpreadProcessing: CONCAT Function

Although the components support 200+ built-in functions, we keep adding more to ensure everything you might need is ready to use. The full list of supported functions is available in the  Functions article.

WordsProcessing: Support for Continuous Section Break When Exporting to PDF

This type of section break was exported as a page break in previous versions of WordsProcessing. It is now properly respected, and the layout of the document is preserved.

WordsProcessing: Support for Alternate Text of Images

The alt attribute of the img HTML element is preserved even when its value is an empty string. The functionality is also supported for the image shapes defined in a DOCX document.

PdfProcessing: Support for Type 3 Fonts

The Type 3 fonts are a feature specific to the PDF standard. The Type 3 fonts consist of glyphs defined with PDF graphic operators. Usually, the entire font is embedded in the PDF document, which allows you to view it on devices without accessing fonts from the operating system. With R2 2022, PdfProcessing provides you with full support for this type of fonts.

PdfProcessing: Support for Setting Different Permissions When Creating Encrypted Documents

These settings enable you to specify whether the user can print the document, copy or modify its content. For more details, check the PdfFormatProvider|Settings topic.

PdfProcessing: Exposed Settings Allow You To Control Font Embedding

The PDF standard requires all fonts except the standard ones to be embedded inside the document to ensure it will always look the same way no matter the device or application used to open it. However, this inevitably leads to increasing the file size. With PdfProcessing, you are now allowed to skip the embedding if the file size is crucial for the scenario. For more information on how to use this functionality, check the PdfFormatProvider|Settings topic.

Got Feedback?

As always, we highly appreciate user feedback, and we would like to invite you to continue sending it to our feedback portals. Only with your feedback we can be sure that we are building the things that you benefit your application development the most!

• Telerik UI for .NET MAUI Feedback Portal
• Telerik UI for Xamarin Feedback Portal
• Telerik UI for WPF Feedback Portal
• Telerik UI for WinUI Feedback Portal
• Telerik UI for WinForms Feedback Portal

Download the Latest Bits

For existing users to download the latest bits, visit the Download section of Your Telerik Account or get the Telerik Control Panel and it will take care of that for you.

For all new users who want to try the products, visit the following pages:

• Telerik UI for .NET MAUI
• Telerik UI for Xamarin
• Telerik UI for WPF
• Telerik UI for WinUI
• Telerik UI for WinForms

Live Webinar and Twitch Session—May 16 & 17

Join us for the live R2 2022 release webinar on Tuesday, May 17 at 11 a.m. ET as our Developer Advocates Ed Charbeneau and Sam Basu present in detail the major updates across our .NET UI libraries.

Save your Seat

In addition, we will be hosting a live Twitch demo session on Monday, May 16, 10:00 a.m. ET, where our Developer Advocates dive into their favorite new features in an interactive live streaming session.