Hallo Create,

füge doch einfach ein ResourceDictionary hinzu und verweise in deinem XAML darauf. Für die Definition von Styles, etc. benötigst du keine App.xaml. Es wird nur oft dort gemacht, weil man will, dass die Definitionen für die gesamte Anwendung gelten (also nicht neu eingebunden werden müssen).

Hallo burkut,

 List<Student> rblKonfigs = persList.Select(p => new Student
{
  Age = p.Age,
 Name = p.Name,
 Anschrift = p.Anschrift
}).ToList();

Wie Mallet aber schon richtig sagt, würde ich Student von Person erben lassen und dann die gleichen Properties aus Student rauswerfen.

Dann kannst du nämlich Folgendes machen:

List<Student> rblKonfigs = persList.Cast<Student>().ToList();

Alternativ zum Cast kannst du mit OfType() arbeiten, da wird dann keine Exception geworfen.

Hallo N0ACE,

nimm am Besten das Binding für den DataContext in deinem UserControl aus dem XAML und definiere es im Codebehind des Controls:

// using ...

namespace TEST_Headlines
{
    public partial class BaseHeadline : UserControl
    {
        public static readonly DependencyProperty TitleProperty = DependencyProperty.Register(
            "Title",
            typeof(string),
            typeof(BaseHeadline),
            null
        );

        public string Title
        {
            get { return (string)GetValue(TitleProperty); }
            set { SetValue(TitleProperty, value); }
        }

        public BaseHeadline()
        {
            InitializeComponent();
            DataContext = this;
        }
    }
}

Alternativ kannst du auch z.B. beim Binding auf Title noch die Quelle (also das Control selbst) über ElementName oder RelativeSource-Binding angeben.

Hallo flacker,

in deinem XAML ist nirgendwo definiert, auf welche Property der TextBox dein Binding angewendet werden soll. Du musst hier die Text-Property angegeben.

....
 <TextBox
            HorizontalAlignment="Left"
            VerticalAlignment="Top">
<TextBox.Text>
            <Binding Path="States" UpdateSourceTrigger="PropertyChanged">
                <Binding.ValidationRules>
                    <local:ValidierungTest/>
                </Binding.ValidationRules>
            </Binding>
</TextBox.Text>
        </TextBox>

Hallo Create,

erzeuge eine eigene Klasse, die von Canvas ableitet und überschreibe darin die MeasureSize-Methode. Innerhalb der Methode kannst du über die Children-Property auf die Elemente auf dem Canvas zugreifen und über deren Width und Height die maximale Größe des Canvas ermitteln. Problematik ist nämlich, dass das Canvas eine undefinierte Größe hat, solltest du sie nicht irgendwo fest definiert haben.

Jedes mal beim Drachen über den Tumb rufst du dann die InvalidateVisual-Methode des Canvas auf. Damit wird festgestellt, dass das gedraggte Element außerhalb des maximalen Bereichs des Canvas liegt und der Scrollviewer automatisch angezeigt.

Hallo Coder007,

Bei der Zertifizierung geht es um das Vorgehen zur Erzeugung einer Softwarearchitektur, welche Risiken, Randbedingungen zu beachten sind und wie diese sinnvoll ermittelt werden. Inhaltlich geht es um die Rolle des Architekten, welche Sichten sinnvoll sind, wie man von den Anforderungen in iterativen Schritten zur passenden Architektur kommt. Für weitere Infos kann ich dir folgende Seite empfehlen:

CPSA

Wenn du den kompletten Inhalt wissen möchtest, kann ich dir das Buch "Basiswissen für Softwarearchitekten" von Mahbouba Gharbi empfehlen.

Hallo Garby,

ich besitze beispielsweise die CPSA (Certified Professional for Software Architecture), die komplett Technologieunabhängig ist.

Hallo S.R.,

ich bin grundsätzlich kein Fan der Microsoft Zertifizierenden. Die Zertifizierung bringt meiner Meinung nach folgende Nachteile:

