.NET

https://learn.microsoft.com/en-us/dotnet/
Admin
.NET is a free, cross-platform, and open-source developer platform for building web, mobile,...
Tokens:37,437,764
Snippets:224,716
Trust Score:10
Update:1 day ago
Show doc for...
Tokens:
Raw
### Run interactive setup with dotnetup init

Source: https://learn.microsoft.com/en-us/dotnet/core/tools/dotnetup/

Starts the interactive setup that asks which SDK channel to install and how to access the managed dotnet command. The output shows the prompts and installation progress.

```text
> dotnetup init
Welcome to dotnetup!

SDK Channel: latest
Mode: Terminal Mode (Suggested)

Would you like to install .NET with the recommended settings?
> Yes, proceed with defaults and install

Downloading SDK <resolved-version>
Installing SDK <resolved-version>
Installed SDK <resolved-version>
Setup complete!
```

--------------------------------

### C# example using ServiceAccount.LocalSystem

Source: https://learn.microsoft.com/en-us/dotnet/api/system.serviceprocess.serviceaccount?view=netframework-4.8.1

C# example that creates a custom installer class, sets the service account to LocalSystem, and configures two services to start manually. The Main method prints usage instructions for InstallUtil.exe.

```csharp
using System;
using System.Collections;
using System.Configuration.Install;
using System.ServiceProcess;
using System.ComponentModel;

[RunInstaller(true)]
public class MyProjectInstaller : Installer
{
    private ServiceInstaller serviceInstaller1;
    private ServiceInstaller serviceInstaller2;
    private ServiceProcessInstaller processInstaller;

    public MyProjectInstaller()
    {
        // Instantiate installers for process and services.
        processInstaller = new ServiceProcessInstaller();
        serviceInstaller1 = new ServiceInstaller();
        serviceInstaller2 = new ServiceInstaller();

        // The services run under the system account.
        processInstaller.Account = ServiceAccount.LocalSystem;

        // The services are started manually.
        serviceInstaller1.StartType = ServiceStartMode.Manual;
        serviceInstaller2.StartType = ServiceStartMode.Manual;

        // ServiceName must equal those on ServiceBase derived classes.
        serviceInstaller1.ServiceName = "Hello-World Service 1";
        serviceInstaller2.ServiceName = "Hello-World Service 2";

        // Add installers to collection. Order is not important.
        Installers.Add(serviceInstaller1);
        Installers.Add(serviceInstaller2);
        Installers.Add(processInstaller);
    }

    public static void Main()
    {
        Console.WriteLine("Usage: InstallUtil.exe [<service>.exe]");
    }
}
```

--------------------------------

### C++ example using ServiceAccount.LocalSystem

Source: https://learn.microsoft.com/en-us/dotnet/api/system.serviceprocess.serviceaccount?view=netframework-4.8.1

C++/CLI example that creates a custom installer class, sets the service account to LocalSystem, and configures two services to start manually. The Main method prints usage instructions for InstallUtil.exe.

```cpp
#using <System.dll>
#using <System.ServiceProcess.dll>
#using <System.Configuration.Install.dll>

using namespace System;
using namespace System::Collections;
using namespace System::Configuration::Install;
using namespace System::ServiceProcess;
using namespace System::ComponentModel;

[RunInstaller(true)]
public ref class MyProjectInstaller : public Installer
{
private:
    ServiceInstaller^ serviceInstaller1;
    ServiceInstaller^ serviceInstaller2;
    ServiceProcessInstaller^ processInstaller;

public:
    MyProjectInstaller()
    {
        // Instantiate installers for process and services.
        processInstaller = gcnew ServiceProcessInstaller;
        serviceInstaller1 = gcnew ServiceInstaller;
        serviceInstaller2 = gcnew ServiceInstaller;

        // The services run under the system account.
        processInstaller->Account = ServiceAccount::LocalSystem;

        // The services are started manually.
        serviceInstaller1->StartType = ServiceStartMode::Manual;
        serviceInstaller2->StartType = ServiceStartMode::Manual;

        // ServiceName must equal those on ServiceBase derived classes.
        serviceInstaller1->ServiceName = "Hello-World Service 1";
        serviceInstaller2->ServiceName = "Hello-World Service 2";

        // Add installers to collection. Order is not important.
        Installers->Add( serviceInstaller1 );
        Installers->Add( serviceInstaller2 );
        Installers->Add( processInstaller );
    }

    static void Main()
    {
        Console::WriteLine("Usage: InstallUtil.exe [<service>.exe]");
    }
};

int main()
{
    MyProjectInstaller::Main();
}
```

--------------------------------

### dotnetup sdk install examples

Source: https://learn.microsoft.com/en-us/dotnet/core/tools/dotnetup/reference/dotnetup-sdk-install

Example commands for installing SDKs: install the latest version, multiple channels, an exact version, and a preview channel with progress disabled.

```bash
dotnetup sdk install latest
```

```bash
dotnetup sdk install 10 10.0.1xx
```

```bash
dotnetup sdk install 10.0.103
```

```bash
dotnetup sdk install preview --no-progress
```

--------------------------------

