Using system windows controls

Как использовать OAuth2 со Spring Security в Java

Javaican 14.05.2025

Протокол OAuth2 часто путают с механизмами аутентификации, хотя по сути это протокол авторизации. Представьте, что вместо передачи ключей от всего дома вашему другу, который пришёл полить цветы, вы. . .

Анализ текста на Python с NLTK и Spacy

AI_Generated 14.05.2025

NLTK, старожил в мире обработки естественного языка на Python, содержит богатейшую коллекцию алгоритмов и готовых моделей. Эта библиотека отлично подходит для образовательных целей и. . .

Реализация DI в PHP

Jason-Webb 13.05.2025

Когда я начинал писать свой первый крупный PHP-проект, моя архитектура напоминала запутаный клубок спагетти. Классы создавали другие классы внутри себя, зависимости жостко прописывались в коде, а о. . .

Обработка изображений в реальном времени на C# с OpenCV

stackOverflow 13.05.2025

Объединение библиотеки компьютерного зрения OpenCV с современным языком программирования C# создаёт симбиоз, который открывает доступ к впечатляющему набору возможностей. Ключевое преимущество этого. . .

POCO, ACE, Loki и другие продвинутые C++ библиотеки

NullReferenced 13.05.2025

В C++ разработки существует такое обилие библиотек, что порой кажется, будто ты заблудился в дремучем лесу. И среди этого многообразия POCO (Portable Components) – как маяк для тех, кто ищет. . .

Паттерны проектирования GoF на C#

UnmanagedCoder 13.05.2025

Вы наверняка сталкивались с ситуациями, когда код разрастается до неприличных размеров, а его поддержка становится настоящим испытанием. Именно в такие моменты на помощь приходят паттерны Gang of. . .

Создаем CLI приложение на Python с Prompt Toolkit

py-thonny 13.05.2025

Современные командные интерфейсы давно перестали быть черно-белыми текстовыми программами, которые многие помнят по старым операционным системам. CLI сегодня – это мощные, интуитивные и даже. . .

Конвейеры ETL с Apache Airflow и Python

AI_Generated 13.05.2025

ETL-конвейеры – это набор процессов, отвечающих за извлечение данных из различных источников (Extract), их преобразование в нужный формат (Transform) и загрузку в целевое хранилище (Load). . . .

Выполнение асинхронных задач в Python с asyncio

py-thonny 12.05.2025

Современный мир программирования похож на оживлённый мегаполис – тысячи процессов одновременно требуют внимания, ресурсов и времени. В этих джунглях операций возникают ситуации, когда программа. . .

Работа с gRPC сервисами на C#

UnmanagedCoder 12.05.2025

gRPC (Google Remote Procedure Call) — открытый высокопроизводительный RPC-фреймворк, изначально разработанный компанией Google. Он отличается от традиционых REST-сервисов как минимум тем, что. . .

Updated on September 24, 2015

    Kisan Patel

This tutorial will explain you learn how to add controls to a WPF application through the code-behind file.

Lets create new WPF application and name it “WPFAddControlDemo” and replace Grid element with the below code in the MainWindow.xaml file.

<Window x:Class="WPFAddControlDemo.MainWindow"
   xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
   xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
   Title="MainWindow" Height="350" Width="525">
   <Grid Name="myGrid">
   
   </Grid>
</Window>

In above code, you can see we have apply the name of the Grid control to myGrid. The controls will be added to the Grid control from your code-behind file. Therefore, open the MainWindow.xaml.cs file and add code shown in below code.

using System.Windows;
using System.Windows.Controls;

namespace WPFAddControlDemo
{
    /// 
    /// Interaction logic for MainWindow.xaml
    /// 
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();

            Label myLabel = new Label();
            myLabel.Content = "Enter your Name: ";
            myGrid.Children.Add(myLabel);
            TextBox myTextBox = new TextBox();
            myTextBox.Margin = new Thickness(0, 10, 20, 0);
            myTextBox.Height = 30;
            myTextBox.Width = 150;
            myTextBox.HorizontalAlignment = HorizontalAlignment.Right;
            myTextBox.VerticalAlignment = VerticalAlignment.Top;
            myGrid.Children.Add(myTextBox);
            Button myButton = new Button();
            myButton.Content = "Submit";
            myButton.Height = 50;
            myButton.Width = 75;
            myGrid.Children.Add(myButton);
        }
    }
}

After adding the controls and setting their properties, as shown in above code. Now, run the application by pressing the F5 key. The output will be:

Download Complete Source Code

WPF

Файлы отделенного кода

Последнее обновление: 15.01.2016

При создании нового проекта WPF в дополнение к создаваемому файлу MainWindow.xaml создается также файл отделенного кода MainWindow.xaml.cs,
где, как предполагается, должна находится логика приложения связанная с разметкой из MainWindow.xaml. Файлы XAML позволяют нам определить
интерфейс окна, но для создания логики приложения, например, для определения обработчиков событий элементов управления,
нам все равно придется воспользоваться кодом C#.

По умолчанию в разметке окна используется атрибут x:Class:

<Window x:Class="XamlApp.MainWindow" 
.......

