Service Locator kann gefährlich sein, weil er recht einfach schlampigen Code erlaubt (du brauchst eine Instanz von IFoo? Frag den Service Locator, wurscht wo du grade bist) - drum ist er auch einer meiner Lieblings-Anti-Patterns, weil ich bisher nur schlechte Erfahrungen damit gemacht habe.
Solang du dir sowas aber im Hinterkopf behältst und nicht am Software Design vorbei arbeitest (nur weil dus damit kannst), sollte es auch kein Problem sein.

Wie sieht den die alternative aus?
Wie löse ich das den sonst auf?
IInterface auf Implementiuerung - da muss es doch zu einem Container.Resolve(IInterface) kommen (ist das noch nicht das Service Locator Pattern?)

Der Service Locator Teil in dem Windsor Beispiel ist exakt an einer Stelle, weil zumindest irgendwo ein Service Locator Aufruf drin sein muss - üblicherweise ist das direkt in Program.Main für dein Haupt- oder Root-Objekt, von dem aus alles seinen Lauf nimmt (üblicherweise die Applikation, das Service oder wie auch immer es bei deiner Applikation auch grade aussieht).
Das kann auch eine Klasse sein, in der Praxis macht man aber halt üblicherweise Interfaces draus, wenn es sinnvoll und zweckmäßig ist (aus den von Abt genannten Gründen).

mit fem Haupt/root Object meinst du, das ich nur davor die abhöngigkeiten auflöse und über dieses dann im Konstruktor alle Abhängigkeiten mit gebe? Wäre das nicht total überladen?
dann muss ich ja von dem Punkt aus alles durchschleifen ...

An anderen Stellen (zb. wenn deine Applikation einen IOutputWriter braucht) übernimmt der IoC Container die Arbeit für dich und versucht, die passende Komponente dafür zu finden (er macht den Service Locator indirekt) - ohne dass du irgendwo ein GottKlasse.GibMir<IOutputWriter>() oder ähnliches schreiben musst.
Alles was du selber dazu tun musst, ist ihm bekannt zu geben, welche Abhängigkeiten du haben willst - und das wurde schon zu Genüge über Konstruktoren usw. in früheren Posts hier drin angesprochen.

Aber genau das ist es scheinbar was ich nicht verstehe 😦
Wann wird das aufgelöst und injiziert?
bzw wie sieht die verwendung davon im konkreten code aus?
Definition (ich muss ja trotzdem vorher sagen für das Interface die implementierung) und Nutzung (wenn ich auf einem objekt was aufrufe, das dann intern was korrekt passiert)

Erstmal zu dem
> .
Ein IoC-Container /Service Locator ist kein Gottobjekt, er hat genau eine Aufgabe. Nämlich die Abhängigkeiten aufzulösen. Er kennt jetzt auch nicht wirklich, die anderen Klasse und benutzt deren Methoden.

Auch sollte man die Abhängigkeiten von außen auflösen lassen, am besten Über Konstruktor Injektion.

Mal Vereinfacht dargestellt.

CustomerController(ICustomerService service)  
{}  
  
...  
  

Ein IoC Container kann jetzt von außen alle Abhängigkeiten auflösen. Das ist grundlegend die beste Lösung.

Das macht auch irgenwie Sinn ...
Aber was du mit von außen auflösen meinst ist mir nicht ganz klar. Von außen Injizieren? Aber gibt das nicht Probleme bei tieferen Hierarchien?

Nein, musst du nicht. Lifestyle Singleton wird automatisch injiziert

Von wem wird das injiziert? Ich meinte ja eigentlich konkret den Container, da man ihn ja überal zum Resolven braucht.
... und wenn der Container noch nicht konfiguriert ist.

... Transiente Objekte
werden über eine Facility reingereicht weil der Container ja nicht wissen kann wieviele Objekte du brauchst.

... was für Facility?
Und warum muss er wissen wieviele es sind. Er kann sie ja neu erstellen oder bauen.

In dem Beispiel wid nur der Service Locator verwendet weil du ja ein erstes Objekt bei einer DesktopApp brauchst, ApplicationController o.ä. Bei einem WebAPI-Projekt z.B. injiziert Castle.Windsor die Abhängigkeiten in die Controller automatisch.

In dem Beispiel sieht man doch gar nicht was es ist ... ?

I.d.R. erfolgt die Auflösung via Service Locator Pattern.
Je nachdem mit welcher Technologie Du arbeitest, gibt es da aber automatismen, zB in ASP.NET mit einem Dependency Resolver.

ASP.net hab ich noch nie was gemacht.
Service Locator Pattern - muss ich mir erst einlesen.
Aber so wie ich das sehe ist das dann eben eine statische singelton - wobei ich meinte, gelesen zu haben, das man sowas meist vermeiden soll.

aus wikipeda zum service locator:

The registry must be unique, which can make it a bottleneck for concurrent applications.  
The registry makes the code more difficult to maintain (opposed to using Dependency injection), because it becomes unclear when you would be introducing a breaking change.  
The registry makes code harder to test, since all tests need to interact with the same global service locator class to set the fake dependencies of a class under test.

😄

Eine Gott-Klasse gibt es in 99% der Fälle im Prinzip schon, denn die besagt, welche Implementierung hinter welchem Interface steckt.
...
Wichtig ist der Grundgedanke:
Du darfst in den einzelnen Klassen immer nur gegen ein Interface arbeiten; Du darfst hier die Implementierung nicht kennen - musst Du auch nicht.
...
Nur Interfaces lassen sich auch mocken und stellen so erst die Basis für sorgfältige Softwaretests / Unit Tests dar.

Danke, für die Bestätigung meines Verständnisses!

Eines verstehe ich noch nicht ganz.

Bei z.B.: WindsorCastl:
https://github.com/castleproject/Windsor/blob/master/docs/README.md

