Skrivbordsguide (WPF .NET)

Välkommen till skrivbordsguiden för Windows Presentation Foundation (WPF), ett gränssnittsramverk som är lösningsoberoende och använder en vektorbaserad renderingsmotor som är byggd för att dra nytta av modern grafikmaskinvara. WPF innehåller en omfattande uppsättning funktioner för programutveckling som omfattar XAML (Extensible Application Markup Language), kontroller, databindning, layout, 2D- och 3D-grafik, animering, formatmallar, mallar, dokument, media, text och typografi. WPF är en del av .NET, så du kan skapa program som innehåller andra element i .NET-API:et.

Det finns två implementeringar av WPF:

1. .NET version (den här guiden):

   En implementering med öppen källkod av WPF som finns på GitHub, som körs på .NET. XAML-designern kräver minst Visual Studio 2019 version 16.8. Men beroende på din version av .NET kan du behöva använda en nyare version av Visual Studio.

   Även om .NET är en plattformsoberoende teknik körs WPF endast i Windows.

2. .NET Framework 4 version:

   .NET Framework-implementeringen av WPF som stöds av Visual Studio 2019 och Visual Studio 2017.

   .NET Framework 4 är en Windows-version av .NET och anses vara en Windows-operativsystemkomponent. Den här versionen av WPF distribueras med .NET Framework. Mer information om .NET Framework-versionen av WPF finns i Introduktion till WPF för .NET Framework.

Den här översikten är avsedd för nybörjare och omfattar de viktigaste funktionerna och begreppen i WPF. Mer information om hur du skapar en WPF-app finns i Självstudie: Skapa en ny WPF-app.

Varför uppgradera från .NET Framework

När du uppgraderar ditt program från .NET Framework till .NET kan du dra nytta av:

• Bättre prestanda
• Nya .NET-API:er
• De senaste språkförbättringarna
• Förbättrad tillgänglighet och tillförlitlighet
• Uppdaterade verktyg med mera

Information om hur du uppgraderar ditt program finns i Uppgradera en WPF-skrivbordsapp till .NET 7.

Program med WPF

WPF finns som en delmängd av .NET-typer som huvudsakligen finns i System.Windows namnrymd. Om du tidigare har skapat program med .NET med ramverk som ASP.NET och Windows Forms bör du känna till den grundläggande WPF-programmeringsupplevelsen:

• Instansiera klasser
• Ange egenskaper
• Anropsmetoder
• Hantera händelser

WPF innehåller fler programmeringskonstruktioner som förbättrar egenskaper och händelser: beroendeegenskaper och dirigerade händelser.

Markup och bakomliggande kod

Med WPF kan du utveckla ett program genom både markup-språk och code-behind, en upplevelse som ASP.NET-utvecklare bör känna till. Du använder vanligtvis XAML-markering för att implementera utseendet på ett program när du använder hanterade programmeringsspråk (kod bakom) för att implementera dess beteende. Den här uppdelningen av utseende och beteende har följande fördelar:

• Kostnaderna för utveckling och underhåll minskas eftersom utseendespecifik markering inte är nära kopplad till beteendespecifik kod.

• Utveckling är mer effektivt eftersom designers kan implementera ett programs utseende samtidigt med utvecklare som implementerar programmets beteende.

• Globalisering och lokalisering för WPF-program förenklas.

Markup

XAML är ett XML-baserat påläggsspråk som implementerar ett programs utseende deklarativt. Du använder den vanligtvis för att definiera fönster, dialogrutor, sidor och användarkontroller och för att fylla dem med kontroller, former och grafik.

I följande exempel används XAML för att implementera utseendet på ett fönster som innehåller en enda knapp:

<Window
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    Title="Window with button"
    Width="250" Height="100">

  <!-- Add button to window -->
  <Button Name="button">Click Me!</Button>

</Window>

Mer specifikt definierar denna XAML ett fönster och en knapp med hjälp av elementen Window och Button. Varje element konfigureras med attribut, till exempel Window-elementets Title attribut för att ange fönstrets rubrikfälttext. Vid körtid konverterar WPF de element och attribut som definieras i markup till instanser av WPF-klasser. Till exempel konverteras elementet Window till en instans av klassen Window vars Title egenskap är värdet för attributet Title.

