.NET Blog   ·   .NET Casts   ·   .NET GUI Foren   ·   .NET BlogBook   ·   WPF Blogger   ·   visual studio one   ·   ASP.NET professional

  • ACHTUNG - NEUES BLOG

    Ab sofort steht unter http://devtyr.norberteder.com mein neues Blog zur Verfügung. Dieses Blog wird nicht weiter betreut, bleibt aber erhalten. Neue Eintr%auml;ge erfolgen nur mehr im neuen Blog. Kommentare werden ebenfalls nicht mehr behandelt. Wer weiterhin meinen Einträgen und Aktivitäten folgen möchte, möge bitte RSS-Feeds, Verlinkungen etc. an die neue Location anpassen.
Download .NET Essentials Installer
Trickkiste

WPF Blogger auch in Spanisch

31.01.09 - .NET, WPF, ASP.NET, Silverlight, Internet, Community
Beitrag von Norbert Eder
  Bisher wurden auf WPF-Blogger.com drei Sprachen angeboten. Verfügbare waren bis jetzt deutsch, englisch und französisch. Heute kam eine neue Sprache hinzu. Ab sofort werden auch spanisch-sprachige Blogs aggregiert. Dies passierte auf vielfachen Wunsch, eingebracht über mein englischsprachiges Blog.

Wer übrigens empfehlenswerte Blogs zum Thema WPF und Silverlight kennt (egal welcher Sprache), der kann sich gerne mit mir in Verbindung setzen, oder den Vorschlag hier eintragen.


  Kommentar hinzufügen   |  0 Trackbacks   |  Permalink  |  Trackback-URL


Styling und Animation einer WPF ListBox

30.01.09 - .NET, WPF
Beitrag von Norbert Eder
 Eine sehr häufig gestellte Frage ist die, wie eine WPF ListBox gestyled und animiert wird. Anhand des nachfolgenden Beispiels wird gezeigt, in welchen Templates was gemacht werden kann und welche Auswirkungen dies hat. Was kann aus diesem Artikel gelernt werden?
  • Animieren von Listbox-Einträgen
  • Überschreiben des Fokuses
  • Styling eines ausgewählten Eintrags

Bevor es ans Eingemachte geht, sehen wir uns das Eregebnis an:



Um die Daten anzuzeigen, werden Objekte vom Typ Person verwendet. Dabei handelt es sich um Datenobjekte, welche sehr einfach aufgebaut sind:
public class Person
{
    public String FirstName { get; set; }
    public String LastName { get; set; }

    public override string ToString()
    {
        return String.Format("{0}, {1}", LastName, FirstName);
    }
}

Um Testdaten zu beziehen wird ein Mock-Objekt verwendet:
public static class PersonMock
{
    private static PersonCollection people =
        new PersonCollection();

    public static PersonCollection GetPeople()
    {
        if (people.Count > 0)
            return people;

        for (int i = 0; i < 10; i++)
            people.Add
                (
                    new Person
                    {
                        FirstName = "FirstName" + i.ToString(),
                        LastName = "LastName" + i.ToString()
                    }
                );

        return people;
    }
}

Nun können wir daran gehen, die ListBox zu stylen:

Dafür ist ein DataTemplate zu erstellen. Dieses wird als ItemTemplate verwendet und beschreibt somit die Darstellung jedes einzelnen Eintrages der ListBox:
<DataTemplate DataType="Person">
    <Border
        Cursor="Hand"
        Name="BorderControl"
        Background="WhiteSmoke"
        BorderThickness="0"
        CornerRadius="5"
        Padding="5">
        <TextBlock
            Name="TextControl"
            Grid.Column="0"
            Text="{Binding}"
            Background="Transparent"
            Padding="4">
            <TextBlock.Style>
                <Style TargetType="TextBlock">
                    <Style.Triggers>
                        <DataTrigger
                            Binding="{Binding ElementName=BorderControl,
                                      Path=IsMouseOver}"
                            Value="True">
                            <Setter Property="Foreground" Value="White"/>
                            <Setter Property="FontWeight" Value="Bold"/>
                        </DataTrigger>
                    </Style.Triggers>
                </Style>
            </TextBlock.Style>
        </TextBlock>
    </Border>
    <DataTemplate.Triggers>
        <EventTrigger
            SourceName="BorderControl"
            RoutedEvent="TextBlock.MouseEnter">
            <BeginStoryboard>
                <Storyboard>
                    <ColorAnimation Storyboard.TargetName="BorderControl"
                        Storyboard.TargetProperty="Background.Color"
                        To="DarkRed" Duration="00:00:00.2" />
                </Storyboard>
            </BeginStoryboard>
        </EventTrigger>
        <EventTrigger
            SourceName="BorderControl"
            RoutedEvent="TextBlock.MouseLeave">
            <BeginStoryboard>
                <Storyboard>
                    <ColorAnimation Storyboard.TargetName="BorderControl"
                        Storyboard.TargetProperty="Background.Color"
                        To="WhiteSmoke" Duration="00:00:00.2" />
                </Storyboard>
            </BeginStoryboard>
        </EventTrigger>
    </DataTemplate.Triggers>