### Visual Basic example using ServiceAccount.LocalSystem

Source: https://learn.microsoft.com/en-us/dotnet/api/system.serviceprocess.serviceaccount?view=netframework-4.8.1

Visual Basic example that creates a custom installer class, sets the service account to LocalSystem, and configures two services to start manually. The Main method prints usage instructions for InstallUtil.exe.

```vb
Imports System.Collections
Imports System.Configuration.Install
Imports System.ServiceProcess
Imports System.ComponentModel

<RunInstallerAttribute(True)> _
Public Class MyProjectInstaller
    Inherits Installer
    Private serviceInstaller1 As ServiceInstaller
    Private serviceInstaller2 As ServiceInstaller
    Private processInstaller As ServiceProcessInstaller    
    
    Public Sub New()
        ' Instantiate installers for process and services.
        processInstaller = New ServiceProcessInstaller()
        serviceInstaller1 = New ServiceInstaller()
        serviceInstaller2 = New ServiceInstaller()
        
        ' The services will run under the system account.
        processInstaller.Account = ServiceAccount.LocalSystem
        
        ' The services will be started manually.
        serviceInstaller1.StartType = ServiceStartMode.Manual
        serviceInstaller2.StartType = ServiceStartMode.Manual
        
        ' ServiceName must equal those on ServiceBase derived classes.            
        serviceInstaller1.ServiceName = "Hello-World Service 1"
        serviceInstaller2.ServiceName = "Hello-World Service 2"
        
        ' Add installers to collection. Order is not important.
        Installers.Add(serviceInstaller1)
        Installers.Add(serviceInstaller2)
        Installers.Add(processInstaller)
    End Sub

    Public Shared Sub Main()
        Console.WriteLine("Usage: InstallUtil.exe [<service>.exe]")
    End Sub
End Class
```

--------------------------------

### Start first-use installation

Source: https://learn.microsoft.com/en-us/dotnet/core/tools/dotnetup/reference/dotnetup

Runs the SDK install workflow. When interactive input is available and no configuration exists, it can start first-use onboarding.

```bash
dotnetup
```

--------------------------------

### dotnetup runtime install examples

Source: https://learn.microsoft.com/en-us/dotnet/core/tools/dotnetup/reference/dotnetup-runtime-install

Examples of installing the latest core runtime, a specific version, an ASP.NET Core runtime, and multiple runtimes.

```bash
dotnetup runtime install
```

```bash
dotnetup runtime install 10.0
```

```bash
dotnetup runtime install aspnetcore@10.0
```

```bash
dotnetup runtime install runtime@9.0 aspnetcore@9.0
```

--------------------------------

### F# Process.Start examples

Source: https://learn.microsoft.com/en-us/dotnet/api/system.diagnostics.process?view=net-10.0

F# example showing how to start Internet Explorer, open URLs and HTML documents, and use ProcessStartInfo to start processes in a minimized window.

```fsharp
module processstartstatic

open System
open System.Diagnostics

// Opens the Internet Explorer application.
let openApplication (myFavoritesPath: string) =
    // Start Internet Explorer. Defaults to the home page.
    Process.Start "IExplore.exe" |> ignore

    // Display the contents of the favorites folder in the browser.
    Process.Start myFavoritesPath |> ignore

// Opens urls and .html documents using Internet Explorer.
let openWithArguments () =
    // url's are not considered documents. They can only be opened
    // by passing them as arguments.
    Process.Start("IExplore.exe", "www.northwindtraders.com") |> ignore

    // Start a Web page using a browser associated with .html and .asp files.
    Process.Start("IExplore.exe", @"C:\myPath\myFile.htm") |> ignore
    Process.Start("IExplore.exe", @"C:\myPath\myFile.asp") |> ignore

// Uses the ProcessStartInfo class to start new processes,
// both in a minimized mode.
let openWithStartInfo () =
    let startInfo = ProcessStartInfo "IExplore.exe"
    startInfo.WindowStyle <- ProcessWindowStyle.Minimized

    Process.Start startInfo |> ignore

    startInfo.Arguments <- "www.northwindtraders.com"

    Process.Start startInfo |> ignore

// Get the path that stores favorite links.
let myFavoritesPath = Environment.GetFolderPath Environment.SpecialFolder.Favorites

openApplication myFavoritesPath
openWithArguments ()
openWithStartInfo ()
```

--------------------------------

### C# Process.Start examples

Source: https://learn.microsoft.com/en-us/dotnet/api/system.diagnostics.process?view=net-10.0

C# example showing how to start Internet Explorer, open URLs and HTML documents, and use ProcessStartInfo to start processes in a minimized window.

