Ich erstelle gerade eine Anwendung, die verschiedene Berechnungen durchführt. Um möglichst flexibel zu sein, habe ich jede Berechnungsmethode in eine eigene DLL gepackt. Diese DLLs sollten nun nicht zur Compile-Zeit eingebunden werden sondern erst zu Laufzeit. Dadurch kann man jederzeit zusätzliche Berechnungsmethoden erstellen und diese dann einfach in das Anwendungsverzeichnis kopieren ohne die gesamte Anwendung neu compilieren zu müssen. Das Ganze funktioniert sogar zur Laufzeit, d.h. die Anwendung muss nicht neu gestartet werden, wenn eine neue DLL hinzukommt.
Das Ganze funktioniert so:
- Ich habe ein Interface erstellt, das als Schnittstelle für alle Berechnungsmethoden dient.
public interface IBaseEngine
{
void StartCalculation();
}
- Dann habe ich ein Berechnungsmodul erstellt, das die Schnittstelle implementiert. Berechnungsmodul und Interface sind im gleichen Namespace:
public class cCapaPlanerEngine : IBaseEngine
{
public cCapaPlanerEngine()
{
}
public void StartCalculation()
{
// Hier kommt die Berechnung
}
}
- Nach dem Compilieren wird die DLL des Berechnungsmoduls in das Anwendungsverzeichnis kopiert.
- Nun kann das Berechnungsmodul instanziiert werden:
IBaseEngine calculationEngine = (IBaseEngine)Activator.CreateInstanceFrom("CalculationEngines\\" + _CalculationEngineName + ".dll", "ScenarioGenerator.CalculationEngines.c" + _CalculationEngineName).Unwrap();
Da sind noch ein paar statische Sachen drin, die besser in die config ausgelagert bzw. automatisch ermittelt werden, aber so ist es momentan etwas verständlicher. Wichtig ist das Unwrap() am Ende, da sonst der Typecast nicht funktioniert.
Eine optimierte Version könnte etwa so aussehen, wobei hier in derm Berechnungsmodul nur eine Klasse stehen sollte:
Assembly calculationEngineAssembly = Assembly.LoadFrom(Properties.Settings.Default.CalculationEnginesPath + "\\" + _CalculationEngineName + ".dll");
calculationEngine = (IBaseEngine)Activator.CreateInstance(calculationEngineAssembly.GetTypes()[0]);
- Nun kann die Berechnungsmethode einfach aufgerufen werden:
calculationEngine.StartCalculation();
Weitere Berechnungsmodule lassen sich nun einfach erstellen indem sie die selbe Schnittstelle implementieren und dann einfach in das Anwendungsverzeichnis kopiert werden.
Man kann eigene enums in den Settings einer Anwendung avblegen. Dazu muss zunächst der enum definiert werden. Anschließend öffnet man die Settings-Datei des Projektes (liegt unter Properties). Im Feld Type kann man hier nun Browse... auswählen. 
Dann gibt man bei SelectedType den vollqualifizierten Namen inkl. Namespace ein. 
Nun kann man in der Spalte Value über eine DropDownList den gewünschten Wert für die Konfiguration auswählen. In der app.config sieht das dann so aus: < CalculationUnitApplication.Properties.Settings>
<setting name="Setting" serializeAs="String">
<value>CapaPlaner</value>
</setting>
</CalculationUnitApplication.Properties.Settings> Auf den Eintrag kann man dann aus dem Code so zugreifen: Properties. Settings.Default.mySetting wobei mySetting der Name ist, der dem Eintrag in der Settings-Einstellung im Feld Name vergeben wurde. Das Ganze ist jetzt typsicher, d.h. wenn jemand die Config-Datei bearbeitet und gibt einen Wert ein, der nicht im enum vorkommt, wird eine Exception geworfen.
Weder was zum Essen noch glänzt es, aber man wird reicher damit, zumindest an Wissen. Die MSDN-Nuggets sind Kurzfilme, die in 10-15 Min. Schritt für Schritt in ein Thema einführen. Gut davbei ist, dass man nach Thema und nach dem Niveau (Einsteiger - Experte) suchen kann.
Link to MSDN Nuggets
Wenn auf einer DataTable ein ColumnChanged-Event eingesetzt wird um bei Änderungen eines Wertes in der DataTable andere Werte in der selben table neu zu berechnen, ergibt sich das Problem, dass das zurückschreiben der neuberechneten Werte wieder zu einem ColumnChanged führt, was den Evbenthandler erneut aufruft und so in einer Endlosschleife endet, die mit einem StackOverflow endet.
Hier gibt es eine recht simple Abhilfe. Man deregistriert den EventHandler bevor die geänderten Werte geschrieben werden und registriert ihn danach einfach wieder. Das kann dann z.B. so aussehen:
void myTable_ColumnChanged(object sender, DataColumnChangeEventArgs e)
{
myDataSet.myTable.ColumnChanged -= new DataColumnChangeEventHandler(myTable_ColumnChanged);
RecalculateValues();
myDataSet.myTable.ColumnChanged += new DataColumnChangeEventHandler(myTable_ColumnChanged);
}
Folgender Code zeigt, wie man in eine Zelle im Infragistics-Grid Prozentwerte aus- und eingeben kann. Zu beachten ist hierbei, dass beim BeforeExitEditMode auf die Text-Eigenschaft zugegriffen werden muss, da der Value zu diesem Zeitpunkt noch nicht gesetzt ist.
private void ugShiftDetails_BeforeEnterEditMode(object sender, CancelEventArgs e)
{
if (this.ugShiftDetails.ActiveCell.Column.Key == "PercentColumn")
{
UltraGridCell c = this.ugShiftDetails.ActiveCell;
c.Value = ((double)c.Value) * 100;
}
}
private void ugShiftDetails_BeforeExitEditMode(object sender, Infragistics.Win.UltraWinGrid.BeforeExitEditModeEventArgs e)
{
if (this.ugShiftDetails.ActiveCell.Column.Key == "PercentColumn")
{
UltraGridCell c = this.ugShiftDetails.ActiveCell;
try
{
c.Value = Double.Parse(c.Text) / 100;
}
catch
{
MessageBox.Show("Invalid Input");
}
}
}
Die Lebensdauer eines Hosts und damit auch der Instanzen der darin enthaltenen Member kann über ein Attribut gesteuert werden. Mein konkreter Anwendungsfall war, dass ich einen Status speichern wollte, der von allen Clients über die gesamte Laufzweit meines Servers abgefragt werden kann. Der Host sollte dazu am einfachsten während der gesamten Laufzeit des Servers als einzige Instanz zur Verfügung stehen. Dazu einfach folgendes Attribut zur Host-Definition hinzufügen: [ServiceBehavior(InstanceContextMode=InstanceContextMode.Single)]
public class cClientHost : IClientInterface Über dieses Attribut lässt sich z.B. die Lebensdauer auch für die auer einer Session einrichten.
Die Fa. artiso (www.artiso.com) für die ich arbeite, sucht momentan einen .net Entwickler. Der Entwickler sollte über folgende Kenntnisse bzw. Eigenschaften verfügen:
- C#, SQL, Winforms, ASP.Net
- Projekterfahrung
-
Selbständiges Arbeiten
-
Qualitätsbewußtsein
Wenn jemand Inteeresse hat bzw. jemand kennt, der Interesse hat, können nähere Informationen unter tschissler@artiso.com erfragt werden.
Paint.Net ist ein kostenloses Grafik-Tool, das umfangreiche Funktionen zur Bearbeitung von Grafiken bietet. Gerade für Entwickler düfte das Tool vollkommen ausreichen und auch eine echte Alternative zu Photshop & Co sein.
http://www.getpaint.net/
Danke an Jonas für den Link
Um in Excel Zellen bis ans Ende einer datenreihe aufzufüllen (z.B. eine Summenformel etc.), kann man einfach den zu übernehmenden Bereich markieren und dann auf das kleine Kästchen rechts unten im selektierten Bereich doppelklicken.
Ich wollte nun das gleiche Ergebnis per VBA erreichen. Dazu habe ich die zu kopierende Zelle erst mal mit dem Namen "Copy" versehen. Dann kann man mit dem folgenden Befehl das AutoFill ausführen:
Range("Copy").AutoFill Destination:=Range("H3:H" & Range("G65535").End(xlUp).Row), Type:=xlFillDefault
Damit wird der Bereich "Copy" von der Zelle H3 bis Hx kopiert, wobei x die letzte Zeile der Spalte G ist, die einen Wert enthält.
In seinem Blog beschreibt bharry einige Fixes und neue Features des SP1 Beta für Team Foundation Server. Scheint wohl jetzt neu zu sein, auch für Service-Packs Betas anzubieten. Na ja so kommt man früher dran und es sind hinterher hoffentlich weniger Fehler drin - mal abwarten. http://blogs.msdn.com/bharry/archive/2006/09/26/772371.aspx
Das Tool selber hat zwar mit .net nix zu tun, ist aber für den Entwickler trotzdem interessant. Es gibt die System-Infos auf dem Desktop aus. Funktioniert auch, wenn man eine Hintergrundgrafik eingestellt hat. http://www.sysinternals.com/Utilities/BgInfo.html 
Beim Databinding möchte man oft Einfluss auf die Darstellung der Werte auf der Oberfläche nehmen. Ein typischer Fall hierzu ist z.B. das Databinding mit Prozentwerten. Hier hat man z.B. einen Wert 0,5 der als 50% angezeigt werden soll. Wenn der Benutzer dann 40% eingibt, soll dieser Wert in 0,4 konvertiert werden. Hierzu kann man die Format- und Parse-Events des Databindings verwenden.
Zuerst müssen die Events definiert werden. Dabei gehen wir in dem Fall davon aus, dass es sich um das erste Databinding auf dem Control handelt.
this.txtValue.DataBindings[0].Format += new ConvertEventHandler(ValueInputPercent_Format);
this.txtValue.DataBindings[0].Parse += new ConvertEventHandler(ValueInputPercent_Parse);
Dann können in den Eventhandlern die entsprechenden Formatierungen vorgenommen werden. Dies können natürlich auch noch mit entsprechenden Fehlerprüfungen versehen werden.
void ValueInputPercent_Parse(object sender, ConvertEventArgs e)
{
e.Value = Double.Parse(e.Value.ToString().TrimEnd('%')) / 100;
}
void ValueInputPercent_Format(object sender, ConvertEventArgs e)
{
e.Value = ((double)e.Value) * 100 + "%";
}
User-Controls werden im Designer von Visual Studio genauso instanziert wie zur Laufzeit. Um hier unterscheiden zu können, kann man mit der Variable DesignMode abfragen, in welchem Modus die Komponente momentan initialisiert wird. Die ist z.B. sinnvoll, wenn man beim instanzieren auf Objekte zugreift, die im DesignMode gar nicht zur Verfügung stehen. Hier ein kleines Beispiel:
public MyControl()
{
InitializeComponent();
if (!DesignMode)
{
try
{
shiftConfiguration.ReadXml(ConfigurationManager.AppSettings["ShiftConfigFile"]);
}
catch (Exception ex)
{
MessageBox.Show("Error reading Shift Configuration File\n\nError : " + ex.Message);
}
}
}
Ich habe heute ein Update meiner Blog-Software eingespielt. Es gibt da im Moment noch ein paar kleinere Probleme z.B. mit den Kommentaren. Ich bin dabei das zu beheben. Wenn jemand sonst noch Fehler auffallen, bitte mir kurz melden.
Als Erweiterung zu meinem Beitrag zum Übernehmen von Excel-Daten über die Zwischenablage (http://www.artiso.com/ProBlog/PermaLink,guid,2017b61d-19f4-4e4a-a033-cbf820d2b18e.aspx) hier nun das Gegenstück, Daten über die Zwischenablage an Excel übergeben:
string Data = "1,1;2,7;3,1;4,8;5,9";
Byte[] ClipboardData = Encoding.UTF8.GetBytes(Data);
MemoryStream ClipboardStream = new MemoryStream(ClipboardData);
DataObject DataObj = new DataObject(DataFormats.CommaSeparatedValue, ClipboardStream);
Clipboard.SetDataObject(DataObj, true);
Daten über mehrere Zeilen werden übrigens mit Environment.NewLine getrennt.
Der nachfolgende Code zeigt, wie JPEG Grafiken (und ebenso auch andere Formate) verlustlos rotiert werden können:
Image i = Image.FromFile(this.imageFilename);
ImageCodecInfo usedIC = this.GetEncoderInfo("image/jpeg");
System.Drawing.Imaging.Encoder encoder =
System.Drawing.Imaging.Encoder.Transformation;
EncoderParameters encparams = new EncoderParameters(1);
EncoderParameter encparam =
new EncoderParameter(encoder,
(long)EncoderValue.TransformRotate270);
encparams.Param[0] = encparam;
i.Save("filename.jpg", usedIC, encparams );
i.Dispose();
i = null;
GC.Collect();
Quelle: http://blog.norberteder.com/index.php?entry=entry060920-223506
.net bietet keine Funktion, um eine Form einfach auszudrucken. Diese Lücke schließt nun Microsofts PrintForm Component 1.0.
http://www.microsoft.com/downloads/details.aspx?familyid=286111b0-6965-46cc-bf6f-c5ee63b1f98c&displaylang=en#filelist
Damit läßt sich bereits mit 2 Zeilen Code eine Form ausdrucken.
this.printForm1.Form = this;
this.printForm1.Print();
Die Komponentebietet darüber hinaus noch eine Vielzahl von Einstellmöglichkeiten, z.B. zur Anzeige einer Druckvorschau etc.
Übrigens nicht durch den Namespace (Microsoft.VisualBasic.Powerpacks) irritieren lassen, die Compunente funktioniert auch unter C# 
User-Controls können auch mit eigenen Events erweitert werden. Das ist eigenlich recht simpel. Man definiert einfach einen Event, z.B.
public event EventHandler LinesChanged;
Dann ruft man an der Stelle, an der der Event ausgelöst werden soll einfach den Event auf. Das geht am einfachsten über:
LinesChanged(this, EventArgs.Empty);
Der Event kann dann außerhalb des User-Controls wie gewohnt mit einem Eventhandler ausgewertet werden. Möchte man mehr Informationen als den Sender übergeben, erstellt man sich einfach eine Klasse, die man von EventArgs ableitet und übergibt dann eine Instanz dieser Klasse beim Aufruf des Events, z.B.
public class MyEventArgs : EventArgs
{
private string msg;
public MyEventArgs( string messageData )
{
msg = messageData;
}
public string Message {
get { return msg; }
set { msg = value; }
}
}
Damit der Eventhandler nun auch noch den richtigen Datentyp für die EventArgs übergeben bekommt braucht mann noch ein Delegate, z.B.
public delegate void MyEventHandler(object sender, MyEventArgs e);
Der Event muss nun entsprechend deklariert werden:
public event MyEventHandler LinesChanged;
Um den Eventhandler nun zu erzeugen, legt man in der umgebenden Klasse eine Instanz des Objektes an, das den Event wirft. Auf dieser Instanz kann man nun den Event mit dem Handler verbinden. Das geht in VS ganz einfach. Man gibt z.B. ein:
MyControl.LinesChanged +=
Dann drückt man zweimal Tab und schon hat man den Eventhandler angelegt. Fertig sieht das dann ungefähr so aus:
MyControl.LinesChanged += new UControl.MyEventHandler(MyControl_LinesChanged)
void MyControl_LinesChanged(object sender, MyEventArgs e)
{
throw new Exception("The method or operation is not implemented.");
}
Mit WCF (Windows Communication Foundation) lassen sich Service orientierte Architekturen (SOA) implementieren. Der Vorteil gegenüber bestehenden technologien besteht darin, dass die eigentliche Schnittstelle von dem Nachrichtenformat und dem Transportweg unabhängig ist, d.h. mann kann einfach durch Konfiguration bestimmen, ob die Kommunikation über HTTP, TCP, MSMQ, Named Pipes etc. stattfinden soll und ob der Nachrichtenaustausch über SOAP/XML, Binärserialisierung etc. erfolgen soll. WCF ist bestandteil von .net 3.0
Im Rahmen eines Projektes habe ich begonnen, mich mit der WCF zu befassen. Die ersten Ergebnisse sind in dem folgenden Tutorial beschrieben. Das Dokument soll einen einfachen Einstieg in WCF bieten. Windows Communication Foundation Tutorial.pdf (847,8 KB)
| |