Willkommen auf myCSharp.de! Anmelden | kostenlos registrieren
 | Suche | FAQ

Hauptmenü
myCSharp.de
» Startseite
» Forum
» Suche
» Regeln
» Wie poste ich richtig?

Mitglieder
» Liste / Suche
» Wer ist online?

Ressourcen
» FAQ
» Artikel
» C#-Snippets
» Jobbörse
» Microsoft Docs

Team
» Kontakt
» Cookies
» Spenden
» Datenschutz
» Impressum

  • »
  • Portal
  • |
  • Mitglieder
Beiträge von nicky
Thema: Wie validiere ich eine Quittung?
Am im Forum: Rund um die Programmierung

Hallo Zusammen,

wir drucken für den Anwender einen Beleg, auf welchem eine Gutschrift ausgewiesen wird. Diese Gutschrift kann sich der Besitzer des Beleges an einer Auszahlungsstelle auszahlen lassen.

An der Auszahlungsstelle soll nun überprüft werden, ob es sich bei dem Beleg um ein von uns erstellten Beleg handelt.

Ich suche jetzt nach Möglichkeiten um die Echtheit an der Auszahlungsstelle zu validieren und freue mich über eure Ideen.

Vielen Dank, nicky

Thema: Schlechte Performance des ItemsControls trotz Virtualisierung
Am im Forum: GUI: WPF und XAML

Hi, ich zeichne Button jetzt selbst, finde aber die Performance immer noch nicht optimal. Es hakelt noch immer. Anbei mal der Code, wohl des Buttons als auch des ItemsControls.

Sind hier noch Schwachpunkte hinsichtlich der Performance zu erkennen?

public class BetButtonPerformance : FrameworkElement
    {
        private const int WIDTH = 62;
        private const int HEIGHT = 62;

        protected override void OnMouseDown(MouseButtonEventArgs e)
        {
            if (!IsLocked)
            {
                IsChecked = !IsChecked;

                if (Command != null)
                    Command.Execute(CommandParameter);
                base.OnMouseDown(e);

                InvalidateVisual();
            }
        }

        protected override Size MeasureOverride(Size availableSize)
        {
            return new Size(WIDTH, HEIGHT);
        }

        protected override void OnRender(DrawingContext dc)
        {
            DrawBackground(dc);
            if (!IsLocked)
                DrawText(dc);
            else
                DrawLock(dc);
        }

        private void DrawBackground(DrawingContext dc)
        {
            var margin = 1;
            var backgroundGradient = new GradientStopCollection
                                    {
                                        new GradientStop(Color.FromArgb(255, 0xf7, 0xf6, 0xfb), 0.0),
                                        new GradientStop(Color.FromArgb(255, 0xe6, 0xe5, 0xe3), 0.5),
                                        new GradientStop(Color.FromArgb(255, 0xd3, 0xd3, 0xd3), 1.0),
                                    };
            Brush background = new LinearGradientBrush(backgroundGradient);

            if (IsChecked)
            {
                var converter = new System.Windows.Media.BrushConverter();
                background = (Brush)converter.ConvertFromString("#FF00A75D");
            }

            dc.DrawRectangle(
                background,
                null,
                new Rect(new Point(0 + margin, 0 + margin), new Size(ActualWidth - margin * 2, ActualHeight - margin * 2)));
        }

        private void DrawText(DrawingContext dc)
        {
            if (formattedText != null)
            {
                if (IsChecked)
                    formattedText.SetForegroundBrush(Brushes.White);
                else
                    formattedText.SetForegroundBrush(Brushes.Black);

                var centerPoint = new Point(WIDTH / 2, HEIGHT / 2);
                Point textLocation = new Point(centerPoint.X - formattedText.WidthIncludingTrailingWhitespace / 2, centerPoint.Y - formattedText.Height / 2);
                dc.DrawText(formattedText, textLocation);
            }
        }

        private void DrawLock(DrawingContext dc)
        {
            var margin = 20;
            var destination = new Rect(new Point(0 + margin, 0 + margin), new Size(ActualWidth - margin * 2, ActualHeight - margin * 2));

            var imageSource = new BitmapImage(new Uri(@"pack://application:,,,/Media/IconLock.png"));
            dc.DrawImage(imageSource, destination);
        }

        private FormattedText formattedText;

        public double Value
        {
            get { return (double)GetValue(ValueProperty); }
            set { SetValue(ValueProperty, value); }
        }

        public static readonly DependencyProperty ValueProperty =
             DependencyProperty.Register(
                 "Value",
                 typeof(double),
                 typeof(BetButtonPerformance),
                 new FrameworkPropertyMetadata(0d, FrameworkPropertyMetadataOptions.AffectsMeasure,
                    (o, e) => ((BetButtonPerformance)o).ValuePropertyChanged((double)e.NewValue)));

        private void ValuePropertyChanged(double value)
        {
            var typeface = new Typeface(
                new FontFamily("Segoe UI"),
                FontStyles.Normal, FontWeights.Normal, FontStretches.Normal
            );

            formattedText = new FormattedText(
                String.Format("{0:N2}", value),
                CultureInfo.CurrentCulture,
                FlowDirection.LeftToRight,
                typeface,
                16,
                Brushes.Black
            );
        }

        public bool IsChecked
        {
            get { return (bool)GetValue(IsCheckedProperty); }
            set { SetValue(IsCheckedProperty, value); }
        }

        public static readonly DependencyProperty IsCheckedProperty =
            DependencyProperty.Register("IsChecked", typeof(bool), typeof(BetButtonPerformance), new PropertyMetadata(false, IsCheckedCallback));

        private static void IsCheckedCallback(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            if (d is BetButtonPerformance)
            {
                (d as BetButtonPerformance).InvalidateVisual();
            }
        }

        public bool IsLocked
        {
            get { return (bool)GetValue(IsLockedProperty); }
            set { SetValue(IsLockedProperty, value); }
        }

        public static readonly DependencyProperty IsLockedProperty =
            DependencyProperty.Register("IsLocked", typeof(bool), typeof(BetButtonPerformance), new PropertyMetadata(false));

        public ICommand Command
        {
            get { return (ICommand)GetValue(CommandProperty); }
            set { SetValue(CommandProperty, value); }
        }

        public static DependencyProperty CommandProperty =
            DependencyProperty.Register("Command", typeof(ICommand), typeof(BetButtonPerformance));

        public object CommandParameter
        {
            get { return (object)GetValue(CommandParameterProperty); }
            set { SetValue(CommandParameterProperty, value); }
        }

        public static DependencyProperty CommandParameterProperty =
            DependencyProperty.Register("CommandParameter", typeof(object), typeof(BetButtonPerformance));
    }
