Schlagwort-Archive: C#

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.

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

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