Code-Inside Blog: .NET CultureInfo in Windows 10

Did you know that the CultureInfo behavior with “unkown” cultures has changed with Windows 10?

I stumbled two times about this “problem” - so this is enough to write a short blogpost about it.

Demo Code

Lets use this democode:

    try
    {


        // ok on Win10, but not on pre Win10 if culture is not registred
        CultureInfo culture1 = new CultureInfo("foo");
        CultureInfo culture2 = new CultureInfo("xyz");
        CultureInfo culture3 = new CultureInfo("en-xy");

        // not ok even on Win 10 - exception
        CultureInfo culture4 = new CultureInfo("foox");

    }
    catch (Exception exc)
    {

    }

Windows 10 Case

If you run this code under Windows 10 it should fail for the “foox” culture, because it doesn’t seem to be a valid culture anyway.

“culture1”, “culture2”, “culture3” are all valid cultures in the Windows 10 world, but are resolved with Unkown Locale and LCID 4096.

I guess Windows will look for a 2 or 3 letter ISO style language, and “foox” doesn’t match this pattern.

Pre Windows 10 - e.g. running on Win Server 2012R2

If you would run the code unter Windows Server 2012 R2 it would fail on the first culture, because there is no “foo” culture registred.

“Problem”

The main “problem” is that this behavior could lead to some production issues if you develop with Windows 10 and the software is running on a Win 2012 server.

If you are managing “language” content in your application, be aware of this “limitation” on older Windows versions.

I discovered this problem while debugging our backend admin application. With this ASP.NET frontend it is possible to add or manage “localized” content and the dropdown for the possible language listed a whole bunch of very special, but “Unkown locale” cultures. So we needed to filter out all LCID 4096 cultures to ensure it would run under all Windows versions.

MSDN

This behavior is also documented on MSDN

The “Unkown culture” LCID 4096 was introduced with Windows Vista, but only with Windows 10 it will be “easy” usable within the .NET Framework.

Stefan Henneken: IEC 61131-3: Methods, Properties and Inheritance

Object-oriented programming (OOP) is a proven way of keeping the complexity of software systems in check. Until recently the preserve of languages such as C++, Java and C#, IEC 61131-3 introduces the concept to PLC programming.

Methods

Previously, a function block consisted of internal, input and output variables. There was only one opportunity to modify internal variables from outside the function block. Instances of the function block were called with the relevant input variables. Different sections within the function block would be executed depending on the value of these input variables, which in turn affected the value of internal variables. For example:

Start engine:

fbEngine(bStart := true, bStop := false, nGear := 1, fVelocity := 7.5);

Stop engine:

fbEngine(bStart := false, bStop := true);

Code within the function block listens for the values of bStart and bStop to switch from FALSE to TRUE. The function block user needs to know that bStart needs to be set to FALSE when stopping the engine. Failure to do so would mean that there would be no switch from FALSE to TRUE on attempting to restart the engine. The user also needs to know that they need to specify a value for the nGear parameter when starting the engine (but not when stopping it).

The OOP extensions introduce a clearer separation between internal variables and the ability to modify them. It is now possible to define additional sub-functions (methods) within a function block, which are available to be called by the user.

Picture01

Methods are comparable to actions, except that parameters can be passed to a method when it is called. Just like functions, methods can also contain local variables. Using methods, the above example can be realised thus:

Start engine:

fbEngine.Start(nGear := 1, fVelocity := 7.5);

Stop engine:

fbEngine.M_Stop();

The Start() and Stop() methods can access internal function block variables, but can also contain variables which can neither be modified from the outside nor be modified by other methods within the function block. This ensures that they cannot be inadvertently overwritten.

Methods can also include a return value, which is returned to the calling entity. If required, it is also possible to declare additional output variables between VAR_OUTPUT and END_VAR. Since TwinCAT 3, functions have also had this capability. Again since TwinCAT 3, it has also been possible to declare functions and methods with no return value.

Only FUNCTION_BLOCK and PROGRAM POUs can contain methods – this option is not available to FUNCTION POUs.

When calling a method, all parameters must be specified. Parameter names can be omitted if required:

fbEngine.Start(1, 7.5);

Where parameter names are used, parameters can be given in any order:

fbEngine.Start(fVelocity := 7.5, nGear := 1);

In the graphical languages, methods are depicted using a separate box:

Picture02

Some programming languages offer the ability to define multiple methods with the same name. Which method is executed is determined by the parameters specified when the method is called (signature). This is known as overloading. Currently, methods in IEC 61131-3 cannot be overloaded. It is not possible to differentiate between methods using signatures. Method names must be unique.

Access specifiers

The method declaration may include an optional access specifier. This restricts access to the method.

PUBLIC The method can be called by anyone – there are no restrictions.
PRIVATE The method is available from within the POU only. It cannot be called from outside the POU.
PROTECTED Only its own POU or POUs derived from it can access the method. Derivation is discussed below.
INTERNAL The method is accessible from within the same namespace only. This allows methods to be available from within a certain library only, for example.
FINAL The method cannot be overwritten by another method. Overwriting of methods is described below.

The default setting where no access specifier is defined is PUBLIC.

A method declaration therefore has the following structure:

METHOD   : 

Properties

Previously, the only way of passing parameters was to call a function block with input variables. State information was returned to the calling entity via output variables. Properties offer a defined way of passing general parameters and state information outside of the function block call.

Properties are distinguished by the fact that access is via a pair of special methods. There is one method for writing and one for reading the property. These methods are designated setters (write) and getters (read). Together they are referred to as accessors. These accessor methods can also perform function such as range checking or unit conversion.

Setters and getters can contain local variables, but no additional inputs or outputs. On exiting the setter or getter method, the values of these local variables are, however, lost. In this respect they behave like functions. The setter therefore needs to provide an appropriate mechanism to ensure that the value of the property is preserved. This can, for example, be achieved by declaring a local variable in the function block.

FUNCTION_BLOCK PUBLIC FB_Engine
VAR
  myPropertyInternalValue : LREAL := 50;
END_VAR

The setter method assigns the value of the MyProperty property to the local variable.

myPropertyInternalValue := MyProperty;

The getter does the opposite and reassigns the value of the local variable to the property.

MyProperty := myPropertyInternalValue;

The local variable myPropertyInternalValue can be used within the function block for internal calculations. Access to this variable is exclusively via the MyProperty property.

Let us add three further properties to the above example, one to specify the maximum permissible velocity (MaxVelocity) and two more to output the current temperature (Temperature) and velocity (Velocity).

In the graphical languages, properties are not shown on the relevant box. To access a property, we use the name of the instance and of the property separated by a dot.

fbEngine(); 
bError := fbEngine.Temperature > 130;

Picture03

There does not have to be both a getter and a setter. In the absence of a setter, for example, the property will be read-only. In TwinCAT 3, the function block definition, including methods and properties, looks like this:

Picture04 

Access specifiers

As with methods, properties can also take the following access specifiers: PUBLIC, PRIVATE, PROTECTED, INTERNAL and FINAL. Where no access specifier is defined, the property is PUBLIC. In addition, an access specifier can also be specified for each setter and getter. This takes priority over the property’s own access specifier.

A property declaration therefore has the following structure:

PROPERTY   : 

Inheritance

Function blocks are an excellent means of keeping program sections separate from each other. This improves software structure and significantly simplifies reuse. Previously, extending the functionality of an existing function block was always a delicate undertaking. This meant either modifying the code or programming a new function block around the existing block (i.e. the existing function block was effectively embedded within a new function block.) In the latter case, it was necessary to create all input variables anew and assign them to the input variables for the existing function block. The same was required, in the opposite direction, for output variables.

TwinCAT 3 introduces the concept of inheritance. Inheritance is one of the fundamental principles of object-oriented programming. Inheritance involves deriving a new function block from an existing function block. The new block can then be extended. To the extent permitted by the parent function block’s access specifiers, the new function block inherits all properties and methods from the parent function block. Each function block can have any number of child function blocks, but only one parent function block. Derivation of a function block occurs in the new function block declaration. The name of the new function block is followed by the keyword EXTENDS followed by the name of the parent function block. For example:

FUNCTION_BLOCK PUBLIC FB_NewEngine EXTENDS FB_Engine

The new, derived function block (FB_NewEngine) possesses all of the properties and methods of its parent (FB_Engine). Methods and properties are, however, only inherited where the access specifier permits.

The child function block also inherits all local variables, VAR_INPUT, VAR_OUTPUT, and VAR_IN_OUT from the parent function block. This behaviour cannot be modified using access specifiers.

If methods or properties in the parent function block have been declared as PROTECTED, the child function block (FB_NewEngine) is able to access them, but they cannot be accessed from outside FB_NewEngine.

Inheritance applies only to POUs of type FUNCTION_BLOCK.

Access specifiers

FUNCTION_BLOCK, FUNCTION or PROGRAM declarations can include an access specifier. This restricts access and, where applicable, the ability to inherit.

PUBLIC Anyone can call or create an instance of the POU. In addition, if the POU is a FUNCTION_BLOCK, it can be used for inheritance. No restrictions apply.
INTERNAL The POU can only be used within its own namespace. This allows POUs to be available from within a certain library only, for example.
FINAL The FUNCTION_BLOCK cannot serve as a parent function block. Methods and properties in this POU cannot be inherited. FINAL is only permissible for POUs of type FUNCTION_BLOCK.

The default setting where no access specifier is defined is PUBLIC. The access specifiers PRIVATE and PROTECTED are not permitted in POU declarations.

If you plan to utilise inheritance, the function block declaration will therefore have the following structure:

FUNCTION_BLOCK   : EXTENDS 

Overwriting methods

The new FUNCTION_BLOCK FB_NewEngine, which is derived from FB_Engine, can contain additional properties and methods. For example, we can add the property Gear. This property can be used to query and change the current gear. Getters and setters for this property need to be set up.

However, we also need to ensure that the nGear parameter from the Start() method is passed to this property. Because the parent function block FB_Engine does not have access to this new property, a new method with exactly the same parameters needs to be created in FB_NewEngine. We copy the existing code to the new method and add new code so that the nGear parameter is passed to the property Gear.

METHOD PUBLIC Start
VAR_INPUT
  nGear : INT := 2;
  fVelocity : LREAL := 8.0;
END_VAR 
 
IF (fVelocity < MaxVelocity) THEN
  velocityInternal := fVelocity;
ELSE
  velocityInternal := MaxVelocity;
END_IF
Gear := nGear; // new

Line 12 copies the nGear parameter to the Gear property.

Where a method or property which is already present in the parent function block is redefined within the child function block, this is referred to as overwriting. The function block FB_NewEngine overwrites the Start() method.

FB_NewEngine therefore has the new property Gear and overwrites the Start() method.

Picture05

fbNewEngine.Start(1, 7.5);

calls the Start() method in FB_NewEngine, since this method has been redefined (overwritten) in FB_NewEngine.

Whilst

fbNewEngine.Stop();

calls the Stop() method from FB_Engine. The Stop() method has been inherited by FB_NewEngine from FB_Engine.

Polymorphism

In addition to inheritance, another fundamental property of object-oriented programming is polymorphism (Greek for ‘having many forms’). This means that a variable can take different data types depending on how it is used. Previously, variables were always assigned a type. Polymorphism always occurs in the context of inheritance and interfaces.

We will illustrate polymorphism using the above example with inheritance. We create one instance each of FB_Engine and FB_NewEngine. A reference is assigned to these instances depending on a variable (bInput).

PROGRAM MAIN
VAR
  fbEngine     : FB_Engine;
  fbNewEngine  : FB_NewEngine;
  bInput       : BOOL;
  refEngine    : REFERENCE TO FB_Engine;
END_VAR
 
IF (bInput) THEN
  refEngine REF= fbEngine;
ELSE
  refEngine REF= fbNewEngine;
END_IF
refEngine.Start(2, 7.5);

A variable of type REFERENCE TO FB_Engine can take an instance of type FB_Engine (line 10), but can also take all function blocks which are derived from FB_Engine – including therefore FB_NewEngine (line 12).

Line 14 then calls the Start() method. It is not possible to determine from this line alone whether the Start() method from FB_Engine or from FB_NewEngine will be executed.

This ambiguity is frequently used in object-oriented programming to make programs more flexible and expandable. To this end, the parameters for a function may be defined as references to a function block. All FBs which are derived from this function block can then be passed to this function.

Interfaces are also important in this context and this is explored in my post IEC 61131-3: Object composition using interfaces.

SUPER pointer

In the above example, we created a new Start() method in FB_NewEngine and copied the existing code from FB_Engine into the new method. This is not always possible, and it also runs counter to the principle of reuse.

Consequently, every function block which is derived from another function block has access to a pointer called SUPER. This can be used to access elements (methods, properties, local variables, etc.) from the parent function block.

METHOD PUBLIC Start
VAR_INPUT
  nGear      : INT := 2;
  fVelocity  : LREAL := 8.0;
END_VAR 
 
SUPER^.Start(nGear, fVelocity); // calls Start() of FB_Engine
Gear := nGear;

Instead of copying code from the parent function block to the new method, the SUPER pointer can be used to call the method from the FB_Engine function block. This does away with the need to copy the code.

In the CFC editor, SUPER is called as follows:

Picture06

The SUPER pointer always has to be written in upper case.

THIS pointer

The THIS pointer is available to all function blocks and points to the current function block instance. This pointer is required whenever a method contains a local variable which obscures a variable in the function block.

An assignment statement within the method sets the value of the local variable. If we want the method to set the value of the local variable in the function block, we need to use the THIS pointer to access it.

nTest := 1; // changes the value of the local variable in the method
THIS^.nTest := 2; // changes the value of the variable in the function block

As with the SUPER pointer, the THIS pointer must likewise always be upper case.

Sample (TwinCAT 3.1.4020)

Effect of FINAL on performance

A method or POU declared with the access specifier FINAL is not able to act as a parent function block. All calls to its methods are direct. This has the effect that there is no longer any need for polymorphism. The compiler is able to take this into account during code generation and optimise the code accordingly. Depending on the application, this optimisation can have a significant effect at runtime. Here, an example:

A function block has two completely identical methods. The only difference is the access specifier. One method has been declared as PUBLIC, the other as FINAL. In a PLC task, first one and then a little later the other method is called.

IF (bSwitch) THEN
  FOR n := 1 TO 50000 DO
    fbTest.MethodFinal(0.534, 1.78, -2.43);
  END_FOR
ELSE
  FOR n := 1 TO 50000 DO
    fbTest.MethodPublic(0.534, 1.78, -2.43);
  END_FOR
END_IF

As we can see, the execution time changes significantly.

Picture07

If the method declared as FINAL is called 50,000 times, the running time for the PLC task on my test device is about 6.9 ms. This rises to about 7.5 ms for the method declared as PUBLIC.

Of course, our example program is rather abstract, as it does almost nothing but call the methods. Nonetheless, this is worth taking into account when selecting an access specifier.

UML diagrams

The inheritance hierarchy can be depicted diagrammatically. Unified Modelling Language (UML) is the established standard in this area. UML defines various diagram types which describe both the structure and behaviour of software.

A good tool for describing the function block inheritance hierarchy is the class diagram.

UML diagrams can be created directly in TwinCAT 3. Changes to the UML diagram have a direct effect on the POUs. Function blocks can thus be modified and amended via the UML diagram.

Picture08