• Zertifizierung für eine Technologie (hier: Microsoft C#)
• Zertifizierung nur für eine Version (Bsp. wenn du dich für 2010 zertifizierst, musst du für 2012 die Zertifizierung nachmachen, wenn du möchtest, dass diese auch dafür gilt.)

Die meisten Arbeitgeber in der Branche kennen die Microsoft Zertifizierungen und wissen, dass ein Zertifikat nicht immer auch heißt, dass man wirklich gut in der Praxis ist, da es sich nur um Multiple Choice Fragen handelt und diese nicht so schwer sind. Ich würde dir eher zu Zertifizierungen raten, die technologieunabhängig sind.

Hallo Sam99,

deine Styles unterscheiden sich lediglich in der Schriftgröße. Deshalb ist es auch nicht verwunderlich, dass beide eine rote Schriftfarbe haben, siehe

Value="{DynamicResource ResourceKey=ForegroundColor}"

Das Label übernimmt also nicht den Style des TextBlock.

Was spricht gegen LINQ to XML? Damit lässt sich die XML viel schöner parsen.

Hallo Epanias,

Erweitere einfach deinen Code um folgende Zeilen:

string verzeichnis;
            int i;
            string[] dateiliste;
            Directory.SetCurrentDirectory(CharDirectory);
            verzeichnis = Directory.GetCurrentDirectory();
            dateiliste = Directory.GetDirectories(verzeichnis);
            lstCharacterList.Items.Clear();
            for (i = 0; i < verzeichnis.Length; i++)
            {
                string vollerPfad = dateiliste[i];
                string ordnername = vollerPfad.Substring(vollerPfad.LastIndexOf("/") + 1);
                lstCharacterList.Items.Add(ordnername);
            }

Eventuell aus dem / einen Backslash machen.

Du kannst natürlich zusätzlich einen zweiten Counter einfügen, der die Anzahl der Versuche protokolliert. Wenn dieser Counter also < 2 ist, dann gilt deine Ausnahme, ansonsten bist du definitiv beim zweiten Versuch.

Hallo indeopax,

erstens ist eine ArrayList schlecht. Verwende hier eine generische Collection, bsp. List<T>. Da du immer Tuple einfügst würde ich für T die Klasse Tuple<string,string> wählen.

Sortieren kannst du es dann so (ungetestet):

List<Tuple<string,string>> liste = new List<Tuple<string,string>>();
liste.Add(new Tuple<string,string>("12","13"));
iste.Add(new Tuple<string,string>("43","12"));
iste.Add(new Tuple<string,string>("21","13"));

//sortieren mit Lamda-Ausdruck
//first und second sind die Tuple, die aktuell verglichen werden
liste.Sort((first,second)=>first.Item1.CompareTo(second.Item1));

Hallo wokie,

ich weiß zwar nicht, was du mit deiner Lösung erreichen willst, aber was spricht dagegen, das Array aufsteigend zu sortieren?

Einfach mit

Array.Sort()

das Array sortieren und dann sind die Elemente der Größe nach aufsteigend sortiert. Die Anzahl der Elemente wäre dann die Länge des Arrays. Außerdem ist es nicht logisch zu sagen, dass in deinem Beispiel 1 ≤ dem aktuellen Element ist, weil es einfach nicht zutrifft, d.h. du würdest dein Ergebnis verfälschen.

Hallo Jazzman,

der Grund des Flackerns liegt daran, dass die Animation, etc. im GUI-Thread abläuft (Gut, ist ja irgendwo logisch, weil du nur aus dem GUI-Thread auf GUI-Elemente zugreifen solltest).

Ich würde mir an deiner Stelle mal die Animation-Klassen und das Storyboard in WPF anschauen, mit dem Animationen in WPF gemacht werden. Bei der stelle ich so schnell kein Flackern fest.

Hallo DaReaLSy,

ohne ein bisschen Code kann dir niemand wirklich weiterhelfen.

Poste doch bitte einfach den Teil deines Homeviews und deiner Main-Methode.

Hallo MysticEmpires,

Ich habe 2 Vermutungen:

1.) Der Simulator unterstützt für das Binding vielleicht kein IEnumerable. Versuche mal auf dem GroupBy "ToList" aufzurufen, also:

llsNews.ItemsSource = posts.GroupBy(p => p.Date.ToString("dddd, d.MMMM yyyy")).ToList();

2.) Wie sehen die Instanzen der posts-Collection aus? Gibt es eine Property Key? Wie ist da die Sichtbarkeit definiert?

Da hab ich mich wohl falsch ausgedrückt. Ich verweise natürlich auf einen Namespace. Die Klasse Class2 liegt nun aber im Namespace Project.BL und deshalb muss ja eine using-Anweisung hinzugefügt werden. Heißt das jetzt, dass es so nicht funktionieren würde? Dann wäre die CodeDomProvider-Klasse zum Kompilieren unnütz.

Hallo zusammen,

folgende Problematik habe ich:

Angenommen, es existiert ein C#-Projekt mit folgender Struktur:

Project.csproj

• BL (Ordner)
  • Class1 (in BL-Ordner)
• Class2

In Class2 wird Class1 verwendet. Hierzu wird eine using-Direktive verwendet:

using Project.BL; 
...
public class Class1
{
   ... //Definition
}

Wenn ich jetzt Class1 mit dem CodeDomProvider und der Methode CompileAssemblyFromSource kompiliere, erhalte ich aus der rückgegebenen ErrorCollection eine FileNotFoundException:

Fehlermeldung:
Die Datei oder Assembly BL kann nicht gefunden werden. (Verweis fehlt?)

Die notwendigen referenzierten Assemblies habe ich der Providerinstanz bereits hinzugefügt.

Wie kann ich dieses Problem mit der Ordnerstruktur/using-Direktive lösen?

Hallo,

setz mal Padding bzw. Margin auf 0.

Wenn das nicht hilft, dann müsstest du wohl das Template für das MenuItem überschreiben.

Hallo sindibad,

Eine RichTextBox ist das richtige Control für deine Anforderung, weil - wie du bereits selbst geschildert hast - die einfache TextBox dies nicht unterstützt.

Grundsätzlich musst du beim "Auftreten"/Loggen einer Exception den Text in die Box schreiben und den StartIndex sowie die Länge des Textes innerhalb der Box ermitteln. Anschließend musst du die Infos den Properties SelectionStart und SelectionLength der Box übergeben und entsprechend die SelectionColor setzen.

Dies sollte dir eventuell helfen:RichTextBox Textteile farbig markieren

So wie ich das sehe, verwendest du Windows Forms und nicht WPF.

Hallo jogisarge,

Im Grunde hast du deine Fragen durch die Beschreibung des Ist-Zustands bereits beantwortet:

Änderungen in der **Tabelle **werden sofort nach verlassen der Zeile an die DB übermittelt.
Änderungen im Detailfenster werden sofort nach dem Speichern-Button an die DB gesendet.

Je nach Anzeigeart also einen Button bzw. Direktes Speichern über das Ereignis "Zeile verlassen". Bedenke aber, dass du...
a)...nur die geänderten Daten speicherst (Dabei hilft dir die ObservableCollection)
b)...Das Speichern asynchron erfolgen sollte, damit die GUI nicht blockiert.

Für die tabellarische Darstellung empfiehlt sich das Datagrid.

Aus der Clean Code Perspektive wäre das so auch nie in Ordnung. Da sollte man die vielen Parameter lieber in ein Objekt zusammenführen. Deshalb ist es so schon unnötig.

Hallo,

hat das eventuell was mit dem Build zu tun, also ob du ne x32 oder ne x64 Version von VS Express installieren willst?

Hallo vita85,

Eine Alternative wäre die Verwendung von

CanResizeWithGrip

beim ResizeMode. Dadurch bekommst du am unteren rechten Rand ein Grip angezeigt, mit dem du die Fenstergröße ändern kannst.

Sollte dir die Lösung nicht reichen, könnte dir eventuell das hier helfen:
Resizing Custom Window in WPF

Hier wird zwar Expression Blend verwendet, aber das kann man auch in Visual Studio und XAML direkt entsprechend umsetzen.

Meine Vermutung ist, dass VS automatisch bei den neuen Projektvorlagen von einer höheren Office-Version ausgeht.

