Sometimes we do love PowerShell for its flexibility, but every so often we don’t. During this (really) small article we would learn how to create PowerShell function and pass parameters to it.

You may ask “Hey, what can be wrong here? I just want to write a simple function like I do in C#. Just several function parameters I can work with.”

Well, in some cases everything goes wrong. Let’s figure it out a little.

## What if

What if you want to create a simple function with parameters?

In C# language, you’d write something similar to this

```csharp
void MyFunction(string message)
{
  System.Diagnostics.Debug.WriteLine($"MyFunction: {message}");
}
MyFunction("Hello");  // call the function
```

And to execute the function, you simply do `MyFunction("Hello")`.

That was simple, hah?

In PowerShell you can do the same this way:

```powershell
function My-Function($Message) {
  Write-Host "My-Function: $Message"
}
My-Function("Hello")  # call the function
# or
My-Function "Hello again"
# or
My-Function -Message "And once again"
```

Well. PowerShell gives you an ability to call the function in several ways.

But what to do if you want to make function parameter strictly typed? Then you have to use an additional block of code — `[Parameter()]`. (That looks like an attribute in C#) and the next version of our sample will be:

```powershell
function My-Function() {
  param([Parameter()] [string] $Message)

  Write-Host "My-Function: $Message"
}

# I left only one function call example here
My-Function "Hello"
```

Both examples look probably the same, except for a strange parameter declaration inside the `param` section. This one — `[Parameter()] [string] $Message`. It seems too much exceeded characters to create a typed parameter for the function, but it is how it works.

`[Parameter()] [string] $Message` says, “Hey, I want a Message parameter of type string”. And PowerShell does it. Moreover, you can create as many parameters as you wish:

```powershell
param(
  [Parameter()] [string] $FirstName,
  [Parameter()] [string] $Address,
  [Parameter()] [int] $Age
)
```

## What about required parameters?

What to do if you want to make one of parameters required?

The answer is simple — use `Mandatory` keyword:

```powershell
[Parameter(Mandatory)] [string] $Name
```

That’s all for this post.

Try PowerShell by your own — it is way more powerful that it looks like at first.


PowerShell functions with parameters like in C#

This guide will help you in installing .Net Core and use C# on your Raspberry Pi 4.

## Prerequisites

- Raspberry Pi 4 with ready-to-go Raspbian system installed

**Note**

_I cover two different approaches on how to install .Net Core on Raspberry device.
The first one is easier as we need to have a browser while the other one assumes that we do not have any browser (or do not want to) and that is why a behavior is slightly different._

## Before installing .Net Core 3.1

Before the installation, we need to check if we already have installed all dependencies needed by .Net Core.

Visit [this](https://github.com/dotnet/core/blob/master/Documentation/linux-prereqs.md) page and check which packages do you need. Raspbian is based on Debian, so we need to install:

- libicu63
- libssl1.1

Open a terminal application on your Raspberry and run the following commands (note that we also need to install `wget` in order to download .net core package itself):

```bash
sudo apt-get -y update
sudo apt-get -y install wget libicu63 libssl1.1
```

## Download and install .Net Core

Unfortunately, at the moment this is no a simple way to install .Net Core using `apt-get` command. We need to download a distribution `tar` archive and install it manually. So here we go.

1. Go to [.Net Core download page](https://dotnet.microsoft.com/download/dotnet-core) and find the latest stable version. In my case, it is .Net Core 3.1.
2. Open that page in the browser and find ARM32 binary file under SDK section. After clicking the link, a new page will open and download will immediately start.
3. Open a terminal and execute a command
   `sudo mkdir -p /usr/share/dotnet`
   This will create a necessary directory.
4. Switch to your Downloads folder and execute another script to unpack downloaded archive:
   `sudo tar -zxf dotnet-sdk-3.1.102-linux-arm.tar.gz -C /usr/share/dotnet`
5. Then you need to create a symbolic link to the dotnet command. This will make dotnet command accessible through the terminal session.
   `sudo ln -s /usr/share/dotnet/dotnet /usr/bin`
6. That is all! Let’s check that everything works by executing a command
   `dotnet --version`
   And you should see something like this
   `3.1.102`

## What if you want to use `wget` instead of a browser?

Follow these additional steps if you don’t have a browser installed or do not have a desktop environment at all at your Raspberry (it calls headless).

1. You need to install `wget` in order to download .Net Core distribution package. To do this run (being on the part of a prerequisite of the article) the following command in the terminal:
   `sudo apt-get -y install wget`
2. While we used the distribution file downloaded from a browser, in this case, we need to do this via `wget` we just downloaded. After clicking the link, a new page will open and download will immediately start. But this behavior is useless for us, as we want to do the installation by a command line.

   Fortunately, there is a link `click here to download manually` so we can copy the full link address and use it for our purpose. Copy this link address. In my case the URL is
   [https://download.visualstudio.microsoft.com/download/pr/349f13f0-400e-476c-ba10-fe284b35b932/44a5863469051c5cf103129f1423ddb8/dotnet-sdk-3.1.102-linux-arm.tar.gz](https://download.visualstudio.microsoft.com/download/pr/349f13f0-400e-476c-ba10-fe284b35b932/44a5863469051c5cf103129f1423ddb8/dotnet-sdk-3.1.102-linux-arm.tar.gz)

3. Run this command for download (use your URL)
   `wget https://download.visualstudio.microsoft.com/download/pr/349f13f0-400e-476c-ba10-fe284b35b932/44a5863469051c5cf103129f1423ddb8/dotnet-sdk-3.1.102-linux-arm.tar.gz`
4. Next, follow from 3rd step of the main tutorial but keep in mind that by default `wget` command saves downloaded files in `/pi` directory.

## That is all

Now you are ready to develop amazing applications in C# for Raspberry Pi.


PowerShell functions with parameters like in C#

Exploring Raspberry Pi 4 with C#