definitiv nein.
es kann sein, wenn du die verbindung offen hälst und keine kommunikation stattfindet, dass das die verbindung einfach zu gemacht wird. Ist normales TCP.
Um das zu verhindern, musst du einen Heartbeat einbauen (also eine Message die alle X sekunden geschickt wird) und auf die, die der server antwortet per echo oder so.

das problem sollte dann aber bleiben, weil es auch TCP ist.
Nur das protokol ist ein anderes. Denk mal drüber nach! 😃

ja, msmq kenn ich.

aber glaub mir, "so simple" ist es nicht.
aktienkurse etcpp. kann man nicht später anfordern, wenn man mit ihnen kritische berechnungen machen will.
je älter die info, desto unnötiger.
ich denke, ich hab ne zufriedenstellende lösung;
werde einen teil demnächst auf em block veröffentlichen und hier nochmal bescheid geben.

es ist eben ein TCP Timeout (der dann passiert, wenn die tcp queue voll ist).
Diesen Timeout kann man mit Socket.SetSocketOption(SocketOptionLevel.Tcp, SocketOptionName.SendTimeout, <value>); setzen.

und dann z.B. so abfangen (man kann auch Send ohne SocketError aufrufen und die SocketException abfnagen und deren ErrorCode auswerten):

SocketError errorCode;
int res = this.Socket.Send(bytes, offset, length, SocketFlags.None, out errorCode);
if (errorCode != SocketError.Success)
{
   if (errorCode == SocketError.TimedOut)
      m_bytesPerTimeout = (m_bytesPerTimeout * 9) / 10;
   else
      throw new SocketException((int)errorCode);
}

das solche timeouts passieren können, ist gang&gäbe.
Mein ganzes problem ist, dass der client alle daten verarbeiten muss, wenn er nicht schnell genug empfangen kann.
also z.b. stellt berechnungen anhand eines aktiernkurses an. er empfängt den ersten kurs und macht seine berechnung; jetzt ist die berechnung so zeitaufwendig, dass er nicht mehr nachkommt mit den kursen; d.h. aber auch, wenn er nochmal zum lesen kommt, sind die daten, die er liesst, veraltet.
dies will ich auf serverseite verhinden, in dem ich diese timeouts abfang und dann anfang, alte daten durch neue zu ersetzen. und dann wieder schicke, wenn er sich erholt hat.

unter Vista geht gar nix.
Blaues fenster mit weißen kästen.

Hi,

kann mir jemand erklären, wann man das eine oder ander benutzten sollte?
sehe momentan keinen direkt sinn für IList<ArraySegment<byte>>? hab aber ArraySegment auch nicht ganz verstanden, wann ich es brauche.

die kunst ist, die möglichen exceptions klar zu dokumentieren.
wenn die performance nicht ganz pro 1 hat, dann sind exceptions ok.

nette fingerübung.
aber ich kann ja auch direkt aufs lyricwiki gehen.

hier jetzt mal mein ansatz

Hier mein Ansatz:

Eine Message sieht folgendermaßen aus:

•      Message M  
  

o Priority (0 ... N), je höher, desto dringlicher
o Type (LOGON, ORDER UPDATE, QUOTE UPDATE, …)
o Identifier (verschiednes, basierend auf dem Type (z.B. eine OrderID=xyz, Ticker=SAP.FRA))

Der Server hat pro Client einen MessageSender. Dem gibt er die Messages. Der MessageSender überprüft zunächst,
ob er schon eine Message vom gleichen Type + Identifier hat.

•      Wenn ja, dann wird diese Message ersetzt (weil z.B. die ORDER=xyz in der Zeit 2 mal geändert wurde, die 1 Änderung ist veraltet, also brauch der Client nur die 2 Änderung )  
  

•      Wenn nein, wird die Message anhand der Priority in die Queue eingepflegt.  
  

