Programming/C Sharp - Revision history

Brodriguez: Add some notes

2023-04-22T19:54:53Z

Add some notes

← Older revision		Revision as of 19:54, 22 April 2023
Line 2:		Line 2:

	It's used often in large, enterprise/business scale projects, due to having solid scaffolding for enforcing consistency through the project, which allows many people to work on a given project with less maintenance overhead. This is accomplished via things like required strong typing and good support for the [[interface class]] structure.		It's used often in large, enterprise/business scale projects, due to having solid scaffolding for enforcing consistency through the project, which allows many people to work on a given project with less maintenance overhead. This is accomplished via things like required strong typing and good support for the [[interface class]] structure.

			== Other ==

			* Classes are always passes by reference.
			* Structs and value types (when not part of a class) are always passed by value.

Brodriguez: Brodriguez moved page C Sharp to Programming/C Sharp

2020-10-25T17:27:20Z

Brodriguez moved page C Sharp to Programming/C Sharp

← Older revision	Revision as of 17:27, 25 October 2020
(No difference)

Brodriguez: Correct formatting

2020-05-06T14:31:57Z

Correct formatting

← Older revision		Revision as of 14:31, 6 May 2020
Line 104:		Line 104:
	Accessibility levels indicate what can and cannot access the given variable or function. The most types are as follows:		Accessibility levels indicate what can and cannot access the given variable or function. The most types are as follows:

	{ note \| See [https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/accessibility-levels this link] to see the all levels in the Microsoft docs. }		{{ note \| See [https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/accessibility-levels this link] to see the all levels in the Microsoft docs. }}
	* <code>public</code> - Anything can access it.		* <code>public</code> - Anything can access it.
	* <code>protected</code> - This class and all inheriting children can access it.		* <code>protected</code> - This class and all inheriting children can access it.

Brodriguez: Update formatting

2020-05-06T12:47:11Z

Update formatting

← Older revision		Revision as of 12:47, 6 May 2020
Line 217:		Line 217:
	Classes are generally defined in new, separate files. A good rule of thumb is to only include multiple classes in one file if they are nested, inner subclasses within the first class.		Classes are generally defined in new, separate files. A good rule of thumb is to only include multiple classes in one file if they are nested, inner subclasses within the first class.

	~~Note that in~~ C#, class variables and methods are often called with <code>this.<value></code>, to help differentiate between local and class level values. However, this is optional and will not always be followed.		{{ note \| In C#, class variables and methods are often called with <code>this.<value></code>, to help differentiate between local and class level values. However, this is optional and will not always be followed. }}

	=== Class Variables ===		=== Class Variables ===

Brodriguez: Create struct section

2020-05-06T12:46:33Z

Create struct section

← Older revision		Revision as of 12:46, 6 May 2020
Line 182:		Line 182:

	=== Structs ===		=== Structs ===
	Structs are essentially a means to group sets of variables together.		Structs are essentially a means to group sets of variables together. They are handled very similarly to C structs.

			Unlike C# arrays or dicts, structs are able to combine as many variable types as desired.

			==== Struct Declaration ====
			First, declare the struct type itself.<br>
			If familiar with classes, this will look a lot like declaring a simplified class that has only class variables and nothing else.
			struct MyStructObject
			{
			public bool test_bool;
			public int test_int;
			public string test_string;
			}

			Once the struct type is declared, we can create instances of it to use.
			MyStructObject a_struct = new MyStructObject();

			==== Accessing Struct Items ====
			Structs are basically containers for holding the associated variables within. Thus, we can easily access the contained variables with syntax that should look fairly familiar.
			// Set or update struct values.
			a_struct.test_bool = true;
			a_struct.test_int = 5;
			a_struct.test_string = "My test string";

			// Print struct values.
			Console.WriteLine(a_struct.test_bool);
			Console.WriteLine(a_struct.test_int);
			Console.WriteLine(a_struct.test_string);

Brodriguez: Create dictionary section

2020-05-06T12:25:50Z

Create dictionary section

