using System;
using System.IO;
using System.Text;

namespace Utilities.IO
{

	/// <summary>
	/// 	A simple class derived from StringWriter, but which allows
	/// 	the user to select which Encoding is used. This is most
	/// 	likely to be used with XmlTextWriter, which uses the Encoding
	/// 	property to determine which encoding to specify in the XML.
	/// </summary>
	public class StringWriterWithEncoding : StringWriter
	{
		private Encoding _encoding;

		/// <summary>
		/// 	Initializes a new instance of the StringWriterWithEncoding class
		/// 	with the specified encoding.
		/// </summary>
		/// <param name = "encoding">The encoding to report.</param>
		public StringWriterWithEncoding(Encoding encoding)
			: base()
		{
			this._encoding = encoding;
		}

		/// <summary>
		/// 	Initializes a new instance of the StringWriter class with the
		/// 	specified format control and encoding.
		/// </summary>
		/// <param name = "encoding">The encoding to report.</param>
		/// <param name = "formatProvider">An IFormatProvider object that controls formatting.</param>
		public StringWriterWithEncoding(Encoding encoding, IFormatProvider formatProvider)
			: base(formatProvider)
		{
			this._encoding = encoding;
		}

		/// <summary>
		/// 	Initializes a new instance of the StringWriter class that writes to the
		/// 	specified StringBuilder, and reports the specified encoding.
		/// </summary>
		/// <param name = "encoding">The encoding to report.</param>
		/// <param name = "sb">The StringBuilder to write to. </param>
		public StringWriterWithEncoding(Encoding encoding, StringBuilder sb)
			: base(sb)
		{
			this._encoding = encoding;
		}

		/// <summary>
		/// 	Initializes a new instance of the StringWriter class that writes to the specified
		/// 	StringBuilder, has the specified format provider, and reports the specified encoding.
		/// </summary>
		/// <param name = "encoding">The encoding to report.</param>
		/// <param name = "sb">The StringBuilder to write to. </param>
		/// <param name = "formatProvider">An IFormatProvider object that controls formatting.</param>
		public StringWriterWithEncoding(Encoding encoding, StringBuilder sb, IFormatProvider formatProvider)
			: base(sb, formatProvider)
		{
			this._encoding = encoding;
		}

		/// <summary>
		/// 	Gets the Encoding in which the output is written.
		/// </summary>
		public override Encoding Encoding
		{
			get { return this._encoding; }
		}
	}
}

Update:
Habe die Klasse mal um Kommentare erweitert.

Die erste Hürde, welche es zu nehmen gilt, ist es, dass ContextMenü auch bei einem Links-Klick zu öffnen. Man kann zwar eine entsprechende Methode nutzen, jedoch gibt es damit Probleme. Daher sollte man hier Reflection nutzen:

// constructor..
this._trayIcon.MouseDown += this.TrayIconMouseDown;

private void TrayIconMouseDown(object sender, MouseEventArgs e)
{
	if (e.Button == MouseButtons.Left)
	{
		MethodInfo mi = typeof (NotifyIcon).GetMethod("ShowContextMenu", BindingFlags.Instance | BindingFlags.NonPublic);
		mi.Invoke(this._trayIcon, null);
	}
}

Nun öffnet sich schon mal das Kontextmenü auch beim Linksklick. Und hier kann man ansetzen, um das Menü entweder zu manipulieren oder zu ersetzen. Ich selbst habe mir einfach zwei Objekte vorbereitet, welche ich je nach Mausklick austausche:

private void TrayIconMouseDown(object sender, MouseEventArgs e)
{
	if (e.Button == MouseButtons.Left)
	{
		this._trayIcon.ContextMenu = this._leftClickMenu;
		MethodInfo mi = typeof (NotifyIcon).GetMethod("ShowContextMenu", BindingFlags.Instance | BindingFlags.NonPublic);
		mi.Invoke(this._trayIcon, null);
	}
	else if (e.Button == MouseButtons.Right)
	{
		this._trayIcon.ContextMenu = this._rightClickMenu;
		MethodInfo mi = typeof(NotifyIcon).GetMethod("ShowContextMenu", BindingFlags.Instance | BindingFlags.NonPublic);
		mi.Invoke(this._trayIcon, null);
	}
}