Jeder MessageSender hat Send-Thread. Dort wird auf neue Messages in der Queue gewartet, gedequeued, serialisiert in BYTES B und an den Socket geschickt.
Pro Sekunde Zeit Interval Z (in Sekunden) merk ich mir jetzt die Anzahl der Bytes, die ich verschicke. Das mach ich erstmal so schnell, bis ich ne SendTimeout bekomm (Timeout ≤ Z).
Sobald ich nen Timeout bekomm, muss ich anfangen, das Senden zu drosseln.
Drosseln:
Idealfall: ich brauch kein Drosseln, sondern es wird direkt alles Verschickt. Ich kann also im Zeitraum Z, Bytes der Größe K verschicken
Timeout:
o Ich Drossel so, dass ich nur noch K = K9/10 bytes pro Z verschicke;
bekomm ich nach nach einer gewissen Zeitinterval ( sagen wir 10Z ) kein Timeout, dann berechne ich K neu
o K=K*11/10

Meinungen dazu?

interessant ist es ja.
ideal wäre ja der weg vom filesystem in das dms.
also ich kopier erstmal beim täglichen arbeiten alles auf ein gesharedes filesystem und diese files werden in das DMS übernohmen, wo ich sie dann auch später weiter managen kann.

Ich hab es selbst geschrieben, da auch unterschiedliche Clients in unterschiedlichen Programmiersprachen/Plattformen miteinander kommunizieren müssen.
Es handelt sich unter anderem auch über Events, die auf verschiedenen Kursen an verschiedenen Börsen der Welt passieren; da kann man keinen overhead gebrauchen 😃 an sich ist die kommunikation schon performant; nur manchmal ist es zuviel für den client, da der längere berechnungen machen muss und dann nicht mehr nachkommt mit den daten, die erbekommt.

danke für die antwort.
mach aber ganz normales tcp/ip über sockets mit eigenen messages um den traffic overhead zu minimieren.
was der server mitbekommt ist, dass er nix mehr an dem client schicken kann - das merkt man dann an einem timeout.
diesen fang ich ab und warte dann ein bissle und versuch es dann nochmal.
an der stelle kenn ich mich aber nicht ganz so gut aus, was die interner betrifft.
wenn eine message 100 bytes lang ist (also ich serialisiere mein object in bytes), bekomm ich ja über Socket.Send die anzahl der bytes zurück die wirklich gesendet werden. wenn ich jetzt 100 senden will, aber nur 50 verschickt werden, und bei den nächsten 50 ein timeout kommt, hab ich fast ein problem, da ich mir erstmal keine bytes merke sondern nur objekte.
denn wenn ein timeout kommt, weiß ich ja "ohoh, der client packt es grad nicht, um muss aufpassen, wieviel ich pro sekunde im schicke. 1, 2, 10, 100 messages? oder würdet ihr versuchen, das dann auf byte-ebene zulösen und über messages?

ja, er will das control aber nicht an seine DLL übergeben.

wenn der thread, nix von dem control weiß, wie ändert er es dann?

hmm schade, ich hatte gehofft, dass die xsi:type="MainFormSettings" genutzt würde.

was passier denn, wenn du jetzt einfach folgendes machst

public static SettingsCollection Load()
{
   SettingsCollection  retval = null;
   try
   {
      XmlSerializer serializer = new XmlSerializer(typeof(SettingsCollection));
      using(FileStream fs = new FileStream("configs\\settings.xml", FileMode.Open))
          retval = (SettingsCollection)serializer.Deserialize(fs);
      foreach (object o in retval.objs)
         retval.types.add(o.GetType());
  }
  catch {
  }
  return retval;
}

man muss nicht iterieren, wenn man den namen kennt,

string name = "Current";
try
{
   Control c = forms.Controls["rbtn" + name];
   if(c is RadioButton) 
   {
      // ...
   }
}
catch { }

public void Connect()
{
    try
    {
       newMessage("Verbindung zur SPS " + IPAdress + " wird initialisiert...";);
       System.Net.IPEndPoint ep = new System.Net.IPEndPoint(IPAddress.Parse(IPAdress), Port);
       socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);               
        //Callback für BeginConnect
        if (m_conCallBack == null)        
            m_conCallBack = new AsyncCallback(OnConnect);
        m_conResult = socket.BeginConnect(ep, m_conCallBack, socket);
    }
    catch (Exception ex)
    {
        _error = true;
        newMessage(ex.Message);
    }
}

