Bei der Arbeit mit Gac müsste ich oft den public key token in den web.configs eingeben und das alles über umständliche Wege und auch das Installieren und Deinstallieren von Assemblys sollte schneller gehen können.

Hier ist die Abhilfe über Externe Tools von VisualStudio [Tools]->[External Tools...]
 

Die Einstellungen
"Use Output window" + "Treat output as Unicode" ermöglicht eine einfachere Ausgabe im Output-Fenster.
"Promt for arguments" für eigene Parametereingaben
"Close on exit" um das Consolen-Fenster automatisch nach der Verarbeitung zu beenden

Hilfreiche Tools
Darkleo SN
Command: C:\Program Files\Microsoft Visual Studio 8\SDK\v2.0\Bin\sn.exe
           oder C:\Programme\Microsoft Visual Studio 8\SDK\v2.0\Bin\sn.exe
Arguments: -Tp "$(TargetPath)"

Darkleo SecUtil
Command: C:\Program Files\Microsoft Visual Studio 8\SDK\v2.0\Bin\secutil.exe
    oder C:\Programme\Microsoft Visual Studio 8\SDK\v2.0\Bin\secutil.exe
Arguments: -hex -s $(TargetPath)

Darkleo GAC Install
Command: C:\Program Files\Microsoft Visual Studio 8\SDK\v2.0\Bin\gacutil.exe
oder C:\Programme\Microsoft Visual Studio 8\SDK\v2.0\Bin\gacutil.exe
Arguments: -i $(TargetPath)

Darkleo GAC Uninstall
Command: C:\Program Files\Microsoft Visual Studio 8\SDK\v2.0\Bin\gacutil.exe
oder C:\Programme\Microsoft Visual Studio 8\SDK\v2.0\Bin\gacutil.exe
Arguments: -u $(ItemFilename)

Zum Portieren (Import/Export) der Extrernal Tools von VS 8.0 auf VS 9.0 ist es Hilfreich zu wissen, dass External Tools in der Regestry abgelegt werden:
HKEY_CURRENT_USER\Software\Microsoft\VisualStudio\8.0\External Tools
HKEY_CURRENT_USER\Software\Microsoft\VisualStudio\9.0\External Tools

WSS External Tools: Automation in Visual Studio 2005 for WSS v3 Feature Development  

Für alle die Selbst Tools einbinden wollen, ist hier die Liste der einzelnen Parameter.

Ich hatte ein Problem, dass auf einem System ein Interner Fehler des .NET Frameworks auftratt und auf dem anderen System nicht und müsste den Fehler analysieren.

Als Erstes habe ich binär versucht Unterschiede festzustellen. 95% Unterschschied in der System.Web.dll 2.0.5727.832 und 2.0.5727.1433.

Um genauer etwas zu sehen könnte man versuchen mit dem Reflector for .NET von Lutz Roeder reinschauen oder die DebugSourcen von Microsoft.
- Zwei Assemblys können beim Reflector nicht geladen werden und auch nicht verglichen werden
- Sourcen von .NET Frameworks von Microsoft zu finden und zu bekommen.

Lösungsansatz:
Ausführen
%comspec% /k ""C:\Programme\Microsoft Visual Studio 8\VC\vcvarsall.bat"" x86

ildasm System.Web.dll /OUT=System.Web.il
ildasm V832.System.Web.dll /OUT=V832.System.Web.il

Somit bekommen wir zwei Intermediate Language-Files die IL-Code enthalten und mit einem Tool wie KDiff lassen sich die Unterschiede schnell aufzeigen und untersuchen.

Ein kleiner Snippet wie man an die IP und Port in WCF dran kommt. 

 
OperationContext context = OperationContext.Current;
 
MessageProperties messageProperties = context.IncomingMessageProperties;
 
RemoteEndpointMessageProperty endpointProperty =
  messageProperties[RemoteEndpointMessageProperty.Name]
  as RemoteEndpointMessageProperty;
 
//IP-Adresse: endpointProperty.Address
//Port: endpointProperty.Port
 

Ich habe verucht das Inhalt von .docx Dokumenten zu ändern, dabei war die Idee: docx ist nichts anderes als ZIP und man könnte ja das File entzippen und die document.xml ändern. Naja ist suboptimal, denn es gibt von Micosoft das "Microsoft SDK for Open XML Formats"