Beim Testen ist mir aufgefallen, dass es mehrere Events gibt, an die man sich hängen könnte, etwa “MouseUp”, “MouseClick” usw. Beim Testen hat bei mir allerdings nur “MouseDown” korrekt funktioniert, bei den anderen hatte ich das Problem, dass zum Teil das Menü erst angezeigt wurde und dann der Eventhandler durchlaufen wurde (ich glaube sogar immer, wenn ich mit der linken Maustaste geklickt habe). Erklären konnte ich es mir allerdings nicht.

Um meinen Ansatz zu verstehen, muss man wissen, was eine asymmetrische Verschlüsselung funktioniert. Während bei einer symmetrischen Verschlüsselung mit einem Passwort sowohl ver- als auch entschlüsselt wird, gibt es bei der asymmetrischen Verschlüsselung zwei Schlüssel. Den Private und den Public Key. Während der Private und der Public Key verschlüsseln können, ist nur der Private Key in der Lage wieder zu entschlüsseln. Will man hingegen wissen, ob eine Nachricht wirklich vom Besitzer des Private Keys kommt, spricht man von Signierung. Signieren kann nur der Besitzer des Privaten Schlüssels, während jeder Public Key Besitzer dies verifizieren kann.

Dieses Verhalten kann man ausnutzen, der Hersteller der Software ist im Besitz des Private Keys und signiert Dateien, welche von der Software, welche den Public Key kennt, verifiziert. Sollte die Signatur nicht gültig sein, verweigert die Software ihren Dienst. Sollte jemand den Inhalt der Datei manipulieren, so muss sie wieder mit dem Private Key neu signiert werden.

Ich habe mir daher eine kleine, aber feine Klasse erstellt, welche entweder ein XML-Dokument oder eine Klasse, welche per XmlSerializer serialisierbar ist, signieren kann. So kann man theoretisch jede Information in eine XML-Lizenz-Datei hinterlegen, etwa wie lange die Lizenz gültig ist. Die nötigen Klassen befinden sich alle im .NET-Framework ab Version 2.0. Der Code ist zum Teil aus der MSDN (siehe Links am Ende des Beitrages).

Diese Möglichkeit bietet keinen absoluten Schutz. Leute könnten mit Programmen wie dotPeek an den SourceCode gelangen und die Prüfung ausbauen. Mit einem Obfuscator kann dies erschwert werden. Zudem dürft ihr niemals den privaten Schlüssel herausgeben, da dieser sowohl signieren als auch einen Public Key erstellen kann.

Beispielapplikation:

Hier findet ihr eine kleine Beispielanwendung. Die Form ist sehr trivial, erstellt erst die Keys, dann die Dummy-Klasse, signieren und zum Schluss validieren.

Links:

How to: Sign XML Documents with Digital Signatures
How to: Verify the Digital Signatures of XML Documents
Beispielanwendung

Wer Text an Methoden / Klassen weitergeben will, die mit Streams arbeiten, sollte dies nicht umständlich über den MemoryStream lösen, sondern sich lieber mal die beiden Klassen StringReader und StringWriter anschauen. Geht deutlich einfacher und man braucht nicht umständlich mit irgendwelchen Encodings / Bytes / Stream-Positionen rumspielen.

<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
    xmlns:msxsl="urn:schemas-microsoft-com:xslt" exclude-result-prefixes="msxsl"
>
    <xsl:output method="xml" indent="yes"/>
    <xsl:template match="@* | node()">
        <xsl:copy>
            <xsl:apply-templates select="@* | node()"/>
        </xsl:copy>
    </xsl:template>
</xsl:stylesheet>

