라이브스마트

In UWP (Universal Windows Platform) development, styles are an essential part of the visual elements experienced by users within the application.
Named Style, which refers to explicit styles, is one way to define the visual properties of UI controls in XAML (XAML is an XML-based markup language used to define the UI of UWP applications).
By using Named Styles, it becomes easy to apply and reuse a consistent style for specific UI elements.
This article will explain the concept of Named Styles in UWP development and explore their usage through concrete examples.

1. Concept of Named Style

Named Style is a set of reusable visual properties that can be applied to specific UI elements, defined within XAML files.
The main purpose of Named Style is to reduce code duplication and provide a consistent user interface.
Named Styles are specified using the Style tag, which allows you to define styles.
Using Named Styles makes it easy to change styles later and helps apply the same style to multiple UI elements.

2. Defining Named Style

Defining a Named Style is simple.
You define the Style tag within Page.Resources in XAML and connect it to the Style property of specific UI elements.
A key point here is to use the x:Key attribute to assign a name to the style, allowing it to be identified when defining styles.

2.1 Example of Style Definition

<Page.Resources>
    <Style x:Key="MyButtonStyle" TargetType="Button">
        <Setter Property="Background" Value="Blue"/>
        <Setter Property="Foreground" Value="White"/>
        <Setter Property="FontSize" Value="16"/>
        <Setter Property="Padding" Value="10,5"/>
        <Setter Property="Margin" Value="5"/>
    </Style>
</Page.Resources>

The above example defines a style named MyButtonStyle, setting the button’s background color, text color, font size, and margins.

3. Applying Named Style

The defined Named Style can be easily applied to UI elements.
This simplifies complex XAML code and allows the same style to be applied to multiple elements.
Named Styles can be applied not only to buttons but also to various other UI elements.

3.1 Example of Applying Style

<Button Style="{StaticResource MyButtonStyle}" Content="Click Me!" />

The above code applies MyButtonStyle to the button, reflecting all the defined style properties on the button.

4. Scalability of Named Style

Named Style provides a powerful feature for creating new styles based on existing styles.
By using the BasedOn attribute, you can define a new style that inherits from an existing style.
This minimizes code duplication and enables the creation of maintainable styles.

4.1 Example of BasedOn

<Style x:Key="MySecondaryButtonStyle" TargetType="Button" BasedOn="{StaticResource MyButtonStyle}">
        <Setter Property="Background" Value="Gray"/>
    </Style>

The above code defines MySecondaryButtonStyle, creating a new style based on MyButtonStyle.
The default background color is blue, but here it has been changed to gray.

5. Customization through Named Style

Named Styles can be defined and applied in various ways according to user requirements.
Styles go beyond mere appearance and greatly impact the overall user experience of the application.
For instance, maintaining consistency in the shape, size, and color of buttons can provide comfort to users while using the application.

5.1 Example of Customization

<Style TargetType="Button">
        <Setter Property="Background" Value="Green"/>
        <Setter Property="Foreground" Value="White"/>
        <Setter Property="FontSize" Value="18"/>
        <Setter Property="BorderThickness" Value="2"/>
        <Setter Property="BorderBrush" Value="Black"/>
    </Style>

Here, the background is set to green, the text color to white, the font size to 18, and a thick black border is added.

6. Differences between Named Style and Template

In UWP, there is also the concept of Template for defining styles of UI elements.
Named Styles and Templates are related but serve different purposes.
Named Style is primarily used for setting visual properties, while Template is used for defining the structure and behavior of UI elements.
This enables the creation of customizable UI elements.

6.1 Example of Template Definition

<ControlTemplate TargetType="Button">
        <Border Background="{TemplateBinding Background}">
            <ContentPresenter />
        </Border>
    </ControlTemplate>

The above code defines a Template for a button. Using Templates allows for the complete modification of the structure of UI elements.

7. Named Style and Data Binding

When using data binding in UWP, it is possible to flexibly adjust the behavior and styles of various UI elements by combining it with Named Styles.
For example, the style of a button can be changed dynamically based on the state of the data.

7.1 Example of Data Binding

<Button Content="Submit" Style="{StaticResource MyButtonStyle}" 
        Background="{Binding IsEnabled, Converter={StaticResource BooleanToColorConverter}}" />

In the above code, the button’s background color is dynamically set based on conditions through data binding.
The BooleanToColorConverter is the converter that makes this process possible.

8. Real World Example: Using Named Style in a UWP Application

