Schädler und .NET

Schritt für Schritt zum eigenen generischen Repository

schaedlerdaniel — Wed, 28 Mar 2012 09:41:43 +0000

Das Speichern und Abfragen von Daten wäre mit dem klassischen Repository-Pattern viel zu aufwändig für kleinere Projekte. In Anlehnung an das hier, in Verbindung mit dem Unit Of Work Pattern, verwendete generische Repository, habe ich mir überlegt, dass es doch für kleinere Projekte auch eine Lösung geben sollte, die nicht so viel Aufwand nach sich zieht.

Als Grundlage, oder besser gesagt als Ausgangspunkt habe ich mir diesen Artikel zur Brust genommen.

Wie wollen wir vorgehen?

Wir erstellen uns ein ganz triviales Model (Adressverwaltung)
Dann erstellen wir uns Schritt für Schritt das Repository
Am Schluss ziehen wir noch ein Fazit aus dem Artikel

Erstellung des Models

In Anbetracht, dass nicht zwingend die Korrektheit der Datenmodellierung und der verwendeten Typen im Mittelpunkt steht, erstellen wir uns das Modell wie folgt.

Wichtig an diesem Punkt ist, dass die Pluralisierung nicht geändert wird (hierzu später mehr bei der Erstellung des Repositories). Die Eigenschaften für die Personen-Entität sind hier represäntativ für alle anderen auch.

Eine Spezialität ist die komplexe Eigenschaft Persistance, welch die Attribute für

CreateDate
ModifyDate
Creator
Modifier

beherbergt. Schön wäre es ja, wenn alle Attribute bei der entsprechenden Operation des Repositories, Add, Update automatisch aktualisiert wird (dazu später mehr).

Soweit so gut, wir haben unsere Modell für die 1001 Adressverwaltung erstellt. Wollen wir doch zum nächsten Schritt übergehen, die Erstellung des Repositories.

Die Repository Erstellung

Damit wir mit unserem Repository die CRUD Operation unterstützen können brauchen wir folgende Methoden:

Rumpf des Repositories
Add
Remove
Update
GetObjectById
GetObjectByQuery
Persistance Attribute automatisch erstellen /aktualisieren

Rumpf des Repositories

Damit wir die restlichen Methoden implementieren können müssen wir das Repository wie folgt erstellen:

namespace GenericRepositoryPattern
{
    public class Repository : IDisposable where T: EntityObject
    {
        /// 
        /// The context of the database.
        /// 
        private readonly AddressModelContainer context;
        /// 
        /// The related objectSet to the context. Is dependent
        /// of the context.
        /// 
        private readonly ObjectSet objectSet;
        /// 
        /// Constructor to initialize the context and the
        /// objectSet.
        /// 
        /// The context of the model.
        public Repository(AddressModelContainer context)
        {
            this.context = context;

            if (context != null) 
            { 
                this.objectSet = context.CreateObjectSet();
                this.context.SavingChanges +=new EventHandler(context_SavingChanges);
            }
        }

(Anmerkung: Die Wiedergabe des Code’s ist gekürzt).
Wichtig hierbei ist, dass der Context von aussen her dem Konstruktor übergeben werden muss und das ObjectSet vom instantiierten Context das ObjectSet erhält.

Add Methode

Damit wir ein neues Objekt zu unserem ObjectContex hinzufügen können müssen wir die Methode wie folgt implementieren.

        /// 
        /// Add's a newly created entity to the
        /// objectSet
        /// 
        /// The newly created entity.
        public void Add(T entity)
        {
            this.objectSet.AddObject(entity);            
            this.context.SaveChanges();                    
        }

Also eine ganz einfache Sache. Als nächstes wenden wir uns der Remove Methode zu.

Remove Methode

Das Entfernen eines Objektes ist relativ rasch implementiert:

        public void Remove(T entity)
        {
            if (entity != null)
            {
                this.objectSet.Attach(entity);
                this.context.DeleteObject(entity);
                this.context.SaveChanges();
            }
        }

Also keine Hexerei. Als nächstes wenden wir uns der Update Methode zu und schauen diese genauer an.

Update Methode

Die Update Methode zeigt sich in ihrer Ausprägung so:

        public void Update(T entity)
        {
            this.objectSet.Attach(entity);
            this.context.ObjectStateManager.ChangeObjectState(entity, EntityState.Modified);        
            this.context.SaveChanges();
        }

Damit der Context weiss, dass sich was geändert hat muss die Entität an den Context wieder „Attached“ und im ObjectStateManager der EntityState auf Modified gestellt werden. Dann speichert der Context die Daten aktualisiert.

GetObjectById

Damit wir ein Object vom Typ Person erhalten, anhand der übergebenen Id, erstellen wir uns in der Methode einen EntityKey und einem KeyValuePair. Das Attribut dass die Id verkörpert heiss auch „Id“.

        public T GetById(Int32 id)
        {
            string entitySet = string.Format(@"{0}Set", typeof(T).Name);
            KeyValuePair member = new KeyValuePair("Id", id);
            IEnumerable> values = new KeyValuePair[] { member };

            EntityKey key = new EntityKey(entitySet, values);

            return (T)this.context.GetObjectByKey(key);
        }

Und hier sehen wir auch wieso wir die Pluralisierung PersonSet belassen haben. Damit der Context weiss in welchem Set er suchen soll müssen wir dieses übergeben. Das erreichen wird mit dem kleinen Codeschnipsel

string entitySet = string.Format(@"{0}Set", typeof(T).Name);

Danach wird der EntityKey erstellt und dem Context zur Abfrage übergeben. Das gefundene Object casten wird dann in den generischen Typ den wir übergeben haben.

GetObjectByQuery

Damit wir spezifisch ein Objekt, oder auch mehrere zurück erhalten können wir diese mit dem entsprechenden Methode und einer Func zurück holen. Als Beispiel: Wenn ich eine Person haben möchte bei welchem ich nur den Vornahmen und den Nachnamen haben möchte, dann lege ich beim Aufrufer der Methode folgende Funktion fest:

Func functionPerson = person => person.FirstName.ToLower().Equals("hans");

Die kann dann der Methode übergeben werden und diese erstellt dann auch das Resultat anhand der übergebenen Methode.

        public IEnumerable GetObjectByQuery(Func customQuery)
        {
            if (customQuery == null)
            {
                throw new ArgumentNullException("parameter: customquery must be given by caller!");
            }

            List result = this.objectSet.Where(customQuery).ToList();
            result.ForEach(this.objectSet.Detach);
            return result;
        }
[/csharp]
Wichtig ist nur, dass die gefundenen Objekte vom Context getrennt werden, damit diese auch ausserhalb der Verwendung des Contextes verwendet werden können.
Persistance Attribute aktualisieren
Dem Leser wird nicht entgangen sein, dass im Konstruktor der Context mit seinem Ereignis SavingChanges verknüpft worden ist. Hier werden alle relevanten Attribute vom komplexen Property IPersistance aktualisiert oder erstellt. Die Ereignisbehandlung sieht dann so aus:
[code language="csharp"]
        void context_SavingChanges(object sender, EventArgs e)
        {
            this.context.ObjectStateManager.GetObjectStateEntries(EntityState.Added).ToList().ForEach(entity => {
                if (entity != null && entity.Entity != null && entity.Entity.GetType().GetProperty("Persistance") != null)
                {
                    IPersistance persistance = CreatePersistance();
                    entity.Entity.GetType().GetProperty("Persistance").SetValue(entity.Entity, persistance, null);
                }
            });

            this.context.ObjectStateManager.GetObjectStateEntries(EntityState.Modified).ToList().ForEach(entity =>
            {
                if (entity != null && entity.Entity != null && entity.Entity.GetType().GetProperty("Persistance") != null)
                {
                    UpdatePersistance(entity.Entity);
                }
            });
        }

Hier wird eigentlich nicht’s anderes gemacht, als das alle Entitäten die den Status Added oder Modified haben das Persistance komplexe Property angepasst. Für das sind dann die zwei Methoden zuständig.

        private IPersistance CreatePersistance()
        {
            IPersistance persistance = new IPersistance();
            persistance.CreateDate = DateTime.Now;
            persistance.ModifyDate = DateTime.Now;
            persistance.Creator = WindowsIdentity.GetCurrent().Name;
            persistance.Modifier = persistance.Creator;
            return persistance;
        }

Wird verwendet wenn eine neue Entität persistiert wird und die nachfolgende wenn eine Entität geändert worden ist.

        private void UpdatePersistance(object entity)
        {
            if (typeof(T).GetProperty("Persistance") != null)
            {
                IPersistance persistance = (IPersistance)typeof(T).GetProperty("Persistance").GetValue(entity, null);
                if (persistance != null)
                {
                    persistance.Modifier = WindowsIdentity.GetCurrent().Name;
                    persistance.ModifyDate = DateTime.Now;
                }
            }
        }

Zur Übersicht noch der vollständige Code des gesamten Repositories.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data.Objects.DataClasses;
using GenericRepositoryPattern.Model;
using System.Data.Objects;
using System.Data;
using System.Security.Principal;
using System.Reflection;

namespace GenericRepositoryPattern
{
    /// 
    /// Generic repository.
    /// 
    /// For example it could be a model entity Person
    public class Repository : IDisposable where T: EntityObject
    {
        /// 
        /// The context of the database.
        /// 
        private readonly AddressModelContainer context;
        /// 
        /// The related objectSet to the context. Is dependent
        /// of the context.
        /// 
        private readonly ObjectSet objectSet;
        /// 
        /// Constructor to initialize the context and the
        /// objectSet.
        /// 
        /// The context of the model.
        public Repository(AddressModelContainer context)
        {
            this.context = context;

            if (context != null) 
            { 
                this.objectSet = context.CreateObjectSet();
                this.context.SavingChanges +=new EventHandler(context_SavingChanges);
            }
        }
        /// 
        /// Get's a specific entity by it's key.
        /// 
        /// The id from the object to retrieve.
        /// The object if it's present in the db, or NULL if not existent.
        public T GetById(Int32 id)
        {
            string entitySet = string.Format(@"{0}Set", typeof(T).Name);
            KeyValuePair member = new KeyValuePair("Id", id);
            IEnumerable> values = new KeyValuePair[] { member };

            EntityKey key = new EntityKey(entitySet, values);

            return (T)this.context.GetObjectByKey(key);
        }
        /// 
        /// Allows the user to query the db with a custom
        /// function to retrieve data from the specific type
        /// of entity.
        /// 
        /// Created outisde by caller
        /// A queryable of T with the possibility to treat it further.
        /// 
        /// Func functionPerson = person => person.FirstName.ToLower().Contains("da")
        /// 
        public IEnumerable GetObjectByQuery(Func customQuery)
        {
            if (customQuery == null)
            {
                throw new ArgumentNullException("parameter: customquery must be given by caller!");
            }

            List result = this.objectSet.Where(customQuery).ToList();
            result.ForEach(this.objectSet.Detach);
            return result;
        }