</DataTemplate>

Das DataTemplate selbst ist sehr einfach gestrickt. Es definiert einen Border, der um ein TextBlock-Element gelegt wird.

Der wesentlich interessantere Part liegt bei den verwenderten Triggern. Es gibt einen DataTrigger für das TextBlock-Element und einige EventTrigger. Worin liegt der genaue Unterschied?

Ein DataTrigger wird an eine Eigenschaft gebunden und überwacht deren Änderungen. Ist der definierte Wert gesetzt, werden die im Trigger definierten Setter ausgeführt. Ändert sich der Wert nochmals, wird der ursprüngliche Zustand hergestellt.

Ein EventTrigger fungiert wie ein Eventhandler für Ereignisse. Das Ereignis wird abonniert und tritt dieses auf, wird die definierte Aktion ausgeführt. In diesem Beispiel wird eine Animation für den Eintrag ausgeführt, der aktuell unterhalb der Maus liegt. Dies wird über die Events MouseEnter und MouseLeave festgestellt. Das erste Ereignis wird geworfen, sobald die Maus in den sichtbaren Bereich eines Elementes gelangt. In diesem Fall wird mit Hilfe einer Animation das Aussehen verändert. Das MouseLeave-Ereignis wird ausgelöst, wenn die Maus den Bereich des Elementes wieder verläßt. In diesem Fall wird durch eine Animation das ursprüngliche Aussehen wieder hergestellt.

Für eine ListBox reicht das aktuell definierte Styling noch nicht. Es fehlen noch zwei Dinge: Erstens erscheint bei einem Klick auf ein Element ein Fokusrand, der beseitigt werden soll. Dies führt und schlussendlich dazu, dass ein ausgewähltes Item noch nicht gestyled wurde. Sehen wir uns hierzu den entsprechenden Style an:
<Style x:Key="GlowContainer" TargetType="{x:Type ListBoxItem}">
    <Setter Property="FocusVisualStyle">
        <Setter.Value>
            <Style>
                <Setter Property="Control.Template">
                    <Setter.Value>
                        <ControlTemplate>
                            <Border
                                Background="Transparent"
                                Opacity="0"
                                CornerRadius="0">
                                <Rectangle
                                    Margin="0"
                                    StrokeThickness="0"
                                    Stroke="Transparent"
                                    StrokeDashArray="1 2"/>
                            </Border>
                        </ControlTemplate>
                    </Setter.Value>
                </Setter>
            </Style>
        </Setter.Value>
    </Setter>
    <Setter Property="Template">
        <Setter.Value>
            <ControlTemplate TargetType="{x:Type ListBoxItem}">
                <Border Background="WhiteSmoke"
                            CornerRadius="5"
                            BorderThickness="2"
                            x:Name="ItemBorder"
                            Margin="6,3,6,3" >
                    <ContentPresenter />
                </Border>
                <ControlTemplate.Triggers>
                    <Trigger Property="IsSelected" Value="true">
                        <Setter
                            TargetName="ItemBorder"
                            Property="BitmapEffect">
                            <Setter.Value>
                                <OuterGlowBitmapEffect
                                    GlowColor="DarkRed"
                                    GlowSize="5" />
                            </Setter.Value>
                        </Setter>
                    </Trigger>
                </ControlTemplate.Triggers>
            </ControlTemplate>
        </Setter.Value>
    </Setter>
</Style>

Der definierte Style enthält zwei Setter. Im ersten wird der ItemContainerStyle definiert. Der Item-Container einer ListBox wird durch ein ListBoxItem dargestellt. Erhält dieses den Fokus, wird dieser dargestellt. In unserem Style definieren wir nun einen Border, der transparent dargestellt wird. Dadurch ist der Fokus nicht mehr zu sehen.