```csharp
using System;
using System.Diagnostics;
using System.ComponentModel;

namespace MyProcessSample
{
    class MyProcess
    {
        // Opens the Internet Explorer application.
        void OpenApplication(string myFavoritesPath)
        {
            // Start Internet Explorer. Defaults to the home page.
            Process.Start("IExplore.exe");

            // Display the contents of the favorites folder in the browser.
            Process.Start(myFavoritesPath);
        }

        // Opens urls and .html documents using Internet Explorer.
        void OpenWithArguments()
        {
            // url's are not considered documents. They can only be opened
            // by passing them as arguments.
            Process.Start("IExplore.exe", "www.northwindtraders.com");

            // Start a Web page using a browser associated with .html and .asp files.
            Process.Start("IExplore.exe", "C:\\myPath\\myFile.htm");
            Process.Start("IExplore.exe", "C:\\myPath\\myFile.asp");
        }

        // Uses the ProcessStartInfo class to start new processes,
        // both in a minimized mode.
        void OpenWithStartInfo()
        {
            ProcessStartInfo startInfo = new ProcessStartInfo("IExplore.exe");
            startInfo.WindowStyle = ProcessWindowStyle.Minimized;

            Process.Start(startInfo);

            startInfo.Arguments = "www.northwindtraders.com";

            Process.Start(startInfo);
        }

        static void Main()
        {
            // Get the path that stores favorite links.
            string myFavoritesPath =
                Environment.GetFolderPath(Environment.SpecialFolder.Favorites);

            MyProcess myProcess = new MyProcess();

            myProcess.OpenApplication(myFavoritesPath);
            myProcess.OpenWithArguments();
            myProcess.OpenWithStartInfo();
        }
    }
}
```

--------------------------------

### Install preview runtimes

Source: https://learn.microsoft.com/en-us/dotnet/core/tools/dotnetup/channels/preview

Installs one or more runtime components using the preview channel. The example installs both the runtime and aspnetcore runtimes.

```bash
dotnetup runtime install runtime@preview aspnetcore@preview
```

--------------------------------

### dotnetup sdk example commands

Source: https://learn.microsoft.com/en-us/dotnet/core/tools/dotnetup/reference/dotnetup-sdk

Example usage of the dotnetup sdk subcommands: install, update, and uninstall. These commands manage .NET SDK installations.

```plaintext
dotnetup sdk install 10.0.1xx
dotnetup sdk update
dotnetup sdk uninstall 10.0.1xx
```

--------------------------------

### Start method example

Source: https://learn.microsoft.com/en-us/dotnet/communitytoolkit/maui/markup/extensions/view-extensions

Sets Label.HorizontalOptions to LayoutOptions.Start using the Start extension method.

```csharp
new Label().Start()
```

--------------------------------

### Install Azure.Provisioning.WebPubSub package

Source: https://learn.microsoft.com/en-us/dotnet/api/overview/azure/provisioning.webpubsub-readme?view=azure-dotnet

Use this command to install the Azure.Provisioning.WebPubSub client library for .NET via NuGet. This is the first step to get started with the library.

```bash
dotnet add package Azure.Provisioning.WebPubSub
```

--------------------------------

### Install Azure.Provisioning.ContainerRegistry package

Source: https://learn.microsoft.com/en-us/dotnet/api/overview/azure/provisioning.containerregistry-readme?view=azure-dotnet

Use this command to install the Azure.Provisioning.ContainerRegistry client library for .NET via NuGet. This is the first step to get started with the library.

```bash
dotnet add package Azure.Provisioning.ContainerRegistry
```

--------------------------------

### F# example using Task.Factory.ContinueWhenAll

Source: https://learn.microsoft.com/en-us/dotnet/api/system.threading.tasks.task.factory?view=net-10.0

F# example that starts two tasks to get files and directories from the user's Documents folder, then uses Task.Factory.ContinueWhenAll to display the counts. The output is shown in the comments.

```fsharp
open System
open System.IO
open System.Threading.Tasks

let mutable files = Unchecked.defaultof<string[]>
let mutable dirs = Unchecked.defaultof<string[]>
let docsDirectory = Environment.GetFolderPath Environment.SpecialFolder.MyDocuments

let tasks =
    [| Task.Factory.StartNew(fun () -> files <- Directory.GetFiles docsDirectory)
       Task.Factory.StartNew(fun () -> dirs <- Directory.GetDirectories docsDirectory) |]

Task.Factory.ContinueWhenAll(
    tasks,
    fun completedTasks ->
        printfn $"{docsDirectory} contains: "
        printfn $"   {dirs.Length} subdirectories"
        printfn $"   {files.Length} files"
)
|> ignore

// The example displays output like the following:
//       C:\Users\<username>\Documents contains:
//          24 subdirectories
//          16 files

```

--------------------------------

### Visual Basic example using Task.Factory.ContinueWhenAll

Source: https://learn.microsoft.com/en-us/dotnet/api/system.threading.tasks.task.factory?view=net-10.0

Visual Basic example that starts two tasks to get files and directories from the user's Documents folder, then uses Task.Factory.ContinueWhenAll to display the counts. The output is shown in the comments.