Let’s take a look at how to utilize Named Styles in a real UWP application. Below is the full example code.

<Page
        x:Class="MyApp.MainPage"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:local="using:MyApp"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        mc:Ignorable="d"
        >
    <Page.Resources>
        <Style x:Key="MyButtonStyle" TargetType="Button">
            <Setter Property="Background" Value="Blue"/>
            <Setter Property="Foreground" Value="White"/>
            <Setter Property="FontSize" Value="16"/>
            <Setter Property="Padding" Value="10,5"/>
            <Setter Property="Margin" Value="5"/>
        </Style>
    </Page.Resources>

    <Grid>
        <Button Style="{StaticResource MyButtonStyle}" Content="Click Me!" />
    </Grid>
    </Page>

This example adds a simple button and applies the style through the defined Named Style. Thus, Named Styles become a powerful tool in UWP development.

Conclusion

We explored how to utilize Named Styles in UWP development.
Named Styles, which help maintain consistency of UI element styles and make them reusable, assist in efficient development.
The importance of Named Styles becomes even more pronounced when considering the maintenance and scalability of the application.
I hope this article has helped you understand the basic concepts of Named Styles and how to apply them in practice.

In modern application development, design patterns help improve software structure and facilitate maintenance. In next-generation app development on the Windows platform, the MVVM (Model-View-ViewModel) pattern is widely used in UWP (Universal Windows Platform). This article will explain the MVVM pattern in detail, focusing on one of its components, the ViewModel, and will provide example code to aid understanding.

1. Overview of the MVVM Pattern

MVVM separates the application structure into three main components: Model, View, and ViewModel. A brief description of their roles is as follows:

• Model: This part contains the application’s data and business logic. It is responsible for retrieving and storing data and is not directly connected to the View or ViewModel.
• View: Represents the UI elements displayed to the user. It collects user input and updates the screen, with changes to the View being carried out through the ViewModel.
• ViewModel: Acts as a mediator between the Model and View. It provides data to be displayed in the View and processes user input to update the Model. This reduces the dependency between the View and the Model.

2. Advantages of the MVVM Pattern

Some key advantages of using the MVVM pattern are:

• Ease of Testing: Because the ViewModel is separated from the UI, business logic can be easily validated through Unit Testing.
• Ease of Maintenance: Since the UI and business logic are separated, the impact on other areas during modifications is minimized.
• Code Reusability: Multiple views can be supported with the same ViewModel, facilitating code reuse.

3. Role of the ViewModel

The primary roles of the ViewModel are:

• Preparing data for transfer and displaying or updating it in the View.
• Receiving user input and passing it to the Model or processing business logic.
• Automatically updating the UI through data binding with the View.

4. Components of the ViewModel

The ViewModel typically consists of the following components:

• Properties: Properties that contain data to be displayed in the View. It implements the INotifyPropertyChanged interface to notify the UI of data changes.
• Commands: Objects that delegate methods to handle user input. They are implemented through the ICommand interface and handle user actions like button clicks in the UI.
• Methods: Methods that implement business logic. They update the Model or perform specific tasks.

5. Example: Implementing ViewModel in UWP

Now, let’s implement a simple MVVM pattern in UWP. In this example, we will create a simple application that receives a user-inputted name and displays a greeting message.

5.1. Define Model

public class GreetingModel
{
    public string Name { get; set; }
}

5.2. Define ViewModel

using System.ComponentModel;
using System.Windows.Input;

public class GreetingViewModel : INotifyPropertyChanged
{
    private GreetingModel _greetingModel;
    private string _greetingMessage;

    public GreetingViewModel()
    {
        _greetingModel = new GreetingModel();
        GreetCommand = new RelayCommand(ExecuteGreetCommand);
    }

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

    public string GreetingMessage
    {
        get => _greetingMessage;
        set
        {
            if (_greetingMessage != value)
            {
                _greetingMessage = value;
                OnPropertyChanged(nameof(GreetingMessage));
            }
        }
    }

    public ICommand GreetCommand { get; }

    private void ExecuteGreetCommand()
    {
        GreetingMessage = $"Hello, {Name}!";
    }

    public event PropertyChangedEventHandler PropertyChanged;

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

5.3. Define RelayCommand Class

using System;
using System.Windows.Input;

public class RelayCommand : ICommand
{
    private readonly Action _execute;
    private readonly Func _canExecute;