var container = new WindsorContainer();

// adds and configures all components using WindsorInstallers from executing assembly
container.Install(FromAssembly.This());

// instantiate and configure root component and all its dependencies and their dependencies and...
var king = container.Resolve<IKing>();
king.RuleTheCastle();

Hier brauche Ich ja überall wo ich ein Interface zu einer Implementierung auflösen will eine Instanz des Containers.
Wenn ich den nur einmal im Programm haben will, muss ich den ja entweder:
statisch irgendwo ablegen () oder
ihn überall hin durchschleifen (hatten wir doch schon) oder
ich erselle ihn überall neu (überall boilerplate + abhängig davon)
daher sehe ich nicht wie ich das verbessere.

Selbige Frage stellt sich bei mir auch für Java und Guice (von google):
https://github.com/google/guice/wiki/Motivation

  public static void main(String[] args) {
    Injector injector = Guice.createInjector(new BillingModule());
    BillingService billingService = injector.getInstance(BillingService.class);
    ...
  }

Wenn ich sowas in gröseren Projekten einsetzt denke ich auch das es paar sachen besser macht (IoC) aber dadurch andere Porbleme bringt.

Hi, danke für die antworten!
Das ist auch im Moment so mein Verständnis von IoC & DI.

Für die Injektion der Dependency gibt es ja scheinbar verschiedene Methoden (Konstruktoren, property, .... )

Aber nach wie vor muss irgendwo eine Auflösung Interface zu Implementation stattfinden. Das muss auch in den Frameworks passieren ... das ist das was ich nicht nachvollziehen kann wann/wo das so funktioniert, dass es nicht zu einer Gott-Klasse (alles in einem Platz was man auch nicht will), klappt. (Oder soll man diesen Hintergedanken einfach ignorieren?)

hi Zusammen

Ich habe begonnen mich in einige Software Pattern ein zu lesen,
und habe bei einigen noch Verständnis Probleme,
bei denen ich hoffe hier bei einer Diskussion vl mehr Verständnis dafür zu entwickeln.

Zunächst mal gibt es Patterns die sehr einfach sind, und die ich auch hin und wieder (auch unbewusst, ohne Wissen ihrer Existenz) benutzt habe.
Aber es gibt eben auch weit größere/komplexere Patterns, bei denen ich mir immer denke,
wie komme ich den da vorher drauf die zu verwenden (wo ich mir noch dazu eine Anpassung überlegen muss, weil 1:1 geht ja eh nur in Beispielen).

Egal, jetzt mal aber Konkret zu Inversion of Control & Dependency Injection.
Das ist grad das Thema, das in meinem Kopf als „nicht ausreichend verstanden“ herumfliegt.
(Als Hinweis, ich nutze gerade meist C# oder Java)

Dabei geht es ja um mehrere Punkte/Ideen.
Man verwendet Interfaces/Abstractionen um nicht mehr von konkreten Implementierungen ab zu hängen.
Das ist eigentlich auch klar und einleuchtend, kommt aber mit so ein paar harken für mich mit …
Wenn ich also eine Methode aufrufe, und Parameter mitgebe, und dabei Interfaces erwartet werden ist es von Vorteil da ich da beliebige Implementierungen einfüllen kann.

Bei einfachen (jetzt nicht gleich ganz die primitiven) Daten Parametern stelle ich mir das ja noch toll vor. aber wenn es dann um Objekte geht die viel Logic oder so mitbringen wie irgend ein service oder so … naja
Allerdings soll es ja auch so sein, damit ich in der Methode mich auch nicht darum kümmern muss wie das gerade geht
(Ich weiß nur, dass das erhaltene Object vom typ IDataOutputController genutzt werden kann um die daten aus zu geben)

Seis drum.

Aber wenn ich jetzt also „beliebige“ Objekte die die Interfaces implementieren nutzten kann muss ich das ja auch irgendwo entscheiden:
Welche das konkret sind (1), und sie auch irgendwo instanziieren (2), und irgendwie auch zu den Stellen im Programmablauf bringen wo sie genutzt werden (3).
Und bei den Problemen (1, 2, 3) ist dann die Frage wo/wie ich das mache.

1: passiert sowas nur zu compile time oder ist dafür auch runtime gedacht?

3 & 2: Wenn ich die irgendwo am „Beginn“ des Programm Laufs oder Zentral habe, muss ich diese Objekte ja immer mit durchschleifen, was ja alles unnötig kompliziert macht.

2 & 3: Wenn ich das instanziieren dann nur „vor Ort“ mache, ist das dann wieder über den Code Überall verstreu und bei Änderungen muss ich überall hineingreifen.
Es gibt da zwar auch andere Mechanismen (die ich auch nicht ganz versteh) die dann per Annotation (oder andem) funktionieren.
Aber dabei muss ich dann doch auch irgendwie Zentrall die Verknüpfung von Interface auf Implementierung herstellen.
Und das Widerspricht dann wieder dem Prinzip keine Gott-Klassen haben zu wollen. (Oder auch in XML ausgelagert zu haben)

Wie kommt man da also um diese Knoten drum rum?

Events sollten eigentlich keine große Logik beinhalten sondern nur idealerweise die gesamte Logik in eine unabhängig aufzurufende Methode auslagern.
Damit hättest du nicht die Anforderung das du irgendwelche Events auslösen müßtest sondern nur die Methoden die diese Events dann ebenso aufrufen. Stichwort: Testbarkeit und Unit-Tests.

Gut, das sind sie Schon 😉
Ändert aber nichts an der Tatsache, dass ich Events oder eben die Methoden nicht Triggern kann.
Es geht hier nicht um Unit-Tests. (da kann ich ja wenn ichs richtig gemacht habe die Events ja eh triggern).

Warum du die Ausführung nicht steuern könenn solltest wenn sie in einer anderen Methode lagert erschließt sich mir nicht.

Wie starte ich in einer laufenden Anwendung von außen durch VS die Methode?
Das erschließt sich mir nicht 😃

Aber um deine eigentliche Frage zu beantworten.
EventHandler sind auch nur Methoden die du ebenso wie jede andere Methode einfach ausführen kannst.
Die Parameter kannst du, wenn du denn weißt welche kommen, ganz einfach selbst übergeben.
Manche Controls bieten auch Methoden an um ein UI Event zu generieren:
Der Button zum Beispiel hat die
>
die ein Click Event auslöst.

Das ist mir so weit schon klar (denke ich).
Aber ich will das Event ja nicht Programmtisch auslösen.
-> Gewünscht ist: Von Visual-Studio aus ein Event (oder eben eine Methode) auslösen.

Und? Wo sollte da das Problem liegen?
Bzw. wieso sollte der Code-Aufbau deshalb nicht stimmen?
Die Ausführung kann ich deshalb trotzdem nicht ansteuern, egal ob im EventHandler oder einer andere Methode ....

Hi,

Ich habe mir letztens gedacht, dass es Praktisch wäre, Events in der (in debugge Mode) laufenden Anwendung auslösen zu können.

Z.B. hatte ich den Fall, dass ich was am Verhalten einer Anwendung testen wollte, dass ich nicht so mal über die GUI auslösen konnte aber es super gewesen wäre wenn ein Event mit einem Wert in den Args ausgelöst würde.

Gibt es irgendwie eine Möglichkeit?
Wünschte mir sowas wie Rechtsklick -> Event auslösen -> Die werte eingeben -> OK und das Event wird gefeuert.

Wäre Cool ...

hmm ne, dass mim Namen der Methode war nur weil ich wärend dem Beitrag Schreiben Refactored habe 😃

Klappt also tatsächlich nicht.
Habe es auf den Einfach-Download wieder reduziert, und rufe es aus einem Power-Shell Script auf =)