Damit das ausgewählte Element entsprechend dargestellt wird, werden im zweiten Setter die notwendigen Vorkehrungen getroffen. So wird ein ControlTemplate definiert. Dieses besteht aus einem Border und einem ContentPresenter. Den Border werden wir nutzen, um einen Glow-Effekt darzustellen. Der ContentPresenter stellt den Platzhalter für den anzuzeigenden Inhalt dar.
Zusätzlich enthält das ControlTemplate einen Trigger. Dieser hängt sich an die Eigenschaft IsSelected und schlägt an, sobald der Wert auf true gestellt wird, also das Element ausgewählt wurde. In diesem Fall wird ein Outer Glow definiert und die Eigenschaft BitmapEffect gesetzt. Damit wäre das ausgewählte Element auch gestyled.

Wer an diesem Beispiel testen möchte, kann dieses unterhalb herunter laden. Ich empfehle jedoch einen genaueren Blick auf Control Templates, Data Templates, Triggers, Effekte und Animationen, um eine tieferes Verständnis zu erhalten.



  Kommentar hinzufügen   |  0 Trackbacks   |  Permalink  |  Trackback-URL


WPF PropertyGrid in neuer Version verfügbar

29.01.09 - .NET, WPF, Internet, Community, Tools, 3rd Party Tools
Beitrag von Norbert Eder
  Das zu 100% in WPF entwickelte WPF PropertyGrid Control wurde in einer neuen Version zur Verfügung gestellt. Es bietet reichhaltige Funktionen und ist zudem auch noch hübsch anzusehen. Nachfolgend ein Ausschnitt der langen Funktionsliste:
  • 100% WPF Component (no Windows Forms interop, no native code calls, etc.)
  • Same property editing approach introduced by Visual Studio 2008 WPF Designer ("Cider") and Expression Blend, same steps for creating inline and dialog based editors
  • Built-in property editors and support for editors customization, injection
  • Property grouping, sorting and filtering, property display schemas based on multiple rule sets
  • Several display modes for properties (Native CLR properties, Dependency properties, All properties)
  • Optional display of Attached or Read-only properties
  • Category initial mode configuration (expanded or collapsed by default)
  • Property metadata (DisplayNameAttribute, CategoryAttribute, DescriptionAttribute, etc) and ICustomTypeDescriptor support
  • All property metadata is accessible from custom editors, MetadataStore support
  • Property "Search Box" with live view updates, possibility to hide/show search box
  • Basic support for Windows Forms interopability, display of non-dependency objects, integration into Windows Forms application)

Weitere Informationen, Screenshots, Tutorials etc. finden sich auf der Projektseite: http://www.codeplex.com/wpfpropertygrid


  1 Kommentar - 1368 mal angesehen   |  0 Trackbacks   |  Permalink  |  Trackback-URL


Sichtbarkeit von Elementen über WPF Commands steuern

28.01.09 - .NET, WPF
Beitrag von Norbert Eder
 Das WPF Command System ist ein sehr mächtiges System. Nur gibt es da eine Sache, die mich dann doch etwas stört: Zwar kann über CanExecute und PreviewCanExecute (also Bubbling bzw. Tunneling Ereignis) festgelegt werden, ob ein Command ausgeführt werden kann oder nicht, nur wird dabei lediglich darüber entschieden, ob das jeweilige Element aktiviert oder deaktiviert ist. In manchen Fällen würde ich mir jedoch wünschen, konfigurieren zu können, was genau geschehen soll. In meinem Fall möchte ich das Element gänzlich ausblenden.

Da ich dafür keine angebotene Funktionalität finden konnte, habe ich mir selbst etwas gebaut. Ob es die schönste Lösung ist kann ich nicht sagen. Hat jemand eine bessere zur Hand, freue ich mich natürlich über eine entsprechende Mitteilung.

