So a recent project has facilitated me brushing up on my C# – so I thought I would share some basic translations of things that can be frustrating when you know the usual programming principles (object orientated programming), but not all the syntax.
A quick couple of points to note:
- C# is a strictly typed language, that means you have to know about what your variables are going to be, and yes, you have to declare them somewhere sensible
- Accessing methods and properties within your class does not require usage of $this – you’re talking about true scope of variables and methods, so you don’t have to worry about it
- Public, protected and private are essentially the same
- You have to declare the return types on every method, none of this return an object or false stuff
- Namespacing is essentially the same as if you were following the PSR-4 standard
- Everything, including strings, are objects
- A single quote and a double quote are fundamentally different things
Declaring a variable
Okay, so starting with the basics, declaring a variable is basically the same, except you have to declare the type, so declaring age as a variable, integer, with the value of 25 would look like this in PHP:
$age = 25;
However, in C# it would look like this
int age = 25;
Moving into this being a property in a class, you must rather than optionally, or have to if you’re conforming to PSR-2, so in PHP it looks like this
public $age = 25;
In C# it’s going to look like this:
public int age = 25;
Declaring methods
Okay this is an easy one in PHP, it looks something like this. Using PHP 7.1 we can strictly type the return.
public function myMethod(MyClassOne &$argumentByReference, MyClassTwo $argumentByValue) : ObjectClass
{
// Do something in your method here
}
// This would be called by doing something like
$object->myMethod($parsedByReference, $parsedByValue);
This one gets slightly different when translated into C# for a couple of reasons. You must declare the types of the parameter, the type of the response(s), it also gets a bit different when calling the method too:
public ObjectClass myMethod(ref MyClassOne argumentByReference, MyClassTwo argumentByValue)
{
// Do something in your method here
}
// Now calling your method would look slightly different
Object.myMethod(ref parsedByReference, parsedByValue);
Using Objects
Instantiating objects isn’t much different either, really; it looks different but that’s because it’s strictly typed.
Main difference between use statements in PHP and C# (other than that it is using in C#) is that you use a namespace, the classes contained therein (this namespace only, not its children) are automatically available.
In PHP I want to include a class and then instantiate it, will look something like this:
use Vendor\Project\Namespace\ClassName; // Then you have all of your usual declarations, which we'll get to $myObject = new ClassName();
However when you want to do this in C# it looks something like this:
using Vendor\Project\Namespace; // Then all of your usual declarations ClassName myObject = new ClassName();
Declaring Classes, using Inheritance and Interfaces
This gets a bit different, but only syntactically. We’re going to create Person as an abstract class, this will be extended by the Employee class. Employee is going to implement an interface called Emailable.
For the sake of ease I’ve not separated these into different files
In PHP it would look like this:
abstract class Person{
// Shared functionality here
}
interface Emailable{
// Interface requirements here
}
class Employee extends Person implements Emailable{
// Employee functionality, including Emailable requirements, in here
}
In C# however it would look like this
namespace ObjectOrientatedPrinciples.MyExample
{
abstract public class Person
{
}
interface Emailable
{
}
public class Employee : Person, Emailable
{
}
}
You will see from this that C# doesn’t necessarily draw the distinction between classes being extended and interfaces being implemented.
Arrays and Lists
This is actually the only thing I found to be a little bit painful, however there is a decent tutorial on arrays on the Microsoft Developer Network (MSDN)
Closing Off
I’ll leave it at that for tonight. But a quick few bits that I thought might help someone out, it would’ve helped me if I could’ve found this article this morning. Though admittedly probably only saved me an hour or so. Not the point though, here it is 🙂