        /// 
        /// Updates the values of the entity.
        /// 
        /// Updates a given entity with new values.
        public void Update(T entity)
        {
            this.objectSet.Attach(entity);
            this.context.ObjectStateManager.ChangeObjectState(entity, EntityState.Modified);        
            this.context.SaveChanges();
        }
        /// 
        /// Add's a newly created entity to the
        /// objectSet
        /// 
        /// The newly created entity.
        public void Add(T entity)
        {
            this.objectSet.AddObject(entity);            
            this.context.SaveChanges();                    
        }
        /// 
        /// Occurs every time an entity is saved or updated.
        /// It goes through the entity properties to update or craete
        /// the persistance attributes that are necessary for saving.
        /// 
        /// The context
        /// The eventargs from the context.
        void context_SavingChanges(object sender, EventArgs e)
        {
            this.context.ObjectStateManager.GetObjectStateEntries(EntityState.Added).ToList().ForEach(entity => {
                if (entity != null && entity.Entity != null && entity.Entity.GetType().GetProperty("Persistance") != null)
                {
                    IPersistance persistance = CreatePersistance();
                    entity.Entity.GetType().GetProperty("Persistance").SetValue(entity.Entity, persistance, null);
                }
            });

            this.context.ObjectStateManager.GetObjectStateEntries(EntityState.Modified).ToList().ForEach(entity =>
            {
                if (entity != null && entity.Entity != null && entity.Entity.GetType().GetProperty("Persistance") != null)
                {
                    UpdatePersistance(entity.Entity);
                }
            });
        }
        /// 
        /// Set's the createdate to the datetime
        /// where the creation of the entity
        /// object has been executed.
        /// 
        /// The entity to create the IPersistance creator and update attributes.
        private IPersistance CreatePersistance()
        {
            IPersistance persistance = new IPersistance();
            persistance.CreateDate = DateTime.Now;
            persistance.ModifyDate = DateTime.Now;
            persistance.Creator = WindowsIdentity.GetCurrent().Name;
            persistance.Modifier = persistance.Creator;
            return persistance;
        }
        /// 
        /// Set's the modifydate to the datetime
        /// where the modification of the entity
        /// object has been executed.
        /// 
        /// The entity to update the IPersistance modify attributes.
        private void UpdatePersistance(object entity)
        {
            if (typeof(T).GetProperty("Persistance") != null)
            {
                IPersistance persistance = (IPersistance)typeof(T).GetProperty("Persistance").GetValue(entity, null);
                if (persistance != null)
                {
                    persistance.Modifier = WindowsIdentity.GetCurrent().Name;
                    persistance.ModifyDate = DateTime.Now;
                }
            }
        }
        /// 
        /// Removes an entity from the database.
        /// 
        /// The entity to remove. Must be loaded prior to remove.
        public void Remove(T entity)
        {
            if (entity != null)
            {
                this.objectSet.Attach(entity);
                this.context.DeleteObject(entity);
                this.context.SaveChanges();
            }
        }

        #region IDisposable Members
        /// 
        /// Dispose the context.
        /// 
        public void Dispose()
        {
            if (this.context != null)
            {
                this.context.Dispose();
            }
        }

        #endregion
    }
}

Fazit

Mit dem hier vorgestellten Ansatz ist es uns , auch für kleinere Projekte möglich, rasch und einfach CRUD Methoden zur Verfügung zu stellen ohne, dass wir das Unit of Work und das Repositoriy Pattern in ihren grössten Ausprägungen implementieren müssen.

Wenn Ihnen der Artikel gefallen hat, würde ich mich über einen KICK freuen. Auf Verbesserungsvorschläge und Kritik bin ich natürlich auch offen.

WCF DataContracts synchronisieren mit Entity Framework Klassen

schaedlerdaniel — Tue, 28 Feb 2012 15:32:33 +0000

Im Rahmen einer Projektarbeit haben wir das Ziel Businessdaten über die WCF zu transportieren. Die Daten sind im Entity Framework gespeichert. Schön wäre es wenn wir diese Entitäten direkt über den Kommunikationskanal schicken könnten. Leider ist dies nicht möglich da ein direktes Versenden der Entitäten, durch Projektrestriktionen nicht erlaubt ist, oder man ganz einfach keine Referenzen auf dem Client auf den Namespace System.Data haben möchte.

Also muss eine Lösung her die einigermassen hilfreich sein kann. Diese Lösung erledigt das Mapping eines einkommenden DatenVertrages mit der entsprechenden Entität.

Vorbereitungen

AddressManagement.BusinessModel
AddressManagement.PersistanceModel
AddressManagement.ServiceLayer

Für das Hosten der WCF können wir verschiedene Möglichkeiten nutzen, die aber in diesem Blogpost nicht abgedeckt werden. Es soll nur die Möglichkeit einer generischen Mapping Methode aufgezeigt werden, damit die Daten vom Entity Framework nicht direkt über den Kommunikationskanal versendet werden müssen, sondern gekapselt werden.

Wir erstellen uns ein Entity-Modell dass wie folgt aussieht: (Dieses erstellen wir im Projekt AddressManagement.Persistance)

Anschliessend erstellen wir uns unseres eigentliche Businessklassenmodell welches wir im Projekt AddressManagement.BusinessModel anlegen.

Das Businessklassen Model

Wichtig hierbei ist, dass die Beziehungen, Phones, Addresses genau gleich heissen wie im Entity Model. Auch alle anderen Eigenschaften müssen die gleiche Schreibweise haben, da sonst im Mapper keine Übereinstimmung gefunden wird.

Die Businessklassen sollen dann mit der WCF übertragen werden. Hierzu werden die Klassen mit den entsprechenden Attributen versehen.

Die Klasse Person

namespace AddressManagement.BusinessModel
{
    [DataContract]
    [KnownType(typeof(Address))]
    [KnownType(typeof(Phone))]
    public class Person : IPersistance
    {        
        #region IPersistance Members
        [DataMember]
        public Int32 Id { get; set; }
        #endregion
        [DataMember]
        public string FirstName { get; set; }
        [DataMember]
        public string LastName { get; set; }
        [DataMember]
        public IEnumerable Addresses { get; set; }
        [DataMember]
        public IEnumerable Phones { get; set; }
    }
}

Die Klasse Phone

namespace AddressManagement.BusinessModel
{
    [DataContract(IsReference = true)]
    [KnownType(typeof(ObjectType))]
    public class Phone : IPersistance
    {
        #region IPersistance Members
        [DataMember]
        public Int32 Id { get; set; }
        #endregion
        [DataMember]
        public string SubScriberNumber { get; set; }
        [DataMember]
        public ObjectType PhoneType { get; set; }
    }
}

Die Klasse Address

namespace AddressManagement.BusinessModel
{
    [DataContract(IsReference = true)]
    [KnownType(typeof(ObjectType))]
    public class Address : IPersistance
    {
        #region IPersistance Members
        [DataMember]
        public Int32 Id { get; set; }
        #endregion
        [DataMember]
        public string StreetName { get; set; }
        [DataMember]
        public Int16 StreetNumber { get; set; }
        [DataMember]
        public Int16 PostalCode { get; set; }
        [DataMember]
        public string CityName { get; set; }
        [DataMember]
        public ObjectType AddressType { get; set; }
    }
    [DataContract]
    public enum ObjectType
    {
        [EnumMember]
        Private,
        [EnumMember]
        Business
    }
}

Der Mapper/Synchronisierer

Damit wir nun beide Welten miteinander abgleichen können ist der Mapper zu erstellen, welche ich Schritt für Schritt erläutere. Wir erstellen uns als erstes eine Statische Klasse mit dem Namen DataContractToEntityMapper oder DataContractAndEntitySynchronizer und erstellen als erstes folgende Methode:

        /// 
        /// Maps a given datacontract to the appropriate entity.
        /// Check's if the datacontract is new or must be updated
        /// and return the newly persisted contract back or it's updated
        /// values, if it was already persisted before.
        /// 
        /// Type of the datacontract
        /// Type of the entity
        /// The datacontract to interact with.
        /// A new or updated datacontract from the database.
        public static IPersistance SynchronizeDataContractAndEntity(T dataContract)
            where T : IPersistance
            where U : EntityObject
        {
            IPersistance persistance = Activator.CreateInstance();
            // 1. a) Determine if the datacontract is already persisted.
            if (dataContract.Id == 0)
            {
                // 1. b) Map the newly created entity to the datacontract.                
                PersistDataContract(dataContract);
            }
            else
            // 2.) Map an existing entity to it's datacontract pendant
            {
                U persistedEntity = Activator.CreateInstance();
                using (AddressRepository repository = new AddressRepository(new AddressManagementPersistanceModelContainer()))
                {
                    persistedEntity = repository.GetByKey(dataContract.Id);
                    persistance = UpdateProperties(dataContract, persistedEntity);
                }
            }
            return persistance;
        }

Diese Methode führ folgende Aktionen durch:

Existiert der eingetroffene DataContract schon in der Datenbank?
Ist die Id 0, dann muss eine neue Entität angelegt werden
Ist die Id > 0 ist der Contract bereits in der Datenbank vorhanden und muss mit den vorliegenden Werten aktualisiert werden.
Zum Schluss, nachdem die Entity und der DataContract miteinander synchronisiert worden sind, wird ein aktualisierter DataContract zurück gegeben.

Als nächster Schritt erstellen wir uns eine Methode die für den Abgleich der Property-Werte zuständig ist. Diese unterscheidet ob es sich bei der Eigenschaft um eine Collection oder um eine einfache Eigenschaft handelt und führt dementsprechend die Aktualisierung aus:

        /// 
        /// Updates the properties from a datacontract.
        /// 
        /// The type of datacontract
        /// The type of the entity
        /// The datacontract to update the values.
        /// The entity that is persisted and owns the actual values.
        /// Updated datacontract.
        private static IPersistance UpdateProperties(T dataContract, U entity)
            where T : IPersistance
            where U : EntityObject
        {
            IPersistance persistance = (IPersistance)CreateInstance(dataContract, entity);
            entity.GetType().GetProperties().ToList().ForEach(entityPropertyInfo =>
            {
                string propertyName = entityPropertyInfo.Name;
                PropertyInfo dataContractPropertyInfo = persistance.GetType().GetProperty(propertyName);
 
                if (entityPropertyInfo != null && !entityPropertyInfo.PropertyType.Name.Contains(typeof(EntityCollection).Name))
                {
                    var entityPropertyValue = entityPropertyInfo.GetValue(entity, null);
                    if (entityPropertyValue != null && dataContractPropertyInfo != null && !dataContractPropertyInfo.PropertyType.IsEnum)
                    {                        
                        dataContractPropertyInfo.SetValue(persistance, entityPropertyValue, BindingFlags.Default, null, null, null);
                    }
                }
                else if (entityPropertyInfo != null && dataContract.GetType().GetProperty(entityPropertyInfo.Name) != null)
                {
                    var ienumerableValues = (IEnumerable)HandleRelatedEnds(dataContract, (IEnumerable)entityPropertyInfo.GetValue(entity, null));
                    persistance.GetType().GetProperty(entityPropertyInfo.Name).SetValue(persistance, ienumerableValues, BindingFlags.Default, null, null, null);
                }
            });
            return persistance;
        }

Der erste Teil aktualisiert alle flachen Eigenschaften des DatenContracts. Der zweite Teil kümmert sich um die Collections.

        /// 
        /// Handles the collections an creates for the datacontract
        /// appropriate items to add them to the list.
        /// 
        /// Type of datacontract
        /// The specific contract where the list belongs to.
        /// The entitycollection to map to the datacontract.
        /// A List of IPersistance objects (BusinessModel Objects).
        private static List HandleRelatedEnds(T dataContract, IEnumerable entityCollectionToDuplicate) where T : IPersistance
        {
            List persistances = new List();
            IEnumerator it = entityCollectionToDuplicate.GetEnumerator();
 
            while (it.MoveNext())
            {
                EntityObject entity = ((EntityObject)it.Current);
                IPersistance ipersistance = CreateInstance(dataContract, entity);
                ipersistance = UpdateProperties(dataContract, entity);
                persistances.Add(ipersistance);
            }
 
            return persistances;
        }

Damit die Items erstellt werden können braucht es eine weitere Hilfsmethode die uns entsprechende Instanzen zurück gibt.

        /// 
        /// This method creates a specific instance from the Businessmodell Assembly
        /// given by the entity type.
        /// 
        /// The IPersistanceObject to create
        /// The entity that contains the values
        /// The datacontract to add /remove or update
        /// The entity that was created /updated depending on the passed datacontract.
        /// 
        private static IPersistance CreateInstance(T dataContract, U entity) where T : IPersistance
        {
            IPersistance persistance;
            string typeOfEntity = entity.GetType().Name;
            Assembly assembly = Assembly.GetAssembly(typeof(IPersistance));
            Type type = assembly.GetTypes().FirstOrDefault(assemblyType => assemblyType.Name.ToLower().Equals(typeOfEntity.ToLower()));
            persistance = (IPersistance)assembly.CreateInstance(type.FullName);
 
            return persistance;
        }

[/csharp]
Der Funktionsumfang der oben beschriebenen Methode ist einfach. Nimm den Entity-Namen und suche in der BusinessModel Library nach dem entsprechenden Typ und instanziiere einen solchen und gib diesen dann zurück, damit er in der aufrufenden Methode in die Liste eingefügt werden kann.
Eine weitere Methode brauchen wir, damit wir einen DataContract, der über keinen Wert in der Id verfügt, persistieren können. (Das Repository ist nicht Teil dieses).

[sourcecode language="csharp"]
        /// 
        /// A newly passed datacontract with it's properties
        /// will be persisted in the entity framework.
        /// 
        /// DataContractType
        /// EntityType (must macht with the datacontract type)
        /// The datacontract to persist.
        private static void PersistDataContract(T dataContract) where T : IPersistance where U : EntityObject
        {
            U entityToPersist = Activator.CreateInstance();
            entityToPersist.GetType().GetProperties().ToList().ForEach(dataContractPropertyInfo =>
            {
                string propertyName = dataContractPropertyInfo.Name;
                PropertyInfo entityPropertyInfo = dataContract.GetType().GetProperty(propertyName);
 
                if (entityPropertyInfo != null && entityPropertyInfo.PropertyType != (typeof(RelatedEnd)))
                {
                    var entityPropertyValue = entityPropertyInfo.GetValue(dataContract, null);
                    if (entityPropertyValue != null)
                    {
                        dataContractPropertyInfo.SetValue(entityToPersist, entityPropertyValue, BindingFlags.Default, null, null, null);
                    }
                }
            });
 
            using (AddressRepository repository = new AddressRepository(new AddressManagementPersistanceModelContainer()))
            {
                repository.Add(entityToPersist);
                repository.SaveChanges();
            }
        }

Mit dieser letzten Methode haben wir den Mapper erstellt. Nun ist es uns möglich von einem Sender ein Objekt der Businessklassen zu erstellen und müssen uns keine Sorgen machen, ob dies bereits persistiert worden ist oder nicht. Wir erhalten als dann die aktualisierten oder neuen Werte von der Datenbank als Resultat zurück und können somit auf dem Client weiter arbeiten.

Fazit

Der Mapper hat nicht den Anspruch 100% aller Fälle abzudecken, er versucht zu zeigen wie man eine grösstmögliche Modularisierung anstreben kann, ohne dass auf dem Client Server DLL’s refernziert werden müssen. Und natürlich ein nicht zu unterschätzender Punkt ist der Aufwand einmal für die WCF Seite und einmal für die Persistance-Seite ein Modell zu führen.

Sollte Ihnen der Artikel gefallen haben, würde ich mich über einen kick freuen. Gerne beantworte ich auch Fragen und Kritik.

WCF Service über JQuery ansprechen leicht gemacht

schaedlerdaniel — Tue, 31 Jan 2012 13:13:13 +0000

Zur Zeit bin ich an einer Weiterbildung für die Verwendung von .NET im Grossfirmenumfeld. Ein Thema darin ist ist Windows Communication Foundation (kurz WCF genannt).

Da ich aus der Ecke der Webprogrammierer komme interessiert es mit primär, wie ich einen WCF-Service von einer Webseite her ansprechen kann.

Was brauchen wir denn für einen Service der auf der Basis der WCF für einen Webseitenzugriff konfiguriert ist?

Vorbereitungen

Erstellen eines neues ASP.NET Projektes über den Menüpunkt “Neues Projekt erstellen…”
Mit NuGet zuerst die JQueryUI und dann die JQuery
Libraries hinzufügen
Erstellen Sie einen Ordner Services in der Solution
In den zuvor erstellten Service fügen Sie ein neues Item hinzu (Vorlage für einen
WCF-Service) und benennen Sie diesen mit “ImageService”
Visual Studio erstellt uns eine .svc und ein entsprechendes Interface ImageService.cs.
Hier stehen noch nicht allzu viele Sachen drin sodass wir die DoWork Methode im
Interface ein wenig anpassen. Nach dem Hinzufügen des Service sollte die Solution
mit den aktuellen JQuery Referenzen ausgestattet sein und folgende .NET Dll’s als
Referenz aufweisen:
- System.Service.Model
- System.Runtime.Serializatin

WCF Konfiguration

Soweit so gut. Wir sind bereit den WCF Service zu implementieren. Hierzu wird in die Solution noch ein Verzeichnis Images hinzugefügt, dass einfach mit den Beispiel Bildern von Windows befüllt wird. Zuerst fangen wir mit der Konfiguration der Web.Config für unseren Dienst an.

Konfiguration der Web.Config mit dem „WCF Service Configurator“ (Finden Sie unter Tools bei Visual Studio 2010)

Erstellen eines neuen Services

Auswahl der DLL von welcher her der Service generiert werden soll. Sollte im bin
Verzeichnis keine DLL vorliegen so kann man dies mit dem „Erstellen der Solution“
beheben
Den Vertrag (Contract) können wir stehen lassen und weiter klicken.
Da wir einen ImageService für’s Internet bereitstellen wollen, lassen wir die Konfiguration
auf http sein.

Auch weitere Optionen belassen wir auf dem Standard. Wir wollen einen einfachen
ImageService ohne Duplex Funktion und lassen den Vorschlag des Assistenten so wie
er ist.

Zum Schluss erstellen wir die Endpunkt-Adresse über welche der Service erreicht
werden soll.

Wir haben einen neuen Service erstellt, wie uns der Assistent nun mitteilt.

Anpassen des WCF Service für unsere Bedürfnisse

Nun haben wir den Service deklarativ in der Web.Config erstellt. Nun müssen wir noch Anpassungen vornehmen, damit der Service auch mit einer WebHttpBinding angesprochen werden kann (das Programmiermodell http von WCF).

Anpassen des erstellten Service für die Verwendung mit ASP.NET (WCF Service Configurator).

Selektieren Sie den zuvor erstellten Endpunkt

Das Binding muss mit der DropDownListe auf webHttpBinding gewechselt werden.

Nun müssen wir dem Binding noch eine Konfiguration zuordnen. Dies können wir tun
indem wir den Punkt „Bindings“ auswählen und ein neues hinzufügen. ACHTUNG:
Man muss das WebHttpBinding auswählen, damit die erstellte Konfiguration darauf
wirkt.

Wir geben der neu erstellen Konfiguration einen Namen und belassen die Standardwerte
so wie sie sind (Die Ausnahmen werden nachstehend aufgelistet).

Konfigurationselement	Wert	Grund
ByPassProxyOnLocal	True	Lokale Adressen werden nicht über einenProxy-Server aufgelöst.
CrossDomainScriptAccessEnabled	True	Zugriff von überall her möglich per Script (Internet Service).

Nun wechseln wir wieder zu den Endpunkten und wählen unseren erstellten Endpunkt
aus. Danach können wir in der Bindungskonfiguration die neu erstellte Bindung auswählen.

Den WCF Service zum Leben erwecken

Wir erstellen uns eine Global.asax die für das Starten und Beenden der WebApplikationen die entsprechenden Methoden bereitstellt. Interessant sind die Methoden Application_Start und die Application_End.

Wir fügen unserem Webprojekt eine Global.asax mit dem Befehl Add new Item… hinzu.

Damit wir webHttp verwenden können müssten wir System.ServiceModel.Web referenzieren
damit wir ein Objekt vom Typ WebserviceHost erstellen können.

Die Global.asax sieht dann wie folgt aus:

 using System; using System.ServiceModel.Web; using
                Sample.WebHttpImageService.Services; namespace Sample.WebHttpImageService { public
                class Global : System.Web.HttpApplication { ///
                
        /// Host is declared here to not been removed by
        /// the carbage collector.
        /// 
                private static WebServiceHost host = new WebServiceHost(typeof(ImageService), new
                Uri("http://localhost:8099")); ///
                
        /// Occurs when application is staring up.
        /// 
                ///
                
                ///
                
                protected void Application_Start(object sender, EventArgs e) { try { host.Open();
                } catch (Exception exception) { host.Abort(); } } ///
                
        /// Occurs at application shutdown.
        /// 
                ///
                
                ///
                
                protected void Application_End(object sender, EventArgs e) { host.Close(); } } }

Startet man nun das Projekt kann unter Umständen die Fehlermedung kommen, dass man
eine nicht registrierte URL versucht aufzurufen. Abhilfe schafft hier das Visual
Studio als Administrator zu starten (generell mit WCF zu empfehlen).

Nun wollen wir prüfen ob der Service mit der Methode GetImages angesprochen werden
kann. Die machen wir indem wir http://localhost:8099/ImageService/GetImages in den
Browser eingeben. Wir eine Fehlermeldung, die besagt dass die Methode nicht ausgeführt
werden kann.

Ist ja eigentlich logisch, denn unsere momentane Service Methode erwartet einen
Parameter der über Web „GET“ übermittelt wird. Dies wurde noch nicht implementiert.

Ist das Attribut im Interface angegeben können wir zum Beispiel mit dem Auftruf
http://localhost:8099/ImageService/GetAllImages?path=Test einen Methodenaufruf machen
und erhalten das folgende Beispiel Resultat.

Anpassen der WCF Methode GetImages

Nun wollen wir doch, dass der Service über einen AJAX Aufruf per JQuery angesprochen werden kann. Hierzu gehen wir wie folgt vor. Da die Service-Methode noch nicht so tut wie wir das gerne wollen, dekorieren wir die Methode im Interface mit dem Attribute WebGet. Das Interface sieht nun wie folgt aus:

[ServiceContract]
public Interface IImageService{
[OperationContract]
[WebGet]
public List GetImages(string path);
}

Die Implementierungsklasse sieht dann so aus:

public class ImageService : IImageService{
public List GetImages(string path){
List result = new List(){ "Hello WCF"};
return result;
}
}

Clientseitige Implementierung

Nun kommen wir auf die Clientseite. Wir fügen, falls es nicht schon getan wurde, ein Default.aspx WebForms zur Solution hinzu.

Hierzu erstellen wir uns unter dem Verzeichnis (Scripts) ein Unterverzeichnis mit dem Namen „Custom“ und fügen uns dort eine ImageService.js Datei hinzu, die folgenden Inhalt aufweist. (Vergessen Sie nicht die JQuery Scriptreferenz im Header der Default.aspx hinzuzufügen).

Unser erstelltes Clientscript sieht dann so aus:

$(document).ready(function () {
    var imagesUri = "http://localhost:7777/Images/";

    jQuery.support.cors = true;

    $.ajax({

        type: "GET",
        url: "http://localhost:8099/ImageService/GetImages?path=" + imagesUri,
        dataType: "text",
        contentType: "application/text; charset=utf-8",
        success: function (message) {
            //$('#Result').append(message);
            var xmlDocument = jQuery.parseXML(message);
            var images = xmlDocument.getElementsByTagName("string");

            for (var index = 0; index <= images.length - 1; index++) {

                $('#Result').append("");

            }
        },
        error: function (message) {

        }
    });

});

Die Default.aspx braucht dann nur noch eine Script-Referenz auf diese Datei.


    Zugreifen auf WCF mittels JQuery

Der httpQuery muss mit dem Parameter der im Inteface für die Servicedefinition festgelegt worden ist übereinstimmen. Nun ist es nicht wirklich ansprechend ein Hallo reinzugeben und dann als Resultat Hallo WCF, mit den geschweiften Klammern zu erhalten.

Wichtig hierfür ist das JQuery für CrossDomain zugriff konfiguriert wird. Dies geschieht wie folgt:

	jQuery.support.cors = true;

Nun da WCF und ASP.NET nicht im gleichen Kontext beheimatet sind kann die Grundlage beider genommen werden. Beide bauen auf System.Web.Hosting auf. Folgenes Beispiel lässt alle Bilder die vom Pfad übergeben worden sind mit dem DirectoryInfo suchen und finden.

using System;
using System.Collections.Generic;
using System.IO;
using System.Web.Hosting;
using System.Linq;

namespace Sample.WebHttpImageService.Services
{
    /// 
    /// Get's the images from the path given by parameter.
    /// 
    /// ImagePath to look for images.
    public class ImageService : IImageService
    {
        public string[] GetImages(string path)
        {
            List result = new List();
            
            Uri uri = new Uri(path, UriKind.Absolute);
            
            FileInfo[] images = new DirectoryInfo(HostingEnvironment.MapPath(uri.LocalPath)).GetFiles();

            images.ToList().ForEach(image =>
                                        {
                                            string imageUrl = string.Format(@"{0}{1}", path, image.Name);
                                            result.Add(imageUrl);
                                        });

            return result.ToArray();
        }

Unser Image Service muss so dann nicht im ApsNetCompatibilityMode betrieben werden und wir können trotzdem auf Files auf dem WebServer zugreifen. Nähere Details können hier gefunden werden WCF Service and ASP.NET

Zu guter Letzt Verarbeiten wir Client-seitig das XML das wir vom Server zurück erhalten und zeigen die Bilder an.

Das Bilder anzeigen haben wir ja in die ImageService.js ausgelagert.

Fazit

Mit eigentlich ganz wenig Aufwand ist es möglich einen Service zur Verfügung zu stellen der von allen Interessierten konsumiert werden kann. Trickreich an den ganzen Recherchen war auf jeden Fall das Zusammenspiel zwischen ASP.NET und der WCF die ja nicht im gleichen Kontext laufen, ohne dass man das AspNetCompatibilityReruirement Attribut braucht, oder den WCF-Service im Kompatibilitätsmodus laufen lässt. Weiter werde ich versuchen in den nächsten Wochen ein wenig mehr um die Daten die ausgetauscht werden, zu beleuchten.

Wenn Ihnen dieser Artikel gefallen hat, würde ich mich über einen Kick freuen und bin auch empfänglich für Rückmeldungen und Kritik.

Entity Framework ein pragmatischer Ansatz

schaedlerdaniel — Fri, 23 Dec 2011 11:49:48 +0000

Was meine ich damit?

Ganze einfach, da ich recht pragmatisch bin und nicht gerne all zu viel schreibe, dachte ich mir es muss doch eine Möglichkeit geben, dass ich genau eine Methode habe, die mir aufgrund eines übergebenen Typ’s die Resultate der Datenbank zurückliefert.

Normalerweise hätte ich das mit einer Vererbung gelöst.

1.) Eine BaseEntität erstellen
2.) Alle anderen Entitäten erben von dieser Basis-Entität.

So ist es mir möglich mit folgendem Code die entsprechenden Tabellen anzusprechen.

using(MyContext context = new Context())
{
      context.BaseEntity.OfType().ToList();
}

Nun der Ansatz ist nicht schlecht, hat aber seine Tücken, nähmlich dann wenn man grosse Datenmengen verarbeiten muss, dann muss er zuerst alle Daten die dem übergebenen Typ in der BaseEntität entsprechen laden und nochmals die der vererbten Entität.

Was wäre die Lösung?

Keine Vererbung. Gibt natürlich ein wenig mehr zu tun, man hat aber bei einem nicht bekannten Mengengerüst den Vorteil, dass die Datenbank schneller wachsen kann, ohne dass man ein Refactoring am Code vornehmen müsste.

Das ganze einfache Model sieht man nachstehend.

Jetzt kommt aber der entscheidende Punkt, den man beim Desing der Eintitäten beachten soll. Das Entity FrameWork kann mit dem EntitySet Namen umgehen. Wenn wir den EntitSet Namen gleich wie die Entität erfassen, so kann man ohne Probleme mit

 myEntity.GetType().Name;

das EntitySet so angeben. Wenn man aber den generierten Namen lassen möchte, muss man bewusst sein, dass man sich dann den EntitySet-Name, bestehend aus dem Objekt-Typ Namen und einem Postfix vor einer Abfrage erstellen sollte.

Ich habe den ersten Weg gewählt und mir den EntitySet Namen gleichgesetzt wie der EntityName (im Grunde weiss ich ja dass die Tabelle Person heisst, die Menge aber Personen sind).

Wie sieht den nun der Ansatz aus?

Zu diesem Zweck habe ich mir einen ContextHelper erstellt. Interssant ist hier die Methode Get, die anhand eines ObjectQuery die Abfrage an den Kontext sendet.

Was brauchen wir dazu?

1.) Ein ObjectQuery mit entsprechenden ObjectParametern dass sich aus dem übergebenen Objekt und dessen Eigenschaften zusammensetzt.
2.) Ein string Query, welches die die Parameter aufnimmt und anhand des übergebenen Objekts erstellt wird.