Följande bild visar användargränssnittet (UI) som definieras av XAML i föregående exempel:

Eftersom XAML är XML-baserat monteras användargränssnittet som du skapar med det i en hierarki med kapslade element som kallas elementträd. Elementträdet ger ett logiskt och intuitivt sätt att skapa och hantera UIs.

Kod bakom

Det huvudsakliga beteendet för ett program är att implementera de funktioner som svarar på användarinteraktioner. Till exempel genom att klicka på en meny eller knapp och anropa affärslogik och dataåtkomstlogik som svar. I WPF implementeras det här beteendet i kod som är associerad med markering. Den här typen av kod kallas code-behind. I följande exempel visas den uppdaterade markeringen från föregående exempel och koden bakom:

<Window
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.AWindow"
    Title="Window with button"
    Width="250" Height="100">

  <!-- Add button to window -->
  <Button Name="button" Click="button_Click">Click Me!</Button>

</Window>

Den uppdaterade markeringen definierar xmlns:x namnområde och mappar det till schemat som lägger till stöd för kod bakom typerna. Attributet x:Class används för att associera en kodbakomklass till den här specifika XAML-koden. Med tanke på att det här attributet deklareras för elementet <Window> måste klassen code-behind ärva från klassen Window.

using System.Windows;

namespace SDKSample
{
    public partial class AWindow : Window
    {
        public AWindow()
        {
            // InitializeComponent call is required to merge the UI
            // that is defined in markup with this class, including  
            // setting properties and registering event handlers
            InitializeComponent();
        }

        void button_Click(object sender, RoutedEventArgs e)
        {
            // Show message box when button is clicked.
            MessageBox.Show("Hello, Windows Presentation Foundation!");
        }
    }
}

Namespace SDKSample

    Partial Public Class AWindow
        Inherits System.Windows.Window

        Public Sub New()

            ' InitializeComponent call is required to merge the UI
            ' that is defined in markup with this class, including  
            ' setting properties and registering event handlers
            InitializeComponent()

        End Sub

        Private Sub button_Click(ByVal sender As Object, ByVal e As RoutedEventArgs)

            ' Show message box when button is clicked.
            MessageBox.Show("Hello, Windows Presentation Foundation!")

        End Sub

    End Class

End Namespace

InitializeComponent anropas från code-behind-klassens konstruktor för att sammanfoga användargränssnittet som definieras i markup-språket med code-behind-klassen. (InitializeComponent genereras åt dig när ditt program skapas, vilket är anledningen till att du inte behöver implementera det manuellt.) Kombinationen av x:Class och InitializeComponent se till att implementeringen initieras korrekt när den skapas.

Observera att i märkningen definierade elementet <Button> ett värde av button_Click för attributet Click. När markup och bakomliggande kod har initierats och fungerar tillsammans, kopplas Click-händelsen för knappen automatiskt samman med metoden button_Click. När knappen klickas anropas händelsehanteraren och en meddelanderuta visas genom att anropa metoden System.Windows.MessageBox.Show.

Följande bild visar resultatet när knappen klickas:

Indata och kommandon

Kontroller identifierar och svarar oftast på användarindata. WPF-indatasystemet använder både direkta och dirigerade händelser för att stödja textinmatning, fokushantering och muspositionering.

Program har ofta komplexa indatakrav. WPF tillhandahåller ett kommandosystem som separerar användarindataåtgärder från koden som svarar på dessa åtgärder. Med kommandosystemet kan flera källor anropa samma kommandologik. Du kan till exempel utföra vanliga redigeringsåtgärder som används av olika program: Kopiera, Klipp utoch Klistra in. Dessa åtgärder kan anropas med hjälp av olika användaråtgärder om de implementeras med hjälp av kommandon.

Kontroller

De användarupplevelser som levereras av programmodellen är konstruerade kontroller. I WPF är kontroll ett paraplybegrepp som gäller för en kategori av WPF-klasser som har följande egenskaper:

• Finns antingen i ett fönster eller på en sida.
• Ha ett användargränssnitt.
• Implementera vissa beteenden.

Mer information finns i Controls.

WPF-kontroller efter funktion

De inbyggda WPF-kontrollerna visas här:

• knappar: Button och RepeatButton.