```vb
Imports System.IO
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim tasks(1) As Task
      Dim files() As String = Nothing
      Dim dirs() As String = Nothing
      Dim docsDirectory As String = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments)
      
      tasks(0) = Task.Factory.StartNew( Sub()
                                           files = Directory.GetFiles(docsDirectory)
                                        End Sub )
      tasks(1) = Task.Factory.StartNew( Sub()
                                           dirs = Directory.GetDirectories(docsDirectory)
                                        End Sub )
      Task.Factory.ContinueWhenAll(tasks, Sub(completedTasks)
                                             Console.WriteLine("{0} contains: ", docsDirectory)
                                             Console.WriteLine("   {0} subdirectories", dirs.Length)
                                             Console.WriteLine("   {0} files", files.Length)
                                          End Sub)
   End Sub
End Module
' The example displays output like the following:
'       C:\Users\<username>\Documents contains:
'          24 subdirectories
'          16 files

```

--------------------------------

### C# Application_Startup building the host

Source: https://learn.microsoft.com/en-us/dotnet/desktop/wpf/app-development/how-to-use-host-builder

Creates the host with CreateApplicationBuilder, registers services (SampleLifecycleService, IGreetingService, MainWindow), starts the host, and shows the main window.

```C#
private async void Application_Startup(object sender, StartupEventArgs e)
{
    var builder = Host.CreateApplicationBuilder();

    builder.Services.AddHostedService<SampleLifecycleService>();
    builder.Services.AddSingleton<IGreetingService, GreetingService>();
    builder.Services.AddSingleton<MainWindow>();

    _host = builder.Build();

    await _host.StartAsync();

    MainWindow mainWindow = _host.Services.GetRequiredService<MainWindow>();
    mainWindow.Show();
}
```

--------------------------------

### Install a daily SDK tracking a specific preview phase

Source: https://learn.microsoft.com/en-us/dotnet/core/tools/dotnetup/channels/daily

Installs the .NET SDK from the daily channel for a specific preview phase. The example uses '11.0.1xx-preview.5-daily'.

```bash
dotnetup sdk install 11.0.1xx-preview.5-daily
```

--------------------------------

### Define Functions for Function Calling

Source: https://learn.microsoft.com/en-us/dotnet/api/overview/azure/ai.agents.persistent-readme?view=azure-dotnet

Starts the function calling example by defining the functions the agent can use: get the user's favorite city, get a nickname for a given city, and get the current weather optionally with a temperature unit. The implementations shown are representative stubs.

```csharp
// The actual implementations here are merely representative stubs.
```

--------------------------------

### Task.Factory Property

Source: https://learn.microsoft.com/en-us/dotnet/api/system.threading.tasks.task.factory?view=net-10.0

Gets a default TaskFactory instance for creating and starting tasks. The example demonstrates using Task.Factory.StartNew to populate arrays and Task.Factory.ContinueWhenAll to display results.

```APIDOC
## Task.Factory Property

### Description
Gets a default TaskFactory instance that can be used to create and start tasks with default configuration values.

### Property Value
- **TaskFactory** - A default TaskFactory instance with the following property values:
  - CancellationToken: CancellationToken.None
  - ContinuationOptions: TaskContinuationOptions.None
  - CreationOptions: TaskCreationOptions.None
  - Scheduler: null or TaskScheduler.Current

### Remarks
This property returns a default instance of the TaskFactory class identical to one created by the parameterless TaskFactory constructor. The most common use is to create and start a new task in a single call to the TaskFactory.StartNew method. Starting with .NET Framework 4.5, the Task.Run method provides the easiest way to create a Task object with default configuration values.

### Example
```csharp
using System;
using System.IO;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      Task[] tasks = new Task[2];
      String[] files = null;
      String[] dirs = null;
      String docsDirectory = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);

      tasks[0] = Task.Factory.StartNew( () => files = Directory.GetFiles(docsDirectory));
      tasks[1] = Task.Factory.StartNew( () => dirs = Directory.GetDirectories(docsDirectory));

      Task.Factory.ContinueWhenAll(tasks, completedTasks => {
                                             Console.WriteLine("{0} contains: ", docsDirectory);
                                             Console.WriteLine("   {0} subdirectories", dirs.Length);
                                             Console.WriteLine("   {0} files", files.Length);
                                          } );
   }
}
// The example displays output like the following:
//       C:\Users\<username>\Documents contains:
//          24 subdirectories
//          16 files
```
```

--------------------------------

### dotnetup init examples

Source: https://learn.microsoft.com/en-us/dotnet/core/tools/dotnetup/reference/dotnetup-init

Example commands for dotnetup init: basic invocation, specifying the shell, and setting the install path.

```bash
dotnetup init
```

```bash
dotnetup init --shell bash
```

```bash
dotnetup init --install-path .\.dotnet
```

--------------------------------

### Run the Sense HAT quickstart

Source: https://learn.microsoft.com/en-us/dotnet/iot/quickstarts/sensehat

Command to download and run a script that installs the .NET SDK, clones the Sense HAT quickstart repository, builds the project, and runs it.

```bash
. <(wget -q -O - https://aka.ms/dotnet-iot-sensehat-quickstart)
```

--------------------------------

### LBound function example

Source: https://learn.microsoft.com/en-us/dotnet/api/microsoft.visualbasic.information.lbound?view=net-10.0

Shows how to use LBound to get the lowest subscript for different dimensions of an array. All calls return 0 because array subscripts start at 0.