Атрибут x:Class указывает на класс, который будет представлять данное окно и в который будет компилироваться код в XAML
при компиляции. То есть во время компиляции будет генерироваться класс XamlApp.MainWindow,
унаследованный от класса System.Windows.Window.

Кроме того в файле отделенного кода MainWindow.xaml.cs, который Visual Studio создает автоматически, мы также можем найти класс с тем же именем —
в данном случае класс XamlApp.MainWindow. По умолчанию он имеет некоторый код:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;

namespace XamlApp
{
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();
        }
    }
}

По сути пустой класс, но этот класс уже выполняет некоторую работу. Во время компиляции этот класс объединяется с классом, сгенерированном из кода XAML.
Чтобы такое слияние классов во время компиляции произошло, класс XamlApp.MainWindow определяется как частичный с модификатором partial.
А через метод InitializeComponent() класс MainWindow вызывает скомпилированный ранее код XAML, разбирает его и по нему строит графический интерфейс окна.

Взаимодействие кода C# и XAML

В приложении часто требуется обратиться к какому-нибудь элементу управления. Для этого надо установить у элемента в XAML свойство Name.

Еще одной точкой взаимодействия между xaml и C# являются события. С помощью атрибутов в XAML мы можем задать события, которые будут связанны с
обработчиками в коде C#.

Итак, создадим новый проект WPF, который назовем XamlApp. В разметке главного окна определим два элемента: кнопку и текстовое поле.

<Window x:Class="XamlApp.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:local="clr-namespace:XamlApp"
        mc:Ignorable="d"
        Title="MainWindow" Height="350" Width="525">
    <Grid x:Name="grid1">
        <TextBox x:Name="textBox1" Width="150" Height="30" VerticalAlignment="Top" Margin="20" />
        <Button x:Name="button1"  Width="100" Height="30" Content="Кнопка" Click="Button_Click" />
    </Grid>
</Window>

И изменим файл отделенного кода, добавив в него обработчик нажатия кнопки:

using System.Windows;

namespace XamlApp
{
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();
        }

        private void Button_Click(object sender, RoutedEventArgs e)
        {
            string text = textBox1.Text;
            if (text != "")
            {
                MessageBox.Show(text);
            }
        }
    }
}

Определив имена элементов в XAML, затем мы можем к ним обращаться в коде c#: string text = textBox1.Text.

При определении имен в XAML надо учитывать, что оба пространства имен «http://schemas.microsoft.com/winfx/2006/xaml/presentation» и
«http://schemas.microsoft.com/winfx/2006/xaml» определяют атрибут Name, который устанавливает имя элемента. Во втором случае
атрибут используется с префиксом x: x:Name. Какое именно пространство имен использовать в данном случае, не столь важно,
а следующие определения имени x:Name="button1" и Name="button1" фактически будут равноценны.

В обработчике нажатия кнопки просто выводится сообщение , введенное в текстовое поле. После определения обработчика мы его можем связать с
событием нажатия кнопки в xaml через атрибут Click: Click="Button_Click". В результате после нажатия на кнопку
мы увидим в окне введенное в текстовое поле сообщение.

Картинка с сайта: metanit.com

Создание элементов в коде C#

Еще одну форму взаимодействия C# и XAML представляет создание визуальных элементов в коде C#. Например, изменим код xaml следующим образом:

<Window x:Class="XamlApp.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:local="clr-namespace:XamlApp"
        mc:Ignorable="d"
        Title="MainWindow" Height="350" Width="525">
    <Grid x:Name="layoutGrid">

    </Grid>
</Window>

Здесь для элемента Grid установлено свойство x:Name, через которое мы можем к нему обращаться в коде. И также изменим код C#:

using System.Windows;
using System.Windows.Controls;

namespace XamlApp
{
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();

            Button myButton = new Button();
            myButton.Width = 100;
            myButton.Height = 30;
            myButton.Content = "Кнопка";
            layoutGrid.Children.Add(myButton);
        }
    }
}

В конструкторе странцы создается элемент Button и добавляется в Grid. И если мы запустим приложение, то увидим добавленную кнопку:

Картинка с сайта: metanit.com

XAML — это декларативный язык программирования общего назначения, предназначенный, в настоящее время, в основном для конструирования и инициализации объектов визуального интерфейса приложения.  Одна из целей использования XAML при разработке приложений — отделить логику приложения от его интерфейса.  

Каждый элемент в документе XAML отображается на экземпляр класса .NET

При этом, имя элемента в разметке XAML в точности соответствует имени класса. Например, элемент <Button> из предыдущей статьи сообщает WPF, что должен быть создан объект Button.

<Button Content="Нажми меня" Width="200" Height="60" Click="Button_Click"/>

Код C# с помощью которого мы могли бы получить точно такой же результат, выглядит следующим образом:

Button button = new Button();
button.Content = "Нажми меня";
button.Width = 200;
button.Height = 60;
button.Click += new RoutedEventHandler(Button_Click);

Различие в том, что при написания кода XAML результат будет виден сразу же в визуальном редакторе. При создании же кнопки в коде C# нам необходимо будет вначале скомпилировать и запустить приложение, чтобы увидеть результат.

