C# Syntax verstehen: public MyMethod (int value) : base(value) { … }

Das wird auch base-Konstruktor genannt. Wird der base-Konstruktor aufgerufen, dann wird zuerst dessen Code ausgeführt und dann erst der Code des abgeleiteten Konstruktors. Ein Beispiel zum Verständnis:

using System;
using System.Threading;

    class Program
    {
        static void Main(string[] args)
        {
            new BaseClass("Called by initialisation of BaseClass");
            new DerivedClass("Called by initialisation of DerivedClass");
            Thread.Sleep(10000); // wenn dieser Code in einem 'Console Application'-Projekt drin ist, dann kann man sich so den Output 10 Sekunden lang anschauen. 
        }
    }

    class BaseClass
    {
        public BaseClass(string value)
        {
            Console.WriteLine("Constructor of base class. " + value);
        }
    }

    class DerivedClass : BaseClass
    {
        public DerivedClass(string value) : base(value)
        {
            Console.WriteLine("Constructor of derived class. " + value);
        }
    }

In der Konsole wird ausgegeben:

Constructor of base class. Called by initialisation of BaseClass
Constructor of base class. Called by initialisation of DerivedClass
Constructor of derived class. Called by initialisation of DerivedClass

Workaround für plötzliches ‚Der angeforderte Vorgang erfordert hoehere Rechte‘ beim Öffnen Deiner Programme

Problem

Durch irgendwelche mysteriösen Gründe kann ich von Zeit zu Zeit meine Programme nicht mehr öffnen. Versuche ich dies, erscheint der Prompt für die Benutzerkontensteuerung. Selbst wenn ich hier die korrekten Windows-Credentials eingebe, erhalte ich eine Fehlermeldung: „Der angeforderte Vorgang erfordert höhere Rechte“

Der angeforderte Vorgang erfordert hoehere Rechte

BTW: Gleichzeitig ist ein bestimmtes Netzlaufwerk nicht mehr erreichbar.

Workaround

Man kann nun die Windows Commandline als Administrator öffnen:

command line als administrator ausfuehren

Dann zum betreffenden Programm navigieren und ausführen. Nun sollte es wie gewohnt starten.

Lehrgangs-Anbieter Waffensachkunde (WaffSaKu) in Bayern

Nürnberg (Mittelfranken)
Akademie für Sicherheit
http://www.akademiefuersicherheit.de/schutz/lehrgang-sicherheit-schulung/

Schweinfurth (Unterfranken)
Waffen Albert GmbH
http://www.waffen-albert.de/lehrgaenge/waffensachkunde/

Schönau an der Brend (Unterfranken)
Mike Zimmermann
http://www.alruwa.de/lehrgangstermine/

Pfreimd (Oberpfalz)
Oberpfälzer Schützenbund e.V.
http://www.osb-ev.de/lehrwesen/waffensachkunde/waffensachkunde.htm

Premenreuth (Oberpfalz)
Kai Wendt
http://www.ess-wendt.de

Kulmain (Oberpfalz)
WSA (Marco Dötterl)
http://waffensachkunde.org/sportsch-tzen.html

Stockdorf (Oberbayern)
Michael Fesseler
http://www.waffensachkunde.co

Viechtach (Niederbayern)
Peter Lerch
http://www.waffensachkunde.bayern/

Markt Kühbach (Schwaben)
Waffen Mayr
http://www.schulungszentrum-mayr.com/sm_lga/waffensachkunde_info.php

Prüfungsfragen

Bundesverwaltungsamt Stand 1.1.2010

Sachkundetrainer der German Rifle Association

