codeasy .net
or Sign Up

Double agent

Double Agent

As soon as I granted Noname access through the shields of Wonderland, two things changed in my life: I wasn't that lonely anymore, and I became a double agent. On the one hand, humanity believed in me, and I was doing my best to return possession of Earth to humans. On the other hand, I revealed all of Wonderland's network to a machine, and knowing the potential damage that could cause stung a bit. The good thing is that I know what I'm doing. Do I really though? Yes, I suppose I do. This machine is the only sane creature in the world of future.

Noname needed some time to get up to speed on the Rust project. Meanwhile, I investigated Wonderland.
The whole place was quite heavily roboticized. It was both terrific and threatening at the same time. We were essentially using machines to fight other machines. We trained our coding skills on those machines that we had, reprogrammed them, added new modules and updated old ones. That's how we discovered how they are built. Unfortunately, the machines on the other side of the equation, bent on destroying humanity, where producing new versions of their own robots every week. Understanding this highlighted to me the fact that we were simply learning concepts of programming, rather than the machine's software architecture, because that changes far too often to keep up with. The skills involved in becoming a good programmer will help lay the groundwork to allow each of us to grasp a new software construction if needed.

Professions in Wonderland are divided between support and execution roles. The support track is all about supplying resources to Wonderland to make sure everyone has water, food, air, and health care. Execution professions are all about programming to fight machines. Guess which area is more popular. If you're thinking the flashy, high-speed execution track is more popular, think again! Support roles are actually more coveted. Why? Because people don't want to die, first of all. Machines hunt the best programmers the same as the U.S.A. government hunted terrorists at the start of the second millennium. In addition, if executers disappear one day, supporters have the knowledge and skills to survive. The opposite doesn't hold true: if a majority of supporters disappear, it would be difficult for executors to keep it all together and find all resources needed for life. These people are less organized and tired of endless war; above all, they just want to get some rest. No heroes here. They need hope, and I'm here to bring it with me!
Today I had one more lesson with Sintia.

Static

"Hello everyone, sorry for being late," Sintia said as she entered the class.
I had always liked when people with a high status, such as professors, managers, or presidents took a moment to apologize for being late. That small consideration shows how they value the time of other people.
"Today we are going to talk about the static keyword," she said. Taking a sip of water, she began sharing with us all her wisdom.

"Let's start talking about memory. First, we create a class Dog with two fields and a constructor:"

class Dog
{
    private string _name;
    private int _age;

    public Dog(string name, int age)
    {
        _name = name;
        _age = age;
    }
}

"How much memory does this take?" Sintia asked.
"It takes nothing because we haven't created any objects yet," answered one of the students, recalling our previous lessons.

"Well, it will still take a very tiny amount of space, but yes, for your level, it's ok to say it takes nothing," Sintia smiled.
She continued, "Next, we create two objects of class Dog, with different names and ages:"

  class Program
{
    public static void Main()
    {
        var chappy = new Dog("Chappy", 3); // _name == "Chappy", _age == 3
        var lucy = new Dog("Lucy", 5);     // _name == "Lucy", _age == 5
    }
}

"The memory layout for these objects looks like this:"

C# objects in memory

Sintia continued, "As you see, both fields are copied for every new object and changing one of them will not impact others. This is where the static keyword comes in. A static modifier declares a static member, which belongs to the type itself rather than to a specific object."

"Static fields. When we mark the field with static, it will NOT be copied every time a new object is created. To make a field static, add the static keyword right after the access modifier, just before the field's name. To access a static field, use a class name instead of the object name. Take a look at the following example:"

class Dog
{
    public static int DogsCounter; // public static field

    private string _name;
    private int _age;

    public Dog(string name, int age)
    {
        _name = name;
        _age = age;

        DogsCounter++; // Changing the static field
    }
}

class ClassWithMain
{
    public static void Main()
    {
        Dog.DogsCounter = 0; // Access static field

        var chappy = new Dog("Chappy", 3); // DogsCounter is incremented
        var lucy = new Dog("Lucy", 5);     // DogsCounter is incremented

        Console.WriteLine(Dog.DogsCounter); // Access static field
    }
}
// Outputs:
// 2

"Teo, do you understand what is happening in this example?" Sintia asked.
"Well," I said, buying time to get my answer right, "You created a static field DogsCounter and incremented it whenever a new object of type Dog was created".

"Bravo! That is exactly what this code is doing! In the end, DogsCounter contains the number of objects created, and in our case, it is 2," Sintia said.

"You mean it updates the same DogsCounter for every object?" one of the students asked.
"Exactly - take a look at the memory layout to understand it better:"

C# static fields

