Category: UWP Programming

UWP (Universal Windows Platform) is a platform introduced by Microsoft for application development based on the Windows 10 operating system. With UWP, developers can write applications that can run on various devices, and these applications will work on desktops, tablets, Xbox, HoloLens, and many other devices that use Windows 10.

Main Features of UWP

• Broad device support: UWP can run on all Windows 10 devices. This means that developers can create applications that can be used across all devices with a single development effort.
• Modern UI framework: UWP uses XAML (Extensible Application Markup Language) to allow designers to create user interfaces, making it easy to implement vibrant and responsive UIs.
• Store distribution: UWP apps can be distributed through the Microsoft Store, making them easily accessible to users. Developers can also distribute their apps outside of the store if necessary.
• Consistency of APIs: UWP provides the same set of APIs across various Windows 10 devices, allowing developers to write code in a consistent manner for diverse hardware.
• Support for advanced features: UWP supports application development leveraging advanced technologies such as artificial intelligence, machine learning, and AR/VR (augmented reality/virtual reality).

Structure of UWP Apps

UWP applications typically have the following structure:

• App.xaml: Contains the overall settings of the application. It defines resource dictionaries, start pages, etc.
• MainPage.xaml: The page that defines the main user interface of the application.
• Views and ViewModels: Maintains the structure of the application using the MVVM (Model-View-ViewModel) pattern.
• Assets: A folder that contains images, styles, and other resources.

Setting up the UWP Development Environment

The environment required for developing UWP apps includes:

• Windows 10: The Windows 10 operating system is required for UWP development.
• Visual Studio: Microsoft’s integrated development environment, which includes all the tools needed for UWP app development.
• Windows 10 SDK: You must install the software development kit (SDK) for UWP app development.

Example of UWP App Development

Now, let’s create a simple UWP app. This application is a straightforward app that displays a greeting when the user enters their name and clicks a button.

1. Create a new UWP project

1. Open Visual Studio, and select “File” menu then “New” -> “Project”.
2. Select C# as the language and choose the “Blank App (Universal Windows)” template, then name the project and click “Create”.
3. You can set the target and minimum versions at this time; using the defaults is fine.

2. Design the user interface with XAML

Open MainPage.xaml in Visual Studio and modify it as follows:

<Page
    x:Class="HelloWorld.MainPage"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="using:HelloWorld"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d">

    <Grid>
        <StackPanel HorizontalAlignment="Center" VerticalAlignment="Center">
            <TextBox x:Name="NameInput" PlaceholderText="Enter your name" />
            <Button Content="Greet" Click="GreetButton_Click" />
            <TextBlock x:Name="GreetingText" FontSize="20" Margin="10" />
        </StackPanel>
    </Grid>
</Page>

3. Implement logic with C#

Open the MainPage.xaml.cs file and add the following code:

using Windows.UI.Xaml;
using Windows.UI.Xaml.Controls;

namespace HelloWorld
{
    public sealed partial class MainPage : Page
    {
        public MainPage()
        {
            this.InitializeComponent();
        }

        private void GreetButton_Click(object sender, RoutedEventArgs e)
        {
            var name = NameInput.Text;
            GreetingText.Text = $"Hello, {name}!";
        }
    }
}

4. Run the app

After writing the code, you can run the app (Debug → Start or F5 key) to test it on the emulator or an actual device.

Conclusion

UWP is a platform that allows you to develop powerful applications that can run on various Windows 10 devices. Thanks to modern UI design tools and robust API support, developers can create apps that provide rich experiences tailored to user needs. The advantages of UWP development are numerous, equipping you with all the tools needed to deliver better user experiences. Leverage these features to develop your own UWP applications.

UWP (Universal Windows Platform) is a platform for developing applications that can run on various Windows 10 devices. This allows developers to create apps that run on PCs, tablets, Xbox, IoT devices, and more. UWP is Microsoft’s new app model, providing a modern user interface (UI) and flexible application structure.

Setting Up the UWP Development Environment