Sehr schönes Trainingstool. Per Zufall werden die Fragen aus dem Prüfungskatalog zur Beantwortung gezeigt. Mittels Permalink kann man sich in seinen Browser-Favoriten einen Trainingsordner anlegen mit den Fragen, bei denen man noch Schwierigkeiten hatte. Und es ist sogar auf dem Smartphone einsetzbar. Außerdem macht das Lernen mit diesem Tool definitiv mehr Spaß, als mit dem Fragenkatalog des Bundesverwaltungsamtes. Leider werden die bereits beantworteten Fragen noch nicht gespeichert (z.B. per Cookies), was aber sicherlich noch auf der ToDo-Liste des Entwicklers steht. Daher den Entwickler mit einer kleinen Spende unterstützen.

DataContext im data binding-Konzept (WPF)

Der DataContext ist die default Quelle Deiner bindings. Ist er gesetzt, wird er innerhalb der Control-Hierarchie (beginnend mit Window) nach unten vererbt. Jedes WPF-Control hat sein eigenes DataContext-property, sodass man auf jeder Vererbungsebene die Vererbungshierarchie durchbrechen und ab dort eine neue Vererbungshierarchie etablieren kann. Wird der DataContext nicht gesetzt ist er null.

Der DataContext kann auf verschiedene Arten an verschiedenen Stellen erstellt werden (was es nicht gerade leichter macht, den Gesamtüberblick zu behalten):

DataContext via Window.DataContext

<Window x:Class="SampleApplication.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" DataContext="{Binding Employee}">

bzw.

<Window x:Class="Example.MainWindow" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:l="clr-namespace:Example" Title="Example" Height="300" Width="300" Name="Main">

 <Window.DataContext>
     <StaticResource ResourceKey="data"/>
 </Window.DataContext>

Ziemlich gute Darstellung des Zusammenspiels von Window.DataContext, Window.Resources und einem WPF-Control: http://stackoverflow.com/a/1959701/1777526

DataContext in einem untergeordneten WPF-control

<UserControl DataContext="{Binding RelativeSource={RelativeSource Self}}">

Quelle

DataContext in der Codebehind-Datei

    public MainWindow()
    {
        (...)
        gridOfNames.DataContext = new ParameterDataSource();
        (...)
    }

Häufig wird die zu entwickelnde GUI selbst als DataContext gesetzt, wobei es zwei Wege gibt:

1.) im XAML

<Window x:Class="MyClass"
  Title="{Binding windowname}"
  DataContext="{Binding RelativeSource={RelativeSource Self}}"
  Height="470" Width="626">

weiterführende Quelle

2.) im Codebehind

public class MyWindow : Window {

    public MyWindow() {
        InitializeComponents();
        DataContext = this;
    }   
}

Weiterführende Quelle mit gutem Anwendungsbeispiel

Binding-Quellen jenseits vom DataContext

Braucht man eine Binding-Quelle nur für ein UI-control (und nicht für dessen Nachkommencontrols in der Vererbungshierarchie) kann man diese individuell setzen. Ein gg.falls existierender DataContext wird dadurch für dieses UI-Control überschrieben. Z.B. mit ‚ElementName‘ welches direkt zu einem anderen UI-Element bindet:

<Window x:Class="WpfTutorialSamples.DataBinding.HelloBoundWorldSample" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" Title="HelloBoundWorldSample" Height="110" Width="280">
    <StackPanel Margin="10">
         <TextBox Name="txtValue" />
         <WrapPanel Margin="0,10">
             <TextBlock Text="Value: " FontWeight="Bold" />
             <TextBlock Text="{Binding Path=Text, ElementName=txtValue}" />
         </WrapPanel>
     </StackPanel>
</Window>

… oder mit dem Source-Property, welches z.B. zu einer Window.Ressource bindet:

<Window
  xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
  xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
  xmlns:src="clr-namespace:SDKSample"
  SizeToContent="WidthAndHeight"
  Title="Simple Data Binding Sample">

  <Window.Resources>
    <src:Person x:Key="myDataSource" PersonName="Joe"/>
  </Window.Resources>
  (...)
  <TextBlock Text="{Binding Source={StaticResource myDataSource}, Path=PersonName}"/>
  (...)
</Window>