We’ll be managing Lists<> of different types and calling some of the most common functions.

Read the complete tutorial after the break.

Hi there, thanks for reading the blog.

Ok first off let’s create a new Console Application.

Add the following code in the Main() method:

List<string> MyStringList = new List<string>();

List<int> MyIntList = new List<int>();

List<object> MyObjectList = new List<object>();

With this code we’re declaring three lists, one of type string, one of type int  and one of type object.

In the object type list we can store all sorts of information from chars, to bytes, to strings, to ints. It’s a generic type of list. Useful for passing parameter to a SQL Stored Procedure. But that’s a bit ahead of our scope.

Let’s add some items to our lists.

MyStringList.Add("Hello, this is the first item.");
MyStringList.Add("Second item.");
MyStringList.Add("Third item.");

We’ve added three strings to our list. Simple enough right?

There is a neat function in the Lists class that Inserts an item to any zero-based index we want. For instance:

MyStringList.Insert(1, "Modified second item."); 

We’ll insert "Modified second item.” to the second position in our list displacing every item after it by one.

Write down this code to see it in action:

foreach (string X in MyStringList)
{
       Console.WriteLine(X);
}
Console.ReadLine();

For each string we find in MyStringList, write down the string X to the console.

That concludes the string based tutorial for lists. Stay tuned for int based, and object based.

Decimal – Binary – Hexadecimal

Students are asked to build this program in their first week of school so I thought a lot of my readers would enjoy this.

With this program you’ll be able to convert from all three formats to all three formats. Each conversion is in it’s own method so you can easily see how it works.

Have fun guys!

This is how our final solution will look like.

We’ll use:

• Labels
• Textboxes
• Buttons
• Class Instancing
• Number Formatting

Download the final solution here.

The complete tutorial, after the break.

So let’s get started.

Create a class called ConversionFormulas. We’ll hold all of our formulas in this class.

#region “Decimal Conversions”
public string DecimaltoBinary(TextBox txtdecimal, TextBox txtbinary)
{
Int32 DecimalNumber = Convert.ToInt32(txtdecimal.Text);
Int64 BinaryNumber;
char[] BinaryArray;
string BinaryResult = “”;

while (DecimalNumber > 0)
{

BinaryNumber = DecimalNumber % 2;
BinaryResult += BinaryNumber;

DecimalNumber = DecimalNumber / 2;
}

BinaryArray = BinaryResult.ToCharArray();
Array.Reverse(BinaryArray);

BinaryResult = new string(BinaryArray);

return BinaryResult;
}

public string DecimaltoHexadecimal(TextBox txtdecimal, TextBox txthexadecimal)
{
int DecimalValue = Convert.ToInt32(txtdecimal.Text);
string HexValue = DecimalValue.ToString(“X”);
return HexValue;
}
#endregion

#region “Binary Conversions”
public string BinarytoDecimal(TextBox txtdecimal, TextBox txtbinary)
{
return Convert.ToInt64(txtbinary.Text, 2).ToString();
}
#endregion

#region “Hexadecimal Conversions”
public string HexadecimaltoDecimal(TextBox txtdecimal, TextBox txthexadecimal)
{
int DecimalValue = int.Parse(txthexadecimal.Text, System.Globalization.NumberStyles.HexNumber);
string DecimalString = DecimalValue.ToString();

return DecimalString;
}
#endregion

Notice that all of our methods return a string value at the end. This is so we can easily place that string to a textBox of our chosing.

Go back to Form1 and create an instance of the previous class so we can access it’s methods.

Conversion_Formulas oFormulas = new Conversion_Formulas();

Next we have to program our three buttonClick events in Form1. Double click on each button and copy the following code:

private void button1_Click(object sender, EventArgs e)
{
textBox2.Text = oFormulas.DecimaltoBinary(textBox1, textBox2);
textBox3.Text = oFormulas.DecimaltoHexadecimal(textBox1, textBox3);
}

private void button2_Click(object sender, EventArgs e)
{
textBox1.Text = oFormulas.BinarytoDecimal(textBox1, textBox2);
textBox3.Text = oFormulas.DecimaltoHexadecimal(textBox1, textBox3);

}

private void button3_Click(object sender, EventArgs e)
{
textBox1.Text = oFormulas.HexadecimaltoDecimal(textBox1, textBox3);
textBox2.Text = oFormulas.DecimaltoBinary(textBox1, textBox2);
}

Notice that when we call on each method we have to pass parameters to it, we have to let the method know what textBoxes to work with.

That’s about it. I hope you guys enjoyed this tutorial, if you have any question feel free to ask in the comments.

