Tips and tricks in C# .NET
August 19, 2016 2 Comments
A SecureString is a confidential piece of information that is erased from memory when not in use anymore. You can use this object if you need to pass around things like passwords and PIN codes that should be protected while in use.
August 18, 2016 Leave a comment
Introduction
In the previous post we looked at the fanout exchange type. This exchange type corresponds to the publish-subscribe message exchange pattern. This MEP is very similar to one-way messaging. The major difference is that there can be multiple queues bound to an exchange. The incoming messages are forwarded to every queue where each queue is monitored by a listener. This exchange type is suitable for cases where you know that there will be multiple listeners.
So far we’ve looked at patterns where the publisher sent a message to a queue and didn’t care about any response back from the consumer. In this post we’ll see how to set up two-way messaging where a publisher receives a response from the consumer.
August 17, 2016 1 Comment
If you are familiar with LINQ then you are probably aware of the notion of deferred execution: queries are not carried out until they are needed. This is not different in parallel LINQ either. Let’s see an example:
Set up a data source:
int[] integerArray = new int[100];
for (int i = 0; i < integerArray.Length; i++)
{
integerArray[i] = i;
}
Define a parallel query:
IEnumerable<double> results =
integerArray.AsParallel().Select(item =>
{
return Math.Sqrt(item);
});
The query has not been carried out at this point. It is carried out when the following foreach loop starts:
double sum = 0;
foreach (double result in results)
{
sum += result;
}
Console.WriteLine("Total {0}", sum);
You can force query execution with the same extension methods as in “normal” LINQ, such as ToList, ToArray etc.:
IEnumerable<double> results =
integerArray.AsParallel().Select(item =>
{
return Math.Sqrt(item);
}).ToList();
In this case the query is executed as soon as it has been defined.
View the list of posts on the Task Parallel Library here.
August 16, 2016 4 Comments
You can create an empty sequence of a type using the Empty operator in Linq. Its usage is very simple:
IEnumerable<string> emptyStringSequence = Enumerable.Empty<string>();
This creates a sequence of strings consisting of 0 elements.
August 15, 2016 4 Comments
Introduction
In the previous post we looked at an alternative way to consume messages from a queue in RabbitMq. In particular we discussed the usage of the EventingBasicConsumer which is an event and delegate based alternative to the DefaultBasicConsumer class. The outcome is the same in both cases, i.e. the consumer monitors the assigned queue and pulls messages from it.
In this post we’ll discuss how to work with the fanout exchange type.
August 14, 2016 Leave a comment
Introduction
In the previous post we looked at the job worker configuration class. It’s not a very complicated implementation. It basically constructs a job poller for each CP region the job agent will monitor. It also constructs an AWS client with the proper AWS credentials.
There are a couple more building blocks of the third party action before we have a functioning system. One of them is the implementation of the JobPoller interface which is the topic of this post. In particular we’ll be looking at one of the dependencies of the job poller, the job service class.
August 13, 2016 Leave a comment
Introduction
In the previous part we started looking at the job worker initialisation details. The job worker takes the form of a deamon thread and implements the org.apache.commons.daemon.Daemon interface. The job worker daemon implementation introduces a range of new classes that we need to look at in order to get the full picture. One was the job poller interface which only has a single method called execute.
Another such element is the job worker configuration class which we’ll discuss in this post.
August 10, 2016 4 Comments
Introduction
In the previous post we saw how to process messages from a queue using a receiver we derived from a default basic consumer. We implemented the HandleBasicDeliver function for that purpose. We also discussed two message exchange patterns (MEPs), one-way and and worker queues. The two are practically identical in code but the worker queues MEP implies that we have 2 or more consumers competing for the messages from the queue. That way we can spread out the message load across multiple consumer instances.
In this short post we’ll look at an alternative way to consume messages from a queue in code.
August 8, 2016 3 Comments
Introduction
In the previous post we looked at the RabbitMq .NET client. The client is a library that can be downloaded from NuGet and which allows us to work with RabbitMq messages in our .NET projects in an object-oriented way. In particular we saw how to create an exchange, a queue and a binding in code. We also successfully sent a message to the queue we created in a simple .NET console application. We also discussed the notion of durability whereby we can make all resources in RabbitMq fault tolerant so that they survive a server restart.
In this post we’ll see how to consume one-way direct messages in code.
August 5, 2016 6 Comments
Introduction
In the previous post we installed the RabbitMq service on Windows. I think you’ll agree that it wasn’t a very complicated process. We then logged into the management GUI using the default “guest” administrator user. We finally looked at how to create users and virtual hosts. We said that a virtual host was a container or namespace to delimit groups of resources within RabbitMq, such as “sales” or “accounting”. We also created a new user called “accountant”.
In this post we’ll start working with RabbitMq in Visual Studio. We’ll in particular start exploring the RabbitMq .NET client library.
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 