A function has a string-parameter containing only digits. The function has to increment the value and return a string having the very same format.
For example: input is ’0100′ the returnvalue is ’0101′

Take this for granted:
- input is always numeric
- the incremented value will never have more chars then the input.

Requirements:
- increment the input-string by one
- padding must be dynamically, depending on the input-value (must also work for ’010′ and ’00100′)

And here is the result, starting with the fastest one:

• return (int.Parse(input) + 1).ToString().PadLeft(input.Length, ’0′);

• return (int.Parse(input) + 1).ToString(CultureInfo.InvariantCulture.NumberFormat).PadLeft(input.Length, ’0′);

• return (Convert.ToInt32(input)+1).ToString(“D” + input.Length);

And the slowest one:

• return (Convert.ToInt32(input) + 1).ToString(input.Aggregate(“”, (current, t) => current + “0″));

Summary:
- assigning values to variables is slow, so do it all within 1 line.
- using FormatProviders is slow.
- using linq is maximum slow.
- ‘Convert.ToInt32′ checks for NULL, then calls ‘int.Parse’, so better use int.Parse, if you don’t care for null.

• What are attributes?

In .NET attributes are used to combine code with declarations. e.g. is the class serializable, or is the property readonly.
Get more information here: codeproject

• My Scenario:

In the internet you can find a couple of blogposts, dealing with setting attributes at runtime . I needed this to build a read-only property Grid, without modifying all the objects, I want to display.

Most information of this article is based on: dotnetfacts

In a short summary: the read-only attributes are set on all public properties except collections.  This is to keep the CollectionEditor button alive, which is disabled when setting readonly= true on collections too.

• What I did:

You cannot create property-based attributes during runtime, but the readonly attribute exists for each property of your class by default. Even, if you do not add the Line “[ReadOnly(false)]“.
This is, why the following code-snippet works. It sets the readonly-attribute on each public property except collections.

• My Problem:

When assigning the class to the Property-Grid, all properties are displayed readonly. And next to collections you still have the button to investigate them.
But when opening the CollectionsEditor you might discover the following:

Although class “Connector” contains more properties than just a ToString-Method, it is treated like a string object.
For a tool like “Enar Spy” this is totally worthless, as you cannot investigate any collections.

• Solution:

By accident, I found an article mentioning my problem in a single sentence:
“Add the readonly-attribute to your class’ properties declaration (= in source code). Because if you don’t, .NET will mix it up and do some crazy stuff.”
(Shame on me, I do not remember, where I found that hint!)

That’s why I ended up adding the line “[ReadOnly(false)]” to each property of each class I use in Enar Spy.

And guess what?
The propertyGrid’s collection editor now works like a charm:

This issue definitely needs some more investigation.

Does anybody have more information about this topic?

I appreciate each comment to this topic!

New in this version:

• ElementDetails: all collections are loaded in-depth (except Element- or Package- Collections). Therefore you open an element and see it’s operations and their parameters.
  There’s also an option to display the database-record of the current element or package.

• Filtergram: find objects in the current diagram by any property (only non-collections are supported yet)

• eaLauncher: now supports addin-registrations in Local Machine hive introduced with EA 9.0.

For more details see the documentation.

If you already installed Version 1.0 (from here): there is no need to uninstall. Version 1.2.1 will replace previous versions automatically.

Requirements: .NET 3.5 & Enterprise Architect 8 or above.

Downloads are here:
Setup: v1.2.1
Documentation: Overview
Demo-Video: 1080i (taken from v1.0)

Your Feedback is welcome! Mail to us, or drop a comment in this topic’s details.

Here’s a short summary of what to do in a .NET project:

• register the ActiveX Control on the developer’s machine.
• add the control to a form
• visual studio will add a reference to it.
  in solution explorer navigate there, and set it’s properties to “isolated” and “copy local”.
• compile the project. VS will create a manifest to allow the usage of the activeX without registering it.
• copy the activeX control to your output folder
• Test it by compiling your app, unregister the control, and start your app.
  Lucky you, it will operate as desired.

