Archiv der Kategorie: .NET

Champions of C# 9 : „Simplified parameter null validation code“

In this blog post I wan’t to have a closer look at a current proposals for the upcoming C# Version 9.

Proposal #2145 – Simplified parameter null validation code.

Usually, if handing over parameters to a method, some checking for NULL is required to prevent unexpected behavior. Have a look at the following sample of a method with some checking.

private string ParseText(string text)
    if (text is null)
      throw new ArgumentException(nameof(text));
    return text;

In C# 9, this code could be simplified by adding ! as an indicator for „Will not be NULL“ to the parametername. The code would then look like this.

private string ParseText(string text!)
    return text;

Based on This discussion from summer 2019, the new syntax is supposed to throw an Exception too, if the constraint is violated. Most likely also an ArgumentException, but this doesn’t seem to have specified yet.

New Resources Section and first Page „Resources to learn C# and ASP.NET“

Today I published a new section in my Blog, to collect resources to various topics. The goal for these pages is, to stick around and for me to update them regularly, to keep them relevant. The first page of this format is about Learning C# and ASP.NET. As someone who is working with these technologies for almost two decades, I hope I can deliver some useful information for beginners. Also, I am open for suggestions. What resources did I forget ? Let me know.

DotNetFiddle mit Unterstützung für F#, ASP.NET MVC und NuGet Packages.

Guten Abend,

leider konnte ich auf der Webseite keine Release-Notes finden.
Allerdings wurde irgendwann zwischen Januar und jetzt der Funktionsumfang dieses Tools für „.NET im Browser“ nochmal deutlich aufgebohrt.
Man kann nun als Sprache F# zusätzlich zu den bisherigen C# und VB.NET nutzen, NuGet Packages,wie man aus Visual Studio Projekten kennt, einbinden und auch Fiddles für ASP.NET MVC erstellen.


Bild: Screenshots von

C#: Lookup vs. Dictionary

Lookup (Namespace: System.Linq)

Lookup : ILookup : IEnumerable>

A Lookup is a collection which implements the ILookup Interface. It was introduces with LINQ and can be used instead of Dictionary.

A key don’t has to be unique, so you can have multiple entries with the same key. Also the Lookup is immutable, that means you can not add values on the fly, like you could with a List or Dictionary. You can however determine its count (.Count) and you can access the items with [value].

When you look up a key that does not exist in the Lookup, you don’t get a KeyNotFound-Exception but an empty sequence instead.

You cannot directly instantiate a Lookup, it is a result of a LINQ-Selection, which needs a Func for Key-Selection and a Func for Value selection.

Here is an example:

var myList = new List>
                new KeyValuePair(30, "Sam"),
                new KeyValuePair(10, "Hans"),
                new KeyValuePair(10, "Fred"),
                new KeyValuePair(20, "Sepp"),
                new KeyValuePair(10, "Ron")