Die Get Methode sind dann so aus:

        /// 
        /// Get method for deleting a row in the database.
        /// 
        /// Type of object to get.
        /// The search object which has to retrieve all matching entires in the database.
        public static IEnumerable Get(T entity) where T : EntityObject
        {
            IEnumerable result = null;
            using (BlogModelContainer container = new BlogModelContainer())
            {
                string queryCommand = string.Format("SELECT VALUE {1} FROM {0}.{1} WHERE 1=1", container.DefaultContainerName, entity.GetType().Name);

                // Creating the query, depending on how much of the properties in the given object are filled out
                // In this case only string properties will be read.
                queryCommand = CreateQueryString(entity, queryCommand);

                ObjectQuery entityQuery = new ObjectQuery(queryCommand, container);
                CreateParameters(entity).ForEach(entityQuery.Parameters.Add);

                result = entityQuery.ToList();
            }

            return result;
        }

Damit diese Methode bedient werden kann sind drei weitere notwendig.

1.) Eine die nur PropertyInfo’s zurückgibt welche auch einen Wert haben.
2.) Eine die den QueryString anhand der PropertyInfo’s abfüllt.
3.) Last but not least eine Methode die anhand der PropertyInfo’s die ObjectParameter erstellt.

Die PropertyInfo Methode sieht wie folgt aus:

        /// 
        /// Get's all properties from an object that where
        /// filled, or they have a value and returns it.
        /// 
        /// 
        /// The entity to look for the properties.
        /// List of propertyInfos (each propertyInfo has a value)
        private static List GetProperty(T entity) where T : EntityObject
        {
            List result = new List();

            entity.GetType().GetProperties().ToList().ForEach(property =>
            {
                if (property.PropertyType.Equals(typeof(string)))
                {
                    string propertyValue = property.GetValue(entity, new object[] { }) as string;

                    // Determining if the the property value of type string is filled out.
                    if (!string.IsNullOrWhiteSpace(propertyValue))
                    {
                        result.Add(property);
                    }
                }
            });

            return result;
        }