<ItemsControl ItemsSource="{Binding Events}"
							Margin="0 50 0 0"
							VirtualizingStackPanel.IsVirtualizing="True" 
							VirtualizingStackPanel.VirtualizationMode="Standard">
	<ItemsControl.ItemsPanel>
			<ItemsPanelTemplate>
					<VirtualizingStackPanel/>
			</ItemsPanelTemplate>
	</ItemsControl.ItemsPanel>
	<ItemsControl.ItemTemplate>
			<DataTemplate>
					<StackPanel>
							<Grid>
									<Grid.ColumnDefinitions>
											<ColumnDefinition Width="60"/>
											<ColumnDefinition Width="70"/>
											<ColumnDefinition Width="*"/>
											<ColumnDefinition Width="*"/>
											<ColumnDefinition Width="60"/>
									</Grid.ColumnDefinitions>
									<StackPanel Grid.Column="3" Orientation="Horizontal">
											<controls:BetButtonPerformance DataContext="{Binding BetsPrimaryFirst}"
																										 Value="{Binding BetValue, Mode=OneWay}" 
																										 IsChecked="{Binding IsChecked, Mode=TwoWay}"
																										 IsLocked="{Binding IsLocked, Mode=OneWay}"
																										 Command="{Binding DataContext.ToggleBetCommand, RelativeSource={RelativeSource AncestorType=Window}, Mode=OneWay}"
																										 CommandParameter="{Binding ., Mode=OneWay}"/>
											<controls:BetButtonPerformance DataContext="{Binding BetsPrimarySecond}"
																										 Value="{Binding BetValue, Mode=OneWay}" 
																										 IsChecked="{Binding IsChecked, Mode=TwoWay}"
																										 IsLocked="{Binding IsLocked, Mode=OneWay}"
																										 Command="{Binding DataContext.ToggleBetCommand, RelativeSource={RelativeSource AncestorType=Window}, Mode=OneWay}"
																										 CommandParameter="{Binding ., Mode=OneWay}"/>
											<controls:BetButtonPerformance DataContext="{Binding BetsPrimaryThird}"
																										 Value="{Binding BetValue, Mode=OneWay}" 
																										 IsChecked="{Binding IsChecked, Mode=TwoWay}"
																										 IsLocked="{Binding IsLocked, Mode=OneWay}"
																										 Command="{Binding DataContext.ToggleBetCommand, RelativeSource={RelativeSource AncestorType=Window}, Mode=OneWay}"
																										 CommandParameter="{Binding ., Mode=OneWay}"/>
											<controls:BetButtonPerformance DataContext="{Binding BetsPrimaryFourth}"
																										 Value="{Binding BetValue, Mode=OneWay}" 
																										 IsChecked="{Binding IsChecked, Mode=TwoWay}"
																										 IsLocked="{Binding IsLocked, Mode=OneWay}"
																										 Command="{Binding DataContext.ToggleBetCommand, RelativeSource={RelativeSource AncestorType=Window}, Mode=OneWay}"
																										 CommandParameter="{Binding ., Mode=OneWay}"/>
											<controls:BetButtonPerformance DataContext="{Binding BetsPrimaryFifth}"
																										 Value="{Binding BetValue, Mode=OneWay}" 
																										 IsChecked="{Binding IsChecked, Mode=TwoWay}"
																										 IsLocked="{Binding IsLocked, Mode=OneWay}"
																										 Command="{Binding DataContext.ToggleBetCommand, RelativeSource={RelativeSource AncestorType=Window}, Mode=OneWay}"
																										 CommandParameter="{Binding ., Mode=OneWay}"/>
											<controls:BetButtonPerformance DataContext="{Binding BetsPrimarySixth}"
																										 Value="{Binding BetValue, Mode=OneWay}" 
																										 IsChecked="{Binding IsChecked, Mode=TwoWay}"
																										 IsLocked="{Binding IsLocked, Mode=OneWay}"
																										 Command="{Binding DataContext.ToggleBetCommand, RelativeSource={RelativeSource AncestorType=Window}, Mode=OneWay}"
																										 CommandParameter="{Binding ., Mode=OneWay}"/>
									</StackPanel>
							</Grid>
							<Rectangle Margin="0 0 0 2" Height="0.5" Fill="Gray"/>
					</StackPanel>
			</DataTemplate>
	</ItemsControl.ItemTemplate>
	<ItemsControl.Template>
			<ControlTemplate>
					<Border BorderThickness="{TemplateBinding Border.BorderThickness}"
									Padding="{TemplateBinding Control.Padding}"
									BorderBrush="{TemplateBinding Border.BorderBrush}"
									Background="{TemplateBinding Panel.Background}"
									SnapsToDevicePixels="True">
							<ScrollViewer IsDeferredScrollingEnabled="False" 
														CanContentScroll="True" 
														Padding="{TemplateBinding Padding}">
									<ItemsPresenter SnapsToDevicePixels="{TemplateBinding UIElement.SnapsToDevicePixels}"/>
							</ScrollViewer>
					</Border>
			</ControlTemplate>
	</ItemsControl.Template>