Each box stands for one function block and is always divided into three horizontal sections. The top section shows the name of the function block, the middle section lists its properties and the lower section lists all its methods. In this example, the arrows show the direction of inheritance and always point towards the parent function block.


Norbert Eder: .NET Transaction: Timeout via Config setzen

Für Transaktionen im .NET Framework (siehe System.Transactions.Transaction) kann ein Timeout gesetzt werden. Programmatisch ist dies über die TransactionOptions und der dort angebotenen Eigenschaft Timeout möglich.

Allerdings ist auch eine Konfiguration des Timeouts möglich. Zu diesem Thema finden sich aber unterschiedliche Aussagen im Internet.

Das Default-Timeout einer Transaction liegt bei 10 Minuten. Kann die Transaktion innerhalb dieser Zeit nicht abgeschlossen werden, erfolgt ein Abbruch derselben.

Default-Timeout verändern

Das Default-Timeout kann für jede Anwendung in der app.config verändert werden. Dazu ist folgender Eintrag notwendig:

<system.transactions>
  <defaultSettings timeout="00:15:00"/>
</system.transactions>

Diese Einstellung erhöht das Default-Timeout auf 15 Minuten.

Wird ein Timeout programmatisch gesetzt, wird das konfigurierte Timeout überschrieben.

Es kann zwar ein beliebiges Default-Timeout gesetzt werden, allerdings gibt es auch ein maximales Timeout.

Maximales Transaction Timeout konfigurieren

An vielen Stellen wird die Konfiguration dieses Timeouts über die app.config gezeigt. Dies ist nicht richtig. Das maximale Timeout muss über die machine.config gesetzt werden. Diese liegt sowohl für 32bit als auch für 64bit Kompilate vor, daher rate ich zur Anpassung beider Dateien. Zu finden sind sie hier:

%windir%\Microsoft.NET\Framework\v4.0.30319\config\machine.config
%windir%\Microsoft.NET\Framework64\v4.0.30319\config\machine.config

Die neue Einstellung kann folgendermaßen gesetzt werden:

<system.transactions>
  <machineSettings maxTimeout="00:20:00"/>
</system.transactions>

Zu beachten ist, dass diese Einstellung die allerletzte innerhalb der machine.config sein muss (direkt vor ), da es sonst zu Problemen kommt und die Einstellung nicht verwendet wird.

Viel Erfolg!

The post .NET Transaction: Timeout via Config setzen appeared first on Norbert Eder.

Manfred Steyer: Material zu Angular-Session von Global Azure Bootcamp in Linz, 2017

Nachfolgend mein Material von meiner Angular-Session vom global Azure Bootcamp in Linz:

Kazim Bahar: 12 Open Source UI-Frameworks für WPF-Anwendungen

Auf der mittlerweile populärsten Sourcecode-Verwaltungsplattform GitHub befinden sich etliche frei verfügbare UI-Frameworks für .NET Anwendungen. Die hier aufgelisteten Frameworks für WPF sind...

Holger Schwichtenberg: Microsofts To-Do kann mit Wunderlist bisher nicht mithalten

Microsofts neue Aufgabenverwaltung liegt derzeit noch weit hinter dem Vorgänger Wunderlist zurück.

Jürgen Gutsch: A first glimpse into CAKE

