Bin Freizeitprogrammierer.
Hab irgendwann mit 12 mal mit Visual Basic NET angefangen.
Dann so mit 14 auf Java getroffen.
Hab viel damit rumprobiert und auch viel Spaß gehabt.
Irgendwann dann, wahrscheinlich wegen der Syntax, auf C# gestoßen und seit einiger Zeit eben mit C# am programmieren.
Ist soweit auch ziemlich einfach.
Das Framework kenn ich ja noch aus den VB.NET Zeiten und die Syntax von Java.
Bin allerdings immer noch ziemlich am schwanken zwischen Java und C#.
Bin jetzt 15 und besuche die 10. Klasse eines Gymnasiums.
Habe dringend vor danach Abitur und zu machen und dann Informatik an einer Uni zu studieren.
Ich weiß dass ein Studium in Informatik an einer Uni viel Theorie bedeuted, aber genau das will ich.
Um zurück aufs Thema zu kommen: Besonders intressiert mich die Netzwerk- und Grafikprogrammierung.

Lg Chris

Dann lager den Thread aus.
Und wenn alle Daten empfangen sind, soll er ein Event aufrufen.
Dann wird auch deine GUI oder whatever nicht blockiert.

Lg Chris

Ah das macht Sinn!
Besten Dank für die Info, somit kann ich heute Nacht doch noch in Ruhe schlafen ;P

Lg Chris

Nur so nebenbei: Warum willst du eigentlich umbedingt die Daten der 404-Seite haben?
Wenn der Status 404 auftritt, weißt du doch was Sache ist.
Der Artikel ist nicht verfügbar.
Wofür dann das übliche "Diese Seite existiert nicht..." einlesen?