Requirements: Windows XP and above, Visual Studio 2005 and above.

Note: Not every component is meant for Reg-Free COM, but in most cases it works.
And: it must be registered on the computer, the app is compiled on.

Get more information here (msdn magazin).

EnAr Spy integrates into Enterprise Architect as a custom Add-In. Once installed, the developer needs to rightclick the item he wants to investigate, to get a view containing all properties and collections.

Also included in the current version:
- execute SQL directly out of Enterprise Architect
- lookup information from repository object
- remove Version-Control from the project.

Best of all: EnAr Spy is free of charge; just download and install.

Requirements: .NET 2.0 & Enterprise Architect 8 or above.

Please note, that we will not take any responsibility on possible data loss or damage to any software or hardware.

Downloads are here:

Setup: EnArSpy 1.1.122
Dokumentation: PDF 
Demonstration: Video (1080i)

Die konkrete Implementierung einer beispielhaften Businesslogik ist das Thema dieses Artikels. Mit OCF lässt sich jede Art von Businesslogik umsetzen, jedoch wird die Umsetzung von Anwendungen für den Verwaltungssektor besonders unterstützt. Im letzten Artikel wurde schon kurz beschrieben, welche Entity Typen der Wizard anbietet. Businessobject, BaseDocument und Businesscase sind Typen, die in eGov-Fachanwendungen sehr häufig vorkommen. Businessobject ist das Basisobjekt eines jeden Geschäftsobjektes, enthält u.a. ein Property Identificationstring zur Darstellung der Aktenzahl bzw. Geschäftszahl. BaseDocument und Businesscase (Geschäftsfall) sind Ableitungen.

Im Beispiel werden 2 Entities erzeugt: File (Akt) und Document. File wird auf Basis des Entity Typs „Archive Object“ erzeugt, Document mit „Base Document“. Document erhält zusätzlich noch einen Foreign Key, der auf „File“ verweist.

Damit erhält man alle benötigten Klassen.

Im Design Modus des LinqToSql Mapping Files „Entities.dbml“ fügt man jetzt manuell eine Association zwischen „File“ und „Document“ ein. Damit wird „File“, also der „Akt“, zum Container für Dokumente. Ein typischer Use Case im Verwaltungsbereich.

Als nächstes folgen ein paar notwendige Anpassungen. Der DataContract „File“ muss um ein Property „Documents“ erweitert werden.

Die Klasse “FileTranslator”, die das Business Entity „File“ in den DataContract „File“ übersetzt, muss ebenfalls angepasst werden, damit etwa beim Abfragen eines Aktes die verlinkten Dokumente gleich mitgeliefert werden.

Damit sind die Vorbereitungen fertig und man kann die Service Methoden implementieren, beispielhaft die Methoden „CreateFile“, „CreateDocument“ und „GetFileByID“.

Dazu öffnet man das Interface „IBusinessService“ im Contracts-Projekt und ergänzt die Methoden.

Die Implementierung des ServiceContracts könnte so aussehen:

Damit ist die Implementierung der Businesslogik fertig. Nach dem Update der Service Referenz im Client-Projekt, kann man auf die Service Methoden zugreifen und ein kleines Testprogramm schreiben.

Damit hat man bereits das Grundgerüst einer „ELAK konformen Fachanwendung“. Eine interessante Erweiterung des Beispiels wäre die Anbindung an den Dms Service Ocf|Dms. Jedes Document Objekt wäre dann mit einem Content verlinkt.

Setup: Nach der Installation stehen das Solution Template “OCF Business Solution” und der Entity Generierungsassistent “OCF Entity Wizard” zur Verfügung.

Aufbau: Eine Business Solution wird nach einem vorgegebenen Pattern gebaut. Sie besteht nach der Generierung über das Template aus drei Projekten. Die Basis der Business Solution bildet ein WCF Service (Businessobjekt Service), der den wesentlichen Teil der Businesslogik enthält. Das Contracts-Projekt enthält die ServiceContracts und DataContracts. Das Client Projekt ist eine WPF Applikation mit einer Service Referenz auf den Businessobjekt Service.