kein C# aber ....

WOW
...

also einzeln bekomme ich es schon hin, aber wenn ich mehrere will klappt es nicht.

function MakeFileName(tUrl)
{
	var name = tUrl
	.replace(/[^A-Za-z_]*/g, "");
	
	return name;
}

function SaveThisUrl(theUrl)
{
	var fileName = MakeFileName(theUrl);
	console.log('	FileName: ' + fileName);
	
	var pa = require('webpage').create();
	
	pa.open(theUrl, function() { 
		console.log('		Make: ' + theUrl + ' ' + fileName);
		pa.render(fileName + '.JPEG', {format: 'jpeg', quality: '85'}); 
	});	
}


var content = fs.read('loadFile.txt');
var lines = content.split('\n');

for(var i = 0;i<lines.length;i++){
   var line = lines[i];
   console.log('Line[' + i + ']: ' + line);
   Render(line);
}

Es scheint nicht vorhersehebar abzubrechen und ich sehe nicht ganz warum
(hab aber auch noch keine erfahrung wie man da debuggt und geh mal schlafen)

Es soll automagisch gehen.
Sonst könnt ich eh von hand.

Deshalb poste ich ja auch im c# forum 😃

Bei den Meisten Seiten ist es eh Responsive und ein normaler Browser auf die richtige subDomain (m.heise.de z.b.) und Größe angepasst zeigt es "richtig" an.

Aber wie gesagt, automagisch soll es gehen.
Ich gebe ihm 3 URLs und das Programm gibt mir 3 Bilder.

Hallo,

Ich würde gerne von Websites Bilder erzeugen, als wurde ich sie mit den (mobilen) Browser besuchen und dabei aber die ganze Seite Speichern(nicht nur das sichtbare).

Komme da aber nicht wirklich vom Fleck.

Ich habe schon paar Sachen probiert, die mir aber im besten Fall schon Bilder liegen, aber alles andere als wie in dem mobil Browser, noch nicht mal so wie in einem Desktop Browser, der auf die passende Große verkleinert wurde(was mir auch reichen würde).
Ich glaube, das das css fehlt.

z.B. Folgendes:
Converting a webpage to an image using c#

Bei anderen bekomme ich es nicht mal so gut hin.

Jemand eine andere Idee wie ich das lösen kann?

Hier vl noch ein Beispiel was ich gerne hatte an Heise.de :

Im besten Fall gibt's eine Doku die beim groben Anwendungszweck der Anwendung beginnt und immer tiefer ins Detail geht bis man mit der Doku und den enthaltenen Diagrammen eine schöne Karte bekommt um im Projekt zu navigieren.

Habe ich leider in der Form nur noch nie gesehen ...

Hehe, darum gehts ja - zum Teil.

Um das Big Picture zu verstehen ist es wichtig, die verschiedenen Ebenen der Anwendung zu kennen.

Vielleicht ist BigPicture auch zu groß. Also was die Anwenung als ganzes macht, ist mir schon klar.
Aber es geht um subkompnenten/teile davon, also für ein feature einen Subteil ... (hach ich habe kein passendes Vokabular dafür, besonders um die Uhrzeit).

Gute Tools kenne ich ehrlich gesagt keine. Klassendiagramme die automatisch erstellt werden finde ich wenig aussagekräftig.

Ich auch nicht so (zumindest die die ich bis jetzt gesehen habe).
Mich interesseirt meist nur eine Kleine Teilmenge (da wo ich grad im Code stehe),
und davon auch mehr einen Fokus wie die (am besten selektive) Daten darin "fließen".

Ich hab' für eine Arbeit auf der Uni ein paar Paper zur
> gelesen. Das klingt nach dem was du suchst aber mir ist kein Tool für C#/.Net bekannt.

Bin ich mir nciht ganz sicher, außerdem schient man da eh im Moment nicht rann zu kommen 😃