http://www.microsoft.com/downloads/details.aspx?FamilyId=AD0B72FB-4A1D-4C52-BDB5-7DD7E816D046&displaylang=en

Ein kleines Beispiel:
Word-Dokument mit folgendem Inhalt (FULL.docx):

{FULL_NAME}
Tel: {PHONE}

 
static void Main(string[] args)
{
  Console.WriteLine("Start Processing...");
  SearchAndReplace(@"FULL.docx", @"FULL_OUT.docx");
  Console.ReadKey();
}
 

 
//Search and replace content in a part
public static void SearchAndReplace(string path, string path_out)
{
 using (WordprocessingDocument wordDoc =
          WordprocessingDocument.Open(path, true))
 {
  string docText = null;
 using (StreamReader sr =
          new StreamReader(wordDoc.MainDocumentPart.GetStream()))
 {
    docText = sr.ReadToEnd();
  }
 docText = docText.Replace("{FULL_NAME}", "Darkleo.COM/BLOG!");
 docText = docText.Replace("{PHONE}", "101010101011");
 CreateNewWordDocument(path_out, docText);
 }
}  
 
//Create a new package as a Word document.
public static void CreateNewWordDocument(string path,string xml_content)
{
 using (WordprocessingDocument wordDoc =
          WordprocessingDocument.Create(
          path,
          WordprocessingDocumentType.Document))
 {
 // Set the content of the document so that Word can open it.
 MainDocumentPart part = wordDoc.AddMainDocumentPart();
  using (Stream stream = part.GetStream())
  {
    byte[] buf = (new UTF8Encoding()).GetBytes(xml_content);
    stream.Write(buf, 0, buf.Length);
   }
 }
}

Weiter Infos: http://msdn2.microsoft.com/en-us/library/bb491088.aspx
Open XML Package Explorer: http://www.codeplex.com/PackageExplorer
Download: docx_test.zip

Eine Anforderung wieso dieser Datentype entstand ist, für URLs müssten Zeichen gesparrt werden und trotzdem wollten wir nicht auf die Eindeutigkeit von Guid verzichten.

Anforderungen:

1. URL Übertragbar, darf keine Sonderzeichen enthalten
2. Soll die gleiche Zufallsrate besitzen wie Guid und soll in Guid Convertierbar sein

Ich habe Intern einen Guid Typen verwendet und durch Codierung von Base64 aus  dem Raum 15 in Raum 64 übertragen, dabei werden weniger Zeichen für die gleiche Information benötigt, Rund 30% weniger von 32 auf 22 Zeichen.

Mit Zip Algorithen würden ich Punkt 1 nicht erfühlen und String Comprimierung funktioniert erst ab 60-90 Zeichen.
Durch Imlicit opertaor kann ich diesen Datentypen in Guid und String implizit umwandeln.
Implizit heisst ohne es direkt anzugeben: z.B. bei Verbinden von Strings "SmallGuid: "+new SmallGuid().

public static implicit operator Guid(SmallGuid item)
{
 return item.Guid;
}

public static implicit operator string(SmallGuid item)
{
 return item.SmallString;
}

explizit operator: http://msdn2.microsoft.com/en-us/library/xhbhezf4.aspx
implizit operator: http://msdn2.microsoft.com/en-us/library/z5z9kes2.aspx

Kern Methoden der Codierung:

public static string GuidToString(Guid guid)
{
string ret = string.Empty;
byte[] b = guid.ToByteArray();
ret = Convert.ToBase64String(b).Remove(22);
return ret;
}
public static Guid StringToGuid(string smallString)
{
Guid ret = new Guid();
byte[] b = Convert.FromBase64String(smallString + "==");
ret = new Guid(b);
return ret;
}

Test:
Guid g = new Guid("11111111111111111111111111111111");
Console.WriteLine("Guid: " + g);
Console.WriteLine("Guid.Length: " + g.ToString().Length);
SmallGuid sg = new SmallGuid(g);
Console.WriteLine("SmallGuid: " + sg.SmallString); // auch ("SmallGuid: "+sg) funktioniert
Console.WriteLine("SmallGuid.Length: " + sg.SmallString.Length);
Console.WriteLine("Cast to Guid: "+(Guid)sg);
Console.WriteLine("Guid(N).Length: " + ((Guid)sg).ToString("N").Length);
Console.ReadKey();