public void OnConnect(IAsyncResult asyn)
{
    try
    {         
        Socket s = (Socket)asyn.AsyncState;        
        s.EndConnect(asyn);
        newMessage("Verbindung  aufgebaut";);
    }
    catch(Exception e)
    {
        newMessage(e.Message);
    }
}

nicht getestet.

hi,

nur mal so ne Bemerkung am Rande:
ich bin ja echt kein fan von ASP.NET (auch nicht von ASP). Ich finde, die sind da ganz einfach an der Aufgabenstellung vorbei.
Deswegen hab ich immer einen Bogen um .NET in Verbindung mit Webseiten gemacht.
Ich finde den neuen Ansatz - das MVC Konzept - viel ansprechender, wobei ich für den View auch keine ASP Seiten will.

nochmal:

dein Connected.WaitOne(); blockiert, nicht das connect.

genau; dein Connected.WaitOne(); blockiert.
um zu schauen, ob die verbindung geklappt hat, ist ja deine callback funktion da.
die wird in einem anderen thread ausgeführt. dort kannst du dann dein newMessage aufrufen (dran denken, Invoke zu benutzen)

clients verbinden sich mit meinem server, fordern live-daten an und bekommen diese dann auch.
je nach dem was der client tut, kann es passieren, dass der client nicht richtig nach kommt mit dem empfangen der daten (es gibt datenstaus).
diesen stau würde ich gerne auf der serverseite erkennen und dann den verkehr drosseln, so dass ich den client nicht unnötig weiter belaste.
mir ist klar, dass ich das teilweise mit timeouts regeln kann/muss.

habt ihr nen guten tipp/vorschlag für die umsetzung?

ohne jetzt den code anzuschauen: der private key sollte nur dem "normalen" server bekannt sein; nicht dem root/master server. also muss der normale das zertifikatrequest erstellen und diesen authentifiziern lassen und bekommt dann nur noch die signatur zurück, die er dann mit dem private key verbindet.

das musst du also bei dir einbauen.

hi. den text der exception würde ich schonmal nicht vergleichen, da der je nach system in einer anderen sprache sein kann (deutsch, spanisch, ...)
hast du mal geschaut, ob es irgendwelche InnerExceptions gibt, die auf eine SocketException zeigen?

du könntest auch dein protokol verfeinern, in dem du vor dein object noch selber die größe in bytes des objectes mit gibst (4bytes).
diese size liesst du zuerst, bevor du dann nochmal versuchst, bytes mit länge size zu lesen. und erst dann in deserialisierer steckst, wenn du alle bytes hast.
so kannst du sicher sein, dass alle daten da sind fürs deserialisieren, bekommst aber immer ne exception, wenn die verbindung abbricht.

Eine Möglichkeit, sich das zu sparen, jedem INSERT ein SELECT hinterherzuschießen, und dann die Rückantwort wieder in die DataTables einzupflegen, ist, die PrimKeys nicht in der DB zu generieren, sondern im Client.

ist vorallem sehr nett, wenn solche datenbanken irgendwann mal mit einer dritten mischen muss; bei autoincrement ids hat man es schwer, guid-ids helfen da schon eher. man muss es sich nur angewöhnen.

protected delegate void MethodFillListView(string);

private void addListViewItem(string filename)
{
    if(listView1.InvokeRequired)
    {
        listView1.Invoke(new MethodFillListView(addListViewItem), filename);
    }
    else
    {
        FileInfo fi = new FileInfo(filename);
        int len = (fi.Length / 1024);
        listView1.Items.Add(new System.Windows.Forms.ListViewItem(new String[] { utils.getFileName(filename), getSizeFromBitmap(filename), len .ToString() }));
    }
}

private void fillListView()
{
      try
      {
         foreach (String fName in ofd.FileNames)
         {
             this.addListViewItem(fName);
         }
         lblDir.Text = utils.getDirectory(ofd.FileName);
      }
      catch (Exception ex)
      {
         //TODO: Fehlerbox tütteln
      }
}