Businesslogik: Für jede Entity werden eine Klasse im LinqToSql Objekt Modell (dbml file), eine DataContract Klasse, ein Repository (Entity factory) und ein Translator (übersetzt Entity in DataContract bzw. vice versa) benötigt. Diese Infrastruktur wird auf Wunsch generiert. Jedes generierte Repository ist von einem Basis Repository abgeleitet (Generic Repository, BusinessObject Repository, …). Das gleiche gilt für die anderen generierten Klassen. Etwa bei Wahl des Templates „Business Object“ wird das neue Repository vom BusinessObject Repository und der DataContract vom Basis DataContract „Business Object“ abgeleitet. Bei der Entity Klasse wird in diesem Fall das Interface IBusinessObject implementiert.

Für die Erzeugung dieser Infrastruktur gibt es den OCF Entity Wizard. Über den Menüeintrag „Create OCF Entity“ im Kontextmenü des Service Projekts startet man den Wizard. Sollen die Entity Klasse als auch die Tabelle in der Datenbank automatisch erzeugt werden, wählt man „Create new entity“. Im nächsten Schirm wählt man den Namen der neuen Entity, den Entity Typ (Objekttyp Template) und optional zusätzliche Felder aus. Es gibt zur Zeit fünf Entity Typen: Base Object, Archive Object, Business Object, Base Document und Business Case.

Mit Abschluss des Wizards werden die neuen Klassen erzeugt und man kann loslegen mit der Implementierung der eigenen Businesslogik.

Mehr dazu auf http://www.lieberlieber.com/Ocf.

Ein Medienbruch ist bei einem Arbeitsprozess immer eine Herausforderung. Aus rechtlichen oder technischen Gründen ist eine persönliche Unterschrift manchmal unumgänglich. Das unterschriebene Dokument soll jedoch ohne Aufwand wieder in den elektronischen Arbeitsprozess zurückgeführt werden können.

Ocf|Recognition löst diese Herausforderung mit QrCodes. Auf das gewünschte Dokument wird an einer definierten Position ein QrCode aufgebracht. Dieser QrCode stellt im wesentlichen eine eindeutige ID (Guid) dar. Das Dokument kann dann ausgedruckt und unterschrieben werden. Mit Ocf|Recognition lässt sich das unterschriebene Dokument wieder einscannen, wird über den QrCode wiedererkannt und kann dem entsprechend in den elektronischen Arbeitsprozess wieder zurückgeführt werden.

So I started investigating how I could make a very very simple NUnit runner to help me on that. During my research I found one helpful thread on Stackoverflow.com

What I did to solve my Issue:

First I converted my Test.dll to a Test.exe

Then I had to add 3 NUnit Refrences to this Project

Now with the hints from the Stackoverflow thread it was very easy to prepare a program.cs that would execute my tests.

The first line is pretty important as it set’s up the NUnit framework:

CoreExtensions.Host.InitializeService();

The rest is pretty straightforward – find the name – add to the Testpackage – and Execute:

SimpleTestRunner runner = new SimpleTestRunner();
TestPackage package = new TestPackage("Test");
string loc = Assembly.GetExecutingAssembly().Location;
package.Assemblies.Add(loc);
if (runner.Load(package))
{
          TestResult result = runner.Run(new NullListener());
}

I don’t care about the Results in my Scenario – as I collect the results from a second run with the console runner as described in my other post – for other scenarios it will be necessary to evaluate the results after the Tests are run.

Now running the Test.exe allows me to use Enterprise Architects Debugger just fine.

And I found a pretty interesting result:

It only takes into account “Classes” and not “Instances”.

There is two links that proved helpful – a video tutorial from Sparx Systems and a Blog post from Tom Peplow.

 

Setting up works in a similar way than it does for NUnit – refer to this Posts for hints.

I used my very Simple Account Class from the NUnit sample.

Then I prepared a little runner that would record a Sequence Chart using Enterprise Architects Debugger.