• Data Display: DataGrid, ListViewoch TreeView.

• datumvisning och val: Calendar och DatePicker.

• dialogrutor: OpenFileDialog, PrintDialogoch SaveFileDialog.

• Digital Ink: InkCanvas och InkPresenter.

• Dokument: DocumentViewer, FlowDocumentPageViewer, FlowDocumentReader, FlowDocumentScrollVieweroch StickyNoteControl.

• Indata: TextBox, RichTextBoxoch PasswordBox.

• Layout: Border, BulletDecorator, Canvas, DockPanel, Expander, Grid, GridView, GridSplitter, GroupBox, Panel, ResizeGrip, Separator, ScrollBar, ScrollViewer, StackPanel, Thumb, Viewbox, VirtualizingStackPanel, Windowoch WrapPanel.

• Media: Image, MediaElementoch SoundPlayerAction.

• Menyer: ContextMenu, Menuoch ToolBar.

• Navigering: Frame, Hyperlink, Page, NavigationWindowoch TabControl.

• Val: CheckBox, ComboBox, ListBox, RadioButtonoch Slider.

• användarinformation: AccessText, Label, Popup, ProgressBar, StatusBar, TextBlockoch ToolTip.

Utformning

När du skapar ett användargränssnitt ordnar du kontrollerna efter plats och storlek för att skapa en layout. Ett viktigt krav för en layout är att anpassa sig till ändringar i fönsterstorlek och visningsinställningar. I stället för att tvinga dig att skriva koden för att anpassa en layout under dessa omständigheter tillhandahåller WPF ett förstklassigt, utökningsbart layoutsystem åt dig.

Hörnstenen i layoutsystemet är relativ positionering, vilket ökar möjligheten att anpassa sig till föränderliga fönster- och visningsvillkor. Layoutsystemet hanterar också förhandlingen mellan kontroller för att fastställa layouten. Förhandlingen är en tvåstegsprocess: först talar en kontroll om för sin överordnade vilken plats och storlek den behöver. För det andra talar föräldern om vilken plats kontrollen kan använda.

Layoutsystemet exponeras för underordnade kontroller via grundläggande WPF-klasser. För vanliga layouter som rutnät, stapling och dockning innehåller WPF flera layoutkontroller:

• Canvas: Underordnade kontroller har en egen layout.

• DockPanel: Underordnade kontroller anpassas mot panelens kanter.

• Grid: Barnkontroller placeras i rader och kolumner.

• StackPanel: Barnkontroller staplas antingen lodrätt eller vågrätt.

• VirtualizingStackPanel: Barnkontroller virtualiseras och ordnas på en enda rad som är antingen vågrätt eller lodrätt orienterade.

• WrapPanel: Underordnade kontroller placeras i vänster-till-höger-ordning och omsluts till nästa rad när det inte finns tillräckligt med utrymme på den aktuella raden.

I följande exempel används en DockPanel för att lägga ut flera TextBox kontroller:

<Window
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.LayoutWindow"
    Title="Layout with the DockPanel" Height="143" Width="319">
  
  <!--DockPanel to layout four text boxes--> 
  <DockPanel>
    <TextBox DockPanel.Dock="Top">Dock = "Top"</TextBox>
    <TextBox DockPanel.Dock="Bottom">Dock = "Bottom"</TextBox>
    <TextBox DockPanel.Dock="Left">Dock = "Left"</TextBox>
    <TextBox Background="White">This TextBox "fills" the remaining space.</TextBox>
  </DockPanel>

</Window>

Med DockPanel kan den underordnade TextBox kontroller berätta hur de ska ordnas. För att göra detta implementerar DockPanel en Dock bifogad egenskap som exponeras för de underordnade kontrollerna så att var och en av dem kan ange en dockstil.

Följande bild visar resultatet av XAML-markering i föregående exempel:

Databindning

De flesta program skapas för att ge användarna möjlighet att visa och redigera data. För WPF-program tillhandahålls arbetet med att lagra och komma åt data redan av många olika .NET-dataåtkomstbibliotek som SQL och Entity Framework Core. När data har fått åtkomst och lästs in i en applikations hanterade objekt, börjar det hårda arbetet för WPF-applikationer. I grund och botten handlar det om två saker:

1. Kopiera data från de hanterade objekten till kontroller, där data kan visas och redigeras.

2. Se till att ändringar som görs i data med hjälp av kontroller kopieras tillbaka till de hanterade objekten.

För att förenkla programutvecklingen tillhandahåller WPF en kraftfull databindningsmotor för att automatiskt hantera dessa steg. Kärnenheten i databindningsmotorn är klassen Binding, vars jobb är att binda en kontroll (bindningsmålet) till ett dataobjekt (bindningskällan). Den här relationen illustreras av följande bild:

WPF stöder deklarering av bindningar i XAML-markering direkt. Följande XAML-kod binder till exempel egenskapen Text för TextBox till egenskapen Name för ett objekt med XAML-syntaxen "{Binding ... }". Detta förutsätter att det finns ett dataobjekt inställt på egenskapen DataContext för Window med en Name-egenskap.

 <Window
     xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
     x:Class="SDKSample.DataBindingWindow">

   <!-- Bind the TextBox to the data source (TextBox.Text to Person.Name) -->
   <TextBox Name="personNameTextBox" Text="{Binding Path=Name}" />

 </Window>

WPF-databindningsmotorn ger mer än bara bindning, den tillhandahåller validering, sortering, filtrering och gruppering. Dessutom stöder databindning användning av datamallar för att skapa ett anpassat användargränssnitt för bundna data.

Mer information finns i Översikt över databindning.

Animering av grafik &

WPF ger en omfattande och flexibel uppsättning grafikfunktioner som har följande fördelar:

• Upplösningsoberoende och enhetsoberoende grafik. Den grundläggande måttenheten i WPF-grafiksystemet är den enhetsoberoende pixeln, som är 1/96 tum och utgör grunden för upplösningsoberoende och enhetsoberoende rendering. Varje enhetsoberoende pixel skalas automatiskt så att den matchar dpi-inställningen (dots-per-inch) för det system som den renderar på.

• Förbättrad precision. WPF-koordinatsystemet mäts med flyttal med dubbel precision i stället för enkel precision. Transformeringar och opacitetsvärden uttrycks också som dubbel precision. WPF stöder också ett brett färgomfång (scRGB) och ger integrerat stöd för att hantera indata från olika färgutrymmen.

• Stöd för avancerad grafik och animering. WPF förenklar grafikprogrammering genom att hantera animeringsscener åt dig. Det finns ingen anledning att oroa sig för scenbearbetning, återgivningsloopar och bilinearinterpolation. Dessutom ger WPF stöd för träfftestning och fullt stöd för alfasammansättning.

• Maskinvaruacceleration. WPF-grafiksystemet drar nytta av grafikmaskinvara för att minimera CPU-användningen.

2D-grafik

WPF tillhandahåller ett bibliotek med vanliga vektorritade 2D-former, till exempel rektanglar och ellipser. Formerna är inte bara för visning. former implementerar många av de funktioner som du förväntar dig av kontroller, inklusive tangentbords- och musinmatning.

De 2D-former som tillhandahålls av WPF täcker standarduppsättningen med grundläggande former. Du kan dock behöva skapa anpassade former som hjälper dig att utforma ett anpassat användargränssnitt. WPF tillhandahåller geometrier för att skapa en anpassad form som kan ritas direkt, användas som pensel eller användas för att klippa ut andra former och kontroller.

För mer information, se översikten över geometri.

En del av WPF:s 2D-funktioner inkluderar visuella effekter, såsom toningar, bitmappar, ritningar, att måla med hjälp av videor, rotation, skalning och skevning. Dessa effekter uppnås alla med penslar. Följande bild visar några exempel:

Mer information finns i översikten över WPF-penslar.

3D-återgivning

WPF innehåller även 3D-återgivningsfunktioner som integreras med 2D-grafik för att möjliggöra skapandet av mer spännande och intressanta användargränssnitt. Följande bild visar till exempel 2D-bilder som återges på 3D-former:

Mer information finns i 3D-grafiköversikt.

Animation

Med wpf-animeringsstöd kan du få kontroller att växa, skaka, snurra och tona, för att skapa intressanta sidövergångar med mera. Du kan animera de flesta WPF-klasser, även anpassade klasser. Följande bild visar en enkel animering i praktiken:

För mer information, se översikt över animering.

Text och typografi

WPF erbjuder följande funktioner för att tillhandahålla textrendering av hög kvalitet:

• Stöd för OpenType-teckensnitt.
• ClearType-förbättringar.
• Höga prestanda som drar nytta av maskinvaruacceleration.
• Integrering av text med media, grafik och animering.
• Stöd för internationella teckensnitt och återställningsmekanismer.

Som en demonstration av textintegrering med grafik visar följande bild tillämpningen av textdekorationer:

För mer information, se Typografi i Windows Presentation Foundation.

Anpassa WPF-appar

Fram tills nu har du sett de viktigaste WPF-byggstenarna för att utveckla program:

• Du använder programmodellen för att vara värd för och leverera programinnehåll, som huvudsakligen består av kontroller.
• För att förenkla ordningen för kontroller i ett användargränssnitt använder du WPF-layoutsystemet.
• Du använder databindning för att minska arbetet med att integrera användargränssnittet med data.
• För att förbättra programmets visuella utseende använder du det omfattande utbudet av grafik, animering och mediestöd från WPF.

Men ofta räcker det inte med grunderna för att skapa och hantera en verkligt distinkt och visuellt fantastisk användarupplevelse. WPF-standardkontrollerna kanske inte kan integreras med programmets önskade utseende. Data kanske inte visas på det mest effektiva sättet. Programmets övergripande användarupplevelse kanske inte passar för standardutseendet för Windows-teman.

Därför tillhandahåller WPF olika mekanismer för att skapa unika användarupplevelser.

Innehållsmodell

Huvudsyftet med de flesta WPF-kontroller är att visa innehåll. I WPF kallas typen och antalet objekt som kan utgöra innehållet i en kontroll för kontrollens innehållsmodell. Vissa kontroller kan innehålla ett enda objekt och en typ av innehåll. Innehållet i en TextBox är till exempel ett strängvärde som har tilldelats egenskapen Text.

Andra kontroller kan dock innehålla flera objekt av olika typer av innehåll. innehållet i en Button, som anges av egenskapen Content, kan innehålla olika objekt, inklusive layoutkontroller, text, bilder och former.

Mer information om vilka typer av innehåll som stöds av olika kontroller finns i WPF-innehållsmodell.

Utlösare

Även om huvudsyftet med XAML-markering är att implementera ett programs utseende, kan du också använda XAML för att implementera vissa aspekter av ett programs beteende. Ett exempel är användningen av utlösare för att ändra ett programs utseende baserat på användarinteraktioner. Mer information finns i Formatmallar och mallar.

Mallar

Standardanvändargränssnitten för WPF-kontroller konstrueras vanligtvis från andra kontroller och former. Till exempel består en Button av både ButtonChrome- och ContentPresenter kontroller. ButtonChrome ger standardknappens utseende, medan ContentPresenter visar knappens innehåll, enligt vad som anges av egenskapen Content.

Ibland kan standardutseendet för en kontroll vara i konflikt med programmets övergripande utseende. I det här fallet kan du använda en ControlTemplate för att ändra utseendet på kontrollens användargränssnitt utan att ändra dess innehåll och beteende.

Till exempel genererar en Button händelsen Click när man klickar på den. Genom att ändra mallen för en knapp för att visa en Ellipse form har kontrollens visuella objekt ändrats, men inte funktionen. Du kan fortfarande klicka på kontrollens visuella aspekt och händelsen Click genereras som förväntat.

Datamallar

Med en kontrollmall kan du ange utseendet på en kontroll, men med en datamall kan du ange utseendet på en kontrolls innehåll. Datamallar används ofta för att förbättra hur bundna data visas. Följande bild visar standardutseendet för en ListBox som är bunden till en samling Task objekt, där varje uppgift har ett namn, en beskrivning och en prioritet:

Standardutseendet är vad du kan förvänta dig av en ListBox. Standardutseendet för varje aktivitet innehåller dock bara aktivitetsnamnet. Om du vill visa uppgiftsnamnet, beskrivningen och prioriteten måste standardutseendet för ListBox kontrollens bundna listobjekt ändras med hjälp av en DataTemplate. Här är ett exempel på hur du använder en datamall som skapades för Task-objektet.