Da nur PropertyInfo’s zurückkommen die auch einen Wert aufweisen (momentan nur einen string-Typen, werde auch keine leeren Properties zurückgegeben.

Die Methode für den QueryString sieht dann so aus:

        /// 
        /// Creates the appropriate querystring depending
        /// on the object that was passed.
        /// 
        /// The specific objectType
        /// The entity to query against
        /// The
        /// 
        private static string CreateQueryString(T entity, string queryString) where T : EntityObject
        {
            List parameters = new List();
            GetProperty(entity).ForEach(p =>
            {
                string propertyValue = p.GetValue(entity, new object[] { }) as string;
                queryString += string.Format(" AND {0}.{1} = @{1}", entity.GetType().Name, p.Name);
            });

            return queryString;
        }

Für die ObjectParameter Erstellung wird eine ähnliche Methode verwendet:

        /// 
        /// Creates the queryparameters to pass to the objectquery
        /// depending on the filled out properties in the parameter
        /// object.
        /// 
        /// Specific objectType which must be at least of type EntityObject
        /// The entity with the filled properties for use in the query.
        /// The ObjectParameters Array to add it to the ObjectQuery.
        private static List CreateParameters(T entity) where T : EntityObject
        {
            List parameters = new List();
            GetProperty(entity).ForEach(p =>
            {
                string propertyValue = p.GetValue(entity, new object[] { }) as string;
                ObjectParameter parameter = new ObjectParameter(p.Name, propertyValue);
                parameters.Add(parameter);
            });

            return parameters;
        }

Somit werden die QueryParameter und der Query generisch anhand des “Suchobjektes”, das an die Get-Methode übergeben wird zusammengestellt.

Für Fragen, Kritik und Anregungen freue ich mich über einen Kommentar.

Ich wünsche allen frohe Festtage und einen guten Rutsch ins 2012, auf dass weider viele neue Sachen im .NET 4.5 endeckt werden können.

Das Beispielprojekt kann hier heruntergeladen werden.

Heirate mich (ASP.NET und JQuery Accordion)

schaedlerdaniel — Thu, 27 Oct 2011 08:18:29 +0000

Was ganz nützlich für die Darstellung von Daten ist, ist das Accordion, welches ja auch bereits im AjaxControlToolkit vorkommt.

Nun die meisten werden das Ganze sicherlich rein nativ client-seitig mit JQuery und der Herumschlagerei von Div-Elementen verwendet haben.

Meine Überlegung war es, in Abhängigkeit zu einer Quelle (IEnumerable) die Accordion-Items generieren zu lassen.

Wie bin ich vorgegangen?

Als erstes habe ich mir das Markup eines Demo-Accordions auf der Webseite von JQuery angesehen.

Da es im .NET die Klasse HtmlGeneric gibt kann man mit dieser mit ein wenig Geschick viel anstellen

Also wir brauchen folgendes:

Eine ASP.Seite mit einem Div-Element dass den Container für das Accordion darstellt
Als nächstes brauchen wir eine Klasse, die uns den Accordion Markup generiert
Und last but not least ein Model Element (Klassenelement aus unserem Modell

1. Erstellen der ASPX Seite

Der nachfolgende Markup-Code ist keine Magie und ziemlich schlank

<%@ Page Title="" Language="C#" MasterPageFile="~/Site.Master" AutoEventWireup="true" CodeBehind="Index.aspx.cs" Inherits="AspNetWebFromJQueryUI.Index" %>

Einzig das Referenzieren von JQuery und JQueryUI sollte beachtet werden. Hierzu findet man auf JQueryUI die entsprechende Anleitung im Get started Teil.

2. Den Helper für das Accordion

Nun kommen wir zum Helper für die Erstellung des Markups für das Accordion, der wie folgt aufgebaut ist:

using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Web.UI;
using System.Web.UI.HtmlControls;

namespace AspNetWebFromJQueryUI.Controls
{
    /// 
    /// Responsible for creating an accordion base
    /// for using it with JQueryUI
    /// 
    public static class AccordionHelper
    {
        /// 
        /// Returns the complete HTML code for the accordion.
        /// 
        /// The model type.
        /// The items to show in the accordion
        /// 
        /// The HTML Markup for an accordion in JQuery manner
        public static HtmlGenericControl CreateAccordion(IEnumerable datasource)
        {
            HtmlGenericControl accordion = new HtmlGenericControl {TagName = "div", ClientIDMode = ClientIDMode.Static, ID = "Accordion"};
            accordion.InnerHtml = CreateContentDiv(datasource);

            return accordion;
        }

        /// 
        /// Creates the content div's for putting the model
        /// content to it.
        /// 
        /// The model item (for example from the businessmodel)
        /// The items that are the datasource for the accordion
        /// The HTML string for the accordion
        private static string CreateContentDiv(IEnumerable datasource)
        {
            StringBuilder sb = new StringBuilder();

            if (datasource != null)
                for (int index = datasource.Count() - 1; index >= 0; index--)
                {
                    if (index == 0)
                    {
                        sb.AppendLine(string.Format("{0}", CreateTitleElement(datasource.ToList()[index])));
                        sb.AppendLine(string.Format("{0}", CreateContentItemFromModel(datasource.ToList()[index])));
                    }
                    else
                    {
                        sb.AppendLine(string.Format("{0}", CreateTitleElement(datasource.ToList()[index])));
                        sb.AppendLine(string.Format("{0}", CreateContentItemFromModel(datasource.ToList()[index])));
                    }
                }

            return sb.ToString();
        }

        /// 
        /// Foreach property in the model item it will be crated a desing
        /// like label: value of the property.
        /// 
        /// The model object
        /// The model item to treat
        /// The content for the contentItems in the accordion
        private static string CreateContentItemFromModel(T model)
        {
            StringBuilder sb = new StringBuilder();
            model.GetType().GetProperties().ToList().ForEach(property => sb.AppendLine(string.Format(@"{0}: {1} 
", property.Name, property.GetValue(model, null))));

            return sb.ToString();
        }

        /// 
        /// Takes the first property of an object an set's it 
        /// as title.
        /// 
        /// The model object
        /// The model item to treat
        /// The content for the title in the accordion
        private static string CreateTitleElement(T model)
        {
            StringBuilder sb = new StringBuilder();
            PropertyInfo info = model.GetType().GetProperties().FirstOrDefault();
            string title = string.Format(@"{0}: {1}", info.Name, info.GetValue(model, null));

            return title;
        }
    }
}

Was macht der Code?

Er erstellt das Grundgerüst in welchem die Items reingepflanzt werden.
Er erstellt einen Titel aus dem ersten Property des Modells und setzt diesen mit dem Wert des ersten gefundenen Properties von der Modellklasse
Ist alles erledigt, gibt er den gesamten erstellen Markup zurück

3. Die Modellklasse

Meistens findet ja so ein Accordion bei einem Newsreader Verwendung. Eine solches News-Items hat die folgenden Eigenschaften:

Titel
Inhalt
Veröffentlichungsdatum

Nachstehend die sehr einfache Modellklasse für ein News-Item.

using System;

namespace AspNetWebFromJQueryUI.Model
{
    public class NewsItem
    {
        public string Title { get; set; }

        public string Content { get; set; }

        public DateTime PublishDate { get; set; }

    }
}

Wirklich ganz trivial…

4. Einbindung in unsere Seite

Die Einbindung in die Seite geschieht dann wie folgt:

ResultatDiv der Seite mit einem runat=”server” versehen
Im Codebehind dem Control das generierte Accordion hinzufügen.

using System;
using System.Collections.Generic;
using System.Linq;
using AspNetWebFromJQueryUI.Controls;
using AspNetWebFromJQueryUI.Model;

namespace AspNetWebFromJQueryUI
{
    public partial class Index : System.Web.UI.Page
    {
        protected void Page_Init(object sender, EventArgs e)
        {
            //Create dummyData
            List datasource = new List();

            for (int index = 0; index < 10; index++)
            {
                datasource.Add(new NewsItem() { Content = string.Format(@"Neuigkeitsinhalt {0}", index.ToString()), 
                                                Title = string.Format(@"Neuigkeit {0}", index.ToString()), 
                                                PublishDate = DateTime.Now.Subtract(new TimeSpan(index, index, index)) });
            }
            
            this.ResultDiv.Controls.Add(AccordionHelper.CreateAccordion(datasource.OrderByDescending(n => n.PublishDate)));
            
        }
    }
}

Somit wird beim Starten, alles in einem schönen von JQuery verwalteten Accordion gerendet.

ACHTUNG: Reflection funktioniert nicht in Abhängigkeit zu den .NET Sicherheitseinstellungen, daher muss zuerst überprüft werden, ob mit Reflection gearbeitet werden kann.

Für Anregungen und Fragen würde ich mich auf einen Kommentar freuen

Vorlagen mal anders…

schaedlerdaniel — Sun, 23 Oct 2011 17:24:22 +0000

… und die Möglichkeit auch ohne JQuery Templates auszukommen. Wie soll man das verstehen? Nun ganz einfach, wenn wir eine XML basierte Daten getriebene Webanwendung haben, so ist es nicht immer notwendig mit JQuery Templates das Verschönern der Seite vorzunehmen. Hierzu kann XML /XSL(T) ein wahres Traumpaar sein. Anhand von drei Beispielen soll dann auch gezeigt werden wie es mit dem XMLControl von ASP.NET, rein Client seitig und rein Code-behind bewerkstelligt wird.

XML Data Control

Zuerst erstellen wir uns eine neue ASP.NET WebForms Anwendung und fügen in unsere Seite das XML Data Control ein.

<%@ Page Title="Home Page" Language="C#" MasterPageFile="~/Site.master" AutoEventWireup="true"
    CodeBehind="Default.aspx.cs" Inherits="XMLDataDrivenWeb._Default" %>




    
        XML Driven Web Development
    
    
        XML DataControl to apply XSL to the XML Document.

Damit wir das Control mit den notwendigen Daten füttern können, erstellen wir zwei Dateien im App_Code Ordner.

Die XML Datendatei




    
        Herr
        Hans
        Müller
        Müllerstrasse 14
        3205 Müllhausen
        0132542254
        0123655447
        Präsident
        Müller Hans
    
    
        Frau
        Heidi
        Müller
        Müllerstrasse 14
        3205 Müllhausen
        0766778939
        0324546688
        Vizepräsidentin
        Heidi Müller

Die dazugehörige XSL(T) Datei sieht dann wie folgt aus.



    
    
    
        
                
            
                Kontaktangaben
                Rolle
                Telefon(e)
                E-Mail
            
            
                    
                         
                        

                        
                        

                        
                    
                    
                        
                    
                    
                        
                            
                                
                                                                    
                                
                            
                        
                    
                    
                        
                            
                            mailto:

Kontaktangaben	Rolle	Telefon(e)	E-Mail
			mailto:

Wichtig ist dass der output mode auf HTML gestellt wird, ansonsten wird es mit dem Link in der E-Mail Adresse schwierig diesen korrekt darzustellen.

Der Ouput wird dann automatisch vom XML Control gerendert.

Reine clientseitige Verarbeitung

Eine weitere Möglichkeit, für alle die JavaScript über alles lieben, ist mit JQuery die Transformation vorzunehmen.

<%@ Page Title="" Language="C#" MasterPageFile="~/Site.Master" AutoEventWireup="true" CodeBehind="Index.aspx.cs" Inherits="XMLDataDrivenWeb.Index" %>

Code behind Bearbeitung

Zu guter letzt kann alles natürlich mit C# erledigt werden, was eigentlich auch keine Hexerei darstellt.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Xml.Linq;
using System.Xml;
using System.Xml.Xsl;
using System.IO;
using System.Text;

namespace XMLDataDrivenWeb
{
    public partial class PureDotNet : System.Web.UI.Page
    {
        protected void Page_Load(object sender, EventArgs e)
        {
            GetDocument();
        }

        private void GetDocument()
        {
            XmlDocument x = new XmlDocument();
            x.Load(XmlReader.Create(Server.MapPath(@"/App_Data/Kontaktangaben.xml")));

            XslCompiledTransform transform = new XslCompiledTransform();
            transform.Load(XmlReader.Create(Server.MapPath(@"/App_Data/KontaktFormatierung.xsl")));
            transform.Transform(x.BaseURI, Server.MapPath(@"/App_Data/Result.xml"));

            // Loading the generated result file
            string[] xmlResult = File.ReadAllLines(Directory.GetFiles(Server.MapPath(@"/App_Data")).ToList().Where(f => f.ToLower().Contains("result")).FirstOrDefault());
            
            xmlResult.ToList().ForEach(s =>
                                           {
                                               ResultDiv.InnerHtml += s;
                                           });
            
        }
    }
}

Zu guter letzt soll das Ganze auch ein wenig ansprechend aussehen. Dies machen wir wie gewohnt über CSS. Die folgenen Styles werden nachfolgend aufgeführt:

th 
{
    font-size: x-large;
    font-family: cursive;
    background-color: silver;  
    padding: 2px;    
}

td 
{
    font-size:medium;
    font-style: normal;
    border: thin solid black;
}

Wie wir sehen gibt es immer mehrere Wege nach Rom und das Ganze, ach Microsoft will C# etc. abschaffen und nur noch Richtung JavaScript gehen, eher übertrieben. Es kommt immer noch auf uns Entwickler an wie wir eine Lösung zu einem Problem finden.

Anhand dieses einfachen Beispiels sehen wird, dass es möglich ist für ein Problem die eine oder andere Lösung zu wählen, je nachdem was einem beliebt.

Für Anregungen und Kritik bin ich gerne offen

ASP.NET Optimization Bundling

schaedlerdaniel — Sun, 18 Sep 2011 10:08:26 +0000

Im ganzen HTML 5/ CSS3 etc. Gepredige habe ich doch noch was gefunden was im ASP.NET 4.5 kommen wird. Nun wenn man NuGet mal durchsucht, dann wird man es auch für ASP.NET 4.0 finden. Das Optimization Bundling (Im .NET 4.0 wird es mit Microsoft.Web.Optimization, und dann später mit System.Web.Optimization referenziert). Das Video ASP.NET 4.5 loves HTML5, CSS3 & JavaScript habe ich als sehr informativ empfunden, obwohl nicht wirklich viel neues kommt, oder die Änderunge nicht gerade revolutionär sind.

Damit ich das Pack auch produktiv nutzen kann, habe ich es mal analog dem Video nachgespielt, damit ich, falls ich in meinem gesetzten Alter, nicht mehr alles auswendig weiss, nachlesen kann. Also anfangen, ich von meiner Warte aus entwickle immer noch mit ASP.NET WebForms entgegen dem Hype zu MVC. Also starten wir wie folgt, indem wir eine neue WebForms Solution erstellen.

Kurzübersicht was wir alles machen werden

Erstellen einer ASP.NET 4.0 Solution
Installation des Optimization Bundling per NuGet
Analyse Vorher /Nachher
Fazit

Also fangen wir damit an:

Erstellen einer ASP.NET Solution

Wir starten unser Visual Studio 2010 (Express/Professional/Premium/Ultimae), wählen die Rubrik Web und dann die Vorlage für ASP.NET WebForms. Ein Klick darauf und unsere Solution ist erstellt.

Installieren des ASP.NET Optimization – Bundling

Ist eigentlich keine Hexerei und kann bequem über NuGet erfolgen, dass dann alle notwendigen Schritte übernimmt, und auch die Referenzen im Projekt richtig setzt.

Nach der Installation ist alles bereit, damit wir unsere ASP.NET Lösung optimieren können

Analyse Vorher /Nachher

In diesem kleinen Beispiel hole ich per XHTML-Request drei Personen aus meinem Model und zeige diese an (der XHTML Request kann in seiner Dauer variieren, da interessiert uns die Zeit primär erstmal nicht.) Starten wir die jungfräuliche Solution und drücken im IE9 die Developer Tools mit F12 sehen wir folgende Verkehr:

Interssant sind folgende zwei Punkte

/Styles/Site.css
/Scripts/jquery-1.4.4.min.js

Nun, da wir das Optimization Pack bereits mit NuGet installiert haben, entfällt eine Referenz darauf, denn diese ist bereits vorhanden. Was wir noch machen müssen ist in der Global.asax dafür sorgen, dass die Dateien auch wirklich gebündelt übertragen werden.

        void Application_Start(object sender, EventArgs e)
        {
            BundleTable.Bundles.EnableDefaultBundles();
            Bundle myBundle = new Bundle("~/Scripts", typeof(JsMinify));
            myBundle.AddFile("~/Scripts/jquery-1.4.4.min.js");
            myBundle.AddFile("~/Scripts/PersonScript.js");
        }

Anschliessend passen wir in der Site.Master die Referenz auf JQuery an:

Vorher:

Nachher:

Anschliessend starten wir unsere Solution wieder und analysieren mit den Developer Tools nocheinmal den Netzwerk-Verkehr. Und siehe da, die zwei vorherigen Kandidaten (Scripts und CSS) haben einen kleinen Hypersprung ausgefürht

Fazit

Wir haben einen Performance Anstieg erhalten, der unsere Webseite schneller übertragen lässt. In diesem sehr, sehr kleinen Beispiel und auch dem localhost mögen die Einsparungen vielleicht nicht enorm sein, betrachtet es man aber so, dass viele Wege zu einer Webseite führen können und nicht immer alles übertragen wird (Package los), dann ist dies sicher ein guter Weg die Daten zu komprimieren.

Bei sehr vielen JavaScript- und CSS-Dateien lohnt es sich auf alle Fälle. Die Demo Lösung kann hier heruntergeladen werden. (Das MVC Beispiel wird im Video erläuter, sodass ich dies nicht erstellt habe.)

Mein erstes Mal….

schaedlerdaniel — Sun, 21 Aug 2011 10:00:04 +0000

an der See # Party in Kreuzlingen war super und ich werde auf jeden fall, sollte sie auch nächstes Jahr statt finden wieder hingegen

Wieso denn? Ganz einfach man sieht dort wirklich alle die in der Community aktiv sind und mit denen man per Facebook, Twitter oder irgendeinem Social Tool in Kontakt steht und kann ein wenig fachsimpeln oder auch über Gott und die Welt reden. Schon fast familiäre Stimmung

Welche Session’s habe ich den besucht?

Da die Autofahr ziemlich reibungslos verlief, trudelten ich und mein Fahrer bereits um 07.45 Uhr in Kreuzlingen ein. Ein bisschen früh für den Einlass.

Um 08.25 Uhr blickten wir noch mal rein und konnten uns dann die Badges für SFr. 110.– (was ich für einen sehr günstigen Preis halte) abholen.

Begrüssungsfazit

War nicht so show geladen wie an den Techdays und dass macht die Veranstaltung auch so sympathisch! Weiter so Jungs!

Keynote

Die Keynote war mal ein ganz anderes Thema als, C#, Silverlight und dergleichen. Es ging um den Stress den man sich selber machen kann, oder der durch äussere Faktoren ausgelöst wird. Sehr interessant fand ich dann auch wie sich der Wandel in der IT-Branche vollzogen hat (bis auf ein paar Namensänderungen der Ziele und Verschiebung unter den Top 15 Themen gabs keine grossen Wandel).

Nun ja, da ich meine Mail’s erst am Morgen und dann wieder am Abend kontrolliere und mein Handy so oder so auf lautlos eingestellt ist, hält sich mein Stressfaktor zum Glück in Grenzen.

Danach mal den Plan hervorgenommen und die Session’s gemerkt. Lustigerweise hatte ich 4 mal die Gelegenheit im gleichen Raum die Vorlesungen zu geniessen, was wiederum der Suche für die Örtlichkeit der nächsten Session, erheblich vereinfacht.

Die Sessions

Beruflich habe ich eigentlich immer mit ASP.NET WebForms zu tun. Da auch ich im Wandel bin habe ich die Sessions die sich mit ASP.NET befassten aussen vor gelassen und richtetet meinen Fokus eher Silverlight, XAML, Workflow Foundation.

XAML Deep Dive – Mehr als nur WPF

Dieser Vortrag war sehr lehrreich. Ich fand es super, dass die Einsatzmöglichkeiten von XAML, auch ausserhalb von WPF /Silverlight /Workflow Foundation verwendet werden kann und es ein offener Standard ist. Mein Fazit zu dieser Session: Gut

Falls man die Folien nicht herunterladen kann, findet man auf XAML – Mehr als nur eine einfache Beschreibungssprache einen sehr guten Blogartikel.

Windows Communication Foundation 4.0 – Die Neuerungen

Die Session hat sich mit den Neuerungen der Windows Communication Foundation 4.0 befasst und deren Änderungen die eingeflossen sind. Die Codebeispiele, liefen zu 80%. Es war für mich in dieser Hinsicht schade dass nicht alles funktioniert hat, aber einen positiven Teil kann man dem Ganzen auch abgewinnen: So qualifiziert und auch hohes Fachwissen die Speaker auch habe, auch sie sind Menschen denen Fehler passieren können und das ist sicherlich auch ein guter Aspekt. Schön fand ich wie die einzelnen WCF Neuerungen vorgeführt worden sind. Der Router blieb mir besonders, wegen Performanceeinschränkunen wenn man nicht alles bachtet im Gedächtnis und ich denke dass man dann diesen auch eher seltener einsetzen wird.

Mein Fazit zu dieser Session: Gut (Ich wusste gar nicht das hochdeutsch eine gleiche Geschwindigkeit wie Französisch an den Tag legen kann )

Accessebility

Auf diese Session habe ich mich besonders gefreut, zumal man den Jürgen mal live sehen konnte. Die Aspekte unter welchen man eine barriere freie Webseite baut sind sehr gut dargestellt worden. Auch die anschliessende Diskussion und Fragerunde war sehr aufschluss- und lehrreich. Was habe ich für mich mitgenommen? Am besten Back to the roots, die Webseite in purem HTML erstellen und dynamische Inhalte soweit es geht per CSS zu erstellen. Eine weitere Erkenntnis von mir auch ist dass ASP.NET WebForms eher weniger dazu geeignet ist mit den Boardmitteln einen solche barriere freie Webseite zu erstellen, da muss man eben bei der Generierung der Controls auf der Seite Einfluss nehmen und so kann man in ASP.NET MVC das Ziel einer barriere freien optimaler erreichen.

Mein Fazit zu dieser Session: Gut (ein paar Einstiegslacher lockerten das ganze ein wenig auf (obwohl es wohl Insiderlacher von Jürgen und Karsten waren)).

User Interface Pattern mit Silverlight

Eigentlich hätte ich es mir sparen können diese Session zu besuchen…. Dachte ich zumindest in den ersten 5 Minuten. Aber weit gefehlt: Denn es ist immer wieder gut wenn man die Do’s und Dont’s der UI-Erstellung auf erfrischende Art präsentiert bekommt. Der Sprecher war sehr versiert und auch die Fokusierung von Inhalten durch das menschliche Auge hat, hat mir einen anderen Einblick gegeben.

Rein theoretisch hätte man aber nicht unbedingt Silverlight nehmen müssen.

Mein Fazit zu dieser Session: Gut

Workflow Foundation 4.0

Das Ziel war eine Getting Started Session zu machen die einen Einblick in die Workflow Fondatin 4.0 bieten soll. Dieser Einblick ist nur teilweise geglückt. Dies hat zum einen damit zu tun, dass Features die selbstverständlich sind, also das suchen von Namepsaces à la Expression Blend, nicht wirklich neu waren. Es hätte mir auch mehr gefallen, wenn man eventuell nicht dass klassische Hellow World Beispiel genommen hätte, sonder ein wenig einen kleinen Geschäftsfall erstellt hätte.

Mein Fazit zu dieser Session: Schlecht

Schlusswort

Ich finde es war ein gelungeren Anlass und es hätte auch paar mehr Entwickler kommen können. Meiner Meinung hat ausser berufliche Besuch an einer Koferenz nicht’s mit Geek zu tun sondern mit Interesse an der Arbeit die man macht. Ein Koch der leidenschaftlich kocht, der wird auch zuhause noch gerne kochen und sich auch ausserhalb der Arbeitszeit weiter bilden, weil es ihm Spass macht. Wenn man das nun so auf die Entwickler abmüntzen möchte, dann könnte man es überspitzt sagen, dass diese den Job gar nicht gerne machen (ich weiss es ist überspitzt, aber ich denke dass entspricht so dem Wahrheit).

Auch möchte ich erwähnen dass die geübte Kritik an den Sessions keinesfalls persönlich gemeint sind. Ich selber könnte nicht vor so vielen reden ohne Schweissperlen zu entwickeln, also jedem der vor so vielen Leuten redet, der ist schon, unabhängig von der Kritik, ein Gewinner.

Es würde mich sehr freuen, wenn auch nächstes Jahr wieder eine See # Party statt finden und vielleicht ein wenig mehr Entwickler den Weg dorthin finden würden.

Prism 4.0 Navigation

schaedlerdaniel — Tue, 12 Jul 2011 11:17:06 +0000

Momentan sitze ich gerade an der Navigation für Prism 4.0. Der Blogpost auf MSDN-Blogs war dafür sehr hilfreich. Mein Ziel war es wie so etwas darzustellen:
- Erste Seite
- Zweite Seite
- Dritte Seite

Diese sollten von sich aus auf die nächste navigieren können. Hierfür wurden die ViewModel erstellt die von der ViewModelBase erben. Wichtig hierbei ist, dass die ViewModelBase Klasse das Interface INavigateAsync implementiert (gemäss diesem Flow-Diagramm, das einzig zwingend notwendige für die Navigation unter Prism 4.0).

Damit die Views an der Navigation partizipieren können, dürfen sie nicht wie nachstehend in der InitializeModule-Methode registriert werden:

Falsch

regionManager.Regions["MainRegion"].Add(new MainView(), "MainView");

Richtig

regionManager.Regions["MainRegion"].RequestNavigate(new Uri("MainView", UriKind.Relative));

Der kleine, aber feine Unterschied liegt darin, dass mit RequestNavigate bereits das NavigationJournal “gefüttert” wird und man später darauf zugreifen kann. Der Nachteil an der Sache ist, dass die Views nicht in der Views-Collection der Region mit einem Schlüssel auffindbar sind.

Ein kleines Beispiel soll zeigen, wie man auf einfache Art und Weise eine Navigation mit den ViewModels in Prism erstellt.

Schlussendlich soll von Seite eins bis Seite 3 navigiert werden können, hierfür kann man wie folgt vorgehen:
1.) Erstellen eines WPF Projektes (Referenzen auf Prism und Prism Unity Extension mit NuGet durchführen)
2.) Erstellen eines WPF Projektes (In den Eigenschaften keine Windows Applikation auswählen, sondern anschliessend die Main.xaml und die App.xaml löschen, NuGetReferenzen wie vorhin hinzufügen).

Anschliessend kann mit dem WPF Projekt begonnen werden:
1.) Öffnen Sie die App.xaml und ändern sie diese so ab, dass sie wie unten aufgeführt aussieht (Ansonsten wird das MainWindow zwei mal gestartet).

2.) Erstellen Sie eine Klasse die von UnityBootstrapper erbt und implementieren diese wie folgt:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.Practices.Prism.UnityExtensions;
using System.Windows;
using Microsoft.Practices.Unity;
using Microsoft.Practices.ServiceLocation;
using Prism.NavigationTryOut.NavigationModule;

namespace Prism.NavigationTryOut
{
    public class BootStrapper : UnityBootstrapper
    {
        protected override void InitializeShell()
        {
            base.InitializeShell();
            App.Current.MainWindow = (Window)Shell;
            App.Current.MainWindow.Show();
        }

        protected override DependencyObject CreateShell()
        {
            return ServiceLocator.Current.GetInstance();
        }

        protected override void ConfigureModuleCatalog()
        {
            base.ConfigureModuleCatalog();       

            Microsoft.Practices.Prism.Modularity.ModuleCatalog catalog = (Microsoft.Practices.Prism.Modularity.ModuleCatalog)this.ModuleCatalog;

            // Nicht geeignet! Nehmen Sie stattdessen die Möglichkeit den catalog per XAML auszulesen.
            catalog.AddModule(typeof(NavigationModuleInitializer));
        }

        protected override void InitializeModules()
        {
            base.InitializeModules();
            
        }
    }
}

Anmerkung: Zum jetztigen Zeitpunkt kann noch nicht kompilliert werden.

3.) Öffnen Sie die App.xaml.cs Codebehind und ändern Sie diese wie folgt ab:

using System;
using System.Collections.Generic;
using System.Configuration;
using System.Data;
using System.Linq;
using System.Windows;

namespace Prism.NavigationTryOut
{
    /// 
    /// Interaction logic for App.xaml
    /// 
    public partial class App : Application
    {
        protected override void OnStartup(StartupEventArgs e)
        {
            base.OnStartup(e);
            BootStrapper bootstrapper = new BootStrapper();
            bootstrapper.Run();
        }
    }
}

Wir sind fast am Ziel und müssen noch zwei kleine Sachen erledigen. Die eine wäre
4.) Benennen Sie die Datei MainWindow.xaml um in Shell und machen Sie dies auch im Codebehind mit der von Visual Studio 2010 gebotenen Funktion “refactore” –> rename.

Jetzt haben wir das StartUp Projekt fertig konfiguriert und müssen uns an das zu implementierende Module zuwenden (ACHTUNG: in diesem Post wird eine Referenz, der Einfachheit halber auf das Module erstellt, was in der Praxis vermieden werden sollte).

5.) Erstellen Sie eine Klasse die das Initialisieren des Moduls und das Registrieren der Views übernimmt.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.Practices.Prism.Modularity;
using Microsoft.Practices.Unity;
using Microsoft.Practices.Prism.Regions;
using System.Windows.Input;
using Prism.NavigationTryOut.NavigationModule.Views;
using System.Windows.Controls;