Since a couple of years I use FAKE (C# Make) to configure my builds. Also at the YooApps we use FAKE in some projects. One of the projects uses it since more than two years. FAKE is really great and I love to use it, but there is one problem with it: The most C# developers don't really like to use new things. The worst case for the most C# developers - it seems - is a new tool, that uses an exotic language like F#.

This is why I have to maintain the FAKE build scripts, since I introduced FAKE to the team.

It is that new tool and the F# language that must be scary for them, even if they don't really need to learn F# for the most common scenarios. That's why I asked the fellow developers to use CAKE (C# Make).

  • It is C# make instead of F# make
  • It looks pretty similar
  • It works the same way
  • It is a scripting language
  • It works almost everywhere

They really liked the idea to use CAKE. Why? just because of C#? It seems so...

It doesn't really makes sense to me, but anyway, it makes absolutely sense that the developers need to use and to maintain there own build configurations.

How does CAKE work?

CAKE is built using a C# scripting language. It uses the Roslyn compiler to compile the scripts. Instead of using batch files, as FAKE does, it uses a PowerShell script (build.ps1) to bootstrap itself and to run the build script. The bootstrapping step loads CAKE and some dependencies using NuGet. The last step the PowerShell script does, is to call the cake.exe and to execute the build script.

The bootstrapping needs network access, to load all the stuff. It also loads the nuget.exe, if it's not available. If you don't like this, you can also commit the loaded dependencies to the source code repository.

The documentation is great. Just follow the getting-started guide to get a working example. There's also a nice documentation about setting up a new project available.

Configuring the build

If you know FAKE or even MSBuild it will look pretty familiar to you. Let's have a quick look into the first simple example of the getting started guide:

var target = Argument("target", "Default");

Task("Default")
  .Does(() =>
        {
          Information("Hello World!");
        });

RunTarget(target);

The first line retrieves the build target to execute from the command line arguments. Starting from line 3 we see a definition of a build target. This target just prints a "Hello World!" as a information message.

The last line starts the initial target by its name.

A more concrete code sample is the build script from the CAKE example (I removed some lines in this listing to get a shorter example):

#tool nuget:?package=NUnit.ConsoleRunner&version=3.4.0

var target = Argument("target", "Default");
var configuration = Argument("configuration", "Release");

// Define the build directory.
var buildDir = Directory("./src/Example/bin") + Directory(configuration);

Task("Clean")
  .Does(() =>
        {
          CleanDirectory(buildDir);
        });

Task("Restore-NuGet-Packages")
  .IsDependentOn("Clean")
  .Does(() =>
        {
          NuGetRestore("./src/Example.sln");
        });

Task("Build")
  .IsDependentOn("Restore-NuGet-Packages")
  .Does(() =>
        {
          MSBuild("./src/Example.sln", settings =>
                  settings.SetConfiguration(configuration));
        });

Task("Run-Unit-Tests")
  .IsDependentOn("Build")
  .Does(() =>
        {
          NUnit3("./src/**/bin/" + configuration + "/*.Tests.dll", new NUnit3Settings {
            NoResults = true
          });
        });

Task("Default")
  .IsDependentOn("Run-Unit-Tests");

RunTarget(target);

This script uses another NuGet package to run the NUnit3 tests and references it. A nice feature is to configure the NuGet dependency at the beginning of the script.

This build script contains five targets. The method IsDependentOn("") wires the targets together in the right execution order. This way is a bit different to FAKE and maybe a little bit confusing. It needs to write the targets in the right execution order. If you don't write the script like this, you need to find the initial target and to follow the way back to the very first target. You will read the execution order from the last to the first target.

FAKE does this a little easier and wires the targets up in a single statement at the end of the file:

// Dependencies
"Clean"
  ==> "Restore-NuGet-Packages"
  ==> "Build"
  ==> "Run-Unit-Tests"
  ==> "Default"
 
RunTargetOrDefault "Default"

This could possibly look like this dummy code in CAKE:

// Dependencies
WireUp("Clean")
  .Calls("Restore-NuGet-Packages")
  .Calls("Build")
  .Calls("Run-Unit-Tests")
  .Calls("Default");

RunTarget(target);

Running the build

To run the build, just call .\build.ps1 in a PowerShell console:

If you know FAKE, the results look pretty familiar:

Conclusion

Anyway. I think CAKE gets pretty much faster accepted by the fellow developers at the YooApps than FAKE did. Some things will work a little easier in CAKE than in FAKE and some a little different, but the most stuff will work the same way. So it seems it makes sense to switch to use CAKE at the YooApps. So let's use it. :)

I'm sure, I will write down a comparison of FAKE and CAKE later, if I have used it for a few months.

Golo Roden: Wofür braucht man BCC?

Das BCC-Feld in E-Mails zu erklären, ist aus technischer Sicht einfach: Das Akronym steht für "Blind Carbon Copy", was im Deutschen ungefähr dem Begriff "Blindkopie" entspricht. Doch was ist dessen Sinn? Ein Erklärungsversuch.

Jürgen Gutsch: Please use a password manager

Since years, I'm using a password manager to store and manage all my credentials for all the accounts I use. The usage of such a tool is pretty common for me and it is a normal flow for me to create a new entry in the password manager first before I create the actual account.

I'm always amazed, if I meet people, who don't use any tool to store and manage their credentials. They use the same password or the same bunch of passwords everywhere. This is dangerous and most of them already know about that. Maybe they are to lazy to spend one or two ours to think about the benefits and to search for the right tool or they simply don't know about such tools

For me the key benefits are pretty clear:

  • I don't need to remember all the passwords.
  • I don't need to think about secure passwords while creating new one
  • I just need to remember one single passphrase

Longer passwords are more secure than short ones, even if the short ones include special characters, numbers and upper case characters. But longer passwords are pretty hard to remember. This is why Edward Snowden proposed to use passphrases instead of passwords. Using passphrases like this, are easy to remember. But would it really makes sense to create a different pass-phrase for every credentials you use? I don't think so.

I just created a single pass-phrase which is used with the password manager and I use the password manager to generate the long passwords for me. Most of the generated password are like this:

I4:rs/pQO8Ir/tSk*`1_KSG"~to-xMI/Gf;bNP7Qi3s8RuqIzl0r=-JL727!cgwq

The tool I use is KeePass 2, which is available on almost all devices and OS I use. As small desktop app on Windows, Mac and Linux as an app on Windows phones and Android. (Probably on iOS too, but I don't use such a device). KeePass stores the passwords on a encrypted file. This file could be stored on a USB drive or on a shared folder in the cloud. I use the cloud way to share the file to every device. The cloud store itself is secured with a password I don't know and which is stored in that KeePass file.

What the F***, you really put the key to lock your house into a safe which is inside your house? Yes!

The KeyPass file is synced offline and offline accessible on all devices. If the file changes it will be synched to all devices. I'm still able to access all credentials.

With the most password mangers, you are able to copy the username and the password, using shortcuts to the login forms. Some of them are able to automatically fill in the credentials. KeePass uses the clipboard, but deletes the values from the clipboard after a couple of seconds. Like this, no one else can access or reuse the credentials within the clipboard.

There are many more password manager out there. But KeePass - with the encrypted file - works best for me. I'm responsible to store the file on a save location and I can do that wherever I want.

Summary

Use a password manager! Spend the time to try the tools and choose the tools that fits you best. It is important! Once you use a password manager, you never want to work without one. It will make you live easier and hopefully more secure.

MSDN Team Blog AT [MS]: Pre-Events für die BUILD 2017 (Seattle)

Die Angebote an Trainings am Vortag der BUILD wachsen gerade kräftig. Anbei ein aktueller Stand der Angebote – für die meisten ist eine “Bewerbung” mit einem Profil erforderlich. Neu dazu gekommen sind Veranstaltungen zu Visual Studio Extensions, Visual Studio für Partner und ein .NET Core Training.

Speziell die Visual Studio Veranstaltungen, das .NET Core Training mit Hands-On und die Azure Veranstaltungen (Schwerpunkt Container & Serverless) klingen sehr interessant:

.Net

Azure

AI

Visual Studio Extensions

Visual Studio for partners 

Erweitern Sie ihre BUILD Teilnahme um spannende Trainingsinhalte die direkt von den Produktgruppen angeboten werden.

Golo Roden: Was ist 1/10 im Binärsystem?

In vielen Programmiersprachen führt das Rechnen mit Dezimalzahlen zu ungenauen Ergebnissen. Als Grund wird in der Regel angeführt, dass sich bestimmte Dezimalzahlen nicht exakt im Binärsystem repräsentieren ließen. Doch warum ist das so?

MSDN Team Blog AT [MS]: CELUM – Digital Asset Management auf Microsoft Azure

Schnittstellen zu anderen Systemen sind ein heikles Thema: Oft sind es IT-technische Zwangsheiraten, damit ein Austausch an nötigen Informationen überhaupt erst möglich ist.

Und dann gibt es die Systeme, die Hand in Hand arbeiten, sich verstehen und zusammen mächtige Grundpfeiler der digitalen Architektur für Unternehmen darstellen.

So geschehen bei CELUM und Microsoft Azure. Das Unternehmen aus dem österreichischen Linz liefert mit Digital Asset Management (DAM) eine Anwendung, die das Organisieren, Verwalten und Verteilen von Content übernimmt, während Microsoft-Azure alle Daten in der Cloud verfügbar macht.

 

Die Vorteile in Kombination auf einen Blick:

  • CELUM als App in der Microsoft Azure Cloud
  • Upload von Digitalen Assets in Microsoft Blob Storage
  • CELUM DAM als skalierbarere Cloud Services verfügbar
  • Verwendung von Azure Media-Services für Storage, Encoding oder als Streaming-Dienst direkt über CELUM

 

Wie funktioniert das nun genau?

celum_microsoft-azure

 

 

 

 

 

 

 

 

 

 

 

 

 

In dem Beispiel wird deutlich, wie gut sich CELUM und AZURE ergänzen.

  1. CELUM liefert Bilder und Dokumente in vordefinerten Formaten samt Videos als Originaldatei zu Microsoft Azure. Die Microsoft-Lösung liefert alle URLs für ein Asset zurück in das CELUM System, wo sie dann abgelegt werden.
  2. Der Asset Picker – eine von CELUM gelieferte Javascript Extension, die integrierten Zugriff auf Assets in CELUM ermöglicht und in jedes web-basierte Programm integriert werden kann – fordert über das CMS die benötigten URLs an. In einem zweiten Schritt werden die URLs über eine Rest- Schnittstelle (CORA) an das CMS übermittelt. Hernach speichert das CMS nur URLs ab, jedoch keine Binärdaten.
  3. Das CMS liefert statischen Content, wie HTML sowie die URLs zum medialen Content, direkt vom CMS-Server, die Auslieferung von medialem Content wie Videos, Bilder und Dokumente an den Client erfolgt direkt von MS Azure. Das Content Delivery Network (CDN) liefert Assets (Binärdaten) in verschiedenen Formaten und Auflösungen optimiert für das jeweilige Endgerät aus.

Zusatzoption: Wenn das CDN in Microsoft Azure aktiviert ist, werden für eine performante weltweite Auslieferung die URLs aus dem Blob Storage in CELUM gegen CDN URLs ausgetauscht. Microsoft Azure handhabt die CDN Logik – also das Caching, Verteilung etc. – intern. Dabei wird sie im Microsoft Azure Account von Microsoft konfiguriert.

 

Dateien müssen nicht mehr in lokalen Systemen dupliziert werden: Sie kommunizieren via den ausgegebenen URLs, die über CELUM mit dem Microsoft Blob Storage erstellt und ausgetauscht werden. Zudem ist Microsoft Azure in der Lage, tausende Requests sofort zu verarbeiten – weltweit. Das heißt: Die Assets können via CELUM entsprechend schnell ausgespielt werden. Und das Wichtigste: Der User behält die volle Kontrolle über die ausgespielten Assets.

 

Best Practice Beispiel SCA

CELUM ist der zentrale Content-Speicher und bietet Anbindungen zu CMS und PIM Systemen beim schwedischen Unternehmen SCA, das als global führender Hygieneartikel-Hersteller agiert. Bei SCA werden insgesamt rund 100.000 Assets über CELUM gemanagt, die sich auf gut 50 Marken, wie zum Beispiel Tork, Tena, Tempo oder Zewa aufteilen. Davon sind 30.000 Assets mit Microsoft Azure synchronisiert. Über 100 Webseiten werden über CELUM und Microsoft Azure mit Bildern, Videos, Logos und Dokumenten befüllt. Mit dem Microsoft Azure CDN ist zudem die weltweite Verfügbarkeit bei einer gleichzeitigen starken Performance sichergestellt. Zudem gibt es auch bei anderen Kunden gelungene Integrationen von CELUM und Microsoft Azure u.a. zu SAP hybris, SDL Tridion, OpenCMS, EZpublish, Umbraco und Salesforce.

 

Bei weitere Fragen zu DAM kontaktieren Sie bitte Peter Eder, Sales & Marketing Manager: peter.eder@celum.com oder Ihren Microsoft Ansprechpartner.

Mehr darüber können Sie auch hier erfahren.

Golo Roden: Einführung in Node.js, Folge 14: Websockets

WebSockets sind ein TCP-basiertes Netzwerkprotokoll, das eine dauerhafte und bidirektionale Verbindung zwischen Client und Server ermöglicht. Auf dem Weg lassen sich beispielsweise Push-Nachrichten zeitnah zustellen, ohne aufwändiges Polling betreiben zu müssen. Wie funktioniert das unter Node.js?

MSDN Team Blog AT [MS]: Gratis AI Immersion Hands-On Workshop in Seattle

Das Cortana Intelligence Team hat ein super Angebot für alle Entwickler, die Ihre AI Kenntnisse vertiefen wollen. Es wird ein exklusiver Hands-On Workshop mit den Industrie Experten aus den Product Teams und Microsoft Research angeboten, wo ihr die Möglichkeiten habt, über Künstliche Intelligenz zu lernen und in eure Applikationen einzubauen. Der Workshop ist gratis, allerdings mit einer begrenzten Anzahl an Spots, also schnell anmelden.

AIWorkshop

Hier die Inhalte aus dem Workshop:

  • Applied Machine Learning for Developers
  • Big AI – Applying Artificial Intelligence at Scale
  • Weaving Cognitive and Azure Services to Provide Next-Generation Intelligence
  • Deep Learning and the Microsoft Cognitive Toolkit
  • Building Intelligent SaaS Applications

Mehr Informationen zum Workshop findet ihr auf dem Cortana Intelligence und ML Blog. Anmelden könnt ihr euch hier.

Wenn ihr euch für den Workshop vorbereiten wollt, gibt es auf der MVA viele Kurse rund um Azure Machine Learning, Big Data und Analytics.

Holger Schwichtenberg: Kostenloser Vortrag: "Was bringen Visual Studio 2017 und C# 7.0?"

In diesem User-Group-Vortrag am 26. April um 18 Uhr in Ratingen erhält man einen Überblick über die Neuerungen in Visual Studio 2017, C# 7.0 und Visual Basic 15, einschließlich der .NET Core Tools Version 1.0.

Holger Schwichtenberg: Einfaches überprüfen in .NET/C# , ob eine E-Mail-Adresse richtig aufgebaut ist

Mit der in .NET und .NET Core verfügbaren Klasse System.ComponentModel.DataAnnotations. EmailAddressAttribute kann man einfach E-Mail-Adresse prüfen.

MSDN Team Blog AT [MS]: Azure Data Analytics für Entwickler

In diesem Kurs spricht Lucas Volkert über die Möglichkeiten von Azure Data Analytics. Dabei wird darauf eingegangen was Maschinelles Lernen überhaupt ist und die Möglichkeiten von Azure Machine Learning werden anhand eines praktischen Beispiels vorgestellt. Außerdem werden die Analysemöglichkeiten von Azure Stream Analytics auf sich schnell verändernden Datenbeständen näher betrachtet.

01 | Einführung und Überblick über Azure Machine Learning
Dieses Video gibt eine Einführung zum Maschinellen Lernen und stellt Azure Machine Learning vor.

02 | Azure Machine Learning einsetzen
In diesem Video werden Grundlagen zu Azure Machine Learning erklärt. Diese beinhalten das Anlegen von ML Studio Workspace, das Hochladen der Daten und das Trainieren eines Models.

03 | Azure Stream Analytics
Dieses Video gibt eine Einführung in Azure Stream Analytics und die Stream Analytics Query Language.

Was wirst du lernen?

  • Verstehen was Maschinelles Lernen ist
  • Verstehen wie man den richtigen Algorithmus auswählt
  • Azure ML Studio kennen und verwenden können
  • Modelle aufbauen und trainieren können
  • Trainierte Azure ML Modelle in einer Anwendung einsetzen können
  • Stärken von Azure Stream Analytics kennen
  • Grundlagen der Stream Analytics Query Language beherrschen
  • Live-Daten mit Azure Stream Analytics analysieren können
  • Azure Stream Analytics Ergebnisse in Anwendungen einbinden können

Dieser Kurs erfordert kein Vorwissen.

JETZT KOSTENLOS ANMELDEN!

Manfred Steyer: Lazy Loading with Angular - Material from ng-conf 2017 in Salt Lake City

Please find below the material from my talk at ng-conf regarding Lazy Loading and Preloading in Angular:

Golo Roden: Gelesen: "Wie Google tickt"

Google gehört zweifelsohne zu den beeindruckendsten Unternehmen der digitalen Welt des 21. Jahrhunderts. Doch was zeichnet es aus, was macht das Unternehmen so besonders? Antworten auf diese Fragen gibt das Buch "Wie Google tickt".

Holger Schwichtenberg: QueryTrackingBehavior in Entity Framework Core

In Entity Framework Core hat Microsoft eine eleganteres Feature eingebaut, um die Performance von Datenbank-Leseoperationen per No-Tracking zu steigern.

Stefan Henneken: IEC 61131-3: Methoden, Eigenschaften und Vererbung (Update)

Eine bewährte Methode um die Komplexität von Softwaresystemen zu bewältigen ist die objektorientierte Programmierung (OOP). Bisher eine Domäne von Programmiersprachen wie C++, Java oder C#, steht dieses Konzept mit der IEC 61131-3 auch der SPS-Programmierung zur Verfügung.

Eine kurze Einführung bietet mein Post IEC 61131-3: Vorteile der objektorientierten Spracherweiterungen bei CoDeSys V3 aus dem Jahr 2010. Dort werden die Entstehung der objektorientierten Programmierung sowie deren Eigenschaften erläutert.

Dieser Post ist eine überarbeitete Version von IEC 61131-3: Methoden, Eigenschaften und Vererbung und ebenfalls aus dem Jahr 2010. Neben einigen Anpassungen wurden außerdem neue Themen hinzugefügt, wie z.B. die Zugriffsbezeichner (Access Specifier).

Methoden

Bisher bestand ein Funktionsblock aus internen Variablen, Eingangs- und Ausgangsvariablen. Es gab nur eine Möglichkeit, die internen Variablen von außen zu verändern. Die entsprechende Instanz des Funktionsblocks wurde mit den jeweiligen Eingangsvariablen aufgerufen. Je nach Zustand der Eingangsvariablen wurden unterschiedliche Bereiche im Funktionsblock ausgeführt und dadurch die internen Variablen verändert. Beispiel:

Motor starten:

fbEngine(bStart := true, bStop := false, nGear := 1, fVelocity := 7.5);

Motor stoppen:

fbEngine(bStart := false, bStop := true);

Innerhalb des Funktionsblocks wurde auf eine positive Flanke der Variablen bStart und bStop geachtet. Der Anwender des Funktionsblocks musste wissen, dass aus diesem Grund auch beim Stoppen die Variable bStart auf FALSE gesetzt werden musste. Ansonsten würde bei jedem weiteren Versuch, den Motor neu zu starten, keine steigende Flanke erkannt werden. Auch musste bekannt sein, dass beim Starten des Motors der Parameter nGear mit anzugeben ist. Beim Stoppen war dieses nicht notwendig.

Mit den OOP-Erweiterungen findet eine deutlichere Trennung zwischen den internen Variablen und den Möglichkeiten diese zu ändern statt. Es ist möglich, weitere Unterfunktionen (Methoden) innerhalb des Funktionsblocks zu definieren, die der Anwender aufrufen kann.

Picture01

Methoden sind vergleichbar mit Aktionen. Beim Aufruf können aber Parameter übergeben werden. Auch können Methoden lokale Variablen enthalten, so wie es bei Funktionen möglich ist. Somit könnte das obige Beispiel wie folgt mit dem Einsatz von Methoden umgesetzt werden:

Motor starten:

fbEngine.Start(nGear := 1, fVelocity := 7.5); 

Motor stoppen:

fbEngine.Stop(); 

Die Methoden Start() und Stop() können auf interne Variablen des Funktionsblocks zugreifen, aber auch eigene Variablen enthalten, die weder von außen noch durch andere Methoden des Funktionsblocks veränderbar sind. Ein unbeabsichtigtes Überschreiben wird hierdurch verhindert.

Ebenso können Methoden einen Rückgabewert enthalten, welcher an den Aufrufer der Methode zurückgegeben wird. Falls notwendig, können weitere Ausgangsvariablen zwischen VAR_OUTPUT und END_VAR deklariert werden. Diese Möglichkeit besteht seit TwinCAT 3 auch bei Funktionen. Auch ist es seit TwinCAT 3 erlaubt, Funktionen oder Methoden ohne Rückgabewert zu deklarieren.

Nur POUs vom Typ FUNCTION_BLOCK oder PROGRAM können Methoden enthalten. Bei einer POU vom Typ FUNCTION ist dieses nicht möglich.

Beim Aufruf einer Methode müssen immer alle Parameter angegeben werden. Hierbei kann alternativ auf die Parameternamen verzichtet werden:

fbEngine.Start(1, 7.5);

Werden die Parameternamen explizit angegeben, so ist die Reihenfolge der Parameter beliebig:

fbEngine.Start(fVelocity := 7.5, nGear := 1); 

Methoden werden in den graphischen Darstellungsarten durch eine separate Box aufgerufen:

Picture02

Einige Programmiersprachen bieten die Möglichkeit, Methoden mit gleichen Namen mehrfach anzulegen. Diese müssen sich dann durch die Parameter (Signatur) unterscheiden. Dieses wird als Überladen bezeichnet. Bisher können Methoden in der IEC 61131-3 nicht überladen werden. Es findet keine Differenzierung der Methoden über die Signatur statt. Allein der Name der Methode muss eindeutig sein.

Access Specifier

Optional kann bei der Deklaration einer Methode ein Zugriffsbezeichner (Access Specifier) angegeben werden. Dieser schränkt den Zugriff auf die jeweilige Methode ein.

PUBLIC Jeder darf die Methode aufrufen. Es gibt keine Einschränkungen.
PRIVATE Die Methode steht nur innerhalb des POUs zur Verfügung. Von Außen kann die Methode nicht aufgerufen werden.
PROTECTED Auf die Methode kann nur der eigene POU oder seine Ableitungen zugreifen. Der Begriff der Ableitung wird weiter unten noch erklärt.
INTERNAL Auf die Methode kann nur aus dem eigenen Namensraum zugegriffen werden. Hiermit können z.B. bestimmte Methoden nur innerhalb einer Bibliothek zur Verfügung gestellt werden.
FINAL Die Methode kann nicht durch eine andere Methode überschrieben werden. Das Überschreiben von Methoden wird weiter unten noch erklärt.

Wird auf den Zugriffsbezeichner verzichtet, so ist PUBLIC die Standardeinstellung.

Die Deklaration einer Methode hat somit den folgenden Aufbau:

METHOD <Zugriffsbezeichner> <Name> : <Rückgabetyp> 

Eigenschaften

Parameter konnten bisher nur über den Aufruf des Funktionsblocks und Eingangsvariablen übergeben werden. Zustände wurden durch Ausgangsvariablen nach außen weitergegeben. Mit den sogenannten Eigenschaften (engl.: Properties) gibt es einen fest definierten Weg, allgemeine Parameter und Zustände unabhängig vom Aufruf des Funktionsblocks zu übergeben.

Das Besondere an den Eigenschaften ist, dass der Zugriff durch zwei spezielle Methoden durchgeführt wird. Es gibt eine Methode für das Schreiben und eine für das Lesen der Eigenschaft. Diese Methoden werden auch als Setter (schreiben) und Getter (lesen) oder allgemein Accessor bezeichnet. Innerhalb dieser Methoden kann z.B. eine Bereichsüberprüfung oder eine Einheitenumrechnung stattfinden.

Setter und Getter können lokale Variablen enthalten, aber keine zusätzlichen Ein- und Ausgänge. Die lokalen Variablen verlieren beim Verlassen einer Setter- oder Getter Methode allerdings ihren Wert. Somit verhalten sich diese wie Funktionen. Aus diesem Grund muss der Setter einen entsprechenden Mechanismus bereitstellen, damit der Wert der Eigenschaft erhalten bleibt. Hierzu kann z.B. im Funktionsblock eine lokale Variable deklariert werden.

FUNCTION_BLOCK PUBLIC FB_Engine
VAR
  myPropertyInternalValue : LREAL := 50;
END_VAR 

Im Setter wird der Wert der Eigenschaft MyProperty an die lokale Variable übergeben.

myPropertyInternalValue := MyProperty; 

Der Getter geht den umgekehrten Weg und gibt den Wert der lokalen Variablen zurück an die Eigenschaft.

MyProperty := myPropertyInternalValue; 

Die lokale Variable myPropertyInternalValue kann im Funktionsblock für die internen Berechnungen genutzt werden. Der Zugriff auf diese Variable ist von außen nur über die Eigenschaft MyProperty möglich.

Das obere Beispiel soll um drei Eigenschaften erweitert werden. Eine für die Vorgabe der maximal zulässigen Geschwindigkeit (MaxVelocity) sowie zwei weitere zur Ausgabe der aktuellen Temperatur (Temperature) und der aktuellen Geschwindigkeit (Velocity).

In den graphischen Darstellungsarten werden Eigenschaften nicht an der jeweiligen Box dargestellt. Der Zugriff erfolgt durch den Namen der Instanz und der Eigenschaft, getrennt durch einen Punkt.

fbEngine(); 
bError := fbEngine.Temperature > 130;

Picture03

Getter und Setter müssen nicht gleichzeitig vorhanden sein. Fehlt z.B. der Setter, so kann die Eigenschaft nur gelesen werden. In TwinCAT 3 sieht die Definition des Funktionsblocks mit den Methoden und Eigenschaften wie folgt aus:

Picture04

Access Specifier

Wie bei Methoden sind auch die Zugriffsbezeichner PUBLIC, PRIVATE, PROTECTED, INTERNAL und FINAL erlaubt. Wird kein Zugriffsbezeichner angegeben, so ist die Eigenschaft PUBLIC. Zusätzlich lässt sich an jedem Getter und Setter ein Zugriffsbezeichner angeben. Dieser hat Vorrang vor dem Zugriffsbezeichner der Eigenschaft.

Die Deklaration einer Eigenschaft hat somit den folgenden Aufbau:

PROPERTY <Zugriffsbezeichner> <Name> : <Datentyp>  

Vererbung

Funktionsblöcke eignen sich sehr gut um Programmteile voneinander zu trennen. Hierdurch kann eine bessere Strukturierung der Software erreicht und die Wiederverwendung deutlich vereinfacht werden. Bisher war es allerdings immer kritisch, einen vorhandenen Funktionsblock in seinem Funktionsumfang zu erweitern. Entweder musste der Quellcode angepasst, oder ein neuer Funktionsblock um den vorhandenen herum programmiert werden. Der existierende Funktionsblock wurde sozusagen in einen anderen, einen neuen Funktionsblock eingebettet. Bei der letzteren Variante mussten alle Eingangsvariablen erneut angelegt und den Eingangsvariablen des schon vorhandenen Funktionsblocks zugewiesen werden. Das gleiche musste, nur in umgekehrter Richtung, bei den Ausgangsvariablen gemacht werden.

Mit TwinCAT 3 wird das Prinzip der Vererbung eingeführt. Vererbung ist ein Grundprinzip der objektorientierten Programmierung. Bei der Vererbung wird ein neuer Funktionsblock von einem bestehenden Funktionsblock abgeleitet. Dieser kann anschließend erweitert werden. Dabei erbt der neue Funktionsblock alle Eigenschaften und Methoden des Basisfunktionsblocks, wenn dessen Zugriffsbezeichner (Access Specifier) dieses zulässt. Jeder Funktionsblock kann beliebig viele Nachfolger haben, aber er kann lediglich nur einen Vorgänger (Basisfunktionsblock) besitzen. Das Ableiten eines Funktionsblocks geschieht bei der Deklaration des neuen Funktionsblocks. Die Anweisung EXTENDS wird mit Angabe des Basisfunktionsblocks hinter den Namen des neuen Funktionsblocks angegeben. Beispiel:

FUNCTION_BLOCK PUBLIC FB_NewEngine EXTENDS FB_Engine 

Nach dem Ableiten besitzt der neue Funktionsblock (FB_NewEngine) alle Eigenschaften und Methoden des Basisfunktionsblocks (FB_Engine). Methoden und Eigenschaften werden aber nur dann vererbt, wenn der Zugriffsbezeichner (Access Specifier) dieses zulässt.

Auch werden alle lokalen Variablen, VAR_INPUT, VAR_OUTPUT und VAR_IN_OUT des Basisfunktionsblocks an den neuen Funktionsblock vererbt. Dieses Verhalten kann durch Zugriffsbezeichner nicht eingeschränkt werden.

Wurden Methoden oder Eigenschaften im Basisfunktionsblocks als PROTECTED deklariert, so kann zwar der abgeleitete Funktionsblock (FB_NewEngine) darauf zugreifen, aber außerhalb von FB_NewEngine ist dieses nicht möglich.

Vererbung ist nur bei POUs vom Typ FUNCTION_BLOCK möglich.

Zugriffsbezeichner (Access Specifier)

Bei der Deklaration eines FUNCTION_BLOCK, FUNCTION oder PROGRAM kann ein Zugriffsbezeichner (Access Specifier) angegeben werden. Dieser schränkt den Zugriff und die Möglichkeiten der Vererbung bei Bedarf ein.

PUBLIC Jeder darf den POU aufrufen bzw. eine Instanz davon anlegen. Auch darf der POU, wenn dieser ein FUNCTION_BLOCK ist, für die Vererbung genutzt werden. Es gibt keine Einschränkungen.
INTERNAL Der POU kann nur im eigenen Namensraum verwendet werden. Hiermit können z.B. bestimmte POUs nur innerhalb einer Bibliothek zur Verfügung gestellt werden.
FINAL Der FUNCTION_BLOCK kann nicht als Basisfunktionsblock verwendet werden. Ein Erben von diesem POU ist nicht zulässig. FINAL ist nur bei POUs vom Typ FUNCTION_BLOCK erlaubt.

Wird auf den Zugriffsbezeichner verzichtet, so ist PUBLIC die Standardeinstellung. Die Zugriffsbezeichner PRIVATE und PROTECTED sind bei der Deklaration von POUs nicht zulässig.

Soll die Vererbung genutzt werden, so hat die Deklaration eines Funktionsblocks folgenden Aufbau:

FUNCTION_BLOCK <Zugriffsbezeichner> <Name> : EXTENDS <Name Basisfunktionsblock>

Überschreiben von Methoden

Der neue FUNCTION_BLOCK FB_NewEngine, der von FB_Engine geerbt hat, kann jetzt zusätzliche Eigenschaften und Methoden erhalten. Als Beispiel wird die Eigenschaft Gear hinzugefügt. Über diese Eigenschaft kann der aktuelle Gang abgefragt und verändert werden. Dementsprechend werden Getter und Setter der Eigenschaft erstellt.

Allerdings muss sichergestellt werden, dass der Parameter nGear der Methode Start() an diese Eigenschaft übergeben wird. Da der Basisfunktionsblock FB_Engine keinen Zugriff auf die neue Eigenschaft hat, wird in FB_NewEngine die Methode mit genau dem gleichen Parameter neu anlegt. Der vorhandene Code wird in die neue Methode kopiert und so ergänzt, dass der Parameter nGear an die Eigenschaft Gear übergeben wird.

METHOD PUBLIC Start
VAR_INPUT
  nGear : INT := 2;
  fVelocity : LREAL := 8.0;
END_VAR 

IF (fVelocity < MaxVelocity) THEN
  velocityInternal := fVelocity;
ELSE
  velocityInternal := MaxVelocity;
END_IF
Gear := nGear; // new 

In Zeile 12 wird der Parameter nGear in die Eigenschaft Gear kopiert.

Wird in einem Funktionsblock eine Methode oder eine Eigenschaft neu definiert, obwohl diese im Basisfunktionsblock schon vorhanden ist, so nennt man dieses Überschreiben. Der Funktionsblock FB_NewEngine überschreibt die Methode Start().

Somit besitzt FB_NewEngine die neue Eigenschaft Gear und überschreibt die Methode Start().

Picture05

Durch

fbNewEngine.Start(1, 7.5);

wird die Methode Start() in FB_NewEngine aufgerufen, da diese in FB_NewEngine neu angelegt (überschrieben) wurde.

Während

fbNewEngine.Stop();

die Methode Stop() aus FB_Engine aufruft. Die Methode Stop() wurde von FB_Engine an FB_NewEngine vererbt.

Polymorphie

Neben der Vererbung ist Polymorphie (griechisch für Vielgestaltigkeit) eine grundlegende Eigenschaft der objektorientierten Programmierung. Darunter wird verstanden, dass eine Variable in Abhängigkeit seiner Verwendung unterschiedliche Datentypen annehmen kann. Bisher wurde jeder Variablen immer ein Datentyp zugeordnet. Polymorphie tritt immer in Zusammenhang mit Vererbung und Schnittstellen auf.

Hier soll die Polymorphie am obigen Beispiel durch Vererbung gezeigt werden. Dazu wird von FB_Engine und FB_NewEngine jeweils eine Instanz angelegt. In Abhängigkeit einer Variablen (bInput) werden die Instanzen einer Referenz zugewiesen.

PROGRAM MAIN
VAR
  fbEngine     : FB_Engine;
  fbNewEngine  : FB_NewEngine;
  bInput       : BOOL;
  refEngine    : REFERENCE TO FB_Engine;
END_VAR

IF (bInput) THEN
  refEngine REF= fbEngine;
ELSE
  refEngine REF= fbNewEngine;
END_IF
refEngine.Start(2, 7.5);

Eine Variable vom Typ REFERENCE TO FB_Engine kann nicht nur eine Instanz vom Typ FB_Engine aufnehmen (Zeile 10), sondern auch alle Funktionsblöcke die von FB_Engine geerbt haben; also auch FB_NewEngine (Zeile 12).

In Zeile 14 wird anschließend die Methode Start() aufgerufen. Allein aus dieser Zeile ist nicht erkennbar, ob die Methode aus FB_Engine oder aus FB_NewEngine ausgeführt wird.

Diese Mehrdeutigkeit wird in der objektorientierten Programmierung häufig eingesetzt, um Programme erweiterbar und flexibel zu gestalten. Hierzu werden z.B. Parameter einer Funktion als Referenz auf einen Funktionsblock definiert. Alle FBs, die von diesem Funktionsblock abgeleitet wurden, können somit an die Funktion übergeben werden.

In diesem Zusammenhang spielt auch das Konzept der Schnittstellen (Interfaces) eine wichtige Rolle, welches in meinem Post IEC 61131-3: Objektkomposition mit Hilfe von Interfaces vorgestellt wird.

SUPER-Zeiger

Bei dem obigen Beispiel wurde in FB_NewEngine die Methode Start() neu angelegt und der schon vorhandene Programmcode aus FB_Engine in die neue Methode kopiert. Das ist nicht immer möglich und entspricht auch nicht dem Gedanken der Wiederverwendung.

Aus diesem Grund steht jedem Funktionsblock, der von einem anderen Funktionsblock erbt, ein Zeiger mit dem Namen SUPER zur Verfügung. Über diesen ist es möglich, auf die Elemente (Methoden, Eigenschaft, lokale Variablen, …) des Basisfunktionsblocks zuzugreifen.

METHOD PUBLIC Start
VAR_INPUT
  nGear      : INT := 2;
  fVelocity  : LREAL := 8.0;
END_VAR 

SUPER^.Start(nGear, fVelocity); // calls Start() of FB_Engine
Gear := nGear;

Statt den Code aus dem Basisfunktionsblock in die neue Methode zu kopieren, wird über den Zeiger SUPER die Methode aus dem Funktionsblock FB_Engine aufgerufen. Ein Kopieren ist nicht mehr notwendig.

Im CFC-Editor wird SUPER wie folgt aufgerufen:

Picture06

Der SUPER-Zeiger muss immer in Großbuchstaben geschrieben werden.

THIS-Zeiger

Der THIS-Zeiger steht jedem Funktionsblock zur Verfügung und zeigt auf die eigene Funktionsblockinstanz. Dieser Zeiger ist notwendig, sobald eine Methode eine lokale Variable enthält, die eine Variable im Funktionsblock überdeckt.

Eine Zuweisung in der Methode setzt den Wert der lokalen Variablen. Soll in der Methode die lokale Variable des Funktionsblocks gesetzt werden, so muss der Zugriff über den THIS-Zeiger erfolgen.

nTest := 1; // changes the value of the local variable in the method
THIS^.nTest := 2; // changes the value of the variable in the function block

So wie der SUPER-Zeiger muss auch der THIS-Zeiger immer in Großbuchstaben geschrieben werden.

Beispiel (TwinCAT 3.1.4020)

Einfluss von FINAL auf die Performanz

Wird eine Methode oder eine POU mit dem Zugriffsbezeichner (Access Specifier) FINAL deklariert, so kann dieser Funktionsblock nicht als Basisfunktionsblock dienen. Methodenaufrufe erfolgen immer direkt. Das hat zur Folge das Polymorphie nicht mehr benötigt wird. Der Compiler kann dieses bei der Codegenerierung berücksichtigen und den Code entsprechend optimieren. Je nach Anwendungsfall kann die so erreichte Optimierung sich deutlich auf die Laufzeit auswirken. Hierzu ein Beispiel:

Ein Funktionsblock besitzt zwei völlig identische Methoden. Lediglich der Zugriffsbezeichner ist unterschiedlich. Eine Methode wurde als PUBLIC, die andere als FINAL deklariert. In einer SPS-Task wird erst die eine, einige Zeit später die andere Methode aufgerufen.

IF (bSwitch) THEN
  FOR n := 1 TO 50000 DO
    fbTest.MethodFinal(0.534, 1.78, -2.43);
  END_FOR
ELSE
  FOR n := 1 TO 50000 DO
    fbTest.MethodPublic(0.534, 1.78, -2.43);
  END_FOR
END_IF

Hierbei ist zu beobachten, dass die Durchlaufzeit sich deutlich verändert.

Picture07

Wird die mit FINAL deklarierte Methode 50.000 mal aufgerufen, so liegt die Durchlaufzeit der SPS-Task auf meinem Testgerät bei ca. 6,9 ms. Diese erhöht sich auf ca. 7,5 ms, sobald die Methode mit PUBLIC deklariert wird.

Dieses Beispielprogramm ist eher theoretischer Natur, da das Programm so gut wie nichts anderes macht, als die Methoden aufzurufen. Trotzdem sollte bei der Auswahl des Zugriffsbezeichners dieses beachtet werden.

UML-Diagramme

Die Vererbungshierarchie kann durch grafische Diagramme dokumentiert werden. Als Standard hat sich hierbei die Unified Modeling Language (UML) durchgesetzt. UML definiert verschiedene Arten von Diagrammen, die sowohl die Struktur als auch das Verhalten von Software beschreiben.

Für das Beschreiben der Vererbungshierarchie von Funktionsblöcken eignet sich die Variante Klassendiagramm. Eine Beschreibung von UML finden Sie z.B. unter: http://home.f1.htw-berlin.de/scheibl/uml.

UML Diagramme können direkt in TwinCAT 3 erstellt werden. Änderungen am UML-Diagramm wirken sich unmittelbar auf die POUs aus. So können über das UML-Diagramm die Funktionsblöcke verändert und angepasst werden.

Picture08

Jedes Kästchen steht für einen Funktionsblock und ist immer in drei waagerechte Bereiche aufgeteilt. Im obersten Bereich ist der Name, im mittleren Bereich ist die Auflistung der Eigenschaften und im unteren Bereich sind alle Methoden aufgeführt. Die Pfeile geben in diesem Beispiel die Richtung der Vererbung an und zeigen immer auf den Basisfunktionsblock.


MSDN Team Blog AT [MS]: Emasos IQ – Die mobile Cloud ERP Lösung auf Microsoft Azure

Wie viele Geräte haben Sie auf Lager? Wann ist das Projekt abgeschlossen? Machen Sie mir ein gutes Angebot?

Kunden erwarten Antworten, sofort. Alle Antworten liefert Emasos IQ ERP, jederzeit und auf jedem Device. So lautet die Erfolgs-Rechnung: Durchgängige Geschäftsprozesse + überall verfügbare Daten + skalierbare Architektur für KMU bis Konzern + Microsoft Azure Cloud = Emasos IQ

 

Das sind die Highlights der Lösung Emasos IQ ERP

  • mobil: Ihr Büro ist überall, wo Sie sind
  • Infos schnell und in Echtzeit, aufgrund Indizierungscluster
  • Cloud-Lösung mit Marktstandard MS-Azure
  • individuelle Anpassung im Designmode oder mit releasefähigem Scripting

Emasos IQ ist eine Eigenentwicklung aus Österreich und wurde nach neuesten Methoden konzipiert. Folgende Funktionalitäten garantieren eine rasche Implementierung:

Das Bewusstsein für die Vorteile der Cloud ist mittlerweile in den Unternehmen angekommen. Emasos IQ ERP wurde daher mit der Unified Client Architecture konzipiert. Die Emasos IQ Cloud Services sind mit C# entwickelt und laufen unter Microsoft Azure. Die Lastverteilung können Sie auf mehrere Worker Roles einrichten. In den Emasos IQ Cloud Services laufen sämtliche Geschäftsprozesse ab, die benötigten Daten und Dienste werden angefordert. Bevorzugte Datenbank: Microsoft SQL Server oder Microsoft Azure SQL Datenbank, auch MySQL ist möglich.

Mehr zur Client Architekture von Emasos IQ ist hier zu finden.

 

Modernes Look and Feel mit Kachel-Design, individuell angepasst

Das Büro ist dort, wo Emasos IQ ist. Stationär auf dem Bildschirm im Büro, mobil auf Tablet und Smartphone. Die Mitarbeiter haben überall dieselbe gewohnte Oberfläche. Mehr darüber hier. Neben Standardprozessen benötigen Unternehmen oft individuell angepasste Abläufe. Das erledigen Sie einfach über

  • den leistungsstarken Designmodus: Sie gestalten Bildschirmmasken, Felder oder Listen, formatieren Zeilen oder Zellen und erstellen Suchfilter. Die Anpassungen sind sofort auf allen Geräten verfügbar.
  • Releasefähige Zusatzprogrammierungen mit Scripting und C#.
  • Dashboards gestalten Sie individuell mit Funktionsaufrufen, Schnellzugriffen und Echtzeitinformationen, genauso wie es Ihre Sachbearbeiter, Vertrieb oder Management benötigen.
  • Über das Webportal – natürlich im Corporate Design – können Sie Kunden oder Lieferanten für ausgewählte Prozesse autorisieren und einbinden.

Im Vergleich zu konventionellen Systemen erledigen Sie alle Anpassungen in kürzerer Zeit.

 

Alle Prozesse, die ein Unternehmen benötigt, sind nahtlos integriert und werden in Echtzeit abgebildet

Die Lösung Emasos IQ umfasst Warenwirtschaft,  Kundenmanagement, Dokumentenmanagement, Finanzbuchhaltung, Reports und das Controlling. Sie können Module auch einzeln schrittweise einführen. Alle Daten und Dokumenteninhalte werden Just-in-time im Emasos Indizierungs-Cluster verwaltet. Das sorgt für schnelle und konsistente Ergebnisse. Mit einer Hochgeschwindigkeits-Datenbank und ressourcenschonender Datenübertragung hat Emasos IQ eine Übertragungsrate von nur 5 kbit/sek (Durchschnitt/Benutzer).

Damit ist Emasos IQ schneller als jede andere Software.

 

Was sind die Anforderungen in Ihrem Unternehmen?

Gerne zeigen wir Ihnen die Vorteile von Emasos IQ, bezogen auf Ihren Bedarf. Vereinbaren Sie einen Termin zum Kennenlernen mit Sales Manager: Daniel Schendel

daniel.schendel@emasos.com

Emasos Enterprise Systems GmbH

Universitätsstraße 10 Top 9

1090 Wien

Lesen Sie mehr auf der Webseite von Emasos http://www.emasos.com

emasos-1

 

emasos-2

 

 

Sebastian Seidel: Extend your Xamarin.iOS app with OpenStreetMap

An important feature in the mobile area are maps capabilities. There isn't any app in the market that won't improve their value without a map. Apple and Google doing a great job with there Map-SDKs, but sometimes you hit a spot where they won't suit your needs. Maybe for legal reasons or because you hit a bug inside of them. The later was my case, which is happily resoleved with iOS 10. But I needed an alternative that works offline too.

Golo Roden: Einführung in Node.js, Folge 13: HTTPS und HTTP/2

Die Protokolle HTTPS und HTTP/2 gewinnen zunehmend an Relevanz, weil sie die übertragenen Daten verschlüsseln und die Identität des Servers verifizieren. Darüber hinaus bietet HTTP/2 einige praktische Funktionen, beispielsweise das Multiplexing von Verbindungen. Wie lassen sich die beiden Protokolle in Node.js verwenden?

MSDN Team Blog AT [MS]: Hier lernst du wie du eine Cloud-basierte Anwendung entwickeltst

Du fragst dich wie dir Cloud-App-Entwicklung helfen kann, Geschäftsprobleme zu lösen? MVPs Colin Dembovsky und Steven Borg von Northwest Cadence bieten eine hilfreiche Anleitung zu diesem Thema an. In diesem Kurs liegt der Fokus auf Azure App Entwicklung, Plattform als Service (PaaS) und DevOps auf Visual Studio Team Services.

In diesem Demo-reichen Kurs lernst du, wie Azure dazu beitragen kann, die Produktivität eines Entwickler zu steigern. Außerdem wirst du herauszufinden, wie man plattformübergreifende mobile Apps erstellt und wirst über die von Azure angebotenen Datendienste informiert. Wirf einen Blick auf Microservices und Container, erkunde die Identität als Kern der Enterprise-Mobilität. Lerne wie du eine DevOps-Pipeline einrichtest und vieles mehr in diesem praktischen Cloud-App-Entwicklungs-Tutorial.
1 | Anwendungsplattform – Plattform-as-a-Service (PaaS)
Erfahre mehr über die Vorteile der Entwicklung von Anwendungen auf der Azure-Plattform und schau dir Demos der Entwicklung von mobilen und Web-Apps.

2 | Speicher und Datenbanken
Speicher deine Daten, indem du relationale und NoSQL-Dienste auf Azure verwendest.

3 | Weitere Lösungen zur Unterstützung der App-Entwicklung
Erfahre mehr über Azure Services, die moderne Anwendungsarchitekturen ermöglichen.

4 | DevOps und Visual Studio Team Services
Schau dir Demos an, die dir zeigen, wie du eine Continuous Delivery and Continuous Integration Pipeline für die DevOps-basierte Anwendungsentwicklung erstellen kannst.

Was du lernen wirst?

  • Erfahre mehr über die Vorteile der Entwicklung von Anwendungen auf der Azure-Plattform.
  • Siehe Demos von Mobile und Web App Entwicklung an.
  • Speicher deine Daten, indem du relationale und NoSQL-Dienste auf Azure verwendest.
  • Erfahre mehr über Azure Services, die moderne Anwendungsarchitekturen ermöglicht.
  • Verwende Visual Studio Team Services, um eine Continuous Delivery and Continuous Integration Pipeline zu implementieren.

JETZT KOSTENLOS ANEMLDEN

Jürgen Gutsch: Blogging with Git Flow

Since a while we use Git Flow in our projects at the YooApps. Git Flow is a add-in for Git, that helps us to follow the feature branch process in a standard way. We usually use our Jira ticket number as names for features, bugs or hotfix and we use the Jira Version as a Release name. This makes absolutely sense to us and makes the flow pretty transparent. We also use BitBucket to host our Git repositories, which is directly linked to Jira. That means on every Pull Request we have the direct link to the Jira ticket.

Using Git Flow to release new posts

My idea is to also use Git Flow to release new blog posts.

My blog is generated by Pretzel, which is a Jekyll clone written in C#. I host it on an Azure Web Site. I write my posts in GitHub style Markdown files and push them to GitHub. Every time I push a new post, the Azure Web Site starts a new build and runs Pretzel to generate the static blog.

I already wrote some blog posts about using Pretzel

Dear hackers and bots: Because it is a static web site, it doesn't make sense to search for WordPress login pages or WordPress APIs on my blog ;)

Since almost one and a halve year now, I use Git on GitHub to publish my posts, but I only use the master branch yet and I don't commit the drafts. I sometimes write two or three post in parallel and I anyway have around ten drafts in the Pretzels _drafts folder. This feels a bit messy and I will probably loose my drafted posts, if the machine crashes.

Using Git Flow, I don't need to use the _drafts folder anymore. Every unfinished feature branch is a draft. If I finish a post, I would just need to finish the feature branch. If I want to publish the posts, I can start a new release.

Maybe the release step is a bit too much. But currently I need to push explicitly to publish a new post and it shouldn't be a big deal to also create a new release to merge all finished posts from develop to master. If it doesn't fit, it would be easy to switch to the more simple feature branches.

Let's see how it works :-)

This blog post feature branch is created by using the following commands in the console:

git flow feature start blogging-with-git-flow

Now I'm in the draft mode and will create the blog post file, writing, adding images, linking between existing posts and so on. If this is done I do a first commit and publish the feature branch to GitHub:

git add _posts/*
git add img/*
git commit -m "new post about blogging with pretzel"
git flow feature publish

At this state I can change and commit as much as I want to. If I finish the blog post, I'm going to finish the post and push the current develop branch to GitHub:

git flow feature finish
git push

The last step is publishing the posts. I currently not sure, but I could probably use the number of posts as the minor version number, which will also be used as tag for the release:

git flow release start 1.48.0
git flow release finish
git push --all
git push --tags

(I possibly should create a batch command to execute the four lines to release new posts)

After that push, Pretzel will start "baking" the blog including the new blog post.

If I want to see the current drafts, I just need to display the existing branches:

I'm sure this will be a clean way to publish and to handle the drafts and finished posts.

Versioning

While publishing the latest post like this, I realized that GitHub actually will display a release in the GitHub repository, this is quite nice. This is not really needed but a funny fact and a reason why I wanna think a little more about the version numbers, if I release a new article.

My idea is to change the Major version, if I do a huge change on the layout of the blog or if I add a new feature. Because the layout is still the first version and I only did some really small changes, I'll keep it as version 1. For the minor version I will use the number of published articles.

This doesn't really makes sense from the semver perspective, but blogging should also be fun and this really means is fun to me.

This means, with the latest post I published release 1.47.0 and this post will be in release 1.48.0 ;-)

Authoring

In the last post about writing blog posts using Pretzel, I wrote that I use MarkdownPad 2 to write my pots. Unfortunately it seems that this editor is not longer maintained, no new version was published for a while. I paid for it, to have some more extended feature to use. Anyway, a few months ago it crashes every time I opened it and there was no way to get an updated or fixed version. (I'm pretty sure it was related to the installation of CefSharp.) This is why I now use Typora, which is pretty minimalistic and lightweight. It works completely different, but in a pretty cool way. It doesn't use a splitted screen to edit and preview the content. With typora you write markdown code directly and it immediately translated it to the preview in the same editor view. It also supports custom CSS and different Markdown styles. It is real WYSIWYG.

Any thoughts about it? Feel free to drop a comment and let me know :-)

Marco Scheel: Links for 2017-03-31 [del.icio.us]

AIT: WordToTFS Release – Version 5.3 and 6.0 sim-shipped with Visual Studio 2017

We are proud to announce the new release of WordToTFS that has been sim-shipped with Visual Studio 2017. There are a lot of new features and also some bug fixes we’re going to explain in this blog post. Basically both versions have the same features, but WordToTFS 5.3 still works on the Visual Studio 2015 API while WordToTFS 6.0 is one step ahead using the Visual Studio 2017 API. Please find more details on this topic at the end of the post.

Test Specifications and Test Result Reports

Some major improvements are made in the area of test reports.

Test Result Report including Test Cases without results

With the existing functionality users can create separate test documents: Test Specifications and Test Result Reports. Due to regulatory requirements, we extended the test result reports so that not only test cases with results are exported into the document.

To explain this in detail, the following scenario is used. A very simple Test Plan contains some test suites and test cases. By creating a Test Specification with WordToTFS, the document might contain the structure shown in figure 1 – “Test Specification”. After some test cases have been executed, the Test Result Report contains those test cases, that have been executed. In the sample in figure 1, the Test Result Report would contain every test case from the Test Specification but not Test Case 3. However, there are scenarios with the requirement to also show Test Case 3 in the Test Result Report, even if it has never been run.

image

Figure 1: Test Specification and Test Result Report

Since we want to support both scenarios, a new attribute in the configuration can be used to control this behavior (see figure 2).

Figure 2: New attribute for Test Result Reports

Test Result Report includes Analysis information

It is possible to include a lot of information into the Test Result Report. Nevertheless, there is some data, that has not been that easy to export or it was even impossible. Such an area was the analysis information that can be used to document e.g. Failure Type and Resolution of a particular Test Run (see figure 3).

Figure 3: Change analysis information of a Test Run

The following excerpt of the WordToTFS configuration (see figure 4) shows what needs to be added to the WordToTFS-configuration. Especially the attribute “ResolveResolutionState”, which is yellow highlighted, is very important to get a meaningful resolution state instead of an internal id number.

Figure 4: WordToTFS Configuration for analysis information of Test Run

OLE-objects

Whenever a user integrates OLE-objects in an HTML-backed field of a work item, some magic is done behind the scene (more information on the OLE support can be found in the user guide at pp. 34-35). In some cases users want to know whether a work item contains OLE objects. There are different reasons for this desire that reach from administrative tasks to review of those objects.

Now WordToTFS can detect those embedded OLE-objects and store that information into a separate work item field. Just set the new field attribute “OLEMarkerField” to the reference name of a work item field that should store these meta information. Of course this option does only make sense, if a field is configurered for OLE objects.

Nevertheless it is worth mentioning that there are two ways to use this functionality. If a user has only one field that can contain OLE objects, also only one additional field can be used to set the marker. Which marker value should be used, can be configured as well, by the attribute OLEMarkerValue, as shown in Figure 5.

image

Figure 5: Configuration of OLEMarkerField

The other option is to use only one additional field, even if there are many fields on the work item form, that can contain OLE-objects, e.g. Description and Analysis Result or Impact Analysis. In these cases, the optional attribute OLEMarkerValue must not be used. In this case, the field name is written into the separate field, there are OLE objects in more than one field, all the field names are mentioned in the new field.

The full description of this feature and how to configure this can be found in the user guide at pp. 36-37.

Minor improvements and Bugfixes

Handling of HTML content

In some edge cases the algorithm to handle HTML content was inefficient and sometimes even wrong. Therefore we updated the algorithm that manages the data transformation of those content between Word and TFS/VSTS. By doing this, we got rid of some scenarios where even lines of longer texts were not exported into Word.

Enabling return key to find by ID

Whenever a user wants to add work items to Word by using their TFS ID, she can type the desired ID(s) into the appropriate text box. We enabled to start search by using the return key in addition to clicking the “Find”-button (see figure 6).

image

Figure 6: Get Work Items by ID

Test Results Report pane was loading infinitely – sometimes

After the generation of a Test Report has been aborted, but the document has been reused, some corrupt information was stored in the Word document. This sometimes made the Test Result Reports pane loading infinitely. This has been solved so that the pane is loaded correctly, even if a report generation has been aborted before.

Shared Steps not printed in Test Spec by Query via Commandline interface

Whenever a user wants to print Shared Steps without having its test cases as context, an appropriate work item query needs to be defined and eventually these data can be exported to Word. Nevertheless, this did not work while using WordToTFS from the Commandline interface. This has been solved.

Extended the user guide

Since WordToTFS is a very customizable tool, it is important to have a good documentation available. For this reason we have added a couple of things into the user guide. This was driven by a lot of FAQs we had the last time.

How to get it and compatibility

Anyone who has installed WordToTFS v5.x already, does not need to do anything. The auto-update functionality is going to install the new version in the next couple of days. If you want to fasten that process, feel free to manually trigger the update mechanism using the Update button from the WordToTFS Ribbon (see figure 7).

Figure 7: Update-button

Since we are sim-shipping this release with Visual Studio 2017, we also stared the new major release 6. This version is completely backed by the Visual Studio 2017 API. If you start using WordToTFS right now, this is the version you should use from the beginning.

For all others: As with every major version change in the past, we had planned to end the 5.x-support with this release, too. But we did not make it to get any important feature into that release, we wanted to have. For that reason we have planned to deliver one more update on major version 5 in the next couple of weeks, which will be definitely the the last update for version 5. This means, whenever your border conditions, regulatory requirements or other restrictions allow you to move forward to the major version 6, do not hesitate to do that to ensure further updates. WordToTFS 6.0 uses the TFS 2017 API and can connect to the same TFS versions as Visual Studio 2017. WordToTFS 5.3 is still using the TFS 2015 API and can connect to all TFS versions supported by Visual Studio 2015.

A big THANK YOU

It was a tough challenge to get this release out by today. A good time to thank all contributors, namely the team and foremost our customers that are highly engaged in getting WordToTFS even more mature. Thanks for all your questions that made us rethinking some decisions, your valuable feedback that helped us prioritizing the backlog, your time for getting hands-on-experience with preview versions, and nevertheless your funding that makes it possible to improve your favorite Microsoft Office Word integration for TFS.

MSDN Team Blog AT [MS]: Einladung zum Business Frühstück in Wien: Industry 4.0, Smart Factory und IoT

Vor nicht gar allzu langer Zeit hat mein Kollege Gewald Oberleiterner euch auf ein interessantes Event „Business Breakfast: Industrie 4.0 – Smart Factory und IoT“ in der Schweiz hingewiesen. Aufgrund der hohen Nachfrage holen wir das Business Frühstuck jetzt nach Wien. Das Event ist kostenlos und findet in unserer Microsoft Zentrale in Wien statt.

Termin

4. Mai 2017
08:30 bis 11:30 Uhr
mit anschließendem Fingerfood

Ort

Microsoft Österreich GmbH
Am-Euro-Platz 3, 1120 Wien

Karte

Themen

Lösungen und Produkte,
Use-Cases und Live-Demos,
Zusammenspiel der Produkte für ganzheitliche Lösungen, Best of breed
Austausch, Diskussion und Networking

Über die Themen wie Industrie 4.0 und Internet der Dinge wird gerade viel in Österreich diskutiert und auch die Frage wie diese in Unternehmen integriert werden können. Auch Microsoft Österreich ist vorne dabei und geht mit seiner Kampagne „Wir digitalisieren Österreich“ in die Offensive. In der Bing Suche findet ihr über 35 Millionen deutsche Artikel alleine zu dem Thema Industrie 4.0, Tendenz steigend. Obwohl gerade versucht wird diese Begriffe in jedem Zusammenhang zu erwähnen, geht es dabei im Grunde nur darum, ein Unternehmen effizienter und profitabler zu führen. Sieht man sich zum Beispiel die unzähligen Medienbrüche (Excel Tabellen, ausgedruckte Checklisten, unterschiedliche Papierformate) in Unternehmen an so kann man feststellen, dass vor allem der Arbeitsplatz eine Menge an Potential bietet Prozesse effizienter zu gestalten.

Im Rahmen dieser Veranstaltung möchten wir euch einen Querschnitt zu Themen präsentieren, die eurer Unternehmen fit für das digitale Zeitalter machen. Denn viele, wertvolle Daten die in Unternehmen oft nur als Nebenprodukt anfallen können verwendet werden um das Unternehmen profitabler zu führen. Zu unserem Event gehören interaktive Demos, kompetente Gesprächspartner und reale Anwendungsszenarien bei Kunden die für Abwechslung und Gesprächsstoff in den Pausen sorgen.

AGENDA

08:30 Uhr: Begrüßung bei Kaffee, Gebäck und Früchten

09:00 Uhr: Industry 4.0 – Microsoft Lösungen für Business und Smart Factory
Vesna Glatz, Industry Market Development Manager (Microsoft Österreich)

09:20 Uhr: Industrial IoT mit zenon und Azure – Use Cases & Live Demos
Johannes Petrowisch, Leiter Partner Management (COPA-DATA)

09:40 Uhr: Prozesse & Workflows mit FireStart – Wie Mensch und Maschine besser zusammenarbeiten
Robert Hutter, CEO und Senior Consultant (PROLOGICS)

10:00 Uhr: Kaffeepause zum Inspirationsaustausch

10:30 Uhr: Mobile Formulare mit HybridForms – Datenerfassung offline und mit echter Unterschrift
Christian Ekhart, CEO und Senior Consultant (icomedias)

10:50 Uhr: Ganzheitliche Lösungen für die intelligente Fabrik von morgen – Use Cases & Live Demo
Software-Allianz isv4industry (COPA-DATA, icomedias, PROLOGICS) – Microsoft Partner of the Year 2016

11:20 Uhr: Q&A für eure Themen

11:30 Uhr: Abschluss der Impulsvorträge und Möglichkeit zum Austausch und Vertiefen der Themen bei Fingerfood

JETZT ANMELDEN!

Wir freuen uns auf euch!
Eure Microsoft DX Österreich

Norbert Eder: C# 7: Local Functions

Die Situation kennen viele von euch: Ihr implementiert in einer Klasse eine Berechnung. Diese wird in mehrere Funktionen aufgeteilt, damit das übersichtlicher und leichter verständlich wird. Das funktioniert ganz gut, wenn jede Berechnung eine eigene Klasse erhält. Manchmal enthält sie jedoch mehrere davon (was in manchen Fällen durchaus sinnvoll sein kann). Für diesen Fall wurden Local Functions geschaffen.

Mit Hilfe der Local Functions kann ich eine Funktion im Kontext einer anderen Methode erstellen. Damit hat sie eine eindeutige Zugehörigkeit und ist in diesem Kontext leichter zu verstehen. Sinnvoll ist dies jedoch nur dann, wenn diese Function nur für eine aufrufende Stelle benötigt wird.

Bis jetzt kennen wir solche Konstrukte:

public int Calculate(int x, int y, int count)
{
    var sum = 0;
    for (int i = 0; i < count; i++)
    {
        sum += ComplexCalculation(x, y);
    }
    return sum;
}

private int ComplexCalculation(int x, int y)
{
    return x + y;
}

Unter Verwendung einer Local Function sieht das so aus:

public static int LocalCalculation(int x, int y, int count)
{
    var sum = 0;
    for (int i = 0; i < count; i++)
    {
        sum += LocalComplexCalculation(x, y);
    }
    return sum;

    int LocalComplexCalculation(int a, int b)
    {
        return a + b;
    }
}

Es wird sichergestellt, dass die Local Function nur aus der umliegenden Methode aufgerufen werden kann. Eine versehentliche Verwendung aus einem anderen Bereich der Klasse ist nicht möglich. Auf Methoden-Variablen kann aus einer Local Function heraus zugegriffen werden. Auch werden mehrere Local Functions innerhalb eines Kontextes unterstützt.

Eine async-Unterstützung ist gegeben.

Generell stehe ich dieser neuen Funktionalität etwas skeptisch gegenüber. Sie sollte eher vorsichtig eingesetzt werden, da bei wirklich komplexen Vorgängen Methoden schnell übersichtlich werden und somit genau das Gegenteil erreicht wird. Dennoch: Viel Spaß bei der Verwendung.

The post C# 7: Local Functions appeared first on Norbert Eder.

AIT: New release of TFS ASAP for TFS 2017 Update 1

We are proud to present the new release of our TFS Automated Servicing and Administration Platform (TFS ASAP). This version supports update 1 of Microsoft Team Foundation Server 2017. The release includes two important bug fixes and a slightly different set of preconfigured automations.

First of all, automations added to the configuration file are no longer activated by default in every project. So if a new automation was configured it must now be enabled in every project where it should be used. To make sure you have the correct automations enabled, please check your projects in case of an TFS upgrade.The second bug fix covers the Suspect Links Automation. In previous releases the field type HTML could not be monitored. We removed this restriction and it is now possible to detect changes in every field and respond to that change by setting the Suspected field in linked work items.

To simplify the start for new TFS ASAP users we reduced the number of preconfigured automations. None of these automations require changes to the process template or any adjustments in the configuration file.

image

Automation types for preconfigured automations

The installer (Build 15.1.17089.2) can be downloaded here. For further information please visit www.tfsasap.com. If you don’t have a license key, you can request a trial at support@tfsasap.com.

Marco Scheel: Links for 2017-03-30 [del.icio.us]

Jürgen Gutsch: Using xUnit, MSTest or NUnit to test .NET Core libraries

MSTest was just announced to be open sourced, but was already moved to .NET Core some months ago. It seems it makes sense to write another blog post about unit testing .NET Core applications and .NET Standard libraries using .NET Core tools.

In this post I'm going to use the dotnet CLI and Visual Studio Code completely. Feel free to use Visual Studio 2017 instead, if you want to and if you don't like to use the console. Visual Studio 2017 is using the same dotnet CLI and almost the same commands in the background.

Setup the system under test

Our SUT is a pretty complex class, that helps us a lot to do some basic math operation. This class will be a part of a super awesome library:

namespace SuperAwesomeLibrary
{
  public class MathTools
  {
    public decimal Add(decimal a, decimal b) =>  a + b;
    public decimal Substr(decimal a, decimal b) => a - b;
    public decimal Multiply(decimal a, decimal b) => a * b;
    public decimal Divide(decimal a, decimal b) => a / b;
  }
}

I'm going to add this class to the "SuperAwesomeLibrary" and a solution I recently added like this:

mkdir unit-tests & cd unit-tests
dotnet new sln -n SuperAwesomeLibrary
mkdir SuperAwesomeLibrary & cd SuperAwesomeLibrary
dotnet new classlib
cd ..
dotnet sln add SuperAwesomeLibrary\SuperAwesomeLibrary.csproj

The cool thing about the dotnet CLI is, that you are really able to create Visual Studio solutions (line 2). This wasn't possible with the previous versions. The result is a Visual Studio and MSBuild compatible solution and you can use and build it like any other solution in your continuous integration environment. Line 5 creates a new library, which will be added to the solution in line 7.

After this is done, the following commands will complete the setup, by restoring the NuGet packages and building the solution:

dotnet restore
dotnet build

Adding xUnit tests

The dotnet CLI directly supports to add XUnit tests:

mkdir SuperAwesomeLibrary.Xunit & cd SuperAwesomeLibrary.Xunit
dotnet new xunit
dotnet add reference ..\SuperAwesomeLibrary\SuperAwesomeLibrary.csproj
cd ..
dotnet sln add SuperAwesomeLibrary.Xunit\SuperAwesomeLibrary.Xunit.csproj

This commands are creating the new xUnit test project, adding a reference to the SuperAwesomeLibrary and adding the test project to the solution.

If this was done, I created the xUnit tests for our MathHelper using VSCode:

public class MathToolsTests
{
  [Fact]
  public void AddTest() 
  {
    var sut = new MathTools();
    var result = sut.Add(1M, 2M);
    Assert.True(3M == result);
  }
  [Fact]
  public void SubstrTest() 
  {
    var sut = new MathTools();
    var result = sut.Substr(2M, 1M);
    Assert.True(1M == result);
  }
  [Fact]
  public void MultiplyTest() 
  {
    var sut = new MathTools();
    var result = sut.Multiply(2M, 1M);
    Assert.True(2M == result);
  }
  [Fact]
  public void DivideTest() 
  {
    var sut = new MathTools();
    var result = sut.Divide(2M, 2M);
    Assert.True(1M == result);
  }
}

This should work and you need to call your very best dotnet CLI friends again:

dotnet restore
dotnet build

The cool thing about this commands is, it works in your solution directory and restores the packages of all your solution and it builds all your projects in your solution. You don't need to go threw all of your projects separately.

But if you want to run your tests, you need to call the library or the project directly, if you are not in the project folder:

dotnet test SuperAwesomeLibrary.Xunit\SuperAwesomeLibrary.Xunit.csproj

If you are in the test project folder just call dotnet test without the project file.

This command will run all your unit tests in your project.

Adding MSTest tests

Adding a test library for MSTest works the same way:

mkdir SuperAwesomeLibrary.MsTest & cd SuperAwesomeLibrary.MsTest
dotnet new mstest
dotnet add reference ..\SuperAwesomeLibrary\SuperAwesomeLibrary.csproj
cd ..
dotnet sln add SuperAwesomeLibrary.MsTest\SuperAwesomeLibrary.MsTest.csproj

Event the test class looks almost the same:

[TestClass]
public class MathToolsTests
{
  [TestMethod]
  public void AddTest()
  {
    var sut = new MathTools();
    var result = sut.Add(1M, 2M);
    Assert.IsTrue(3M == result);
  }
  [TestMethod]
  public void SubstrTest()
  {
    var sut = new MathTools();
    var result = sut.Substr(2M, 1M);
    Assert.IsTrue(1M == result);
  }
  [TestMethod]
  public void MultiplyTest()
  {
    var sut = new MathTools();
    var result = sut.Multiply(2M, 1M);
    Assert.IsTrue(2M == result);
  }
  [TestMethod]
  public void DivideTest()
  {
    var sut = new MathTools();
    var result = sut.Divide(2M, 2M);
    Assert.IsTrue(1M == result);
  }
}

And again our favorite commands:

dotnet restore
dotnet build

The command dotnet restore will fail in offline mode, because MSTest is not delivered with the runtime and the default NuGet packages, but xUnit is. This means, it needs to fetch the latest packages from NuGet.org. Kinda weird, isn't it?

The last task to do, is to run the unit tests:

dotnet test SuperAwesomeLibrary.MsTest\SuperAwesomeLibrary.MsTest.csproj

This doesn't really look hard.

What about Nunit?

Unfortunately there is no default template for a Nunit test projects. I really like Nunit and I used it for years. It is anyway possible to use NUnit with .NET Core, but you need to do some things manually. The first steps seem to be pretty similar to the other examples, except we create a console application and add the NUnit dependencies manually:

mkdir SuperAwesomeLibrary.Nunit & cd SuperAwesomeLibrary.Nunit
dotnet new console
dotnet add package Nunit
dotnet add package NUnitLite
dotnet add reference ..\SuperAwesomeLibrary\SuperAwesomeLibrary.csproj
cd ..

The reason why we need to create a console application is, that there is not yet a runner for visual studio available for NUnit. This also means dotnet test will not work. The NUnit Devs are working on it, but this seems to need some more time. Anyway, there is an option to use NUnitLite to create a self executing test library.

We need to use NUnitLight and to change the static void Main to a static int Main:

static int Main(string[] args)
{
  var typeInfo = typeof(Program).GetTypeInfo();
  return new AutoRun(typeInfo.Assembly).Execute(args);
}

This lines automatically executes all TestClasses in the current assembly. It also passes the NUnit arguments to NUnitLite, to e. g. setup the output log file, etc.

Let's add a NUnit test class:

[TestClass]
public class MathToolsTests
{
  [Test]
  public void AddTest() 
  {
    var sut = new MathTools();
    var result = sut.Add(1M, 2M);
    Assert.That(result, Is.EqualTo(3M));
  }
  [Test]
  public void SubstrTest() 
  {
    var sut = new MathTools();
    var result = sut.Substr(2M, 1M);
    Assert.That(result, Is.EqualTo(1M));
  }
  [Test]
  public void MultiplyTest() 
  {
    var sut = new MathTools();
    var result = sut.Multiply(2M, 1M);
    Assert.That(result, Is.EqualTo(2M));
  }
  [Test]
  public void DivideTest() 
  {
    var sut = new MathTools();
    var result = sut.Divide(2M, 2M);
    Assert.That(result, Is.EqualTo(1M));
  }
}

Finally we need to run the tests. But this time we cannot use dotnet test.

dotnet restore
dotnet build
dotnet run -p SuperAwesomeLibrary.Nunit\SuperAwesomeLibrary.Nunit.csproj

Because it is a console application, we need to use dotnet run to execute the app and the NUnitLite test runner.

What about mocking?

Currently creating mocking frameworks is a little bit difficult using .NET Standard, because there is a lot of reflection needed, which is not completely implemented in .NET Core or even .NET Standard.

My Favorite tool Moq is anyway available for .NET Standard 1.3, which means it should work here. Let's see how it works.

Lets assume we have a PersonService in the SuperAwesomeLibrary that uses a IPersonRepository to fetch Persons from a data storage:

using System;
using System.Collections.Generic;

public class PersonService
{
  private readonly IPersonRepository _personRepository;

  public PersonService(IPersonRepository personRepository)
  {
    _personRepository = personRepository;
  }

  public IEnumerable<Person> GetAllPersons()
  {
    return _personRepository.FetchAllPersons();
  }
}

public interface IPersonRepository
{
  IEnumerable<Person> FetchAllPersons();
}

public class Person
{
  public string Firstname { get; set; }
  public string Lastname { get; set; }
  public DateTime DateOfBirth { get; set; }
}

After building the library, I move to the NUnit test project to add Moq and GenFu.

cd SuperAwesomeLibrary.Nunit
dotnet add package moq
dotnet add package genfu
dotnet restore

GenFu is a really great library to create the test data for unit tests or demos. I really like this library and use it a lot.

Now we need to write the actual test using this tools. This test doesn't really makes sense, but it shows how Moq works:

using System;
using System.Linq;
using NUnit.Framework;
using SuperAwesomeLibrary;
using GenFu;
using Moq;

namespace SuperAwesomeLibrary.Xunit
{
  [TestFixture]
  public class PersonServiceTest
  {
    [Test]
    public void GetAllPersons() 
    {
      var persons = A.ListOf<Person>(10); // generating test data using GenFu
      
      var repo = new Mock<IPersonRepository>();
      repo.Setup(x => x.GetAllPersons()).Returns(persons);

      var sut = new PersonService(repo.Object);
      var actual = sut.GetAllPersons();

      Assert.That(actual.Count(), Is.EqualTo(10));
    }
  }
}

As you can see the, Moq works the same was in .NET Core as in the full .NET Framework.

Now let's start the NUnit tests again:

dotnet build
dotnet run

Et voilà:

Conclusion

Running unit tests within .NET Core isn't really a big deal and it is really a good thing that it is working with different unit testing frameworks. You have the choice to use your favorite tools. It would be nice to have the same choice even with the mocking frameworks.

In one of the next post I'll write about unit testing a ASP.NET Core application. Which includes testing MiddleWares, Controllers, Filters and View Components.

You can play around with the code samples on GitHub: https://github.com/juergengutsch/dotnetcore-unit-test-samples/

Holger Schwichtenberg: 2. Magdebuger Developer Days am 10. und 11. Mai 2017

In diesem Jahr findet die Community-Konferenz für Softwareentwickler im Bereich .NET, Java und JavaScript zweitägig statt.

MSDN Team Blog AT [MS]: MVA: Ausgangspunkte

Die Anzahl der Kurse die auf MVA (mva.microsoft.com) angeboten werden kann sicher erschlagend wirken. Daher haben wir uns gedacht wir geben euch verschiede Ausgangspunkte je nach Rolle. natürlich kannst du auch in jeder anderer Kategorie auch schnuppern.

Mobile- und Webentwickler

Mobile- und Webentwickler

 

Erkunde eine breite Palette an Schulungen zur App- und Mobile-Entwicklung, von C# und XAML bis hin zu plattformübergreifenden Apps mit Xamarin. Zudem lerne Tools wie MVC, AngularJS und Bootstrap sowie Techniken zum Erstellen von reaktionsfähigen, zuverlässigen Webanwendungen kennen.

Schnellstart: Erstellen von Apps für Windows Phone 8.1Schnellstart: Erstellen von Apps für Windows Phone 8.1

Einführung in ASP.NET MVCEinführung in ASP.NET MVC

Entwickeln in HTML5 mit JavaScript und CSS3 – SchnellstartEntwickeln in HTML5 mit JavaScript und CSS3 –

Spieleentwickler

Spieleentwickler

Erkunde eine breite Palette an Schulungen zur App- und Mobile-Entwicklung, von C# und XAML bis hin zu plattformübergreifenden Apps mit Xamarin. Zudem lerne Tools wie MVC, AngularJS und Bootstrap sowie Techniken zum Erstellen von reaktionsfähigen, zuverlässigen Webanwendungen kennen.

Schnellstart: Erstellen von Apps für Windows Phone 8.1Schnellstart: Erstellen von Apps für Windows Phone 8.1

Einführung in ASP.NET MVCEinführung in ASP.NET MVC

Entwickeln in HTML5 mit JavaScript und CSS3 – SchnellstartEntwickeln in HTML5

Netzwerk, Infrastruktur und Cloud Engineers

Netzwerk, Infrastruktur und Cloud Engineers

Entdecke die kostenlosen Online-Kurse für Spieleentwickler. Verwenden Sie Tools wie Construct2, GameMaker und Unity zum Entwickeln von 2D- und 3D-Spielen für Anfänger und Fortgeschrittene. Oder werfe einen detaillierten Blick auf C++ und Direct X, um deine Fähigkeiten in den Bereichen Blending, Animationen, Skyboxen etc. zu verbessern!

Schnellstart: Einführung in die Spieleentwicklung mit C++ und DirectXSchnellstart: Einführung in die Spieleentwicklung mit C++ und DirectX

2D- und 3D-Spiele mit Unity für Windows – Schnellstart2D- und 3D-Spiele mit Unity für Windows – Schnellstart

Einführung in WebGL 3D mit HTML5 und Babylon.jsEinführung in WebGL 3D mit HTML5 und Babylon.js

Datenbankadministratoren, Architekten und Entwickler

Datenbankadministratoren, Architekten und Entwickler

Absolviere die benötigte Schulung für Windows Server 2012 R2, PowerShell oder Active Directory. Lerne, wie du dein Rechenzentrum in der Cloud erweiterst, um die Flexibilität zu steigern. Und finde heraus, wie du Lösungen zur Identitäts- und Zugriffsverwaltung auf verschiedenen Geräten implementierst.

Windows Server 2012 R2 EssentialsWindows Server 2012 R2 Essentials

Servervirtualisierung mit Windows Server Hyper-V und System CenterServervirtualisierung mit Windows Server Hyper-V und System Center

Erste Schritte mit PowerShell 3.0 – SchnellstartErste Schritte mit

Studenten, die an einer Karriere im Technologiesektor interessiert sindStudenten, die an einer Karriere im Technologiesektor interessiert sind

Planen Sie Ihre Karriere! Dies ist ein guter Anfang. Egal ob Sie an App-Entwicklung, Grundlagen zu Datenbanken, IT-Verwaltung oder allen Bereichen interessiert sind, die MVA-Technologieschulungen für Anfänger bieten die Grundlagen, Einstiegshilfen und erforderlichen Informationen, um die benötigten Fähigkeiten zu erwerben.

C#-Grundlagen für AnfängerC#-Grundlagen für Anfänger

Grundlagen zur SicherheitGrundlagen zur Sicherheit

DatenbankgrundlagenDatenbankgrundlagen

Marco Scheel: Links for 2017-03-29 [del.icio.us]

MSDN Team Blog AT [MS]: Für Teams mit hohen Ansprüchen an Qualität und Skalierbarkeit: Visual Studio Enterprise

image

image

 Enterprise DevOps

DevOps für Unternehmen

Schnelleres Ausliefern von besserer Software

Agile-Tools, die für den Unternehmenseinsatz optimiert sind, helfen Ihnen, Aufgaben projekt- und teamübergreifend zu verwalten, und das in einer intuitiven und leicht zu bedienenden Umgebung. Die DevOps-Funktionen in Visual Studio 2017 ermöglichen die Automatisierung von Releaseprozessen und Continuous Deployment. Schließen Sie nach der Bereitstellung die Lücke zwischen Produktion und Entwicklung, und beheben Sie Programmfehler schneller dank Einblicken und Daten, die Sie direkt in der Produktionsumgebung sammeln.

 

 

Now with Xamarin5-Sterne-Entwicklung von mobilen Apps

Liefern Sie Apps auf Unternehmensniveau

Visual Studio Enterprise schließt jetzt Xamarin-Entwicklung von Android-, iOS- und Windows-Apps ein. Erstellen Sie mit erstklassigen Tools Apps mit nativer Leistung und Benutzeroberfläche. Optimieren Sie die Leistung Ihrer Apps mithilfe umfassender Daten zur Profilerstellung, und untersuchen Sie sie zur Laufzeit, um Programmfehler schneller zu finden. Überprüfen Sie Ihre Benutzerfreundlichkeit auf realen Geräten mit der Xamarin Test Cloud. Wenn Sie soweit sind, verteilen Sie Ihre Apps an interne Betatester oder direkt an einen App Store.
Weitere Informationen

 

No more “no repro”

Reproduktion von Fehlern jetzt immer möglich

Drehen Sie die Zeit zurück dank des Ausführungsverlaufs für .NET-Code

Eins der häufigsten Probleme, mit denen sich Entwickler konfrontiert sehen, ist dass der Code auf „meinem Computer“ funktioniert, aber nicht in der Test- oder Produktionsumgebung. Die Diagnose solcher Probleme kann Stunden der Suche im Quellcode, des Vergleichens von Umgebungen und ein fortgesetztes Ratespiel über das Setzen der richtigen Haltepunkte mit sich bringen. Mithilfe der Diagnosetools in Visual Studio Enterprise, wie IntelliTrace, können Sie den Verlauf Ihrer Codeausführung in verschiedenen Umgebungen anzeigen und in der Zeit zurück navigieren, um Daten zu untersuchen, ohne manuell Haltepunkte setzen zu müssen. Das spart Ihnen eine Menge Zeit, die Sie produktiver investieren können.
Weitere Informationen

 

Higher-quality code

Code von höherer Qualität

Es geht um Komponententests – jetzt schneller und einfacher

Mithilfe von IntelliTest generieren Sie schnell relevante Komponententests für Ihren Code – automatisch. IntelliTest verringert den Aufwand zum Erstellen von Komponententests sowohl für neuen als auch für vorhandenen Code dramatisch, sodass Sie sich auf die Entwicklung von Funktionen konzentrieren können. Erstellen Sie ganz einfach Komponententestsätze für Legacycode, der noch nie untersucht wurde, und steigern Sie Pfadabdeckung und Codequalität – mit minimalem Aufwand.
Weitere Informationen

 

Manage complexity

Verwaltete Komplexität

Behalten Sie leicht selbst in den größten Projektmappen den Überblick

Verwenden Sie innovative Tools zur Modellierung, und erstellen Sie hochwertige, unternehmenswichtige Software, die den Motor Ihres Geschäfts bilden kann. Verwalten Sie auf einfache Weise Abhängigkeiten und selbst größte Codebasen mit Tools für Code Mapping und Architektursuche. Verwenden Sie erweiterte Tools zum Überwachen und Debuggen, um komplexe Anwendungsprobleme schneller denn je zu identifizieren, zu sichten und zu beheben.

 

Unlimited load testing

Uneingeschränkte Auslastungstests

Verstehen Sie vor der Bereitstellung, was Ihre Anwendung leisten kann

Mit Visual Studio wird es einfach, Auslastungstests in Ihren Entwicklungsprozess zu integrieren, was Ihnen unangenehme Überraschungen in der Produktion erspart. Ob diese Überraschungen ihren Grund in der weltweiten Verbreitung haben, der Größe Ihrer Kundenbasis oder in Problemen, die sich nur bei mehrtägiger Ausführung zeigen, die Auslastungstests in Visual Studio geben Ihnen die Analysemöglichkeiten, um diese Probleme vor der Bereitstellung zu beheben.
Weitere Informationen

 

Database DevOps

Datenbank-DevOps

Weiten Sie DevOps-Prozesse auf SQL Server-Datenbanken aus

Redgate Data Tools sind jetzt in Visual Studio Enterprise enthalten. Mit ReadyRoll Core können Sie Bereitstellungen von Datenbankänderungen Seite an Seite mit Anwendungsänderungen entwickeln, ihre Version verwalten und sie sicher automatisieren. Redgate SQL Prompt Core hilft Ihnen, SQL-Code mühelos in Visual Studio zu erstellen. Steigern Sie ihre Produktivität mit Auto Vervollständigen für Datenbank- und Systemobjekte sowie Schlüsselwörter, und nutzen Sie Spaltenvorschläge bei der Eingabe.

 

Continuous LearningFortgesetztes Lernen

Lernen und experimentieren Sie mit Technologie auf neuestem Stand

Mit einem Visual Studio Enterprise-Abonnement erhalten Sie Zugriff auf Schulungs- und Learningvorteile, die Ihnen helfen, bei den neuesten Technologien auf dem Laufenden zu bleiben und fortgesetztes Lernen zu verwirklichen. Darüber hinaus können Sie mit der enthaltenen Software für Entwicklung und Tests und Azure-Vorteilen Cloudumgebungen einrichten und mit den neuesten Microsoft-Produkten und Clouddiensten ohne zusätzliche Kosten experimentieren. Das ist Lernen auf einem neuen Niveau!

 

 

 

Subscriber benefits

Leistungen im Abonnement

Umfasst alles, was ein Entwickler benötigt

Mit einem Visual Studio Enterprise-Abonnement erhalten Sie Zugriff auf Schulungs- und Learningvorteile, einschließlich Vollzugriff auf Pluralsight, die Ihnen helfen, bei den neuesten Technologien auf dem Laufenden zu bleiben und fortgesetztes Lernen zu verwirklichen. Darüber hinaus können Sie mit der enthaltenen Software für Entwicklung und Tests, technischem Support und Azure-Vorteilen Cloudumgebungen einrichten und mit den neuesten Microsoft-Produkten und Clouddiensten ohne zusätzliche Kosten experimentieren. Das ist Entwickeln auf einem neuen Niveau!
Weitere Informationen

Golo Roden: Callbacks + Promises: Es ist kompliziert

Dank async und await erleben Promises in der JavaScript-Welt derzeit einen neuen Aufschwung. Zahlreiche Module wollen von Callbacks auf die neue API umgestellt werden. Während des Übergangs gilt es jedoch einige Fallstricke zu vermeiden.

Norbert Eder: 3 Tipps für ein positives Umfeld

Es gibt so viele Gründe, warum eine Projektumsetzung oder eine Produktentwicklung scheitern kann. Immer hat es allerdings mit Menschen zu tun. Damit sich Menschen entfalten und etwas Tolles erschaffen können, ist ein positives Umfeld notwendig. Mit diesem Beitrag möchte ich dir drei absolut hilfreiche Tipps mit auf deinen Weg geben.

Herausforderung statt Problem

Ich beobachte sehr häufig, dass viel Zeit aufgewandt wird, von Problemen zu sprechen und diese ausführlich zu diskutieren. Lösungen sind dabei oft nebensächlich. Frustabbau oder -bewältigung steht im Vordergrund. Tatsächlich saugt uns dieses Vorgehen unheimlich viel Energie ab. Energie, die wir sehr viel besser und zielorientierter einsetzen könnten.

Wenn wir von einem „Problem“ oder „Hindernis“ sprechen, dann haftet dem nicht nur etwas Negatives an, sondern wir suggerieren damit auch ein hohes Maß an Unüberwindbarkeit. Das senkt unsere Motivation und damit die Erfolgschancen. Und Hand aufs Herz: Wer will an einem erfolglosen Projekt mitarbeiten?

Wir müssen uns also ändern! Lassen wir Probleme links liegen und widmen wir uns Herausforderungen, Möglichkeiten zur Weiterentwicklung, dem Sammeln von Erfahrung. Das erzeugt einen ganz neuen Spirit und so ganz nebenbei, fällt uns die herausfordernde Tätigkeit viel leichter.

Damit sage ich nicht, Tatsachen zu ignorieren. Ich spreche davon, den Herausforderungen ins Auge zu blicken und auch, wenn man weiß, dass es keinen Spaß machen wird, das Positive daran zu erkennen. Bewegt man sich in einem Team, dann empfiehlt es sich, dies zu kommunizieren. Dadurch kann eine möglicherweise negative Perspektive verändert und in ein positives Licht gerückt werden. Die Herausforderungen lassen sich so besser und einfacher meistern.

Der Schlüssel ist also lösungsorientiert, statt problemorientiert zu sein. Das kann man getrost auf alle Bereiche des Lebens beziehen.

Gegenseitige Unterstützung

Was fällt mir sofort ein, wenn ich an richtig gut laufende Projekte denke? Alle haben zusammen angepackt. Es gab keine Streitereien, kein Zuschieben einer Schuld. Jeder fand es cool daran zu arbeiten und hat die anderen angespornt, motiviert. Wie das? Indem alle paar Tage jemand mit einer neuen Idee, einer coolen Lösung oder einem Prototypen um die Ecke gelaufen kam und das erlangte Wissen mit allen geteilt hat.

Wer Wissen teilt, lernt schneller.

Wenn jeder vor sich hin arbeitet und seine Themen mit niemanden teilt, dann dauert es erfahrungsgemäß länger, Lösungen zu komplexen Aufgabenstellungen zu finden. Ein Team bringt mehr Erfahrung mit sich als ein Einzelner. Warum also diese Kapazität nicht nutzen?

Durch diese gegenseitige Unterstützung und die gemeinschaftliche Arbeit an einer Sache, wird Wissen viel besser verteilt. Das ist nicht nur nachhaltig, sondern verhilft allen zu schnelleren Schritten. Anstatt sich etwas mühsam selbst aneignen zu müssen, wird Know how direkt vermittelt. Erfahrung inklusive. Ergo nochmals: Warum nicht nutzen?

Was aber, wenn nicht jeder diese Idee unterstützt? Klassische Einzelkämpfer?

Zum Ziel kann hier ein positives Vorleben führen. Aufrichtiges Helfen, Vermitteln von Zusatzinformationen, Erkennen und Befreien von Ängsten. All das kann andere Menschen positiv beeinflussen und zu einem weit konstruktiveren Umfeld führen. Hilft dies alles nichts, führt eventuell eine andere Zusammensetzung der Teams zum Erfolg. Gibt es nur ein Team und kommt es zu keinen Verbesserungen, dann könnte eine größere Veränderung angedacht werden.

Gemeinsames Ziel definieren

Wer weiß, warum er etwas macht und dies auch für gut befindet, der wird sich auch darum kümmern, dass es gut wird. Es muss eine gemeinsame Triebfeder geschaffen werden. Etwas, womit sich jeder identifizieren kann. Etwas, wohin jeder gelangen möchte.

Manchmal mag dies aufgrund einer bereits etablierten negativen Stimmung recht schwierig erscheinen. Vielleicht fehlt den Beteiligten auch ein möglicher Ausweg aus der Miesere. In diesem Fall ist Unterstützung angesagt. Ein gemeinsames Erarbeiten eines möglichen Lösungsweges kann zum Ziel führen. Zu beachten ist, dass dieser Weg realistisch ist und mögliche Stolpersteine auch tatsächlich ausgeräumt werden können.

Unbelastete Menschen können einfache Lösungswege bieten

Vielleicht hast du eine entsprechende Erfahrung bereits gemacht. Gerade wenn man tief in einem Thema drinnen ist und vor lauter Wald die Bäume nicht mehr sieht, sind Lösungen oft schwer zu finden. Hier lohnt es sich, „problemfremde“ Personen hinzuzuziehen um unbelastete Ansätze und Meinungen zu erhalten. Ist die Situation sehr verfahren, sollte über das Hinzuziehen eines Beraters, oder Mediators nachgedacht werden.

Fazit

Projekte scheitern neben Fehlern im Projektmanagement vielfach auch an unmotivierten Teams, persönlichen Problemen und fehlender Unterstützung. Im Endeffekt gibt es einige wenige Punkte mit denen eine klare Verbesserung herbeigeführt werden kann:

  1. Negative Formulierungen/Diskussionen verhindern
  2. Aktive gegenseitige Unterstützung und Förderung
  3. Schaffung eines gemeinsamen Ziels

Mit diesen Tipps kann wirklich viel bewegt werden. Vielleicht kannst auch du aus deiner Erfahrung berichten. Wie hast du dir ein positives Umfeld aufgebaut?

The post 3 Tipps für ein positives Umfeld appeared first on Norbert Eder.

MSDN Team Blog AT [MS]: Wir stellen vor: HockeyApp

image

Rufe Berichte zu Abstürzen ab

Niemand möchte, dass seine App abstürzt. Wenn es doch einmal passiert, bist du darauf angewiesen, schnell auf detaillierte Berichte und Informationen zum Absturz zugreifen zu können. HockeyApp erstellt Debugsymbole und gruppiert Abstürze, damit du deren Häufigkeit problemlos erkennen und deinen Backlog priorisieren kannst. Außerdem kannst du die Berichte zu Abstürzen für eine zentrale Verwaltung all deiner Arbeitselemente in deiner vorhandenen ALM-Tools (Application Lifecycle Management) integrieren.

Weitere Informationen zu Absturzberichten

 

Benutzermetriken nachverfolgen

Untersuche das Benutzerverhalten, um deine App zu verbessern. Verfolge die Nutzung anhand täglich und monatlich aktiver Benutzer nach. Überwache Benutzer, bei denen Abstürze aufgetreten sind. Ermittel die Sitzungsanzahl, um die Kundenbindung auszuwerten.

Weitere Informationen zu Nutzungsmetriken

 

Erfasse In-App-Feedback

Die Meinung deiner Benutzer ist für dich entscheidend. Mit HockeyApp kannst du direkt in der App Feedback sammeln und an dein Entwicklungsteam weiterleiten. Und da das Feedback in Form von Diskussionen erfasst wird, kannst du Benutzer direkt ansprechen, um sich umfassend über deren Bedürfnisse und Anforderungen im Zusammenhang mit deiner App zu informieren.

Weitere Informationen zum Erfassen von Feedback

 

 

Verteile deine Apps

Du kannst dir HockeyApp als deinen internen App-Store zu Testzwecken vorstellen. Diese bietet all deine Apps zentral für die Installation durch Betatester und Benutzer an, und fordert die Benutzer bei Bedarf auf, ein Update auf eine bestimmte Version durchzuführen. Integriere die HockeyApp in deinen fortlaufenden Erstellungsprozess, um das Hochladen und Verteilen zu automatisieren, während du gleichzeitig sicherstellst, dass die aktuelle Version deiner App umgehend verfügbar ist.

Weitere Informationen zur App-Verteilung

 

Vollständige Betatestabdeckung

Stell sicher, dass deine Apps auf den Plattformen getestet werden, die dir wichtig sind, und profitiere von Einblicken in die Betatestabdeckung: welche Geräte wurden verwendet, welche Sprachen wurden getestet, und wie lange haben die Tester die App genutzt? Außerdem kannst du eine dedizierte Seite erstellen, um weitere Benutzer auf die Betaversion deine App aufmerksam zu machen, wenn du die Testabdeckung erweitern musst.

Weitere Informationen zur Testabdeckung

 

 

Sorge für ein mobiles DevOps-Erlebnis

Für ein optimales mobiles DevOps-Erlebnis wird HockeyApp mit deiner Umgebung skaliert und integriert. Um das Potenzial deiner Toolkette maximal auszuschöpfen, legt HockeyApp Webhooks und eine offene API offen. Außerdem werden Arbeitselemente zu deinen ALM-Tools hinzugefügt. Wenn du Continuous Integration nutzet, automatisiert HockeyApp deine Erstellung und Verteilung mobiler Apps zudem mit der HockeyApp-Erweiterung für Visual Studio Team Services.

Informationen zu Mobile DevOps

Marco Scheel: Links for 2017-03-28 [del.icio.us]

Marco Scheel: Links for 2017-03-27 [del.icio.us]

Code-Inside Blog: How we moved to Visual Studio 2017

x

Visual Studio 2017 has arrived and because of .NET Core and other goodies we wanted to switch fast to the newest release with our product OneOffixx.

Company & Product Environment

In our solution we use some VC++ projects (just for Office Development & building a .NET shim), Windows Installer XML & many C# projects for desktop or ASP.NET stuff.

Our builds are scripted with CAKE (see here for some more blogposts about [CAKE}(https://blog.codeinside.eu/2017/02/13/create-nuget-packages-with-cake/) and us the TFS vNext Build to orchestrate everything.

Step 1: Update the Development Workstations

The first step was to update my local dev enviroment and install Visual Studio 2017.

After the installation I started VS and opened our solution and because we have some WIX projects we needed the most recent Wix 3.11 toolset & the VS 2017 extension.

Step 2: VC++ update

We wanted a clean VS 2017 enviroment, so we decided to use the most recent VC++ 2017 runtime for our VC++ projects.

Step 3: project update

In the past we had some issues that MSBuild used the wrong MSBuild version. Maybe this step is not needed, but we pointed all .csproj files to the newest MSBuild ToolVersion 15.0.

Step 4: CAKE update

The last step was to update the CAKE.exe (which is controlled by us and not automatically downloaded via a build script) to 0.18.

Step 5: Minor build script changes

We needed to adjust some paths (e.g. to the Windows SDK for signtool.exe) and ensure that we are using the most recent MSBuild.exe.

Step 6: Create a new Build-Agent

We decided to create a new TFS Build-Agent and do the usual build agent installation, imported the code-cert and do some magic because of some C++/COM-magic (don’t ask… COM sucks.)

Recap

Besides the C++/COM/magic issue (see above) the migration was pretty easy and now our team works with Visual Studio 2017.

Golo Roden: Einführung in Node.js, Folge 12: Unit-Tests schreiben

Für das Erreichen einer hohen Codequalität sind Unit-Tests nahezu unverzichtbar. Zum Schreiben und Ausführen der Tests stehen verschiedene Frameworks zur Auswahl, unter anderem Mocha. Wie funktioniert es?

Norbert Eder: C# 7: Literale

Mit C# 7.0 können numerische und binäre Literale lesefreundlicher dargestellt werden. Dies wird durch die Unterstützung von _ als Trennzeichen innerhalb des Literals erreicht.

Der eigentliche Wert bleibt dadurch unverändert.

Beispiele:

var foo = 1_345.01; // 1345,01
var bar = 0b1111_1100_1010_0000; // 61603

Viel Spaß und mehr Übersichtlichkeit beim Verwenden.

The post C# 7: Literale appeared first on Norbert Eder.

Marco Scheel: Links for 2017-03-26 [del.icio.us]

  • New employee quick start guide - Microsoft Tech Community
    When a new employee joins, it is important for the company to enable that employee to quickly onboard to their role. As part of the ramp up process, admins are often asked to help the end user understand and use the available software & tools including Office 365. via Pocket

Marco Scheel: Links for 2017-03-25 [del.icio.us]

Norbert Eder: Windows-Batch: Verzeichnisse älter als n Tage löschen

Gerade wenn Verzeichnisse und Dateien automatisiert werden, sammelt sich in kürzester Zeit ein sehr großer Datenhaufen an. In den meisten Fällen können viele dieser Daten nach einer bestimmten Zeit wieder gelöscht werden. Da bietet es sich an, dies ebenfalls zu automatisieren. Eine Realisierung kann sehr einfach per Windows Batch durchgeführt werden. Hierfür gibt es eine einfache Möglichkeit: FORFILES.

Zur Veranschaulichung ein Beispiel:

pushd D:\drop\Nightly
FORFILES /m dir0815*.* /D -5 /C "cmd /c IF @isdir == TRUE rd /S /Q @path"
popd

IF %ERRORLEVEL% LSS 2 goto finish
EXIT /B %ERRORLEVEL%

:finish
EXIT /B 0

Was passiert hier? Zuerst wird das Arbeitsverzeichnis gesetzt, danach werden mittels FORFILES alle Dateien nach dem Pattern (siehe /m) ermittelt, die älter als 5 Tage (siehe /D -5) sind und an das via /C angegebene Command übergeben.

Anschließend wird das Arbeitsverzeichnis zurückgesetzt und die Errorlevel geprüft. FORFILES gibt einen Errorlevel von 0 zurück wenn Dateien gefunden und verarbeitet wurden. 1 wird zurückgeliefert, wenn keine Dateien für das angegebene Muster bzw. für den Zeitraum zu finden sind. Nachdem ich dies in einem Buildsystem verwende, möchte ich auch in diesem Fall, dass mein Build als fehlerfrei markiert wird. Wird ein anderer Errorlevel als 0 oder 1 gefunden, muss natürlich abgebrochen werden.

Viel Spaß beim anwenden!

The post Windows-Batch: Verzeichnisse älter als n Tage löschen appeared first on Norbert Eder.

AIT: AIT Apply Company Policy 1.4.0

Die neue Version 1.4.0 unseres Tools Apply Company Policy ist verfügbar! Das entsprechende NuGet-Paket wurde ebenfalls veröffentlicht.

Die neue Version beinhaltet einen Bugfix und eine Vereinfachung des Buildprozesses, um selbst eigene Company Policies zu erstellen.

Wollen auch Sie ganz einfach Ihre eigene Company Policy als NuGet-Paket bereitstellen? Dann schauen Sie einfach mal in das Repository auf GitHub rein! Bei Fragen und Ergänzungen stehen wir gerne auf GitHub oder per Mail zur Verfügung.

 

André Krämer: Visual Studio 2017 Launch bei der .NET User Group Koblenz

Update 23.03.2017: Das Treffen ist am 23.03 2017 und nicht wie ursprünglich geschrieben am 24.03.

Am 7. März 2017 veröffentliche Microsoft pünktlich zum 20. Geburtstag von Visual Studio die neue Version 2017.

Bei der .NET User Group Koblenz werden wir aus diesem Anlass am 23. März 2017 um 19:00 Uhr ein Treffen abhalten, bei dem Eric Berres und ich die wichtigsten neuen Features vorstellen werden, mit denen Entwickler noch produktiver werden.

Unter anderem werden wir folgendes besprechen:

  • Visual Studio 2017 Installer / Workloads
  • Schnellerer Start von Visual Studio 2017 dank Lightweight Solution Load
  • Neue Refactorings in Visual Studio
  • ASP.NET Core und Docker
  • Live Unit Testing in Visual Studio 2017
  • Xamarin in Visual Studio 2017

Visual Studio 2017 Launch Event T-Shirts

Für alle Microsoft MSDN Abonnenten gibt es übrigens auch noch ein kleines Geschenk seitens Microsoft: Ein Visual Studio 2017 Geburtstags-T-Shirt. Sollten wir nicht genug Shirts für alle Teilnehmer haben, dann werden diese nach dem Prinzip: First-Come, First-Serve ausgeteilt.

Visual Studio 2017 Launch Event T-Shirts

Weitere Details gibt es auf der Webseite der .NET User Group Koblenz

Don't contact us via this (fleischfalle@alphasierrapapa.com) email address.