</ItemsControl>

Thema: Schlechte Performance des ItemsControls trotz Virtualisierung
Am im Forum: GUI: WPF und XAML

Hallo unconnected, danke die Release Version macht jedoch ähnliche Probleme.

Hallo ThomasE., was genau meinst du mit selber zeichnen, hast du da ein Beispiel?

Thema: Schlechte Performance des ItemsControls trotz Virtualisierung
Am im Forum: GUI: WPF und XAML

Hallo,

die Performance meines ItemsControls ist schlecht. Ich habe ein recht komplexes Template und versuche das bereits zu vereinfachen. Mein erster Eindruck ist jedoch das hier nicht viel zu holen ist, jedes Item besteht aus einigen Steuerelementen und Bindings.

Ich habe die Virtualisierung des ItemsControl bereits ausprobiert.

Mit Virtualisierung: Schnelles initiales Laden, sehr hakliges scrollen
Ohne Virtualisierung: Langsames initiales Laden, flüssiges scrollen

Beides ist auf Grund der Nachteile nicht wirklich brauchbar.

Ich suche einen Kompromiss. Zu Beginn möchte ich durch Virtualisierung ein schnelles Laden erreichen. Es werden also nur die Items in den Arbeitsspeicher geladen die auch tatsächlich angezeigt werden. Danach sollen die restlichen Items im Hintergrund in den Arbeitsspeicher geladen werden, sodass das Scrollen flüssig geschehen kann.

Hat jemand eine Idee oder kennt ein Control was das so oder so ähnlich umsetzt?

nicky

Thema: PrintDocument - Drucken, TabStopp bei Linebreak berücksichtigen
Am im Forum: Rund um die Programmierung