Gehen wir von einer einfachen Anwendung aus, die ein Menü besitzt und dieses einige Einträge. An diesen Menüeinträgen hängen Commands. Kann nun ein Command nicht ausgeführt werden, soll der Menüeintrag verschwinden. Das Basis-Markup sieht folgendermaßen aus:
<DockPanel>
    <Menu DockPanel.Dock="Top">
        <Menu.CommandBindings>
            <CommandBinding 
                Command="ApplicationCommands.Open" 
                Executed="OpenCommand_Executed"/>
            <CommandBinding 
                Command="ApplicationCommands.Close" 
                Executed="CloseCommand_Executed"/>
            <CommandBinding 
                Command="cmd:Commands.ExitCommand" 
                Executed="ExitCommand_Executed"/>
        </Menu.CommandBindings>
        <MenuItem x:Name="FileMenu" Header="File">
            <MenuItem Command="ApplicationCommands.Open"/>
            <MenuItem Command="ApplicationCommands.Close"/>
            <Separator/>
            <MenuItem Command="cmd:Commands.ExitCommand"/>
        </MenuItem>
    </Menu>
</DockPanel>

Wer mit dem Command-System nicht vertraut ist, der findet hier und hier entsprechende Informationen.

Im Markup ist zu sehen, dass bis jetzt kein Handler für CanExecute erstellt wurde. Normalerweise wird dies direkt beim CommandBinding gemacht, das hilft uns allerdings nicht bei der Lösung, da wir innerhalb dieses Handlers nicht mehr auf unseren eigentlichen Menüeintrag kommen und diesen daher auch nicht unsichtbar schalten können. Es muss also eine andere Lösung her.

Das MenuItem-Element besitzt ein Attached Property names CommandManager (diese Eigenschaft besitzen auch andere Elemente). Darüber stehen dieselben Ereignisse zur Verfügung. Anstatt also das Ereignis direkt beim CommandBinding zu abonnieren, können wir dies direkt beim Menüeintrag tun (über das Attached Property) und erhalten im resultierenden Eventhandler auch Zugriff auf unser Element.

So sieht das neue XAML Markup aus:
<Menu DockPanel.Dock="Top">
    <Menu.CommandBindings>
        <CommandBinding 
            Command="ApplicationCommands.Open" 
            Executed="OpenCommand_Executed"/>
        <CommandBinding 
            Command="ApplicationCommands.Close" 
            Executed="CloseCommand_Executed"/>
        <CommandBinding 
            Command="cmd:Commands.ExitCommand" 
            Executed="ExitCommand_Executed"/>
    </Menu.CommandBindings>
    <MenuItem x:Name="FileMenu" Header="File">
        <MenuItem 
            Command="ApplicationCommands.Open"
            CommandManager.CanExecute="OpenMenuCommand_CanExecute"/>
        <MenuItem 
            Command="ApplicationCommands.Close"
            CommandManager.CanExecute="CloseMenuCommand_CanExecute"/>
        <Separator/>
        <MenuItem Command="cmd:Commands.ExitCommand"/>
    </MenuItem>
</Menu>

Nun können wir entweder über den ersten Parameter sender auf das MenuItem oder über die Eigenschaften OriginalSource bzw,. Source der Ereignis-Argumente zugreifen:
private void OpenMenuCommand_CanExecute(
    object sender,
    CanExecuteRoutedEventArgs e)
{
    FrameworkElement elem = sender as FrameworkElement;
    if (FileLoader.IsLoaded)
    {
        if (elem != null)
            elem.Visibility = Visibility.Collapsed;
        e.CanExecute = false;
    }
    else
    {
        if (elem != null)
            elem.Visibility = Visibility.Visible;
        e.CanExecute = true;
    }

    e.Handled = true;
}

Was passiert hier? Es gibt einen statischen Typ FileLoader, der verschiedene Möglichkeiten (als Mock-Objekt) zur Verfügung stellt. So werden die Möglichkeiten angeboten, eine Datei zu öffenen bzw. wieder zu schließen. Über die Eigenschaft IsLoaded kann der aktuelle Status abgefragt werden. Je nachdem, wie diese Eigenschaft gesetzt ist, wird nun auch der jeweilige Menüeintrag angezeigt, oder nicht.

Aussehen tut es im Endeffekt so:


Wer sich dieses Beispiel ansehen möchte, der kann dieses natürlich herunter laden und testen:

  Kommentar hinzufügen   |  0 Trackbacks   |  Permalink  |  Trackback-URL


Kaxaml ab sofort mit Silverlight-Unterstützung

27.01.09 - .NET, WPF, Silverlight, Tools, 3rd Party Tools
Beitrag von Norbert Eder
 Kaxaml ist ein kleiner und ressourcenschonender Editor für XAML. Dieser steht in einer aktualisierten Version zur Verfügung und bietet und auch Unterstützung für Silverlight 2.