Visio für Schichtenmodelle, Altova MapForce für Mapping-Zusammenhänge, Visual Studio Diagramme für Modell-Darstellungen.

Visio hört sich für mich eher nach Dokumentation von Hand an? Ich suche ja eher Automatisches, von Code der Existeirt, am besten da Wo ich gerade dann sitze (cool wäre ein weiteres Fenster wass mir den gerade zu bearbeitenden Code auch Graphisch darstellt und die verbindungen drum rum).
Altova kenn ich nicht (vl kann ich mir das am WE ansehen.)
Visual Studio Diagramme, hab ich auch nicht betrachtet (auch auf die liste).

Ansonsten gibt es hier nicht den einen Weg nach Rom.

Den suche ich doch gar nicht 😉 sondern wie das vl andere hin kommen oder was die gehört haben wie man ncoh dort hin kommen kann.

Es gibt für Entwickler ganz andere Anfordungen an eine Doku als zB an den ITler. Dann kommt es auf die Anwendung selbst an, was man dokumentieren muss.

Naja es geht mir ja uch nicht unbedingt um eine Dokumentation, vl ist das im post falsch rübergekommen, sondenr darum einen übergeordneteren Blick auf den Code zu bekommen, wenn ich grad wo im Code stehe. (Fokus wohl eher für Entwickler, wieso auch wen anderen)

Hi,

Ich bin auf der suche nach Tools (und auch Methoden) zum besseren Nochvollziehen von Code im größeren - also dem Big Picture.
Dabei geht es hier nicht um selbst geschriebenen Code sondern "fremd" Code, in wirklich großen Projekten.

Code lesen hilft zwar aber ich suche eben hilfe zur Unterstützung/Beschleunigung.

Ich selbst bin auch ser Visuel, also ich verusche mir die Zusammenhänge graphisch darzustellen.
Gibt es gut Tools die einen dab unterstützen also eigentlich automatisch erledigen,
dass ich zu dem Code in dem ich gerade arbeite die Beziehungen zu anderen Codeteilen sehe, möglichst einfach/übersichtlich,
ein sinnloses alle Klassen/etc diagramm ist ja nicht gerade hilfreich - und wenn cih alles selber machen muss ist es auch keine große Unterstützung ...

Nutzt ihr Graphische/Visualisierende hilfe?
Welche Formen gibt es noch (Grafische oder nicht)?

Auch beim Datenfluss denke ich offt, dass eine visualisierung praktisch wäre,
dass ich eine Variable auswähle und dann eine Darstellung sehe, durch welche Methoden die Daten fließen(fließen könnten) befor/nachdem sie in diese Variable landen, um so schneller entscheiden zu können wo ich weiter schauen muss.
Ist dieser gedankengang/was ich meine nachvollziehbar?

Weil es hier auch dazu passt -> Im Code Navigieren
So ne sach die mich immer wieder Nerft und ich nur vl den einfachen Weg übersehe ...
-> Wenn ich in nem Event Handler bin und dann wissen will wo das Event ausgelöst wird, gehe ich auf den Methoden-Kopf und "Find Usages".
Dabei werden dann alle vorkommen aufgelistet ... nur die meisten sind die Subscriptionen ... ich würd lieber direkt nur die Auslöser (trigger Orte) sehen

[Bei mir steht VS2010 (Premium) mit Resharper zur verfügung.]

Hallo,

Also ich wollte mal fragen ob wer welche kennt und uselber besucht oder so ..
Blogs zum Thema Programmieren ,
die "Täglich" nette Tipps, Tricks und News bringen,
aber sehr Praxis orientiert.

Also wo mal (praktisch) gezeigt wird,

• wie man irgend ein bestimmtes Problem elegant lösen kann.
• wie man mit einer neuen Spar/Framework version alte sachen besser macht.
• wie man mit diesem oder jenem Tool seinen Arbeitsablauf unterstützt.
• oder mit dem neuen .Net Core wie kann ich die dann jetzt auf Linux auch nutzen ...

Kennt ihr gute?
Welche besucht ihr so?

Ich habe auf einer Maschine mehrere kleine Tools laufen, die unter anderem auch nur als Prozess im Task Manager auf tauchen.
Jetzt hätte ich gerne für diese auf dem Desktop in der Notification Area ein Icon, damit ich sehe ob der Process läuft.

Bei einem der Programme habe ich selbst zugriff auf den Quellcode, und ich könnte die Anwendung wohl in eine Window-App umwandeln und selbst ein Notification Icon einrichten, aber bei den anderen kann ich das sowieso nicht.

Meine Idee: Ich schreibe eine neue Windows-Gui Anwendung bei der ich das Fenster nicht erstelle (also keines angezeigt wird) und abhängig davon, ob die Processe laufen, erstelle ich Notification Icons (oder eines, dass mehrere Repreäsentiert, muss man sich überlegen).
Jetzt ist nur die Frage wie ich überprüfe ob die Processe laufen.
Dauernd in einer Loop durchgehen -> Check auf Processes -> Icon Update -> Sleep.
???

Gibt es dazu eine alternative?
Wie sonst?

Praktisch wäre es auch, wenn ich dem Programm sagen könnte, ob ein überwachtes Programm nicht läuft er es starten soll .. (könnte man mit einbauen)
und das ganze als Service wäre dann denke ich auch "schöner", aber die können ja keine Notification Icons machen ...

Was meint ihr?

Nachdem ich den BGWorker schon einmal genutzt habe, hab ich mich jetzt auch dazu entschieden.
Habe die Methoden dazu im ListenObjekt verpackt.

Habe aber mit dem GUI update scheinbar noch immer ein Problem.
Aber vl zuerst mal bischen genauere Beschreibung:

Meine GUI ist einfach mit paar Buttons und einer Listbox