Einfach alle Nodes und Attribute kopieren, also nichts wildes. Dennoch wurde aus:

<xs:element name="comment" type="xs:string" minOccurs="0" />

folgendes:

<xs:element name="comment" type="xs:string" minOccurs="0"></xs:element>

Das Schema ist noch valide und funktioniert tadellos, nur sieht es nicht wirklich schön aus. Nachdem ich im Netz nach einen bestimmten Parameter im C#-Code und ähnliches gesucht hatte, wurde ich doch noch fündig. Das .NET-Framework bietet zwei verschiedene Methoden zur Transformation.
XslTransform und XslCompiledTransform. Der Kommentar in der MSDN sagt eigentlich alles:

Die XslCompiledTransform-Klasse ist ein XSLT-Prozessor, der die XSLT 1.0 Syntax unterstützt. Dies ist eine neue Implementierung, die im Vergleich zur veralteten XslTransform-Klasse die Leistung verbessert. Die Struktur der XslCompiledTransform-Klasse ist der XslTransform-Klasse sehr ähnlich.

Nebenbei werden auch noch das ShortEndTag unterstützt, womit mein Problem gelöst wäre. Der Vollständigkeit halber sollte noch auf diesen Blogeintrag hingewiesen werden: XslCompiledTransform Slower than XslTransform?, denn auch noch die veraltete XslTransform-Klasse scheint noch ihre Daseinsberechtigung zu haben.

<root>
  <node1>Content</node1>
  <node2>Content</node2>
  <node3>Content</node3>
  <node4>Content</node4>
</root>

Ich wollte nur die “node1″ – Node behalten, sprich alle anderen entfernen. Daher mein erster Ansatz:

XmlDocument xmlDocument = new XmlDocument();
xmlDocument.LoadXml("<root><node1>Content</node1><node2>Content</node2><node3>Content</node3><node4>Content</node4></root>");
XPathNavigator navigator = xmlDocument.CreateNavigator();

string[] nodesToRemove = new[] {"//node2", "//node3", "//node4"};

foreach (var nodeName in nodesToRemove)
{
	XPathNavigator node = navigator.SelectSingleNode(nodeName);
	if (node != null)
	{
		node.DeleteSelf();
	}
}

Console.WriteLine(xmlDocument.OuterXml);

Funktioniert und gut.

Nun wollte ich den Ansatz umdrehen, und alle Nodes entfernen, die nicht den Namen “node1″ haben.

XmlDocument xmlDocument = new XmlDocument();
xmlDocument.LoadXml("<root><node1>Content</node1><node2>Content</node2><node3>Content</node3><node4>Content</node4></root>");
XPathNavigator navigator = xmlDocument.CreateNavigator();

string xpath = "/root/node()[name()!='node1']";

XPathNodeIterator nodes = navigator.Select(xpath);
while(nodes.MoveNext())
{
	if(nodes.Current != null)
	{
		nodes.Current.DeleteSelf();
	}
}

Console.WriteLine(xmlDocument.OuterXml);

Leider war das Ergebnis nicht so wie erwartet, obwohl der XPath korrekt ist und die anderen Nodes selektiert. Es wurde nur “node2″ gelöscht, sprich die erste Node, welche mit dem NodeIterator angesprochen wird. Durch das DeleteSelf() liefert MoveNext() automatisch false zurück, wenn es wieder aufgerufen wird. Ähnliche Probleme gibt es etwa auch, wenn in einer foreach()-Schleife der Enumerator geändert wird. Eine mögliche Lösung wäre folgendes:

while(nodes.MoveNext())
{
	if(nodes.Current != null)
	{
		nodes.Current.DeleteSelf();
		nodes = navigator.Select(xpath);
	}
}