Ausgabe:
Guid: 11111111-1111-1111-1111-111111111111
Guid.Length: 36
SmallGuid: EREREREREREREREREREREQ
SmallGuid.Length: 22
Cast to Guid: 11111111-1111-1111-1111-111111111111
Guid(N).Length: 32

Download

Ich müsste einige Berechnungstabellen für GF erstellen. Hab mir gedacht da könnte mir C# helfen

Und hab mir überlegt machen wir mal einen Typen(GF) mit dem wir einfach Rechnen können.

public static GF operator *(GF g1, GF g2)
{
 string ret = mul(g1.Data, g2.Data).TrimStart('0');
 return new GF(ret);
}
public static GF operator +(GF g1, GF g2)
{
 return new GF(add(g1.Data, g2.Data));
}
public static GF operator -(GF g1, GF g2)
{ 
 return new GF(add(g1.Data, g2.Data));
}
public static GF operator %(GF g1, GF g2)
{
 string rest = mod(g1.Data, g2.Data);
 return new GF(rest);
}

Weitere Infos zum Überladen von weiteren Operatoren:
http://msdn.microsoft.com/library/deu/default.asp?url=/library/DEU/csref/html/vclrfOverloadableOperators.asp

Wie und was kann ich jetzt damit Rechnen?
Folgende Operationen stehen zur Verfügung: +, -, * und modulo (Restrechnung)  

GF a = new GF("1011");
GF b = new GF("1010");
Console.WriteLine("a = " + a+" b = " + b);
Console.WriteLine("+ = " + (a + b));
Console.WriteLine("* = " + (a * b));
a = new GF("1000");
b = new GF("1001");
Console.WriteLine("rest = " + (a * b % new GF(16)));

Addition und Subtraktion
1011+1010=0001
Console.WriteLine("+ = " + (a + b));
out: +=1

Multiplikation
1011*1010=1001110
Console.WriteLine("* = " + (a * b));
out: *=1001110
Rest von GF 2^4
(1011*1010)%10011=0100
Console.WriteLine("rest = " + (a * b % new GF(8)));
out: rest = 100

Rest Algorithmus in 2 Schritten:
Dieser Algorithmus ist dafür da, um den Multiplikationswert zu Normalisieren.
1)Multipliziere:
   1000 * 1001= (x^3)*(x^3+1)
erzeugt eine Liste:
4+4=1000000
4+1=0010000
gleicht vorkommende x hoch n die 2 mal und das vielfache von 2 sind, werden entfernt.
die liste wird dann zusammen gesetzt
1000000
0001000
--------
1001000 = x^6+x^3

2)Funktions Mod
1001000 % 10011 =
man setzt so viele 0 ans ende dass es zum XORen passt und XORt die werte
1001000
1001100
_______
0000100 = Lösch die 0en davor
Lösung: 100

Infos zu ECC (Elliptic curve cryptography)
Online Elliptic Curve Cryptography Tutorial

Fazit:
Die GF-Klasse ist nicht Performant geschrieben, da ich einen String als Internen Datentypen verwendet habe.
Wenn jemand es Optimieren möchte kann er das machen.

Download

Bei der Microsoft Windows Workflow Foundation (WWF) handelt es sich um ein erweiterbares Framework zum Entwickeln von Workflow-Lösungen auf der Windows-Plattform. Ich habe versucht die SqlWorkflowPersistenceService und SqlTrackingService zu nutzen. Dazu müssen einige Datenbanktabllen eingerichtet werden. Hier habe ich versucht alles mit der SQLCMD zu realisieren.

sqlcmd -S Servername1
oder vollständig
sqlcmd -S servername1\SQLExpress -U SqlUserAccount -P SqlPassword

danach erstellen wir uns eine Datenbank Workflow mit zwei Zeilen Code
create database Workflow
go
und exit.

unter diesem Pfad sind die Skripts für die PersistenceService als auch für TrackingService von WWF zu finden.
C:\WINDOWS\Microsoft.NET\Framework\v3.0\Windows Workflow Foundation\SQL\DE
oder
C:\WINDOWS\Microsoft.NET\Framework\v3.0\Windows Workflow Foundation\SQL\EN