Our final solution will look like this:

How our final solution will look like.

We’ll use:

• Labels
• Textboxes
• Buttons
• Class Instancing

Download the final solution here.

The complete tutorial, after the break.

First thing we’ll do is create a class called ConversionFormulas.

Inside this class we’ll create two methods. One to convert from Farenheit to Celcius, and another to convert from Celcius to Farenheit.

Inside your ConversionFormulas class create these methods:

public void ConvertTemperatureFarenheit(TextBox txt1, TextBox txt2)
{
double farenheit = Convert.ToDouble(txt1.Text);
double celcius = (farenheit – 32) * (5.0 / 9.0);
txt2.Text = Convert.ToString(celcius);
}

public void ConvertTemperatureCelcius(TextBox txt1, TextBox txt2)
{
double celcius = Convert.ToDouble(txt2.Text);
double farenheit = (celcius * (9.0 / 5.0)) + 32;
txt1.Text = Convert.ToString(farenheit);
}

Let’s analyze the first line of each method for a bit. When you create a method you can give the method parameters to use. Let me explain what this means:

Let’s say you’re the boss of a sushi chef. You buy him a new knife one day and instruct him on how to gut the fish, cut the fish, scale it, cook it, etc. The chef knows that how to act when he recieves a fish. His instructions were explained by his boss. One day he gets a fish and proceeds to do everything a chef is supposed to do.

It’s a similar situation with methods. You build methods that will work with other controls,methods,etc. Our ConvertTemperatureFarenheit method knows it will recieve 2 textboxes and that’s how we have built it.

You’ll see why we did this in a second.

In your Form1 class create an instance of your ConversionFormulas class:

ConversionFormulas oConversionFormulas = new ConversionFormulas();

Now go to your design tab of Form1 and double click on one button, then double click on the other.

Two onClick method will generate, empty.

private void button1_Click(object sender, EventArgs e)
{

}

private void button2_Click(object sender, EventArgs e)
{

}

When a user click button1 they want to convert to celcius so let’s call that method:

private void button1_Click(object sender, EventArgs e)
{
oConversionFormulas.ConvertTemperatureFarenheit(textBox1, textBox2);
}

private void button2_Click(object sender, EventArgs e)
{
oConversionFormulas.ConvertTemperatureCelcius(textBox1, textBox2);
}

Notice we first called the object we created of the ConversionFormulas class, then called the methods, then added the parameters we needed; in this case textBox1 and textBox2.

That conclused this tutorial. Hope you enjoyed it.

See ya soon,

Serg

We’ll use:

• Lists.
• Switch Case.
• Random Class.

This is what our final solution will look like: Note, the magnifying glass is a picturebox.

Download the final solution here.

The final solution outcome.

Look out for the complete tutorial after the break.

First, we’ll want to build three string Lists<>, one for each of the characters archetypes most RPG’s have: The Nimble Thief/Bowman, The Average Adventurer and the Hulking Giant. Then another three lists for the weapon type of each type of character. A nimble uses a katana type weapon, a buff dude uses a two-handed axe, you get the gist of it? Finally, three more lists for the suffix a weapon might have.

The finished product we’re looking for is something like:

Swift Jian of Lament.

Cumbursome Claymore of The Ancients.

Create a new class for your solution called ItemLists. In that class write:

Declare your code:

List<string> SizeLight = new List<string>();
List<string> SizeMedium = new List<string>();
List<string> SizeHeavy = new List<string>();

List<string> TypeWeaponLight = new List<string>();
List<string> TypeWeaponMedium = new List<string>();
List<string> TypeWeaponHeavy = new List<string>();

List<string> WeaponSuffixEsoteric = new List<string>();
List<string> WeaponSuffixTechnologic = new List<string>();
List<string> WeaponSuffixNaturalistic = new List<string>();

With this bit of code you are creating nine lists of type string. One for each character type.

In that same class, create a void method called GenerateTheLists().

Write the following in that Method:

SizeLight.Add(“Swift”);
SizeLight.Add(“Light”);
SizeLight.Add(“Double-Quick”);
SizeLight.Add(“Supersonic”);
SizeLight.Add(“Hasty”);
SizeLight.Add(“Agile”);
SizeLight.Add(“Hypersonic”);
SizeLight.Add(“Nimble”);
SizeLight.Add(“Rapid”);
SizeLight.Add(“Velocious”);
SizeLight.Add(“Racing”);
SizeLight.Add(“Flashing”);

