{"id":199,"date":"2015-06-21T10:29:29","date_gmt":"2015-06-21T10:29:29","guid":{"rendered":"http:\/\/www.wellcode.de\/home\/?page_id=199"},"modified":"2021-11-05T01:23:22","modified_gmt":"2021-11-05T01:23:22","slug":"wellframe-wellcode-framework-de","status":"publish","type":"page","link":"https:\/\/wellcode.de\/home\/index.php\/de\/wellframe-wellcode-framework-de\/","title":{"rendered":"WellFrame (Wellcode Framework -de)"},"content":{"rendered":"\n

Wellframe ist ein Fullstack Software Developing Framework, das anhand von Datenbankdefinitionen (Tabllen, Spalten, Bez\u00fcge, Views) ein vollwertiges Framework gem\u00e4\u00df der MVC Richtlinie generiert. Die Generierung ist Templates gesteuert und kann in mehrere Zielsprachen (wie C#, Java) generiert werden. Hauptfocus ist jedoch C# und .Net.
Das Framework basiert auf den modernsten Technologien und erstellt automatisch eine Umgebung, die eine Daten- bzw. Business Schicht enth\u00e4lt, darauf basierend wird automatisch ein (u. A. WCF oder .Net Core) Webservice erstellt, dessen Eigenschaften bereits im Vorfeld mit Hilfe von Meta-Informationen gesteuert werden.
F\u00fcr die Pr\u00e4sentationsschicht stellt das Framework elementare Werkzeuge bzw. eine fertige Webentwicklungsumgebung in HTML5, CSS3 und Javascript (SPA) zur Verf\u00fcgung. Die Webentwicklungsumgebung enth\u00e4lt ebenfalls eine Umgebung mit Basisfunktionen zur Erstellung einer Android-App.
Die Android-App fungiert als H\u00fclle (\u00e4hnlich wie Phone-Gaps) f\u00fcr die Steuerung der Webanwendung und kann auf Funktionen des Android-Betriebssystems zugreifen.<\/p>\n\n\n\n

Hauptfocus im bereitgestellten Framework ist eine Entwicklungsumgebung aufzubauen, die elementare Funktionen zur modernen Softwareentwicklung bereitstellt, ohne von Zusatztools abh\u00e4ngig zu sein. So k\u00f6nnen eigene Anforderungen besser skaliert und alte Projekte besser portiert werden.<\/p>\n\n\n\n

Komponenten<\/h1>\n\n\n\n

Die wichtigste Funktion des Frameworks ist seine dynamische und transparente Funktionsweise, dies wird erst ersichtlich, wenn alle Komponenten des Framworks zusammen benutzt werden. Damit aber die Funktionsweise umf\u00e4nglich vorgestellt wird, werden hier die Komponenten einzeln mit Beispielen vorgestellt.<\/p>\n\n\n\n

Folgendes Flussdiagramm illustriert die Funktionsweise des Wellcode Frameworks:<\/p>\n\n\n\n

\"WellFrameFlowChart\"<\/a><\/figure>\n\n\n\n

Zuletzt wird dann ein Beispiel vorgestellt, das alle Komponenten zusamen in einer komplette Entwicklungsumgebung einsetzt.<\/p>\n\n\n\n

WellFrame.dll<\/h2>\n\n\n\n

Um mit dem WellFrame zu arbeiten, ben\u00f6tigt man die Bibliothek WellFrame.dll<\/em><\/strong>, darin sind alle n\u00f6tigen Funktionen enthalten, die das Arbeiten mit dem Framework erm\u00f6glichen.<\/p>\n\n\n\n

Ein Beispiel kann hier<\/a> heruntergeladen werden. Dieses Beispiel benutzt das Framework WellFrame, um die Person<\/em> aus der Microsoft Beispieldatenbank AdventureWorks<\/strong><\/em> abzubilden und einige Routinen darauf auszuf\u00fchren.<\/p>\n\n\n\n

Die AdventureWorks Datenbank k\u00f6nnen Sie bei Microsoft oder Codeplex hier<\/a> herunterladen oder die Person-Tabelle in einer Datenbank selbst mit folgendem Kommando anlegen<\/p>\n\n\n\n

CREATE TABLE [Person].[Person](\n\t[BusinessEntityID] [int] NOT NULL,\n\t[PersonType] [nchar](2) NOT NULL,\n\t[NameStyle] [dbo].[NameStyle] NOT NULL CONSTRAINT [DF_Person_NameStyle]  DEFAULT ((0)),\n\t[Title] [nvarchar](8) NULL,\n\t[FirstName] [dbo].[Name] NOT NULL,\n\t[MiddleName] [dbo].[Name] NULL,\n\t[LastName] [dbo].[Name] NOT NULL,\n\t[Suffix] [nvarchar](10) NULL,\n\t[EmailPromotion] [int] NOT NULL CONSTRAINT [DF_Person_EmailPromotion]  DEFAULT ((0)),\n\t[AdditionalContactInfo] [xml](CONTENT [Person].[AdditionalContactInfoSchemaCollection]) NULL,\n\t[Demographics] [xml](CONTENT [Person].[IndividualSurveySchemaCollection]) NULL,\n\t[rowguid] [uniqueidentifier] ROWGUIDCOL  NOT NULL CONSTRAINT [DF_Person_rowguid]  DEFAULT (newid()),\n\t[ModifiedDate] [datetime] NOT NULL CONSTRAINT [DF_Person_ModifiedDate]  DEFAULT (getdate()),\n    CONSTRAINT [PK_Person_BusinessEntityID] PRIMARY KEY CLUSTERED \n    (\n\t    [BusinessEntityID] ASC\n    )\n)<\/pre>\n\n\n\n
Folgende Schritte sind zu befolgen, um das WellFrame in Ihrer Applikation einzubinden:<\/p>\n\n\n\n
  1. \n
      \n
    1. Laden Sie die Libraries zu WellFrame aus diesem Link <\/a>herunter. Die DLLs sind f\u00fcr AnyCPU<\/em> kompiliert.<\/li>\n
    2. F\u00fcgen Sie Verweise in Ihrem Projekt auf WellFrame.dll<\/em>, Basics.dll<\/em> und DbmsLibrary.dll<\/em> hinzu.<\/li>\n
    3. Die abstrakte Klasse EntityManager<\/em> muss im Projekt abgeleitet werden, \u00fcber diese Klasse k\u00f6nne Entities gruppiert instanziert, ge\u00e4ndert oder gel\u00f6scht werden.<\/li>\n<\/ol>\n<\/li><\/ol>\n\n\n\n
      using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Threading.Tasks;\nusing Wellcode.Frame;\n\nnamespace AdventureWorks\n{\n    public partial class AdvEntityManager\n        : EntityManager\n    {\n        \/\/\/ <summary>\n        \/\/\/ this static instance provides functions for all new generated entities in the class library\n        \/\/\/ <\/summary>\n        public static new AdvEntityManager Manager\n        {\n            get\n            {\n                if (EntityManager._Manager == null)\n                    EntityManager._Manager = new AdvEntityManager();\n                return (AdvEntityManager)EntityManager._Manager;\n            }\n        }\n    }\n}<\/pre>\n\n\n\n
      Entity <\/strong><\/h2>\n\n\n\n
      Diese pr\u00e4sentiert sinngem\u00e4\u00df ein Objekt und dessen Eigenschaften. In unserem Beispiel w\u00e4re dies die Klasse Person<\/em>. Die Person enth\u00e4lt Properties, wie FirstName, LastName, etc.
      Hier ist zu notieren, dass WellFrame die Werte der Entity-Eigenschaften in eine Auflistung speichert. Die Feldnamen der urspr\u00fcnglichen Tabellen werden hierf\u00fcr verwendet. Dies erm\u00f6glich die Nutzung der Entity auch dann, wenn z. B. Datenbankfelder nicht in der Klasse abgebildet sind (Beispiel hierf\u00fcr: benutzerdefinierte Felder).
      Eine Definition sieht wie folgt aus:<\/p>\n\n\n\n
      \/\/\/ <summary>\n    \/\/\/ Person \/ Person - Entity \n    \/\/\/ <\/summary>\n    [DataContract]\n    public partial class Person\n        : WebEntity\n    {\n\t\t#region Members\n\n\t\t\n        \/\/\/ <summary>\n        \/\/\/ BusinessEntityId \/ Person.BusinessEntityID\n        \/\/\/ <\/summary>\n        \/\/\/ <returns>int?<\/returns>\n        [DataMember]\n        public virtual int? BusinessEntityId\n        {\n            get\n            {\n                return (int?)this[\"BusinessEntityID\"];\n            }\n            set\n            {\n                this.Add(\"BusinessEntityID\", value, typeof(int?));\n            }\n        }\n\n        \/\/\/ <summary>\n        \/\/\/ FirstName \/ Person.FirstName\n        \/\/\/ <\/summary>\n        \/\/\/ <returns>string<\/returns>\n        [DataMember]\n        public virtual string FirstName\n        {\n            get\n            {\n                return (string)this[\"FirstName\"];\n            }\n            set\n            {\n                this.Add(\"FirstName\", value, typeof(string));\n            }\n        }\n\n        \/\/\/ <summary>\n        \/\/\/ LastName \/ Person.LastName\n        \/\/\/ <\/summary>\n        \/\/\/ <returns>string<\/returns>\n        [DataMember]\n        public virtual string LastName\n        {\n            get\n            {\n                return (string)this[\"LastName\"];\n            }\n            set\n            {\n                this.Add(\"LastName\", value, typeof(string));\n            }\n        }\n\n        \/\/\/ etc.\n\n\t\t#endregion\n\t} \/\/ Person<\/pre>\n\n\n\n
      EntityList<\/strong><\/h2>\n\n\n\n
      Dies pr\u00e4sentiert eine Auflistung einer Entity<\/em>. Die Basisklasse f\u00fcr die Auflistung hei\u00dft WebEntityList<\/em> In unserem Beispiel w\u00fcrde die Klasse PersonList<\/em> hei\u00dfen und ist wie folgt definiert:<\/p>\n\n\n\n
      \/\/\/ <summary>\n    \/\/\/ Person \/ PersonList - List\n    \/\/\/ <\/summary>\n    [DataContract]\n    public partial class PersonList\n        : WebEntityList<Person>\n    {\n    }<\/pre>\n\n\n\n
      Factory<\/strong><\/h2>\n\n\n\n
      Zu jeder Entity muss eine Factory-Klasse definiert werden. Die Factory-Klasse enth\u00e4lt die Fachlogik und die Manipulation einer Entity.
      Die Basisklasse f\u00fcr die Factory hei\u00dft WebEntityFactory<\/em> und nimmt sinnesgem\u00e4\u00df zwei Template-Klassen an, die Entity und deren Auflistung.
      In unserem Beispiel w\u00e4re die Factory-Klasse f\u00fcr die Person PersonFactory<\/em>. In der Factory k\u00f6nnen diverse Funktion \u00fcberschrieben oder neu hinzugef\u00fcgt werden. Die Definition der Klasse PersonFactory<\/em> kann wie folgt aussehen. Die Definition lehnt sich ma\u00dfgeblich auf die Prim\u00e4rschl\u00fcssel in der Tabelle Person an<\/em>:<\/p>\n\n\n\n
          \/\/\/ <summary>\n    \/\/\/ Person - Person - Factory \n    \/\/\/ <\/summary>\n    public partial class PersonFactory\n        : WebEntityFactory<Person, PersonList>\n    {\n        \/\/\/ <summary>\n        \/\/\/ Factory Intialisierung. \n\t\t\/\/\/ Tabellenname = Person, \n\t\t\/\/\/ Felder       = \"BusinessEntityID\"\n\t\t\/\/\/ Query        = ...\n        \/\/\/ <\/summary>\n        private PersonFactory(EntityManager manager)\n        {\n\t\t\tthis.Manager = manager;\n\t\t\tthis.TableSchema = \"Person\";\n            this.TableName = \"Person\";\n            this.Fields = new string[]\n            {\n                \"BusinessEntityID\"\n            };\n\t\t\tthis.Query = null;\n            this.Database = DatabaseEnum.Standard;\n        }\n\n\n\t\tinternal static PersonFactory CreateFactory(EntityManager manager)\n\t\t{\n\t\t    return new PersonFactory(manager);\n\t\t}\n\n\t\t\/\/\/ <summary>\n        \/\/\/ Erstellt eine neue instanz zu Person\n        \/\/\/ <\/summary>\n        \/\/\/ <returns>Neue instanz zu Person, falls erfolgreich<\/returns>\n        public override Person CreateEntity()\n\t\t{\n\t\t\tvar item = new Person();\n\t\t\t\n\t\t\t\/\/ \u00c4nderungen an den EntityManager melden\n            item.PropertyChanging += this.Manager.WebEntity_PropertyChanging;\n            item.PropertyChanged += this.Manager.WebEntity_PropertyChanged;\n\t\t\titem.AquireEntityManager += this.Manager.AquireEntityManager;\n\n\t\t\treturn item;\n\t\t}\n\n\n\t\t\/\/\/ <summary>\n        \/\/\/ statische Methode f\u00fcr GetEntity \n        \/\/\/ <\/summary>\n        \/\/\/ <returns>Entity, falls vorhanden<\/returns>\n        public Person GetItem(int? businessEntityId)\n        {\n            return this.GetEntity(0, businessEntityId);\n        }\n\n        \/\/\/ <summary>\n        \/\/\/ statische Methode f\u00fcr GetEntity mit Angabe einer Db-Connection\n        \/\/\/ <\/summary>\n        \/\/\/ <returns>Entity, falls vorhanden<\/returns>\n        public Person GetItem(DbConnector conn, int? businessEntityId)\n        {\n            return this.GetEntity(conn, 0, businessEntityId);\n        }\n\n\n\t}<\/pre>\n\n\n\n
      EntityManager<\/strong><\/h2>\n\n\n\n
      in einer automatisierten Umgebung w\u00fcrde der EntityManager automatisch um diverse Funktion zur Manipulation einer Entity erg\u00e4nzt. In unserem Beispiel m\u00fcssen wir jedoch diese zun\u00e4chst manuell hinzuf\u00fcgen:<\/p>\n\n\n\n
      #region Eintr\u00e4ge f\u00fcr EntityManager\n\t\/*\n\t\/\/\/ <summary>\n    \/\/\/ AdvEntityManager Teil zu PersonFactory \/ Person \/ Person.\n    \/\/\/ <\/summary>\n\t*\/\n\tpublic partial class AdvEntityManager\n\t{\n\t\t\/\/\/ <summary>\n        \/\/\/ PersonFactory zu Person \/ Person.\n        \/\/\/ <\/summary>\n        public PersonFactory PersonFactory\n\t\t{\n\t\t\tget\n\t\t\t{\n\t\t\t\tif (_PersonFactory == null)\n\t\t\t\t{\n\t\t\t\t\t_PersonFactory = global::AdventureWorks.PersonFactory.CreateFactory(this);\n\n\t\t\t\t\t\/\/ register factory to the entity manager\n\t\t\t\t\tthis.Factories.Add(_PersonFactory, typeof(Person));\n\t\t\t\t}\n\t\t\t\treturn _PersonFactory;\n\t\t\t}\n\t\t}\n\t\tprivate PersonFactory _PersonFactory = null;\n\t\n        \/\/\/ <summary>\n        \/\/\/ GetPerson zu Person \/ Person\n\t\t\/\/\/ Holen einer Entity \u00fcber ihre Primary-Key-Felder\n        \/\/\/ <\/summary>\n        \/\/\/ <returns>Entity, falls vorhanden<\/returns>\n        public Person GetPerson(int? businessEntityId)\n        {\n            return this.PersonFactory.GetEntity(0, businessEntityId);\n        }\n\t\n        \/\/\/ <summary>\n        \/\/\/ GetPerson zu Person \/ Person\n\t\t\/\/\/ Holen einer Entity \u00fcber ihre Primary-Key-Felder mit Angabe einer Db\n        \/\/\/ <\/summary>\n        \/\/\/ <returns>Entity, falls vorhanden<\/returns>\n        public Person GetPerson(DbConnector conn, int? businessEntityId)\n        {\n            return this.PersonFactory.GetEntity(conn, businessEntityId);\n        }\n\t\n\t\t\/\/\/ <summary>\n        \/\/\/ GetPersonList zu Person \/ Person\n\t\t\/\/\/ Eine Liste von Person mit einer Where-Klausel zur\u00fcckgeben\n        \/\/\/ <\/summary>\n        \/\/\/ <returns>Liste m\u00f6glicher Entities<\/returns>\n        public PersonList GetPersonList(SqlWhereClause where)\n        {\n            return this.PersonFactory.GetEntities(where);\n        }\n\n\t\t\/\/\/ <summary>\n        \/\/\/ GetPersonList zu Person \/ Person\n\t\t\/\/\/ Gesamten Inhalt von Person zur\u00fcckgeben\n        \/\/\/ <\/summary>\n        \/\/\/ <returns>Liste m\u00f6glicher Entities<\/returns>\n        public PersonList GetPersonList()\n        {\n\t\t\tvar where = new SqlWhereClause();\n            return this.PersonFactory.GetEntities(where);\n        }\n\n        \/\/\/ <summary>\n        \/\/\/ SavePerson zu Person \/ Person\n\t\t\/\/\/ Speichern\/Hinzuf\u00fcgen einer Entity\n        \/\/\/ <\/summary>\n        \/\/\/ <returns>Entity, falls vorhanden<\/returns>\n        public Person SavePerson(Person item)\n        {\n            return this.PersonFactory.SaveEntity(item);\n        }\n\n        \/\/\/ <summary>\n        \/\/\/ SavePerson zu Person \/ Person\n\t\t\/\/\/ Speichern\/Hinzuf\u00fcgen einer Entity mit Angabe einer Db-Connection\n        \/\/\/ <\/summary>\n        \/\/\/ <returns>Entity, falls vorhanden<\/returns>\n        public Person SavePerson(DbConnector conn, Person item)\n        {\n            return this.PersonFactory.SaveEntity(conn, item);\n        }\n\n        \/\/\/ <summary>\n        \/\/\/ RemovePerson zu Person \/ Person\n\t\t\/\/\/ Delete an entity object\n        \/\/\/ <\/summary>\n        \/\/\/ <returns>true, if removed<\/returns>\n        public bool RemovePerson(Person item)\n        {\n            return this.PersonFactory.RemoveEntity(item);\n        }\n\t\t\n        \/\/\/ <summary>\n        \/\/\/ RemovePerson zu Person \/ Person\n\t\t\/\/\/ Delete an entity object\n        \/\/\/ <\/summary>\n        \/\/\/ <returns>true, if removed<\/returns>\n        public bool RemovePerson(DbConnector conn, Person item)\n        {\n            return this.PersonFactory.RemoveEntity(conn, item);\n        }\n\n        \/\/\/ <summary>\n        \/\/\/ Speichert eine Auflistung von PersonList. \n        \/\/\/ Als gel\u00f6scht markierte Entities werden endg\u00fcltig gel\u00f6scht\n        \/\/\/ <\/summary>\n        \/\/\/ <param name=\"items\"><\/param>\n        \/\/\/ <returns><\/returns>\n        public int SavePersonList(PersonList items)\n        {\n\t\t\treturn this.PersonFactory.SaveEntities(items);\n\t\t}\n\t}\n\n\t#endregion<\/pre>\n\n\n\n
      Zusammengefasst werden f\u00fcr die Klassen Entity<\/em>, EntityList<\/em>, EntityFactory<\/em>, EntityManager<\/em> zwei Dateien erstellt. Die Klassen selbst m\u00fcssen dann partiell<\/strong> definiert werden.
      Das hat den Hintergrund, dass bei voller Aussch\u00f6pfung des Frameworks die Dateien “*.Designer.cs<\/em>” automatisch erstellt werden. Daf\u00fcr ist ein ausf\u00fcrhliches Beispiel unter diesem Link<\/a> gepostet.In unserem Beispiel werden folgende Dateien erzeugt:<\/p>\n\n\n\n
      1. Die Datei Person.Designer.cs<\/em> enth\u00e4lt alle Properties der Person<\/em>, wie FirstName<\/em>, LastName<\/em>, etc.
        Weiterhin enth\u00e4lt die Datei partielle Definition f\u00fcr der EntityManager, wie z. B. das Erstellen einer Instanz.<\/li>
      2. Die zweite Datei Person.cs ist das sogenannte benutzerdefinierte Teil und kann die Fachlogik und einige \u00dcberschreibungen der Basisklassen enthalten.<\/li><\/ol>\n\n\n\n
        Nun f\u00fchrt man alles zusammen und m\u00f6chte z. B. alle Personen einlesen. Zun\u00e4chst wird ein ConnectionString zu der AdventureWorks-Datenbank zusammengestellt, wie<\/p>\n\n\n\n
        Data Source=.\\SQL2014;Initial Catalog=AdventureWorks2014;Integrated Security=True<\/pre>\n\n\n\n
        Dann k\u00f6nnen alle Personen mit folgendem Befehl ausgelesen werden<\/p>\n\n\n\n
        Wellcode.Basics.WelloConfig.Instanz.DbConnection.ConnectionString = \n\"Data Source=.\\SQL2014;Initial Catalog=AdventureWorks2014;Integrated Security=True\";\n\n\/\/ get all persons\nvar persons = AdvEntityManager.Manager.GetPersonList();\n\nforeach(var person in persons)\n{\n    Console.WriteLine(person.FirstName + \" \" + person.LastName);\n}\n\n\/\/ change a person name\npersons[0].FirstName = \"changed using WillFrame\";\n\n\/\/ save the changes\nAdvEntityManager.SavePerson(persons[0]);\n\n\/\/ another way to save changes\nAdvEntityManager.SaveAll();\n<\/pre>\n\n\n\n
        Das komplette Beispiel kann hier <\/a>heruntergeladen werden. Es ist mit Visual Studio 2013 und dem .Net Framework 4.5 erstellt.\"AdventureWorksPerson\"<\/a><\/p>\n","protected":false},"excerpt":{"rendered":"
        Wellframe ist ein Fullstack Software Developing Framework, das anhand von Datenbankdefinitionen (Tabllen, Spalten, Bez\u00fcge, Views) ein vollwertiges Framework gem\u00e4\u00df der MVC Richtlinie generiert. Die Generierung ist Templates gesteuert und kann in mehrere Zielsprachen (wie C#, Java) generiert werden. Hauptfocus ist jedoch C# und .Net.Das Framework basiert auf den modernsten Technologien und erstellt automatisch eine Umgebung, … Continue reading WellFrame (Wellcode Framework -de)<\/span><\/a><\/p>\n","protected":false},"author":1,"featured_media":110,"parent":0,"menu_order":0,"comment_status":"open","ping_status":"open","template":"","meta":{"_monsterinsights_skip_tracking":false,"_monsterinsights_sitenote_active":false,"_monsterinsights_sitenote_note":"","_monsterinsights_sitenote_category":0,"footnotes":""},"class_list":["post-199","page","type-page","status-publish","has-post-thumbnail","hentry"],"_links":{"self":[{"href":"https:\/\/wellcode.de\/home\/index.php\/wp-json\/wp\/v2\/pages\/199","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/wellcode.de\/home\/index.php\/wp-json\/wp\/v2\/pages"}],"about":[{"href":"https:\/\/wellcode.de\/home\/index.php\/wp-json\/wp\/v2\/types\/page"}],"author":[{"embeddable":true,"href":"https:\/\/wellcode.de\/home\/index.php\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/wellcode.de\/home\/index.php\/wp-json\/wp\/v2\/comments?post=199"}],"version-history":[{"count":12,"href":"https:\/\/wellcode.de\/home\/index.php\/wp-json\/wp\/v2\/pages\/199\/revisions"}],"predecessor-version":[{"id":1683,"href":"https:\/\/wellcode.de\/home\/index.php\/wp-json\/wp\/v2\/pages\/199\/revisions\/1683"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/wellcode.de\/home\/index.php\/wp-json\/wp\/v2\/media\/110"}],"wp:attachment":[{"href":"https:\/\/wellcode.de\/home\/index.php\/wp-json\/wp\/v2\/media?parent=199"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}