Ich hab das using jetzt weggemacht aber es geht immer noch nicht.
Ich habe das ganze nochmal vereinfacht, vlt sieht jemand jetzt den Fehler:
var prov = new ScreenshotImageProvider (handle);
for (int i = 0; i < 100; i++)
{
var b = prov.NextImage ();
var file = path + "image" + i + ".bmp";
b.Save (file);
Thread.Sleep (300);
}
gibt:
Allgemeiner fehler in GDI+.
Der Screenshot wird über
Graphics.CopyFromScreen (left, top, 0, 0, new Size (width, height));
Die eigentliche Funktionalität des Export soll in eigenen Klassen liegen, die z.B. von IExporter ABgeleitet werden.
IExporter
{
void Export (IList<string> items);
}
Weiterhin soll es Presets geben, die bestimmte Eigenschaften des Export speichern. Z.B. für einen Export auf die Festplatte das Zielverzeichnis, bei einem Export zu Flickr den Anmeldename, das Zielalbum usw.
Jetzt is meine Frage, wie ich die Informationen, die ja auch an die Exportklasse übergeben werden müssen, dort hinaein bekomme, weil ja IExporter in der Export-Methode nur einen parameter hat. Ein Paramater-Array würde schon gehn, aber gutes Design sieht anders aus.
aus einem Programm möchte ich Fotos exportieren. Da soll an verschiedene Services möglich sein, z.B. Flickr, die Festplatte, Webgallery...
Die einzelnen Services sollen als Erweiterungen modular aufgebaut sein.
Weiterhin möchte ich, dass es möglich ist für jeden Service mehrere Presets zu erstellen, z.B. Speicherort, Albenverknüpfungen usw.
Ich habe schon ein bisschen rumprobiert, habe aber Probleme, die Funktionalität des Export zu den einzelnen Services von dem der Presets zu trennen.
Habt ihr Vorschläge nach welchen Entwurfsmustern ich das beschriebene Problem lösen könnte?
warscheinlch ist das ganze einfach, habe aber trotzSuche nichts zum Thema gefunden.
Angenommen ich habe eine Variable einer Enumeration (TestEnum a = TestEnum.ABC).
Jetzte möchte ich mit die Entscheidung treffen, ob a zu einer bestimmten Gruppe von Enumerationswerten dazugehört. Z.B.:
//b = true;
bool b = (a == TestEnum.ABC || a == TestEnum.DEF || a == TestEnum.GHI);
//b = false;
bool b = (a == TestEnum.DEF || a == TestEnum.GHI || a == TestEnum.JKL);
Gibt es eine Möglichkeit die Abfrage zu verkürzen (logische Operatoren?!) oder eine einfachere Möglichkeit zur Prüfung ob eine Variable zu einer Menge von Enumerationswerten dazugehört?
ich möchte in einem Programm eine Übersicht von Bildern aus einem Ordner anzeigen lassen. (So wie hier im rechten Teil der Oberfläche: http://f-spot.org/Image:Main-window.png)
Ich möchte also ein Control das eine Liste von Bilder anzeigt. Dazu habe ich jetzt ein paar Fragen bezüglich des Aufbaus.
Da ich zu jedem Bild mehr Informationen anzeigen will will ich für jedes Bild ein einzelnen Control verwenden. Diese Controls sollen dann von dem Übergeordneten angeordnet werden.
Haltet ihr das für sinnvoll oder sollte ich alles von dem großen Teil zeichnen lassen?
Wenn ich jedes Bild in einem extra Control anzeige: Ist es sinnvoller für die Anzeige eine PictureBox nehme oder das Bild per Hand zeichne? Was ist aus Speicher- bzw. Rechenzeitlicher Sicht zu empfehlen?
ich habe eine Klasse, die von XmlElement abgeleitet ist. Sie fügt nur einige Properties ein, die auf Attribute des Knotens zugreifen.
Jetzt habe ich einen string, der XML enthält. Mit diesem möchte ich eine Instanz meine Klasse erzeugen.
Gibt es dafür eine andere Möglichkeit als einen eigenen Cast-Operator zu schreiben?
ich versuche gerade einen einfachen Client zu schreiben, der mit einem von mir geschriebenen Server kommuniziert.
Grundlegend dafür ist eine Klasse, die auf einem Socket aufbaut und Daten versenden und empfangen kann. Wenn Daten empfangen werden wird ein Event gefeuert.
Dieses wollte ich in einer WinForms-Anwendung abfangen. Allerdings wird die erhaltene Nachricht nicht angezeigt, sie wird aber vom Socket empfangen und das Event wird ebenfalls gefeuert.
Die AsyncSocket-Klasse
/// <remarks>
/// AsyncSocket is the class that communicates with the server.
/// </remarks>
public class AsyncSocket
{
private Socket _socket;
private Decoder _decoder = Encoding.UTF8.GetDecoder();
private UTF8Encoding _utf = new UTF8Encoding();
private byte[] _buff = new byte[4096];
private Stream _stream;
/// <summary>
/// Occurs when a connection is established with a server.
/// </summary>
public event EventHandler Connection;
/// <summary>
/// Occurs when a message has been received from the server.
/// </summary>
public event EventHandler<MessageEventArgs> Message;
/// <summary>
/// Initializes a new instance of the <see cref="AsyncSocket"/> class.
/// </summary>
public AsyncSocket ()
{
_socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
}
/// <summary>
/// Establishes a connection to the specified remote host.
/// </summary>
/// <param name="hostname">Hostname to connect to</param>
/// <param name="ssl">Is this connection to be encrypted?</param>
public void Connect(string hostname)
{
IPHostEntry ip = Dns.GetHostEntry(hostname);
IPEndPoint ep = new IPEndPoint(ip.AddressList[0],5222);
_socket.Connect(ep);
if (_socket.Connected)
{
_stream = new NetworkStream(_socket);
}
_stream.BeginRead(_buff, 0, _buff.Length, new AsyncCallback(Receive), null);
OnConnect();
}
/// <summary>
/// Closes the current socket.
/// </summary>
public void Close()
{
_socket.Close();
}
/// <summary>
/// Writes data to the current connection.
/// </summary>
/// <param name="msg">Message to send</param>
public void Write(string msg)
{
byte[] mesg = _utf.GetBytes(msg);
_stream.Write(mesg, 0, mesg.Length);
}
private void OnConnect()
{
if (Connection != null)
{
Connection(this, EventArgs.Empty);
}
}
private void OnMessage(String message)
{
if (Message != null)
{
Message(this, new MessageEventArgs(message));
}
}
private void Receive(IAsyncResult ar)
{
try
{
int rx = _stream.EndRead(ar);
char[] chars = new char[rx];
_decoder.GetChars(_buff, 0, rx, chars, 0);
string msg = new string(chars);
_stream.BeginRead(_buff, 0, _buff.Length, new AsyncCallback(Receive), null);
OnMessage(msg);
}
catch (SocketException e)
{
}
catch (InvalidOperationException e)
{
}
}
/// <summary>
/// Gets the current status of the socket.
/// </summary>
public bool Connected
{
get { return _socket.Connected; }
}
}
Und das Formular:
public partial class TestForm : Form
{
AsyncSocket stream;
public TestForm()
{
InitializeComponent();
stream = new AsyncSocket();
stream.Connection += new EventHandler(stream_Connection);
stream.Message += new EventHandler<MessageEventArgs>(stream_Message);
try
{
stream.Connect("127.0.0.1");
}
catch (Exception ex)
{
richTextBox1.AppendText(ex.Message+"\n");
throw;
}
}
void stream_Connection(object sender, EventArgs e)
{
button1.Enabled = true;
}
void stream_Message(object sender, MessageEventArgs e)
{
richTextBox1.AppendText(e.Message + "\n");
}
private void button1_Click(object sender, EventArgs e)
{
stream.Write(textBox1.Text);
}
}
Original von svenson
Das Interfacé, welches vom Hauptprogramm genutzt und vom Plugin implementiert wird, muss als eigenständiges Assembly (Dll) vorliegen (nix drin außer Interface).
Ich hbae jetzt sichergestellt, dass die gleicher Version der Assambly verwendet wird. Die Namespaces sind auch gleich und es gibt nur ein Interface IRenderer.
Habt ihr noch irgendwelche Ideen, woran das scheitert?
also isValidPlugin() gibt auf jeden Fall true zurück.
Das Problem ist wahrscheinlich die Version der Bibliothek, in der IRenderer liegt. Das Projekt liegt zusammen dem der Oberfläche und der PLugins in einem VS-Projekt.
- Projekt (VS-Projektmappe)
- Bibliothek A (u.a. IRenderer)
- verschiedene Pluginbibliotheken B (Abhängigkeit auf A gesetzt)
- UI (Abhängigkeit auf A und B gesetzt)
Deshalb gehe ich eigentlich davon aus, das immer die aktuellste version beim kompilieren genutzt werden sollte.
ich möchte in einem Programm prüfen, ob eine Klasse ein bestimmtes Interface implementiert.
Dafür benutze ich, wie hier beschrieben, das is-Schlüsselwort. Allerdings wird nie in die Abfrage gesprungen.
ein Codeausschnitt:
if (isValidPlugin(plugin))
{
if (plugin is IRenderer)//Bedingung wird nie erfüllt
registerPlugin(plugin);
}
Hallo,
ich habe ein Programm, dass durch Plugins erweiterbar ist. Jedes Plugin soll in einen seperaten Unterordner des Anwendungsordners liegen.
Allerdings benötigt jedes Plugin bestimmte Dateien (Bibliotheken, die von Host und Plugin gebraucht werden) die schon im Anwendungsverzeichnis liegen.
Muss ich diese auch in jedes Pluginverzeichnis kopieren oder reichtb es wenn sie vom Host-programm geladen werden?
Ich danke schonmal für alle Antworten. Da ich jedoch zur Zeit keinen privaten Internetanschluss besitze kann ich nicht zeitnah antworten. (Frühestens Montag)
ich habe ein Panel, in das ich je nach Benutzereingabe mal mehr oder weniger zeichnen. deshalb wollte ich mittels Autoscroll(falls nötig) einen Scrollbar anzeigen lassen.
Allerdings habe ich festgestellt, dass der nur angezeigt wird, wenn ich Controls in das Panel schiebe. Zeichnen reicht nicht!
Wie kann ich das umgehen?
2. Frage: Wie kann ich außerdem einstellen, dass der Scrollbar unten ist nach dem Zeichnen?
