.Net Talk: Juni 2009

Dienstag, 30. Juni 2009

ContentXXL - Login module

Anbei der Code um ein Loginformular für das Anmeldemodul zu erstellen.
Below you will find the code to create a login-form for the login-module.

<SCRIPT language="vb" runat="server">
Sub Page_load()
'----------------------------------------------------------------------
' Javascript event-handler will be related to the input field
' to capture the return-key event.
'----------------------------------------------------------------------
username.Attributes.Add("onkeypress", "mykeyhandler('" & send.ClientID & "')")
password.Attributes.Add("onkeypress", "mykeyhandler('" & send.ClientID & "')")
if context.items("lang") <> 1 then
send.text = "Loggin"
else
send.text = "Anmelden"
end if
End Sub
</SCRIPT>

<SCRIPT language="JavaScript" type="text/javascript">
//----------------------------------------------------------------------
// Event handler who is waiting for return-keycode at the username
// and password field to call a postback for the login button
//----------------------------------------------------------------------
function mykeyhandler(sender) {
if (window.event.keyCode == 13) {
mysender = sender;
event.returnValue=false;
try {
document.getElementById(sender).click();
} catch(e) {}
}
}
if (document.captureEvents)
{
window.captureEvents(Event.KEYPRESS);
window.onkeypress = handlenetscape;
}
function getReturnValue(e)
{
if (!document.captureEvents)
return true;
else
{
if (e==13)
return false;
else
return true;
}
}
function handlenetscape(e)
{
if (e.which == 13){
__doPostBack('<%=send.UniqueID.replace(":","$") %>',''); } }
//----------------------------------------------------------------------
// Script which gives the focus to the username field when page is loaded,
// and if no username was entered in the username field, it will be
// prepared with the guest login.
//----------------------------------------------------------------------
function focusInput() { document.getElementById('<%=username.clientid %>').focus();
if(document.getElementById('<%=username.clientid %>').value.length < 1) {
if(<%=context.items("lang")%> == 1) {
document.getElementById('<%=username.clientid %>').value='';
document.getElementById('<%=password.clientid %>').value='';
}
else {
document.getElementById('<%=username.clientid %>').value='';
document.getElementById('<%=password.clientid %>').value='';
}
}}
</SCRIPT>

<DIV class="login_form">
<DIV class="center warning"><SPAN [mvif:haserror:neq:]>[pfl:1:Error in logging in][pfl:2:Login error]!</SPAN>[nbsp]</DIV>
<DIV class="login_label"><SPAN class="lauftext">[pfl:1:User][pfl:2:User]:</SPAN></DIV>
<DIV class="login_input">[tb:username:class="login_input"]</DIV>
<DIV class="login_label"><SPAN class="lauftext">[pfl:1:Password][pfl:2:Password]:</SPAN></DIV>
<DIV class="login_input">[tb:password:TextMode="password" class="login_input"]</DIV>
<DIV class="login_label">[nbsp]</DIV>
<DIV class="login_button">[lbn:send:commandName="Update" text="Login"]</DIV></DIV>
<SCRIPT language="Javascript">
document.body.onLoad=focusInput();
</SCRIPT>

ContentXXL Meine Erfahrung - ContentXXL my experience

ContentXXL ist ein Content Management System, welches einen Contentmanager voraussetzt, der auch HTML Kenntnisse besitzt. Im Grunde braucht man für ContentXXL keine tieferen
.NET Kentnisse um es aufzusetzen - so lang es in der Standardversion ohne benutzerdefinierte Einstellungen läuft. Wenn dann allerdings benutzerdefinierte Elemente eingebaut
werden sollen, wird es sehr ungemütlich. ContentXXL benutzt dann verschiedenste eigene Skriptsprachen für die Erstellung von Formularen beispielsweise. Auch andere Anpassungen
gestallten sich sehr schwierig, weil das System nicht OpenSource ist und vieles nicht besonders einsichtig. Es arbeitet mit einer Armee an SQL Prozeduren, was einzelne
Methodenaufrufe schwer nachvollziehbar macht.
ContentXXL kommt mit einem grossen Umfang an Basismodulen, welche zum Grossteil nicht gebraucht werden. Wie schon erwähnt, für den Contentmanager eine einfache Handhabung,
wenn er Module einrichten will, für den Entwickler von benutzerdefinierten Modulen eher ein heiles Durcheinander.
Sobald man das Prinzip verstanden hat, dass jede Seite aus Modulen, diese aus Objekten besteht, funktioniert das Arbeiten einigermassen, auch wenn das Prinzip für Entwickler
mit CMS Vergleichen, sehr umständlich und kompliziert wirkt. Man erwischt sich sehr oft bei der Frage: "Warum hat man das eigentlich so gelöst, was hat sich der ContentXXL
Entwickler dabei gedacht?".
In der Praxis ist die Anforderung bei grossen Firmen, dass man ein Content Management System in einer Serverfarm oder Loadbalanced betreibt. Da gibt es gravierende Mängel an
diesem System. Man findet sich irgendwann in einigen Workarounds wieder, wenn man das bewerkstelligen will. Da Content und System nicht richtig getrennt sind ist der Einsatz
auch im 3 Levelsystem (dev, stage, live) schwer umzusetzen.
Caching war ebenso ein kleines Problem. Es hat den Makel, dass bei nutzen aller Cachingmöglichkeiten (ContentXXL bietet einige), der Cache bei Contentbearbeitung nicht geleert
wird. Somit hat man die Möglichkeit Cachefeatures zu reduzieren, Contentmanagement irgendwie zu trennen, wobei wir da wieder bei Workarounds sind, die man vom CMS standardmässig
erwartet.