To develop UWP applications, the following environment is required:

• Windows 10 operating system
• Visual Studio 2019 or later
• Windows SDK

After installing Visual Studio, select the ‘UWP Development’ workload to install it.

UWP Application Structure

UWP applications are fundamentally composed of the following files:

• App.xaml: Defines the application’s resources and startup page.
• MainPage.xaml: The page where the user interface (UI) is defined.
• Package.appxmanifest: A file that sets the application’s metadata and permissions.

Creating Your First UWP Application

Let’s create a simple UWP application following the steps below.

1. Run Visual Studio and select ‘Create a New Project’.
2. Select ‘Blank App’ from the UWP category, enter the project name, and click ‘Create’.

Code Structure

Once the project is created, the App.xaml and MainPage.xaml files will be generated. Below is an example of MainPage.xaml:

<Page
    x:Class="YourAppNamespace.MainPage"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="using:YourAppNamespace"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d">

    <Grid Background="{ThemeResource ApplicationPageBackgroundThemeBrush}">
        <TextBlock x:Name="textBlock" Text="Hello, UWP!" FontSize="24" HorizontalAlignment="Center" VerticalAlignment="Center"/>
        <Button Content="Click Me" Click="Button_Click" HorizontalAlignment="Center" VerticalAlignment="Bottom" Margin="0,50,0,0"/>
    </Grid>
</Page>

In the code above, we added simple text and a button. Now, let’s handle the button click event in the MainPage.xaml.cs file.

using Windows.UI.Xaml;
using Windows.UI.Xaml.Controls;

namespace YourAppNamespace
{
    public sealed partial class MainPage : Page
    {
        public MainPage()
        {
            this.InitializeComponent();
        }

        private void Button_Click(object sender, RoutedEventArgs e)
        {
            textBlock.Text = "Button has been clicked!";
        }
    }
}

Data Binding in UWP

In UWP applications, data binding can be implemented through the MVVM (Model-View-ViewModel) pattern. Data binding automatically maintains the connection between UI elements and data models. The example below introduces data binding using XAML and C#.

Creating the Model

public class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
}

Creating the ViewModel

using System.ComponentModel;

public class PersonViewModel : INotifyPropertyChanged
{
    private Person person;

    public PersonViewModel()
    {
        person = new Person() { Name = "John Doe", Age = 30 };
    }

    public string Name
    {
        get => person.Name;
        set
        {
            person.Name = value;
            OnPropertyChanged(nameof(Name));
        }
    }

    public int Age
    {
        get => person.Age;
        set
        {
            person.Age = value;
            OnPropertyChanged(nameof(Age));
        }
    }

    public event PropertyChangedEventHandler PropertyChanged;

    protected void OnPropertyChanged(string propertyName)
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }
}

Applying Binding in XAML

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

    <Grid>
        <TextBlock Text="{Binding Name}" FontSize="24" HorizontalAlignment="Center" VerticalAlignment="Center"/>
        <TextBox Text="{Binding Age, Mode=TwoWay}" Width="200" HorizontalAlignment="Center" VerticalAlignment="Bottom"/>
    </Grid>
</Page>

The above code binds the Name property directly to the text block and binds the Age property to the text box in a two-way fashion. By setting the ViewModel as the data context of the page, the UI will be automatically updated with the data.

Deploying UWP Apps

There are several ways to deploy UWP applications:

• Windows Store: You can submit the app to the Microsoft Store for a wider audience.
• Direct Deployment: You can create an .appx package and distribute it directly to users.
• Local Testing: You can run the app in a development environment.

Conclusion

UWP development is a great way to create flexible and intuitive applications that can run on various Windows devices. Through this tutorial, you have learned the basics of UWP development and hopefully created a simple application. You can learn more in-depth content through the official documentation or various communities.

References

• Microsoft Official UWP Getting Started Documentation
• UWP Design Guidelines
• UWP C# Development Documentation

