You may do this as well!

---
Unterstütze mich und meinen Blog und kauf dir was Nettes (über diesen Link)

It needs a linear time based on the length of the string. This is understandable if you think about what it is doing. It needs to generate a “Fingerprint”-number based on its content, so you need to take a look at all the content at least once. So it is O(N).

I was going to do something more useful while I noticed all the precompiler conditions. That is very interesting! The function returns different results whether it is compiled for 32bit or 64bit. The debug version of the framework (Microsoft internal only?) even changes its resulting hashcodes with every buildnumber.

We want to ensure we can change our hash function daily.
This is perfectly fine as long as you don’t persist the
value from GetHashCode to disk or count on String A
hashing before string B.  Those are bugs in your code.

So you better avoid storing hashcodes and you should not exchange hashcodes across process-boundarys. Your communication partner may use a different number of bits!

Last but not least: the result is not stored but recomputed every time you call the function. The implementation is following the advice to not store its result itself.

---
Unterstütze mich und meinen Blog und kauf dir was Nettes (über diesen Link)

This is nothing fancy so far. After coding for straight 20 minutes without any testing in between I decided to test it. I noticed my machine was doing really nothing but burning cpu for a bunch of seconds and quitting then with a StackoverflowException. I had no idea what was going on.

The exception was not really telling too much about the problem. The only thing was a truncated stacktrace. It had something to do with the container trying to create an instance of a service. Without any further information it would be hard to pinpoint this so I decided to search for trace information. I am using Microsoft Prism with the Unity container for inversion of control. So does Unity provide any traces of what is going on? Surprisingly, this is not the case! There is no magic switch.

So I had no choice but removing constructor arguments here and there until I found the root problem. I had managed to create a circular reference:

The MSDN is telling me, that it is my responsibility to prevent this and it also warns of endless recursion. Endless recursion always ends with an StackoverflowException.

My solution was simple. I removed the circular reference through removing one reference. It was not used anyway.

*The name of this article is freely leaned on the name of the blog EAI Technologies & their Pitfalls of an ex coworker

---
Unterstütze mich und meinen Blog und kauf dir was Nettes (über diesen Link)

Many internal services are implemented as a bunch of static methods like so:

static class SeriousService
{
    public static int DoSomething(string value)
    {
        //<side effects here>
        return 17;
    }
}

And the usages of these static classes are all over the place like so:

class SomeModule
{
    public void ExecuteOrder(Order order)
    {
        //...
        SeriousService.DoSomething(order.Name);
        //...
    }
}

The challenge was to write a unit test which would test ExecuteOrder() without side effects in SeriousService.

A state-of-the-art application would insert the service through dependency injection into SomeModule. You could provide a mock for the service and you would be ready to write your unittest.

Unluckily, changing the caller or the signature of the callee was no option to me. The chance to introduce incompatibilities somewhere in the huge family of applications and tools was to high.

After some thinking I came up with the idea to extract the functionality out of the static service:

The “new” static service endpoint has now a private static reference to the service implementation and all public methods forward there calls to this implementation. The new service implementation is based on an extracted interface. Caller and callee are still unchanged (red rectangle). In code, it looks like so:

interface ISeriousService
{
    int DoSomething(string value);
}

class SeriousServiceImpl : ISeriousService
{
    public int DoSomething(string value)
    {
        //<side effects here>
        return 17;
    }
}

static class SeriousService
{
    private static ISeriousService _seriousService
                            = new SeriousServiceImpl();

    //Static endpoint
    public static int DoSomething(string value)
    {
        return _seriousService.DoSomething(value);
    }
}

Until here, all we have done is to insert another level of indirection. But this enables us to replace the real functionality of the service with a mock:

This is possible if the service “endpoint” gets a public method to replace its implementation:

static class SeriousService
{
    private static ISeriousService _seriousService
                            = new SeriousServiceImpl();

    public static void ReplaceServiceImpl(ISeriousService newImpl)
    {
        _seriousService = newImpl;
    }

    //Static endpoint
    public static int DoSomething(string value)
    {
        return _seriousService.DoSomething(value);
    }
}

Having all of this in place you can write your unit test for the module without the fear of any unforseen sideeffects:

[TestFixture]
class SomeModuleTest
{
    [Test]
    public void ExecuteOrder_handles_condition_xyz()
    {
        //Setup
        var service = new Mock<ISeriousService>();
        SeriousService.ReplaceServiceImpl(service.Object);

        //Execute
        new SomeModule().ExecuteOrder(new Order());

        //Asserts here
    }
}

There is one more thing left to be done. Obviously the real instance of SeriousServiceImpl is gone for good after executing the test. So if you want to be able to reuse the current AppDomain for another test you either need to recover it somehow or you have to replace it in every test. I have a nice solution for this as well but this article is already long enough.