Probier am besten mal Folgendes:

Projekteigenschaften (Eigenschaften bei Rechtsklick auf Addin-Projekt) -> Debug -> Starte mit externem Programm => hier musst du die exe deiner Office-Version (Excel, Word, etc.) auswählen, über die dein Addin gestartet werden soll.

Bei mir hat das so funktioniert.

Hallo Endro,

Ja das ist möglich. Ich habe auch vor einer Weile mit VS 2008 ein Addin für Office 2003 erstellt. Vor Kurzem sind wir dann auf VS 2010 umgestiegen und da habe ich das Projekt einfach mit VS 2010 konvertiert und daran weiterentwickelt.

Hallo zusammen,

Laut Microsoft soll die Express-Edition von VS 11 (bzw. VS 2012) nur Metro-Anwendungen ermöglichen, für Desktop-Anwendungen soll man weiterhin die Express-Edition von VS 2010 verwenden, wenn man auf keine höhere Version umsteigen will.

Weiß eventuell jemand, ob es für VS 2010 eine .NET 4.5 Unterstützung (Bsp. über Service Pack) geben wird? Sonst wäre man als Express-Anwender genötigt, auf eine höhere Version umzusteigen.

Wann wird denn die VS 11 Express Version erscheinen?

Ich hab das Problem jetzt gelöst.

Zuerst ist die Berechnung von relativeX und relativeY falsch.

Außerdem hab ich das Zeichnen ausgelagert, indem ich von Canvas abgeleitet habe und darin die OnRender-Methode überschreibe. Dort hole ich mir alle Verbindungen und zeichne dann die Linie über die Properties SourceLocation und DestinationLocation.

Ich habe zur Verdeutlichung ein Screenshot angehängt.

Hier mein Code der Adorner-Klasse:

 public class ConnectionAdorner : Adorner
    {
        private readonly UserControl _adornedElement;
        private bool _isConnected;
        private RelationDirection _direction;

        public ConnectionAdorner(UserControl adornedControl) : 
        base (adornedControl)
        {
            _adornedElement = adornedControl;
            Connectors = new List<Connector>();
        }

        protected override void OnRender(DrawingContext drawingContext)
        {
            var currentBounding = new Rect(_adornedElement.DesiredSize);
            var relativeX = Direction == RelationDirection.SourceToDestination ? 
            Canvas.GetLeft(_adornedElement) : 
            Canvas.GetLeft(_adornedElement) + _adornedElement.ActualWidth;
            
           var relativeY = Canvas.GetTop(_adornedElement) + 
            _adornedElement.ActualHeight / 2.0;
            
            var currentX = Direction == RelationDirection.SourceToDestination ? 
            currentBounding.TopRight.X : currentBounding.TopLeft.X;
            
            var currentY = currentBounding.TopRight.Y + currentBounding.Height / 
            2.0;
            
            var centerPosition = new Point(currentX, currentY);
            ConnectorPoint = new Point(relativeX, relativeY);

            drawingContext.DrawEllipse(new SolidColorBrush(IsConnected ? 
            Colors.Black : Colors.White), new Pen(Brushes.Black, 1.5), centerPosition, 
            5.0, 5.0);

            foreach(var connector in Connectors)
            {
                drawingContext.DrawLine(new Pen(Brushes.Black, 1.5), 
                connector.SourceLocation, connector.DestinationLocation);
            }
        }

        public bool IsConnected 
       { 
          get 
          { return _isConnected; } 
          set
          {
            if(_isConnected != value)
            {
                _isConnected = value;
                InvalidateVisual();
            }
         }
       }

        public RelationDirection Direction 
       {
        set
        {
            if(_direction != value)
            {
                _direction = value;
                InvalidateVisual();
            }
        } 
        get { return _direction; } 
       }

        public Point ConnectorPoint
        {
            get; private set; 
        }

        public IList<Connector> Connectors { private set; get; }
    }

Die Klasse Connector bestimmt den Start- und Endpunkt in Abhängigkeit der Lage der Controls auf dem Canvas.

