Das kannst du mittels SetThreadAffinityMask regeln wobei das im Normalfall nicht nötig sein sollte da der Windows Schedular schon gute Arbeit leistet.

Hier ein kleiner Artikel auf codeproject zu dem Thema: Codeproject Artikel über Schedular und Thread-Affinity

Das dürfte nicht so einfach gehen außer du baust ein Browserplugin. Wie wichtig ist es denn das es aus dem aktuell geöffneten Standarbrowser ausgelesen werden muss? Ansonsten gibt es dazu schon recht viel Zeug im Forum. Siehe z.B.: WebClient mit HTTP-POST- und Cookie-Unterstützung

Ich meinte hier im speziellen die grammatikalische Analyse.

Hallo .NetCoding

du kannst dir zum einschätzen des Aufwands und dem aktuellen Stand von freien Lösungen mal FreeHAL ansehen.

Hmm... das kann ich dir jetzt auch nicht so genau sagen. Wenn man mal mit ILSpy nachschaut dann sieht man das dieser Wert in erster Linie für EventArgs verwendet wird. Allerdings hat die Cell Ja auch ein Row- und ein ColumnIndex-Property und kennt demnach seine position im Grid.

Hast du einfach mal ausprobiert die SetValue-Methode zu überschreiben? Klingt irgendwie genau nach dem was du brauchst.

Nur ein Beitrag falls du meinen Edit übersehen hast.

Schon mal folgendes Event auf dem DataGridView angeschaut? Klingt so als ob es genau dafür gemacht wurde: DataGridView.CellValidating-Ereignis

Wenn du die Logik direkt in deiner Implementierung der Column unterbringen möchtest dann kannst du ja ein eigenes Interface implementieren und im eventhandler mit einem "as" versuchen zu casten.

[EDIT]
Du kannst allerdings auch die SetValue-Methode überschreiben.

du erkennst gerade, dass man mit dem händischen Füllen der ComboBox hier nicht weiter kommt

Das ist so nicht richtig. Es spricht zwar nichts dagegen Databinding zu verwenden aber der Vollständigkeit halber soll hier noch erwähnt werden das man das natürlich auch alles händisch machen kann.

was du brauchst ist z.B. ein BindingSource für dein ComboBox

Man braucht auch nicht unbedingt eine Bindingsource zu verwenden. Eine einfache List<T> tuts auch.

    public partial class Form1 : Form {
        public Form1() {
            InitializeComponent();

            comboBox1.DisplayMember = "Name";
            comboBox1.SelectedIndexChanged += new EventHandler(comboBox_SelectedIndexChanged);

            comboBox2.DisplayMember = "Name";
            comboBox2.SelectedIndexChanged += new EventHandler(comboBox_SelectedIndexChanged);

            List<TestObj> list = new List<TestObj>();

            for (int i = 0; i < 20; i++) {
                TestObj obj = new TestObj(i, "Obj Nr.:" + i.ToString());

                // "Manuelles" hinzufügen
                comboBox1.Items.Add(obj);
                list.Add(obj);
            }

            // Binding an eine List<T>
            comboBox2.DataSource = list;
        }

        void comboBox_SelectedIndexChanged(object sender, EventArgs e) {
            TestObj selectedItem = comboBox1.SelectedItem as TestObj;

            if (selectedItem == null)
                return;

            MessageBox.Show("Name:" + selectedItem.Name + " Id:" + selectedItem.Id);
        }
    }

    class TestObj {

        public int Id { get; set; }
        public string Name { get; set; }

        public TestObj() {

        }

        public TestObj(int id, string name) {
            Id = id;
            Name = name;
        }
    }

Die Infos sind für so ein Thema ein bisschen spärlich. Bitte beachte [Hinweis] Wie poste ich richtig? Punkt 5.

Erstmal wäre der Code den du zum Empfangen verwendest hilfreich. Benutzt du zwei Maschinen oder probierst du es auf dem gleichen Host?

Ersteres schaut für mich nach einem UTF-32 Code aus und den kannst du mit folgender Methode in ein char konvertieren: Syste.Char.ConvertFromUTF32

[EDIT]
Dieser Beitrag könnte für dich auch interessant sein: WebClient mit HTTP-POST- und Cookie-Unterstützung

Um dir helfen zu können brauchen wir erst mal etwas mehr Informationen darüber wie z.B. die Daten aus der DB in die ComboBox kommen.
Um die ComboBox zu befüllen musst du ja den Datensatz inkl. seinem Primärschlüssel bereits "in der Hand" haben solltest ihn also auch unproblematisch auslesen können.

Beachte bitte in Zukunft [Hinweis] Wie poste ich richtig? Punkt 5

Einfach mal so ins blaue geraten könnte es so funktionieren:

MyLinq2SqlEntityType entity = comboBox1.SelectedItem as MyLinq2SqlEntityType;
MessageBox.Show(entity.Id);

wobei "MyLinq2SqlEntityType" i.d.R. der Name der Tabelle im Singular ist und davon ausgegangen wird das dein Primärschlüssel in der Spalte "Id" ist.

Da fällt mir jetzt spontan nichts anderes ein als ein ViewModel-Objekt zu bauen welches dein eigentl. Objekt wrappt:

class TaskForDataGridView {
   public Task RealInstance {get; private set;};

   public TaskForDataGridView(Task realInstance) {
      RealInstance= realInstance;
   }

   public bool TAS_ACTIVE {
      get { return RealInstance.TAS_ACTIVE > 0 ? true : false; }
      set { RealInstance.TAS_ACTIVE = (value ? 1 : 0); }
   }
}

Dann machst du deine Datenbankabfrage und erstellst eine Liste aus TaskForDataGridView-objekten die du dann binden kannst.

Du kannst die Controls auf der Form mit Controls.Add zur Laufzeit hinzufügen. Das tust du dann eben erst dann wenn deine Abfrage erfolgreich war.

Siehe dazu z.B.: Dynamisch erstelle TextBoxen wieder entfernen oder benutze die Forensuche.

Danke für die Anregungen. Werde heut abend mal schauen ob ich dazu komme einige der Vorschläge umzusetzen da ich dieses Snippet selbst immer mal wieder brauche.

Beschreibung:
Ein einfacher word wrap algorithmus der bei Whitespace trennt. Wenn ein Wort zu lang ist für die angegebene Zeilenlänge dann wird es rücksichtslos an der Stelle getrennt ab der es nicht mehr in die Zeile passt.

Das ist die 2. Version des Snippets in dem einige der von herbivore angesprochenen Schwächen behoben sind.

 
        public static string[] WordWrap(this string str, int width, string[] seperators) {

            if (str == null)
                throw new NullReferenceException();
            if (seperators == null)
                throw new ArgumentNullException("seperators", "The seperators array can not be null");
            if (seperators.Length == 0)
                throw new ArgumentException("The seperators array can not be empty", "seperators");
            if (width <= 0)
                throw new ArgumentException("The width must be greater than zero.", "width");

            StringBuilder lineBuilder = new StringBuilder(width);
            List<string> wrappedLines = new List<string>();

            string[] words = str.Split(seperators, StringSplitOptions.RemoveEmptyEntries);

            foreach (string word in words) {

                bool wordWritten = false;

                while (!wordWritten) {

                    if (lineBuilder.Length > 0) {

                        if (lineBuilder.Length + word.Length + 1 <= width) {

                            lineBuilder.Append(" " + word);
                            wordWritten = true;
                        } else {

                            wrappedLines.Add(lineBuilder.ToString());
                            lineBuilder.Length = 0;
                        }
                    } else {

                        if (word.Length <= width) {

                            lineBuilder.Append(word);
                            wordWritten = true;
                        } else {

                            string tooLongWordRemains = word;
                            while (tooLongWordRemains.Length > width) {

                                lineBuilder.Append(tooLongWordRemains.Substring(0, tooLongWordRemains.Length < width ? tooLongWordRemains.Length : width));
                                wrappedLines.Add(lineBuilder.ToString());
                                lineBuilder.Length = 0;

                                int startIdx = tooLongWordRemains.Length < width ? tooLongWordRemains.Length : width;
                                tooLongWordRemains = tooLongWordRemains.Substring(startIdx, tooLongWordRemains.Length - startIdx);
                            }
                            lineBuilder.Append(tooLongWordRemains);
                            wordWritten = true;
                        }
                    }
                }
            }

            if (lineBuilder.Length > 0)
                wrappedLines.Add(lineBuilder.ToString());

            return wrappedLines.ToArray();
        }

        public static string[] WordWrap(this string str, int width) {
            return str.WordWrap(width, new string[] { " ", "\t", "\r", "\n" });
        }

Schlagwörter: word wrap

Beschreibung:

In manchen Anwendungen werden Elemente anhand einer Ordnungszahl verwaltet. Wenn man nun nachträglich irgendwo mittendrin eine Zeile einfügen möchte so muss man auch eine Ordnungszahl angeben die zwischen der vorhergehenden und nachfolgenden liegt. Das kann dieses Snippet übernehmen.

