Wäre es nicht einfach Klasse eigene ASP.NET Anwendungem im Detail in Echtzeit zu monitoren?
Mit monitoren ist gemeint, zu sehen wie performant die Anwendung ist (beobachten) um bei Problemen in das System eingreifen zu können (reagieren).

Ich stelle dieses Framework zum Testen zur Verfügung.

Funktionsweise:
Metricsobjekte: Sammeln von Informationen über das Verhalten von ASP.NET Application.
Storeobjekte sind in Metrics instanziert und bilden die Speicher- und Ladeschicht.
Stateinstanzen prüfen ob Performanceprobleme im System vorhanden sind, Reaktionen darauf muss jeder selbst (web.config) einstellen oder ausprogrammieren.
Dafür gibt es Responder/Container oder auch die direkte Ansprache des Providers oder des Module-interfaces.
IPerformanceProvider ist das FacadenInterface über welches das Do.NET Pla Framework angesprochen werden kann.

Wieso habe ich das erwähnt? Weiß ich selbst nicht!
Es sind Interfaces die jeder selbst implementieren kann aber nicht muss, denn das Framework hat schon eine eigene ProviderGruppe: "PerformanceCounter".
Zum Reagieren gibt es den ResponderDefault der einfach eine Exception wirft.

Das Framework wird über ein HttpModul angeschlossen.

<httpModules>
<add name="PlaModule" type="Do.NET.Pla.PlaModule, Do.NET.Pla"/>

Und die Provider müssen bekannt gegeben werden.

<section name="performanceConfiguration" type="Do.NET.Pla.Configuration.PerformanceConfiguration"/>

<performanceConfiguration enabled="true" providerGroup="PerformanceCounter oder Custom" applicationName ="Portal.Pla">
</performanceConfiguration>

Für Reaktionsmöglichkeiten per Web.config
<add name="_default.*"
enabled="true"
isCriticalPerformance="true"
criticalResponder="PlaWeb.Extend.RedirectResponder, PlaWeb.Extend, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null"
description="Wartungsarbeiten von 2008-2009"
freezeStartDate="01.01.2008 00:00"
freezeEndDate="01.01.2009 00:00"
any="sonstige parameter optional"/>
<!--criticalResponder="Do.NET.Pla.PerformanceCriticalResponderDefault"-->

"_default.*" gibt an, dass die _default.* Seite in allen Contexten überprüft werden soll und bei Eingabe von isCriticalPerformance==true die Reaktionsinstanz erzeugen soll.

Die Custom Responder Klasse sieht so aus:

public class RedirectResponder : PerformanceCriticalResponderBase
{
public override void CallBackCriticalPerformance(object sender, EventArgs e)
{
IPerformanceState state = (IPerformanceState)sender;
HttpContext.Current.Session["_lasterror"] = state;
HttpContext.Current.Response.Redirect("~/Error.aspx", true);//endresponse
}
}

et voila

Würde mich freuen, wenn jemand Feedback gibt ob es Probleme gibt.

Im Sample ist der StateProvider auf die Web.config -> WebService-Klasse angesetzt. Somit können die Seiten zusätzlich zur web.config über einen WebService gesteuert werden. (z.b. ab* für About.None oder alle Seiten die mit ab anfangen.)

[Vortragsfolien] [Sample Project]

Happy monitoring!!!

Hab versucht die Anzahl der Benutzer auf der Seite festzustellen und habe nichts passendes gefunden. Wie immer, wenn etwas nicht da ist, wird versucht sich selbst am Schnellsten und Besten zu helfen

Wäre auch klasse wenn ich nicht unbedingt auf der MasterPage Code verteile, also machen wir uns ein cooles HttpModule welches und auf die Frage "wieviele Benutzer sind auf der ASP.NET Webseite?" eine Antwort liefert.

Label1.Text = string.Format("Es sind {0} Benutzer auf der Webseite.",
                                     Do.NET.Web.CurrentUserModule.Count);

So binden wir das HttpModule zu unserer Webseite an und damit ist es schon Verfügbar.
<httpModules>
   <add name="CurrentUserModule" type="Do.NET.Web.CurrentUserModule, Do.NET.Web"/>
</httpModules>

 Funktioniert nur wenn Session eingeschaltet ist, da das HttpModule sich an den Sessions orientiert.
Beispiel Session Config:
<system.web>
    <sessionState mode="InProc" cookieless="UseUri" timeout="30"/>

Wie mit Hilfe von HttpModulen die gesamte ASP.NET Webapplication in Echtzeit gemonitort werden kann, wird auf dem .NET User Group Dortmund "Do.Net" Treffen am 25.04.08 vorgestellt.  Mit Monitoring ist überwachen und reagieren gemeint .

Weitere Infos dazu auf www.do-dotnet.de.

Download donetweb Solution
currentusermodule.cs

Ein anderer Ansatz mit MembershipProvidern wird hier beschrieben: http://aspnet.4guysfromrolla.com/articles/041608-1.aspx