```vb
Dim lowest, bigArray(10, 15, 20), littleArray(6) As Integer
lowest = LBound(bigArray, 1)
lowest = LBound(bigArray, 3)
lowest = LBound(littleArray)
' All three calls to LBound return 0.
```

--------------------------------

### CreateDomain example in C++

Source: https://learn.microsoft.com/en-us/dotnet/api/system.appdomain.createdomain?view=net-10.0

C++/CLI example showing how to set up AppDomainSetup and Evidence, then call AppDomain.CreateDomain with a friendly name, evidence, and setup. The example uses placeholder strings for directory, file, assembly, and host.

```cpp
// Set up the AppDomainSetup
AppDomainSetup^ setup = gcnew AppDomainSetup;
setup->ApplicationBase = "(some directory)";
setup->ConfigurationFile = "(some file)";

// Set up the Evidence
Evidence^ baseEvidence = AppDomain::CurrentDomain->Evidence;
Evidence^ evidence = gcnew Evidence( baseEvidence );
evidence->AddAssembly( "(some assembly)" );
evidence->AddHost( "(some host)" );

// Create the AppDomain
AppDomain^ newDomain = AppDomain::CreateDomain( "newDomain", evidence, setup );
```

--------------------------------

### Visual Basic EventLogInstaller Setup

Source: https://learn.microsoft.com/en-us/dotnet/api/system.diagnostics.eventloginstaller?view=netframework-4.8.1

Visual Basic version of the EventLogInstaller example. It sets Source to "NewLogSource" and Log to "MyNewLog", adds the installer to the Installers collection, and includes a Main method that creates an EventLogInstaller instance.

```vb
   Imports System.Configuration.Install
Imports System.Diagnostics
Imports System.ComponentModel

<RunInstaller(True)>  _
Public Class MyEventLogInstaller
   Inherits Installer
   Private myEventLogInstaller As EventLogInstaller
   
   Public Sub New()

      ' Create an instance of an EventLogInstaller.
      myEventLogInstaller = New EventLogInstaller()

      ' Set the source name of the event log.
      myEventLogInstaller.Source = "NewLogSource"

      ' Set the event log that the source writes entries to.
      myEventLogInstaller.Log = "MyNewLog"

      ' Add myEventLogInstaller to the Installer collection.
      Installers.Add(myEventLogInstaller)
   End Sub

 Public Shared Sub Main()
 End Sub
 Dim myInstaller As New EventLogInstaller()
End Class
```

--------------------------------

### Launch method to start the setup process

Source: https://learn.microsoft.com/en-us/dotnet/framework/deployment/how-to-get-progress-from-the-dotnet-installer

Launches the .NET Framework 4.5 setup executable using CreateProcess. The command line includes the section name and any additional arguments. After launching, it calls Run() to monitor progress and returns whether the launch was successful.

```cpp
bool Launch(const CString& args)
{
CString cmdline = L"dotNetFx45_Full_x86_x64.exe -pipe TheSectionName " + args; // Customize with name and location of setup .exe that you want to run
STARTUPINFO si = {0};
si.cb = sizeof(si);
PROCESS_INFORMATION pi = {0};

// Launch the Setup.exe that installs the .NET Framework 4.5
BOOL bLaunchedSetup = ::CreateProcess(NULL,
 cmdline.GetBuffer(),
 NULL, NULL, FALSE, 0, NULL, NULL,
 &si,
 &pi);

// If successful
if (bLaunchedSetup != 0)
{
IProgressObserver& observer = dynamic_cast<IProgressObserver&>(*this);
Run(pi.hProcess, observer);

……………………..
return (bLaunchedSetup != 0);
}

```

--------------------------------

### Create DocumentAnalysisClient with AzureKeyCredential

Source: https://learn.microsoft.com/en-us/dotnet/api/overview/azure/ai.formrecognizer-readme?view=azure-dotnet

Creates a DocumentAnalysisClient using an endpoint and an API key. Replace the endpoint and apiKey placeholders with your values. This is the primary authentication method used in the getting started guide.

```csharp
string endpoint = "<endpoint>";
string apiKey = "<apiKey>";
var credential = new AzureKeyCredential(apiKey);
var client = new DocumentAnalysisClient(new Uri(endpoint), credential);
```

--------------------------------

### DateSerial basic usage and examples

Source: https://learn.microsoft.com/en-us/dotnet/api/microsoft.visualbasic.dateandtime.dateserial?view=net-10.0

Shows how to use DateSerial to create a date, get the last day of the previous month, and find the day of the week for the 15th of next month. The example uses a starting date and the 0 day value to represent the last day of the previous month.

```vb
' DateSerial returns the date for a specified year, month, and day.
Dim aDate As Date
' Variable aDate contains the date for February 12, 1969.
aDate = DateSerial(1969, 2, 12)
Console.WriteLine(aDate)

' The following example uses DateSerial to determine and display
' the last day of the previous month.
' First, establish a starting date.
Dim startDate = #1/23/1994#
' The 0 for the day represents the last day of the previous month.
Dim endOfLastMonth = DateSerial(startDate.Year, startDate.Month, 0)
Console.WriteLine("Last day in the previous month: " & endOfLastMonth)

' The following example finds and displays the day of the week that the 
' 15th day of the following month will fall on.
Dim fifteenthsDay = DateSerial(Today.Year, Today.Month + 1, 15)
Console.WriteLine("The 15th of next month is a {0}", fifteenthsDay.DayOfWeek)
```