Anwendungsfälle finden sich z.B. in EDI-Formaten oder älteren ERP-Systemen.

        /// <summary>
        /// Takes a list of integers and inserts numbers where nessecary (where the value is 0).
        /// </summary>
        /// <param name="numbersList">The list</param>
        /// <param name="defaultIncrement">The default increment value</param>
        /// <example>
        /// If we have the following list and the defaultIncrement is 10000
        /// 
        /// LineNo.:
        /// [00] = 0
        /// [01] = 0
        /// [02] = 10000
        /// [03] = 20000
        /// [04] = 30000
        /// [05] = 0
        /// [06] = 40000
        /// [07] = 50000
        /// [08] = 0
        /// [09] = 60000
        /// [10] = 0
        /// [11] = 0
        /// 
        /// the resulting list would look like this:
        /// 
        /// LineNo.:
        /// [00] = 3333
        /// [01] = 6666
        /// [02] = 10000
        /// [03] = 20000
        /// [04] = 30000
        /// [05] = 35000
        /// [06] = 40000
        /// [07] = 50000
        /// [08] = 55000
        /// [09] = 60000
        /// [10] = 70000
        /// [11] = 80000
        /// </example>
        public static void InsertNumbersBetween(List<int> numbersList, int defaultIncrement) {
            int previousNo = 0;

            for (int i = 0; i < numbersList.Count; i++) {

                int gap = 0;
                int maxLineNo = 0;
                int itemNo = i;

                if (numbersList[i] == 0) {
                    while (itemNo < numbersList.Count &&
                          numbersList[itemNo] == 0) {
                        gap++;
                        itemNo++;
                    }

                    bool endOfList = false;
                    if (itemNo == numbersList.Count) {
                        maxLineNo = previousNo + (gap * defaultIncrement);
                        endOfList = true;
                    } else
                        maxLineNo = numbersList[itemNo];

                    int range = maxLineNo - previousNo;
                    int step = range / (endOfList ? gap : gap + 1);

                    int currentGapElement = 1;
                    for (int y = i; y < i + gap; y++) {
                        numbersList[y] = previousNo + step * currentGapElement;
                        currentGapElement++;
                    }
                } else {
                    previousNo = numbersList[i];
                }
            }
        }
    }

Schlagwörter: Ordnungszahl, Zeilennummer, Einfügen

Beschreibung:

Eine C# Implementierung des Timecode welcher bei der Videobearbeitung verwendet wird.

Methoden:

• ToString: Gibt den Timecode im Format HH:MM:SS:FF aus
• FromMilliseconds: Erstellt eine Timecode Instanz aus der Anzahl der Millisekunden und den FPS
• FromTimeSpan: Erstellt eine Timecode Instanz aus einem Timespan objekt und den FPS
• CalculateDuration: Berechnet die Dauer aus TcIn und TcOut
• Parse: Erstellt eine MediaTimeCode Instanz aus einem String im Format HH:MM:SS:FF

public struct MediaTimeCode {

        public int Hours { get; set; }
        public int Minutes { get; set; }
        public int Seconds { get; set; }
        public int Frames { get; set; }

        public static MediaTimeCode FromMilliseconds(long milliseconds, int framesPerSecond) {

            TimeSpan timespan = TimeSpan.FromMilliseconds(milliseconds);

            return FromTimeSpan(timespan, framesPerSecond);
        }

        public static MediaTimeCode FromTimeSpan(TimeSpan timespan, int framesPerSecond) {

            double framesPerMillisecond = (double)framesPerSecond / (double)1000;
            int frames = (int)(timespan.Milliseconds * framesPerMillisecond);

            return new MediaTimeCode() {
                Hours = timespan.Hours,
                Minutes = timespan.Minutes,
                Seconds = timespan.Seconds,
                Frames = frames
            };
        }

        public static MediaTimeCode CalculateDuration(MediaTimeCode tcIn, MediaTimeCode tcOut, int fps) {

            double fpm = 60 * fps;
            double fph = 60 * fpm;

            double frameHours = tcIn.Hours * fph;
            double frameMinutes = tcIn.Minutes * fpm;
            double frameSeconds = tcIn.Seconds * fps;

            double tcInFrames = frameHours + frameMinutes + frameSeconds + tcIn.Frames;

            frameHours = tcOut.Hours * fph;
            frameMinutes = tcOut.Minutes * fpm;
            frameSeconds = tcOut.Seconds * fps;

            double tcOutFrames = frameHours + frameMinutes + frameSeconds + tcOut.Frames;

            double durationInFrames = tcOutFrames - tcInFrames;

            int fRest = (int)durationInFrames % (int)fps;
            int frames = (int)durationInFrames - fRest;

            int s = frames / (int)fps;
            int sRest = s % 60;
            int minutes = ((s - sRest) / 60) % 60;
            int hours = (100 - minutes) / 60;

            return new MediaTimeCode() {
                Hours = hours,
                Minutes = minutes,
                Seconds = sRest,
                Frames = fRest
            };
        }