Also ich habe mir jetzt geholfen indem ich nicht mehr einen String, sondern zwei Strings drucken pro Zeile:

Aus:
"Vorname:\tThomas ABCDEFGHIJK..."

Wird:
"Vorname:"
"Thomas ABCDEFGHIJK..."

Beim ersten erhöhe ich den Y Wert nicht damit der zweite Wert in der selben Zeile ist und den zweiten Werte drucke ich mit einem X-Offset in Höhe des Tabstopps. Naja, geht aber mich würde eine andere Lösung trotzdem interessieren!

Thema: PrintDocument - Drucken, TabStopp bei Linebreak berücksichtigen
Am im Forum: Rund um die Programmierung

Hi !

Ich nutze PrintDocument um eine Quittung mit einem TSP100-Drucker zu drucken.

Meine Methode druckt Text linksbündig. Wenn der Text zu lang ist, wird dieser umgebrochen. Das entsprechende Rectangle berechne ich mit MeasureString.

Aktuelles Ergebnis, keine Überlänge:


String: "Vorname:\tThomas..."

Vorname:        Thomas

Aktuelles Ergebnis, Überlänge:

String: "Vorname:\tThomas ABCDEFGHIJK..."

Vorname:        Thomas ABCD
EFGHIJK

Wunschergebnis:

String: "Vorname:\tThomas ABCDEFGHIJK..."

Vorname:        Thomas ABCD
                EFGHIJK

Die Frage ist, wie gehe ich vor damit der TabStopp auch beim Zeilenumbruch berücksichtigt wird?

        private void PrintTextLeft(Graphics g, string headline, ref float yPostion, Font customFont = null)
        {
            StringFormat stringFormat = new StringFormat();
            stringFormat.LineAlignment = StringAlignment.Near;
            stringFormat.Alignment = StringAlignment.Near;
            stringFormat.SetTabStops(0.0f, formatTabs);

            var font = (customFont == null) ? GetFont() : customFont;
            SizeF sizeF = g.MeasureString(headline, font, WIDTH);

            g.DrawString(headline, font, Brushes.Black, new RectangleF(new PointF(0, (int)yPostion), new Size(WIDTH, (int)yPostion)), stringFormat);
            yPostion += sizeF.Height;
        }

Thema: Win 10: Benachrichtigung "Das Programm funktioniert nicht mehr" trotz handling Unhandled Exceptions
Am im Forum: GUI: WPF und XAML

Hi, das passiert leider nur bei einem Client, daher konnte ich es bisher nicht debuggen. Vielleicht sollte ich mir mal Remote Debugging ansehen :)

Thema: Win 10: Benachrichtigung "Das Programm funktioniert nicht mehr" trotz handling Unhandled Exceptions
Am im Forum: GUI: WPF und XAML

Hallo, ich beobachte seit heute ein seltsames Problem welches ich allerdings bisher nur auf Windows 10 Rechnern feststellen konnte und komischerweise auch nicht immer.

Es gibt den Fall das eine Unhandled Exception auftritt, in diesem Fall starte ich das Programm neu, soviel erstmal als Nebeninformation. Unhandled Exceptions fange ich wie folgt ab:

        public void App_Startup(object sender, StartupEventArgs e)
        {
            AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(OnUnhandledException);
            Dispatcher.UnhandledException += OnDispatcherUnhandledException;
            DispatcherUnhandledException += OnDispatcherUnhandledException;
        }

        private void OnUnhandledException(object sender, UnhandledExceptionEventArgs e)
        {
             // Code zum Restart + Enviroment.Exit(1)
        }

        private void OnDispatcherUnhandledException(object sender, System.Windows.Threading.DispatcherUnhandledExceptionEventArgs e)
        {
             // Code zum Restart + Enviroment.Exit(1)
        }

Damit konnte ich bisher die Windows Benachrichtigung "Das Programm funktioniert nicht mehr" unterdrücken. Auf besagtem Windows 10 Rechner kommt die Meldung trotzdem. Hat jemand eine Idee?

nicky

Thema: Addierer mit Übertragsauswahl (Carry Select Adder)
Am im Forum: Smalltalk

Hallo Zusammen,

jetzt hat es mich doch mal getroffen und ich muss mir einige Basics aneignen. Leichter gesagt als getan!

Ich habe also einige logische Schaltungen entworfen und stehe jetzt bei Zusatzaufgabe zum Carry Select Adder.

Zunächst sollten wir die Tiefe von einem Volladdiere, einem Multiplexer und einem Carry Select Adder beschreiben. Das war noch recht einfach, denn die habe ich nachgebaut und konnte es einfach abzählen. Bei den Zusatzaufgaben hab ich jedoch Probleme.