aus der .xaml

  <ListBox DockPanel.Dock="Top" Margin="0,0,0,5" Name="LbUris" ItemsSource="{Binding}" />

aus der xaml.cs

  UriList = new ObservableCollection<UriObject>();
  LbUris.ItemsSource = UriList;

zur liste kann ich per zB.: drag&drop Daten hinzufügen was schlussendlich über ... passiert

        public void AddToList(string uri)
        {
            UriObject uriObj = new UriObject(url);

            uriObj.AddId = counter;
            UriList.Add(uriObj);
            counter++;

            if (ProcessStartAutomatically)
            {
                 uriObj.DoWorkOnObject();
            }
        }

Und hier die Object classe

  internal class uriObj : INotifyPropertyChanged
  {
      public event PropertyChangedEventHandler PropertyChanged;

      private bool IsProcessed;

      public void DoWorkOnObject()
      {
          BackgroundWorker bgWorker;
          bgWorker = new BackgroundWorker();
          bgWorker.DoWork += new DoWorkEventHandler(BW_DoWork);
          bgWorker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(BW_Complete);

          var myArgs = new MyArgs();
          myArgs.IsDone = false;
          myArgs.Uri = this.uri;
          myArgs.Title = this.title;

          bgWorker.RunWorkerAsync(myArgs);
      }

      public override string ToString()
      {
          string state = "   New   ";

          if (IsProcessed)
          {
              state = "Done";
          }

          return string.Format("[{0}]\t{1}", state, uri);
      }

      private void BW_DoWork(object sender, DoWorkEventArgs e)
      {
          MyArgs myArgs = (MyArgs)e.Argument;
          // do the Work .... with myArgs.Uri
          myArgs.IsDone = true;
          e.Result = myArgs;
      }

      private void BW_Complete(object sender, RunWorkerCompletedEventArgs e)
      {
          if (e.Error == null)
          {
              MyArgs myArgs = (MyArgs)e.Result;
              this.IsProcessed = myArgs.IsDone;
          }

          this.NotifyPropertyChanged("IsProcessed");
      }

      private void NotifyPropertyChanged(string propertyName = "")
      {
          if (PropertyChanged != null)
          {
              PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
          }
      }
  }

Dabei soll dann in der Listbox auf der GUI einfach für jedes Object eine Line sein, die das Object repräsentiert.
Durch die Override von ToString() soll das auch angepasst an den State des Objekts passieren.
Nur wenn die Bearbeitung abgeschlossen ist, passiert nichts.
Hab gelesen, dass ich eben das INotifyPropertyChanged implementieren muss weil die ObservableCollection nur bei Add/remove "reagiert".

Nur passiert eben so auch nicht ... weil das PropertyChanged Event keinen Handler (PropertyChanged) hat.
Muss ich den tatsächlich selbst implementieren das ich ein 'LbUris.Items.Refresh();' ausführen kann, oder sollte da irgendwo etwas automatisch passieren, was ich nicht sehe?

Hallo,

Ich habe eine ziemlich einfach WPF GUI.
Dabei ist eine ListView die auf eine ObservableCollection<ProcObjects> binded.
Jedes von diesen ProcObjects muss abgearbeitet werden (Objekte beinhalten nur URIs (File/http)), was einiges an Zeit brauchen kann – daher natürlich nicht im GUI Thread.

Jetzt habe ich dazu ein paar Fragen wie ich das am besten im Hintergrund machen kann.
Nach dem bearbeiten des Objektes muss das natürlich auch wissen dass es Fertig ist (+ Erfolg /Misserfolg) um das in der Liste dazustellen

1. Wie kann ich es am saubersten anstellen, dass die Objekte dass dann mitbekommen (also Thread Rückgabe wert)
2. Wo/Wie handle ich am besten die Threads?
   Ich dachte an zwei verschiedene Optionen
   -- a. In den Objekten selbst eine Methode die das macht. Beim Interieren rufe ich die Methode einfach auf alle auf.
   -- b. Ich gehe in einer Schleife über die liste und rufe eine Methode auf die die Objekte verarbeitet ( also an die ich es übergebe)

Bei beiden natürlich klar, dass nicht auf das Ergebnis gewartet wird, das soll denn auch im Background „zurückkommen“ und das „bearbeitet-Flag“ im zugehörigen Objekt updaten.

Hi,
Ich wurde gerne in einem C# Programm zwei Bilder (z.B. Screenshots) vergleichen und ihren Unterschied "bewertet" haben (1=genau gleich, 0=Garnichts gleich).
Dabei sollte es aber möglich sein, einige Parameter anzugeben, die bis zu einem gewissen wert nicht zu einem Unterscheidung führen sollen. Wichtig wäre da eine Verschiebung um einige Pixel Richtung X und/oder Y.

Gibt es für soetwas schon in .Net ne Classe/namespace?

OK, dachte es gebe vl eine andere Lösung als ein Fenster drüber zulegen ...
Gibts einen Unterschied bei sowas zwischen WPF und WinForms?

Zu den Usability-Hinweißen:
Normalerweise nehme ich bei so was in der Richtung eine Notifcation Icon.
Aber für den hier vorliegenden Fall passt das schon so.

Die Nachrichtenschleife muss ich mir mal anschauen

Hi,

Ich habe eine Anwendung, die immer wieder ausgeführt wird ( mehr mals Täglich),
und dabei Daten in einer Datei erweitert soll.

Die Daten die Anfallen beim Abarbeiten haben Kontext mäßig ein Tabellen format.
Die so in etwa aussehen:

NAME	SUM		Datum1		Datum2
-------------------------------------------------------------------
A1	Sum(V1:n)	Va1		Va2
B	Sum(V1:n)	Vb1		Vb2
C	Sum(V1:n)	NULL		Vc1