Natürlich weiß ich nicht was du überhaupt vorhast 😉
Allerdings intressiert mich eben, warum du das umbedingt brauchst (;

Lg Chris

Installiere mal "Live HTTP Headers" als Addon für Firefox.
Dort kannst Du mitverfolgen was genau passiert wenn Du einen falschen Artikel aufrufst.
Auch Firefox bekommt einen 404-Status zurück, allerdings werden IMO auch Daten mitgesendet, welche die Fehler-Seite ist, die Du beschrieben hast.

Ich würde an deiner Stelle wahrscheinlich eine Funktion schreiben, welche vorher prüft ob der Artikel existiert.
Sie könnte wie folgt aussehen:

bool TopicExists(String URL)
{
	try
	{
		HttpWebRequest Request = (HttpWebRequest)WebRequest.Create(URL);
		Request.Accept = "text/xml";
		WebResponse Response = Request.GetResponse();
		return true;
	}
	catch
	{
		return false;
	}
}

Lg Chris

// Edit mochte "boolean" nicht 😦

Suchen bildet (:
Zugriff auf Steuerelement aus Klasse
Nächste mal bitte erstmal suchen (Damit mein ich nicht nur die Suchfunktion, sondern auch die FAQ)

Lg Chris

Ohne Gewähr:

Du hast es eigentlich schon ganz richtig gesagt.
In der while-Schleife wird sofort abgefragt ob Daten verfügbar sind.
In der do-while-Schleife wird der erste Durchgang schon durchgeführt, dann wird geschaut ob weitere Daten verfügbar sind.

Das ganze hat was mit Timing zu tun.
while-Schleife: Es kann ja gut sein, dass noch garkeine Daten verfügbar sind, zum Zeitpunkt der ersten Abfrage.
do-while-Schleife: Daher wird erstmal gewartet, bis der Stream die ersten Daten (Maximal soviele wie die Länge des Buffers) eingelesen hat. Damit wird sicher gestellt, dass es tatsächlich soweit ist, dass die Daten vom anderen Ende über den Stream angekommen sind.

Also sollte theoretisch auch folgendes klappen (Damit du deine while-Schleife benutzen kannst (;)

while (!stream.DataAvailable)
{
	Thread.Sleep(50);
}

while (stream.DataAvailable)
{
	//Daten einlesen...
}

Damit wäre auch die Frage beantwortet wieso es mit der auskommentierten Sleep()-Methode und beim Debuggen funktioniert.
Einfach weil beidesmal die Daten mehr Zeit haben anzukommen.

Lg Chris (;

@JAck30lena: Okay ich probier mich dran! Danke!
@monson: Das war das erste was ich überprüft hab (;

Lh

Wie hast du denn die Sockets initialisiert, also ProtocolType SocketType etc.?

        public WASClient()
        {
            client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
        }

was wireshark ist, weiß ich nciht. du kannst dich bei aktiviertem tracing mit dem debugger dranhängen und im outputwindow sehen, was genau verarbeitet und gesendet wird und was empfangen wird.

Hört sich intressant an, allerdings verstehe ich (weder durch den Eintrag der MSDN, noch durch Google) wie man Tracing benutzt.
Ein Beispiel wäre super!

Lg Chris

Ich kannte den Begriff "Network Tracing" vorher garnicht.
Zwar finde ich diesen Eintrag in der MSDN: http://msdn.microsoft.com/en-us/library/a6sbz1dx.aspx , allerdings verstehe ich nicht wie es funktioniert und nicht was das überhaupt ist.
Der Name selbst sagt ja soviel aus wie "Netzwerk Verfolgung" - erinnert mich an WireShark.
Ist das sowas in der Art?
Wäre dir sehr dankbar wenn du mich in dem Thema ein wenig aufklären würdest (;

Lg

Der Rückgabewert ist unterschiedlich.
Aber zusammengefasst zwsichen 10'000 und 100'000.
Aber Welten weg von der eigenentlichen Anzahl von Bytes, die gesendet wurden! (Wie gesagt, ~3'000'000)

Lg

Hey,
ich arbeite zurzeit an meinem Projekt "WAS - Watch another Screen".
Es gibt einen Server und einen Client.
Der Server schickt als erstes ein Daten-Paket mit der Größe von ca. 3 Millionen Bytes.
Der Client liest die Bytes in einen Buffer ein.
Wenn ich mir nach dem Empfangen allerdings das empfangene Byte-Array anschaue, merke ich dass ab dem 16060. Byte nur noch 0en sind.

Hier die dazugehörigen Code-Schnipsel:

Die Send-Methode meiner Server-Klasse.

       public void Send(byte[] packet)
        {
            byte[] x = BitConverter.GetBytes(packet.Length);
            connection.Send(x); // connection = Socket
            connection.SendBufferSize = packet.Length;
            connection.Send(packet);
        }

Die GetPacket-Funktion meiner Client-Klasse:

public byte[] GetPacket()
        {
            while (client.Available == 0)
            {
                System.Threading.Thread.Sleep(50);
            }       
            byte[] l = new byte[4];
            client.Receive(l); // client = Socket
            int x = BitConverter.ToInt32(l, 0);
            byte[] buffer = new byte[x];
            client.ReceiveBufferSize = x;
            client.Receive(buffer);
            return buffer;
        }

Übrings: Vor jedem Packet werden immer erst 4 Bytes vom Server gesendet, welche dem Client sagen, welche Größe das Byte-Array hat, damit der Buffer dementsprechend groß initialisiert werden kann.

Was komisch ist: Wenn ich die Get-Packet - Funktion Zeile für Zeile debugge, kommen alle Bytes an...

Kennt ihr dieses Problem, könnt ihr mir helfen?

Lg Chris!

Allerdings müsste dann jede Nachricht zuerst zum Server geschickt werden, der dann die ggf. verarbeitete Nachricht an alle anderen weiter leitet.

Na und?
Quasi jeder Multiuser-Chat basiert auf diesem Prinzip (;
Genau so solltest du es auch machen.
Einer spielt die Rolle des Servers bzw ebenfalls als eigener Client.
Alle Clients verbinden sich zum Server, also dem Host-Computer, über einen vorher festgelegten Port.
Die Clients können dann Befehle/Nachrichten/Whatever an den Server schicken, und dieser kann die empfangenen Daten auswerten und eine "Antwort"/Resultat an alle Clients schicken.

Lg

Heise hat natürlich auch noch seinen Senf dazu gegeben: http://www.heise.de/newsticker/Wolfram-Alpha-Der-Countdown-laeuft--/meldung/137933
Bin schon ziemlich gespannt darauf, das Projekt auszuprobieren (:

Und mein unscheinbarer Desktop. (Habs gerne aufgeräumt)

Cool dr4g0n76, den Trick kannte ich noch garnicht!

Edit: Aber wenn ich grad mal drüber nachdenk...das ist einfach nur logisch. (Okay, das sind eigentlich alle Tricks, nciht wahr?)

Bin seit 2 Jahren Schlagzeuger und seit 4 oder 5 Jahren spiele ich Akustik-Gittare.
Lieder schreib ich in GuitarPro.

Lg

Und auch ich habe wieder was gelernt.
Ich dachte, der Timer würde weiter laufen, auch wenn der Thread in dem der Timer initialisiert und gestartet wurde, beendet ist.

Lg Chris

Ich will nur noch kurz was in den Raum werfen:
Schau dir mal die Funktion GetAsyncKeyState aus der user32.dll an.
(Auf die Weise hab ich sowas immer gelöst)
Infos dazu findeste genug hier im Forum oder auch in Google 😉

Lg Chris

Bitte lese dir mal genau den [Hinweis] Wie poste ich richtig?-Thread durch!
Dann würdest du eventuell Google benutzen und nach nichtmal knapp 5 Sekunden auf dieser Seite landen: http://dotnet-snippets.de/dns/c-timer-anlegen-SID111.aspx

Trotzalledem: Frohe Ostern auch dir 😉

Lg Chris

Mit dem WebBrowser-Steuerelement kenn ich mich zwar nicht aus, da ich es nie benutze, aber versuch mal:

while (webBrowser1.ReadyState != WebBrowserReadyState.Complete)
{
        Thread.Sleep(100);
}

Lg Chris

Tic-Tac-Toe oder 4-Gewinnt.

Bei Tic Tac Toe sehe ich das Problem, dass es fast identische Intelligenzen werden, die immer Unentschieden spielen würden.
4-Gewinnt ist aber auch ne sehr gute Idee.
Ich glaub, ich werde mich bald einfach mal dran, einen Spiele-Server fürn 4-Gewinnt-Spiel zu programmieren, vielleicht finden sich ja dann Leute die Bock haben Clients (KI's) zu schreiben. 😃
Lg

Hey,
mir ist vorhin was witziges in den Sinn gekommen.
Man könnte doch mal ein Battle zwischen 2 Schach-KI's machen.

Das heißt, 2 Leute programmieren, jeder für sich, ein Schachprogramm.
(Also jeder programmiert die Schach-KI, die immer ausrechnet, welcher der klügste Zug grade ist).
Dann programmiert jemand noch einen Server.
Die Schachprogramme beider Gegner verbinden sich dann zum Server.
So dann wird noch entschieden wer anfängt (Wer Weiss ist).
Der fängt dann als erster an, einen Zug auszuführen.
Also das Programm entscheidet sich für seinen ersten Zug, sendet diesen an den Server, der Server wertet aus, und schickt das Resultat an beide Clients (Gegner).
Dann ist die Gegenseite dran.
Alles läuft halt über diesen Server, der selbstverständlich alle Spielregeln einprogrammiert hat.

Aber ich weiß...allein den Server mit den ganzen Spielregeln zu programmieren wäre ne ziemliche Arbeit.
Außerdem müsste man dann noch ein eigenes Protokoll erfinden, damit die Clients mit dem Server auch kommunizieren können.
Und dann "einfach mal so" ne Schach-KI zu programmieren ist auch sehr kompliziert.
Also beim Server würde ich sehr gerne mitarbeiten, da ich viel Erfahrung im Thema Netzwertechnik habe, aber selbst einen "Schachclient" zu programmieren..nep, das würde ich niemals hinbekommen 😃

Eigentlich weiß ich auch, dass sehr wahrscheinlich keiner die Zeit und Lust hat bei sowas mit zu machen, aber ich wollte meine Idee einfach mal zu "Papier" bringen und euch fragen, wie ihr diese Idee theoretisch findet 😉

Lg Chris

Jah, aber du kannst ja nicht, nur um die Filegröße rauszubekommen, jedes Mal die komplette Datei herunterladen?!
Wie gesagt, ich würde das ehr sowas machen in Richtung:

WebRequest request = WebRequest.Create("http://www.microsoft.com/mspress/images/banner.gif");
WebResponse response = request.GetResponse();
MessageBox.Show(response.ContentLength.ToString());

Ist jetzt ausm Kopf geschrieben, kA ob das alles so passt (müsste aber eigentlich funktionieren)

Lg

Ich würde es etwa wie folgt lösen:

• WebRequest erstellen
• WebResponse abfragen
• ContentLength auslesen

Lg Chris

Warum machst du das in einer Schleife?
Wie wäre es mit:

List<byte> listofbytes = new List<byte>();
listofbytes.Add(1);
listofbytes.Add(2);
listofbytes.Add(3);
//.....
socket.Send(listofbytes.ToArray());

Und wenn es umbedingt in einer Schleife sein muss, würde ich einfach nach der Send-Anweisung noch ein:

socket.Flush();

einbauen, um sicher zugehen, dass auch jedesmal wirklich etwas versendet wird.
Bzw vllt gehts auch, wenn du es nach der Schleife einmalig einbaust.
Musste bisschen rumprobieren.

Lg Chris

Coole Sache, kannte diesen Namespace noch garnicht, geschweige denn diese DeflateStream-Klasse (;
(Und sie beruht, nach dem was ich gelesen hab, sogar auf dem Huffman-Algorithmus)

Wie auch immer, hab mir jetzt folgende Funktion geschrieben:

public byte[] CompressByteArray(byte[] input)
{
MemoryStream ms = new MemoryStream();
DeflateStream compresseStream = new DeflateStream(ms, CompressionMode.Compress, true);
compresseStream.Write(input, 0, input.Length);
compresseStream.Close();
byte[] output = new byte[(int)ms.Length];
ms.Read(output, 0, output.Length);
ms.Close();
return output;
}

Das Input-ByteArray hat ne Länge von 288000.
Das Output-ByteArray ist nacher zwar ca. 70% kleiner, aber es besteht nur aus Nullen.
Wo ist mein Fehler?

Liebe Grüße 😉

Edit: [ QUOTE ] durch [ CSHARP ] ersetzt 😉

Edit:

So, habe den Code nun nochmal umgeschrieben:

        public byte[] CompressByteArray(byte[] data)
        {
            MemoryStream compresseStream = new MemoryStream();
            DeflateStream deflateStream = new DeflateStream(compresseStream, CompressionMode.Compress, true);
            for (int i = 0; i < data.Length; i++)
            {
                deflateStream.WriteByte(data[i]);
            }
            deflateStream.Flush();
            deflateStream.Close();
            byte[] compresseddata = compresseStream.ToArray();
            return compresseddata;
        }

Zwar bekomme ich jetzt kein leeres Bytearray mehr zurück, allerdings ist es 72% größer als das, was ich als Input-Daten übergeben habe.
Man man man, erst bekomm ich garnichts zurück...und dann zuviel 😁

Also nochmal die Frage, was mache ich Falsch? 🙁

Lg

Edit: Okay, habs nun hinbekommen 😉 Danke für den Tipp.

Hey Danke erstmal für deine Antwort, allerdings kann ich damit jetzt nicht sehr viel anfangen, könntest du dich noch etwas konkreter ausdrücken?
Außerdem frage ich mich, ob die Performance da mitspielt.

Lg

Hey,
mein Server sendet etwa jede viertel Sekunde genau 4+228000 Bytes an meinen Client.
Lokal geht das auch einwandfrei, aber wenn das ganze durchs Internet läuft, macht meine Verbindung halt nicht mit...
Desshalb dachte ich mir, dass ich mein dickes Datenpaket "verpacke".
Ich dachte da an den Hoffman-Algorithmus.
Die Theorie, wie dieser Algorithmus funktioniert hab ich komplett verstanden.
Nur mit der Umsetzung komm ich überhaupt nicht klar, da ich noch nie mit einzelnen Bits gearbeitet habe.
Es gibt einige Sourcecodes für diesen Algorithmus, sogar welche in C#, aber habe große Probleme diese in mein Projekt einzubauen.
Ich weiß nähmlich zB auch nicht, wie man den Huffman-Baum noch verschicken soll usw.
Kann mir das eventuell jemand erklären?
Oder hat jemand vllt noch nen anderen Lösungsvorschlag für mich?

Lg Chris 😉

Hey, danke erstmal für die Antworten.
Also z.Z. löse ich das ganze noch so:

        public byte[] GetScreen()
        {
            Bitmap screen = new Bitmap(SystemInformation.VirtualScreen.Width, SystemInformation.VirtualScreen.Height);
            Graphics gr = Graphics.FromImage(screen);
            gr.CopyFromScreen(0, 0, 0, 0, screen.Size);
            gr.Dispose();
            double sizeFactor = 600.0 / screen.Width;
            double newHeigth = sizeFactor * screen.Height;
            Bitmap newImage = new Bitmap(600, (int)newHeigth);
            using (Graphics g = Graphics.FromImage(newImage))
            {
                g.InterpolationMode = InterpolationMode.HighQualityBilinear;
                g.DrawImage(screen, new Rectangle(0, 0, 600, (int)newHeigth));
            }
            MemoryStream IS = new MemoryStream();
            newImage.Save(IS, System.Drawing.Imaging.ImageFormat.Jpeg);
            IS.Flush();
            return IS.ToArray();
        }

Die Idee von Chicklord, nur Änderungen im Bild rüberzusenden, finde ich sehr gut.
Hab da auch schonmal was probiert, aber das ist wie gesagt kräftig in die Hose gegangen ist.
Allerdings verstehe ich nicht ganz, wie du das meinst.
Also ich habe meinen Screen als Bitmap.
Diesen Screen vergleiche ich (außer beim ersten Durchlauf) mit dem vorherigem Screen. Jeder Pixel der anders ist bleibt, jeder der gleich geblieben ist, wird dann zu 0 0 0 (Ich verwende meistens 24Bpp). Das Bitmap wandele ich dann wie bisher in JPEG um, und schicke das Jpeg-Bild dann zum Client.
Nur würde das JPEG Bild doch dann beim Client verdammt merkwürdig aussehen?!
Überall würden durch die (0 0 0) schwarze Punkte/Fläöchen sein.
Oder wie meintest du das?

Um da nicht zu Komplex zu werden:

Ich bitte dich darum, komplex zu werden 😉
Ruhig schön ausführlich, wenns dir nichts ausmacht (:

Evtl. wäre für diesen Zweck auch eine Art Videostreaming geeignet...

Hört sich ebenfalls gut an, allerdings weiß ich nicht genau wie Video-Stream funktionieren, aber ich denke mal, nicht sehr anders als was Chickenlord da beschreibt, oder?

Danke nochmal für eure Hilfe 😉
Lg

Also ich wäre sehr intressiert an dem Projekt 😃
Am besten wäre halt wirlklich, wenn du es dann OpenSource machen würdest und den Code ein wenig kommentieren würdest 😉

Liebe Grüße und viel Erfolg

Versuch mal sowas in der Art davor zu setzen:

Bass.BASS_Init(-1, 44100, BASSInit.BASS_DEVICE_DEFAULT, this.Handle, null);

Edit: Grrrrrrr, zu spät.

Hey.
Ich programmiere z.Z. ein "Remote Screen" - Tool.
(Heißt: Server wartet auf Client, Client verbindet sich, Server schickt in regelmäßigen Abständen den aktuellen Screen an den Client, sodass dieser sehen kann, was auf dem Server-Computer grade passiert)

Da mein Versuch, nur jede Veränderung die auf dem aktuellen zum vorherigem Screen zu sehen ist, zum Client zu senden, kräftig in die Hose gegangen ist, hab ich mich halt jetzt entscheiden, tatsächlich immer den kompletten Screen rüber zu schicken.
Würde ich allerdings immer das komplette Bitmap verschicken, wären das jedesmal 1440000 Bytes (1,44MB).
Zusammensetzung: 6008003 (600 = Höhe, 800 = Breite, 3 = R, G und B)
Und wenn ich dann 10 Frames pro Sekunde verschicken will..wären das 14,4MB/s...und das macht meine Leitung leider nicht mit 😄
Desshalb müsste ich das Bitmap irgendwie verkleinern.
Damit meine ich jetzt nicht die Auflösung, die sollte schon bei 800*600 bleiben...
Aber es gibt ja noch andere Formate, wie JFIF (JPEG), PNG usw.
Nur wie funktioniert die Umwandlung?
Ich könnte das Bitmap als JPEG abspeichern und dann wieder laden, allerdings würde mir das zu lange dauern, und iwie finde ich das eine unsaubere Lösung.
Hat jemand Ideen/Anregungen/Tipps für mich?
Wäre super (:

Wie man sich das aktuelle Bild einer Webcam holst: WebCam mittels VFW in C#
Den Rest solltest du eigentlich selbst hinbekommen..

Hey, ich bin zurzeit mit dem Projekt "Watch another Screen" beschäftigt.
Dabei handelt es sich um eine Art "Remote Desktop", nur ohne Steuerung.
Also simpel gesagt:
> Server-Applikation auf einem Computer wartet auf Client
> Client verbindet sich zum Server
> Server sendet nun den aktuellen Desktop-Screen und alle darauffolgenden Veränderungen
> Client empängt diese Daten und stellt sich das Bild zusammen
So kann man halt vom Client-Computer aus sehen, was grade beim Server-Computer los ist.

Ich habe schon viel rumprobiert.

**1. Versuch: *Server macht ein Screen und verkleinert die Auflösung zu 800x600. Der Screen wird in 60 Teile/Spalten/Balken aufgeteilt (60(10px(y)*800(x)). Jeder "Balken" wird in einer Schleife durchgegangen, sobald auch nur ein Pixel anders ist, als beim lezten Durchgang, wird der komplette Balken als Byte-Array an den Client gesendet.
Im Schema:

Index-Byte(0-59), Pixel1-Color-R, Pixel1-Color-G, Pixel1-Color-B, Pixel2-Color-R, Pixel2-Color-G, Pixel2-Color-B, ... , ... Die X und Y Koordinaten kann der Client sich durch den Index-Byte selbst zusammenrechnen.
Bei diesem Versuch allerdings, wurde das ganze wirklich "balkenmäßig" beim Client angezeigt..also man hat tatsächlich gesehen dass Balken für Balken erneuert wurde..und das auch nicht wikrlich schnell.

2. Versuch: Server macht alle 300 Millisekunden (0,3s) ein verkleinerten Screen (800x600) und versendet ihn komplett zum Client. Das lief sogar sehr gut, allerdings nur lokal auf meinem Computer. Würde man das ganze durchs Internet machen, bräuchte man einen Upload von 5-6 MB pro Sekunde. (Und das auch noch bei einem schlechten FPS-Verhältnis)

3. Versuch: Server macht ein Screen und verkleinert die Auflösung zu 800x600. Server verschickt den kompletten Screen zum Client. Der Client speichert das Bild und zeigt es an. Nun wird in einer Schleife immer wieder ein Screen gemacht und jeder einzelene Pixel wird auf Veränderung überprüft. Ist ein Pixel anders, wird dieser in einem 5-Byte-Paket im Schema [Pixel-X, Pixel-Y, Pixel-Color-R, Pixel-Color-G, Pixel-Color-B] versendet.
Der Client empängt den Pixel er wird nun also im Bild ausgetauscht.
Das läuft aber soooooooooo langsam, dass man tatsächlich jeden einzelne Pixel-Veränderung beobachten kann.

Bei allen Versuchen:

• wird als Format für das Bild Bitmap benutzt
• wird zur Darstellung beim Client eine Picturebox benutzt
• eine TCP-Verbindung benutzt
• wie schon gesagt, eine Auflösung von 800x600 Pixel benutzt

Was ich nun bräuchte, wären nur theoretische Vorschläge wie man mein Anliegen bewältigen könnte.
Was ich halt gerne hätte:

• Eine Auflösung von 800x600 Pixel
• Das Bild sollte sich flüssig ändern beim Client

Ich bin für jeden Verbesserungsvorschlag/Ratschlag/Tipp wirklich dankbar!

Solltet ihr irgendwas nicht verstanden haben, bitte umbedingt nachfragen.
(Da ich weiß, dass ich nicht der beste Erklärbär bin)

Lieber Gruß. Chris 😉