Wie groß ist die Tiefe eines 2k-Bit Addierer mit Übertragsauswahl?

Wie groß ist die Tiefe eines 2k-Bit Addierer mit Übertragsauswahl, wenn die Addierer LOW;HIGH0;HIGH1 durch 2k^-1 Bit Addierer mit Übertragsauswahl realisiert werden?


Wofür steht 2k und wie unterscheidet sich ein 2k-Bit Addierer mit Übertragsauswahl von einem "einfachen" Addierer mit Übertragsauswahl.

Danke für eure Hilfe, ich bin für jeden kleinen Lösungstipp dankbar! :) nicky

Thema: WebClient mitloggen wieviel Bytes tatsächlich runtergeladen wurden
Am im Forum: Web-Technologien

Der Tipp die Kompression manuell durchzuführen war glaub ich ganz gut, hier meine aktuelle Lösung:

using System;
using System.IO;
using System.IO.Compression;
using System.Net;

namespace TestCompressionDownload
{
    class Program
    {
        static void Main(string[] args)
        {
            var url = "http://www.example.com/program.xml";

            GZipWebClient webClient = new GZipWebClient();
            var compressed = webClient.DownloadData(url);
            var uncompressed = Decompress(compressed);

            ByteArrayToFile("foo.xml", uncompressed);

            Console.WriteLine("File compressed: {0}", BytesToMegabytesAsText(compressed.Length));
            Console.WriteLine("File uncompressed: {0}", BytesToMegabytesAsText(uncompressed.Length));
            Console.ReadLine();
        }

        static byte[] Decompress(byte[] gzip)
        {
            using (GZipStream stream = new GZipStream(new MemoryStream(gzip), CompressionMode.Decompress))
            {
                const int size = 4096;
                byte[] buffer = new byte[size];
                using (MemoryStream memory = new MemoryStream())
                {
                    int count = 0;
                    do
                    {
                        count = stream.Read(buffer, 0, size);
                        if (count > 0)
                        {
                            memory.Write(buffer, 0, count);
                        }
                    }
                    while (count > 0);
                    return memory.ToArray();
                }
            }
        }

        static bool ByteArrayToFile(string filename, byte[] byteArray)
        {
            using (var fs = new FileStream(filename, FileMode.Create, FileAccess.Write))
            {
                fs.Write(byteArray, 0, byteArray.Length);
                return true;
            }
        }

        static string BytesToMegabytesAsText(long length)
        {
            var mb = (length / 1024f) / 1024f;
            return String.Format("{0} MB", mb);
        }
    }

    public class GZipWebClient : WebClient
    {
        protected override WebRequest GetWebRequest(Uri address)
        {
            HttpWebRequest httpRequest = base.GetWebRequest(address) as HttpWebRequest;
            httpRequest.AutomaticDecompression = DecompressionMethods.None;
            httpRequest.Headers.Add("Accept-Encoding", "gzip,deflate");
            return httpRequest;
        }
    }
}

// Edit: Es ist natürlich sinnvoll nicht jede Datei zu dekomprimieren. Eine Abfrage könnte so aussehen:

                GZipWebClient webClient = new GZipWebClient();
                var data = webClient.DownloadData(link);
                var bytesDownloaded = data.Length;
                if (webClient.ResponseHeaders["Content-Encoding"] == "gzip")
                {
                    data = DecompressGzip(data);
                }
                ByteArrayToFile(filename, data);

Thema: WebClient mitloggen wieviel Bytes tatsächlich runtergeladen wurden
Am im Forum: Web-Technologien

Ich möchte wissen wie viele Bytes tatsächlich übertragen werden um zu überwachen, wie viel Traffic mein Tool verursacht.

Hintergrund ist, dass das Tool auf PCs mit Trafficbeschränkung läuft.

Thema: WebClient mitloggen wieviel Bytes tatsächlich runtergeladen wurden
Am im Forum: Web-Technologien

Ich möchte den Traffic mitschreiben. Content-Length liefert -1 wenn man die Kompression verwendet. Ich glaube das liegt daran, dass es in Chunks übermittelt wird.

Thema: WebClient mitloggen wieviel Bytes tatsächlich runtergeladen wurden
Am im Forum: Web-Technologien

Das hört sich vielversprechend an, ich schau es mir mal an! :)

Thema: WebClient mitloggen wieviel Bytes tatsächlich runtergeladen wurden
Am im Forum: Web-Technologien