Bei einem Ablauf des Programmes wird eigentlich immer eine neue Spalte mit dem Datum erstellt.
Wen bei dem Datum werte (V) für einen Namen vorhanden sind wird dieser eingetragen, wenn nicht nicht(ggf einen NULL wert) und wenn ein neuer Name ist, muss eine neue Zeile angelegt werden.
Und für alle Zeilen sollte es eine "summenspalte" geben (das wäre dann die Komfort version)
Eigentlich soll das ganze als CSV geacht sein, damit die Werte leicht mit excel verarbeitet werden können.

Jetzt frageich mich wie ich das am besten/geschicktesten aufziehe,
um die Tabelle bei jedem mal nicht komplett neu einlesen & aufbauen zu müssen?
Oder gibt es da für CSV irgend etwas, das mir diesen Tasks abnimmt,
weil ich ja jedesmal alles komplett durchgehen muss.

Gibt es den Namen Schon?
Nein --> Namen (Spalte) hinzufügen und alte Spalten mit NULL füllen
Gibt es die Spalte schon?
Nein --> Hinzufügen
Wert für Spalte beim Namen Hinzufügen.
Wenn Name neu ist, Spalte spalten mit NULL auffüllen ...
Und die Summenspalte updaten ...

Hi,

Ich habe eine kleine Konsolen Anwendung die normal schön im Hintergrund läuft (kann auch ohne Konsolenfenster laufen)
Bei manchen "Events" im Programm Ablauf würde ich jetzt gerne, dass mir die Anwendung den ganzen Bildschirm paar mal flashen/aufflackern lässt in Rot oder so
Also den Schirm kurz komplett Rot oder einen Roten-Schleier über alles - für ne halbe Sekunde ein paar mal eben.

Jetzt wollte ich mal wissen wie das überhaupt am einfachsten geht.
Und wie ich das mache ohne mir gleich hundert neue Abhängigkeiten ins bot zu holen

Hmm so auf die schnelle nicht entdeckt wo der angezeigt wird ...

Aber klappt das dann auch bei XML?
(Prinzipiell wär mir ja was schlankeres lieber)

Hallo,
Oft genug kommt es vor, dass ich XML/HTML files parsen muss und dabei eben Werte auslesen muss.
Manchmal haben die „gesuchten“ Teile IDs manchmal nicht …
Die Sprachen die ich verwende sind C# & Powershell.

Dabei ist es oft anstrengen die richtigen XPathes herauszufinden und dabei mache ich auch oft Fehler 😉

Daher wollte ich wissen, ob es irgendwelche unterstützenden Tools dafür gibt.

Dabei wäre es toll wenn ich zB.: ein XML File einlese, mich mit dem Cursor an eine Stelle setze (auf ein Attribut, in einen Node, …) dass dann ein String angegeben wird, der als XPath verwendet werden kann um dieses Element zu erhalten.

In einem Test Modus könnte man dann auch andere Files einlesen und den XPAth live testen …

Oder gibt es andere Tools/VS Plugins die das Arbeiten mit XML & HTML Files effizienter gestalten.

Wow, danke für die vielen Antworten.

Mir gefällt Rubens Ansatz (schön einfach) am besten.

Nur das ich ein Problem bei dem ganzen übersehen habe:
Der bbWork.Work(); kann auch mehrere Minuten (oder Stunden) blockieren ...
Er verarbeitet irgendwelche Netzwerk anfragen.
Ich habe mal den Ersteller (alter Kollege) angeschrieben, ober nicht doch den Quell Code irgendwo hat, um drinnen zu schauen was da passiert.

Habe jetzt versucht den Thread dann mit myThread.Abort() abzubrechen ... allerdings hat das keine Wirkung gezeigt ...
Denke, dass es bei Task Cancellation ähnlich sein wird. Muss ich mir aber noch ansehen ...

Hi,

Ich habe eine Klasse (myProcessor) die ich gerne im Background ausführen würde,
so, dass ich dann darauf aus meinem normalen Programmfluss (Konsolen-Anwendung) die Methoden (Starting/Stopping) aufrufen kann.

Wie kann ich das mit C#.Net bewerkstelligen?

Wenn ich da versuche in Threads zu starten klappt das mim Stoppen nicht mehr ...

Class myProcessor
{
	private BlackBoxWorker bbWork;
	private bool running;
	
	public myProcessor() {
		bbWork = new BlackBoxWorker();
	}

	public void Starting() {
		running = true;
		while(running) {
			bbWork.Work(); 		// This is blocking the whole Thread for some time
			Thread.Sleep(5000);
		}
	}

	public void Stopping() {
		running = false;
	}
}

Class Application
{
	static void main (args)
	{
		myProcessor mP = new myProcessor();
		
		// doing work here ....
		
		// myProcessor im background starten ....
		// aber wie ?
		// Thread.Start(mP.Starting)
		
		// doing work here
		
		// myProcessor im background stopen ....
		// aber wie ?
		// Thread.Start(mP.Stopping)
		
	}
}

Hallo,

Ich habe eine einfach Konsolen Anwendung, die wenn ich sie ein zweites Mal starte (erste läuft noch) abstürzt.
Das liegt daran, das Ports schon belegt sind etc. jetzt will ich aber verhindern, das die zweite Instanz einfach abstürzt – da werde ich wohl einfach die richtigen Exceptions fangen müssen …

Ich möchte aber auch per Übergebenem Commandline Argument sagen können wie die Anwendung damit umgehen soll.

1. Wenn eine andere Instanz schon existiert, soll die neuere einfach kurz ausgeben, läuft schon und sich dann beenden.
2. Es soll brutal alle anderen Instanzen abschießen und dann kurz warten und normal los arbeiten.

Jetzt ist die Frage wie ich das am besten mache …