Gut an ContentXXL ist:
- Untere Bereichsführung im Sitemanager
- Support funktioniert gut
- Definieren von Benutzerrechten
- Cachingmöglichkeiten

Nicht gut an ContentXXL ist:
- Keine Informationen zu ContentXXL oder Fragen online in Suchmaschinen zu finden
- Quellcode nicht gut strukturiert
- Datenbank sehr undurchsichtig
- nicht geeignet für die einfache Installation in Multiserversystemen
- Wartung und Updates sind schwierig zu fahren
- Dev, Stage, Live kaum umsetzbar
- Kosten
- Sprachunterstützung - es sollten mehr Sprachen unterstützt werden
- Caching und Contentupdate

Mein Fazit ist. Für eine kleinere Webseite, wo die Rolle des Contentmanagers auch die des Webpublishers ist, sicher ein interessantes System, wenn man nur live arbeitet.
Jedoch für grosse Webseiten, mit mehreren Sprachvarianten, verschiedenen Produktionslevels, Multiserverumgebungen würde ich das CMS nicht empfehlen. Das einzig gute Feature
bei grösseren Webseiten wäre die Benutzerrechteverwaltung.
Wenn jemand ein CMS braucht, welches viel Onlinesupport bietet, einfache Struktur um viel benutzerdefiniert zu entwickeln, dann denke ich ist er bei ContentXXL absolut
falsch. Da würde ich Umbraco oder DotNetNuke empfehlen.

IE Emulatoren

Manchmal würde man gerne seine Webseite in einem älteren Internet Explorer testen. Jedoch ist es im Standardbetrieb nicht möglich den Internet Explorer in mehreren Versionen auf einem Rechner laufen zu lassen. Hierzu kann man Emulatoren des IE verwenden. Eine Webseite, welche verschiedene Emulatoren anbietet ist die folgende. Einfach herunterladen, entzippen und die .exe Datei starten und schon kann man jede Webseite besuchen.

Sometimes you might feel the need to test your website in older version of the Internet Explorer. Usually it is not possible to have several versions running on one PC. But you can do the work-around in using emulators. The following link has several IE version emulators. Just unzip and run the .exe and you can go to any website.

http://browsers.evolt.org/?ie/32bit/standalone

Mittwoch, 17. Juni 2009

Das richtige CMS - the cms that fits

Es gibt mittlerweile hunderte von Content Management Systemen. Jedoch, welches ist das Beste? Hierzu habe ich einmal zwei Kernthemen herausgefiltert. Soll es ein System sein, welches von einem erfahrenen Entwickler eingestellt und von einem kaum erfahrenen User verwaltet wird, oder der umgekehrte Fall, ein System, welches von einem nicht erfahrenen User eingestellt und verwaltet werden kann? Detailiertere Anforderungen wären. Soll es später in einem 1 Webserverbetrieb oder Serverfarm, Loadbalanced funktionieren? Alles zentrale Fragen, welche analysiert werden müssen.
Danach gibt es noch zwei Unterschiede. Geht man den weg Open-Source oder nicht? Open-Source bietet die Möglichkeit ein System den eigenen Anforderungen anzupassen. Jedoch sind manche Systeme schon bei ihrem Kauf angepasst. In meiner PHP und .NET Entwicklerzeit konnte ich ein wenig Erfharung sammeln und muss bisher sagen, dass das bestüberlegteste Konzept bisher das Open-Source CMS Umbraco mit sich bringt. Vorteil von open-source ist, dass sich viele Entwickler beteiligen. Sollte einer abspringen oder seine Tätigkeit beenden, läuft das Projekt selbständig weiter. Bei gekauften Lösungen muss man damit rechnen, dass bei Einstellung des Betriebs einer Firma, jeglicher Support mit eingestellt wird.
(siehe unten)

