• Du befindest Dich hier:
• Community
• »
• Mitglieder
• »
• Zicore
• »
• Beiträge von Zicore

Das Manipulieren einzelner Pixel macht man tatsächlich besser mit Get- und Setpixel, allerdings sind die Standard Methoden viel zu langsam.

Siehe auch: GetPixel und SetPixel um Längen geschlagen. 800 mal schneller

Hier ein Projekt von mir welches dir vielleicht als Beispiel dienen kann: Perlin Noise Textur Generierung

So oder so wirst du dich mit den Grundlagen der jeweiligen Plattform vertraut machen müssen ob HTML und JavaScript oder .Net Framework und C#.

Im Prinzip wurden dir die nötigen Tipps genannt um durchzustarten.

Hier nochmal kurz:

- Starte ein WinForms Projekt.
- Erzeuge dir ein Panel.
- DoubleBuffered im Panel einschalten.
- OnPaint überschreiben oder Paint Event abonnieren und los Zeichnen.

Edit: Zum Thema Performance. C# setzt zumindest bei WinForms auf die GDI+ API von Windows. Die ist mittlerweile in die Jahre gekommen und nicht das schnellste. Für die meisten Dinge reicht es allerdings noch.

Bei JavaScript hängt es stark vom Browser bzw. dessen JavaScript Engine ab. Chrome ist beispielsweise deutlich schneller als Firefox.

Wie wäre es mit JavaScript und Canvas?

http://www.w3schools.com/html/html5_canvas.asp

Ich kann meinen Vorrednern nur zustimmen. Lerne die Basics mit deiner Ausgabe oder mit dem 2012er Openbook und anhand von kleinen Projekten.

Das Internet ist voll von Wissen zu dem Thema C# und .Net.

Wenn es spezifischer wird, kann man später immer noch zum Buch greifen oder zunächst mal fragen.

Trotzdem würde ich dir die aktuelle Version von Visual Studio empfehlen, also derzeit 2015.

Damit kannst du direkt die neuen Features von C# kennenlernen und verwenden.

Ich hatte mal Avast vor einem Upgrade drauf und danach diverse Probleme mit Windows, Lösung war es Avast zu deinstallieren und Avast dann neu zu installieren.

Ja

Ich habe vor kurzem das Update 3 RC für VS 2015 installiert.
Bisher keine Probleme, bis ich heute das Threads Fenster gebraucht habe.

Kann mir jemand sagen ob Ihr das Threads Fenster unter Debuggen-> Fenster -> Threads öffnen könnt?

(Kann man nur bei während des Debuggings öffnen).

Sobald ich es versuche zu öffnen erhalte ich:

Nein, aber weil:

Mir ist noch ein Problem in der GUI aufgefallen.

Beim Exporter kommt es wenn man ein bischen rumklickt.

Bei der Farbe u.A. wenn man Pfeiltasten Hoch und Runter verwendet.

Innerhalb dieses Projekt habe ich nun die Seite http://bitcoinreflection.com/ online genommen.

Diese zeigt ein echtzeit Kerzen-Diagramm zu den aktuellen Bitcoin Kursen, ein Orderbook und die letzten 50 Trades.

Der Download in der Menüleiste verlinkt noch auf Version 0.9.10.

Auf dem Bild sind Angular Controller und Razor Partials (Views), das können in Zukunft noch Angular Partials werden, aber das sollte noch kein Problem darstellen.

Der Hub wird in einem Service bzw. einer Factory bereitgestellt.

Im Controller binde ich mich an das on Event des Hubs und dieses Event wird pro Controller ausgeführt, immer wenn der Hub Daten sendet und damit das model nicht für die falsche View geschrieben wird muss ich diese Abfrage machen:

if (data.exchange === $attrs.exchange && data.Pair.Key === $attrs.pair) {
    $scope.ticker = data;
}

'use strict';

app.controller('ExchangeController', ['$scope', 'backendHubProxy','$attrs',
  function ($scope, backendHubProxy, $attrs) {

      console.log('trying to connect to service');
      var tickerHub = backendHubProxy(backendHubProxy.defaultServer, 'ExchangeHub');
      console.log('connected to service');

      $scope.tickerHub = tickerHub;

      //------------------

      tickerHub.on('updateTicker', function (data) {
          if (data.exchange === $attrs.exchange && data.Pair.Key === $attrs.pair) {
              $scope.ticker = data;
          }
      });

      tickerHub.start().done(function () {
          var args = [$attrs.exchange, $attrs.pair];
          tickerHub.invoke('RequestTicker', args, function (data) { });
      });

      //------------------

      tickerHub.on('updateTrade', function (data) {
          if (data.exchange === $attrs.exchange) {
              $scope.trades = data.trades;
          }
      });

      tickerHub.start().done(function () {
          var args = [$attrs.exchange, $attrs.pair];
          tickerHub.invoke('RequestTrade', args, function (data) { });
      });

      //------------------

      tickerHub.on('updateBalance', function (data) {
          if (data.exchange === $attrs.exchange) {
              $scope.balances = data.balances.Items;
          }
      });

      tickerHub.start().done(function () {
          var args = [$attrs.exchange, $attrs.pair];
          tickerHub.invoke('RequestBalance', args, function (data) { });
      });
  }
]);