Danke für deinen Input, aber wie ich an die tatsächlichen Bytes komme ist mir immernoch ein Rätsel. Hier war mein Versuch aber so erhalte ich auch nur wieder den dekomprimierten Wert.

    class HTTPDownload
    {
        public static long Download(string url, string destination)
        {
            HttpWebRequest httpRequest = (HttpWebRequest)WebRequest.Create(url);
            httpRequest.AutomaticDecompression = DecompressionMethods.Deflate | DecompressionMethods.GZip;
            httpRequest.Method = WebRequestMethods.Http.Get;

            HttpWebResponse httpResponse = (HttpWebResponse)httpRequest.GetResponse();
            Stream httpResponseStream = httpResponse.GetResponseStream();

            int bufferSize = 1024;
            byte[] buffer = new byte[bufferSize];
            int bytesRead = 0;

            long length = 0;
            FileStream fileStream = File.Create(destination);
            while ((bytesRead = httpResponseStream.Read(buffer, 0, bufferSize)) != 0)
            {
                length += bytesRead;
                fileStream.Write(buffer, 0, bytesRead);
            }

            return length;
        }
    }

Thema: WebClient mitloggen wieviel Bytes tatsächlich runtergeladen wurden
Am im Forum: Web-Technologien

Hi, ich verwende WebClient für den Download einer Xml Datei. Mein Request akzeptiert Kompression und der Webserver liefert diese auch. Jetzt möchte ich mitschreiben wie viel bytes ich tatsächlich runterlade. Mit dem WebClient komm ich bisher nur an die "uncompressed bytes". Hat jemand eine Idee wie ich herausfinde, wie viel "compressed bytes" ich runterlade?

using System;
using System.Net;

namespace Test_Downloader
{
    class Program
    {
        static void Main(string[] args)
        {
            using (var client = new CustomWebClient())
            {
                client.DownloadProgressChanged += Client_DownloadProgressChanged;
                var url = "http://www.example.com/foo.xml";
                client.DownloadFileAsync(new Uri(url), "bar.txt");
            }
            Console.ReadLine();
        }

        private static void Client_DownloadProgressChanged(object sender, DownloadProgressChangedEventArgs e)
        {
            //Console.WriteLine("downloaded bytes: {0}", (int)e.BytesReceived);
            Console.WriteLine("downloaded total bytes: {0}", (int)e.TotalBytesToReceive);
        }
    }

    class CustomWebClient : WebClient
    {
        protected override WebRequest GetWebRequest(Uri address)
        {
            HttpWebRequest request = base.GetWebRequest(address) as HttpWebRequest;
            request.AutomaticDecompression = DecompressionMethods.Deflate | DecompressionMethods.GZip;
            return request;
        }
    }
}

Thema: Wie dekodiere ich Hex Datensatz ohne zusätzliche Informationen
Am im Forum: Rund um die Programmierung

Hallo, gegeben ist folgender Datensatz:

hex: 28-FB-AA-B1-DB-12-F4-7E-B5-77-97-B5-08-00-00-00

Dieser soll entsprechend dekodiert werden, sodass eine für Menschen lesbare Zeichenfolge entsteht. Der erwartete Output fängt mit "026900..." an und hat insgesamt 30 Zeichen.

Es für mich Neuland aber ich befürchte schon das meine Frage relativ naiv ist: Kann ich aus den vorliegende Daten ohne weitere Informationen erkennen wie diese kodiert wurden? Falls nicht, welche zusätzlichen Informationen benötige ich bzw. wie gehe ich vor?

Ich habe natürlich schon mal ein wenig rum gespielt aber habe bisher nur kryptischen Output erhalten.

Vg, nicky

Thema: WPF Anwendung hat nur unter Windows XP Memory Leaks
Am im Forum: GUI: WPF und XAML

Ja. Ich rufe zum teste regelmäßig GC.Collect() auf und nehme an, dass sich der RAM dadurch nicht von 50mb auf 250mb erhöhen sollte.

Thema: WPF Anwendung hat nur unter Windows XP Memory Leaks
Am im Forum: GUI: WPF und XAML

Zitat von MrSparkle
Welche Anhaltspunkte hast du für diese Vermutung?

Ich kann den Fehler lediglich in der Kombination Windows XP + .NET 4 feststellen. Auf meinem Dev-PC [Windows 8] ist der Leak nicht nachzuvollziehen. Also meine Vermutung beruht eher auf dem Ausschlussverfahren.