There are already hundreds of content management systems out there. But how do you get to know which one is the best? Therefore I grab two main topics. Is a system supposed to be integrated and improved by a experienced developer and maintained by a regular user or do you want a regular user to setup and maintian the system? Detailed specifications to a CMS would be: is it supposed to run in a single webserver environment or a server-farm, loadbalanced, etc.? Those are basic and centralized question that need to be analyzed.
Then there are two differences. Are you going the way to open-source or not? Open-source offers the possibility to customize to your needs. Most features are in-box with bought systems. During my development-experience with PHP and .NET, I must say, the best structured concept so far is the open-source CMS Umbraco. Basic advantage of open-source is, that multiple developers are involved. If one of the core-developers should leave the project, it will continue. If a bought solution company will terminate their business, then usually support gets terminated as well.

Nützliche Links zu Content Management Systemen:
Useful links to content management systems:

Open-source:
www.umbraco.org (.NET)
www.dotnetnuke.com (.NET)
www.typo3.org (PHP)
www.joomla.de (PHP)

Lizenzlösungen/licensed versions:
www.sitecore.net (.NET)
www.episerver.com (.NET)
www.contentxxl.de (.NET)

Dienstag, 16. Juni 2009

Separieren von web.config Daten

Es gibt manchmal Situationen in welchen man gerne Daten aus der web.config aus der Applikation bearbeiten würde. Jedoch sind durch ASP.NET .config Dateien aus der Applikation nicht zugänglich. Es gibt einen kleinen Workaround, der jedoch eine kleine Sicherheitslücke öffnet. Dessen sollte man sich bewusst sein. Man hat die Möglichkeit Daten aus der web.config auszulagern. Was man dann machen kann, ist die Daten in einem selbsternannten XML File zu speichern und auf dieses aus der Applikation zuzugreifen.
Man kann in der web.config die AppSettings oder ConnectionStrings per configSource auslagern. Man verwendet dann eine test.test Datei, Endung kann man selbst bestimen z.B. test.Firmenname und dort lagert man die Nodes aus. Man kann jetzt per XML zugreifen und Änderungen vornehmen. Vielleicht sollte man vorher noch die Rechte auf dieses File zur Sicherheit ändern.

There are sometimes situations, where you would like to change data in the web.config out of the application. ASP.NET usually blocks .config files to be changes out of the application. There is a little work-around to this situation. But be aware, that this reduces a little bit your application- security.
You can outsource the AppSettings or ConnectionString with configSource. Then you create a new test.test file (you can use any file-type also own one) and paste the nodes in there. You can now access this file with XML and make changes. Maybe you should set different permissions on this file to add some security.

web.config
<appSettings configSource ="test.test" />

test.test File
<appSettings>

</appSettings>

Freitag, 12. Juni 2009

Maxlength in der Textbox

Eine Textbox, welche die Eigenschaft MaxLength auf einen bestimmten Wert gesetzt hat, kann dennoch aus dem Codebehind mit beliebig langen Strings befüllt werden. Eine Änderung zur Laufzeit wird nicht möglich, weil dann die Länge beschränkt ist.

A text-box with the property MaxLenght set to some length can be set with a value longer then the length from the code-bhind. Changes during runtime are not possible, because then the length limit will determine.

Donnerstag, 11. Juni 2009

if-else VS. XML

Ich denke jeder Entwickler hatte schon einmal die Situation, dass er verschiedene Abhängigkeiten abfangen musste. Dies ist mit if-else bzw. switch möglich, jedoch erfordert es bei jeder Änderung der Logik das Änderen des Quellcodes und dieser steht bei einer kompilierten Anwendung oft nicht zur Verfügung. Anbei ein Beispiel das ganze per XML zu lösen. Umgebung für dieses Beispiel ist Framework 3.5 mit Linq. Ich habe zur Ausgabe Dropdownlists verwendet.