Vor allem für kleinere Aufgaben, wie dem Erstellen von Beispielen bzw. Demo-Anwendungen bietet dieses Werkzeug eine hervorragende Unterstützung.

Quelle: nerdplusart.com

  Kommentar hinzufügen   |  0 Trackbacks   |  Permalink  |  Trackback-URL


Noch mehr Tipps und Tricks

27.01.09 - .NET, WPF, ASP.NET
Beitrag von Norbert Eder
 Die angebotene Trickkiste hat wieder eine Aktualisierung erfahren. Die Silverlight-Anwendung blieb dieselbe, jedoch habe ich an den Inhalten geschraubt. Ab sofort stehen auch Inhalte zu:
  • Windows Presentation Foundation (WPF)
  • Silverlight
zur Verfügung.



Über eine bequeme Suche nach Tags werden die einzelnen Tipps und Tricks in einer übersichtlichen Liste mit Teaser dargestellt. So fällt es einfach, den richtigen Eintrag zu finden.

Meinungen, Wünsche, usw. werden natürlich jederzeit gerne entgegen genommen.


  Kommentar hinzufügen   |  0 Trackbacks   |  Permalink  |  Trackback-URL


SQL Server Management Studio und Vista: Fehler 29506

26.01.09 - SQL Server
Beitrag von Norbert Eder
 Nachdem es mir heute mein SQL Server Management Studio Express zerrissen hat konnte nur mehr ein Uninstall und ein Reinstall helfen. Denkste! Die Neuinstallation endete nach kompletten Durchlauf im Fehler 29506.

Mit ein wenig Recherche (man glaubt gar nicht, wie viele dieses Problem noch haben) kam ich auf die Lösung - eigentlich einfachst.

Einfach die Command Line mit Adminstratorrechten ausführen und so das Setup starten. Die Installation läuft ohne Probleme durch. So einfach kann es sein.

  2 Kommentare - 1758 mal angesehen   |  0 Trackbacks   |  Permalink  |  Trackback-URL


Fehler der Datenbindung schnell finden

25.01.09 - .NET, WPF
Beitrag von Norbert Eder
 Wer Datenbindung in seinen WPF-Anwendungen häufig benötigt, wird kennen, wie mühsam die Suche nach einem Fehler sein kann. Dabei bietet das .NET Framework hilfen, um derartigen Fehlern schnell auf die Spur zu kommen. Ganz ohne Tools.

Im .NET Framework 3.5 gibt es die Klasse PresentationTraceSources aus dem Namespace System.Diagnostics. Dieses bietet uns die Möglichkeit, Traces von bestimmten Bereichen anzapfen zu können. Es werden zwei Wege geboten, auf diese Traces zuzugreifen:
  • Durch die Registrierung des Startup-Ereignisses der Application können die notwendigen Angaben in dessen Eventhandler getätigt werden.
  • Die Angabe der Traces kann auch über die Applikations-Konfigurations-Datei vorgenommen werden. Dies bietet den Vorteil, dass diese Funktion ohne großem Aufwand aktiviert bzw. deaktiviert werden kann.

Aber sehen wir uns dazu ein Beispiel an, welches die entsprechenden Angaben via Code tätigt.

Dazu verwenden wir ein Fenster mit einem DockPanel und einer ListView mit drei Spalten. Daran sollen Daten gebunden werden.
<DockPanel>
    <ListView x:Name="PeopleList">
        <ListView.View>
            <GridView>
                <GridViewColumn
                    Header="ID"
                    DisplayMemberBinding="{Binding Id}"/>
                <GridViewColumn
                    Header="LastName"
                    DisplayMemberBinding="{Binding Lastname}"/>
                <GridViewColumn
                    Header="FirstName"
                    DisplayMemberBinding="{Binding FirstName}"/>
            </GridView>
        </ListView.View>
    </ListView>
</DockPanel>

Um die Daten zu halten, wird eine Klasse Person verwendet:
public class Person
{
    public Int64 Id { get; set; }
    public String FirstName { get; set; }
    public String LastName { get; set; }
}

Hier fällt vielleicht auf, dass das Binding für die Eigenschaft LastName via XAML fehlerhaft angegeben wurde. In diesem einfachen Fall ist es nicht schwer, den Fehler zu finden. Bei komplexeren Aufgaben ist schon wesentlich mehr Aufwand notwendig.