Nach dem Löschen wird der XPath einfach noch mal ausgeführt. Meiner Meinung nach keine wirklich schöne Lösung, leider aber die einzige die ich gefunden habe, welche auch funktioniert.

		/// <summary>
		/// 	Der Haupteinstiegspunkt für die Anwendung.
		/// </summary>
		[STAThread]
		private static void Main()
		{
			Application.EnableVisualStyles();
			Application.SetCompatibleTextRenderingDefault(false);

			_trayIcon = new NotifyIcon {Icon = Icon.FromHandle(new Bitmap("Gear.png").GetHicon()), Visible = true};
			_trayIcon.Click += TrayIconClick;

			Application.Run();
			_trayIcon.Dispose();
		}

Im Anhang findet ihr eine Beispielsolution. Wichtig ist, dass ihr euch selbst ums Dispose() kümmern müsst, damit etwa das NotifyIcon aus der Taskleiste verschwindet, sobald die Applikation beendet wird. Das Beispiel öffnet beim Klick auf das NotifyIcon eine leere Form. Wird diese geschlossen, wird das ganze Programm beendet.

Download: Beispiel Solution – Start App With Notify Icon

Dabei bringt Visual Studio 2010 eine Reihe von wunderschönen Icons mit.

Jedoch hat der Generator vom Manuel Schmitt einen kleinen Nachteil. Nun gibt es Passwörter / PINs die ich mir nicht merken kann aber auch nicht ändern kann. Sprich ich muss eine Möglichkeit haben, meine vorhandenen Daten in so ein “Zufallsbild” hineinzubekommen. Und daran arbeite ich gerade.
Aktuell kann man sich die Passwortkarte schon generieren, eigene Daten kann man aber noch nicht angeben.

Wenn der Kram fertig ist, gibs ihn hier zum herunterladen!

var dic = new Dictionary<string, string>()
       	{
	{"de", "Deutsch"},
	{"en", "Englisch"}
       	};

Die Werte möchte ich in einer ComboBox haben, die Values als anzuzeigenden Text, die Values soll er mir im Code zurückgeben. Ein Dictionary kann man jedoch nicht direkt als DataSource binden. Da die Lösung selbst bei Google etwas versteckt ist, hier die Lösung:

combobox1.DataSource = new BindingSource(dic, null);
combobox1.DisplayMember = "Value";
combobox1.ValueMember = "Key";

Und schon werden alle Einträge aus dem Dictionary angezeigt

(via Mad Props)

List<int> _list = new List<int>();
_list.Add(1);
_list.Add(2);
_list.Add(3);
_list.Add(4);

for(int i = 1; i <= 3; i++) {
   int x = _list[i];
   _list.Remove(x);
}

Mein Code war natürlich nicht mit Integerwerten. Ich musste noch ein paar andere Sachen machen, daher war ein RemoveRange() nicht möglich.
Nun wer findet den Fehler?

Ich liste es einfach mal auf:

Durchlauf: 1 - Lösche Element 1 - Rest 2
Durchlauf: 2 - Lösche Element 2 - Rest 1
Durchlauf: 3 - Lösche Element 3 - Rest 0

Beim letzten Durchlauf wird er immer Probleme kriegen. Das Element gibt es nicht mehr. Durch Remove() rücken die Elemente in der Indizierung nach.
Es müsste also heißen:

Durchlauf: 1 - Lösche Element 1 - Rest 2
Durchlauf: 2 - Lösche Element 1 - Rest 1
Durchlauf: 3 - Lösche Element 1 - Rest 0

oder in C#-Code:

for(int i = 1; i <= 3; i++) {
   int x = _list[1];
   _list.Remove(x);
}

Vor allem wenn man in den Debugger schaut, kamen da merkwürdige Werte raus.
Ich sehe, dass die Methode “DeleteEntries()” mit dem Count-Parameter 2 aufgerufen wird, oben zeigt mir der Debugger aber 1 an. Liegt daran, dass in der Liste bereits ein Element entfernt wurde. Somit ist also, wenn man es genau nimmt, beides richtig.

Die alte Schreibweise