        public override string ToString() {
            return string.Format("{0:00}:{1:00}:{2:00}:{3:00}",
                Hours,
                Minutes,
                Seconds,
                Frames);
        }

        public static MediaTimeCode Parse(string tcString) {

            string[] tcParts = tcString.Split(':');

            int hours = int.Parse(tcParts[0]);
            int minutes = int.Parse(tcParts[1]);
            int seconds = int.Parse(tcParts[2]);
            int frames = int.Parse(tcParts[3]);

            return new MediaTimeCode() {
                Hours = hours,
                Minutes = minutes,
                Seconds = seconds,
                Frames = frames
            };
        }
    }

Schlagwörter: Video Timecode, TcIn, TcOut, Struct

Servus zusammen,

ich würde meinen lokalen Rechner im Büro ja sofort gegen einen virtualisierte Desktop eintauschen wenn die Infrastruktur dahinter Leistungsfähig genug ist.

Die Plattenzugriffe sind mit einem anständigen SAN dahinter deutlich schneller als das mit einer lokalen Platte der Fall ist (nun gut, habe noch keine SSD in meiner Mühle) und selbst mit Laptop und einer UMTS-Verbindung bin ich immer wieder überrascht was das RDP-Protokoll seit Version 7 so alles leisten kann.

Größter Knackpunkt war für mich beim remote arbeiten immer der fehlende Multi-Monitor support aber auch das ist Geschichte.

Ich muss immer öfter mal auf dem Testsystem eines Kunden ein paar SQL Skripte schreiben und mache das eigentlich richtig gerne da dort eine dicke Kiste dahinter steht und die Leitungen auch ordentlich dimensioniert sind sowie die Latenz top ist.

Ansonsten arbeite ich zum testen sowie zum entwickeln unter Linux (z.B. eclipse auf debian für php) auch oft mit lokal installierten VMs (VMWare Workstation) und bin mit der Reaktionszeit mehr als zufrieden (sogar das OpenGL-Eyecandy läuft flüssig). Das ganze auf einem nun doch schon etwas in die Jahre gekommen Dell Precision M2400 mit Core2Duo 2.8Ghz und 8GB Ram.

Unseren Kunden haben wir nun auch schon öfter Terminal Server für ihre Anwendungen mit IGEL Thin Clients verkauft und bislang gab es noch keine Beschwerden (gut dort laufen i.d.R. nur ERP-Anwendungen mit, sagen wir mal genügsamer GUI).

Mit VmWare View habe ich jetzt selber leider noch keine Erfahrungen sammeln können. Ich könnte mir allerdings gut vorstellen das die Kosten-Nutzen Rechnung durchaus aufgeht wenn man alle Rechner in der Firma virtualisiert da die Rechner von Einkauf, Buchhaltung, Vertrieb etc. ja doch nur die meiste Zeit idlen und eine aktuelle Dual- oder gar Quadcore CPU dort oft hoffnungslos unterfordert ist. Diese Rechenleistung kann man ja dynamisch der Entwicklung und dem Test zur Verfügung stellen wenn sie nicht genutzt wird und ansonsten werden minimalanforderungen definiert für die man zugesicherte Resourcen bekommt.

So weit ich weiss hatte Sun dieses Konzept damals in weiten Teilen des Unternehmens obligatorisch gemacht (Sun Ray Thin Clients) eventuell findet man Erfahrungsberichte darüber im Netz.

Oft wird wohl das Message Passing Interface verwendet.

Für C# im speziellen gibt es auch eine Implementierung: MPI.NET

An das DataGridView wohl gar nicht. Den musst du als Parameter (SqlParameter für SQL-Server) an dein SqlCommand übergeben.

Wenn unklar siehe: [Artikelserie] SQL: Parameter von Befehlen

Back to the roots. Erinnert mich irgendwie ganz stark an Visual Studio.Net (2002).

Hallo zusammen,

mit den aktuellen Versionen des Adobe Readers gibt es eine AccessViolationException wenn man innerhalb des Controls die Tab-Taste drückt und so wie es aussieht möchte Adboe das Problem auch nicht beheben.

Habe hier einen kleinen Workaround aus dem Adobe Support-Forum (AccessViolationException fatal error, Acrobat 9, AxAcroPDFLib, .NET, Win7) eingebaut:

/// <summary>
/// .NET Wrapper für Adobe Reader ActiveX-Steuerelement
/// </summary>
public class AdobeReaderControl : AxHost {

    protected override void WndProc(ref Message m) {
        if (m.Msg == 0x1450) // Bug wenn man im reader TAB drückt (AccessViolationException) http://forums.adobe.com/thread/530591
            return;
        base.WndProc(ref m);
    }

