UWP Development, Resources Provided by Prism

UWP (Universal Windows Platform) development is a platform for developing applications that run on Windows 10 and later Windows operating systems. These applications can run on various devices (PCs, tablets, Xbox, etc.) and provide a high level of user experience in terms of user interface (UI), performance, accessibility, security, and more. In UWP development, Prism is a useful framework that supports the MVVM (Model-View-ViewModel) architectural pattern, and the various resources provided within this framework contribute to enhancing the quality and productivity of applications.

Overview of the Prism Framework

Prism is a framework that can be used across several platforms like WPF (Windows Presentation Foundation), Xamarin.Forms, and UWP. It primarily offers the following features:

  • Modularity: It separates the application into smaller modules, making it easier to manage.
  • Support for MVVM Pattern: It enhances testability and maintainability by separating the view and business logic.
  • Command and Event Aggregator: Simplifies communication between components.
  • Navigation: Supports efficient and clear transitions between pages.

Resources of Prism

Prism maximizes development efficiency by defining and reusing shareable resources. These resources are primarily provided in the following forms:

1. Styles

Various styles can be defined to maintain UI consistency in UWP applications. Prism provides several common styles by default. These styles are managed through a `ResourceDictionary` and can be easily used in XAML.

2. Control Templates

Control Templates define the appearance of UI elements. Prism provides reusable Control Templates to maintain consistent visual representation of various UI elements.

3. Converters

Converters are resources used to transform data types during data binding. Prism provides several built-in converters to support binding according to the type of data. 


public class BooleanToVisibilityConverter : IValueConverter
{
    public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
    {
        if (value is bool boolean)
        {
            return boolean ? Visibility.Visible : Visibility.Collapsed;
        }
        return Visibility.Collapsed;
    }

    public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
    {
        return value is Visibility visibility && visibility == Visibility.Visible;
    }
}

4. Behaviors

Behaviors are functionalities that work alongside UI elements to add behavior. Prism provides various Behaviors to easily add new functionalities to UI components. This enhances code decoupling and reusability.

Example of Using Prism Resources

Below is an example of developing a UWP application using Prism’s resources. This example implements a simple application that displays a message when the user clicks a button.

1. XAML Setup

First, we define the Styles, Control Templates, and Behaviors that will be used in the MainPage.xaml file.

2. ViewModel Setup

Next, we create the ViewModel to define the action that occurs on button click. 


using Prism.Commands;
using Prism.Mvvm;
using System;

namespace MyApp.ViewModels
{
    public class MainPageViewModel : BindableBase
    {
        private string _message;
        public string Message
        {
            get { return _message; }
            set { SetProperty(ref _message, value); }
        }

        public DelegateCommand MyCommand { get; private set; }

        public MainPageViewModel()
        {
            MyCommand = new DelegateCommand(OnMyCommandExecuted);
        }

        private void OnMyCommandExecuted()
        {
            Message = "Button was clicked!";
        }
    }
}

3. App Entry Point Setup

Finally, we set up the entry point of the application and bind the View and ViewModel. 


using Prism.Ioc;
using Prism.Unity;
using Windows.UI.Xaml;
using MyApp.Views;

namespace MyApp
{
    sealed partial class App : PrismApplication
    {
        public App() : base() { }

        protected override void RegisterTypes(IContainerRegistry containerRegistry)
        {
            containerRegistry.RegisterForNavigation();
        }

        protected override void OnInitialized()
        {
            this.InitializeComponent();
            NavigationService.NavigateAsync("MainPage");
        }
    }
}

Conclusion

By appropriately utilizing the resources provided by Prism when developing UWP applications, you can write more efficient and maintainable code. Styles, Control Templates, Converters, and Behaviors are all elements that enhance the UI and user experience of the application. Through these resources, you can increase code reusability and deepen your understanding of the MVC pattern.

I hope this blog post helps you understand how to utilize Prism’s resources and apply them in actual applications. UWP development will offer more opportunities in the future, and Prism is one of the best tools to accompany you on this journey.

References