'use strict';

app.factory('backendHubProxy', ['$rootScope', 'backendServerUrl',
  function ($rootScope, backendServerUrl) {

      function backendFactory(serverUrl, hubName) {
          var connection = $.hubConnection(backendServerUrl);
          var proxy = connection.createHubProxy(hubName);

          var hubStart = null;

          var hub = {
              on: function (eventName, callback) {
                  proxy.on(eventName, function (result) {
                      $rootScope.$evalAsync(function () {
                          if (callback) {
                              callback(result);
                          }
                      });
                  });
              },
              invoke: function (methodName, args, callback) {
                  proxy.invoke.apply(proxy, $.merge([methodName], args))
                      .done(function (result) {
                          $rootScope.$evalAsync(function () {
                              if (callback) {
                                  callback(result);
                              }
                          });
                      });
              },
              start: function () {
                  if (hubStart === null) {
                      hubStart = connection.start();
                  }
                  return hubStart;
              }
          };
          return hub;
      };

      return backendFactory;
  }]);

Das Grundproblem ist, dass das Model im Controller überschrieben wird, wenn ich die Abfrage mit

if (data.id === $attrs.exchange)

Ich habe eine View die mehrfach auf einer Seite angezeigt werden kann.
Zudem habe ich ein Angular Controller der sich um diese View kümmern soll.

Meine Merkmale sind die @Model.Id und @Model.Pair.Key. Die kann ich auch dem Hub übergeben und bekomme die entsprechenden Daten, aber wie bekomme ich die Daten in models.ticker nur für die entsprechende View?

Ich verwende die $attrs um die Parameter im vorraus festzulegen und die Lösung funktioniert zwar, erscheint mir aber nicht sehr elegant.

Zudem muss ich die Daten derzeit Serverseitig zyklisch bereitstellen. Aber das ist ein anderes Problem.

Gibt es da eine bessere Lösung?

@using IntTrader.API;
@inherits Nancy.ViewEngines.Razor.NancyRazorViewBase<IntTrader.Web.Model.ExchangeModel>

<div class="col-xs-4 col-sm-2 placeholder" ng-controller="ExchangeController" data-exchange="@Model.Id" data-pair="@Model.Pair.Key">
    <h3 class="blue"><a href="/markets/@Model.Name.ToLower()">@Model.Name</a></h3>
    <div class="modal-title" ng-model="models.ticker">{{models.ticker.lastPrice}}</div>
    <div class="center-block">
        <table class="trades" id="[email protected]"></table>
    </div>
</div>

'use strict';

app.controller('ExchangeController', ['$scope', 'backendHubProxy','$attrs',
  function ($scope, backendHubProxy, $attrs) {

      console.log('trying to connect to service');
      var tickerHub = backendHubProxy(backendHubProxy.defaultServer, 'TickerHub');
      console.log('connected to service');

      $scope.tickerHub = tickerHub;

      tickerHub.on('update', function(data) {
          console.log($scope.exchange);
          if (data.id === $attrs.exchange){
              $scope.models = {
                  ticker: data
              };
          }
      });
  }
]);

'use strict';

app.factory('backendHubProxy', ['$rootScope', 'backendServerUrl',
  function ($rootScope, backendServerUrl) {

      function backendFactory(serverUrl, hubName) {
          var connection = $.hubConnection(backendServerUrl);
          var proxy = connection.createHubProxy(hubName);

          connection.start().done(function () { });

          var hub = {
              on: function(eventName, callback) {
                  proxy.on(eventName, function(result) {
                      $rootScope.$apply(function() {
                          if (callback) {
                              callback(result);
                          }
                      });
                  });
              },
              invoke: function(methodName, p1, p2, callback) {
                  proxy.invoke(methodName, p1, p2)
                      .done(function(result) {
                          $rootScope.$apply(function() {
                              if (callback) {
                                  callback(result);
                              }
                          });
                      });
              }
          };
          return hub;
      };

      return backendFactory;
  }]);