P.S.: Bitte nicht über die Codequalität wundern, das Ganze ist als Spike-Solution gedacht.

Hallo zusammen,

ich habe einen Adorner erstellt, der mir auf einem UserControl einen Kreis zeichnet. Das funktioniert auch wunderbar. Nun platziere ich zwei dieser UserControls auf einem Canvas. Nun möchte ich, dass die beiden Kreise der Adorner über eine Linie miteinander verbunden werden.

Hierzu berechne ich die Positionen der Kreise relativ zum Canvas und lasse dann die Linie in der OnRender-Methode der Adorner-Klasse mit drawingContext.DrawLine zeichnen. Leider wird die Linie falsch gezeichnet.

Wo liegt genau der Fehler bzw. gibt es eine einfache Lösung zum Zeichnen der Linie?

Ich möchte kein Line-Objekt dem Canvas hinzufügen.

Danke für eure Hilfe.

Hallo chilic,

ich gehe nicht davon aus, dass es am Betriebssystem liegt. Das liegt wahrscheinlich an der Konfiguration. Je nachdem, ob du alles von Hand per Code oder mittels des Editors in Visual Studio (App.config) gemacht hast, musst du auch dann an der entsprechenden Stelle die Konfiguration anpassen. Es existiert ein ReceiveTimeout, das glaub ich per default bei 1 min liegt. Das solltest du entsprechend anpassen.

Schau auch mal hier:
Timeouts in WCF

Hallo UNeverNo,

schau dir mal das Interface IConvertible an. Ich denke, wenn du es schon irgendwo auf dem generischen Weg versuchen möchtest, dann sollte die Einschränkung zumindest auf diesem Interface liegen. Aber wie herbivore schon sagt, gibt es keine ultimative Lösung hierfür.

Eventuell könnte auch dynamic für dich interessant sein.

Ich habe auf die entsprechende Tabelle einen Trigger gesetzt, der in einer Art Report-Tabelle die entsprechenden Infos einträgt. Und nur auf diese Tabelle lausche ich mit der SqlDependency-Klasse. Bei einem Insert über den Trigger in die Tabelle erhalte ich dann ein Event. Dann hole ich den letzten Eintrag (über Zeitstempel) aus der Tabelle und interpretiere die Daten. Ich würde die SQLDependency niemals auf mehrere Tabelle lauschen lassen.

Hallo Coooder,

Am Besten verwendest du in WPF ein Hauptfenster und nimmst als INhalt einen ContentPresenter. Die einzlenen Inhalte setzt du als UserControls um und weißt der Property Content des ContentPresenters die entsprechende Instanz des UserControls zu.

Ein ähnlicher Ansatz verfolgt das Framework Prism

In den UserControls kannst du dann auch schön wie bei einem Fenster oder Formular die entsprechende Kontextlogik kapseln.

Hallo Second Sun,

ich habe sowas entsprechend in unserer Firma schon umgesetzt. Diesen Teil müsstest du mit der SqlDependency-Klasse selbst übernehmen. Wenn du dabei Hilfe für das Konzept brauchst, kann ich dir gerne helfen.

Hallo m.grauber,

ich habe versucht entsprechend deiner Beschreibung das ganze nachzustellen und habe bei der Kombination von deiner Umsetzung und mit der von DaMoe80 keine Probleme. Hier mein Code:

public partial class MyUserControl : UserControl
{
    public static readonly DependencyProperty TestprobProperty =    
    DependencyProperty.Register("Testprob", typeof(UIElement),
    typeof(MyUserControl), new PropertyMetadata(TestprobChanged));


    private static void TestprobChanged(DependencyObject aD, 
    DependencyPropertyChangedEventArgs aE)
    {
      (aD as MyUserControl).Testprob = (UIElement)aE.NewValue;
    }


    public MyUserControl()
    {
      InitializeComponent();
    }

    public UIElement Testprob
    {
      set
      {
        SetValue(TestprobProperty, value);
      }
      get
      {
        return (UIElement)GetValue(TestprobProperty);
      }
    }
  }

Und in dem Hauptfenster:

<Window x:Class="WpfApplication1.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" 
        xmlns:WpfApplication1="clr-namespace:WpfApplication1" 
        Title="MainWindow" Height="350" Width="525">
    <StackPanel>
        <TextBox x:Name="TextBox1"  />
        <Grid>
        <WpfApplication1:MyUserControl 
           Testprob="{Binding ElementName=TextBox1}"/>
    </Grid>
    </StackPanel>
</Window>

Ist das so, wie du es dir gedacht hast?

Bei LINQ wird immer dann ein Zugriff auf die Datenbank ausgeführt, wenn du das Ergebnis der Abfrage direkt benötigst, beispielsweise über ToList, FirstOrDefault oder eben für das Update/Insert bei SaveChanges. LINQ ist nur eine Abfragesprache. Eine Transaktion wird höchstens durch den Dataprovider durchgeführt, auf dem du operierst.

Wenn du herausfinden willst, was genau den Deadlock verursacht, dann schau mal hier:
SQL Server Profiler für Deadlocks

Für mich sieht das soweit ganz in Ordnung aus. Ich stimme da gfoidl zu. Wieviele Nutzer führen den Zugriff über deine Methode gleichzeitig aus? Eventuell führt ein anderer gleichzeitig einen Zugriff im Sinne eines Inserts auf dieselbe Tabellen durch, wobei für diese Transaktion eine Sperre für den einen Benutzer eingerichtet wird.

Eventuell solltest du die Methode GetExistingOrders zuvor ausführen und dann die zurückgelieferte Liste der Property deines anonymen Typs aus der eigentlichen Abfrage zuweisen. Ich denke, da sind zuviele Transaktionen gleichzeitig, was zum Deadlock führen kann.

Am Besten du fängst die Exception explizit und führst die Abfrage noch einmal durch.

Eventuell hilft dir das hier weiter:
SQL Server Deadlock Workaround

Hi Dennis,

für mich klingt das so, als ob du an einer anderen Stelle die Datenbank/Tabelle durch einen Aufruf/eine Transaktion explizit sperrst. Mich würde interessieren, was du genau in den Methoden CreateDataContext und GetExistingOrders machst.

Wenn du eventuell diese posten könntest, kann ich dir weiterhelfen. Auf den ersten Blick ist das nicht für mich ersichtlich.

Chris

Hallo akunz,

für die Rahmenauswahl siehe folgendes Beispiel:
Selection Box in WPF

Wenn du wissen willst, welches Element innerhalb der Box liegt, wäre mein Vorschlag, dass du dir für jedes Element und für die Auswahlbox einen Member der Klasse Rect merkst. Sobald du im MouseMove die größe der Box neu berechnet hast, kannst du durch alle Elemente gehen und den Member Rect der Box mit den anderen Rect-Member der Elemente mittels der Methode Intersect überprüfen. Bei denen, wo das Ergebnis true ist, weißt du dass sie in dem Bereich der Box liegen.

P.S.: Für die Positionsangabe ist es wichtig, dass du diese in Relation zu einem gemeinsamen Panel machst.

Hallo Luna1987,

Ich verstehe deinen Code so, dass wenn er in den else-Zweig läuft, eine MessageBox ausgegeben werden soll. Das Problem liegt meiner Meinung nach in folgender Zeile:

if (result != null)

Deine Validate-Methode liefert niemals null zurück, sondern entweder als ValidationResult Valid oder false. Somit ist die Instanz immer != null und deshalb gibt er auch Valid zurück. Du solltest an dieser Stelle result auf Valid oder nicht valid prüfen.

Außerdem schließe ich mich gfoidl an und würde hier das Binding in XAML bevorzugen.

Hallo zusammen,

ich habe ein MDE-Gerät mit Windows CE 5.0. Dafür habe ich bereits eine WinForms Oberfläche entwickelt. Nun möchte ich mit einer Desktop-Applikation über wlan kommunizieren, das heißt, activesync fällt flach. Meine Frage ist nun, wie ich am besten die Kommunikation zwischen dem Gerät und der Applikation realisieren kann. Welche Möglichkeiten bieten sich mir an?