Development on the Windows platform can be done in various ways, but UWP (Universal Windows Platform) is gaining attention as one of the most modern and powerful methods. UWP apps are designed to work across a variety of Windows devices, providing users with a consistent experience. In this article, we will detail the basic concepts of UWP development, setting up the development environment, the process of creating a real UWP app, and finally, how to install the app.

1. What is UWP Development?

UWP is a platform announced by Microsoft in 2015 that allows the creation of apps that run on various Windows devices, including desktops, tablets, smartphones, Xbox, and IoT devices. The biggest advantage of UWP is interoperability. With a single code base, it can run on various devices and automatically adjusts to fit the screen size and input methods of each device.

1.1 Key Features of UWP

• Support for various devices: UWP apps run on various Windows devices such as PCs, Xbox, and mobile devices.
• Responsive design: The UI automatically adjusts to fit various screen sizes with one code base.
• Distribution via Windows Store: UWP apps can be easily distributed and updated through the Microsoft Store.
• Support for the Internet of Things (IoT): It also supports app development for IoT devices, making it easy to access a connected world.

2. Setting Up the UWP Development Environment

To develop UWP apps, you need to install several essential tools. This will allow you to easily get started with creating UWP applications.

2.1 Installing Visual Studio

The IDE commonly used for UWP app development is Visual Studio. You can download the latest version from Microsoft’s official website. During installation, select the ‘Universal Windows Platform development’ workload to install the related tools.

2.2 Installing the Windows 10 SDK

The Windows 10 SDK is a package that includes the APIs and tools necessary for developing UWP apps. It is usually included by default during Visual Studio installation, but you may need to install it separately. Installing the Windows 10 SDK allows you to implement features using the latest APIs.

3. Creating a UWP App

Once you are ready, let’s create a real UWP app. Here, we will describe the process of creating a basic ‘Hello World’ app.

3.1 Creating a New Project

After launching Visual Studio, click on ‘Create a new project’. Select the ‘Blank App (Universal Windows)’ template and specify a project name and location, then click ‘Create’.

3.2 Designing the UI with XAML

UWP uses XAML (Extensible Application Markup Language) to compose the UI. Open the MainPage.xaml file created and modify it as follows.

3.3 Writing C# Code

To combine the UI and logic, open the MainPage.xaml.cs file and add the necessary code. By default, since the UI elements are composed in XAML, no additional code is needed.

3.4 Running the App

Now let’s run the app. Click the ‘Start’ button in Visual Studio to build and run the UWP app. Once it is running, you will see the ‘Hello, World!’ text appear in the center of the screen.

4. Installing the UWP App

Once the app is complete, let’s look at how to install it. UWP apps can be distributed through the Microsoft Store or installed via enterprise deployment methods.

4.1 Distributing to Microsoft Store

By distributing the UWP app to the Microsoft Store, users can easily download and install the app. To distribute, you must register at the Microsoft Developer Center. After registration, follow these steps.

1. Create an app package: Click on the ‘Project’ menu in Visual Studio and select ‘Store’ > ‘Create App Packages…’
2. Package settings: Enter settings for package creation and click the ‘Create’ button.
3. Distribution: Upload the created package to the Developer Center and create a listing that includes app descriptions, screenshots, etc.
4. Review and publish: After review and approval by Microsoft, users will be able to download the app through the Microsoft Store.

4.2 Enterprise Deployment

When deploying UWP apps in an enterprise environment, you can deploy directly to devices within the organization. To do this, you can create an App Installer file or use PowerShell scripts.

1. Create an App Installer file: Create a .appinstaller file through which users can install the app.
2. Using PowerShell: You can execute commands to install the app package using PowerShell. For example, you can use the following command:

powershell
        Add-AppxPackage -Path "C:\Path\To\YourApp.appx"
    

This command installs the app package located at the specified path.

5. Conclusion

UWP development is a powerful approach for modern Windows app development. By leveraging the advantage of easily developing and distributing apps that can run on various devices, developers gain the opportunity to reach a larger audience. Through the content explained in this article, we hope that you enhance your basic understanding of UWP development and app installation, leading to actual app development. We encourage you to develop various UWP apps in the Windows ecosystem going forward.

