Category: UWP Programming

1. What is UWP?

UWP (Universal Windows Platform) is a platform from Microsoft that allows you to develop applications that run on a variety of devices (PCs, tablets, smartphones, etc.). UWP maximizes developer productivity by enabling the creation of apps that can run on multiple devices with a single codebase.

Key features of UWP include the ability to run apps on various platforms such as mobile, PC, and Xbox,
XAML-based UI composition, and the provision of various APIs for modern app development.
Thanks to these advantages, UWP is becoming increasingly popular among developers.

2. What is the Prism Framework?

The Prism Framework is a library designed to enhance the quality and maintainability of XAML-based applications such as WPF, Xamarin.Forms, and UWP.
It adopts the MVVM (Model-View-ViewModel) pattern to help developers easily organize and manage their apps.

Prism provides the following key features:

• Modularity: Applications can be divided into multiple modules, distributing work and increasing code reuse.
• Dependency Injection: It provides an easy-to-manage structure for necessary components, making it convenient for testing.
• Event Aggregation: It effectively manages and binds a variety of events and commands.

3. Installing the Prism Framework

To use the Prism Framework, you need to install the NuGet package.
After creating a new UWP project in Visual Studio, install the required Prism package through the NuGet Package Manager as follows:

Install-Package Prism.Windows

Once the installation is complete, the basic structure of the project is ready.

4. Creating a New UWP Project

Launch Visual Studio and select the ‘Create a new project’ option. In the ‘Platform’
category, choose ‘Windows’, and then select ‘UWP App’.

After setting the project name and save location, click the ‘Create’ button to generate the new project.

5. Setting Up the Prism-Based Structure

To introduce the Prism Framework into the newly created UWP project, you need to set up the basic structure.
In this step, modify the App.xaml.cs file to set it up as a Prism Application.

using Prism;
using Prism.Ioc;

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

    protected override void RegisterTypes(IContainerRegistry containerRegistry)
    {
        // Register services here.
    }

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

6. Creating and Configuring Modules

Another advantage of Prism is support for modularity. You can manage each feature as a separate module.
Create a new module and write the Registration file.

public class MyModule : IModule
{
    public void OnInitialized()
    {
        // Called when the module is initialized.
    }

    public void RegisterTypes(IContainerRegistry containerRegistry)
    {
        containerRegistry.RegisterForNavigation();
    }
}

7. Implementing the MVVM Pattern

Implement the MVVM pattern using UWP and Prism. Create a ViewModel and bind it to the View to easily manage data and testing.

public class MainViewModel : BindableBase
{
    private string _title;
    public string Title
    {
        get { return _title; }
        set { SetProperty(ref _title, value); }
    }

    public MainViewModel()
    {
        Title = "Hello, Prism!";
    }
}

8. Implementing Pages and Data Binding

Bind the ViewModel in MainPage.xaml to create interaction with UI elements.
Below is a simple example of XAML code.

<Page x:Class="YourAppNamespace.MainPage"
      xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
      xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">

    <Grid>
        <TextBlock Text="{Binding Title}" 
                   FontSize="24" 
                   HorizontalAlignment="Center" 
                   VerticalAlignment="Center"/>
    </Grid>
</Page>

9. Testing and Debugging

After building the application, run debugging and testing before deploying to the UWP store.
Utilize Visual Studio’s debugging tools to quickly identify problems in the code.

10. Conclusion and Additional Resources

Through the above steps, I hope you have gained an understanding of the basic flow of UWP app development using the Prism Framework.
I encourage you to refer to websites and books for deeper learning.
Check out the official Prism documentation or
Getting Started with UWP.

Overview of Graphics Processing in UWP

In UWP, XAML and C# are used for graphics processing, enabling developers to easily and quickly create UIs and implement interactions with users. Pen and Shape play important roles in this graphic implementation.

Introduction to Pen

The Pen object is a tool used to draw lines, curves, or other paths. The Pen can specify the thickness, color, style, and more of the line.