Die Schreibweise unter C#3.0 mit Überladung wäre also in etwa so:

    public class Program
    {
        static void Main(string[] args)
        {

            AddValues("Ich bin ein", "String");
            Console.WriteLine(_value);

            AddValues("Ich bin ein", "String", true);

            Console.ReadLine();
        }

        public static string _value;

        public static void AddValues(string value1, string value2)
        {
            AddValues(value1, value2, false);
        }
        public static void AddValues(string value1, string value2, bool output)
        {
            _value = string.Format("{0} {1}", value1, value2);
            if(output)
            {
                Console.WriteLine(_value);
            }
        }
    }

Wenn wir nun das Projekt ausführen erhalten wir folgende Ausgabe.

Ich bin ein String
Ich bin ein String

Die erste Ausgabe erfolgt manuell, die zweite direkt in der Methode, wie gewünscht.

C#4.0 mit Default Values

Unter C#4.0 mit Default Values kann man die ganze Sache nun vereinfachen:

public static void AddValues(string value1, string value2, bool output = false)
{
    _value = string.Format("{0} {1}", value1, value2);
    if(output)
    {
        Console.WriteLine(_value);
    }
}

Die Ausgabe ist identisch. Die erste Zeile wird manuell ausgegeben, die zweite über den Methodenaufruf. Das macht die Sache einfach, spart Code, macht ihn leserlicher. Man findet sicherlich noch weitere Vorteile.

Das Problem erkennen

Kommen wir nun zu den Problemen. Bevor ich die erläutern kann, muss man wissen, wie C# die Default Values behandelt. Wenn man sich die Anwendung per Reflector ansieht, sieht man folgenden Code (in der C#-Ansicht):

private static void AddValues(string value1, string value2, [Optional, DefaultParameterValue(false)] bool output);

Die Zeile spricht für sich. Der Standardwert lautet “false”. Nun erstellen wir ein neues Projekt (“TestApp”) und referenzieren auf unsere Methode mit dem Default Value:

namespace TestApp
{
    class Program
    {
        static void Main(string[] args)
        {
            DefaultValues.Program.AddValues("Ich bin ein", "String");
            Console.WriteLine(DefaultValues.Program._value);

            Console.ReadLine();
        }
    }
}

Ausgegben wird eine Zeile, wie erwartet, durch die manuelle Ausgabe. Nun sehen wir uns die zweite Exe-Datei mal im Reflector an:

Program.AddValues("Ich bin ein", "String", false);

Auf einmal sind drei Parameter vorhanden, obwohl wir nur zwei im Sourcecode angegeben haben. Der Compiler setzt automatisch den dritten Parameter mit dem Standardwert, in dem Fall false.
Nun ändern wir die AddValues()-Methode, die Ausgabe soll standardmäßig sofort in der Methode erfolgen, zudem ändern wir den String etwas:

public static void AddValues(string value1, string value2, bool output = true)
{
    _value = string.Format("Zusammengesetzt: {0} {1}", value1, value2);
    if (output)
    {
        Console.WriteLine(_value);
    }
}

Nun kompilier ich nur das Projekt “DefaultValues” und kopiere die DefaultValues.exe in das Bin-Verzeichnis der TestApp. Wenn ich nun die TestApp.exe starte erhalte ich folgende Ausgabe:

Zusammengesetzt: Ich bin ein String

Allerdings haben wir den Standardwert für die Ausgabe auf true gesetzt, daher müsste die Ausgabe doppelt erscheinen, einmal direkt über den Methodenaufruf und einmal durch die manuelle Ausgabe.

Problem beheben

Dieses Problem resultiert daher, dass der Standardwert nicht “on-the-fly” aus der DefaultValue.exe geholt wird, sondern vom Compiler in der TestApp.exe gesetzt wurde.
Die Methode aus der DefaultValues.exe wird also immer noch mit “AddValues(“Ich bin ein”, “String”, false);” aufgerufen. Und so lange wir das TestApp-Projekt nicht neu kompilieren, wird sich an der Ausgabe nichts ändern.

Fazit