sqlcmd -S servername1 -d Workflow -i SqlPersistenceService_Schema.sql
sqlcmd -S servername1 -d Workflow -i SqlPersistenceService_Logic.sql
sqlcmd -S servername1 -d Workflow -i Tracking_Schema.sql
sqlcmd -S servername1 -d Workflow -i Tracking_Logic.sql

und das Ergebnis:

Weiter Infos zu SQLCMD: http://msdn2.microsoft.com/de-de/library/ms162773.aspx

Noch schneller gehts so:

C:\>sqlcmd
create database workflow
go
use workflow
go
:r "C:\WINDOWS\Microsoft.NET\Framework\v3.0\Windows Workflow Foundation\SQL\EN\SqlPersistenceService_Schema.sql"
:r "C:\WINDOWS\Microsoft.NET\Framework\v3.0\Windows Workflow Foundation\SQL\EN\SqlPersistenceService_Logic.sql"
:r "C:\WINDOWS\Microsoft.NET\Framework\v3.0\Windows Workflow Foundation\SQL\EN\Tracking_Schema.sql"
:r "C:\WINDOWS\Microsoft.NET\Framework\v3.0\Windows Workflow Foundation\SQL\EN\Tracking_Logic.sql"
exit

Über Pageflow im ASP.NET bin ich über mehrere Blogs auf Oslo gekommen.

http://www.microsoft.com/soa/products/oslo.aspx

Es gibt fünf vorrangige Entwicklungsanstrengungen in "Oslo" :

• Framework
  .NET Framework "4"
  model-driven development als Teil von WCF und Workflow Foundation (WF) Technologien.
• Server
  Platform für hoch Skalierbare SOA and BPM Lösungen.
  BizTalk Server "6" mit erweiterungen von WCF und WF
• Services
  Erweiterungen des BizTalk Services incubation (http://labs.biztalk.net/)
• Tools
  life-cycle management von Visual Studio Team System
  model-driven design und deployment von verteilten Anwendungen.
• Repository
  System Center "5"
  Visual Studio "10"
  und BizTalk Server "6"
  Verwaltung, Versieonierung und Deployment Unterstützung.

http://www.directionsonmicrosoft.com/samples/Olso1107.pdf

Als Erstes habe ich festgestellt:

WCSF besteht aus Folgenden Blocks

• Composite Web Application Block 
• Page Flow Application Block 
• Object Container DataSource

Zusätzlich wäre noch zu sagen WCSF implementiert ein MVP Pattern
ASP.NET MVC Framework ist ein reiner MVC Pattern für ASP.NET Seiten.

Wiederverwendbarkeit der Views

WCSF ist Viewbasiert und jede View Initialisiert seinen eigenen Controller.
Ohne erweiterungen können die Views in anderen Controllern nicht so einfach verwendet werden.

MVC-Framework ist Controllerbasiert, der Controller wird als erstes Initialisiert und holt die Daten und ruft die View auf.

Fazit: Bei einer Viewbasierten Lösung, wenn Daten gebraucht werden, wird eine leere View gebraucht die dann eine Methode auf dem Controller aufrufen soll und das ist ein Problem.

Front Controllers oder Application Controllers
Der Controller in ASP.NET MVC Framework ist ein Front Controller wo hingegen der Controller in WCSF ein Application Controller ist.

Als erstes wird in ASP.NET MVC Framework landen die Webrequests im Front Controller:

Controller bekommt den Request
Interaction mit dem Model
Auswahl einer View
Ergebnis in der View anzeigen.

Application Controller in der Web Client Software Factory bekommen den Webrequests nach der View und Presenter:

View bekommt den Request
Presenter wird über IoC in die View Injected
View übergibt Request zu Presenter
Presenter übergibt Request zu Model ( kann auch ein Application Controller sein)
Presenter sorg für das Ergibnis in der View

Das langerwartete Framework ist da und ist unter dem Begriff: ASP.NET 3.5 Extensions veröffentlicht.
http://www.hanselman.com/blog/ASPNET35ExtensionsPlusMVCHowToScreencast.aspx

Es ist da, und kann auch zum Spielen herruntergeladen werden.
http://asp.net/downloads/3.5-extensions/

Zusätzliche Erweiterung von Rob Conery
http://blog.wekeroad.com/2007/12/10/aspnet-mvc-is-here-ctp/

Demnächst kommen vielleicht die besten Umsetzungen von mir in diesem Blog :)