I think every developer had already the situation, that he needed to display or catch certain dependencies. With if-else or switch you can do that, but in case of changes to the logic, you need to get into the source code and change that. Sometimes you don't have the source code or just a compiled version. You can handle this with XML. The environment of this example is framework 3.5 with Linq. I used for output dropdown-lists.

aspx - Seite

Codebehind

protected void Page_Load(object sender, EventArgs e)
{
if (!Page.IsPostBack)
{
LoadFirstMenu();
}
}

protected void LoadFirstMenu()
{
Ebene1.Items.Add(new ListItem("Auswahl", "Auswahl"));
XDocument myDocument = XDocument.Load(MapPath("XMLTest.xml"));
var myQuery = from strResult in myDocument.Descendants("Logic").Descendants("Parent") select strResult.Attribute("ID").Value;
foreach (var Item in myQuery)
{
Ebene1.Items.Add(new ListItem(Item, Item));
}
Ebene2.Items.Clear();
Ebene3.Items.Clear();
}

protected void LoadSecondMenu(object sender, EventArgs e)
{
Ebene2.Items.Clear();
if (Ebene1.SelectedItem.Value != "Auswahl")
{
Ebene2.Items.Add(new ListItem("Auswahl", "Auswahl"));
XDocument myDocument = XDocument.Load(MapPath("XMLTest.xml"));
var myQuery = from strResult in myDocument.Descendants("Logic").Descendants("Parent").Descendants("Child") where strResult.Parent.Attribute("ID").Value == Ebene1.SelectedItem.Value select strResult.Attribute("ID").Value;
foreach (var Item in myQuery)
{
Ebene2.Items.Add(new ListItem(Item, Item));
}
}
Ebene3.Items.Clear();
}

protected void LoadThirdMenu(object sender, EventArgs e)
{
if (Ebene2.SelectedItem.Value != "Auswahl")
{
Ebene3.Items.Add(new ListItem("Auswahl", "Auswahl"));
XDocument myDocument = XDocument.Load(MapPath("XMLTest.xml"));
var myQuery = from strResult in myDocument.Descendants("Logic").Descendants("Parent").Descendants("Child").Descendants("Child") where strResult.Parent.Attribute("ID").Value == Ebene2.SelectedItem.Value select strResult.Attribute("ID").Value;
foreach (var Item in myQuery)
{
Ebene3.Items.Add(new ListItem(Item, Item));
}
}
}

protected void GetValue(object sender, EventArgs e)
{
if (Ebene3.SelectedItem.Value != "Auswahl")
{
XDocument myDocument = XDocument.Load(MapPath("XMLTest.xml"));
var myQuery = from strResult in myDocument.Descendants("Logic").Descendants("Parent").Descendants("Child").Descendants("Child") where strResult.Attribute("ID").Value == Ebene3.SelectedItem.Value select strResult.Value;
foreach (var Item in myQuery)
{
MyLit.Text = Item;
}
}
}

XML Datei

