Messaging through memory-mapped files in .NET C#

November 18, 2015 Leave a comment

We saw in this and this posts how to use memory-mapped files to map an existing file to a memory location that multiple processes had access to on the same machine.

The same key objects, i.e. MemoryMappedFile and MemoryMappedViewAccessor can be used for interprocess messaging purposes. The following code shows how a “server” can create a new shared file mapped to memory. Here we use the CreateNew method for this purpose and give the file a mapping name. Note that this is only an in-memory file, it won’t be saved on disk:

Read more of this post

Filed under .NET, Messaging Tagged with ,

Reading from a memory-mapped file in C# .NET

November 17, 2015 1 Comment

In this post we saw how to write to a memory-mapped file in .NET. We wrote a short string – “Here comes some log message.” – to a 10KB file. Here we’ll quickly look at how to read from the same file by mapping it into memory first.

The way to read from a file is very similar to writing to it. We’ll still need the MemoryMappedFile and MemoryMappedViewAccessor objects:

Read more of this post

Filed under .NET, Files and directories Tagged with ,

Wiring up a custom authentication method with OWIN in Web API Part 1: preparation

November 16, 2015 2 Comments

Introduction

There are a number of authentication types for a web project: basic -i.e. with username and password -, or token-based or claims-based authentication and various others. You can also have some custom authentication type that your project requires.

In this short series we’ll go through how to wire up a custom authentication method in a Web API project. We’ll see the classes that are required for such an infrastructure. We’ll also discuss how to wire up these elements so that the custom authentication mechanism is executed as part of the chain of Katana components.

Read more of this post

Filed under .NET, Security Tagged with , , ,

Writing to a file using a MemoryMappedFile in C# .NET

November 13, 2015 Leave a comment

You can use memory-mapped files to map a file to a place in memory that multiple processes can access. The necessary objects reside in the System.IO.MemoryMappedFiles namespace.

The following example will create a MemoryMappedFile object using the following ingredients:

  • The file path
  • The file mode which in this example is CreateNew, i.e. a new file will be created if it doesn’t exist
  • A map name that other processes can refer to
  • An initial size of the file. This is mandatory for files that don’t exist otherwise you’ll get an exception. The file will be given this initial size with a lot of string-termination characters. If you try to open the file in a text editor then you may get a warning that the file is full of NULL characters. This depends on the type of editor you’re using

Read more of this post

Filed under .NET, Files and directories Tagged with ,

Domain Driven Design with Web API extensions part 7: domain events with RabbitMq completed

November 12, 2015 1 Comment

Introduction

In the previous post we set up the local RabbitMq environment. We also created a simple console application that built the message queue where the DDD demo project and the simulated financial application will communicate. We also prepared the way for the completion of the messaging process by creating an app setting reader and adding the RabbitMq related settings to web config.

In this post we’ll complete the demo by sending a message to the queue and reading it from the dummy financial console application.

Read more of this post

Filed under .NET, Design patterns, Design principles, Messaging Tagged with , , , , ,

Set various options for your HTTP calls through the HttpClientHandler object in .NET

November 11, 2015 Leave a comment

The HttpClient object in the System.Net.Http namespace has become quite a standard object in .NET to initiate HTTP calls in code. In this short post I’d like to draw your attention to one of its constructors which allows you to set various useful options.

Read more of this post

Filed under .NET, C# language features Tagged with ,

Introducing the Command Line Parser Library to make parsing command line arguments easier

November 10, 2015 3 Comments

If you’ve worked extensively with .NET console applications then you’ve probably encountered difficulties with parsing the command line arguments. They are passed into the args argument of the Main function. Then it’s your task to investigate if the caller has passed in all necessary arguments:

  • Have all the mandatory arguments been passed in?
  • What default value do we take for optional arguments?
  • What about the ordering of arguments?

…et cetera, the list could grow a lot longer.

Fortunately there are libraries that can help you parse the arguments. One such library is called Command Line Parser Library available from NuGet here. You can find its project page here with some initial code examples.

Read more of this post

Filed under .NET, C# language features Tagged with ,

Domain Driven Design with Web API extensions part 6: domain events with RabbitMq

November 9, 2015 2 Comments

Introduction

In the previous post we looked at some basic theory behind messaging between independent applications. We discussed a couple of options to solve the problem. In this post we’ll start building our messaging environment using RabbitMq.

Read more of this post

Filed under .NET, Design patterns, Design principles, Messaging Tagged with , , , ,

Exception handling in the .NET Task Parallel Library with C#: a safety catch-all

November 6, 2015 2 Comments

Introduction

There can be situations that your application uses threads to such an extent that you either cannot put a try-catch block around every single Task.Wait, Task.WaitAll etc. calls or you simply forget it. There is a way to subscribe to all unhandled aggregate exceptions that the task scheduler encounters. You can then decide what to do with the exception there.

The task scheduler has an UnobservedTaskException event. It’s straightforward to subscribe to that even with the += operator.

Read more of this post

Filed under .NET, Task Parallel Library Tagged with , ,

Domain Driven Design with Web API extensions part 5: domain events between independent systems

November 5, 2015 1 Comment

Introduction

In the previous post we looked at a solution on how elements of a .NET solution can communicate with each other using a mediator. The mediator keeps the publisher decoupled from the subscribers. Also, the mediator won’t have any knowledge of the event handlers, their exact types and what and how they will handle the messages from the domain objects.

The solution helps the email sending event handler read the domain event in case a user added a new or updated an existing load test. In this post we’ll direct our attention to messaging between independent applications. We’ll ultimately simulate that a financial application also wants to be notified of the load test domain events in order to calculate the monthly profits.

Read more of this post

Filed under .NET, Design patterns, Messaging Tagged with , , , , ,

← Older posts

Newer posts →

Elliot Balynn's Blog

A directory of wonderful thoughts

Software Engineering

Web development

Disparate Opinions

Various tidbits

chsakell's Blog

WEB APPLICATION DEVELOPMENT TUTORIALS WITH OPEN-SOURCE PROJECTS

Once Upon a Camayoc

ARCHIVED: Bite-size insight on Cyber Security for the not too technical.