As part of Windows platform development, UWP (Universal Windows Platform) is a platform for developing applications that run on Windows 10 and later. UWP allows the same application to run on various Windows devices, including PCs, tablets, Xbox, and IoT devices. In this article, we will explain the UWP development environment and introduce the process of creating a basic UWP application.

1. Features of UWP

UWP has the following features:

• Cross-device compatibility: It can be executed on various Windows devices through code reusability.
• Modern UI: It allows the creation of modern and responsive user interfaces using XAML.
• Store distribution: Applications can be distributed and managed through the Microsoft Store.
• Security: It runs in a sandbox environment, providing high security.

2. Setting up the UWP Development Environment

To develop UWP applications, a suitable development environment is necessary. Here are the main software and tools required for UWP development.

2.1 Installing Visual Studio

Install Visual Studio, which is the standard IDE for UWP development. The steps for installation are as follows:

1. Visit the official Visual Studio website and download the installation file.
2. Run the installer and select “Developer tools” or “All features” for the installation type.
3. Select “Developer tools” for UWP development.
4. After completing the installation, launch Visual Studio.

2.2 Installing Windows SDK

Visual Studio includes the Windows SDK by default, but if a specific version of the SDK is required, it can be downloaded separately. The SDK provides the APIs and tools necessary for UWP application development.

2.3 UWP Platform Components

A UWP application consists of the following basic components:

• App.xaml: Defines the starting point and resources of the application.
• MainPage.xaml: Defines the first page of the application.
• Package.appxmanifest: Defines the settings and information of the application.

3. Creating Your First UWP Application

Now let’s actually create a UWP application.

3.1 Creating a New Project

Launch Visual Studio and follow the steps below to create a new UWP project:

1. Select “New” > “Project” from the “File” menu in Visual Studio.
2. Select “Windows” from the project templates and then choose “Blank App (Universal Windows Platform)”.
3. Set the project name and path, and click the “Create” button.

3.2 Designing UI and Writing Code

Once the project is created, open the MainPage.xaml file to design the UI. The following example is a simple application that displays a message box when the button is clicked:

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

    <Grid Background="{ThemeResource ApplicationPageBackgroundThemeBrush}">
        <Button x:Name="MyButton"
                Content="Click Me!"
                VerticalAlignment="Center"
                HorizontalAlignment="Center"
                Click="MyButton_Click"/>
    </Grid>
</Page>

Then add the button click event handler in the MainPage.xaml.cs file:

using Windows.UI.Xaml;
using Windows.UI.Xaml.Controls;

namespace MyFirstUWPApp
{
    public sealed partial class MainPage : Page
    {
        public MainPage()
        {
            this.InitializeComponent();
        }

        private async void MyButton_Click(object sender, RoutedEventArgs e)
        {
            var dialog = new MessageDialog("Hello, welcome to UWP development!");
            await dialog.ShowAsync();
        }
    }
}

3.3 Running the Application

You can run the application by pressing the F5 key in Visual Studio. A window with a clickable button will open, and when the button is clicked, a message box will appear.

4. Debugging and Deployment

Debugging and deployment are also very important processes in UWP development. Visual Studio provides powerful debugging tools that allow you to handle code errors while running the application and fixing bugs.

4.1 Debugging

To debug, press the F5 key to run the application and set breakpoints on the desired lines of code. The application will pause execution when it reaches that code. Afterward, you can inspect variable values or program flow to resolve issues.

4.2 Deployment

Once the application is completed, it can be published to the Microsoft Store. In Visual Studio, select “Prepare for Deployment” from the “Solution” menu to generate an .appx or .appxbundle file. Submit this file to the Microsoft Store for distribution.

5. The Evolution and Future of UWP

UWP continues to evolve in line with Microsoft’s latest technology trends. Currently, UWP is being developed in integration with WinUI and MAUI (Multi-platform App UI), enabling developers to create applications across various devices with more powerful and flexible tools.