So summing up, we saw how to introduce another level of indirection into our architecture. We used it to swap the implementation of a static service as was needed to write unit tests without side effects.

---
Unterstütze mich und meinen Blog und kauf dir was Nettes (über diesen Link)

var sentence = "Hello World!";
var words = sentence.Split(new char[] { ' ' });

If you take a look at the available overloads on Split() you may miss the params keyword. In fact it isn’t even visible on the overview page:

But if you take a closer look on Split(char[]) you will see this:

The params keyword tells you that the method accepts any number of arguments of type char. So you could also provide only one, which will simplify the given sample to:

var sentence = "Hello World!";
var words = sentence.Split(' ');

---
Unterstütze mich und meinen Blog und kauf dir was Nettes (über diesen Link)

var fabse = myList.Where(p => p.Name == "Fabse").First();

There are several ways to improve this scenario. First has an overload where it accepts a predicate function, so the following example yields the same result:

var fabse = myList.First(p => p.Name == "Fabse");

But what happens if your list has no elements fulfilling your filter? First() will throw an exception. It is considered bad style to use exceptions to handle program flow. But is quite hard sticking to First() and avoiding the exception at the same time.

It is better to use FirstOrDefault() if there is the possibility of not getting any result. If there is no result, the default for the inferred data type is used, which is null for all reference types and 0 (zero) or false for int/float/double/… and bool. Sample:

var fabse = myList.FirstOrDefault(p => p.Name == "Fabse");
if (fabse != null)
{
    //use fabse ;-)
}

Today I discovered the functions Single() and SingleOrDefault() which have nearly the same semantics but they will test the data source for further hits regarding your predicate. If there are other hits, you will see an InvalidOperationException.

I like this behavior very much because I often search for the existence of a somehow special object and based on this existence I do something or not. If there is more than one of these special objects, there is most likely something wrong with the data and it is better to stop the process and to examine the data. So an exception feels right at this moment.

To finish up this kwik-e: First() will give you the first (duh!) element while Last() and LastOrDefault() will give you the last element.

---
Unterstütze mich und meinen Blog und kauf dir was Nettes (über diesen Link)

---
Unterstütze mich und meinen Blog und kauf dir was Nettes (über diesen Link)

RavenDB ist eine schema-lose Dokumentendatenbank und damit Vertreter der NoSQL-Bewegung. Zugriffe erfolgen über REST. Es gibt eine .Net ClientAPI und mit der kann man in 3 Zeilen jedes beliebige Objekt in die Datenbank schreiben. Ich bin echt beeindruckt, wie unerwartet unkompliziert das geht.

Ich habe eine halbwegs klare Projektidee im Kopf, so musste ich einige konkrete Fragen klären, die durch das Lesen von Ayendes Blog (Tipp!!!) nicht zu klären waren.

Kann man RavenDB embedded hosten? Ja! Neben dem Hosten über einen Windows Service oder über den IIS kann man auch im Client selbst die Datenbank hosten womit das ganze zu einer Standalone-App wird.

Wie gut kommt es mit Blobs klar? Hier habe ich lange probiert. Zuerst hatte ich immer ein Byte-Array in meinen Objekten, was aber schnell zu OutOfMemory-Situationen führt. Ich hatte mit ca. 1000 Objekten mit je 3mb Inhalt zu tun. Es erfolgt eine Base64-Codierung bei der Übertragung so dass zu einem Zeitpunkt in Server und Client in Summe vermutlich mindestens 4 Varianten gehalten werden. Wenn man die richtigen Google-Suchwörter verwendet, findet man heraus, dass RavenDB auch Attachments als Konzept versteht. Hier gibt es wohl keine Transaktionalität aber dafür Performance! Mir gelang es, ein Attachment mit 335mb in 66s in die Datenbank zu pumpen, was für meine Anforderungen vollkommen genügt. Bei dem nächstgrößeren Versuch mit 500mb kam es zu einer OutOfMemoryException, aber das ist ok. Attachments können übrigens auch direkt durch einen Browser geladen werden!

Sollte jetzt der Eindruck entstanden sein, dass RavenDB langsam ist, dann muss ich dem Widersprechen. Mir gelang es die 1000 Objekte nur mit Metadaten und ohne Blobs in unter einer Sekunde in die Datenbank zu laden.

Ich bin sehr beendruckt von RavenDB und kann jedem nur empfehlen, sich selbst einen Eindruck zu verschaffen.

Mein Ostermontag ist jedenfalls gut angelegt

---
Unterstütze mich und meinen Blog und kauf dir was Nettes (über diesen Link)

Right click your database, select “Tasks”, then “Generate Scripts”:

Follow the wizzard, but change the option to script data to true:

You should be able to figure out everything else on your own.

---
Unterstütze mich und meinen Blog und kauf dir was Nettes (über diesen Link)