"As you see, the field is shared among objects if it is marked with static," Sintia concluded.

Create a class Car. Inside the class, create a public static int field CarsCount and increment it in the constructor.
In the Main method, create 5 objects of the type Car. Then, output a string containing the number of cars created to the screen, "Number of created cars is {CarsCount}", using the value of the static field for it.

"Can you say that static fields belong to a class, rather than to an object?" one of the students asked.
"Yes, you can say so," Sintia answered. She continued:
"Static fields are accessible from within any object of a class, any method, or any constructor. They can also be public or private. Just be aware that when you change the static field from one object, you change it for all other objects as well."

Insert the next C# programmer

"Now that we've covered static fields, it's time to talk about static methods. The static keyword applies to methods as well as fields. A static method behaves similarly to a non-static method, but it has access only to static fields and methods and does not require an object of a class to be created. To call a static method, use a class name instead of an object name. To make a method static, add the static keyword after the access modifier.

"I'm sorry, but this is a lot of new information right in a row. Can we just create a static method and see it in action?" someone asked.
"You want everything at once...," Sintia replied "Sure, here is an example:"

class Dog
{
    public static int DogsCount; // public static field
    public string Name;          // public NON-static field

    public void NotStaticMethod()
    {
        DogsCount = 0;          // Can access static field, no problem
        Name = "Hairy Paw-ter"; // Can access non-static field
    }

    public static void StaticMethod()
    {
        DogsCount = 0;      // Can access static field, no problem
        Name = "Chewbarka"; // Can't access non-static field. Error
    }
}

class Program
{
    public static void Main()
    {
        Dog.StaticMethod();    // Call static method on a class. No object
                               //  required.
        Dog.NotStaticMethod(); // Can't call non-static method on a class,
                               //  object needed

        Console.WriteLine(Dog.DogsCount); // Access static field via class
                                          //  name
        Console.WriteLine(Dog.Name);      // Can't access non-static field
                                          //  via class name

        var dog = new Dog();

        Console.WriteLine(dog.DogsCount); // Can't access static field via
                                          //  object
        Console.WriteLine(dog.Name);      // Can access non-static field via
                                          //  object

        dog.StaticMethod();    // Can't call a static method on an object.
                               //  Use class name.
        dog.NotStaticMethod(); // Can call non-static method on an object
    }
}

"Why is the Main method is always static?" I asked.

"I was expecting that question sooner or later," Sintia said. "It is a C# standard. The Main method should always be static. Now that we've gone over static methods, you can probably guess why we've obliged you to declare all methods with static to be able to compile a program?"

"You mean that because Main is static, it can call only static methods?" I answered/asked.
"Exactly right. If you want to call a method from Main without first creating an object, you must make that method static."

class Program
{
    static void StaticMethod()
    {
        // Something
    }

    void NotStaticMethod()
    {
        // Something
    }

    public static void Main()
    {
        StaticMethod(); // Ok. Can call static from static.

        NotStaticMethod(); // Error. Can't call non-static method like this.

        var program = new Program(); // Not standard, but still valid
        program.NotStaticMethod();   // Ok. Can call a non-static method on
                                     //  an object.
    }
}

Make the program compile by replacing or adding static modifiers. The program should output "Noname is the best human friend." to the console.