    /// <summary>
    /// Hostet das Adobe Reader ActiveX-Steuerelement in Windows.Forms.
    /// </summary>
    public AdobeReaderControl()
        : base("{CA8A9780-280D-11CF-A24D-444553540000}") // CLSID des Adobe Readers (ist bei allen 32-Bit Versionen gleich)
    { }

    /// <summary>
    /// Lädt eine PDF-Datei.
    /// </summary>
    /// <param name="path">Pfad</param>
    public void LoadFile(string path) {
        // LoadFile-Methode auf dem Adobe Reader aufrufen
        this.GetOcx().GetType().InvokeMember("LoadFile", BindingFlags.InvokeMethod | BindingFlags.OptionalParamBinding, null, this.GetOcx(), new object[1] { path });
    }

    /// <summary>
    /// Druckt die geladene PDF-Datei.
    /// </summary>
    public void Print() {
        // Print-Methode auf dem Adobe Reader aufrufen
        this.GetOcx().GetType().InvokeMember("Print", BindingFlags.InvokeMethod | BindingFlags.OptionalParamBinding, null, this.GetOcx(), new object[0]);
    }
}

Probiere es mal mit dem EF. Das unterstützt dein DB Modell von Haus aus und du musst keine DateTables vermanschen: ADO.NET team blog: Inheritance in the Entity Framework

Wenn z.B. zwei Firmen Daten tauschen wollen, dann könnte man einen WebService nutzen. Das wäre hier natürlich ideal, kein Timer, kein Verbindungsaufbau usw.
Ich weiss nicht, ob das auf einen Windows Mobile überhaupt geht.
Und wenn ja, wie soll man den Scanner ansprechen? Der hat ja keine feste IP.

Du könntest auch einen Webservice benutzen. Das Verfahren würde ähnlich aussehen: Du würdest den Webservice periodisch aufrufen und somit brauchst du nur die IP oder den DNS Namen des Servers zu kennen.

Mein Problem ist, dass wenn ich, nach dem die FTP Verbindung steht, das Netzwerk aus und wieder anschalte und nun versuche eine Datei zu verschieben, dann bekomme ich einen Fehler.

Ja, wie sollen auch ohne einen erneuten Verbindungsaufbau Daten fließen. Ich sehe jetzt aber auch nicht das große Problem darin diesen Zustand abzufangen und die Verbindung erneut aufzubauen.

ist es mir denn dort auch möglich, "lokal" auf dem Gerät Daten zwischenzuspeichern?

Wie wäre es damit?
Web SQL Database

Die Idee das über IPC zu machen ist grundsätzlich gut nur würde ich dir auch eher zu einer Implementierung raten die auf Named Pipes verzichtet. Alternativ könntest du z.B. Zyan für die Kommunikation über Remoting benutzen.

IMHO auch ein schöner Weg wäre eine Datenbank (SQL Express wenn nichts anderes im Haus ist) zu verwenden in die geloggt wird. Da bleibst du sehr flexibel und kannst die Daten auch leicht in die gängigen Monitoring-Tools am Markt integrieren.