Um dem Problem einfach auf die Spur zu kommen, wird das Startup-Ereignis der Anwendung registriert. Dies passiert in der Datei App.xaml:
<Application x:Class="PresentationTraceDemo.App"
    xmlns="..."
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    StartupUri="MainWindow.xaml"
    Startup="Application_Startup">
    <Application.Resources>

    </Application.Resources>
</Application>

Im Eventhandler verwenden wir nun PresentationTraceSources, um die Ablaufverfolgung für die Datenbindung zu nutzen. Dazu leiten wir diese auf unsere Konsole um und defnieren einen Level. Dieser definiert, welche Daten aufgefangen und geschrieben werden:
private void Application_Startup(
    object sender,
    StartupEventArgs e)
{
    PresentationTraceSources.DataBindingSource.Listeners.Add(
        new ConsoleTraceListener());
    PresentationTraceSources.DataBindingSource.Switch.Level =
        SourceLevels.Critical : SourceLevels.Error : SourceLevels.Warning;
}

Wenn wir nun die Anwendung starten, ist sie folgendermaßen zu sehen:


Es ist schön zu sehen, dass die Spalte LastName nicht befüllt wurde. Zwar einfach zu erkennen, werfen wir jetzt allerdings einen Blick in die Konsole. Hier sollte nun eine Nachricht zu finden sein, die uns auf einen Fehler in der Datenbindung aufmerksam macht:

System.Windows.Data Error: 39 :
BindingExpression path error: 'Lastname' property not found on 'object' ''Person' (HashCode=23686174)'.
BindingExpression:Path=Lastname; DataItem='Person' (HashCode=23686174);
target element is 'TextBlock' (Name=''); target property is 'Text' (type 'String')


Damit können nun auch komplexere Fehler gefunden werden.

Fazit


Es lohnt sich auf jeden Fall, sich auch die weiteren Möglichkeiten von PresentationTraceSources anzusehen, da darüber sehr viele hilfreiche Informationen bezogen werden. Viele der vorhandenen Tools greifen ebenfalls auf diese Quelle zu.

Nachfolgend stehe eine Demoanwendung zur Verfügung, die obiges Beispiel abbildet. Es lohnt sich auch ein Blick in die MSDN. Dort ist zudem zu finden, wie obiges via Applikations-Konfigurations-Datei konfiguriert werden kann.




  Kommentar hinzufügen   |  0 Trackbacks   |  Permalink  |  Trackback-URL


Bist du es leid für andere nach Lösungen zu suchen?

23.01.09 - Internet
Beitrag von Norbert Eder
 Bist du in der Community aktiv? Dann werden die Fragen, die sehr schnell durch eine Suche in der bevorzugten Suchmaschine beantwortet werden könnten, ein gewisses Frustpotential aufwerfen. Bekannt? Wenn ja, dann empfehle ich den nachfolgenden Link:

http://letmegooglethatforyou.com/

Wie es funktioniert, zeigt dieser Link:
http://letmegooglethatforyou.com/?q=letmegooglethatforyou&l=1

Sehr feine Sache!

PS: Wann gibt es eigentlich "Let me Live that for you"? ;-)

  2 Kommentare - 1074 mal angesehen   |  0 Trackbacks   |  Permalink  |  Trackback-URL


Einfache Messungen der Performance

22.01.09 - .NET, Grundlagen
Beitrag von Norbert Eder
 Es ist schon lange her, da hatte ich im Beitrag Zeitmessung einfach gemacht auf die Klasse Stopwatch hingewiesen. Da nach wie vor sehr viele Entwickler diese Möglichkeit der sehr einfachen Messung nicht kennen, möchte ich nochmals darauf hinweisen.

Gerade beim Vergleich von Codestücken oder bei der Erhebung von Zeiten an bestimmten Stellen kann damit großer Aufwand eingespart werden und man erhält innerhalb kürzester Zeit Kennzahlen. Zusätzlich ist es damit einfach, ein eigenes Performance-Service zu implementieren, um an zentralen Stellen der Anwendung Messungen durchzuführen. Dadurch können auch im laufenden Betrieb Engpässe festgestellt werden.

  Kommentar hinzufügen   |  0 Trackbacks   |  Permalink  |  Trackback-URL



Zurück Weiter