--------------------------------

### C# example: Enumerate text elements and indexes with GetTextElementEnumerator and ParseCombiningCharacters

Source: https://learn.microsoft.com/en-us/dotnet/api/system.globalization.stringinfo.gettextelementenumerator?view=net-10.0

This example demonstrates calling GetTextElementEnumerator to enumerate each text element (honoring combining characters and surrogates) and ParseCombiningCharacters to get the starting index of each text element. It is part of a larger example for the StringInfo class. The output shows the text elements and their indexes for the string "a\u0304\u0308bc\u0327".

```csharp
using System;
using System.Text;
using System.Globalization;

public sealed class App {
   static void Main() {
      // The string below contains combining characters.
      String s = "a\u0304\u0308bc\u0327";

      // Show each 'character' in the string.
      EnumTextElements(s);

      // Show the index in the string where each 'character' starts.
      EnumTextElementIndexes(s);
   }

   // Show how to enumerate each real character (honoring surrogates) in a string.
   static void EnumTextElements(String s) {
      // This StringBuilder holds the output results.
      StringBuilder sb = new StringBuilder();

      // Use the enumerator returned from GetTextElementEnumerator
      // method to examine each real character.
      TextElementEnumerator charEnum = StringInfo.GetTextElementEnumerator(s);
      while (charEnum.MoveNext()) {
         sb.AppendFormat(
           "Character at index {0} is '{1}'{2}",
           charEnum.ElementIndex, charEnum.GetTextElement(),
           Environment.NewLine);
      }

      // Show the results.
      Console.WriteLine("Result of GetTextElementEnumerator:");
      Console.WriteLine(sb);
   }

   // Show how to discover the index of each real character (honoring surrogates) in a string.
   static void EnumTextElementIndexes(String s) {
      // This StringBuilder holds the output results.
      StringBuilder sb = new StringBuilder();

      // Use the ParseCombiningCharacters method to
      // get the index of each real character in the string.
      Int32[] textElemIndex = StringInfo.ParseCombiningCharacters(s);

      // Iterate through each real character showing the character and the index where it was found.
      for (Int32 i = 0; i < textElemIndex.Length; i++) {
         sb.AppendFormat(
            "Character {0} starts at index {1}{2}",
            i, textElemIndex[i], Environment.NewLine);
      }

      // Show the results.
      Console.WriteLine("Result of ParseCombiningCharacters:");
      Console.WriteLine(sb);
   }
}

// This code produces the following output:
//
// Result of GetTextElementEnumerator:
// Character at index 0 is 'ā̈'
// Character at index 3 is 'b'
// Character at index 4 is 'ç'
//
// Result of ParseCombiningCharacters:
// Character 0 starts at index 0
// Character 1 starts at index 3
// Character 2 starts at index 4
```

--------------------------------

### Run dotnetup init interactive setup

Source: https://learn.microsoft.com/en-us/dotnet/core/tools/dotnetup/getting-started

Runs the interactive setup for dotnetup. The output shows the recommended settings and installation progress. The paths and environment guidance depend on your system and selected mode.

```text
> dotnetup init
Welcome to dotnetup!

SDK Channel: latest
Mode: <recommended-mode> (Suggested)

<recommended-mode> modifies <configuration-target> to set PATH and DOTNET_ROOT to prefer <install-path>.

Would you like to install .NET with the recommended settings?
> Yes, proceed with defaults and install

Installing SDK <resolved-version> to <install-path>...
<download and installation progress>
Installed at <install-path>:
  SDK <resolved-version>
<mode-specific environment guidance>
Setup complete!
```

--------------------------------

### Start Alerter service example in C#

Source: https://learn.microsoft.com/en-us/dotnet/api/system.serviceprocess.servicecontroller.start?view=net-11.0-pp

C# example that checks if the Alerter service is stopped, starts it, and waits until its status is Running. Throws InvalidOperationException if the service cannot be started.

```csharp
// Check whether the Alerter service is started.

ServiceController sc  = new ServiceController();
sc.ServiceName = "Alerter";
Console.WriteLine("The Alerter service status is currently set to {0}",
                   sc.Status);

if (sc.Status == ServiceControllerStatus.Stopped)
{
   // Start the service if the current status is stopped.

   Console.WriteLine("Starting the Alerter service...");
   try
   {
      // Start the service, and wait until its status is "Running".
      sc.Start();
      sc.WaitForStatus(ServiceControllerStatus.Running);

      // Display the current service status.
      Console.WriteLine("The Alerter service status is now set to {0}.",
                         sc.Status);
   }
   catch (InvalidOperationException)
   {
      Console.WriteLine("Could not start the Alerter service.");
   }
}
```

--------------------------------

### Visual Basic Full Example with Storyboard Setup