Kann ich bestätigen, habe das gleiche Phänomen.

Du kannst einfach alle Buttons auf die gleiche Methode binden. Auch im Designer, dazu musst du lediglich die entsprechende Methode bei dem Event auswählen.

Hast du denn das Zielframework auf mindestens Net 4.5 umgestellt?

Hallo zusammen,

Diesmal wieder ein größeres Projekt.

Es handelt sich dabei um eine API die diverse Cryptocurrency Markt APIs unter einer zusammenführen soll.
Das ganze befindet sich stark in Entwicklung und ist in mehrere Module aufgeteilt.

IntTrader.API welche die eigentlich Abstraktion der Märkte darstellt. Derzeit teilweise implementiert sind Bitfinex.com und Kraken.com

Der IntTrader ist die Referenz Implementation der API in Form einer WPF Desktop Anwendung und mit IntTrader.Web ist eine Web Plattform auf Nancy Basis (Razor, MVC) in Entwicklung.

Den Fokus werde ich nun mehr auf die Web Anwendung legen, um Plattform unabhängiger zu bleiben.

Das Projekt liegt auf GitHub: https://github.com/Zicore/IntTrader und wie der Client aussieht kann man entweder dort sehen oder hier im Anhang.

Wer sich beteiligen möchte kann das gerne über GitHub machen oder mit mir in Kontakt treten.

Ziel des ganzen ist es eine Trading Plattform zu schaffen, bei der man mit einem Login an verschiedenen Märkten handeln kann.

Technologien: C#, .Net 4.5, WPF, Json, Nancy, Razor, CoffeeScript, HTML5, Bootstrap, SignalR, jQuery

Deinen Dialog musst du aus dem UI Thread erstellen und der Background worker müsste sich um die Arbeit im Hintergrund kümmern.

Selbst wenn der User darauf warten muss, darf kein Thread den UI Thread blockieren.

Du scheinst den Dialog aus dem Background Worker Thread zu starten, das wird nicht funktionieren.

Fenster -> Neues Fenster.

Ich denke dazu musst du zunächst Zeichnen und dann Skalieren.

Ab sofort Open Source: https://github.com/Zicore/NoiseTools

Typisches Verhalten von Antiviren Programmen wie Avast. Prüft dein Programm in einer Sandbox und wenn es nichts feststellt, startet es das Programm wie gewohnt.

Hallo lazy,

naja so schwer was zu finden ist das jetzt nicht: Doing a NotifyIcon program the right way

Stichwort: ApplicationContext

Grüße

André

Hallo *neo*,

prüf mal ob es an der Byte-Reihenfolge liegen kann. Eventuell beim Encoden des Strings.

André

Hallo Movementroboter,

das ganze habe ich, glaube ich, schonmal beantwortet.

Der Ladebalken wird animiert, das heißt es ist nicht sofort sichtbar wie viel Prozent er anzeigt.

Das kannst du ja leicht prüfen.

Grüße

André

Das ist ja der Punkt, es muss eben nicht jeder die komplette Blockchain auf seinem Rechner haben.
Es reicht wenn es genügend Full Nodes gibt um das Netzwerk am Leben zu halten.

Soweit ich weiß, war es laut dem Paper von Satoshi Nakamoto nicht geplant das jeder Client die komplette Blockchain synchronisiert.

Wichtig aber, ist das die Miner mit steigenden Anforderungen schritthalten und das wird schätzungsweise noch lange der Fall sein.

Die Bandbreite bringt auch nur Probleme wenn viele gleichzeitige Transaktionen durchgeführt werden.

Mir fehlt leider die Zeit um die Informationen detailierter zusammenzufassen.

Hallo,

natürlich gibt es Risiken, wie überall.

Die Community hinter Bitcoin ist allerdings schon so riesig, dass eine Lücke m.E. entweder schnell gefunden werden würde oder aber schnell behoben werden würde.

Erst kürzlich hatte ein Miningpool bedrohliche 45% an Hashingpower erreicht.
Die Reaktionen in der Community waren super, viele haben sofort reagiert auf die Gefahren hingewiesen und den Pool gewechselt. Sogar der Poolbetreiber hat verlauten lassen die 51% auf jedenfall zu verhindern.

Niemand kann vorhersehen ob es in Zukunft zu Problemen kommen wird, da heißt es einfach abwarten und die Lage im Auge behalten.

Jeder muss selbst bewerten ob das Risiko tragbar ist.

Hier noch was zur Skalierbarkeit: Bitcoin Wiki Scalability

Momentan gibts Anhörungen in New York: Department of Financial Services (NYDFS Public Hearing on Virtual Currencies)