Ja ich lese immer noch und bin für jeden weiteren konkreten Hinweis sehr dankbar!

Thema: Durch Button neue View öffnen ohne eigenes Fenster
Am im Forum: GUI: WPF und XAML

Hi, ich würde ebenfalls ein ContentControl verwenden und die .Content Eigenschaft mit dem jeweiligen ViewModel überschreiben.

ContentControl.Content = new PersonViewModel();

Dafür ist es jedoch noch notwendig das View an das ViewModel zu mappen.
        
<Application.Resources>
  <DataTemplate DataType="{x:Type viewModel:PersonViewModel}">
    <view:PersonView/>
  </DataTemplate>
</Application.Resources>

Thema: WPF Datagrid: Spalten immer an Fenstergröße anpassen
Am im Forum: GUI: WPF und XAML

Hi, doch geht immer noch! :)

Thema: WPF/XAML: Default-Binding bei einer Klasse
Am im Forum: GUI: WPF und XAML

Hi ! Die Änderung siehst du nicht, weil OnPropertyChanged nach der Änderung nicht aufgerufen wird. Du musst dem View mitteilen, dass es Änderungen innerhalb der "nested properties" gab. Beispielsweise könntest du nach der Änderung MyProperty neu setzen.

Thema: WPF Datagrid: Spalten immer an Fenstergröße anpassen
Am im Forum: GUI: WPF und XAML

Hi, zeig mal mehr von deinem Code. Bei mir wird die Spaltenbreite unabhängig von der CanUserAddRows Property entsprechend der Window Width aufgeteilt.

<Window x:Class="debug.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:local="clr-namespace:debug"
        mc:Ignorable="d"
        Title="MainWindow" Height="350" Width="525">
    <Window.Resources>
        <Style x:Key="mainGrid" TargetType="{x:Type DataGrid}">
            <Setter Property="ColumnWidth" Value="*" />
            <Setter Property="AutoGenerateColumns" Value="False" />
            <Setter Property="IsReadOnly" Value="False" />
            <Setter Property="CanUserAddRows" Value="True" />
            <Setter Property="CanUserResizeColumns" Value="True" />
            <Setter Property="GridLinesVisibility" Value="none" />
            <Setter Property="BorderBrush" Value="Transparent" />
            <Setter Property="RowHeaderWidth" Value="0" />
            <Setter Property="HorizontalAlignment" Value="Stretch" />
            <Setter Property="VerticalAlignment" Value="Stretch" />
            <Setter Property="MinRowHeight" Value="50" />
        </Style>
    </Window.Resources>
    <Grid>
        <DataGrid Style="{StaticResource mainGrid}" ItemsSource="{Binding Items}">
            <DataGrid.Columns>
                <DataGridTextColumn Binding="{Binding Name}"/>
                <DataGridTextColumn Binding="{Binding Street}"/>
                <DataGridTextColumn Binding="{Binding Postal}" />
                <DataGridTextColumn Binding="{Binding City}" />
            </DataGrid.Columns>
        </DataGrid>
    </Grid>
</Window>

Thema: WPF Anwendung hat nur unter Windows XP Memory Leaks
Am im Forum: GUI: WPF und XAML

Ich habe mich jetzt mehrmals am Profiling versucht aber finde keine signifikanten Unterschiede im Vergleich zweier Snapshots. Bin mir aber auch ehrlich gesagt unsicher ob ich es richtig interpretiere.

Das Problem tritt ja nur unter Windows XP auf. Das macht es nicht grad einfacher. Ich hatte jetzt das Glück noch zwei andere Entwickler zu befragen. Der Fehler wurde nicht dem Quelltext zugeordnet und es scheint als wäre das ein Bug des Frameworks, welcher nur unter Windows XP zu Vorschein kommt.

Thema: WPF Anwendung hat nur unter Windows XP Memory Leaks
Am im Forum: GUI: WPF und XAML

Hi, also ich habe ein ContentControl dessen Content Eigenschaft ich rotierend mit unterschiedlichen Views überschreibe. In Rahmen meiner Fehlersuche habe ich folgendes Szenario erstellt:

  • Neues View alle 5 Sekunden
  • Es wird immer das gleiche View angezeigt (jedoch immer eine neue Instanz)
  • Aufruf GC.Collect bei jedem View-Wechsel (nur während der Fehlersuche)

Jetzt habe ich zwei Tests gemacht:
1. View

<UserControl><Grid></Grid></UserControl>
Kein Leak!

2. View

