Kann man wohl so machen 😃 . Mit Behaviors könntest du es wiederverwendbar implementieren. Ist aber kein Muss. Wenn es so für dich funktioniert würde ich es so lassen.
Hinweis :
Die "PART_" Naming terminologie verwendet man eigentlich nur im Templating Bereich um zu signalisieren das ein Steuerelement ein Teil des Gesamten Controls ist. Du kannst das natürlich so lassen aber wollte dich da nur in Kenntnis setzen damit dir der Unterschied bewußt ist.
Der Code selbst scheint funktional zu sein, ist aber recht umständlich zu lesen. Du könntest um das ganze lesbarer zu machen deine for Schleifen in separate Methoden extrahieren und diese "UnselectItemAfterIndex(x)" oder sowas in der Richtung nennen.
Deine Spezifikation ist recht ungenau. Mousemove bedeutet du hältst den Mousebutton dabei nicht gedrückt? Beginn der Liste heißt ab dem aktuell markierten Datensatz oder wirklich erst Position? Was passiert beim scrollen? Soll der Anwendungsfall ähnlich dem im Windows Explorer beim markieren von Dateien sein? Mach dir genau Gedanken darüber was du machen möchtest und recherchiere an welche Events du dich anhängen musst.
Zur Umsetzung :
Ich würde an deiner Stelle auf Behaviors setzen. Mit Codebehind wirst du dieselbe Umsetzung immer wieder neu schreiben müssen. Mit Commands wird das ganze extrem umständlich da die Mouseevents viel zu häufig getriggert werden. Behaviors hingegen erweitern die Funktionalität eines Steuerelements und du kannst dich im Code des Behaviors an die passenden Events dran hängen. Mit Hilfe von Command DependencyProperties in deinem Behavior kannst du dich dann an Funktionalität deines Behaviors dranhängen.
Die Frage ist hier aber auch wie vertraut du mit WPF bist und wie sauber deine Umsetzung werden soll.
Zur Selektierung von Elementen in einer ListView wirst du im Netz aber bestimmt auch ein paar Beispiele und Open Source Libraries finden. Oder du setzt ggf. auf eine fertige Gratis Lösung. Auch hier gibt es ein paar gute.
<Window x:Class="MyTool.MainWindow"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:scm="clr-namespace:System.ComponentModel;assembly=WindowsBase"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:local="clr-namespace:MyTool"
Title="MyTool"
Height="300"
Width="400"
WindowStartupLocation="CenterScreen"
Icon="_Images/AppIcon.ico"
xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
d:DataContext="{d:DesignInstance Type={x:Type local:MainViewModel}}"
d:DesignHeight="300"
d:DesignWidth="300"
DataContext="{StaticResource MainViewModel}">
Am besten das in deiner View Definition hinterlegen. Wenn der Designer damit kann wird die Intellisense es auch können.
d:DataContext="{d:DesignInstance vm:MainViewModel, IsDesignTimeCreatable=true}"
Mit interfaces sollte es eigentlich keine Probleme geben sofern du kein DataTemplate mit einem Interface Datatype baust. Dabei kann es in der Tat Problematisch sein weil zur Designzeit keine Substitutes für die Interfaces erzeugt werden können.
ICommand sollte hier aber keine Probleme machen sofern. Schon gar nicht wenn sie nur einen Propertytype beschreiben 😃
Ansonsten poste mal etwas mehr von deinem Beispiel. Welche IDE nutzt du ?
d:DataContext="{d:DesignInstance vm:MyDesignTimeViewModel, IsDesignTimeCreatable=true}"
Probier das mal in deiner View oben mit einzusetzen. Das nutze ich immer wenn ich Intellisense im XAML haben möchte. Ggf. beeinflusst das auch den Designer? Genaues kann ich sonst nicht sagen ohne selbst dein Projekt zu haben. Ich arbeite selbst auch gar nicht mehr mit dem Designer.
Macht es einen Unterschied wenn du den Call base.OverridenMethod() mit in deine Methoden einbaust?
Hallo Abt,
die beiden Quellen sind schon mal super wobei ich bei Coffeebean sowieso mal in die Projekte schauen wollte.
Azure werde ich auch mal ausprobieren da gibt es ja bestimmt kostenfreie Probemöglichkeiten.
Aurelia und React werde ich mir mal anschauen und vergleichen danke dir 😃.
Zu dem was ich tun möchte:
Im Grunde genommen soll es (erstmal) eine recht einfache Online Plattform für meine eigenen Zwecke sein um F"ortschritte von bestimmten Dingen" festzuhalten und sich selbst Challenges zu setzen. Challenges und Fortschritte sollen auch schnell und leicht mit Bildern verknüpft werden können. Alles möglichst persistent und überall abrufbar. Natürlich mit netter UI. Später auch Dashboards usw. usw.
Wie gesagt möchte ich es auch eh erstmal nur intern für mich selbst nutzen um mich mit dem aktuellen Webzeug auseinander zu setzen und dann schauen ob das ganze ggf. sogar community fähig wäre. Ähnliche Plattformen gibt es da ja einige. Geht mir in diesem Fall also weniger um Erfolg sondern mehr um den Lerneffekt
Hallo zusammen,
ich bin mittlerweile viele Jahre .NET Entwickler im Client Enterprise Entwicklungsbereich (Forms/WPF) und hatte neulich eine Idee für ein Projekt welches ich gerne im Web Bereich umsetzen möchte. Zu diesem Zweck möchte ich mich gerne mit den aktuelleren Webtechnologien und Methoden auseinander setzen um zu schauen womit ich das Projekt entwickle und habe in diesem Zug häufiger von ASP.NET Core und Angular / Typescript gelesen.
In den letzten 2 Tagen habe ich mir einige Videos zu den beiden Technologien angeschaut und bin auch echt begeistert wie krass sich das ganze seit ASP.NET weiterentwickelt hat.
Mir stellen sich dennoch einige Fragen / Vorgehensweisen und wollte mal bei euch nachhören ob ihr zu meinen Themenbereichen ein paar gute Tutorial Videos / Artikel an der Hand habt die ihr empfehlen könnt weil sie euch weitergebracht haben.
Bereiche wo ich noch Informationen benötige wären:
Server:
Client:
Sonstiges:
Ich hoffe die Frage ist nicht zu allgemein gehalten oder kommt so rüber als würde ich mir Arbeit ersparen wollen. Ich möchte lediglich vermeiden mir bei "schlechten" Quellen Dinge abzuschauen und eure Erfahrungen einfließen lassen.
Es funktioniert schon so wie du dir das vorstellst.
This only applies to any custom controls you have defined
Das ist der einzige Unterschied. Ersetz deinen Button mal durch ein weiteres Custom Control und teste nochmal 😃
Die Standardcontrols von WPF neu zu definieren funktioniert nur dann global wenn du sie in der App.xaml oder den Resourcen eines gewünschten Controls einbindest. So wie du das schon richtig erkannt hast 😃.
This only applies to any custom controls you have defined i.e. classes derived from Control, directly or indirectly. You can change the default style for a standard control by deriving from it and calling DefaultStyleKeyProperty.OverrideMetadata in the static constructor, but you then have to supply the full style including ControlTemplate.
Alles andere muss explizit in der App.xaml eingebunden werden
Siehe auch : http://stackoverflow.com/questions/1228875/what-is-so-special-about-generic-xaml
Hab dir mal eine angepasste Version angehängt wo es geht.
Es ist halt wichtig zu wissen wie Resourcen in WPF ermittelt werden. Der gängige Weg mit externen Libraries ist über die Themes/Generic.xaml
Ansonsten geht es auch wenn du alle Resourcen in der App.Resources lädst
Ich suche dir gleich mal einen Artikel dazu raus
Probier mal folgendes :
// Achtung hier nicht den Static Ctor nehmen
public CustomWindow()
{
SetResourceReference(StyleProperty, typeof (CustomWindow));
}
Ansonsten würde ich deiner Vermutung zustimmen ich hatte schon einmal das gleich Problem.
Spontane Frage ohne alles 2x gelesen zu haben :
public ListenanzeigeVM Listen { get; private set; }
public DetailseiteVM Details { get; private set; }
Die werfen kein RaisePropertyChanged ... warum genau nicht ?
Ich würde dir empfehlen sowas in einem richtigen Bildbearbeitungstool zu erstellen ( dazu sind sie da ). Prinzipiell würde das garantiert auch mit WPF gehen aber es wäre ein nicht zu unterschätzender Aufwand notwendig.
Ggf. kannst du mal schauen ob es mit Blend machbar ist ( das sollte ab VS 2013 enthalten sein ).
Ansonsten einfach ein Jpg als Image in den Background einbinden.
EDIT : Anmerkung - Wenn du kein Grafiker bist macht dich WPF auch zu keinem 😃
Ich verstehe deine Intention leider noch nicht genau. Mir ist nicht klar auf Grund welcher Tatsache du welche Zahl ausgeben möchtest?
Warum addierst du die Wahrscheinlichkeiten aller bisher iterierten Elemente zusammen ?
Zu deiner eigentlich Frage. Mit LinQ kann man da bestimmt einiges eleganter machen aber ich weiß leider nicht genau was du erreichen möchtest.
Google dir mal
BindingOperations.EnableCollectionSynchronization(List, Lock);
zusammen und schau ob es damit geht 😃
Wenn du eh schon ganz sicher alle nötigen Datensätze in deinem DGV hast würde ich vermeiden einen zusätzlichen SQL Command an deinen Server zu senden
EDIT : Zu der eigentlichen Frage -> Eine Abfrage über ein Netzwerk wird nahezu immer langsamer sein als eine lokale Berechnung.
Ist auch denke ich der bessere weil flexiblere Ansatz
@Rioma
Warum behandelst du das Doubleclick nicht in der ListView und führst deine Aktionen über einen Command im ViewModel durch?
Ich habe das mal ähnlich bei nem DataGrid gemacht.
<DataGrid.InputBindings>
<MouseBinding MouseAction="LeftDoubleClick" Command="{Binding MyCommand}" />
</DataGrid.InputBindings>
In der Firma wo ich zuvor gearbeitet habe kam die Komponente zum Einsatz und man kann schon sagen, dass es damals keine mit einem ähnlichen Umfang wie diese gab.
Es kommt aber natürlich auf deine Anforderungen an und was sich dort in den letzten 3 Jahren getan hat weiß ich auch nicht genau.
Hab aber selbst eher positive Erinnerungen an die Komponente.
Hab mich trotzdem mal auf die Warteliste gesetzt. Mal sehen obs was bringt
bereits ausgebucht =(
Ich glaube wenn es in der Generic.xaml drin steht wird im jeweiligen CustomControl auch "OnApplyTemplate()" aufgerufen. Wenn das der Fall ist wird das Control korrekt eingebunden.
Wenn dies nicht der Fall ist wird es auch oft nicht korrekt eingebunden. Es gibt dafür ein paar Spezialfälle wie ich bereits erwähnte ( z.B. das Window ). Ob der Button auch dazu gehört weiß ich grade nicht aber wäre durchaus möglich.
Spezialfall deshalb weil normalerweise die Generic.xaml nur dann automatisch erkannt wird, wenn das CustomControl in derselben Assembly steckt wie die jeweilge Generic.xaml.
Das ist nen ziemlich undurchsichtiges Thema und mir fällt es grade selbst schwer das in Worte zu fassen.
Du kannst mal probieren in den Ctor deines CustomControls folgendes einzubetten :
public MyCustomControl()
{
SetResourceReference(StyleProperty, typeof (MyCustomControl));
}
Ich hab mir häufig damit geholfen zu schauen ob das OnApplyTemplate aufgerufen wird oder nicht. Wenn nein dann ist meist nochwas im argen.
Ansonsten bleib ich dabei das dein Beispiel leider auch echt überhaupt nicht Praxistauglich ist auch wenn ich durchaus verstehe das du die Details erkennen möchtest.
Hinweis: Du kannst dir vermutlich recht viel in der MahApps Library abschauen was Styling angeht.
Mir erschließt sich nicht ganz der Sinn. Was versuchst du mit dieser seltsamen Kombination zu erreichen? Ich würde erwarten, dass dein UserControl ein CustomControl enthält aber nicht selbst durch dieses definiert wird.
<views:MyUserControl x:Class="ThemeTest.Views.MyUserControl"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:views="clr-namespace:ThemeTest.Views">
<views:MyCustomControl />
</views:MyUserControl>
<[B]views:MyCustomControl[/B] x:Class="ThemeTest.Views.MyUserControl" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:views="clr-namespace:ThemeTest.Views"> </views:MyCustomControl>
Vertan ?
Ich mache es immer so, dass ich meine Controls in einer Assembly halte mit einem "DefaultTheme" über die Generic.xaml
Für jedes weitere andere Theming dieser Controls mache ich eine neue Assembly die darauf referenzieren und neue Resourcedictionaries definieren.
Wenn ich das Theme jetzt wechseln will Cleare ich mein Application Resourcedictionary und füge das neue Basisresourcedictionary aus der Theme dll hinzu.
Sonderfälle gibt es hier allerdings auch z.B. beim Themen von der Window Komponente.
Ich bin nicht sicher ob ich dich richtig verstanden habe bzw. worin genau dein Problem liegt aber vielleicht hilft dir das ja schon mal.
Im Prinzip ist das natürlich eine schöne Idee. Ohne Plan läuft sowas allerdings bekanntlich oft ins Nichts. "Man könnte" ist relativ vage auch wenn deine Absichten natürlich nobel sind. Problem des Gegenseitig etwas beibringen ist halt oft, dass eher einer den anderen voraus ist und sowas dann schnell frustrierend sein kann für denjenigen der immer der Erklärende ist.
Ich denke, dass es wie so oft an den Menschen hängt die sich für etwas zusammen tun möchten. Ich fänds daher ehrlich gesagt cool wenn du etwas von dir selbst erzählst. Ich bin schon eine Weile daran interessiert mich Hobbymäßig mehr mit Unity und Spieleprogrammierung zu beschäftigen. Ich wohne selbst auch in Köln daher wäre so "Ein Abend die Woche" prinzipiell immer gut möglich. Ich entwickle seit gut 8 Jahren in C# und würde behaupten, dass ich das meiste in der Sprache selbst kenne. Ansonsten liegen meine Schwerpunkte bisher nur in WPF/Forms, was für Unity weniger nützlich sein dürfte.
Bleibt halt der Punkt passt man menschlich und als Team gut zusammen. Man hat von dir hier im Forum noch nichts gelesen, daher wärs cool wenn du ein bisschen von dir persönlich/beruflich erzählst ( gerne auch als PN ).
Ich hab es so gelöst, dass mein TabControl eigentlich nur eine Repräsentation eines bestimmten ViewModels ist. Auch die TabItems selbst sind einzelne ViewModels.
Im CloseCommand des TabControl ViewModels bewirkte ich nur, dass meine Itemssource verändert wird und das entfernte ViewModel benachrichtigt wird, dass es geschlossen wurde. Als Parameter gebe ich das zu schließende ViewModel an.
Im TabControl hab ich dann ein eigenes ItemTemplate geschrieben welches dann wie folgt aussieht :
<TabControl.ItemTemplate>
<DataTemplate>
<Grid Cursor="Hand" VerticalAlignment="Top" Height="36">
<Grid.ColumnDefinitions>
<ColumnDefinition Width="*" />
<ColumnDefinition Width="18" />
</Grid.ColumnDefinitions>
<TextBlock Grid.Column="0" Text="{Binding MyTitle}"/>
<Button x:Name="CloseButton" Height="16" Grid.Column="1" VerticalAlignment="Top" VerticalContentAlignment="Top" HorizontalContentAlignment="Left" Margin="6,4,0,0"
Command="{Binding RelativeSource={RelativeSource FindAncestor, AncestorType=TabControl}, Path=DataContext.CloseTabItemCommand}"
CommandParameter="{Binding}">
<fa:FontAwesome FontSize="12" Icon="Times" />
<Button.Style>
<Style BasedOn="{StaticResource ChromelessButtonStyle}" TargetType="{x:Type ButtonBase}">
<Style.Triggers>
<Trigger Property ="IsMouseOver" Value="True">
<Setter Property="Foreground" Value="{DynamicResource WindowCloseButtonBackgroundBrush}"/>
</Trigger>
</Style.Triggers>
</Style>
</Button.Style>
</Button>
</Grid>
</DataTemplate>
</TabControl.ItemTemplate>
Habe jetzt zu SQLite gegriffen und bin bisher ganz zufrieden.
SqlExpress war mir für den Anwendungsfall einfach too much.
Mit SQL Compact hatte ich in letzter Zeit wegen ausgelaufener Visual Studio Unterstützung eher negatives im Kopf und wollte daher mal was anderes probieren.
Danke ich werde es mal mit SQLite probieren 😃
verwendetes Datenbanksystem: Das ist die Frage
Hallo zusammen,
ich entwickle demnächst eine kleine Anwendung für einen einzelnen Nutzer und bin derzeit auf der Suche nach einer Möglichkeit meine angefallenen Daten adäquat abzulegen und auszulesen.
Ich möchte dabei nach Möglichkeit keine drittanbieter Software installieren müssen daher würde bei mir ein SQL System generell rausfallen oder?
DLL's mit ausliefern wäre natürlich ok aber sowas wie "installieren zu zunächst bla bla" wäre schon ziemlich abturnend.
Nice 2 Have wäre die Möglichkeit ein ORM aufschalten zu können ( Dapper o.ä. ) und wenn die angefallenen Daten selbst in Dateiform irgendwo platziert werden könnten ( nicht im Netzwerk ) wäre das klasse. Eine größenbeschränkung der Datenbank wäre zwar nicht so geil aber würde ich noch in Kauf nehmen.
Vielen Dank für euren Rat 😃
Soweit ich weiß kann man beim überschreiben einer Methode nicht die Parameter ändern.
Rein theoretisch kannst du ja nen int übergeben ( in Form eines objects ) und in deiner Methode casten. Oder du machst die Methode Generisch. Aber so wie du dir das vorstellst klappt das nicht.
Hallo zusammen,
wir werden demnächst jemanden in unserer Firma haben der 1-2 Tage zum Probearbeiten kommt. Seine Schwerpunkte liegen im Bereich WPF. Unsere entwickelte Software baut sowohl auf Forms als auch WPF auf.
Wir suchen momentan nach einer Möglichkeit um dem neuen Kollegen eine angemessene Arbeitsaufgabe zu geben. Unsere eigene Software ist wohl eher nicht so geeignet, da ihm die ganzen Prozesse nicht so schnell klar werden würden und er mehr Zeit mit Lesen als alles andere verbringen würde.
Kennt jemand vielleicht eine gute Quelle für Praktikumsaufgaben oder Probeprojekte die höchstens ein paar Tage in Anspruch nehmen würden?
Wir würden durch das Probearbeiten halt gerne Erfahren wie seine Arbeitsweise aussieht. Ob er gut mit WPF und MVVM zurecht kommt und generell so vom Typ her drauf ist.
Willst du das zu Übungszwecken implementieren?
Es gibt ne Linq Extension "Reverse"
var meineBytes = new byte[15];
var reversedBytes = meineBytes.Reverse();
EDIT : Jetzt erst gesehen, dass du die ja bereits nutzt.
Einfacher wäre es mit einem Interface
public interface IHasSpecialMethod
{
void SpecialMethod();
}
Und dann Interface implementieren
public class MyForm : Form, IHasSpecialMethod
{
// ...
}
Dann brauchst du später nicht auf einen bestimmten generischen Typen casten sondern kannst einfach auf das Interface gehen.
var myFormWithInterface = this.ActiveMdiChild as IHasSpecialEvent;
myFormWithInterface.SpecialMethod();
Das ganze findest du unter dem Stichwort "Nested Class"
Ich denke GOTO ist meistens der einfache Ausweg innerhalb eines schlechten Designs.
Es wäre hilfreich zu wissen was für Technologien du überhaupt einsetzt
Kritikfähig und lernbereit sein
Das was du machen möchtest wird eigentlich durch eine BindingSource ( Stichwort .NET Binding ) abgebildet. Ich würde nicht den Weg gehen die Änderungen durch eine Klasse in ein Form schreiben zu lassen sondern dein Form auf Änderungen in der Klasse reagieren zu lassen.
Ich glaube viel eher er hat 2 verschiedene Anwendungen und will Infos von a nach b schicken
Würde spontan auf Autocode des Designers tippen.
Ggf. die DesignerSerializationVisibility vergessen zu setzen ? Public Properties die nicht im Designcode stehen sollen, sollten mit [DesignerSerializationVisibility.Hidden] desklariert werden.
Auch daran denken das alle Eigenschaften die nicht im Designer verfügbar sein sollen aber public sind auch [Browsable(false)] zu stellen
Einfach mal danach googlen
(Sagte derjenige der auf Grund fehlender Sozialkompetenz seine Katzen abgibt =)){gray}
Bei Spleen handelt es sich aber um die Hauptseite des TSG und nicht um den Shop
In der VisualTreeHelper Klasse des .NET Frameworks befindet sich eine Methode um zu ermitteln ob 2 Objekte kollidieren. Den Aufruf dieser Methode musst du allerdings selbst auslösen glaube ich. Du könntest sie z.B. aufrufen sobald sich deine Formen bewegen.
Mehr zu der Methode findest du auch im MSDN
Naja gut das hat dafür aber auch ne 30Day Trial
Und ein bisschen besser als die VS interne autodokumentation ist ghostdoc schon. Schon allein das dieser die Doku aus geerbten Interfaces übernimmt
Kannst dir dazu auch noch GhostDoc laden. Das ist ein Tool das dir zumindest grob behilflich dabei ist die Doc zu erstellen
Perfekt das wars danke dir
Folgendes Beispiel :
decimal fAnzahlAktuell = 12;
decimal fMenge = 2;
decimal fAnzahlReserviertPickpos = 0;
decimal a = ((decimal)(fAnzahlAktuell - fAnzahlReserviertPickpos)) > fMenge ? fMenge : (decimal)(fAnzahlAktuell - fAnzahlReserviertPickpos);
decimal b = (decimal)((fAnzahlAktuell - fAnzahlReserviertPickpos) > fMenge ? fMenge : (decimal)(fAnzahlAktuell - fAnzahlReserviertPickpos));
Wenn ich mit x86 kompiliere dann sind a und b beide = 2.
Wenn ich mit anycpu kompiliere ist a = 2 und b = 0
Kann mir einer erklären warum?
Achso ich verwende übrigens VS2010 , .NET 4.0 und Win 7 x64