← Older revision		Revision as of 12:25, 6 May 2020
Line 148:		Line 148:
	Dictionaries can be incredibly powerful. See [[Dictionaries]] for more info.		Dictionaries can be incredibly powerful. See [[Dictionaries]] for more info.

			==== Declaring Dictionaries ====
			Similarly to C# arrays, once the data type is declared in a dictionary, it cannot be changed. However, note that "keys" and "values" in a dictionary can each hold a different, unique data type.

			For example, to declare a dictionary of string keys and int values, use:
			Dictionary<string, int> my_dict = new Dictionary<string, int>();

			==== Accessing Dictionary Values ====
			To set new key-value pairs, use:
			my_dict.Add(<key>, <value>);

			To read an existing key-value pair, use:
			my_dict[<key>]

			To update an existing key-value pair, use:
			my_dict[<key>] = <updated_value>;

			To remove an existing key-value pair, use:
			my_dict.Remove(<key>);

			==== Example ====
			Here's an example of a dictionary for a hypothetical business trying to track count of items sold.

			// Create our dict.
			Dictionary<string, int> product_sold = new Dictionary<string, int>();

			// Add initial values.
			product_sold.Add("Ice Cream", 50);
			product_sold.Add("Burgers", 56);
			product_sold.Add("Pizza", 102);

			// Sold another pizza. Update value.
			product_sold["Pizza"] += 1;

	=== Structs ===		=== Structs ===

Brodriguez: Create array section

2020-05-06T12:07:37Z

Create array section

@@ Line 111: / Line 111: @@
 === Return Type ===
 The return type is exactly that. Aka, the type of the variable that the function returns on function exit. If a variable does not return anything, then the type of <code>void</code> type.
 == Classes ==
 Classes are generally defined in new, separate files. A good rule of thumb is to only include multiple classes in one file if they are nested, inner subclasses within the first class.

Brodriguez: Add function section

2020-05-06T11:42:06Z

Add function section

← Older revision		Revision as of 11:42, 6 May 2020
Line 88:		Line 88:
	}		}

			== Functions ==
			Functions in C# are syntactically handled similarly to C, with a few modifications. The format is:
			<accessibility> <return_type> <function_name>(<args>)
			{
			// Function logic here.
			}

			For example:
			public void MyFunc(int my_int, string my_string)
			{
			// Function logic here.
			}

			=== Accessibility ===
			Accessibility levels indicate what can and cannot access the given variable or function. The most types are as follows:

			{ note \| See [https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/accessibility-levels this link] to see the all levels in the Microsoft docs. }
			* <code>public</code> - Anything can access it.
			* <code>protected</code> - This class and all inheriting children can access it.
			* <code>private</code> - Only this class can access it. Not even inheriting children have access.

			=== Return Type ===
			The return type is exactly that. Aka, the type of the variable that the function returns on function exit. If a variable does not return anything, then the type of <code>void</code> type.

	== Classes ==		== Classes ==

Brodriguez: Correct typo

2020-05-06T11:14:33Z

Correct typo

← Older revision		Revision as of 11:14, 6 May 2020
Line 187:		Line 187:
	// Check if our provided value is valid before setting.		// Check if our provided value is valid before setting.
	// In this case, we simply make sure it's 3 characters or greater.		// In this case, we simply make sure it's 3 characters or greater.
	if (this.test_string.~~length~~ > 2)		if (this.test_string.Length > 2)
	{		{
	this.test_string = value;		this.test_string = value;

Brodriguez: Minor formatting

2020-05-06T10:54:12Z

Minor formatting

← Older revision		Revision as of 10:54, 6 May 2020
Line 2:		Line 2:

	It's used often in large, enterprise/business scale projects, due to having solid scaffolding for enforcing consistency through the project, which allows many people to work on a given project with less maintenance overhead. This is accomplished via things like required strong typing and good support for the [[interface class]] structure.		It's used often in large, enterprise/business scale projects, due to having solid scaffolding for enforcing consistency through the project, which allows many people to work on a given project with less maintenance overhead. This is accomplished via things like required strong typing and good support for the [[interface class]] structure.


	== Comments ==		== Comments ==
Line 25:		Line 26:

	#endregion MyRegionName		#endregion MyRegionName


	== Variables ==		== Variables ==
Line 47:		Line 49:
	bool a_bool = true;		bool a_bool = true;
	int converted_bool = Convert.ToInt32(a_bool);		int converted_bool = Convert.ToInt32(a_bool);


	== If Statements ==		== If Statements ==
Line 84:		Line 87:
	break;		break;
	}		}


	== Classes ==		== Classes ==