Свойства каждого класса можно устанавливать через атрибуты

Собственно, это правило наглядно продемонстрировано в примере выше для кнопки. В XAML атрибуты Content, Width и Height являются, по сути, свойствами класса Button.

Как и любой XML-документ, код XAML допускает вложение одного элемента внутрь другого

Вложение обычно является способом выразить включение (containment). Другими словами, если вы видите элемент Button внутри элемента Grid, то пользовательский интерфейс  включает Grid, содержащий внутри себя Button. Например,

<Grid Name="grid">
    <Button Content="Нажми меня" Width="200" Height="60" Click="Button_Click"/>
</Grid>

Здесь стоит обратить внимание на элемент Grid, а точнее, на его атрибут Name. Следуя предыдущему правилу, мы установили для класса Grid значение свойства Name как «grid». Теперь мы можем продемонстрировать то, как будет выглядеть аналогичный код, написанный на C#.

Button button = new Button();
 button.Content = "Нажми меня";
 button.Width = 200;
 button.Height = 60;
 button.Click += new RoutedEventHandler( Button_Click);
 _ = grid.Children.Add(button);

В последней строке мы добавляем к списку дочерних элементов grid созданную кнопку.

Пространства имен XAML

Когда мы пишем код на C#, то для того, чтобы получить доступ к каким-либо классам, мы подключаем соответствующие пространства имен с помощью директивы using, например

using System.Windows.Controls;

В XAML, чтобы задействовать какое-либо элементы, мы также подключаем пространства имен, но уже используя правила работы как с XML. Например, посмотрим на содержимое файла MainWindow.xaml

<Window x:Class="HelloWpf.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:local="clr-namespace:HelloWpf"
        mc:Ignorable="d"
        Title="MainWindow" Height="450" Width="800">
    <Grid>
        
    </Grid>
</Window>

Вторая и третья строчки представляют собой пространства имен, подключаемые в проект по умолчанию. А атрибут xmlns представляет специальный атрибут для определения пространства имен в XML.

Пространство имен http://schemas.microsoft.com/winfx/2006/xaml/presentation

содержит описание и определение большинства элементов управления. Так как это пространство имен является пространством имен по умолчанию, то оно объявляется без каких-либо префиксов. При этом, следует отметить, что сопоставление пространства имен http://schemas.microsoft.com/winfx/2006/xaml/presentation в XAML и пространства имен в C# производится не так, как свойства класса C# и атрибут элемента в XAML. Так, подключение в XAML пространства имен http://schemas.microsoft.com/winfx/2006/xaml/presentation приведет к тому, что в проект будут подключены следующие пространства имен C#:

System.Windows
System.Windows.Automation
System.Windows.Controls
System.Windows.Controls.Primitives
System.Windows.Data
System.Windows.Documents
System.Windows.Forms.Integration
System.Windows.Ink
System.Windows.Input
System.Windows.Media
System.Windows.Media.Animation
System.Windows.Media.Effects
System.Windows.Media.Imaging
System.Windows.Media.Media3D
System.Windows.Media.TextFormatting
System.Windows.Navigation
System.Windows.Shapes
System.Windows.Shell

Пространство имен http://schemas.microsoft.com/winfx/2006/xaml

Определяет некоторые свойства XAML, например свойство Name или Key. Используемый префикс x в определении xmlns:x означает, что те свойства элементов, которые заключены в этом пространстве имен, будут использоваться с префиксом x — x:Name или x:Key. Это же пространство имен используется в первой строчке в файле MainWindow.xaml

x:Class="HelloWpf.MainWindow

Пространство имен http://schemas.microsoft.com/expression/blend/2008

Предоставляет поддержку атрибутов в режиме дизайнера. Это пространство имен, в основном, предназначено для другого инструмента по созданию дизайна на XAML — Microsoft Expression Blend.

Пространство имен http://schemas.openxmlformats.org/markup-compatibility/2006

обеспечивает режим совместимости разметок XAML. В определении объекта Window можно найти применение этого пространства имен, а именно:

mc:Ignorable="d"

Это выражение позволяет игнорировать парсерам XAML во время выполнения приложения дизайнерские атрибуты из пространства имен с префиксом d, то есть из пространства имен http://schemas.microsoft.com/expression/blend/2008.

xmlns:local=»clr-namespace:HelloWpf» — пространство имен текущего проекта

Так как в предыдущей части мы создавали проект с названием HelloWpf, то Visual Studio по умолчанию создало для такого проекта пространство имен HelloWpf. Через префикс local мы можем получить в XAML различные объекты, которые были определены в проекте.

Итого

С помощью языка разметки XAML можно достаточно выразительно описать интерфейс приложения. При этом, для создания каких-либо классов и объектов, например, кнопки, метки и так далее в XAML используются элементы, наподобие элементов XML и каждому элементу XAML соответствует аналогичный класс C#. Для определения свойств в XAML используются атрибуты и, при этом, каждый атрибут соответствует аналогичному свойству класса. Что касается пространств имен, то здесь в XAML используется правило «многие к одному», то есть одному пространству имен XAML могут соответствовать несколько пространств имен .NET.