<?xml version="1.0" encoding="utf-8" ?>
<Logic>
<Parent ID="ParentItem">
<Child ID="Child1.1">
<Child ID="Child1.1.1">TextBlock 1.1.1</Child>
<Child ID="Child1.1.2">TextBlock 1.1.2</Child>
<Child ID="Child1.1.3">TextBlock 1.1.3</Child>
<Child ID="Child1.1.4">TextBlock 1.1.4</Child>
<Child ID="Child1.1.5">TextBlock 1.1.5</Child>
</Child>
<Child ID="Child1.2">
<Child ID="Child1.2.1">TextBlock 1.2.1</Child>
<Child ID="Child1.2.2">TextBlock 1.2.2</Child>
<Child ID="Child1.2.3">TextBlock 1.2.3</Child>
<Child ID="Child1.2.4">TextBlock 1.2.4</Child>
<Child ID="Child1.2.5">TextBlock 1.2.5</Child>
</Child>
<Child ID="Child1.3">
<Child ID="Child1.3.1">TextBlock 1.3.1</Child>
<Child ID="Child1.3.2">TextBlock 1.3.2</Child>
<Child ID="Child1.3.3">TextBlock 1.3.3</Child>
<Child ID="Child1.3.4">TextBlock 1.3.4</Child>
<Child ID="Child1.3.5">TextBlock 1.3.5</Child>
</Child>
</Parent>
<Parent ID="ParentItem2">
<Child ID="Child2.1">
<Child ID="Child2.1.1">TextBlock 2.1.1</Child>
<Child ID="Child2.1.2">TextBlock 2.1.2</Child>
<Child ID="Child2.1.3">TextBlock 2.1.3</Child>
<Child ID="Child2.1.4">TextBlock 2.1.4</Child>
<Child ID="Child2.1.5">TextBlock 2.1.5</Child>
</Child>
<Child ID="Child2.2">
<Child ID="Child2.2.1">TextBlock 2.2.1</Child>
<Child ID="Child2.2.2">TextBlock 2.2.2</Child>
<Child ID="Child2.2.3">TextBlock 2.2.3</Child>
<Child ID="Child2.2.4">TextBlock 2.2.4</Child>
<Child ID="Child2.2.5">TextBlock 2.2.5</Child>
</Child>
</Parent>
<Parent ID="ParentItem3">
<Child ID="Child3.1">
<Child ID="Child3.1.1">TextBlock 3.1.1</Child>
<Child ID="Child3.1.2">TextBlock 3.1.2</Child>
<Child ID="Child3.1.3">TextBlock 3.1.3</Child>
<Child ID="Child3.1.4">TextBlock 3.1.4</Child>
<Child ID="Child3.1.5">TextBlock 3.1.5</Child>
</Child>
<Child ID="Child3.2">
<Child ID="Child3.2.1">TextBlock 3.2.1</Child>
<Child ID="Child3.2.2">TextBlock 3.2.2</Child>
<Child ID="Child3.2.3">TextBlock 3.2.3</Child>
<Child ID="Child3.2.4">TextBlock 3.2.4</Child>
<Child ID="Child3.2.5">TextBlock 3.2.5</Child>
</Child>
<Child ID="Child3.3">
<Child ID="Child3.3.1">TextBlock 3.3.1</Child>
<Child ID="Child3.3.2">TextBlock 3.3.2</Child>
<Child ID="Child3.3.3">TextBlock 3.3.3</Child>
<Child ID="Child3.3.4">TextBlock 3.3.4</Child>
<Child ID="Child3.3.5">TextBlock 3.3.5</Child>
</Child>
<Child ID="Child3.4">
<Child ID="Child3.4.1">TextBlock 3.4.1</Child>
<Child ID="Child3.4.2">TextBlock 3.4.2</Child>
<Child ID="Child3.4.3">TextBlock 3.4.3</Child>
<Child ID="Child3.4.4">TextBlock 3.4.4</Child>
<Child ID="Child3.4.5">TextBlock 3.4.5</Child>
</Child>
</Parent>
<Parent ID="ParentItem4">
<Child ID="Child4.1">
<Child ID="Child4.1.1">TextBlock 4.1.1</Child>
<Child ID="Child4.1.2">TextBlock 4.1.2</Child>
<Child ID="Child4.1.3">TextBlock 4.1.3</Child>
<Child ID="Child4.1.4">TextBlock 4.1.4</Child>
<Child ID="Child4.1.5">TextBlock 4.1.5</Child>
</Child>
<Child ID="Child4.2">
<Child ID="Child4.2.1">TextBlock 4.2.1</Child>
<Child ID="Child4.2.2">TextBlock 4.2.2</Child>
<Child ID="Child4.2.3">TextBlock 4.2.3</Child>
<Child ID="Child4.2.4">TextBlock 4.2.4</Child>
<Child ID="Child4.2.5">TextBlock 4.2.5</Child>
</Child>
</Parent>
</Logic>

Willkommen

Willkommen in meinem Blog. Ich möchte hier regelmässig über .NET IT Themen berichten. Über Erfahrungen, Work-arounds, etc. aus dem Bereich Applikationsentwicklung im Microsoft .NET Umfeld. Ich arbeite mit folgenden Applikationen und Software. Entwickeln in Visual Studio, sowie Visual Studio Express, dazu MS SQL und MS SQL Express. Als Applikationen zur Weiterentwicklung und Einsatz verwende ich Umbraco und ContentXXL. Ich hoffe die Posts sind interessant und helfen bei der ein oder anderen Fehlermeldung oder verbessern Eure Applikation.

Welcome to my blog. I try to talk in regular periods about .NET topics. About experience, work-arounds, etc. in the .NET environment based on application development. I am working with the following software and applications. Developing in Visual Studio and Visual Studio Express based on MS SQL and MS SQL Express Edition. As applications I am using Umbraco and ContentXXL. I hope you enjoy my posts and that they might help you to solve an error or to improve your application.

.Net Talk