    public RelayCommand(Action execute, Func canExecute = null)
    {
        _execute = execute;
        _canExecute = canExecute;
    }

    public bool CanExecute(object parameter) => _canExecute == null || _canExecute();

    public void Execute(object parameter) => _execute();

    public event EventHandler CanExecuteChanged
    {
        add => CommandManager.RequerySuggested += value;
        remove => CommandManager.RequerySuggested -= value;
    }
}

5.4. Define View

<Page
    x:Class="UWP_MVVM.MainPage"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="using:UWP_MVVM"
    DataContext="{Binding GreetingViewModel, Source={StaticResource Locator}}">

    <StackPanel>
        <TextBox
            Width="300"
            Text="{Binding Name, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}" />
        <Button Command="{Binding GreetCommand}" Content="Greet" />
        <TextBlock Text="{Binding GreetingMessage}" FontSize="24" />
    </StackPanel>
</Page>

6. Conclusion

The MVVM pattern improves the structure of UWP applications and enhances development efficiency. The ViewModel plays a key role, allowing for a reduction in coupling between the View and the Model. I hope this article has provided a deeper understanding of the MVVM pattern and the role of the ViewModel.

If you wish to obtain more information, please refer to various online resources or documents. I hope you develop better UWP applications using the MVVM pattern!

Windows Universal Platform (UWP) application development has become an important part of software development in the 21st century. Microsoft has enabled developers to create applications that can run on various Windows 10 devices through UWP. The MVVM (Model-View-ViewModel) architectural pattern is recognized as a key design pattern in UWP application development. In this article, we will explore the concept of ‘view’ in UWP applications based on the MVVM pattern and understand it in depth through practical examples.

Introduction to MVVM Pattern

The MVVM pattern separates the structure of the application so that each component can be developed, tested, and maintained independently. Here is a brief description of each component of MVVM:

• Model: Defines data and business logic. It encompasses all data used by the application and the rules for manipulating that data.
• View: Defines the user interface. All UI elements that the user can see are defined here.
• ViewModel: Acts as an intermediary between the Model and View, providing data required by the View and handling user input. The View is bound to the ViewModel to display data.

Understanding the View

In the MVVM pattern, the ‘view’ comprises the parts of the application’s user interface that includes all elements interacting with the user. In UWP, the view is defined using XAML (eXtensible Application Markup Language). XAML allows for the declarative definition of UI elements.

The view plays a crucial role not only in encompassing UI elements but also in processing user input and structuring elements that users will see. Here are the main characteristics of the view in UWP:

• Data Binding: The view is bound to the properties of the ViewModel, allowing for easy interaction between data and the UI.
• Styles and Templates: UWP provides various styles and templates, enabling developers to easily customize the UI.
• Commands: The view can use commands from the ViewModel to handle interactions with the user.

Example: View in UWP Application

Now, let’s look at a simple example of how to implement the view in a UWP application according to the MVVM pattern. In the example below, we will create a simple counter app.

1. Create Model

public class CounterModel
{
    public int Value { get; set; }

    public CounterModel()
    {
        Value = 0;
    }

    public void Increment()
    {
        Value++;
    }

    public void Decrement()
    {
        Value--;
    }
}

2. Create ViewModel

using System.ComponentModel;
using System.Windows.Input;

public class CounterViewModel : INotifyPropertyChanged
{
    private readonly CounterModel _model;

    public int CounterValue
    {
        get { return _model.Value; }
        set 
        {
            _model.Value = value;
            OnPropertyChanged(nameof(CounterValue));
        }
    }

    public ICommand IncrementCommand { get; }
    public ICommand DecrementCommand { get; }

    public CounterViewModel()
    {
        _model = new CounterModel();
        IncrementCommand = new RelayCommand(Increment);
        DecrementCommand = new RelayCommand(Decrement);
    }

    private void Increment()
    {
        _model.Increment();
        CounterValue = _model.Value;
    }

    private void Decrement()
    {
        _model.Decrement();
        CounterValue = _model.Value;
    }

