Trux

kann nicht von "string" in "System.Diagnostics.ProcessStartInfo" konvertiert werden.

Finde ich recht eindeutig:

using System.Diagnostics;

[...]

ProcessStartInfo startInfo = new ProcessStartInfo("www.rtl.de");

Process process = new Process(startInfo);

process.Start();

System.Diagnostics.Process.Start(new System.Diagnostics.ProcessStartInfo("www.rtl.de"));

Naja, wenn er 1,5 min braucht ist es liegt das Problem wohl ein wenig tiefer...

Denke das du die Verbindung via DNS-Name aufbaust, um den namen aufzulösen und rauszufinden das der zielrechner grade nicht erreichbar ist braucht es alles zusamme denke ich seine zeit. Was du altanativ machen kannst ist die rechne einfach so "anzupingen" ping-classen findeset du eine menge via google.

Oder einfach IP-Addressen verwenden

also text farbe:

label.ForegroundColor = Color.Red;

byte Array:

möglichkeit 1:

byte[] byArray = new byte[] {0,1,2};

möglichkeit 2:

string strTest = "Tester String";

List<byte> byList = new List<byte>();

byList.Add(0);

byList.Add(1);

foreach(char cSign in strTest)

{

if(byList.Contains((byte)cSing)

{

//Invalid

}

}

ich denke es kommt drauf an wo man die Berechnungen ausführt...

(Also ich hab es jetzt alles nicht getestet, ist nur so aus der Luft gegriffen)

Also wenn man die "Krasse berechnung" im ButtonClick oä ausführt kann ich mir gut vorstellen das es nicht hinhaut mit dem wait cursor...

Also ein Funktionsaufruf ist ja bekanntlich syncron.

Wenn du zu beginn den Cursor auf wait stellst und in deiner Methode noch was machst, dann wieder auf normal schaltest kann der Thread in dem du ausgeführt wirst doch garnich den Cursor ändern.

Will heißen das du den cursor oder die berechnung (schleife) in einem anderen thread-context ausführen solltest.

Also ganz wichtig ist das es in C# keine "globalen" funktionen gibt.

Es geht einfach nicht, weil die sprache komplett objekt orientiert ist, und nicht nur so halb wie c++.

Also brauchst du schonmal eine Klasse in der du deine Threading methode hast. Inwieweit das Threading im Compact-Framework unterstützt wird kann ich nicht sagen.

using System;

using System.Threading;

namespace example

{

     public class ThreadExample

     {

          public void Start()

          {

               Thread t = new Thread(new ThreadStart(Thread));

               t.Start();

          }


          private void Thread()

          {

               while(true)

               {

                    //Mach was

                    Thread.Sleep(1000);

               }

          }

     }

}

Ich denke das du überlegen solltest eine Factory zwischenschalte um deine restrikstionen einzubauen.

Also hast du das jetzt mal versucht den Button im Init / PreInit zu erstellen, der ControlCollection hinzuzufügen als auch den Event anzubinden.

Ich meine das es einfach nur ein timing problem ist...

hast du bei der text-box das auto-postback aktiviert?

Also wenn du deine Controls erst im PageLoad erstelltst ist es viel zu spät. Denn das PageLoad ist das erste der abgearbeiteten events.

Versuch es mal im Init / PreInit, msdn: ASP.NET Page Life Cycle

Wann bindest du denn den event an?

Also in welchem Page Event. Du musst da eine gewisse Reinfolge einhalten damit im ProcessPostBack der Event schon angebunden ist, und somit der Click verarbeitet werden kann.

Must dir sonst eifach mal die Verarbeitungs Reinfolge der ASP.Net page anschauen.

Also wenn du die Form deiner applikation drucken möchtest kannst du das Graphics über CreateGraphics() von der Form abrufen.

Wenn der druck kram von C# (hab noch nie gedruckt) ein image haben möchte (wo von ich ausgehe) kann man den Graphic mittels

BitBlt kopieren:

/// <summary>

/// BitBlt

/// </summary>

[DllImport("gdi32.dll", ExactSpelling=true, SetLastError=true)]

public static extern bool BitBlt(IntPtr hObject,int nXDest,

                                   int nYDest,

                                   int nWidth,

                                   int nHeight,

                                   IntPtr hObjSource,

                                   int nXSrc,

                                   int nYSrc,

                                   TernaryRasterOperations dwRop);


Graphics gr = Form.CreateGraphics(); //Graphics von der Form erstellen lassen

IntPtr pGr = gr.GetHdc(); //Pointer auf den Hdc

BitMap bmp = new BitMap(Form.Width,Form.Height); // Neues Bitmap erstellen => Ziel

Graphics tmpGr = Graphics.FromImage(bmp); //Temp Graphics für das BitMap

IntPtr pTmpGr = tmpGr.GetHdc(); //Pointer vom tmpGraphis

BitBlt(pTmpGr,0,0,Form.Width,Form.Height,pGr,0,0,0x00CC0020); //Graphic inhalt kopieren

gr.ReleaseHdc(pGr); //Hanleds wieder releasen

tmpGr.ReleaseHdc(pTmpGr);

gr.Dispose();//Disposen

tmpGr.Save();

tmpGr.Dispose();


bmp ///Bitmap von der Form

Die möglichkeite besteht.

Es kommt bei der Umsetzung jedoch auf deine Struktur drauf an.

Wenn du eine object-factory über remoting abrufst kannst du es natürlich mithilfe der Factory limitieren.

Oder du überschreibst die CreateObjRef (von Marshal) und implementierst einen statischen counter.

Und wenn der wert überschritten wird kannst du mithilfe (ich glaube) remoting services das angeofrderte object wieder disconnecten (disconect object).

Als dritte möglichkeit kann man sicherlich auch von ObjRef erben (MSDN ObjRef) es damit realisieren.

Hat sich erledigt, muss anstelle des IntPtr ein Pointer-Pointer erstellen.

So noch mal ein frage am rande, gibt es eine elegantere methode als:

IntPtr pHdc = g.GetHdc(); //Pointer

IntPtr ppHdc = IntPtr.Zero; //Pointer-Pointer

unsafe

{

     int nHdc = pHdc.ToInt32();

     int* npHdc = &nHdc;

     ppHdc = (IntPtr)npHdc;

}

also ich erstellen ein Bitmap, mithilfe dessen ich ein Graphics erstelle.

Von dem Graphics über gebe ich den IntPtr an das ComObject, welches dann letztendlich in mein Bitmap zeichnen soll.

Ein HDC* ist ein Pointer.

Schon klar

Anders: ich bekommen eine adresse auf einen Speicherbereich in dem kein HDC abgebildet ist...

Ich habe unter C# ein Graphics-Object und möchte aus einer C++ DLL via Com mit diesem Graphics-Object malen.

Das ganze sieht vie folgt aus:

Die C++ DLL wurde mit ATL erstellt, und hat ein Interface mit einer Methode Draw(HDC* hdc).

Unter C# habe ich ein ComObject mit der Methode Draw(IntPtr hdc)

wenn ich nun von einem Graphics den HDC pointer (GetHdc()) abrufen und übergebe, bekomme ich auf der C++-Seite nur ein pointer mit dem nicht viel anzufangen ist.

Ist mein weg grundlegend falsch, oder gibt es da ein trick wie ich das gewünschte ziel erreichen kann?

Danke für eure hilfe

Hi,

ich verweise einfach mal auf

http://forum.fachinformatiker.de/showthread.php?p=913499#post913499

Danke für die Hilfe

Hallo,

ich würde gerne eine .Net-Assembly via VB aus Excel heraus aufrufen.

Mit C++-DLL's ist das ja entsprechend einfach. ala

Private Declare Function Test Lib "Test.dll" Alias "?Test@@YG@@Z" (ByVal strText As String, ByRef var As Variant) As Variant

public function schreib(ByVal strText As String) As Variant

   Dim varRtn As Variant

   schreib = Test (strText, varRtn)

End Function

somit kann ich in X-beliebiger Celle

=schreib("Testausgabe")

eingeben und VB würde meine Funktion in der DLL aufrufen.

Kennt irgendwer eine Möglichkeit ähnliches für eine .Net-DLL zu schaffen?

Gruss und Danke

Trux

Ich weiß ja nicht genau wuzu du das machen willst aber mit den Mutex kann man auch einen Thread "warten" lassen...

Timeout.Infinite-Feld:

Eine Konstante, mit der eine unbegrenzte Wartezeit angegeben wird. Dieses Feld ist konstant.

Thread.Interrupt-Methode:

Unterbricht einen Thread, der sich im WaitSleepJoin-Threadzustand befindet.

Also ich weiß ja nicht was du erreichen möchtest, aber ich würde das

Thread.Sleep(Timeout.Infinite);

firstThread.Interrupt();

rausnehmen

is das umsonst?

Ja, die DockPanel Suite ist umsonst und OpenSource.

btw hab ich hier vs2003....

Der VS2005 skin funktioniert glaube ich auch unter VS2003 weiß das aber nicht so genau.

Mit der WeifenLuo DockPanel Suite läßt sich das relativ einfach realisieren.

Skin für einen VS 2005 Look

Kommt auf deine Struktur drauf an, möglich dass es nicht ohne geht.

Möglich wäre auch internal statt public / private zu verwenden.

So weit ich weiß gibt es den Befehl so unter .Net nicht mehr.

Schau dir mal die ProcessInfo klasse und auch die ProcessStart an.