The result I’m getting from Enterprise Architect looks like this:

It doesn’t take into account that I have two instances of the same class – I would have rather expected it to look like:

What do you think? Is there value in a Sequence Diagram based on classes rather than on instances?

Yesterday Mario from Codeforce joined me to consult us on how to move Teamcity Agents into Amazon EC2. It took us two hours including lunch

After our session Mario made a nice blog post on the Topic:

How to run the Build Process in the Cloud with Teamcity and Amazon EC2 « All about Cloud Computing

Now we can build LieberLieber AMUSE even faster

All of this work has been done on Windows 7 x64 with Visual Studio 2010.  In order to have as little troubles as possible you have to go for the x86 version of the tools so everything works nicely. As EA is a x86 Application using the x64 Tools will not work.

In order run this you need at least NUnit 2.5.5 – where as I went with the latest Version NUnit 2.5.7

I prepared a simple demo solution in Visual Studio 2010 that consists of an Accounts an Accounts Test Project.

Using Resharper from Jetbrains I can run my unit tests nicely inside Visual Studio 2010

Next I generate a new Project inside Enterprise Architect. Inside the new Model I than “Add a Package” named  “AccountsClassModel”.

A right click on this new Package “AccountsClassModel” allows me to call the “Import Source Directory” function of Enterprise Architect.

As my Visual Studio Solution is in “C:\Source\Accounts” I specify this directory as the Root Directory. As my 2 Projects reside in separate folders below the root folder it is important to check the “Recursively Process Subdirectories” Option

It takes a little while for EA to import the sources and generate the required items inside our Package.

After the Import is done – we will see a similar structure in the Project Browser as we did before in Visual Studio.

To be able to build, configure and run stuff from inside EA we need to show the “Debugger” Window.

Inside the “Debugger” Window have to configure “Package Build Scripts” – those Scripts tell EA what to do when we “Build” or “Run” the solution.

When this is called for the first time we will see an empty list. By pressing “Add” we can move forward to con figure the scripts.

The first “Tab” that is interesting for us is the “Build” one. We use msbuild.exe to compile the Solution just like Visual Studio is doing it.

%windir%\Microsoft.NET\Framework\v4.0.30319\msbuild.exe Accounts.sln /Target:Rebuild

After hitting “Ok” we can run our script from the Debug Window using the context menu.

If everything is setup correctly we should see 0 Errors in the “Build” Tab of the “Output” Window.

We can easily go back to editing our Script with the “Edit Script” option from the context menu.

As I am running an x64 setup I have to make sure the .net .dll’s are compiled for x86 – therefore we need to enhance the command line from before a little bit.

%windir%\Microsoft.NET\Framework\v4.0.30319\msbuild.exe Accounts.sln /Target:Rebuild /Property:Config=Debug;Platform=x86

As we have prepared our Visual Studio Solution for x86 compilation we will receive an error when we try to compile the solution now.

So wee need to go back to Visual Studio’s “Configuration Manager” and add a new “Solution Platform”.

After this step the Dialog should look like this. Don’t forget to save the Solution in Visual Studio. – If you know recompile with the Build Script from EA the package should be built fine.

Now we can configure Nunit to run with Enterprise Architect – be careful in defining the x86 versions of the tools so it will work on x64 computers.

“C:\Program Files (x86)\NUnit 2.5.7\bin\net-2.0\nunit-console-x86.exe” AccountsTest\bin\x86\Debug\AccountsTest.dll

Don’t forget to select the correct “Output Parser” – which is “NUnit”

Next we need to show the “Testing” Window inside Enterprise Architect.

The “Testing” Window will look empty – so let’s go and run some tests!

5 Test Cases could be run and they have been added to the Model.

Visiting the “Unit” Tab of the Testing Window will now show the test results from our NUnit execution.

In July’s beta, Microsoft has moved this property from System.Environment to Microsoft.Devices.Environment namespace.

//enum DeviceType contains: Device, Emulator
this.IsEmulator = (Microsoft.Devices.Environment.DeviceType == DeviceType.Emulator);