In München findet am 13. und 14. Februar 2007 die Entwickler-Konferenz VSOne statt. In 8 Tracks werden sehr interessante Sessions rund um die Software-Entwicklung mit .net angeboten:
- Windows Forms
- Windows Mobile
- Web 2.0
- Advanced Development (ADC)
- Visual Basic
- SQL Server & BI
- Business Fasttrack
- Tools&Solutions
Ich werde dort zwei Vorträge halten, einen zum Thema Databinding in Winforms, einen zum Datenaustausch mit mobilen Devices über Active Sync.
Nähere Infos unter www.vsone.de
Will man in einem Web-Service Sessions nutzen, so muss der Client Cookies handeln können. Ist der Client eine Web-Applikation, so ist das kein Problem. Bei WinForms muss man da zu einem kleinen Kniff greifen.
Man muss für den Service einen CookieContainer erstellen. Dazu kann man im Client folgenden Code verwenden:
WebService.MyService ws = new WebService.MyService();
ws.CookieContainer = new CookieContainer();
Damit kann dann auch der Windows-Client Cookies handeln.
Mit Microsoft Sandcastle lassen sich die XML-Kommentare aus dem Sourcecode in eine Dokumentation konvertieren. Damit lassen sich ohne viel Aufwand Dokumentationen im Stile einer MSDN-Dokumentation erstellen, die sogar in die VS-Hilfe eingebunden werden können. Einen Einstieg bietet das folgende Tutorial von Jonas:
http://www.dotnet-ulm.de/Downloads/20061121/Sandcastle.zip
Es gibt ein Control mit dem Namen DSOFramer, das es erlaubt, Office-Anwendungen in eine eigene WinForms-Anwendung zu integrieren. Das Control hat allerdings einen Schönheitsfehler, es funktioniert nicht auf MDIChild-Forms. Versucht man innerhalb eines MDIChilds per Code eine Datei im DSOFramer zu laden, erhält man eine nichtssagende Fehlermeldung. Über einen kleinen Trick lässt sich das Problem allerdings beseitigen. Man baut sich einfach ein Usercontrol, in das man den DSOFramer steckt. danach funktioniert das Control auch in MDIChilds.
Infos und Download des DSOFramer_Controls unter http://support.microsoft.com/kb/311765
Dank an Christopher für den Tipp.
artiso, mein Arbeitgeber, sucht momentan einen .net-Entwickler zur Festanstellung. Falls jemand Interesse hat oder jemanden kennt, der im Moment einen Job sucht, der kann gerne mit mir Kontakt aufnehmen.
Hier die Stellenanzeige:
Die artiso solutions GmbH, ein ein visionäres .net Entwicklungsunternehmen in der Nähe von Ulm sucht zum nächstmöglichen Zeitpunkt einen/eine
.net Entwickler/-in
Die artiso entwickelt individuelle Softwarelösungen für groß- und mittelständische Unternehmen in Süddeutschland. Hierbei kommen sowohl Web- als auch Windows-Technologien und Smart Devices zum Einsatz. Es werden modernste Entwicklungstechnologien, zum Beispiel .net 3.0 ebenso wie innovative Architekturansätze und moderne Entwicklungstools eingesetzt.
Wir bieten unseren Entwicklern-/innen die Möglichkeit, sich mit innovativen Technologien zu beschäftigen. In unserem Team kann sich jeder seinen individuellen Neigungen entsprechend einbringen und Verantwortung übernehmen.
Nähere Informationen erhalten Sie unter http://www.artiso.com/ oder via e-Mail unter tschissler@artiso.com.
Um den aktuell angemeldeten Windows-User zu ermitteln gibt es zwei Möglichkeiten:
1.) string userName = Environment.UserName
Diese Variante liest aus der Systemumgebung die entsprechende Einstellung aus.
Nachteil: Diese Einstellung kann leicht manipuliert werden, z.B. in der Eingabeaufforderung mit Set USERNAME = Administrator
2.) string userName = System.Security.Principal.WindowsIdentity.GetCurrent().Name;
Diese Variante fragt den User direkt im Windows Sicherheitsystem ab und kann deshalb nicht manipuliert werden.
Hat man eine umfangreiche Form mit vielen Controls, ist es oft nicht einfach, den Überblick über die Tab-Reihenfolge der Form zu behalten. Und für den Anwender ist es ärgerlich, wenn er bei Tastaturbedienung wild auf der Eingabemaske herum geführt wird. IN VS 2005 gibt es im Menü Ansicht hier einen Eintrag, der hier eine Lösung bietet . Ruft man den Menüpunkt Aktivierreihenfolge (Taborder) auf (ist nur verfügbar wenn das aktive Fenster eine Winform enthält), wird die Form in einem speziellen Modus dargestellt und auch der Cursor ändert sein Aussehen.
Die Zahlen, die nun bei jedem Control angegeben werden, geben die Tabreihenfolge an. Hat man Gruppierungselemente wie z.B. Panels, so werden durch Komma getrennt erst die Reihenfolge der Gruppen und dann die des Controls angezeigt.
Um die Tabreihenfolge zu ändern beginnt man nun einfach die Controls in genau der Reihenfolge anzuklicken, wie man sie haben möchte. Die Zahlen werden sofort angepasst.
Um den Modus wieder zu verlassn, muss man den Menüpunkt im Menü Ansicht einfach wieder deaktivieren. So einfach erhält man saubere Tabreihenfolgen.
Oft hat man das Problem, dass man eindeutige, fortlaufende Nummern erzeugen möchte. In einer MultiUser-Umgebung braucht man dazu eine zentrale Instanz, die gleichzeitige Zugriffe mehrere User korrekt verwaltet, typischerweise eine Datenbank. Mit Oracle z.B. kann man diese Nummern mit Hilfe einer Sequenz erzeugen.
CREATE SEQUENCE SOPTOOLS.SEQSOPNUMMER
START WITH 1
INCREMENT BY 1
MINVALUE 0
NOCACHE
NOCYCLE
NOORDER
Die Parameter sind eigentlich weitgehend selbsterklärend. Die Meisten Beispiele findet man, wenn man nun mit Hilfe des INSERT-Befehls einen neuen Eintrag erzeugen möchte. Das sieht dann ungefähr so aus:
INSERT INTO SOPS (SOPNUMMER, SOPNAME)
VALUES (SEQSOPNUMMER.NEXTVAL,'NeueSOP')
Damit wird ein neuer Datensatz angelegt. Dabei wird die Sequenz automatisch um eins erhöht und der neue Wert als SOPNUMMER eingetragen. D.h. wenn der Befehl mehrfach hintereinander ausgeführt wird, hat jeder Eintrag eine eindeutige SOPNUMMER. Mit .CURRVAL kann man übrigens auf die Sequenz zugreifen, ohne dass der Wert erhöht wird.
Bei mir war's aber so, dass ich einfach nur den nächsten Wert der Sequenz wollte ohne einen INSERT. Da muss man zu einem kleinen Trick greifen. Man kann die Sequenz nicht direkt abfragen, sondern immer nur in Verbindung mit einer Tabelle. Hier bietet Oracle die Pseudo-Tabelle DUAL, die für diesen Zweck super geeignet ist. Sie enthält genau eine Zeile mit einer Spalte. Damit liefert folgende Abfrage den nächsten Wert der Sequenz und erhöht die Sequenz automatisch:
SELECT SEQSOPNUMMER.NEXTVAL FROM DUAL
Ich bin jetzt auch auf der Blog-Liste der DtoNetGerman Bloggers gelistet. Einfach mal vorbeischauen, dort sind sehr interessante deutschsprachige Blog versammelt. Link to DotNetGerman Bloggers
Mit dem patterns & practices Guidance Explorer wird dem Entwickler ein Tool an die Hand gegeben, mit dem er entsprechende Entwicklungs-Patterns und Best Practices zu verschiedenen Themen gefunden werden können. Darüber hinaus kann man eigene Checklisten und eigene Guidance-Sets erstellen. Link to patterns & practices Guidance Explorer
Diese Community-Seite beschäftigt sich hauptsächlich mit der Entwicklung von Software für die Windows Media Center Edition. Link to Code-Green.de
Will man eine Liste mit allen Werten eines enums befüllen, z.B. zur Ausgabe in einer DropDown-List, kann man folgenden Code verwenden:
foreach (int Entry in Enum.GetValues(typeof(DataLayer.LogDataLayer.LogDataLayer.LogEntryTypes)))
{
vl.ValueListItems.Add(Entry, ((DataLayer.LogDataLayer.LogDataLayer.LogEntryTypes)Entry).ToString());
}
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)
Vor kurzem habe ich hier gepostet, wie man Debug-Informationen ausgeben kann. Hier noch eine kleine Ergänzung. Man kann den Debug-Informationen auch noch Informationen über die Quelldatei, das Modul und die Zeile ausgeben. Dazu dient der folgende Code:
Debug.WriteLine("Quelledatei = " + new StackFrame(0, true).GetFileName() +
"\nMethode = " + new StackFrame(0, true).GetMethod() +
"\nZeile = " + new StackFrame(0, true).GetFileLineNumber() + "\n");
Gefunden bei Dani.Net
Unter http://www.netfxguide.com/ finden sich jede Menge Links zu Webkasts, Tutorials, Artikel etc. zum Thema .Net 3.0. Die Inhalte sind in die Rubrichen WCF, WPF, WF und sonstiges gegliedert.
Auf Dani.NET habe ich folgenden interessanten Beitrag gefunden:
In wohl praktisch jeder Applikation müssen Settings für den Mail-Versand gespeichert werden - SMTP-Hoster, statische Sender-Adresse etc.
Wer das wie ich bis jetzt immer mit eigenen Konfigurations-Abschnitten gelöst hat, der soll hier belehrt werden  src="http://blogs.dotnetgerman.com/dani.net/smilies/happy.gif"> :
<configuration>
(...)
<system.net>
<mailSettings>
<smtp from="info@mydomain.com">
<network host="my.smtp.host"/>
</smtp>
</mailSettings>
</system.net>
(...)
</configuration>
So sieht ein entsprechender built-in Dokumentations-Abschnitt aus. Natürlich wäre es zB. auch möglich, entsprechende
Credentials für den SMTP-Server zu definieren.
Wenn nun ein Mail-Objekt erstellt wird und über die Klasse SmtpClient versendet wird, werden
automatisch die entsprechenden Daten aus dem Config-File genommen.
Heute habe ich mir mal Outlook 2007 näher angeschaut und dabei bin ich über die Funktion gestolpert, mit der Outlook RSS Feeds lesen kann. Eigentlich bin ich mit dem SharpReader, den ich bisher einsetze, ganz zufrieden. Einzig sört mich, dass ich auf verschiedenen Rechnern nicht sauber synchronisieren kann, welche Einträge ich schon gelesen habe.
In Outlook werden die Einträge der Feeds werden in Outlook als Nachrichten auf dem Exchange-Server abgelegt. Daraus ergeben sich zwei Vorteile:
1.) Die Einträge stehen auf allen Rechnern zur Verfügung. Auch der Status (gelesen / ungelesen) wird für alle Outlook-Clients zur Verfügung gestellt.
2.) Ich kann die Einträge auch offline lesen. Dazu bietet Outlook auch die Möglichkeit, den kompletten Eintrag als HTML-File lokal zu speichern.
Total begeistert war ich dann, als ich feststellte, dass ich sogar mit meinem Outlook 2003 auf die heruntergeladenen Einträge Zugriff habe. OPML-Files können übrigens über die Import / Export-Funktion von Outlook importiert und auch wieder exportiert werden.
Nachträgliche Einstellungen können über einen etwas versteckten Dialog vorgenommen werden: Tools / Options / Mail Setup / E-mail Accounts / RSS-Feeds
Seit ca. 2 Monaten blogge ich nun und dies ist der 100ste Eintraig in meinem Blog. Mir macht es Spass und für mich ist der Blog auch ein gutes Nachschlagewerk. Die Statistik zeigt mir, dass es wohl den einen oder anderen gibt, der auch liest, was ich hier so von mir gebe.
Für mich wäre es klasse, hier ein wenig Feedback zu erhalten. Ich bin dankbar für Anregungen aller Art. Sind die Beiträge zu knapp oder zu ausführlich? Sind die Themen interessant? Hat es dem einen oder anderen evtl. schon bei einem konkreten Problem geholfen. Lesen Sie den Blog regelmäßig oder sind Sie über eine Suchmaschine nur zufällig darauf gestossen? Wie sind Sie auf den Blog gekommen etc. etc.
Ich würde mich freuen, wenn ich ein wenig Feedback bekommen könnte. Entweder über den Contact-Link auf der linken Seite oder einfach als Kommentar zu diesem oder Beitrag.
In manchen Situationen hilft ein Breakpoint beim Debugen einfach nicht weiter. Haben Sie schon mal versucht, einen Eventhandler für ein Mouse-Move-Ereignis mit einem Breakpoint zu debuggen? Das ist schlicht unmöglich.
Abhilfe schafft hier das Debug-Objekt. Sie können damit z.B. Informationen im Ausgabefenster von VS ausgeben. In oben beschriebenen Fall würden Sie also z.B. folgendes verwenden:
private void Form2_MouseMove(object sender, MouseEventArgs e)
{
System.Diagnostics.Debug.WriteLine(e.X + " - " + e.Y);
}
Das Ergebnis sieht man wie gesagt im Ausgabefenster von Visual Studio (Einblenden über Strg + Alt + O).
Welche Entwickler hat denn schon die Namespaces aller Objekte des Frameworks im Kopf? Da hilft oft nur in der Hilfe nachschauen - oder man kennt eine kleine aber sehr nette Funktion im Visual Studio 2005!
Man gibt einfach den Namen des Objektes ein. Ist das Objekt im .net Framework enthalten, erkennt VS das automatisch und zeigt dies durch einen kleinen roten Strich am Ende des Objektnamens ein. Klickt man darauf, kann man auswählen, ob der Namespace vor dem Objekt eingefügt l oder ob automatisch ein Using für den Namespace eingefügt werden soll. Unten sieht man ein Beispiel mit dem Objekt MailMessage. 
Eigentlich dachte ich, das sei eine ganz simple Aufgabe, aber dann hat mich das Ganze doch 2 Stunden Zeit gekostet. Das Ziel war, zwei Panels über einen separaten Scrollbar zu scrollen. Alse Panels in der Form platziert, AutoScroll auf false gesetzt, damit nicht jedes Panel mit einem Scrollbar versehen wird und den Scrollbar hinzugefügt. Der Event für das Scrollen war auch schenll gefunden, aber dann gab es Probleme.
Deshalb hier die Vorgehensweise, die nach meinen Versuchen am besten funktioniert hat.
private void Form2_Load(object sender, EventArgs e)
{
this.panel1.AutoScroll = true;
this.panel2.AutoScroll = true;
this.ultraScrollBar1.Minimum = this.panel1.HorizontalScroll.Minimum;
this.ultraScrollBar1.Maximum = this.panel1.HorizontalScroll.Maximum;
this.ultraScrollBar1.Value = this.panel1.HorizontalScroll.Value;
this.ultraScrollBar1.SmallChange = this.panel1.HorizontalScroll.SmallChange;
this.ultraScrollBar1.LargeChange = this.panel1.HorizontalScroll.LargeChange;
this.panel1.AutoScroll = false;
this.panel2.AutoScroll = false;
}
private void ultraScrollBar1_Scroll(object sender, ScrollEventArgs e)
{
this.panel1.AutoScrollPosition = new Point(e.NewValue, 0);
this.panel2.AutoScrollPosition = new Point(e.NewValue, 0);
}
Hierzu ein paar Anmerkungen:
1.) Die Werte für Minimum, Maximum, SmalChange und LargeChange können vom Panel nur dann sauber abgefragt werden, wenn AutoScroll = true gesetzt ist.
2.) Wird die Scrollposition über this.panel1.HorizontalScroll.Value gesetzt, was naheliegend wäre, kommt es bei abgeschaltetem AutoScroll zu einem seltsamen Flimmer-Effekt. Statt dessen muss die AutoScrollPosition gesetzt werden.
3.) Auch für das zweite Panel muss das AutoScroll einmal aktiviert und dann wieder deaktiviert werden, sonst scrollt das nicht mit.
Also diese Lösung funktioniert mal.
Diese Vorgehensweise scheint mir jedoch recht unlogisch und sehr umständlich. Ob das Framework da nichts besseres bietet oder ob ich da einfach noch nicht den richtigen Dreh gefunden hab, weiss ich im Moment noch nicht. Ich werde bei Gelegenheit das mal vertiefen und an dieser Stelle wieder posten.
Zur Erstellung von Reports sind die Reporting Services des SQL-Servers recht bekannt. Dass aber auch Reports direkt in VS 2005 ohne SQL-Server erstellt werden können, ist weniger bekannt. Die Berichte können zur Laufzeit angepasst werden. Diese Reporting-Funktionalität kann einfach in eigene Anwendungen integriert werden. Durch ein offenes XML-Format können die Berichtsvorlagen auch aus eigenen Anwendungen heraus erzeugt werden.
In einem Web-Cast stellt Sebastian Weber die Funktionen aber auch die Unterschiede zu den SQL-Server Reporting-Services dar.
https://www.microsoft.com/germany/MSDN/webcasts/library.aspx?id=118771506
Auf dieser Seite wird der Einstieg in die .Net Programmierung an ein paar Beispielen Schritt für Schritt aufgezeigt. Damit kann wirklich jeder in die Programmierung mit .Net einsteigen und Interesse daran finden.
Vor allem bei der Aufmachung hat sich Microsoft echt was einfallen lassen.
http://www.microsoft.com/germany/msdn/aktionen/wirbauenwas/default.mspx
Wenn man seine Klassen sauber mit XML-Kommentaren versieht, ist es ein leichtes, daraus auch eine schöne Dokumentation zu erstellen. Nur beim eingeben der XML-Kommentare taucht oft die Frage aus, wie sieht das Ergebnis aus? Dazu jedesmal die Dokumentation zu erstellen ist recht mühsam. Abhilfe schafft hier dieses kleine Tool, das in der IDE eine HTML-Vorschau ermöglicht.
http://www.kyrsoft.com/opentools/qdocviewer.html
|