    public event PropertyChangedEventHandler PropertyChanged;

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

3. Create View (XAML)

4. Binding ViewModel in App.xaml.cs

public App()
{
    this.InitializeComponent();
    this.Suspending += OnSuspending;
}

protected override void OnLaunched(LaunchActivatedEventArgs e)
{
    Frame rootFrame = Window.Current.Content as Frame;

    if (rootFrame == null)
    {
        rootFrame = new Frame();
        Window.Current.Content = rootFrame;
    }

    if (rootFrame.Content == null)
    {
        var viewModel = new CounterViewModel();
        rootFrame.Navigate(typeof(MainPage), viewModel);
    }

    Window.Current.Activate();
}

Conclusion

In the MVVM pattern, the ‘view’ is a core component of the user interface and plays a significant role in shaping user experience. We learned how to define views using XAML in UWP and handle user interaction through ViewModel and data binding. Through this example, we hope to provide a foundation for understanding the basic MVVM pattern and applying such structures in more complex UWP applications.

The world of UWP development is vast and filled with diverse possibilities, and the MVVM architecture greatly helps maximize that potential. We encourage you to continuously practice and gain deeper understanding through various examples.

If you have any further questions or need assistance, please feel free to leave a comment.

One of the architecture patterns used by developers to create applications is the MVVM (Model-View-ViewModel) pattern, which is particularly suitable for UWP (Universal Windows Platform) development. MVVM clearly separates the structure of the application, enhancing maintainability and facilitating testing. This article aims to deeply explore the ‘Model,’ an important element of the MVVM pattern.

Overview of the MVVM Pattern

The MVVM pattern is divided into three main components:

• Model: Responsible for data and business logic. This layer represents the core data of the application and primarily involves interactions with the database.
• View: Contains the visual components of the user interface. It structures the UI to allow users to interact with the interface and is responsible for displaying data through bindings with the ViewModel.
• ViewModel: Acts as a bridge between the Model and the View. It mainly handles user interface operations, processes model data, and passes it to the View.

Role of the Model

The Model defines the data structure of the application and includes logic for loading, saving, and validating data. In UWP application development, the Model is primarily used for business logic and data representation. For example, it manages layers of data such as user information or app settings.

Components of the Model

The Model typically consists of the following components:

• Data Class: A class that defines the data structure of the application.
• Repository Class: Contains methods for reading and writing data through interactions with the database.
• Service Class: Includes the business logic of the application and handles processing for multiple data models.

Example Code: Implementing a User Information Model

Let’s implement a simple user information model. Here, we will create a Model for a UWP application using C# and XAML.

1. Defining the Data Class

public class User
{
    public string Name { get; set; }
    public string Email { get; set; }
    public string Phone { get; set; }

    public User(string name, string email, string phone)
    {
        Name = name;
        Email = email;
        Phone = phone;
    }
}

2. Implementing the Data Repository Class

using System.Collections.Generic;
using System.Threading.Tasks;

public class UserRepository
{
    private List<User> _users = new List<User>();

    public Task<List<User>> GetUsersAsync()
    {
        return Task.FromResult(_users);
    }

    public Task AddUserAsync(User user)
    {
        _users.Add(user);
        return Task.CompletedTask;
    }

    public Task RemoveUserAsync(User user)
    {
        _users.Remove(user);
        return Task.CompletedTask;
    }
}

3. Implementing the Business Logic Class

public class UserService
{
    private UserRepository _userRepository;

    public UserService(UserRepository userRepository)
    {
        _userRepository = userRepository;
    }

    public async Task AddUserAsync(string name, string email, string phone)
    {
        var user = new User(name, email, phone);
        await _userRepository.AddUserAsync(user);
    }

    public async Task<List<User>> GetUsersAsync()
    {
        return await _userRepository.GetUsersAsync();
    }
}

Interaction Between MVVM and the Model

In the MVVM pattern, the Model does not interact directly with the ViewModel or the View. Instead, the ViewModel communicates with the Model to retrieve the necessary data, process it, and pass it to the View. This reduces the coupling between the View and the Model, creating a more flexible structure.

Implementing the ViewModel Class

using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Runtime.CompilerServices;
using System.Windows.Input;

public class UserViewModel : INotifyPropertyChanged
{
    private UserService _userService;
    public ObservableCollection<User> Users { get; set; }

    public ICommand AddUserCommand { get; set; }

    public UserViewModel(UserService userService)
    {
        _userService = userService;
        Users = new ObservableCollection<User>();
        AddUserCommand = new RelayCommand(AddUser);
    }

    private async void AddUser()
    {
        await _userService.AddUserAsync("John Doe", "john@example.com", "123-456-7890");
        var users = await _userService.GetUsersAsync();
        Users.Clear();
        foreach (var user in users)
        {
            Users.Add(user);
        }
    }