Danke bereits für eure Hilfe.

Hallo zusammen,

ich hätte da eine Frage:

Im .NET Framework existiert die Klasse TcpListener, die die Methode **BeginAcceptTcpClient **zur Verfügung stellt. Leider existiert diese Methode nicht für das Compact Framework (Ich arbeite mit dem Compact Framework 3.5). Gibt es eine Alternative zu dieser Methode innerhalb des CF und wenn ja, wie sieht diese aus?

Danke schon einmal für eure Hilfe.

Hallo csOffroad,

Die ActiveX Komponente hat eine PreProcessMessage-Methode, die du entsprechend "überschreiben" musst.

Ungefähr so:

[DllImport("User32.dll")]
public static extern IntPtr SendMessage(IntPtr hWnd, int Msg, IntPtr wParam, IntPtr lParam);

public override bool PreProcessMessage(ref Message m)
{
    var pressedKey = (Keys)m.WParam.ToInt32();
    if(pressedKey == Keys.Escape) 
    { 
        //control = activex control
       SendMessage(control.Handle,m.Msg,m.WParam,m.LParam);
       return true;
    }
    return base.PreProcessMessage(ref m);
}

Die Methode PreProcessMessage wird immer dann automatisch aufgerufen, wenn eine Tastatureingabe erfolgt.

Hallo m.grauber,

ich weiß jetzt nicht genau wie dein Code aussieht, aber so wie ich dich verstehe, ist ein Wert der ObservableCollection null. Hast du vielleicht in Erwägung gezogen eine Art ViewModel-Klasse zu schreiben, die die ObservableCollection als Property definiert und bei der du in den set und get Accessors expizit die Collection und deren Inhalte auf Ungültigkeiten prüfen und diese beheben lassen kannst, bevor sie schlussendlich dem Entity und damit der DB zugewiesen wird.

Ein anderer Ansatz wäre es sogenannte Selftracking Entities zu verwenden.
Standardmäßig wird die Änderung für die Entity immer mitverwaltet. Mit Selftracking Entities kannst du das Verhalten abschalten. So kannst du zunächst das Entity ohne Verwaltung durch den DB Context bearbeiten und musst dich dann aber selbst um alles kümmern.

Die dritte Möglichkeit die mir einfällt, ist das Verhalten deines Bindings zu ändern. Eventuell kannst du das Binding im Sinne der Wertänderung selbst definieren, d.h. du sagst dem Binding explizit, wann es sich aktualisieren soll. dafür gibt es spezielle Methoden auf dem Binding Objekt.

Generell solltest du vielleicht den Stück Code für die Combobox sowie für die Definition des Bindings und wo der Fehler auftritt posten, damit man das Problem schneller findet.

Hallo Abt,
vielen Dank für Deine Antwort.

In diesem Fall ist es leider nicht so, dass die Verbindung automatisch geschlossen wird.
Gibt es andere Möglichkeiten darauf zu reagieren, wenn das Browserfenster geschlossen wird?

Hallo zusammen,

ich habe folgendes Problem:

Ich habe eine ASP.net Seite die eine Datenbankverbindung zu einer db4o Datenbank öffnet.
Beim Beenden, soll die Verbindung zu Datenbank geschlossen werden.

Ich habe versucht dies über die Funktion Application_End() in der Glabal.asax zu tun. Allerdings wird diese Funktion nie aufgerufen.

Wann wird dieses Event ausgelöst, bzw wie kann ich darauf reagieren?

So ich habe das Problem endlich lösen können:

Es lag an den Build-Einstellungen meiner DB-Schnittstellen Assembly.

Ich habe einfach den Haken bei den Projekteinstellungen für Code optimieren rausgenommen und dann mit dem entsprechenden Build getestet.

Also für den Debug-Modus habe ich die DEbug-Dll verwendet und beim Release die Release-Dll.

Danke für eure Hilfe.

Hallo Wacko,

versuche mal folgendes:
Permissions on Database

was unter Resolution steht.

Es geht hier zwar um ASP.NET, aber das ist egal, die Lösung müsste für dein WinForms Problem das gleiche sein.