<UserControl><Grid><TextBlock Text="Test"/><TextBlock Text="95.300.900"/></Grid></UserControl>
Speicher von 30mb auf 50mb in 5min. (Nur auf Windows XP!)

8o

Thema: WPF Anwendung hat nur unter Windows XP Memory Leaks
Am im Forum: GUI: WPF und XAML

Ja schon ausprobiert, liegt wohl nicht am Framework

Thema: WPF Anwendung hat nur unter Windows XP Memory Leaks
Am im Forum: GUI: WPF und XAML

Hi, ich habe eine .NET 4 Anwendung geschrieben, welche im Kiosk-Mode läuft. Unter anderem wird auf den Client-PCs Windows XP eingesetzt. Hierbei kann ich beobachten, dass über einen Zeitraum von 24 Stunden der genutzte Arbeitsspeicher von 60mb auf 120mb ansteigt. Unter Windows 8 kann ich das nicht feststellen.

Ich habe auf meinem Dev-PC zwei Snapshots des Heaps verglichen (Zeitraum drei Stunden). Hierbei ist nichts zu erkennen.

Wie gehe ich jetzt vor bzw. welche Möglichkeiten habe ich diesen Leak auf den Client-PCs zu finden?

nicky

Thema: ASP.NET Azure Hosting - Automatisches Datenbank Backup
Am im Forum: Web-Technologien

Sollte ich mich vielleicht von dem Gedanken lösen ein automatisiertes Backup zu erstellen und auf meiner lokalen Festplatte zu speichern? :)

Thema: ASP.NET Azure Hosting - Automatisches Datenbank Backup
Am im Forum: Web-Technologien

Hallo,

die Azure-Backup Funktionen bieten aber keine Möglichkeit einen dump der Datenbank automatisiert runterzuladen oder habe ich etwas übersehen?

Viele Grüße, nicky

Thema: ASP.NET Azure Hosting - Automatisches Datenbank Backup
Am im Forum: Web-Technologien

Hallo,

um meine Projekte zu dokumentieren habe ich mir eine ASP.NET MVC Anwendung erstellt. Es ist mein erstes ASP.NET MVC Projekt und ich hoste die Anwendung bei Microsoft Azure. Ich nutze eine SQL Datenbank und den Blob Storage.

Jetzt würde ich die Datenbank gerne automatisch sichern, nur wie?. Ich könnte mir vorstellen das Backup im Blob Storage abzulegen und ggf. als Download bereitzustellen.

Würde gerne mal ein paar Anregungen dazu sammeln, vielleicht hat das ja jemand schon mal zu umgesetzt?

Viele Grüße, nicky

Thema: Image Binding und anschließend wieder freigeben
Am im Forum: GUI: WPF und XAML

Hallo,

kann ich ein Bild, während es noch angezeigt wird, wieder freigeben und ggf. auch löschen?

Ich hab dazu folgenden Converter gefunden:

using System;
using System.Globalization;
using System.Windows.Data;
using System.Windows.Media.Imaging;

namespace Popcorn.Converters
{
    /// <summary>
    /// Used to check if the path to the image file is empty or not
    /// </summary>
    public class UriToCachedImageConverter : IValueConverter
    {
        /// <summary>
        /// Convert a path image to a bitmap-cached image
        /// </summary>
        /// <param name="value">The value produced by the binding source.</param>
        /// <param name="targetType">The type of the binding target property.</param>
        /// <param name="parameter">The converter parameter to use.</param>
        /// <param name="culture">The culture to use in the converter.</param>
        /// <returns>Cached image</returns>
        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
        {
            if (string.IsNullOrEmpty(value?.ToString())) return null;
            var path = value.ToString();
            var bi = new BitmapImage();
            bi.BeginInit();
            bi.UriSource = new Uri(path);
            bi.CacheOption = BitmapCacheOption.OnLoad;
            bi.EndInit();
            return bi;
        }

        /// <summary>
        /// Not supported
        /// </summary>
        /// <param name="value">The value produced by the binding source.</param>
        /// <param name="targetType">The type of the binding target property.</param>
        /// <param name="parameter">The converter parameter to use.</param>
        /// <param name="culture">The culture to use in the converter.</param>
        public object ConvertBack(object value, Type targetType, object parameter,
            CultureInfo culture)
        {
            throw new NotSupportedException();
        }
    }
}

Leider scheint das nicht immer zu funktionieren. Ich erhalte trotzdem manchmal die Exception:
Fehler
System.IO.IOException: The process cannot access the file '...Template\Images\Terminal.jpg' because it is being used by another process.

Jemand dazu eine Idee?