Der Tag verging,
und halb betrunken
ist Saltan ins Bett gesunken ...
Ich war dort, trank Met und Bier,
naß ward nur der Schnauzbart mir.
[Puschkin]

Die Afterlaunch Veranstaltung ist sehr interessant gewesen, vor allem auch das Thema "Visual Studio 2008 - Tipps und Tricks für die Praxis"von Roland Weigelt von der User Group Bonn www.bonn-to-code.net.

Auf der .NET User Group Dortmund findet auch ein Vortrag über "Tipps und Tricks in Visual Studio 2008" statt, wer afterlaunch verpasst hat, kann sich auf Do-DotNet.de Webseite für das Treffen am 25.04 anmelden und für alle die da waren, es findet eine vertiefung in die Tipps und Tricks statt also Anmelden lohnt sich.

Die Teilnahme an den Treffen ist kostenlos, es gibt auch keine formale Mitgliedschaft.

Weitere Information findet ihr hier: http://www.do-dotnet.de

Es gibt das nächste Treffen im April (Fr. 25.04.2008 18-20 Uhr) einfach formlos über www.do-dotnet.de anmelden.

Die geplanten Themen:

• Tipps und Tricks rund um das Visual Studio 
  Es werden die kleinen und versteckten Helfer in Visual Studio zu schnellerem Arbeiten vorgestellt.
• ASP .NET Monitoring
  Paul Mizel zeigt wie es durch PerformanceCounter möglich ist eigene WebAnwendungen zu Monitoren.
• Danach gibt es eine Überraschung

Die Teilnahme an den Treffen ist kostenlos, es gibt auch keine formale Mitgliedschaft.

Die Aufgabe ist es die Arbeitsabläufe zu speichern um später weiter zu arbeiten und vielleicht auch weiter zu delegieren.

Wir speichern jeden Vorgang mit dem Benutzernamen ab dazu erstellen wir UserCorrelationTokenProvider was wir später über die Web.config noch bekannt geben werden.

public class UserCorrelationTokenProvider :
  IPageFlowCorrelationTokenProvider
{
public string GetCorrelationToken()
{return HttpContext.Current.User.Identity.Name;}
}

Eine Procedure für die Ausgabe aller Instancen mit der UserID als Parameter:

set ANSI_NULLS ON
set QUOTED_IDENTIFIER ON
go
CREATE PROCEDURE [dbo].[pageFlow_GetAllInstanceByCorrelationToken]
@correlationToken NVARCHAR(256)
AS
BEGIN
SELECT * FROM  dbo.pageFlow_InstanceStore WHERE
CorrelationToken = @correlationToken
END
GO

Zugriff auf die Procedure:

public List<PageFlowInstanceItem> GetInstancesList()
{
List<PageFlowInstanceItem> result = new List<PageFlowInstanceItem>();
using (SqlConnection conn = new SqlConnection(
@"Integrated Security=SSPI;Persist Security Info=False;Initial Catalog=
WCSF_QuickStart;Data Source=.\SQLExpress"))
{
 using (SqlCommand command = new SqlCommand("pageFlow_GetAllInstanceByCorrelationToken", conn))
 {
  command.CommandType = CommandType.StoredProcedure;
  SqlParameter IdIn = command.Parameters.Add("@correlationToken", SqlDbType.VarChar, 255);
  IdIn.Direction = ParameterDirection.Input;
  IdIn.Value = HttpContext.Current.User.Identity.Name;
  conn.Open();
  using (SqlDataReader reader = command.ExecuteReader())
  {
   while (reader.Read())
   {
    result.Add(new PageFlowInstanceItem(
    "Beschreibung",
    reader["InstanceID"].ToString(),
    reader["Type"].ToString()));
   }
  }
 }
}
return result;
}

Hiermit ist es möglich die Liste der PageFlows zu lesen, jetzt nur noch aufwecken
IPageFlow flow = PageFlowDirectory.Provider.GetPageFlow(instanceID);
flow.Resume();
flow.RedirectToCurrentPage();

Fertig.

WCSF: www.codeplex.com/websf

Heute habe ich mit mehrfachen Generics(public class MyGeneric<A,B,C>) gekämpft. Hab versucht verschiedene Constraints an verschiedene Typen zu setzten, g**glen war auch nicht einfach, hier ist die Lösung dazu:

public class MyGeneric<A,B,C,D,P>: GenericInterfaceImpl<A>,IGenericInterface<B>
where A : class
where B : IComparable 
where C : class, new()
where D : struct
where P : ProviderBase
{
//code
}

Kennt Ihr das Problem eigene Icons für Anwendungen zu erstellen?
Jedes mal muss ich persönlich nach Icons suchen oder immer wieder eigene erstellen.

hier ist eine schöne Sammlung von Icons.

http://www.famfamfam.com/lab/icons/

Weitere Icon-Links werden hoffentlich folgen.
http://www.crystalxp.net

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