Entertaining C #. Five examples for a coffee break

Having written more than one article about Veeam Academy , we decided to open up a bit of internal cuisine and offer you a few examples in C # that we parse with our students. When compiling them, we made a start from the fact that our audience is novice developers, but it may also be interesting for experienced programmers to look under the cat. Our goal is to show how deep the rabbit hole is, while at the same time explaining the features of the internal structure of C #.

On the other hand, we will be glad to comment from experienced colleagues who either point out the shortcomings in our examples, or can share their own. Like questions like to use in interviews, so surely we all have something to tell.

We hope that our selection will be useful for you, help you refresh your knowledge or just smile.

Example 1

Structures in C #. They often have questions even for experienced developers, which is what so many different online tests like to use.

Our first example is an example of attentiveness and knowledge of what the block is using. And also quite a topic for communication during the interview.

Consider the code:

publicstruct SDummy : IDisposable
    {
        privatebool _dispose;
        publicvoidDispose()
        {
            _dispose = true;
        }
        publicboolGetDispose()
        {
            return _dispose;
        }
        staticvoidMain(string[] args)
        {
            var d = new SDummy();
            using (d)
            {
                Console.WriteLine(d.GetDispose());
            }
            Console.WriteLine(d.GetDispose());
        }
    }

Example 2

Constructors and the sequence of their calls is one of the main themes of any object-oriented programming language. Sometimes such a sequence of calls can surprise and, much worse, even “fill up” the program at the most unexpected moment.

So, consider the MyLogger class:

classMyLogger
{
    static MyLogger innerInstance = new MyLogger();
    staticMyLogger()
    {
        Console.WriteLine("Static Logger Constructor");
    }
    privateMyLogger()
    {
        Console.WriteLine("Instance Logger Constructor");
    }
    publicstatic MyLogger Instance { get { return innerInstance; } }
}

Suppose that this class has some business logic that we need to support logging (functionality is not so important now).

Let's see what is in our class MyLogger:

1. Static constructor set
2. There is a private constructor without parameters
3. Defined private static variable innerInstance
4. And there is an open static property Instance for communication with the outside world.

For ease of analyzing this example inside the class constructors, we added a simple console output.

Outside the class (without using tricks like reflection) we can only use the open static Instance property, which we can call as follows:

classProgram
{
    publicstaticvoidMain()
    {
        var logger = MyLogger.Instance;
    }
}

Example 3

Programmers often have to write helper functions (utilities, helpers, etc.) to make their lives easier. Usually such functions are fairly simple and often take up only a few lines of code. But you can even stumble out of the blue.

Suppose we need to implement such a function that checks a number for oddness (that is, that a number is not divisible by 2 without a remainder).

The implementation might look like this:

staticboolisOddNumber(int i)
{
    return (i % 2 == 1);
}

At first glance, everything is fine and, for example, for the numbers 5.7 and 11, we expectedly get True.

Example 4

Anyone who programmed in C # probably met with LINQ, which is so convenient to work with collections, creating queries, filtering and aggregating data ...

We will not look under the hood of LINQ. Perhaps we will do it another time.

In the meantime, consider a small example:

int[] dataArray = newint[] { 0, 1, 2, 3, 4, 5 };
int summResult = 0;
var selectedData = dataArray.Select(
    x =>
    {
        summResult += x;
        return x;
    });
Console.WriteLine(summResult);

Example 5

Let's say at once - we do not consider this example at our lectures at the Academy, but sometimes we discuss it during coffee breaks more like an anecdote.

Despite the fact that it is unlikely to be indicative from the point of view of determining the level of the developer, this example was encountered in several different tests. Perhaps it is used for universality, because it works the same way both in C and C ++, and in C # and Java.

So let there be a line of code:

int i = (int)+(char)-(int)+(long)-1;

Interested in Studying at Veeam Academy?

We are now recruiting for spring intensive C # in St. Petersburg, and we invite everyone to take an online test on the Veeam Academy website .

The course starts on February 18, 2019, will run until mid-May and will be, as always, completely free. Registration for anyone who wants to pass entrance testing is already available on the Academy website: academy.veeam.ru