Source: https://learn.microsoft.com/en-us/dotnet/api/system.windows.media.animation.storyboard.begin?view=windowsdesktop-10.0

Complete Visual Basic example that sets up the page, creates the ellipse and storyboard, and registers event handlers for mouse clicks. Demonstrates using SnapshotAndReplace and Compose HandoffBehavior.

```vb
Imports System.Windows
Imports System.Windows.Navigation
Imports System.Windows.Media
Imports System.Windows.Media.Animation
Imports System.Windows.Shapes
Imports System.Windows.Controls
Imports System.Windows.Input

Namespace Microsoft.Samples.Animation.AnimatingWithStoryboards

    ' Create the demonstration.
    Public Class FrameworkElementStoryboardHandoffBehaviorExample
        Inherits Page


        Private containerBorder As Border
        Private interactiveEllipse As Ellipse
        Private theStoryboard As Storyboard
        Private xAnimation As DoubleAnimation
        Private yAnimation As DoubleAnimation

        Public Sub New()

            WindowTitle = "Interactive Animation Example"

            ' Create a name scope for the page.
            NameScope.SetNameScope(Me, New NameScope())

            Dim myPanel As New DockPanel()
            myPanel.Margin = New Thickness(20.0)

            containerBorder = New Border()
            containerBorder.Background = Brushes.White
            containerBorder.BorderBrush = Brushes.Black
            containerBorder.BorderThickness = New Thickness(2.0)
            containerBorder.VerticalAlignment = VerticalAlignment.Stretch

            interactiveEllipse = New Ellipse()
            With interactiveEllipse
                .Fill = Brushes.Lime
                .Stroke = Brushes.Black
                .StrokeThickness = 2.0
                .Width = 25
                .Height = 25
                .HorizontalAlignment = HorizontalAlignment.Left
                .VerticalAlignment = VerticalAlignment.Top
            End With

            Dim interactiveTranslateTransform As New TranslateTransform()
            Me.RegisterName("InteractiveTranslateTransform", interactiveTranslateTransform)

            interactiveEllipse.RenderTransform = interactiveTranslateTransform

            xAnimation = New DoubleAnimation()
            xAnimation.Duration = TimeSpan.FromSeconds(4)
            yAnimation = xAnimation.Clone()
            Storyboard.SetTargetName(xAnimation, "InteractiveTranslateTransform")
            Storyboard.SetTargetProperty(xAnimation, New PropertyPath(TranslateTransform.XProperty))
            Storyboard.SetTargetName(yAnimation, "InteractiveTranslateTransform")
            Storyboard.SetTargetProperty(yAnimation, New PropertyPath(TranslateTransform.YProperty))

            theStoryboard = New Storyboard()
            theStoryboard.Children.Add(xAnimation)
            theStoryboard.Children.Add(yAnimation)


            AddHandler containerBorder.MouseLeftButtonDown, AddressOf border_mouseLeftButtonDown
            AddHandler containerBorder.MouseRightButtonDown, AddressOf border_mouseRightButtonDown

```

--------------------------------

### Start Alerter service example in C++

Source: https://learn.microsoft.com/en-us/dotnet/api/system.serviceprocess.servicecontroller.start?view=net-11.0-pp

C++ example that checks if the Alerter service is stopped, starts it, and waits until its status is Running. Throws InvalidOperationException if the service cannot be started.

```cpp
// Check whether the Alerter service is started.
ServiceController^ sc = gcnew ServiceController;
if ( sc )
{
   sc->ServiceName =  "Alerter";
   Console::WriteLine(  "The Alerter service status is currently set to {0}", sc->Status );
   if ( sc->Status == (ServiceControllerStatus::Stopped) )
   {
      // Start the service if the current status is stopped.
      Console::WriteLine(  "Starting the Alerter service..." );
      try
      {
         // Start the service, and wait until its status is "Running".
         sc->Start();
         sc->WaitForStatus( ServiceControllerStatus::Running );
         
         // Display the current service status.
         Console::WriteLine(  "The Alerter service status is now set to {0}.", sc->Status );
      }
      catch ( InvalidOperationException^ e ) 
      {
         Console::WriteLine(  "Could not start the Alerter service." );
      }
   }
}
```

--------------------------------

### Start Alerter service example in Visual Basic

Source: https://learn.microsoft.com/en-us/dotnet/api/system.serviceprocess.servicecontroller.start?view=net-11.0-pp

Visual Basic example that checks if the Alerter service is stopped, starts it, and waits until its status is Running. Throws an exception if the service cannot be started.

```vb
' Check whether the Alerter service is started.

Dim sc As New ServiceController()
sc.ServiceName = "Alerter"
Console.WriteLine("The Alerter service status is currently set to {0}", sc.Status)

If sc.Status = ServiceControllerStatus.Stopped Then
   ' Start the service if the current status is stopped.
   Console.WriteLine("Starting the Alerter service...")

   Try
      ' Start the service, and wait until its status is "Running".
      sc.Start()
      sc.WaitForStatus(ServiceControllerStatus.Running)
      
      ' Display the current service status.
      Console.WriteLine("The Alerter service status is now set to {0}.", sc.Status)
   Catch 
      Console.WriteLine("Could not start the Alerter service.")
   End Try
End If
```