Eventuell mal die SQL Server Integration Services anschauen bevor man anfängt die nachzubauen. Eventuell reichen die ja für deinen Fall auch schon aus (Für spezielle Sachen gibt es auch eine C#-Skript Komponente).

Die Pakete kann man auch aus einer C#-Client Anwendung aus aufrufen und die Pakete selbst können im FS oder auch in einer DB liegen.

Ich habe zwar noch Alternativen ohne Workflows in petto, aber Workflows sind in unseren Unternehmen gerade "In"

Da muss man immer ein bisschen aufpassen. Workflows werden oft gerne als der universelle Problemlöser verkauft der sie aber nicht sind. Gerade wenn man die Workflows durch Fachabteilungen erstellen lassen will kann einiges schief gehen.

Aber hier geht es eher grundlegend darum, ob diese Idee umsetzbar ist.

Ja 😃 Aber du hast das alles noch sehr vage beschrieben.

Also da Workflows ja auch nur Typen sind die in Assemblies liegen kannst du sie schon mal dynamisch laden, parametrisieren und starten. Du kannst ebenfalls Workflows dynamisch im Code erstellen (grob gesagt wie wenn du Controls auf ne Form packst nur das du eben Activities in einen Workflow stopfst).

Stellt sich halt noch die Frage wo du deine Daten herholen möchtest und wie die Konvertierungen gestrickt sein sollen.

Mein Vorschlag war das du ein Interface definierst welches die Datenquelle darstellt (mit einer Methode GetSorceStream()) und ein Interface für die Datensenke (mit Methode WriteSinkStream(Stream stream)). Von diesen Interfaces kann es dann verschiedene Implementierungen für Files, Datenbanken, RSS-Feeds etc. geben, gleiches gilt für die Senke.
Zwischen Quelle und Senke sind die Workflows angesiedelt und transferieren/transformieren die Daten auf dem Weg zur Senke.
Das einzige was der Entwickler der Workflows dazu kennen muss ist deine Schnittstelle.

Du kannst dann auch ein XML-Manifest bauen welches die benötigten Informationen über einen Workflow enthält (welcher Workflow, wo liegt er, welche Quelle/Senke ist zu benutzen, Abhängigkeiten, Schedules etc.). Dieses File bzw. die Infos daraus kannst du in einer Datenbank registrieren und dafür ein Verwaltungstool schreiben. Auch interessant ist wenn die Workflows diese Informationen selbst liefern können.

Probier mal eher MetaDataSet.ReadFrom(XmlReader reader). Den XmlReader kannst du dir ja beliebig bauen.

Die flexibelste Möglichkeit wäre wohl (wenn es nur um Konvertierungen geht) einfach Streams zwischen den einzelnen WF-Knoten hin und her zu schicken.

Dein WF-Host würde dann anhand einer Config auf einen Ordner pollen etc. und die Daten als Stream in den Workflow füttern wo sie so auch wieder rausfallen und in einer Datei/DB landen.

Kannst ja verschiedene Quellen uns Senken bauen die nachher im Host konfigurierbar sind.

Probiers mal mit file://Pfad.wsdl

Unter welchem Account läuft der Service denn? Probiere einfach mal den Administrator Account aus und schaue ob es dann funktioniert. Wenn ja weisst du schon mal das es ein Berechtingungsproblem ist (Komme darauf da die Konsolenanwendung in der es geht wahrscheinlich aus der IDE mit Admin-Rechten gestartet wird).

So kann man sich und anderen (männlichen Kollegen) die Arbeit auch verschönern... Einfach mal ein paar schöne Bilder im Quelltext verteilen.
Geht mit der "Image Insertion" Extension von MS.

Oder man eignet sich das fehlende Wissen an, anstatt Technologien in bereichen zu verwenden wo sie nicht hingehören!

Da hast du mich ein bisschen falsch verstanden. Meine Aussage war da schon eher auf große Projekte/Produkte bezogen. Wenn die Webentwickler bzw. Webdesigner gerade "idlen" oder man das GUI-Design für billig Geld outsource will kann es gut sein das man mit HTML, CSS + JS eben besser beraten ist als mit WPF. Wenn dazu noch ein gutes Framework da ist welches die Einbindung einfach von statten gehen lässt spricht eigentlich nichts dagegen außer eventuell den Vorlieben.

Ein Grund könnte z.B. sein das HTML- und CSS-Wissen am Markt deutlich leichter und wahrscheinlich auch billiger zu bekommen ist als einen Designer der sich mit WPF auskennt. Wenn Anpassbarkeit an verschiedene Kunden (CI, leicht anders Angeordnete Masken) also wichtig ist könnte HTML eigentlich genau passen. Außerdem kann man so externen Entwicklern leicht ermöglichen den GUI-Umfang um kleine tools etc. zu erweitern da ja Javascript ebenfalls möglich ist.

Zumal bei allen Unterschieden aufgrund der gemeinsamen Problemdomäne natürlich die wirklich relevanten Daten in allen Quellen vorhanden sind.

Und genau das ist der Punkt. Eigentlich läuft es immer auf eine relativ ähnlich Strukturierte Datenbank hinaus die alle Daten in aggregiert Form zusammenfasst: Ein Data-Warehouse.

Zum Vergleich könntest du dir mal die gängigen Preissuchmaschinen und die dazu passenden Implementierungen in den Open Source Webshops ansehen. Dazu muss man sagen das es sehr viele kleinere und teilweise stark spezialisierte Webshops gibt die ohne die Anbindung an solch eine Suchmaschine kaum gefunden würden und es somit im Interesse der Shopbetreiber ist. Bei den großen Anbietern sieht es da teilweise schon wieder ganz anders aus denn viele brauchen diese Suchmaschinen nicht (mehr) um ihre Sichtbarkeit zu steigern und können aufgrund ihrer Bekanntheit die Preise leicht anheben ohne einen Kundenschwund befürchten zu müssen. Da steht die Vergleichbarkeit der Preise wieder im Weg und einige Betreiber dieser Seiten wehren sich dann dagegen.

Zur Technik um externe Seiten zu parsen sei noch kurz gesagt das es wirklich kein Ding der Unmöglichkeit ist ein flexibles System zu schaffen um schnell auf Änderungen an den Seiten zu reagieren aber falls man nicht in einem Vertragsverhältnis mit dem Anbieter steht wird man ohne die entsprechenden Informationen vorab zu bekommen immer eine Ausfallzeit haben wenn sich die Seite ändert.

es würde schon reichen, wenn man die id´s absolut randomisiert und gewisse Schlüsselelemente der Seite html-hierarchietechnisch immer mal wieder umpositioniert.

Das könnte aber zu komischen Layouts führen da solche Änderungen in verschiedenen Browsern, gerade wenn es zufällig geschieht, eben auch eine zufällige Wirkung auf das eigentlich so sorgfältig geplante Layout der Seite haben kann (wird? IE6 und Freunde 😉 und mit relativen XPath-Abfrage etc. kommt man dann meist trotzdem zum Ziel.
AJAX Seiten stellen einen dort zum Teil vor größere Probleme allerdings auch nur dann wenn die Seite dadurch sowieso an ihrer Barrierefreiheit leiden würde was in der Regel nicht erwünscht ist.

Im Grunde ist es doch genau so (obwohl natürlich trotzdem ein ganz anderes Thema) wie in [FAQ] DB-Password/Kennwort/Connection-String sicher speichern. Absolute Sicherheit ist nicht möglich.

Und um noch komplett vom eigentlichen Thema abzuschweifen (immerhin sind wir im Smalltalk-Bereich) ist das Internet (spezifischer: HTML) auch gar nicht dafür ausgelegt das jeder seine eigenen Brötchen bäckt und sich dabei nicht in die Karten schauen lässt. Das vorerst große Ziel ist ja schließlich das semantische Web in welcher ausprägung auch immer und das würde in dieser Form so nicht funktionieren und den Fortschritt in diesem Bereich dratisch eindämmen.

Um eine grobe Vorstellung davon zu erhalten was man mit diesen Techniken heutzutage ohnehin schon anstellt bzw. anstellen kann kannst du dir ja auch das noch reinziehen: INDECT Deliverable 4.4 - A tool for pattern based information retrieval (Der Download ist sehr zäh, kann sich jeder bei denken was er möchte 😉 Als alternative Quelle habe ich noch folgenden Link gefunden: [PDF] XML Data Corpus: Report on methodology for collection, cleaning and unified representation of large textual data from various sources: news reports, weblogs, chat)

Hast du eine XSD zu deinem XML? Wenn ja könntest du den XmlSerializer benutzen das dürfte sich dann etwas eleganter gestalten.

Servus zusammen,

habe hier einen WCF Service im IIS gehostet der sich bei der Initialisierung aus einer Konfigurationsdatei einige Assemblies von der Platte lädt und die Typen daraus mit einigen Zusatzinformationen in ein Dictionary<Type, Zusatzinformation> speichert.

Pseudocode:

foreach (var file in bindingsDirectoryInfo.GetFiles("*.xml")) {
   IDictionary<Type, Zusatzinfo> typesInConfig = LoadAssembliesAndTypesFromDisk(file);
}

danach möchte ich natürlich den Key nutzen können um die Zusatzinfos wieder raus zu bekommen:

public void DoSomethingWithObject(object obj) {
   Type t = obj.GetType();
   Zusatzinfo z = typesInConfig[t];   // ---> KeyNotFoundException
}

Das funktioniert in einer Desktop-Anwendung auch ganz gut (da alles Assemblies im selben Ordner liegen und damit die .exe und mein Code die selben Assemblies heranziehen) allerdings nicht in einem IIS gehosteten Service (dort liegen die zur Ausführung benötigten Assemblies zur runtime alle in C:\Windows\system32\inetsrv).
Das Problem ist das der Parameter zwar grundsätzlich vom selben Typen ist, die Assemblies zur Initialisierung aber aus anderen Verzeichnissen geladen wurden -> andere Assemblies -> andere Typen.
Eventuell steh ich auch nur auf dem Schlauch aber was kann man dagegen tun?

Man kann die Header auch wenn man den HttpWebRequest benutzt einzeln bearbeiten: HttpWebRequest.Headers-Property

[Edit]
Hmm.. ned gelesen, den Hinweis gabs schon.

Na dann lasse doch deine Bemühungen hier: http://pinvoke.net/default.aspx/user32/FindWindow.html einfließen. Außerdem sollten dort bereits alle Fragen beantwortet sein.

Ziemlich genau das:

// Untypisiertes DataSet
DataRow rowToAdd = ds.Tables["Stifte"].newRow();
rowToAdd["Art"] = "Kugelschreiber";
rowToAdd["Farbe"] = "Blau";
ds.Tables["Stifte"].Rows.Add(rowToAdd);

// Typisiertes DataSet:
neuerStift.Art = "Kugeschreiber";
neuerStift.Farbe = "Blau";

bekommst du mit typisierten DataSets hin wenn du unbgedingt bei dieser Technik bleiben möchtest (angeschaut haben sollte man es sich ohnehin mal da "wichtiger" Bestandteil von ADO.Net).
Ansonsten kann ich mich den Empfehlungen der anderen es mal mit einem O/R Mapper wie dem Entity-Framework zu versuchen nur anschließen.

P.S.: Wäre in deinem Buch folgendes Kapitel: Gallileo Open Book - Stark typisierte DataSets

Ne im Ernst: WinCE ist wohl am komfortabelsten und wohl auch am gängisten.

Schau dir mal Data Transfer Objects an.

Im Grunde nur eine Klassse die deine Daten aus der Datenbank hält und die du durch die Schichten durchgibst (z.B. kannst du die DTOs in ein eigenes Assembly legen und dann von überall aus referenzieren.)

Einfach mal anschauen. Sollte eigentlich genau das tun was du suchst: yet another asterisk caller id

Man kann allerdings auch rdlc-Reports (dann ohne Server, rdl(c) <- steht für Client) benutzen und automatisiert mit einem versteckten ReportViewer Control daraus ein PDF Rendern.

Das würde in etwa so gehen:

                ReportViewer rv = new ReportViewer();

                ReportDataSource rds0 = new ReportDataSource("Test", TestDataTable);

                rv.LocalReport.DataSources.Add(rds0); // ... weitere Datenquellen


                rv.LocalReport.ReportPath = cmd.ReportName;
                string deviceInfo =
                  "<DeviceInfo>" +
                  "  <OutputFormat>EMF</OutputFormat>" +
                  "  <PageWidth>8.5in</PageWidth>" +
                  "  <PageHeight>11in</PageHeight>" +
                  "  <MarginTop>0.25in</MarginTop>" +
                  "  <MarginLeft>0.25in</MarginLeft>" +
                  "  <MarginRight>0.25in</MarginRight>" +
                  "  <MarginBottom>0.25in</MarginBottom>" +
                  "</DeviceInfo>";


                if (cmd.ReportParameters != null)
                    rv.LocalReport.SetParameters(cmd.ReportParameters.Values);

                Warning[] warnings = null;
                rv.LocalReport.Render("Image", deviceInfo, CreateStream, out  warnings);

Der obige Code rendert in eine Bilddatei für den späteren Druck. Als OutputFormat kannst du allerdings auch PDF angeben.

Weitere Beispiele gibts unter: Report Viewer Tutorials.

Bin erst jetzt dazu gekommen mir mal den kompletten Post anzusehen. Soll das ganze dann später ähnlich funktionieren wie das DataColumn.DisplayExpression Property? Das geht so wie du das gerne hättest mit dieser Library nicht.

Bleibt die Frage ob es überhaupt nötig ist. Würdest du es komplett zur Laufzeit evaluieren könntest du die Spaltendefinitionen in einer Konfigurationsdatei unterbringen und auch z.B. je nach Benutzerberechtigung setzen. Auch mit ein bisschen Sorgfalt und Test kannst du Fehler in der Spaltendefinition nahezu ausschließen.

ich sitze hier im Urlaub und meine Freundin meckert schon weil ich vor meinem Laptop am verzweifeln bin

Hmm... hat sie irgendwie recht. Viel spass noch im Urlaub :evil:

Ob das mit dem EF auch funktioniert ist zwar fraglich aber ein Versuch wäre es doch Wert: DynamicLINQ mit Linq2SQL funktioniert es vorzüglich.

Lass doch einfach mal die Arrays weg und arbeite direkt mit der TreeView.Nodes und TreeNode.Nodes Collection.

pizzaInDenWarenkorbButton_click(object sender, EventArgs e) {
   TreeNode aktuellHinzugefügtePizza = meinTreeView.Nodes.Add(pizzenComboBox.SelectedText);

// mach was mit aktuellHinzugefügtePizza 
// z.B. die gewählten Zutaten hinzufügen

}

würde dir für jede Pizza einen neuen Knoten im Tree anlegen.

klickt der user nun auf "nächste pizza" soll sich die position erhöhen und ein neuer tree erstellt werden

Du meinst wahrscheinlich eher ein neuer Root-Node im bestehenden TreeView?
Einen neuen TreeView dafür zu erstellen ist harter overkill und auch nicht unbedingt übersichtlicher.

Das mit der Position finde ich auch irreführend. Soll es heißen das die eine Pizza vor der anderen zubereitet werden soll?

Füge einfach für jede neue Pizza (also wann immer der Button "Pizza zu bestellung hinzufügen" gedrückt wurde) einen neuen Root-Knoten hinzu unter den du dann die Zutaten hängst.