var myLookup = (Lookup) myList.ToLookup(

var len = myLookup.Count;
var entry = myLookup[10];

Dictionary (Namespace: System.Collections.Generic)

Dictionary : IDictionary 
: ICollection>, IEnumerable>, IEnumerable

A key has to be unique, so you can have only one multiple entry with the same key. The Dictionary is mutable, that means you can add values on the fly. Also you can use normal collection methods to determine its count (.Count) and to access the items with [value].

When you look up a key that does not exist you get a KeyNotFound-Exception.
You can directly instantiate a Dictionary.

Here is an example:

var myDictionary = new Dictionary();
myDictionary.Add(20, "Fred");

var len = myDictionary.Count;
var entry = myDictionary[10];

Blogpost Original Date: 16.02.2010, Updated: 13.12.2013

Dirty Hack: Sharepoint DelegateControl manipulieren

Hallo zusammen,

keine Lösung die ich euch wirklich empfehlen möchte, mehr eine Notlösung falls Ihr mal in die Verlegenkeit kommt ein Layout-Detail in einem DelegateControl ändern zu wollen, und nicht wirklich Einfluß auf den Rest habt bzw. keine unnötigen Konflikte riskieren wollt.
Nachfolgend ein Beispiel, das die Grafik eines Submit-Buttons innerhalb eines DelegateControls verändert.

var dg = this.ChangePasswordDelegateControl as Control;

if (dg != null && dg.Controls.Count > 0)
  var control = dg.Controls[0].FindControl("imgbtnChangePassword") as ImageButton;
  if (control != null) control.ImageUrl = "/images/special_submit_bt.gif";

Viel Spaß

JavaScript ausführen wenn sich UpdatePanel aktualisieren

Hallo zusammen,

Möchte man auf Seiten mit mehreren UpdatePanels gezielt Javascript ausführen, wenn sich ein bestimmtes Panel aktualisiert, kann man das über den Javascript-PageLoaded Event der Hauptseite realisieren. Dieser Event liefert Informationen über die aktualisierten Panels mit. Im folgenden Beispielcode gehen wir nur von einem Panel aus, das Array aus get_panelsUpdated kann aber auch komplett ausgewertet werden.

Noch ein Tip: Verschiedene Zustände eines UpdatePanels (Zum Beispiel bei MultiViews) kann man auch einfach über die Prüfung von Layoutelementen erreichen. Für die ReadOnly Ansicht kann man zum beispiel ein HTML-Element mit der ID ReadOnlyView in die entsprechende View packen. Ist es vorhanden, ist das Panel in der ReadOnly Ansicht und man kann entsprechend JavaScript ausführen.

Viel Spaß beim ausprobieren

Generic View Models in Silverlight

I like using Base-Classes for any kind of „Class-Group“. Very prominent groups are Models and ViewModels in Silverlight-Applications.

The ViewModel-Baseclass can hold any functionality, that applies to every ViewModel inheriting from it and, if we are talking about Generics, can be very convenient to use.

For example, if I want to apply the factory-pattern to my ViewModels and want every Model to have a static Create-Method I can simply implement this Method in the Base-Class.

public class ViewModelBase 
	public virtual ViewModelBase Create() 
		return new ViewModelBase(); 

Of cause, without Generics we are limited to the return-Type. We could now override this method in every specific ViewModel to at least return the right ancestor of ViewModelBase. An easier way is, to use Generics for this case. The class could look like this :

public class ViewModelBase where TViewModel : ViewModelBase 
	public virtual TViewModel Create() 
		return Activator.CreateInstance(typeof(TViewModel)); 

Now we can simply create our new specific ViewModel like this

public class MyViewModel : ViewModelBase

to get what we want generically.


Another possible scenario would be the following. We know, every ViewModel contains a Collection of Models, all inheriting from a class called ModelBase. we could extend out code the following way:

public class ViewModelBase where TViewModel : ViewModelBase 
	public virtual TViewModel Create() 
		return Activator.CreateInstance(typeof(TViewModel)); 
	public List MyList {get;set;} 

or, the better way, we could extend our Generic header to be type safe.

public class ViewModelBase 	
                                        where TViewModel : ViewModelBase 
					where TChildModel : ModelBase 
	public virtual TViewModel Create() 
		return Activator.CreateInstance(typeof(TViewModel)); 

	public List MyList {get;set;} 

Defining a Class by

public class MyViewModel : ViewModelBase

Like always, if we talk about inheritance, you should avoid to go too far with that. I implemented a Framework I use for rapid prototyping where a lot of things are done in the base-class via reflection, but in a productive environment its not always what you want. Plan your development as precise as possible.

  • What do you want to be individually implemented by each ViewModel ?
  • When is it a good thing to implement it in the Base-Class ?
  • How confusing is you inheritance for other developers ?


Good Luck 😮

Extension Methods in VB.Net

My preferred .NET-language is C#, but as a consultant I have to write VB every once in a while. Here is a little introduction, how my beloved
Extension Methods work in VB.Net.

Just two steps:

Step1 – Create a new Module called for example “StringExtensions.vb” and add an Import –Statement for System.Runtime.CompilerServices

Step2 – Write your Extension Method, and put an <Extension()> directive on top. Here is an example:

    Public Function AddAbcX(ByVal mystring As String) As String
        Return myString + "ABC"
    End Function

Notice the _ behind the directive. Don’t forget this one.

You notive one additional thing. A while ago I read an article about Extension Methods and got the suggestion to add an X to each methodname.
So, if using intellisense, you will see directly if the method you’re about to call is an Extension Method or a build-in Method. Good idea I think.

Another suggestion – Put the method in the same namespace as the object it belongs to (I said namespace, not file!).

So you have your methods ready when you start using the object.


C#-Code dynamisch kompilieren mit CodeDom – Ein Beispiel

Guten Nachmittag,
die Aufgabenstellung war in diesem Fall so simpel wie kompliziert. Eine Formel die als String vorlag, sollte evaluiert werden. Nach einiger Suche stieß ich dann auf eine Lösung mit JScript und VSA. Für die Lösung mussten zunächst das Assembly Microsoft.JScript im Projekt referenziert werden und über using Microsoft.JScript eingebunden werden.

Der Code für die Funktion sah dann so aus:

public static string Eval(string Formular)
     return Microsoft.JScript.Eval.JScriptEvaluate(Formular, Microsoft.JScript.Vsa.VsaEngine.CreateEngine()).ToString();

so weit so gut. Ich möchte hier aber noch eine zweite Variante anführen, die etwas moderner ist und auf dem CodeDom von DotNet basiert. Hierfür müssen auch keine extra Assemblies referenziert werden.
Zunächst benötigt man eine Methode, die eine Klasse dynamisch erzeugt.

private object MathSolver(string Formular)
            // Der dynamische Code
            StringBuilder sb = new StringBuilder ();
            sb.Append("using System;");
            sb.Append("using System.Collections;");
            sb.Append("public class DynamicMathSolver");
            sb.Append("  public decimal Eval()");
            sb.Append("  {");
            sb.Append("          return " + Formular + ";");
            sb.Append("  }");

            Microsoft.CSharp.CSharpCodeProvider scp = 
                 new Microsoft.CSharp.CSharpCodeProvider();
            System.CodeDom.Compiler.ICodeCompiler cc = 
            System.CodeDom.Compiler.CompilerParameters cp = 
                 new System.CodeDom.Compiler.CompilerParameters();
            System.CodeDom.Compiler.CompilerResults Results = 
                 cc.CompileAssemblyFromSource(cp, sb.ToString());
            return Results.CompiledAssembly.CreateInstance("DynamicMathSolver");

Im Anschluss muss die Klasse nur noch angesprochen, und mittels Reflection die Methode aufgerufen werden.

 public string Result
                    // Evaluate Formula
                    object objMathSolver = MathSolver(SolvedFormula);
                    string  result = 
                          DynamicMathSolver.GetType().GetMethod("Eval").Invoke(DynamicMathSolver, null).ToString();
                return result;

Das war nur ein Beispiel für das erzeugen einer dynamischen Klasse. Dieses vorgehen lässt sich aber sicher noch für eine Vielzahl weiterer Fälle verwenden.

Haltet mich mal auf dem Laufenden, was Ihr damit so anstellt !
Sascha Baumann