SizeMedium.Add(“Sturdy”);
SizeMedium.Add(“Metallic”);
SizeMedium.Add(“Hardy”);
SizeMedium.Add(“Weighted”);
SizeMedium.Add(“Hilted”);
SizeMedium.Add(“Sharpened”);
SizeMedium.Add(“Devious”);
SizeMedium.Add(“Chromed”);
SizeMedium.Add(“Casted”);
SizeMedium.Add(“Polished”);
SizeMedium.Add(“Detailed”);
SizeMedium.Add(“Ornamented”);

SizeHeavy.Add(“Heavy”);
SizeHeavy.Add(“Cumbersome”);
SizeHeavy.Add(“Titanic”);
SizeHeavy.Add(“Two-Handed”);
SizeHeavy.Add(“Collosal”);
SizeHeavy.Add(“Gold-plated”);

TypeWeaponLight.Add(“Katana”);
TypeWeaponLight.Add(“Rapier”);
TypeWeaponLight.Add(“Tachi”);
TypeWeaponLight.Add(“Jian”);
TypeWeaponLight.Add(“Thinsword”);
TypeWeaponLight.Add(“Twig”);

TypeWeaponMedium.Add(“Gladius”);
TypeWeaponMedium.Add(“Broadsword”);
TypeWeaponMedium.Add(“Small-sword”);
TypeWeaponMedium.Add(“Dao”);
TypeWeaponMedium.Add(“Excalibur”);
TypeWeaponMedium.Add(“Sabre”);
TypeWeaponMedium.Add(“Two-handed sword”);

TypeWeaponHeavy.Add(“Claymore”);
TypeWeaponHeavy.Add(“Chained-ball”);
TypeWeaponHeavy.Add(“Mace”);
TypeWeaponHeavy.Add(“Trunk”);
TypeWeaponHeavy.Add(“Sword”);

WeaponSuffixEsoteric.Add(“of Lament.”);
WeaponSuffixEsoteric.Add(“of Spectres.”);
WeaponSuffixEsoteric.Add(“of The Reaper.”);
WeaponSuffixEsoteric.Add(“of Baphomet.”);

WeaponSuffixTechnologic.Add(“2.0″);
WeaponSuffixTechnologic.Add(“of The Internet.”);
WeaponSuffixTechnologic.Add(“of Electricity.”);
WeaponSuffixTechnologic.Add(“of Intranetz.”);
WeaponSuffixTechnologic.Add(“of Leeroy Jenkins.”);

WeaponSuffixNaturalistic.Add(“of Gaia.”);
WeaponSuffixNaturalistic.Add(“of Mother Earth.”);
WeaponSuffixNaturalistic.Add(“of The Land.”);
WeaponSuffixNaturalistic.Add(“of Trents.”);

What we’re doing with those long lines of code is adding a string each time we call on the .Add methodn of each list. We’re populating the lists with bits and pieces.

Now we have our lists, we have our name, good, great, excellent! However since we created the lists and it’s contents in another class we won’t be able to access them from our main Form, “Form1″.

We must create access properties. Write this down in your ItemLists class.

public List<string> pSizeLight
{
get { return SizeLight; }
set { SizeLight = value; }
}

public List<string> pSizeMedium
{
get { return SizeMedium; }
set { SizeMedium = value; }
}

public List<string> pSizeHeavy
{
get { return SizeHeavy; }
set { SizeHeavy = value; }
}

/************************************/

public List<string> pTypeWeaponLight
{
get { return TypeWeaponLight; }
set { TypeWeaponLight = value; }
}

public List<string> pTypeWeaponMedium
{
get { return TypeWeaponMedium; }
set { TypeWeaponMedium = value; }
}

public List<string> pTypeWeaponHeavy
{
get { return TypeWeaponHeavy; }
set { TypeWeaponHeavy = value; }
}

/************************************/

public List<string> pWeaponSuffixEsoteric
{
get { return WeaponSuffixEsoteric; }
set { WeaponSuffixEsoteric = value; }
}

public List<string> pWeaponSuffixTechnologic
{
get { return WeaponSuffixTechnologic; }
set { WeaponSuffixTechnologic = value; }
}

public List<string> pWeaponSuffixNarutalistic
{
get { return WeaponSuffixNaturalistic; }
set { WeaponSuffixNaturalistic = value; }
}

What this code is doing is letting us access the lists from anywhere. That’s all you need to know.

Ok, we’re done working on the ItemLists class. Now let’s move on to Form1.

First things first, we need to create an instance of the ItemLists class to use all the methods and attributes in that class. Write this in your Form1 Class:

ItemsLists oItemLists = new ItemsLists();