so wars gedacht (code nicht getestet). du benutzt ganz schön viele member variablen an den falschesten stellen. ofd würde ich dem thread mitgeben als kopie, dein fI und dein fLength gehören auch lokal, wie bei mir gemacht.

ja, hab es gelesen.
Wollte nur zeigen, wie es nicht geht. falls mal jemand nochmal sucht.
Mit der Grafikkarten API zu liebäugeln hab ich auch schon überlegt, nur kann es ja auch andere hersteller geben, deren api ich nicht zur verfügung hab.
hatte gehofft, es gibt da irgendetwas generisches.

Über die WMI-Klasse
> vielleicht?

nee, leider auch nicht

strComputer = "." 
Set objWMIService = GetObject("winmgmts:\\" & strComputer & "\root\CIMV2") 
Set colItems = objWMIService.ExecQuery( _
    "SELECT * FROM Win32_DesktopMonitor",,48) 
For Each objItem in colItems 
    Wscript.Echo "-----------------------------------"
    Wscript.Echo "Win32_DesktopMonitor instance"
    Wscript.Echo "-----------------------------------"
    Wscript.Echo "ScreenWidth: " & objItem.ScreenWidth
Next

Output: `

Win32_DesktopMonitor instance

ScreenWidth: 3840`

wo hingegen

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
    public struct DISPLAY_DEVICE
    {
        [MarshalAs(UnmanagedType.U4)]
        public int cb;

        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 32)]
        public string DeviceName;

        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 128)]
        public string DeviceString;

        [MarshalAs(UnmanagedType.U4)]
        public uint StateFlags;

        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 128)]
        public string DeviceID;

        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 128)]
        public string DeviceKey;
    }


    [DllImport("user32.dll", ExactSpelling = true, CharSet = CharSet.Unicode)]
    static extern bool EnumDisplayDevicesW(string lpDevice, int iDevNum,
       ref DISPLAY_DEVICE lpDisplayDevice, int dwFlags);

    [STAThread]
    static void Main(string[] args)
    {
        DISPLAY_DEVICE d = new DISPLAY_DEVICE();
        d.cb = Marshal.SizeOf(d);
        try
        {
            for (int id = 0; EnumDisplayDevicesW(null, id, ref d, 0); id++)
            {
                Console.WriteLine(
                    String.Format("{0}, {1}, {2}, {3}, {4}, {5}",
                             id,
                             d.DeviceName,
                             d.DeviceString,
                             d.StateFlags,
                             d.DeviceID,
                             d.DeviceKey
                             )
                              );
                d.cb = Marshal.SizeOf(d);
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine(String.Format("{0}", ex.ToString()));
        }
    }

Output:
0, \\.\DISPLAY1, Matrox Parhelia APVe , 5, PCI\VEN_102B&DEV_2538&SUBSYS_0947102B&REV_02, \Registry\Machine\System\Curren tControlSet\Control\Video\{CEDE138E-8FC1-4727-996A-6CC6FBABC14B}\0000 1, \\.\DISPLAYV1, NetMeeting driver, 8, , \Registry\Machine\System\CurrentControlSet\Control\Video\{8B6D7859-A639-4A15-8 790-7161976D057A}\0000 2, \\.\DISPLAYV2, RDPDD Chained DD, 8, , \Registry\Machine\System\CurrentControlSet\Control\Video\{DEB039CC-B704-4F53-B4 3E-9DD4432FA2E9}\0000

mal sehen, was ich noch so finde.

genau.

folgendes snippet hat mir auch nicht geholfen:

using System;
using System.Runtime.InteropServices;
using Microsoft.DirectX;
using Microsoft.DirectX.Direct3D;

class MainClass
{
    [STAThread]
    static void Main(string[] args)
    {
        foreach (AdapterInformation adapterInfo in Manager.Adapters)
        {
            Console.WriteLine("{0}", adapterInfo.CurrentDisplayMode);            
        }
    }
}

Output:

Height: 1024
Width: 3840
RefreshRate: 60
Format: X8R8G8B8

Hi,

ich würde gerne die die monitore enumerieren.
Zunächst hab ich die Screen Klasse aus System.Windows.Forms probiert.
Die liefert auf meinem System (Matrox Karte, 3 Monitore im Stretched mode: heißt auflösung 3840x1024) nur einen Screen. An der Grafikkarte hängen aber 3 Monitore.
Es müsste also einen Weg geben, die Grafikkarte direkt zu fragen.
Hat da jemand ne Idee?

du solltest darauf achten, dass du Oberfläche und Businesslogik klar voneinander trennst. ListViewItems sind ein GUI-Element und sollte keine Businesslogik enthalten.

ich weiß schon.
hintergund: die view zeigt Gewinn+Verlust von versch. Aktienkäufen und -verkäufen an.
diese Käufe/Verkäufe laufen nach einander ein.
Einmal kauft man 100 Aktien von dem einen Wert A, dann 200 von B, dann verkauft man 500 von A und später kauft man wieder 400 von A. Der Server (ist ne Client/Server anwendung) weiß im Grunde nix von Gewinn/Verlust, NetSize (also wieviele Aktien ich von welchem Wert noch im Bestand hab) oder Durchschnittspreis.
Das alles berechnet der Client. Wenn SubItem i nun den Durchschnittskaufpreis anzeigt, merk ich mir an dessen Tag die Anzahl der gekauften Aktien und deren gesamten Kaufpreis um so immer wieder den Durchschnitt berechnen zu können.

Eigentlich hast du recht: man sollte die Berechnungsdaten seperat speichern und damit rechnen und die view dementsprechend abändern.

ich will die listviewitem eben nicht selber zwischenspeichern (an den items hängen zusätlich infos (wie z.b. die berechnung der .Text property)) wodurch ich das Item und dessen subitems nicht wegwerfen will.

deswegen hätt ich eine property "a la" .Visible ganz schick gefunden.

Kennt jemand ne Möglichkeit oder schon ein fertiges Control, mit dem ich bestimmte Zeilen ausblenden kann ohne sie wirklich aus der Listview herauslöschen zu müssen?

ich geb dir recht.
so wie die klasse ist, kann man sie nicht wirklich gebrauchen (außer im UI umfeld, weil dann SynchronizationContext.Current auf eine object vom typ System.Windows.Forms.WindowsFormsSynchronizationContext zeigt). man müsste also SynchronizationContext als Basis nutzen und selbst was drumrum schreiben.

wenn ich mir folgenden artikel http://www.codeproject.com/KB/cpp/SyncContextTutorial.aspx liest es sich schon brauchbar, oder nicht?
übersehe ich etwas?

danke schön.

Hallo,

Windows.Forms hat ja die Möglichkeit, mit InvokeRequired zu checken, ob man sich im richtigen Thread befindet um dann ggf. mit Hilfe von Invoke eine Methode in der richtigen Thread aufzurufen.

So etwas will ich irgendwie nachprogrammieren. Ich hab eine C-API, die ich mit Hilfe von C++/CLI in ein Assembly gewrapped hab. die C-API verlangt, dass alles in einer Thread aufgerufen werden.

Ich hab jetzt eine Funktion in der API, der bei bestimmten Bedingungen einen Fehler wirft. In diesem Fall hab ich mir einen Scheduler gebaut (der in einer ganz anderen Thread läuft). diesem geb ich ein delegate auf die methode, die fehlgeschlagen ist, und eine uhrzeit mit und der scheduler ruft dann zur gegebenen uhrzeit, das delegate auf.

da der scheduler aber in einer anderen thread läuft, bräuchte ich etwas, um das delegate in die richtige thread zu schiften. weiß jemand, ob es schon sowas gibt?

hi.

welches format haben denn die antworten?
zeilen mit \r\n getrennt oder wie? vielleicht ein \0 am ende?
ich denke mal, es wird alles geschickt, aber du behandelst die antwort in result nicht richtig.

du solltest auch prüfen, ob recv > 0 ist, ansonsten gabs ein disconnect.

im grunde ist es ja kein fehler, sondern ganz normales verhalten.
beginreceive ist asynchron; wenn du server.close aufrufst, schließt du den socket; dann wird eben nocheinmal der callback von beginreceive aufgerufen
dort ist der socket. um das endreceive muss so oder so ein try ... catch und dann einfach ObjectDisposedException abfangen und ignorieren also beispielsweise

try { int l = s.EndReceive(ar); }
catch (ObjectDisposedException) { } // ignore
catch (SocketException se) { ... } // check se.SocketErrorCode
catch (Exception e) { } // fatal & unexpected

so; das hat ja alles nix gebracht;
hatte wohl irgendwie mit der AutoValidate Property rumgespielt; hab die jetzt mal auf Disable gesetzt (war vorher EnablePreventFocusChange) und jetzt scheint das verhalten wieder normal zu sein.

folgendes fenster hab ich

|-----------------------------------------|
|                                         |
|  |------------|         |------------|  |
|  | item1      | |-----| | itemA      |  |
|  | item2      | | <-> | | itemB      |  |
|  | item3      | |-----| | itemC      |  |
|  |            |         |            |  |
|  |            |         |            |  |
|  |            |         |            |  |
|  |------------|         |------------|  |
|                                         |
|-----------------------------------------|

ein fenster mit 2 listviews; dazwischen ein button
dieses fenster, soll man resizen können; ab jetzt helfen die standard anchors nicht mehr. bei einem resize soll nähmlich folgendes passieren

|-------------------------------------------------|
|                                                 |
|  |----------------|         |----------------|  |
|  | item1          | |-----| | itemA          |  |
|  | item2          | | <-> | | itemB          |  |
|  | item3          | |-----| | itemC          |  |
|  |                |         |                |  |
|  |                |         |                |  |
|  |                |         |                |  |
|  |----------------|         |----------------|  |
|                                                 |
|-------------------------------------------------|

die listviews sollen sich also gleichmäßig vergrößern + der button in der mitte bleiben.
hat jemand nen tipp?

musste folgendes tun:

        
protected override void OnClick(EventArgs e)
{
   base.OnClick(e);

    this.Focus();
}

leider nix ... aber danke.

hab das jetzt eingekreist. man kann meine mdi-fenster detachen (von dem mdi-verbund befreien) und wieder attachen. nachdem ein detachtes fenster wieder attched wurde, können die mdi-childs nur noch aktiviert werden, wenn auf deren titelleiste geklickt wird ...

etwas code dazu

protected virtual void OnAttachCommand()
        {            
            this.ShowInTaskbar = false;
            Form parent = this.Tag as Form;
            this.MdiParent = parent != null ? parent : Desktop.Instance;                                  
        }

        protected virtual void OnDetachCommand()
        {
            Form f = this.MdiParent;
            this.Tag = f;
            if (this.WindowState == FormWindowState.Maximized)
                this.WindowState = FormWindowState.Normal;
            this.ShowInTaskbar = true;
            this.MdiParent = null;            
            //this.Owner = f;                                   
        }

seh da keinen fehler ... vielleicht ist er dort auch nicht

Hi,

wieso muss man eigentlich, wenn man SymmetricAlgorithm implementiert, noch selbst auf den Ciphermode achten? sowas ist doch ein design-fehler nein?
Was haltet ihr davon?

hallo,

ich wühle mich gerade durch Hashing in c# und frage mich, wie man es wohl anstellt, einen md5 über chunks zu erstellen.
heisst, die daten kommen nacheinander an (kein stream), sie sind aber so gross. summiert sind die daten so gross, dass ich sie nicht im speicher halten will, sondern immer wenn sie ankommen, in die md5 function stecken und wegwerfen.
wenn dann irgendwann alle daten da sind, soll das resultat des md5 der selbe sein als hätte ich die daten als grosses byte[] array in ComputeHash gesteckt.

HCRYPHASH mit CryptHashData bietet das in CryptoAPI. im framework bietet das interface das irgendwie nicht. oder bin ich blind?

gibt nen howto dazu (leider vb.net) aber sollte leicht zu übersetzen sein

Simple Singleton Forms

mdiChild.MaximizeBox = false;
mdiChild.MinimizeBox = false;
mdiChild.ControlBox = false;

heb dir die handles con den controls doch einfach auf, und ändere die dann ab