IT / Administration / Development / other stuff: May 2015

Wednesday, May 27, 2015

dynamic dispatch using "as dynamic" in c#

I found a new entry for our internal coding guidelines: "don't use dynamic dispatching if not absolutely necessary!".

wikipedia:

...

In computer science, dynamic dispatch is the process of selecting which implementation of a polymorphic operation (method or function) to call at run time. Dynamic dispatch contrasts with static dispatch in which the implementation of a polymorphic operation is selected at compile-time. The purpose of dynamic dispatch is to support cases where the appropriate implementation of a polymorphic operation can't be determined at compile time because it depends on the runtime type of one or more actual parameters to the operation.

...

Dynamic dispatch is often used in object-oriented languages when different classes contain different implementations of the same method due to common inheritance.

...

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Dynamic
{
    public interface IInt
    {
    }

    public class A : IInt
    {
    }

    public class B : A
    {

    }

    class Program
    {
        static void Main(string[] args)
        {
            Program p = new Program();

            IInt x = new A();
            p.Print(x);
            p.Print((A)x);
            p.Print(x as B);
            p.Print(123);
            p.Print(x as dynamic);

            Debugger.Break();
        }

        public void Print(IInt p)
        {
            Console.WriteLine("IInt");
            //if (p is B)
            //{
            //    Print(p as B);
            //} 
            //else if(p is A)
            //{
            //    Print(p as A);
            //}
        }

        public void Print(A p)
        {
            Console.WriteLine("A");
        }

        public void Print(B p)
        {
            Console.WriteLine("B");
        }
        /*
        public void Print(object p)
        {
            Console.WriteLine("obj");
        }*/

        public void Print(dynamic p)
        {
            Console.WriteLine("dynamic");
        }
    }
}

Output:
IInt
A
B
dynamic
A

The reason why line 61 to 65 is commented out is that it is technically not possible to keep both functions in code ... the one with the object parameter and the one with the dynamic (will be translated to object later). At first sight it seems to be elegant to call line 30 and get the interface function and then call line 34 and get the "right" function, but don't forget the difference... you put compiler decisions to run-time, so you trick the compiler in some ways. Don't do that!

kind regards,
Daniel

sql recursive functions (linked lists in sql)

In modern programming languages it makes sense to work with lists, stacks, dictionaries and other collections. This can be crucial when you want to persist the data into the database, because some considerations have to be made about sorting and stuff like that.

Now implementing a linked list in a table is easy:

table: mylist

ID: int (not null)
data: nvarchar(50)
nextID: int (null)

... more tricky is to walk through the list and find e.g.: the leaf of a corresponding root (seeing a list as a special sort of tree).

the solution is described at:

http://stackoverflow.com/questions/16749095/sql-recursive-function-that-gets-all-ancestors-of-an-item

...but the other way round using parent_id instead of a next_id

data_table:

ID parent_id name

---------------------

1 2 first

2 4 second

3 3 third

4 5 fourth

5 - fifth

the solution looks as follows:

with parents as 
(
  select ID, parent_ID
  from data_table t
  where parent_ID is not null
  union all 
  select p.ID, t.parent_ID
  from parents p
    inner join data_table t on p.parent_ID = t.ID
      and t.parent_ID is not null
      and t.ID <> t.parent_ID
)
select *
  , parents = '(' + stuff
    (
      (
        select ', ' + cast(p.parent_ID as varchar(100))
        from parents p 
        where t.ID = p.ID
        for xml path('')
      ), 1, 2, ''
    ) + ')'
from data_table t
order by ID

line 1 gives the inner statement a name to call it e.g.: more often like in
with y as (select * from x where id > 12) select * from y, y
... here you have a smaller set of data to cross join
line 3 to 5 makes a select as a starting point for the recursion (the original records)
union all in line 6 adds to the starting point a data set defined below
line 7 to 11 was at first sight simply magical to me

line 7 selects the columns corresponding to line 2 (required by the union and makes sense with the recursive algorithm) ... the own id and the parent of parent
line 8 requests data from the data table itself (the recursion using the name), but
line 9 joins parent data to the original data

line 13 to 24 uses the "expanded" data evaluated and shows it nicely in an own column using "for xml path".

the expanded result is:

| ID | parent_ID |
|----|-----------|
|  1 |         2 |
|  2 |         4 |
|  3 |         3 |
|  4 |         5 |
|  2 |         5 |
|  1 |         4 |
|  1 |         5 |

this will be transformed to

| ID | parent_id |   name |   parents |
|----|-----------|--------|-----------|
|  1 |         2 |  first | (2, 4, 5) |
|  2 |         4 | second |    (4, 5) |
|  3 |         3 |  third |       (3) |
|  4 |         5 | fourth |       (5) |
|  5 |    (null) |  fifth |    (null) |

...

There is an addition for select statements to overwrite the max recursion depth (in sql server it is default set to 100) to work with "deep" lists or trees.

OPTION (MAXRECURSION 0)

kind regards,

Daniel

Monday, May 11, 2015

Tool for load tests and performance tests

I needed to make some load and performance tests ... I thought about using the visual studio components, but I realized that I have no studio installed on the machine where I wanted to make my testing ... I needed another tool! Test Studio of Telerik costs 80$ a month ... #dislike

Finally I thought about using an open source tool. After some google search I found some opportunities ( http://blazemeter.com/blog/open-source-load-testing-tools-which-one-should-you-use ), but JMeter seems to be outstanding...

... and it worked for me! The following tutorial with 20 minutes was enough to setup my first easy use case...

kind regards,
Daniel

Wednesday, May 6, 2015

C# Debug-Info

Hi,

a few days ago I found a quite cool feature:

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace TestProject
{
    class Program
    {
        [DebuggerDisplay("Person: '{Name}'")]
        public class Person
        {
            public string Name { get; set; }
            public int Age { get; set; }
        }
        static void Main(string[] args)
        {
            var persons = new List<Person>(new Person[] { 
                new Person() { Name = "Johnny Galecki", Age = 40},
                new Person() { Name = "Kaley Cuoco-Sweeting", Age = 30},
            });

            Debugger.Break();

            if (Debugger.IsLogging())
            {
                persons.ForEach(x => Debugger.Log(0, "output", x.Name + Environment.NewLine));
            }
        }
    }
}

In line 12 DebuggerDisplay tells the Debugger to show the information "person" and then the person's name. E.g.: if you are running this example application the debugger will break (like setting a break-point) on line 25. When you check the variable using a "watch"-window or "local" you will see that the output is now something helpful instead of the full qualified class name.

Other important features related to Debug-Info:

DebuggerStepThrough-Attribute
DebuggerBrowsable-Attribute

kind regards,

Daniel

EDIT: check also DebuggerTypeProxy: https://msdn.microsoft.com/en-us/library/d8eyd8zc.aspx