Now we can use the Lists we create in the other class by calling on the oItemLists object.

We want the program to randomly select items from the list and use them, so let’s create a Random object. Write this in your Form1 Class:

Random RandomSelector = new Random();

We also want the final string that our program generates to be saved, so create a string array. Write this in your Form1 Class:

string[] GeneratedWeaponName = new string[2];

Now let’s get down and dirty, go the design tab of your form and double click on your picturebox. Program the following in the Click event:

switch (comboBox1.SelectedIndex)
{
case 0:
int a = RandomSelector.Next(0, oItemLists.pSizeLight.Count);
int b = RandomSelector.Next(0, oItemLists.pTypeWeaponLight.Count);
string SizeLight = oItemLists.pSizeLight[a];
string WeaponLight = oItemLists.pTypeWeaponLight[b];
string GeneratedNameA = SizeLight + ” ” + WeaponLight;
GeneratedWeaponName[0] = GeneratedNameA;
break;

case 1:
int c = RandomSelector.Next(0, oItemLists.pSizeMedium.Count);
int d = RandomSelector.Next(0, oItemLists.pTypeWeaponMedium.Count);
string SizeMedium = oItemLists.pSizeMedium[c];
string WeaponMedium = oItemLists.pTypeWeaponMedium[d];
string GeneratedNameB = SizeMedium + ” ” + WeaponMedium;
GeneratedWeaponName[0] = GeneratedNameB;
break;

case 2:
int f = RandomSelector.Next(0, oItemLists.pSizeHeavy.Count);
int g = RandomSelector.Next(0, oItemLists.pTypeWeaponHeavy.Count);
string SizeHeavy = oItemLists.pSizeHeavy[f];
string WeaponHeavy = oItemLists.pTypeWeaponHeavy[g];
string GeneratedNameC = SizeHeavy + ” ” + WeaponHeavy;
GeneratedWeaponName[0] = GeneratedNameC;
break;
}

switch (comboBox2.SelectedIndex)
{
case 0:
int a = RandomSelector.Next(0, oItemLists.pWeaponSuffixEsoteric.Count);
string WeaponSuffixA = oItemLists.pWeaponSuffixEsoteric[a];
GeneratedWeaponName[1] = WeaponSuffixA;
break;

case 1:
int b = RandomSelector.Next(0, oItemLists.pWeaponSuffixTechnologic.Count);
string WeaponSuffixB = oItemLists.pWeaponSuffixTechnologic[b];
GeneratedWeaponName[1] = WeaponSuffixB;
break;

default:
int c = RandomSelector.Next(0, oItemLists.pWeaponSuffixNarutalistic.Count);
string WeaponSuffixC = oItemLists.pWeaponSuffixNarutalistic[c];
GeneratedWeaponName[1] = WeaponSuffixC;
break;
}

Oh shit! Don’t be intimidated by this code, it’s incredibly simple to understand once you follow along with it.

Let’s look at the first part. It’s a switch code, that accepts a number from the SelectedIndex from a ComboBox.

Ok, when a user clicks on our pictureBox1, we’ll act according to what the selectedIndex is. Simple enough.

Now let’s look at our cases, if the selectedIndex is zero, the program does the following:

Gets a random number from o to the ammount of items our list has. So if our list has 10 items, it will generate a number from 0 to 10.

It does the same for the other list as well, saving the number to variables a and b respectively.

Then using those numbers as indexes it retrieves the item from the list in position a, and saves the string to a string variable.

After that the program simply concatenates both retrieves strings and saves it to another string, which in turn is saved to the string array we declared earlier in our program.

Up to this point, we have generated the first part of our weapon name. So if we generated the name, the output would be:

Cumbersome Two-Handed Axe

Do the same for the weapon suffixes and we have ourselves a fully fledged name generator!

I hope you guys have enjoyed reading this tutorial. I encourage reader to please send me feedback so I can improve in areas I’m lacking. This is my first blog after all.

See ya soon!

I made this blog in order to host some of my tutorials for programming in C#. To understand the tutorials you will have to have a beginner to intermidiate level of the C# language. Advanced users should look elsewhere for more advanced tutorials.

The tutorials here will range from simple programs to manipulate numbers, to semi advanced  game programming.

If you love to program I’d like to recommend you visit www.dreamincode.net

It is a forum for asking all sorts of questions regarding a wide range of Languages. C#, PHP, SQL, you name it, it has a subforum there.

Add me to your friends list: papuccino1

First up on the list of game tutorials is a full Bingo game.  Stay tuned.

See you soon,

Serg