Wie stelle ich Fest ob schon eine Instanz läuft?
Einfach schauen ob andere Prozesse (mehr als einer (einer ist die Instanz selbst)) mit dem Namen laufen? (kann sich ja Prozesse mit einem Namen holen)
Ist das eine gute Überlegung?
Kann ich innerhalb der Anwendung den eigenen Prozess Namen herausfinden?

Wie beende ich die andere Instanzen der Application?
Da müsste ich wieder den Namen des Prozesses herausfinden und alle beenden bis auf den eigenen – nur woher weiß ich welcher der eigene Prozess ist um den zu überspringen?

Nein, "Check Repository" ist mir nicht explizit aufgefallen, aber denke, dass ich es mal ausprobiert habe und dabei dann kaum Änderungen festgestellt habe ...
Muss ich mir aber nochmal ansehen.

Dann solltest du evtl mal die Möglichkeiten von SVN besser anschauen.

Ich habe nichts entdeckt, was dem entgegensprechen würde, was ich will, habe aber im Client keine Möglichkeit dafür gefunden.
Daher frage ich andere, bei denen ich mir vorstelle, dass sie mehr Erfahrung haben.

1. "Show Log" zeigt dir von den ausgewählten Dateien /Verzeichnissen an was wann wie wo geändert wurde.

Hilft aber nicht wenn ich auf einen Blick sehen will was sich zu mir geändert hat.
Ist ja nicht so, das nur ein Check In seit meinem letzten Update passiert ...
Da müsste ich mir jetzt dort X- Check Ins durchsehen.

2. Wenn du nicht das ganze Verzeichnis Updaten willst, dann markiere eben nur die dateien, die du möchtest.

Irgendwie nicht das was ich will.
Ich möchte dazu aber erst mal wissen welche dafür in frage kommen ...
Kommt dem also eigentlich auch nicht entgegen 😦

3. Ist das meist eine ziemlich schlechte Wahl, denn selten hängen gemeinsame Änderungen nicht zusammen, wenn du also weniger aus checkst, kannst du Probleme bekommen.

Das mag zwar für dich stimmen, aber ich sehe das als Positiv wenn ich eine zusätzliche Möglichkeit habe mir:

1. anzusehen was sich geändert (zu mir) hat.
2. ich das auch auswählen kann, was ich will - beim Check In muss ich mit einem ähnlichen Problemen umgehen (Ich bin der Meinung das man einem Nutzer das zutrauen kann, wenn er nicht will, muss er ja nicht)

Stimmt schon, Daten die nicht im Repository sind werden natürlich usen vor gelassen.
Wenn aber jetzt Änderungen im SVN Repo sind (durch andere Nutzer),
und ich Update sage, schwup-di-wup, werden alle daten die geändert wurden upgedatet.
(Ein fenster öffnet sich in dem man alle Pfade vorbei huschen sieht ...)

Bei einem CheckIn öffnet sich ein Fenster in dem alle files die ich ein checken kann
(weil sie neu/geändert sind) angezeigt werden und ich kann selektieren welche nun tatsächlich übertragen werden + die commit message angeben.
<siehe Anhang>

Ich würde gerne beim Update auch vorher sehen welche files jetzt genau vom Repo zu mir "kommen" (update/merge, added, ...).
Oder wenn ich mir sogar von denen auswählen könnte welche (mit den eventuellen Komplikationen dadurch habe ich kein Problem).

Hi

Als SVN Client nutze ich TortoiseSVN.

Wenn man einen CheckIn auf einem Ordner durchführt,
kann man genau auswählen welche files eingecheckt werden.

Bei einem Update werden aber einfach alle files upgedatet.
Ich würde auch bei einem Update gerne genauer selektieren können was ich mir hole,
bzw zumindest zuvor sehen was alles geupdatet würde.

Kann man das ändern, dass es ähnlich dem Check In abläuft?

Hallo!

Ich habe mir eine Anwendung schrieben die als Tray Icon (NotifyIcon) laufen soll.

Prinzipiell läuft die Anwendung nur ich bekomme kein Kontext Menu auf dem Icon hin.
Ich habe mal den Code Reduziert, damit ich ihn hier übersichtlich Posten kann.
(lauffähig ist er trotzdem)

   public class Anwendung
   {
      public const string PathTo = @"D:\";
      public const string TheFile = @"InfoFile.txt";
      
      public static NotifyIcon ApIcon;
      public static FileSystemWatcher FsWatcher;

      public ContextMenu TrayMenu;
      public MenuItem TrayMenuItem1;

      public static bool Running;

      /// <summary>
      /// Mains this instance.
      /// </summary>
      public static void Main()
      {
         Anwendung myApp = new Anwendung();
         myApp.Run();
         myApp.ExitAppl();
      }

      /// <summary>
      /// Runs this instance.
      /// </summary>
      public void Run()
      {
         Running = true;
         // Console.WriteLine("Press \'q\' to quit the sample.");
         // while (Console.Read() != 'q' && Running) ;
         while (Running) ;
      }

      /// <summary>
      /// Initializes a new instance of the <see cref="Anwendung"/> class.
      /// </summary>
      public Anwendung()
      {
         TrayMenu = new ContextMenu();
         TrayMenuItem1 = new MenuItem();
         TrayMenuItem1.Index = 0;
         TrayMenuItem1.Text = "Exit";
         TrayMenuItem1.Click += new System.EventHandler(OnExit);
         TrayMenu.MenuItems.AddRange(new System.Windows.Forms.MenuItem[] { TrayMenuItem1 });

         ApIcon = new NotifyIcon();
         ApIcon.Icon = Properties.Resources.Icon1;
         ApIcon.ContextMenu = TrayMenu;
         ApIcon.DoubleClick += new EventHandler(OnExit);
         ApIcon.MouseDoubleClick += new MouseEventHandler(OnExit);
         ApIcon.Text = "The Notifier";
         ApIcon.Visible = true;

         FsWatcher = new FileSystemWatcher(PathTo);
         FsWatcher.NotifyFilter = NotifyFilters.LastWrite;
         FsWatcher.Filter = TheFile;

         FsWatcher.Changed += new FileSystemEventHandler(OnChanged);
         FsWatcher.EnableRaisingEvents = true;
      }


      public static void OnExit(object source, EventArgs e)
      {
          Running = false;
      }

      ~Anwendung()
      {
         ExitAppl();
      }

      public void ExitAppl()
      {
         ApIcon.Visible = false;
         ApIcon.Dispose();
         FsWatcher.EnableRaisingEvents = false;
         FsWatcher.Dispose();
      }

      private static void OnChanged(object source, FileSystemEventArgs e)
      {
          Anwendung.UpdateInfo(Anwendung.ReadInfoFromFile());
      }

      public static void UpdateInfo(string msg)
      { 
          // Maybe some other changes ....
               ApIcon.BalloonTipTitle = "Title:";
               ApIcon.BalloonTipText = msg;
               ApIcon.ShowBalloonTip(5000);
      }

      public static string ReadInfoFromFile()
      {
          string InfoFromFile;
          string line = File.ReadLines(PathTo + TheFile).Last();
          // Process line --> InfoFromFile
                InfoFromFile = line;


          return InfoFromFile;
      }
   }

