Tips and tricks in C# .NET
October 13, 2015 Leave a comment
We saw in this and this post how to catch and handle exceptions thrown by threads. A task has properties that let you read its state and determine what happened to it.
October 12, 2015 2 Comments
Introduction
In the previous post we laid the foundations for this short series. We went through a refresher of claims and OWIN and started building a simple ASP.NET MVC web project to investigate what’s available about the user of the current thread in a controller. We saw that by default the only claim available about a user might be their name, unless they are anonymous of course.
In this post we’ll continue to explore claims of authenticated users.
October 9, 2015 Leave a comment
Sometimes you need to change the fore- and background colours in your .NET console application. Normally it’s fine with the traditional black background and white foreground colours – or whatever the user has set as default colours – however, some message types may deserve extra attention.
This short post will demonstrate how to change the colours in a console application.
October 8, 2015 Leave a comment
Introduction
Claims have become widespread in software projects to tighten the security aspects of an application. We looked at claims before on this blog – see the link in the next paragraph – but time goes by and new features have been added to this technology lately. This is especially true as far as OWIN is concerned. In this mini-series we’ll concentrate on a very narrow aspect of claims in .NET MVC: claims transformation in OWIN middleware.
October 7, 2015 1 Comment
Tasks in .NET TPL make it easy to assign tasks that should run upon the completion of another task.
We’ll need a basic object with a single property:
public class Series
{
public int CurrentValue
{
get;
set;
}
}
Declare a task that increases the CurrentValue in a loop and return the Series. This task is called the antecedent task.
Task<Series> motherTask = Task.Factory.StartNew<Series>(() =>
{
Series series = new Series();
for (int i = 0; i < 10000; i++)
{
series.CurrentValue++;
}
return series;
});
Declare the continuation task where we also use the antecedent as method parameter:
motherTask.ContinueWith((Task<Series> previousTask) =>
{
Console.WriteLine("Final Balance: {0}", previousTask.Result.CurrentValue);
});
The antecedent task will then schedule the continuation task for you. If there are other tasks then they may run before or after the continuation tasks depending on the task scheduler.
View the list of posts on the Task Parallel Library here.
October 6, 2015 Leave a comment
The dynamic keyword in C# is similar to Reflection. It helps you deal with cases where you’re not sure of the concrete type of an object. However, you may expect the object to have a certain method that you can invoke at runtime. E.g. you have a framework that external users can write plugins for. You may set up a list of rules for the plugin to be valid, e.g. it must have a method called “Execute” and a property called “Visible”.
There are various ways you can solve this problem and one of them is dynamic objects. Using the dynamic keyword will turn off the automatic type checking when C# code is compiled. The validity of the code will only be checked at runtime.
October 5, 2015 2 Comments
Introduction
In the previous post we continued working on our Web API 2 layer and added two new controller actions: POST which handles both updates and insertions and DELETE which is responsible for deleting load tests. Our first draft of the DDD load testing demo is actually finished at this point. All that’s left is testing the POST and DELETE functions of the Web API.
We’ll do that in this post. We’ll also write some conclusions.
October 2, 2015 1 Comment
It happens that you’d like to terminate a .NET console application with some exit code. Normally exit codes are integers where negative numbers indicate that something has gone wrong with -1 being the most common. Positive digits and zero on the other hand usually imply a program execution with no errors. The most common positive exit codes are 0 and 1.
October 1, 2015 Leave a comment
Introduction
In the previous post we started building the top layer of our load testing DDD demo solution. We added an empty Web API 2 project and also created a GET controller action to retrieve the open load tests 2 weeks ahead. We also managed to add an IoC controller called StructureMap which injects the required concrete dependencies into the controllers and service methods.
In this post we’ll continue building on our demo project and add the POST and DELETE controller actions as well. We’ll also see another application of the view-model concept we saw earlier.
September 30, 2015 20 Comments
Introduction
The strategy pattern is one of the simplest patterns to implement. Have you ever written code with ugly if-else statements where you check some condition and then call another method accordingly? Even worse: have you written if-else statements to check the type of an object and then called another method depending on that? That’s not really object-oriented, right? The strategy pattern will help you clean up the mess by turning the if statements into objects – aka strategies – where the objects implement the same interface. Therefore they can be injected into another object that has a dependency of that interface and which will have no knowledge of the actual concrete type.
A directory of wonderful thoughts
Web development
Various tidbits
WEB APPLICATION DEVELOPMENT TUTORIALS WITH OPEN-SOURCE PROJECTS
ARCHIVED: Bite-size insight on Cyber Security for the not too technical.
Exercises in .NET with Andras Nemes 