Bei mir endete dieses Uninstall sehr früh, aber auch ohne Fehlermeldung. Repair half nicht. Geholfen hat aber, im IIS alle SharePoint-Sites zu löschen, alle Application Pools zu löschen und auch im SQL Server alle SharePoint Datenbanken zu droppen. Jetzt läuft das Uninstall und ist auch schon fast durch.

Ursache ist wohl, dass das Entwicklungsimage, auf dem ich arbeite, durch Kopieren und Umbenennen entstanden ist, denn die alten App-Pools liefen auf ALTERRECHNER\Administrator, was dann wohl auch zu der IdentityNotMappedException führte, welche ich im Eventlog gesehen habe.

---
Unterstütze mich und meinen Blog und kauf dir was Nettes (über diesen Link)

Ich glaube er schläft nie und tut den ganzen Tag nichts anderes, aber wenn man selbst mal Zeit hat, sind seine Beiträge immer interessant und auch die Kommentare sind idR sehr qualitativ.

Ansehen!

---
Unterstütze mich und meinen Blog und kauf dir was Nettes (über diesen Link)

I had a working piece of code doing exactly this but I had to redo it using a pipeline componentan instead of an orchestration.

Everything is straightforward. If you had set the context value in your orchestration like this:

EmailOut(SMTP.MessagePartsAttachments) = 2;

you would take a look in the msdn to get the values right and then translate it to the following code in your pipeline component:

inmsg.Context.Write(“MessagePartsAttachments”,
“http://schemas.microsoft.com/BizTalk/2003/smtp-properties”, 2);

I did this with every context value and tested it. It worked well but there was no attachment?! But there was also no error!

Finding the solution took me more time then I am willing to admit…

If you take a sharp look in the MSDN then you might find this:

[SerializableAttribute]
[GuidAttribute("9EE763F5-ECE7-42f6-BE97-38EA64FB7607")]
[IsSensitivePropertyAttribute(false)]
[PropertyGuidAttribute("9EE763F5-ECE7-42f6-BE97-38EA64FB7607")]
[PropertyTypeAttribute("MessagePartsAttachments",
"http://schemas.microsoft.com/BizTalk/2003/smtp-properties",
"unsignedInt", "System.UInt32")]
public sealed class MessagePartsAttachments : MessageContextPropertyBase

I was desperate at best and tried everything and this one worked:

inmsg.Context.Write(“MessagePartsAttachments”,
“http://schemas.microsoft.com/BizTalk/2003/smtp-properties”, (UInt32)2);

You cannot see any difference at all if you take a look at a suspended/tracked message but this was the cause of the missing attachments. I hope this might save you some time!

---
Unterstütze mich und meinen Blog und kauf dir was Nettes (über diesen Link)

Die anderen Überladungen von Match() tun dann aber ihren Job richtig…

---
Unterstütze mich und meinen Blog und kauf dir was Nettes (über diesen Link)

Folgendes Snippet erfüllt den Job aber als Einzeiler:

File.WriteAllText("c:\\streamOut.txt", new StreamReader(meinStream).ReadToEnd());

Zu beachten ist, dass je nach Typ von meinStream die Position anschließend zurück gesetzt werden muss oder auch, das dies gar nicht möglich ist und daher die weitere Programmausführung fehlerhaft wird.

---
Unterstütze mich und meinen Blog und kauf dir was Nettes (über diesen Link)

Ich hatte nun den Fall, dass ich neben dem schon existierenden Pfad(linker Teil der Grafik) einen zusätzlichen Fall hatte, bei dem ein Direct Receive aus der MessageBox nötig war. Kommt die Nachricht aus der MessageBox, ist (für diesen Fall) klar, dass es keine Folgenachrichten gibt.

Man kann eine Orchestration nun nicht nur über ein Receive-Shape starten lassen, sondern auch auch über mehrere Receives, die in einem Listen-Shape untergebracht wurden. Das hatte ich dann auch versucht.

Auch wenn aus logischer Sicht kein Pfad möglich ist, der vom Direct Receive zum “Receive Follower” führt, verwehrt BizTalk die Kompilierung dieser Orchestration.

Der Versuch, den Receive aus dem Receive Port durch einen Filter auf der MessageBox zu formulieren fruchtete ebenfalls nicht. Finales Ergebnis war, die gemeinsame Funktionalität in einer separaten Orchestration auszulagern und für den Direct Receive eine zusätzliche Orchestration zu bauen, die einen Call macht.

Außerdem ist die Fehlermeldung “unknown system error” auch sehr hilfreich beim Finden des eigentlichen Problems, denn eigentlich ist die Orchestration viel größer, als hier auf dem Screenshot zu sehen.

---
Unterstütze mich und meinen Blog und kauf dir was Nettes (über diesen Link)