    public event PropertyChangedEventHandler PropertyChanged;
    protected void OnPropertyChanged([CallerMemberName] string propertyName = null)
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }
}

Conclusion

In the MVVM pattern, the Model is a core element that manages data and business logic. The Model strengthens the overall structure of the application through close interactions with the View and ViewModel. During UWP application development, the implementation of the Model can expand beyond simple data storage to include business logic and data validation. This allows developers to create applications that are maintainable and easy to test.

Moving forward, explore how to build more complex applications through interactions between the Model and ViewModel as well as data binding. By understanding and utilizing the MVVM pattern well, your application will become more flexible and powerful.

UWP (Universal Windows Platform) is a platform for developing powerful applications that can run on various Windows 10 devices. The MVVM (Model-View-ViewModel) pattern is widely used to systematically organize the structure of applications. MVVM is a structural pattern that enhances code maintainability, improves testability, and promotes the separation of UI and business logic.

Overview of MVVM

MVVM consists of three main components:

• Model: Defines data and business logic. Deals with interactions with databases or web APIs.
• View: Defines the user interface (UI). This is the part where users visually see and interact with data.
• ViewModel: Acts as an intermediary between the View and Model. It handles events or commands that occur in the View and notifies the View of data received from the Model.

Advantages of the MVVM Pattern

• Maintainability: The separation of UI and business logic allows each component to be modified and tested independently.
• Testability: The ViewModel can be tested independently, making unit testing easier.
• Data Binding: In UWP, data binding between the View and ViewModel can be easily set up using XAML.

Implementing MVVM

Now, let’s implement the MVVM pattern in a UWP application. In the following example, we will create a simple To-Do list application.

1. Model

First, we define a model class representing a To-Do item.

public class TodoItem
{
    public string Title { get; set; }
    public bool IsCompleted { get; set; }
}

2. ViewModel

The ViewModel handles interactions between the UI and the Model.

using System.Collections.ObjectModel;
using System.ComponentModel;

public class TodoViewModel : INotifyPropertyChanged
{
    private string newTodoTitle;
    private ObservableCollection<TodoItem> todos;

    public event PropertyChangedEventHandler PropertyChanged;

    public TodoViewModel()
    {
        Todos = new ObservableCollection<TodoItem>();
    }

    public ObservableCollection<TodoItem> Todos
    {
        get { return todos; }
        set
        {
            todos = value;
            OnPropertyChanged("Todos");
        }
    }

    public string NewTodoTitle
    {
        get { return newTodoTitle; }
        set
        {
            newTodoTitle = value;
            OnPropertyChanged("NewTodoTitle");
        }
    }

    public void AddTodo()
    {
        if (!string.IsNullOrWhiteSpace(NewTodoTitle))
        {
            Todos.Add(new TodoItem { Title = NewTodoTitle, IsCompleted = false });
            NewTodoTitle = string.Empty; // Clear the input field
        }
    }

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

3. View

Define the View in XAML and set up data binding with the ViewModel.

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

    <Page.DataContext>
        <local:TodoViewModel />
    </Page.DataContext>

    <StackPanel>
        <TextBox
            Text="{Binding NewTodoTitle, Mode=TwoWay}"
            PlaceholderText="Enter a new to-do item" />
        <Button
            Content="Add"
            Command="{Binding AddTodo}" />

        <ListView ItemsSource="{Binding Todos}">
            <ListView.ItemTemplate>
                <DataTemplate>
                    <StackPanel Orientation="Horizontal">
                        <CheckBox
                            IsChecked="{Binding IsCompleted}" />
                        <TextBlock Text="{Binding Title}" />
                    </StackPanel>
                </DataTemplate>
            </ListView.ItemTemplate>
        </ListView>
    </StackPanel>
</Page>

MVVM and Data Binding

In UWP, data binding can be easily implemented using XAML. By directly binding properties of the ViewModel to UI elements in the View, the UI automatically reflects the state of the model. This allows for synchronization between the Model and View without additional code.

Conclusion

Using the MVVM pattern in UWP makes applications more structured and easier to maintain. In this article, we have looked at how to implement the MVVM pattern through a simple To-Do list application. Proper utilization of the MVVM pattern can reduce the complexity of applications, increase code reusability, and allow for more effective testing.

As you develop more complex UWP applications in the future, make sure to effectively utilize the MVVM pattern to write stable and maintainable code!

References

• Microsoft Docs: MVVM Design Pattern
• MVVM Light Toolkit: MVVM Light