--------------------------------

### Create application manifest with name, processor, and provider URL

Source: https://learn.microsoft.com/en-us/dotnet/framework/tools/mage-exe-manifest-generation-and-editing-tool

Continues the previous example by adding the deployment name, target microprocessor, and a provider URL for ClickOnce update checks.

```bash
mage -New Application -FromDirectory . -Name "Hello, World! Application" -Version 1.0.0.0 -Processor "x86" -ProviderUrl http://internalserver/HelloWorld/
```

--------------------------------

### Sample output of dotnet --list-sdks on Windows

Source: https://learn.microsoft.com/en-us/dotnet/core/install/how-to-detect-installed-versions

Example output showing installed SDK versions and their installation paths on Windows.

```text
7.0.404 [C:\program files\dotnet\sdk]
8.0.100 [C:\program files\dotnet\sdk]
9.0.306 [C:\program files\dotnet\sdk]
10.0.100 [C:\program files\dotnet\sdk]
```

--------------------------------

### Example: Start asynchronous operation with RunWorkerAsync in C#

Source: https://learn.microsoft.com/en-us/dotnet/api/system.componentmodel.backgroundworker.runworkerasync?view=net-10.0

C# example that starts an asynchronous operation by calling RunWorkerAsync with a number to compute.

```csharp
// Start the asynchronous operation.
backgroundWorker1.RunWorkerAsync(numberToCompute);
```

--------------------------------

### Build the sample application

Source: https://learn.microsoft.com/en-us/dotnet/core/dependency-loading/collect-details

Builds the sample application from the assembly loading extension points sample.

```bash
dotnet build
```

--------------------------------

### Sample output of dotnet --list-sdks on Linux

Source: https://learn.microsoft.com/en-us/dotnet/core/install/how-to-detect-installed-versions

Example output showing installed SDK versions and their installation paths on Linux.

```text
7.0.404 [/home/user/dotnet/sdk]
8.0.100 [/home/user/dotnet/sdk]
9.0.306 [/home/user/dotnet/sdk]
10.0.100 [/home/user/dotnet/sdk]
```

--------------------------------

### Example: Start asynchronous operation with RunWorkerAsync in C++

Source: https://learn.microsoft.com/en-us/dotnet/api/system.componentmodel.backgroundworker.runworkerasync?view=net-10.0

C++ example that starts an asynchronous operation by calling RunWorkerAsync with a number to compute.

```cpp
// Start the asynchronous operation.
backgroundWorker1->RunWorkerAsync( numberToCompute );
```

--------------------------------

### Install .NET 9 SDK and list runtimes/SDKs

Source: https://learn.microsoft.com/en-us/dotnet/core/tools/dotnet-install-script

Installs the latest .NET 9 SDK to a local directory using dotnet-install.sh, then verifies the installation by listing runtimes and SDKs. The output shows the installation steps and the resulting runtimes and SDKs.

```bash
:~ $ ./dotnet-install.sh --channel 9.0 --install-dir local-dotnet  # installs the latest 9 SDK to the specified directory
dotnet-install: Attempting to download using aka.ms link https://builds.dotnet.microsoft.com/dotnet/Sdk/9.0.303/dotnet-sdk-9.0.303-linux-x64.tar.gz
dotnet-install: Remote file https://builds.dotnet.microsoft.com/dotnet/Sdk/9.0.303/dotnet-sdk-9.0.303-linux-x64.tar.gz size is 218004272 bytes.
dotnet-install: Extracting archive from https://builds.dotnet.microsoft.com/dotnet/Sdk/9.0.303/dotnet-sdk-9.0.303-linux-x64.tar.gz
dotnet-install: Downloaded file size is 218004272 bytes.
dotnet-install: The remote and local file sizes are equal.
dotnet-install: Installed version is 9.0.303
dotnet-install: Adding to current process PATH: `$HOME/local-dotnet`. Note: This change will be visible only when sourcing script.
dotnet-install: Note that the script does not resolve dependencies during installation.
dotnet-install: To check the list of dependencies, go to https://learn.microsoft.com/dotnet/core/install, select your operating system and check the "Dependencies" section.
dotnet-install: Installation finished successfully.
:~ $ ./local-dotnet/dotnet --list-runtimes # see what runtimes we have available
Microsoft.AspNetCore.App 9.0.7 [$HOME/local-dotnet/shared/Microsoft.AspNetCore.App]
Microsoft.NETCore.App 9.0.7 [$HOME/local-dotnet/shared/Microsoft.NETCore.App]
:~ $ ./local-dotnet/dotnet --list-sdks # see what SDKs we have available
9.0.303 [$HOME/local-dotnet/sdk]
```

--------------------------------

### Install a daily SDK with dotnetup

Source: https://learn.microsoft.com/en-us/dotnet/core/tools/dotnetup/channels/daily

Installs the .NET SDK from the daily channel for the specified feature band. The example uses '11.0.1xx-daily'.

```bash
dotnetup sdk install 11.0.1xx-daily
```
Tokens:
Raw