using Windows.UI.Xaml.Media;
// Create a Pen object
var myPen = new Pen
{
    Brush = new SolidColorBrush(Windows.UI.Colors.Blue),
    Thickness = 2
};

Introduction to Shape

Shape is a class for drawing basic shapes. There are several Shape classes available in UWP, including Rectangle, Ellipse, Line, Polygon, and Path. Each class is used to represent various shapes.

Basic Pen Usage Example

The code below is a simple example of drawing a line on a Canvas using Pen in a UWP application.

<Canvas x:Name="myCanvas">
    <Path Stroke="{StaticResource MyPen}" Data="M 20,20 L 200,200" />
</Canvas>

private void DrawLine()
{
    var myPen = new Pen
    {
        Brush = new SolidColorBrush(Windows.UI.Colors.Red),
        Thickness = 3
    };
    
    var line = new Line
    {
        X1 = 20,
        Y1 = 20,
        X2 = 200,
        Y2 = 200,
        Stroke = myPen.Brush,
        StrokeThickness = myPen.Thickness
    };

    myCanvas.Children.Add(line);
}

Examples of Various Shapes

UWP allows you to use various Shapes. Below is an example of drawing a Rectangle and an Ellipse.

<Canvas x:Name="myCanvas">
    <Rectangle Width="100" Height="50" Fill="Green" />
    <Ellipse Width="100" Height="50" Fill="Blue" />
</Canvas>

private void DrawShapes()
{
    var rectangle = new Rectangle
    {
        Width = 100,
        Height = 50,
        Fill = new SolidColorBrush(Windows.UI.Colors.Green)
    };

    var ellipse = new Ellipse
    {
        Width = 100,
        Height = 50,
        Fill = new SolidColorBrush(Windows.UI.Colors.Blue)
    };

    myCanvas.Children.Add(rectangle);
    myCanvas.Children.Add(ellipse);
}

Adding Interactions

After drawing graphics with Pen and Shape, you can add interactions with users. For example, here is how to change the color of a shape when the mouse is clicked.

private void myCanvas_PointerPressed(object sender, PointerRoutedEventArgs e)
{
    var point = e.GetCurrentPoint(myCanvas).Position;
    var ellipse = new Ellipse
    {
        Width = 50,
        Height = 50,
        Fill = new SolidColorBrush(Windows.UI.Colors.Red),
        Margin = new Thickness(point.X, point.Y, 0, 0)
    };
    myCanvas.Children.Add(ellipse);
}

Utilizing the Combination of Pen and Shape in UWP

Pen and Shape can be used together to create complex graphics easily. For example, it is possible to combine multiple Shapes to create a complex figure. Additionally, the path of the Shape can be drawn using the Pen.

private void DrawComplexShape()
{
    var myPath = new Path
    {
        Stroke = new SolidColorBrush(Windows.UI.Colors.Black),
        StrokeThickness = 1,
        Data = Geometry.Parse("M 10,100 C 20,10, 40,10, 50,100")
    };

    myCanvas.Children.Add(myPath);
}

Performance Optimization

Optimizing performance while using Pen and Shape in UWP is very important. Especially when drawing a large number of shapes, performance degradation might occur, so batching and offscreen rendering should be considered.

private void OptimizeRendering()
{
    var visualLayer = new DrawingVisual();
    using (var dc = visualLayer.RenderOpen())
    {
        for (int i = 0; i < 1000; i++)
        {
            dc.DrawEllipse(new SolidColorBrush(Colors.Blue), null, new Point(i * 10, i * 10), 5, 5);
        }
    }
}

What is Path?

Path is a powerful tool used to draw vector graphics in UWP. The Path object, which can be defined in XAML (XML Application Markup Language), can define complex shapes and graphics. Through Path, users can easily create various shapes and apply animations, styling, and transformations.

Main Components of Path

Path consists of several components, with the most important ones being:

• Data: Defines the shape of the figures that make up the Path. This allows you to define lines, curves, polylines, and more.
• Stroke: Defines the color and thickness of the outer lines of the Path. This sets the boundaries of the shapes.
• Fill: Defines the internal color of the Path. This sets the color used to fill the shapes.
• Transforms: Defines the transformations applied to the Path. This allows for movement, rotation, scaling, and more.

How to Use Path

To use Path, you can define shapes using the Path tag in XAML. Let’s look at a basic example of using Path.

Basic Path Example

<Path Fill="Blue" Stroke="Black" StrokeThickness="2">
    <Path.Data>
        <GeometryGroup>
            <RectangleGeometry Rect="10,10,100,50" />
            <EllipseGeometry Center="60,60" RadiusX="30" RadiusY="30" />
        </GeometryGroup>
    </Path.Data>
</Path>

The example above draws a rectangle and a circle filled with blue. The Fill and Stroke properties set the colors, and the StrokeThickness property adjusts the line thickness.

Path Animation

Path can provide a more attractive UI by applying animation effects. In UWP, you can add animations to Path using Storyboard.

Path Animation Example

<Page.Resources>
    <Storyboard x:Name="PathAnimation">
        <DoubleAnimation 
            Storyboard.TargetName="MyPath" 
            Storyboard.TargetProperty="(UIElement.RenderTransform).(RotateTransform.Angle)" 
            From="0" To="360" Duration="0:0:2" 
            RepeatBehavior="Forever" />
    </Storyboard>
</Page.Resources>

<Path x:Name="MyPath" Fill="Red" Stroke="Black" StrokeThickness="2" RenderTransform="RotateTransform">
    <Path.Data>
        <EllipseGeometry Center="50,50" RadiusX="50" RadiusY="50" />
    </Path.Data>
</Path>

<Button Content="Start" Click="StartAnimation" />

In the example above, clicking the ‘Start’ button initiates an animation where a red circle rotates 360 degrees over 2 seconds. The RepeatBehavior property can be used to set whether the animation repeats.

Path Transform

You can apply various transformation effects using the Transform property of Path. It allows easy modification of the Path’s position and shape through movement (Move), rotation (Rotate), and scaling (Scale).

Path Transformation Example

<Path Fill="Green" Stroke="Black" StrokeThickness="2">
    <Path.RenderTransform>
        <TransformGroup>
            <RotateTransform Angle="45" />
            <TranslateTransform X="30" Y="30" />
        </TransformGroup>
    </Path.RenderTransform>
    <Path.Data>
        <RectangleGeometry Rect="0,0,100,50" />
    </Path.Data>
</Path>

The example above rotates a green rectangle by 45 degrees and moves its position by 30 units on the X-axis and 30 units on the Y-axis. You can combine multiple transforms to apply to the Path.

Path and Events

Path can handle events for user interaction. You can add mouse events to the Path object so that users can interact with the shapes directly.

Mouse Click Event Example

<Path Fill="Purple" Stroke="Black" StrokeThickness="2" MouseLeftButtonDown="Path_Click">
    <Path.Data>
        <EllipseGeometry Center="100,100" RadiusX="50" RadiusY="50" />
    </Path.Data>
</Path>

The example above defines a Path_Click event that executes when the Path is clicked. This event can allow additional actions to be performed based on the Path clicked by the user in C# code.

C# Code Example

private void Path_Click(object sender, MouseButtonEventArgs e) {
    MessageBox.Show("Path was clicked!");
}

Path and Data Binding

In UWP, Path can dynamically change the properties of shapes through data binding when using the MVVM pattern. This allows the Path’s UI to automatically update according to changes in data.

Data Binding Example

<Path Fill="{Binding Color}" Stroke="Black" StrokeThickness="2">
    <Path.Data>
        <EllipseGeometry Center="50,50" RadiusX="50" RadiusY="50" />
    </Path.Data>
</Path>

The example above defines a Path bound to the Color property. If the Color property changes, the Path’s Fill property will also update automatically.