Default Values sind eine nette Sache, um sich Überladungen zu sparen, den Code leserlicher zu machen und dem Programmierer das Leben leichter. Aber eigentlich gibt es keine Default Value, der Compiler setzt einfach nur die Werte, die man vorher manuell gesetzt hat. Wenn man diesen Aspekt nicht vergisst, können DefaultValues eine schöne Sache sein, ansonsten sucht man sich wahrscheinlich dumm und dämlich, bis man den Fehler gefunden hat.

Vielen Dank hier noch mal an Oliver Sturm, welcher die Problematik auf der Basta kurz aber verständlich erklärt hat.

Beispielsolution: DefaultValues.zip

(Wenn Interesse besteht, lade ich mal eine Beispielsolution hoch).

Die GUI ist nicht mehr ganz so aktuell. Aktuell bin ich mir noch nicht so sicher, wie ich die Daten speicher, momentan tendiere ich dazu, die Daten als XML-Datei auf der Platte zu speichern.

PrintDialog pd = new PrintDialog();
if (pd.ShowDialog() == DialogResult.OK)
{
    // do nothing

}

Nichts großes, sollte einfach nur so ein Druckerfenster öffnen, wo der Drucker ausgewählt wird etc. Leider öffnete sich der erhoffte Dialog nicht. Der Debugger läuft dahin, aber er führt den ShowDialog() einfach nicht aus.

Wenn ich die Eigenschaft “UseEXDialog” auf “true” setze, funktioniert es.
Jedoch wollte ich nicht den XP-Dialog, sondern den anderen. Auch im Netz fand ich keine wirkliche Lösung.
Da diese Codezeilen aus einem bestehenden Projekt stammen, habe ich kurzerhand neue Projekte in den Frameworks 2.0, 3.5 und 4.0 angelegt. Jeweils mit dem Codeschnippsel oben. Und siehe da, es funktioniert problemlos, in jeder Frameworkversion. Nun die Unterschiede gesucht.

Fündig wurde ich den Projekteigenschaften unter “Build” bzw. “Erstellen”.
Ich muss dazu sagen, dass die Applikation vorher auf einem anderen Rechner mit einem 32-bit Windows entwickelt wurde. So stand hier unter dem Punkt “Platform target:” (auf Deutsch vermutlich Zielplattform) “Any CPU”.
Stellt die Anwendung hier auf 32-bit (x86) und der PrintDialog() wird hervorragend funktionieren. x64 oder Any CPU funktioniert nicht.
Auf so etwas muss man erstmal kommen, warum das so ist, keine Ahnung.

So habe ich noch mal in der MSDN nachgeschlagen:

This class may not work on AMD64 microprocessors unless you set the UseEXDialog property to true.

Ich bin zwar nun nicht der technisch versierte Mensch, aber für mich hört sich das nach einem Problem mit einem AMD Prozessor an, ich habe jedoch einen Intel (ich lasse es mir aber dennoch gerne erklären).

        public IEnumerable<Data> Search(string filter)
        {
            var dataSet = from data in this.bigDataSet
                          where data.Name.Contains(filter)
                          select data;

            return dataSet;
        }

Über die Variable “filter” wollte ich die Daten eingrenzen. Allerdings sollte es auch möglich sein, sich alle Datensätze anzusehen. In der MSDN zu string.Contains() lautet es:

Rückgabewert
true, wenn der value-Parameter in dieser Zeichenfolge vorkommt oder value eine leere Zeichenfolge (“”) ist, andernfalls false.

Heißt für mich, dass ich “filter” leer lassen kann und so alle Datensätze bekomme. Funktionierte aber nicht. Ich vermute mal, es liegt daran, dass ich Linq-to-Ent verwende. Das Workaround funktioniert aber ganz gut:

        public IEnumerable<Data> Search(string filter)
        {
            var dataSet = from data in this.bigDataSet
                          where (!string.IsNullOrEmpty(filter) ? data.Name.Contains(filter) : true)
                          select data;

            return dataSet;
        }