namespace Prism.NavigationTryOut.NavigationModule
{
    public class NavigationModuleInitializer : IModule
    {
        private readonly IUnityContainer container;
        private readonly IRegionManager regionManager;      

        public NavigationModuleInitializer(IUnityContainer container, IRegionManager regionManager)
        {
            this.container = container;
            this.regionManager = regionManager;
        }

        public void Initialize()
        {
            this.container.RegisterType("MainView");
            this.container.RegisterType("ViewOne");
            this.container.RegisterType("ViewTwo");
            
            regionManager.Regions["MainRegion"].RequestNavigate(new Uri("MainView", UriKind.Relative));
        }
    }
}

6.) Anschliessen können wir auch gleich die ViewModelBase Klasse erstellen, die von jeder anderen ViewModel Klasse geertbt wird. Diese sieht dann so aus:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.Practices.Prism.Regions;
using Microsoft.Practices.ServiceLocation;
using System.Windows.Input;
using Microsoft.Practices.Unity;

namespace Prism.NavigationTryOut.NavigationModule
{
    public class ViewModelBase : INavigateAsync 
    {        
        private IRegionManager regionManager;
        private IUnityContainer container;
        protected IRegion mainRegion;

        /// 
        /// Das NavigationsJournal beeinhaltet alle relevanten Uri's
        /// die in der Navigation betroffen sind und waren.
        /// 
        public virtual IRegionNavigationJournal NavigationJournal
        {
            get;
            private set;
        }

        /// 
        /// Command für das Anzeigen der nächsten Seite.
        /// 
        public virtual ICommand NextCommand
        {
            get;
            private set;
        }

        /// 
        /// Command für das Schliessen der Applikation.
        /// 
        public virtual ICommand CloseCommand
        {
            get;
            private set;
        }

        /// 
        /// Command für das Navigieren zur vorherigen Seite.
        /// 
        public virtual ICommand PreviousCommand
        {
            get;
            private set;
        }        

        /// 
        /// Konstruktor lokalisiert mit dem ServiceLocator bereits instantiierte Klassen
        /// die mit dem UnityContainer bereits registriert worden sind.
        /// 
        public ViewModelBase()
        {
            regionManager = ServiceLocator.Current.GetInstance();
            IRegionNavigationService navigationService = regionManager.Regions["MainRegion"].NavigationService;           

            this.NavigationJournal = navigationService.Journal;
            mainRegion = regionManager.Regions["MainRegion"];
        }

        public void RequestNavigate(Uri target, Action NavigationCallback)
        {
            regionManager.RequestNavigate(mainRegion.Name, target, NavigationCallback);
        }

        /// 
        /// Notwendige Methode um auf .RequestNavigate reagiren zu können.
        /// 
        /// 
        public void NavigationCallback(NavigationResult res)
        {
            ClearUnusedViewsFromReagion(mainRegion, res.Context.Uri.OriginalString);
        }

        /// 
        /// Diese Methode übernimmt, das Entfernen von Views, die nicht mehr angezeigt
        /// werden sollen. Da die Views nicht mit .Add zur Region hinzugefügt wurden, 
        /// werden hier die Namen mit dem ViewModel verglichen.
        /// 
        /// 
        /// 
        protected void ClearUnusedViewsFromReagion(IRegion region, string viewName)
        {
            foreach (var view in region.Views.ToList())
            {
                if (!view.GetType().Name.Contains(viewName))
                {
                    region.Remove(view);
                }                
            }
        }
    }
}

7.) Erstellen der VieModels (vgl. SourceCode zum herunterladen). Exemplarische zeige ich hier nur das erste ViewModel (die anderen sind ähnlich aufgebaut)

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows.Input;
using Microsoft.Practices.Prism.Commands;

namespace Prism.NavigationTryOut.NavigationModule.ViewModel
{
    public class MainViewModel : ViewModelBase
    {
        private ICommand _nextCommand;
        public override ICommand NextCommand
        {
            get { return _nextCommand; }
        }

        private ICommand _closeCommand;
        public override ICommand CloseCommand
        {
            get { return _closeCommand; }
        }

        private ICommand _previousCommand;
        public override ICommand PreviousCommand
        {
            get { return _previousCommand; }
        }

        public MainViewModel()
        {
            _nextCommand = new DelegateCommand(new Action(OnNavigateNext));
            _closeCommand = new DelegateCommand(new Action(OnClose));
            _previousCommand = new DelegateCommand(new Action(OnPrevious));
        }

        private void OnNavigateNext()
        {
            base.RequestNavigate(new Uri("ViewOne", UriKind.Relative), base.NavigationCallback);
        }

        private void OnClose()
        {
            
        }

        private void OnPrevious()
        {
            base.NavigationJournal.GoBack();
        }
    }
}

Die entsprechende View (die anderen zeigen nur ein aderes Bild an) werden wie in Punkt 8.) erstellt:

Anmerkung: Das ViewModel kann nicht erstellt werden, da im Konstruktor der ServiceLocator von Unity für das Auflösen des IRegionManagers verwendet wird. Dieser wird erst zur Laufzeit erstellt und daher erhält man eine NULL-Reference-Exeption im GUI-Design.

So damit hätten wir eine kleine, aber noch mit Verbesserungspotenzial versehene Navigationslösung erstellt, deren Ansatz man sicher weiter verfolgen kann. In diesem Sinne danke ich für das Lesen des Blogpost’s und freue mich auf konstruktive Kritiken.

Die dazugehörige Solution kann hier heruntergeladen werden.

Dynamisch generiertes Bilder-Menu erweitern mit JQueryUI

schaedlerdaniel — Sun, 12 Jun 2011 16:55:09 +0000

Im letzten Blogbeitrag wurden die Bilder im Verzeichnisbaum in das Menu gerendert (also die Struktur). Damit man noch ein wenig mehr Pepp in das Ganze bringen kann, ist es möglich JQueryUI zu verwenden. Zu diesem Zweck habe ich mir den Modal Dialog ausgesucht, dass wenn der Benutzer ein Bild, das verkleinert dargestellt wird, in einem Dialog angezeigt bekommt.

Was ist denn da alles notwendig?

Eigentlich nicht ganz viel:
1.) Man lade eines der vielen Themen herunter, dass von JQueryUI schon zur Verfügung gestellt wird.
2.) Grundlage bildet der vorherige Blogpost “Dynamisch generiertes Bilder-Menu”. Die Source kann hier herunter geladen werden.
Wie kommen wir denn nun zu dem modalen Bild

Als erstes passen wird den Menu-Click Event an. Hier werden dann dynamisch anhand der Anzahl Bilder die IMAGE-ASP.NET Controls in das entsprechende DIV gerendert.

        /// 
        /// If menu is clicked the image will be rendered as image tag into the site
        /// 
        /// 
        /// 
        protected void GalleryMenu_ItemClick(object sender, MenuEventArgs e)
        {
            MenuItem menuItem = (MenuItem)e.Item;
            string path = string.Format(@"Images/{0}", menuItem.ValuePath);
            DirectoryInfo directoryInfo = new DirectoryInfo(Server.MapPath(path));
            FileInfo[] files = directoryInfo.GetFiles("*.jpg");

            foreach (var picture in files)
            {
                Image image = new Image();
                image.Height = 200;
                image.Width = 200;
                image.ClientIDMode = System.Web.UI.ClientIDMode.AutoID;
                image.ID = string.Format(@"Image_{0}", picture.Length);
                image.ImageUrl = string.Format("{0}/{1}", path, picture.Name);
                image.Attributes.Add("onclick", string.Format(@"ShowImageInOriginalSize('{0}')", image.ClientID));
                ImageResultDiv.Controls.Add(image);
            }
        }

Das Ganze kann dann noch mit ein wenig JavaScript (JQuery) gepfeffert werden und sie dann auch entsprechend schön aus (sofern man das entsprechende Thema anhand der JQueryUI Hilfe eingebunden hat).

ACHTUNG:Die Stolperfalle, wenn man das angeklickte Bild dem ModalpopUp-Extender übergeben hat, dann wird es zwar angezeigt, aber nicht mehr in die Source (dort wo es angeklickt worden ist) “zurück” gelegt. Aus diesem Grund ist es wichtig ein modales Bild zu haben dass die Höhe und die Breite als 0 aufweist und erst, wenn der Dialog angezeigt wird, in die entsprechende Grösse verändert wird.

Somit kann das “Fake”-Bildchen versteckt und spielt erst wieder eine Rolle, wenn es gebraucht wird. Für Anregungen und Kritik bin ich offen und hoffe auf Rückmeldungen.