Conclusion

UWP development plays a very important role in modern Windows application development. By establishing a suitable development environment and creating basic UWP applications, it offers opportunities to deploy and run the same application across various Windows devices. I hope what you learned today helps you take your first step into the world of UWP application development.

References

• Getting Started with UWP – Microsoft Docs
• Visual Studio Download Page

In recent years, cross-platform development has become increasingly important alongside various platforms, and UWP (Universal Windows Platform) development is gaining attention. UWP is a platform for developing apps that run on Windows 10 and later versions, providing advanced APIs and tools to help developers deliver better user experiences. In this article, we will detail how to develop apps using the UWP MVVM pattern and clarify concepts through example code.

UWP and MVVM Pattern

The MVVM (Model-View-ViewModel) pattern is a design pattern used to separate the UI and business logic, making it very useful in UWP app development. Let’s look at each component of the MVVM pattern:

• Model: Includes data and business logic. This is where interactions with the database and API calls usually take place.
• View: Refers to the UI that is displayed to the user. The UI is defined using XAML.
• ViewModel: Acts as a mediator between the view and the model. It communicates the model’s data to the view through data binding and passes user input from the view to the model.

Advantages of UWP MVVM Architecture

• Maintainability: The separation of UI and logic makes it easier to maintain the code.
• Testability: The ViewModel can be tested, making unit testing easier.
• Reusability: Components of ViewModel and Model can be reused.

Preparing to Develop UWP MVVM Apps

To develop UWP MVVM apps, you need to install Visual Studio. It is also recommended to use the latest version of Visual Studio that includes the SDK for UWP development.

Once Visual Studio installation is complete, follow these steps to create a new UWP project:

1. Launch Visual Studio.
2. From the File menu, select ‘New’ > ‘Project’.
3. Select UWP and choose ‘Blank App (UWP)’, then specify the project name.

Creating the MVVM Structure

After the project is created, you will set up the MVVM structure. First, create the following folder structure:

/MyUwpApp
|--- /Models
|--- /ViewModels
|--- /Views

Defining the Model

The model contains the data structures and business logic that the app will use. Let’s create a simple ‘Person’ model.

namespace MyUwpApp.Models
{
    public class Person
    {
        public string Name { get; set; }
        public int Age { get; set; }
    }
}

Defining the ViewModel

The ViewModel acts as a connector between the model and the view. Create a ‘MainViewModel’ to manage the list of people to be displayed in the user interface.

using System.Collections.ObjectModel;
using System.ComponentModel;
using MyUwpApp.Models;

namespace MyUwpApp.ViewModels
{
    public class MainViewModel : INotifyPropertyChanged
    {
        private ObservableCollection<Person> _people;
        public ObservableCollection<Person> People
        {
            get { return _people; }
            set 
            {
                _people = value;
                OnPropertyChanged(nameof(People));
            }
        }

        public MainViewModel()
        {
            People = new ObservableCollection<Person>
            {
                new Person { Name = "John Doe", Age = 30 },
                new Person { Name = "Admiral Yi Sun-sin", Age = 40 }
            };
        }

        public event PropertyChangedEventHandler PropertyChanged;

        protected void OnPropertyChanged(string propertyName)
        {
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
        }
    }
}

Defining the View

In UWP, XAML is primarily used to define the user interface. Modify MainPage.xaml to connect it to the ViewModel.

Running the App

Now that everything is ready, let’s run the app. Click the run button in Visual Studio to execute the app locally. A list of people should be displayed, along with each person’s name and age.

Conclusion

In this article, we explored the basics of UWP app development and how to use the MVVM design pattern, along with a simple example code to build a real application. Using the MVVM pattern enables easier code maintenance and increases testability. There are many features that can be implemented with UWP, so continue to learn and evolve.

Additional Resources

• UWP Official Documentation
• WPF MVVM Example
• Windows Community Toolkit