Vielleicht hat ja jemand genauere Informationen, warum der erste Ansatz nicht funktioniert. Auf Anhieb habe ich nichts gefunden.

        protected override void OnLoad(EventArgs e)
        {
            base.OnLoad(e);
            if (DwmIsCompositionEnabled())
            {
                // Paint the glass effect.
                this.margins = new MARGINS {Top = -1, Left = -1, Bottom = -1, Right = -1};
                DwmExtendFrameIntoClientArea(this.Handle, ref margins);
            }
        }

Nun ist der ganze Arbeitsbereich durchsichtig. Doch sobald man GDI+-Controlls verwendet, ergibt sich folgender Grafikfehler:

Um dies zu umgehen, müsst ihr in der Main()-Methode folgendes einfügen (bzw. anpassen)

Application.SetCompatibleTextRenderingDefault(true);

Das Ergebnis sieht schon besser aus, leider immer noch nicht so wie gewünscht.

Leider liegt das aber am System bzw. den Controls im .NET-Framework. Unter WPF gibt es dieses Problem zum Beispiel nicht.
Wie ihr die Aero Glass Effekte in WPF nutzen könnt, findet ihr etwa bei Robert Mühsig.

Ach ja, falls ihr nun Bereiche haben wollt, die nicht durchsichtig sind, könnt ihr zum Beispiel ein Panel nutzen. Das Ergebnis sieht in etwa so aus:

  <script type="text/javascript">
      window.onload = function() {
          CKEDITOR.replace('ckEditor', {
            skin: 'office2003',
            filebrowserUploadUrl: '<%=Url.Action("UploadImage") %>'
      });
  };

</script>

Wichtig ist hier der Parameter “filebrowserUploadUrl”. Dies ist der Pfad, wohin das Bild beim Upload gesendet wird.
Im Controller wird das ganze nun verarbeitet:

        [AcceptVerbs(HttpVerbs.Post)]
        public string UploadImage()
        {
            // Datei speichern
            var identifier = Guid.NewGuid();
            string[] fileExt = Request.Files[0].FileName.Split('.');
            string safeFile = identifier + "." + fileExt[fileExt.Length - 1];
            Request.Files[0].SaveAs(Path.Combine(HostingEnvironment.MapPath("~/UploadedImages/"), safeFile));

            // Daten an CKEditor zurück geben
            string result = "<script type=\"text/javascript\">";
            result += "window.parent.CKEDITOR.tools.callFunction(" + Request.QueryString["CKEditorFuncNum"] + ", \"" +
                      Path.Combine(Url.Content("~/UploadedImages/"), safeFile) + "\",\"\");</script>";
            return result;
        }

Erst speicher ich das Bild irgendwo und gebe dann den Pfad per Javascript zurück. Da ich nur das JS ausführen lassen muss, gebe ich kein komplettes View zurück. Die Url wird dann korrekt an CKEditor übergeben (siehe Screenshots). Der letzte Parameter des callFunction()-Aufrufes kann für Fehlermeldungen genutzt werden, Bild zu groß o.ä.
Mich hat dieser kleine Aufruf bestimmt eine Stunde gekostet!

            var dateListe = from dateStamps in this.DataList
                             group dateStamps by
                                 new {dateStamps.PostedTime.Year, dateStamps.PostedTime.Month}
                             into g
                                 select new
                                           {
                                               Year = g.Key.Year,
                                               Month = g.Key.Month,
                                               Count = g.Count()
                                           };

Habe mir kurz als Debugmeldung einen String daraus gebastelt:

            foreach (var liste in linkListe)
            {
                ViewData["test"] += "Datum: " + liste.Month + " " + liste.Year + " Anzah: " + liste.Count + "<br />";
            }

Als Rückgabe erhaltet ihr eine Liste:

Datum: 1 2006 Anzah: 1
Datum: 3 2006 Anzah: 2

Damit kann man Arbeiten