ListBox behåller sitt beteende och övergripande utseende och endast utseendet på innehållet som visas i listrutan har ändrats.

För mer information, se översikt av datamallning.

Stilar

Format gör det möjligt för utvecklare och designers att standardisera på ett visst utseende för sin produkt. WPF ger en stark stilmodell, vars grund är det Style elementet. Formatmallar kan använda egenskapsvärden för typer. De kan tillämpas automatiskt på allting baserat på typen eller på enskilda objekt vid hänvisning. I följande exempel skapas ett format som anger bakgrundsfärgen för varje Button i fönstret till Orange:

<Window
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.StyleWindow"
    Title="Styles">

    <Window.Resources>
        <!-- Style that will be applied to all buttons for this window -->
        <Style TargetType="{x:Type Button}">
            <Setter Property="Background" Value="Orange" />
            <Setter Property="BorderBrush" Value="Crimson" />
            <Setter Property="FontSize" Value="20" />
            <Setter Property="FontWeight" Value="Bold" />
            <Setter Property="Margin" Value="5" />
        </Style>
    </Window.Resources>
    <StackPanel>

        <!-- This button will have the style applied to it -->
        <Button>Click Me!</Button>

        <!-- This label will not have the style applied to it -->
        <Label>Don't Click Me!</Label>

        <!-- This button will have the style applied to it -->
        <Button>Click Me!</Button>
        
    </StackPanel>
</Window>

Eftersom det här formatet är avsett för alla Button kontroller tillämpas formatet automatiskt på alla knappar i fönstret, enligt följande bild:

Mer information finns i Formatmallar och mallar.

Resurser

Kontroller i ett program bör ha samma utseende, vilket kan innehålla allt från teckensnitt och bakgrundsfärger för att styra mallar, datamallar och formatmallar. Du kan använda WPF:s stöd för användargränssnittsresurser för att kapsla in dessa resurser på en enda plats för återanvändning.

I följande exempel definieras en vanlig bakgrundsfärg som delas av en Button och en Label:

<Window
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.ResourcesWindow"
    Title="Resources Window">

  <!-- Define window-scoped background color resource -->
  <Window.Resources>
    <SolidColorBrush x:Key="defaultBackground" Color="Red" />
  </Window.Resources>

  <!-- Button background is defined by window-scoped resource -->
  <Button Background="{StaticResource defaultBackground}">One Button</Button>

  <!-- Label background is defined by window-scoped resource -->
  <Label Background="{StaticResource defaultBackground}">One Label</Label>
</Window>

Mer information finns i Definiera och referera till en WPF-resurs.

Anpassade kontroller

Även om WPF tillhandahåller en mängd anpassningsstöd kan du stöta på situationer där befintliga WPF-kontroller inte uppfyller behoven hos ditt program eller dess användare. Detta kan inträffa när:

• Det användargränssnitt som du behöver kan inte skapas genom att anpassa utseendet på befintliga WPF-implementeringar.
• Det beteende som du behöver stöds inte (eller stöds inte enkelt) av befintliga WPF-implementeringar.

I det här läget kan du dock dra nytta av en av tre WPF-modeller för att skapa en ny kontroll. Varje modell riktar sig mot ett specifikt scenario och kräver att din anpassade kontroll härleds från en viss WPF-basklass. De tre modellerna visas här:

• användarkontrollmodell
  En anpassad kontroll härleds från UserControl och består av en eller flera andra kontroller.

• Kontrollmodell En anpassad kontroll härleds från Control och används för att skapa implementeringar som skiljer deras beteende från deras utseende med hjälp av mallar, ungefär som de flesta WPF-kontroller. Genom att härleda från Control kan du få större frihet att skapa ett anpassat användargränssnitt än användarkontroller, men det kan kräva mer arbete.

• Framework-elementmodell.
  En anpassad kontroll härleds från FrameworkElement när dess utseende definieras av anpassad renderingslogik (inte mallar).

Mer information om anpassade kontroller finns i Kontrollredigeringsöversikt.

Se även

• Självstudie: Skapa en ny WPF-app
• Migrera en WPF-app till .NET
• Översikt över WPF-windows
• Översikt över databindning
• XAML-översikt