Ich habs auch auf verschiedene weißen versucht,
aber kriege das Kontext menu nicht hin. Wenn ich rechts klicke passiert gar nicht 😦

Wenn jemand Infos hat worann es liegen mag ...

Gibt es ein tool, dass das automatisch den Code durchsucht und aufspürt?
Klar, alle und so wird es nicht finden.

Aber ich hatte letztens einen ziemlich üblen Schnitzer, bei dem ich enttäuscht war, dass das nicht aufgefallen ist:

Beim Refraktoren eines Fields zu Properties:
Hat der Getter dann nicht das field zurück gegeben, sondern sich selbst ….
Ganz offensichtlich ein Fehler .. Endlosschleife ? thread in overflow state …

StyleCop, FxCop & Resharper ist das scheinbar nicht aufgefallen (ich weiß ist nicht Style …).
Gibt es da irgend ein tool das code auf solche doch ziemlich einfachen aber tötlichen Fehler abklopft, … ?

Also bei mir bleiben einige datein da.

Vl liegt es auch nicht daran.
Aber nach einem Manuellen löschen und Neustrat von VS klappt es.

Daher würde ich es da eben gerne einbauen ins "Clean/Bereinigen" ... nur wie?

Oder Du versuchst mal ob Du mit einem Rechtsklick auf die Solution -> Batch -> Bereinigen bzw Neuerstellen auch weiter kommst. Das funktioniert bei mir (bis eben auf ASP.NET Projekte) gut.

Das ist dann wohl Clean & Rebuild, die wie gesagt nichts nützen.

Du kannst Dir ein PreBuild-Script machen, das die Ordner alle vor dem Build löscht.

Naja ich würde gerne ein Post-Clean-Script bauen,
nur wo "klinkt" man das ein?

Hallo,

Ich nutze gerade Visual Studio 2010 um in C# zu programieren.
Im Build-Menu gibt es das Build, Rebuil und Clean Project.

Manchmal scheint er mit Build/ Rebuild nicht wirklich alles neu zu bauen,
dann muss ich von hand die Ordner bin & obj löschen. Ein Clean hilft dabei nicht.
Daher wollte ich wissen, ob & wie es möglich ist, zusätzlich zum Clean automatich das löschen von Datein/Ordnern ausführen zu können.

Also nur, dass ich das richtig verstanden habe.
Die Methode wurde von der Analyse als potentielles Risiko erkannt,
und sollte daher nur von Voll Vertrauenswürdigem Code aufgerufen werden.

d.h. Ich muss die Methode die ObserverInst.Stop() aufruft mit dem Attribut aus statten?

Aber da es alles Mein Code ist vertraue ich dem ja Gleicher maßen.
Daher könnte ich ja der Ganzen Klasse/ allem den verpassen ...

Hi,

Ich habe ein Project geerbt, bei dem ich folgende Warnings erhalte:

Fehlermeldung:
Warning 66 CA2122 : Microsoft.Security : 'ObserverInst.Stop()' calls into 'Process.GetProcessesByName(string)' which has a LinkDemand. By making this call, 'Process.GetProcessesByName(string)' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection:
->'ObserverInst.Stop()'
->'ObserverInst.Stop()' D:\Project\Utilities\ObserverInst.cs 47 Project

Fehlermeldung:
Warning 67 CA2122 : Microsoft.Security : 'ObserverInst.Stop()' calls into 'Process.Kill()' which has a LinkDemand. By making this call, 'Process.Kill()' is indirectly exposed to user code. Review the following call stack that might expose a way to circumvent security protection:
->'ObserverInst.Stop()'
->'ObserverInst.Stop()' D:\Project\Utilities\ObserverInst.cs 47 Project

Betreffender Code sieht so aus:

      public static void Stop()
      {
         try
         {
            Process[] Observer = Process.GetProcessesByName(Configuration.ObserverExeName);
            foreach (Process prc in Observer)
            {
               prc.Kill();
            }

            Logger.Debug("Observer.Kill()");
         }
         catch (Exception)
         {
            Logger.Warning("No Observer to stop.");
         }
      }

Ich bin mir nicht ganz sicher was die Warnings bedeuten bzw wie ich sie behoben kriege.
Vl kann mir wer Tipps geben, wie ich das wieder verbessern kann.
Habe schon empfohlene Eigenschaften hinzugefügt ("Full Trust" & co) die resultieren dann aber nur in weiteren Problemen. Allerdings sliegt das wohl auch dran, dass ich es nicht richtig verstehe ...

PS: Bin mir nicht Sicher ob der Thread hier richtig steht.