Create a class that has one public static method, GetSumBetween, that takes two integers, a and b, and returns as an integer the sum of all integers between a and b (including a and b). In the Main method, read two integers from the console, call GetSumBetween, and print the returned number to the console.
For example (don't output the green text):
>6
>10
40  // 6 + 7 + 8 + 9 + 10 = 40

"Sintia, is it possible to declare a local variable as static?" someone asked.
"No, C# doesn't support static local variables. However, C# does support static classes as well as static constructors."
"What is the difference between a usual class and a static class?" I asked.
"Well, for one, you can't instantiate a static class." Sintia began.
"Is instantiating the same as creating an object of a class?" someone interrupted.
"Instantiate means to create an instance of a class using the keyword new. The process of creating an object of a class is also called instantiating a class," Sintia explained.

"What was I saying? Ah, right. You can't instantiate a static class, and as a result, the static class can't have any non-static fields, methods, or constructors. Does everyone follow? I see lots of bewildered eyes," Sintia said, smiling and scanning the students in the classroom.

Programmer when the code compiles

The rapid pace of the class was starting to wear on me and my peers. "I think we're a bit lost," I said. "Sometimes you talk about entities we've never heard of without explanation. For example, we haven't covered what static constructor is, but we know that in a static class all constructors should be static. It would be easier if we knew static constructor was first," I complained.

Sintia stopped smiling. She stared up at the ceiling and tool a three-second pause. Then she came back down to earth with a speech. "You are right, Teo. I will be more cautious in the topic discussions. Having said that, I'm asking each and every one of you to put as much effort as you can into learning outside of class as well as in. The world's fate is in our hands. There is no way back. Only forward. Toward victory!

"Ok, let's try that again," Sintia said, recalibrating. "Static constructors. The main purpose of a static constructor is to initialize static fields, in the same way that the usual constructor initializes instance fields. To create a static constructor, add the static keyword before the constructor declaration. Be aware that static constructors can't have access modifiers, are always parameterless, and have access only to static fields and methods. Here's an example of a static class with a static constructor:"

static class Util
{
    private static int _someStaticField;
    private static string _anotherStaticField;

    private int _notStaticField; // Error: Cannot have non-static fields in
                                 //  a static class

    static Util() // Static Constructor: Must be parameterless and have no
                  //  access modifiers
    {
        _someStaticField = 0;      // Initializing static fields
        _anotherStaticField = "Secret initial value"; // Initializing static
                                                      //  fields
    }

    public void DoWhatever()
    {
        // Error: Cannot have non-static methods in a static class
    }

    public static void PrintState() // Static Method
    {
        Console.WriteLine(_someStaticField);
        Console.WriteLine(_anotherStaticField);
    }
}

"A usual constructor is called when the object is created, but when is a static constructor called?" someone asked.
"A static constructor is called automatically before the first instance is created and before any static members are referenced," Sintia replied.

Measuring distance is an essential task at Wonderland. Create a static class, DistanceMeasurer, that has one public method, GetDistance, with a return type of double, that takes 4 int parameters that represent 2D point coordinates: x1, y1, x2, y2. The GetDistance method should output the distance between the two given points (x and y) on a plane.
In the Main method, read 4 integers from the console, execute GetDistance, and output the result to the screen.
For example:
>2
>1
>3
>4
3.16227766016838

"Sintia, can a single class have both a static constructor and a usual one?" I asked.
Sintia replied, "Yes, that is an absolutely valid case. As long as the class itself is not static, it is possible. Take a look at this code sample:"

class DroidCleaner
{
    private static string _shieldsLockDownKey; // Static field

    private string _name; // Non-static field

    static DroidCleaner() // Static constructor
    {
        _shieldsLockDownKey = "02344F70"; // Initializing static fields
    }

    public DroidCleaner(string name) // Instance (usual) constructor
    {
        _name = name; // Initializing instance (usual) fields
    }

    public static void SetNewShieldsLockDownKey(string key) // Static method
    {
        _shieldsLockDownKey = key; // Only has access to static fields
    }

    public void PrintName() // Non-static method
    {
        Console.WriteLine(_name); // Has access to instance fields
    }
}

Wonderland has a formal president. He is a bit eccentric, and likes when all text that he reads is placed in a frame of stars: *. For example, instead of "Hello, sir," he expects to see:
**************
* Hello, sir *
**************
Create a static class TextFramePretifier. It should contain a private static int field, _textsPretified, that increments for every text that this class processes. Add a static constructor that initializes _textsPretified to zero. Also add a public static method Prettify that takes a string text and returns void. The method should first print a sentence "Processing text: {_textsPretified}" that indicates how many texts have been processed. Then, from the new line, it should print the given text into a frame of stars. The input text is guaranteed to take no more than one line. The user string should have one space before and after the frame, as shown in the below example.
In the Main method, read a string from the console and call your method with this input. Repeat this until user inputs "exit". For example:
>Why frame is so important, sir?
Processing text: 1
***********************************
* Why frame is so important, sir? *
***********************************
>You look great today, sir!
Processing text: 2
******************************
* You look great today, sir! *
******************************
>exit

Does this C# program work?

The president was happy with your implementation of the TextFramePretifier... for one day. Then he decided that he wants to control the width of the frame. Take the code of the previous task and modify it to take an integer that represents the width of the frame and then print a message in the frame as you did in previous task, but using the given width this time. Write as many words as you can in each line; if there is an empty space, fill it with spaces. The number of words in a message will not exceed 100. All words are guaranteed to be shorter than (frameWidth - 4). Treat spaces as word separators and all other symbols, such as commas or question marks, as part of the word they're connected to. The text is guaranteed to have only single spaces.
For example:
>15
>You look great today, sir!
Processing text: 1
***************
* You look    *
* great       *
* today, sir! *
***************
>A zebra does not change its spots.
Processing text: 2
***************
* A zebra     *
* does not    *
* change its  *
* spots.      *
***************
>exit

Lesson well done!

This site uses cookies. By continuing to browse this site you are agreeing to our use of cookies.

Got it!