Tips and tricks in C# .NET
August 28, 2015 Leave a comment
In this post we looked briefly at how to work with directories in isolated storage. In this post we’ll look at where isolated storage files are saved on disk depending on the isolation type: by user or by machine.
Recall our code to save the program settings specifically for the user:
August 27, 2015 Leave a comment
Introduction
In the previous post we discussed the concept of associations and standalone classes. We saw why it was important to keep the coupling between domain objects at a minimum. We also built the central object in our load test domain, Loadtest.cs.
In this post we’ll take a step upwards and discuss the root of the load test aggregate.
August 26, 2015 Leave a comment
In this post we briefly went through the basics of isolated storage files. We saved some applications settings in a text file within the isolated storage reserved for an application at the user level.
We’re not restricted to save files in isolated storage. We can also create folders for organisation purposes. It’s very easy to create a folder. The IsolatedStorageFileStream example is almost identical to what we saw in the post referenced above. However, remember that the directory must be created first before you can save anything in it:
private static void SaveSettingsInIsoStorage()
{
IsolatedStorageFile applicationStorageFileForUser = IsolatedStorageFile.GetUserStoreForAssembly();
applicationStorageFileForUser.CreateDirectory("AppSettings");
IsolatedStorageFileStream applicationStorageStreamForUser = new IsolatedStorageFileStream("AppSettings/settings.txt", FileMode.Create, applicationStorageFileForUser);
AppSettings settings = new AppSettings()
{
Job = "Programmer",
Language = "C#",
Name = "Andras"
};
string contents = JsonConvert.SerializeObject(settings);
using (StreamWriter sw = new StreamWriter(applicationStorageStreamForUser))
{
sw.WriteLine(contents);
}
}
It can be a good idea to check whether the directory exists before you create it:
string[] directoryNames = applicationStorageFileForUser.GetDirectoryNames("AppSettings");
if (!directoryNames.Any())
{
applicationStorageFileForUser.CreateDirectory("AppSettings");
}
Read the next part here.
Read all posts dedicated to file I/O here.
August 25, 2015 3 Comments
There’s a special storage location for a .NET application on Windows that is allocated to that application. It’s called isolated storage and it’s an optimal place to store files by an application that doesn’t have full access to the file system. Writing to and reading from isolated storage doesn’t require any extra security check. An application without full access to the file system will be able to use its allocated slot in isolated storage and nothing else. It’s an ideal mechanism for storing e.g. application state.
However, don’t confuse isolated storage with file security. It is still a “normal” location on disk with a file path. A typical location is under users/[username]/appdata/local. Therefore you or full-trust applications can still find and modify the files saved in isolated storage. However, limited-trust applications won’t be able to access any other part of the file system.
August 24, 2015 2 Comments
Introduction
In the previous post we built up the objects that will surround the central domain object, i.e. Loadtest. We saw examples of entities and value objects. We are deliberately keeping the objects simple so as to keep the size of the demo manageable for a blog like this. Always keep in mind that real-life domain objects will be more complex than those but our main goal is to concentrate on a small section.
In this post we’ll connect the dependent objects with Loadtest. We’ll also look at two new concepts from DDD: associations and standalone classes.
August 20, 2015 2 Comments
Introduction
In the previous post we discussed the concept of ubiquitous language in DDD. It describes the problem domain in clear terms that are well-known for each stakeholder in the project. Each bounded context has its own well defined ubiquitous language that all parties stick to in every form of communication. We also defined the most important terms and rules for load testing bounded context of our demo application.
In this post we’ll start coding the domain objects. My intention is to be as detailed as possible as the domain layer is the most important on in a DDD project. Therefore this section will span two blog posts.
August 19, 2015 Leave a comment
Here comes a simple extension method to calculate the standard deviation of a list of integers:
public static double GetStandardDeviation(this IEnumerable<int> values)
{
double standardDeviation = 0;
int[] enumerable = values as int[] ?? values.ToArray();
int count = enumerable.Count();
if (count > 1)
{
double avg = enumerable.Average();
double sum = enumerable.Sum(d => (d - avg) * (d - avg));
standardDeviation = Math.Sqrt(sum / count);
}
return standardDeviation;
}
Here’s how you can call this method:
List<int> ints = new List<int>() { 4, 7, 3, 9, 13, 90, 5, 25, 13, 65, 34, 76, 54, 12, 51, 23, 3, 1, 7 };
double stdev = ints.GetStandardDeviation();
View all various C# language feature related posts here.
August 18, 2015 Leave a comment
We’ve looked at the available concurrent collections in .NET before:
3 of these objects implement the same interface. Can you guess which three are similar in some sense? Stacks, bags and queues differ from dictionaries in that elements in those collections cannot be retrieved by an index of any sort. You can take/pop/dequeue the elements one by one but you cannot get to element #3 without first removing all elements before that.
August 17, 2015 Leave a comment
Introduction
In the previous post we went through a couple of important terms in DDD and also started coding the foundations of the web suite demo app. In particular we discussed the meaning of bounded contexts and the shared kernel. Each domain object will be defined within a specific context, e.g. the load testing context and the web monitoring context as mentioned previously. There may be some sections where the contexts overlap. These sections are contained within the shared kernel that each bounded context can refer to. Finally we started building our code and introduced abstractions for the entities, value objects and aggregate roots.
In this post we’ll first introduce the concept of ubiquitous language and then sort out the key terms that describe our problem domain.
August 14, 2015 2 Comments
In the previous post we finally solved the mystery of how the Add method was “hidden” in the ConcurrentDictionary object. We now know how explicit interface implementation works in code.
However why would you implement an interface explicitly?
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 