.NET Framework

https://learn.microsoft.com/en-us/dotnet/framework
Admin
.NET Framework is a development platform for building applications for web, Windows, and Microsoft...
Tokens:4,149,251
Snippets:34,946
Trust Score:10
Update:1 week ago
Show doc for...
Tokens:
Raw
### Launch method to start the installer

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

Launches the setup executable (dotNetFx45_Full_x86_x64.exe) with a pipe argument. Customize the command line with the correct path and name. Uses the MmioChainer base class's Run() method to monitor progress.

```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);
}

```

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

### Run Setup.bat to install certificates

Source: https://learn.microsoft.com/en-us/dotnet/framework/wcf/samples/message-security-anonymous

Run Setup.bat from the sample install folder in a Developer Command Prompt for Visual Studio with administrator privileges. This installs all certificates required for running the sample.

```batch
Setup.bat
```

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

### Example: Subscribe to Started state

Source: https://learn.microsoft.com/en-us/dotnet/framework/configure-apps/file-schema/windows-workflow-foundation/states

Configuration example that subscribes to workflow instance-level tracking records for the 'Started' instance state using the <states> element.

```XML
<workflowInstanceQueries>
    <workflowInstanceQuery>
      <states>
        <state name="Started"/>
      </states>
    </workflowInstanceQuery>
</workflowInstanceQueries>
```

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

### GetRequestedRuntimeVersion Function

Source: https://learn.microsoft.com/en-us/dotnet/framework/unmanaged-api/hosting/deprecated-clr-hosting-functions

Gets the version number of the CLR requested by the specified application. If that version is not installed, gets the most recent version that is installed before the requested version. Deprecated.

```APIDOC
## GetRequestedRuntimeVersion Function

### Description
Gets the version number of the CLR requested by the specified application. If that version is not installed, gets the most recent version that is installed before the requested version. Deprecated.

### Method
Function

### Parameters
- **application** (string) - Required - The application for which to get the requested runtime version.

### Return Value
Version number of the CLR requested by the application.
```

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

### Install with custom option: installutil /reg=true

Source: https://learn.microsoft.com/en-us/dotnet/framework/tools/installutil-exe-installer-tool

Installs the assembly, writes progress to the log, and uses the installer's custom /reg option to update the system registry.

```console
installutil /LogFile=myLog.InstallLog /reg=true myAssembly.exe

```

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

### Example configuration using <probing>

Source: https://learn.microsoft.com/en-us/dotnet/framework/configure-apps/file-schema/runtime/probing-element

Example configuration file that specifies the runtime should search the bin, bin2\subbin, and bin3 subdirectories for assemblies.

```xml
<configuration>
   <runtime>
      <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
         <probing privatePath="bin;bin2\subbin;bin3"/>
      </assemblyBinding>
   </runtime>
</configuration>

```

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

### StartsWith example

Source: https://learn.microsoft.com/en-us/dotnet/framework/data/adonet/ef/language-reference/string-canonical-functions

Checks if the string starts with the target, returning true for this example.

```sql
-- The following example returns true.
StartsWith('abc', 'ab')
```

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

### Inspect idle event bookmarks via e.Bookmarks

Source: https://learn.microsoft.com/en-us/dotnet/framework/windows-workflow-foundation/using-workflowinvoker-and-workflowapplication

Inspects the Idle handler's WorkflowApplicationIdleEventArgs to list bookmarks in e.Bookmarks. The example expects a bookmark named EnterGuess owned by ReadInt and is based on the Getting Started Tutorial's idle event handler.

```C#
wfApp.Idle = delegate (WorkflowApplicationIdleEventArgs e)
{
    foreach (BookmarkInfo info in e.Bookmarks)
    {
        Console.WriteLine($"BookmarkName: {info.BookmarkName} - OwnerDisplayName: {info.OwnerDisplayName}");
    }

    idleEvent.Set();
};
```

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

### Setup.bat: create and install server certificate

Source: https://learn.microsoft.com/en-us/dotnet/framework/wcf/samples/message-security-user-name

Setup.bat batch file creates a server certificate using makecert.exe and installs it into the client's trusted people store using certmgr.exe. The %SERVER_NAME% variable is the server name; if run with 'service' argument it is the fully-qualified domain name, otherwise defaults to localhost. The client installation step is required because Makecert-generated certificates are not implicitly trusted.

```bat
echo ************
echo Server cert setup starting
echo %SERVER_NAME%
echo ************
echo making server cert
echo ************
makecert.exe -sr LocalMachine -ss MY -a sha1 -n CN=%SERVER_NAME% -sky exchange -pe

```

```console
certmgr.exe -add -r LocalMachine -s My -c -n %SERVER_NAME% -r CurrentUser -s TrustedPeople

```

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

### gacutil -i hello.dll example

Source: https://learn.microsoft.com/en-us/dotnet/framework/app-domains/install-assembly-into-gac

Example command that installs an assembly with the file name hello.dll into the global assembly cache. This is for development purposes only; do not use gacutil.exe to install production assemblies.

```plaintext
gacutil -i hello.dll

```

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

### Install Storage Manager, Initializer, and Provider

Source: https://learn.microsoft.com/en-us/dotnet/framework/wcf/samples/durable-instance-context

Creates the storage manager, instance context initializer, and instance provider, then adds them to the DispatchRuntime of each endpoint.

```csharp
IStorageManager storageManager =
    StorageManagerFactory.GetStorageManager(storageManagerType);

InstanceContextInitializer contextInitializer =
    new InstanceContextInitializer(storageManager);

InstanceProvider instanceProvider =
    new InstanceProvider(description.ServiceType);

foreach (ChannelDispatcherBase cdb in serviceHostBase.ChannelDispatchers)
{
    ChannelDispatcher cd = cdb as ChannelDispatcher;

    if (cd != null)
    {
        foreach (EndpointDispatcher ed in cd.Endpoints)
        {
            ed.DispatchRuntime.InstanceContextInitializers.Add(contextInitializer);
            ed.DispatchRuntime.InstanceProvider = instanceProvider;
        }
    }
}

```

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

### Run setup.bat with client argument

Source: https://learn.microsoft.com/en-us/dotnet/framework/wcf/samples/authorization-policy

Run on the client computer in Developer Command Prompt for Visual Studio with administrator privileges.

```batch
setup.bat client
```

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

### C# Console Application Using SqlBulkCopy

Source: https://learn.microsoft.com/en-us/dotnet/framework/data/adonet/sql/single-bulk-copy-operations

This C# code demonstrates the syntax for using SqlBulkCopy to copy data from a source table to a destination table in the same SQL Server instance. It requires the work tables created as described in 'Bulk Copy Example Setup'. The example uses a SqlDataReader to read source data and writes it to the destination table, then displays the starting and ending row counts.

```C#
static void Main()
{
    var connectionString = GetConnectionString();
    // Open a sourceConnection to the AdventureWorks database.
    using (SqlConnection sourceConnection =
               new(connectionString))
    {
        sourceConnection.Open();

        // Perform an initial count on the destination table.
        SqlCommand commandRowCount = new(
            "SELECT COUNT(*) FROM " +
            "dbo.BulkCopyDemoMatchingColumns;",
            sourceConnection);
        long countStart = Convert.ToInt32(
            commandRowCount.ExecuteScalar());
        Console.WriteLine($"Starting row count = {countStart}");

        // Get data from the source table as a SqlDataReader.
        SqlCommand commandSourceData = new(
            "SELECT ProductID, Name, " +
            "ProductNumber " +
            "FROM Production.Product;", sourceConnection);
        SqlDataReader reader =
            commandSourceData.ExecuteReader();

        // Open the destination connection. In the real world you would
        // not use SqlBulkCopy to move data from one table to the other
        // in the same database. This is for demonstration purposes only.
        using (SqlConnection destinationConnection =
                   new(connectionString))
        {
            destinationConnection.Open();

            // Set up the bulk copy object.
            // Note that the column positions in the source
            // data reader match the column positions in
            // the destination table so there is no need to
            // map columns.
            using (SqlBulkCopy bulkCopy =
                       new(destinationConnection))
            {
                bulkCopy.DestinationTableName =
                    "dbo.BulkCopyDemoMatchingColumns";

                try
                {
                    // Write from the source to the destination.
                    bulkCopy.WriteToServer(reader);
                }
                catch (Exception ex)
                {
                    Console.WriteLine(ex.Message);
                }
                finally
                {
                    // Close the SqlDataReader. The SqlBulkCopy
                    // object is automatically closed at the end
                    // of the using block.
                    reader.Close();
                }
            }

            // Perform a final count on the destination
            // table to see how many rows were added.
            long countEnd = Convert.ToInt32(
                commandRowCount.ExecuteScalar());
            Console.WriteLine($"Ending row count = {countEnd}");
            Console.WriteLine($"{countEnd - countStart} rows were added.");
            Console.WriteLine("Press Enter to finish.");
            Console.ReadLine();
        }
    }
}
```

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

### Start CLR ETW tracing with Xperf

Source: https://learn.microsoft.com/en-us/dotnet/framework/performance/controlling-logging

Starts a CLR ETW tracing session using Xperf. The GUID is the CLR ETW provider GUID, and 0x1CCBD:5 traces everything at and below level 5 (verbose).

```bash
xperf -start clr -on e13c0d23-ccbc-4e12-931b-d9cc2eee27e4:0x1CCBD:5 -f clrevents.etl
```

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

### Set install log file: installutil /LogFile=

Source: https://learn.microsoft.com/en-us/dotnet/framework/tools/installutil-exe-installer-tool

Installs the assembly and writes progress information to the specified log file.

```console
installutil /LogFile=myLog.InstallLog myAssembly.exe

```

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

### Display InstallUtil.exe help: installutil /?

Source: https://learn.microsoft.com/en-us/dotnet/framework/tools/installutil-exe-installer-tool

Run this command to display the command syntax and available options for InstallUtil.exe. Use this to get help without specifying an assembly.

```console
installutil /?

```

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

### Create secure HTTPS metadata endpoint in code (VB)

Source: https://learn.microsoft.com/en-us/dotnet/framework/wcf/feature-details/how-to-secure-metadata-endpoints

Visual Basic version of the same example: creates a ServiceMetadataBehavior, enables HTTPS GET, sets the HTTPS URL, adds the behavior to the service host, and opens it. Requires an SSL certificate and the URL must start with https://.

```vb
' Create a new metadata behavior object and set its properties to 
' create a secure endpoint. 
Dim sb As New ServiceMetadataBehavior()

With sb
    .HttpsGetEnabled = True
    .HttpsGetUrl = New Uri("https://myMachineName:8036/myEndpoint")
End With

With myServiceHost
    .Description.Behaviors.Add(sb)
    .Open()
End With

```

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

### Main entry point launching the installer

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

The main function checks if .NET Framework 4.5 is already installed using IsNetFx4Present. If not, it launches the installer via Server().Launch(args).

```cpp
// Main entry point for program
int __cdecl main(int argc, _In_count_(argc) char **_argv)
{
    int result = 0;
    CString args;
    if (argc > 1)
    {
        args = CString(_argv[1]);
    }

    if (IsNetFx4Present(NETFX45_RC_REVISION))
    {
        printf(".NET Framework 4.5 is already installed");
    }
    else
    {
        result = Server().Launch(args);
    }

    return result;
}

```

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

### C# setup and supporting members for callback example

Source: https://learn.microsoft.com/en-us/dotnet/framework/data/adonet/sql/windows-applications-using-callbacks

C# class members and setup for the callback example. Includes the delegate, connection string with asynchronous processing enabled, display methods, and a form-closing handler that prevents closing while a command is executing.

```C#
// Add these to the top of the class, if they're not already there:
using System;
using System.Data;
using System.Data.SqlClient;

// Hook up the form's Load event handler (you can double-click on
// the form's design surface in Visual Studio), and then add
// this code to the form's class:

// You'll need this delegate in order to display text from a thread
// other than the form's thread. See the HandleCallback
// procedure for more information.
// This same delegate matches both the DisplayStatus
// and DisplayResults methods.
private delegate void DisplayInfoDelegate(string Text);

// This flag ensures that the user doesn't attempt
// to restart the command or close the form while the
// asynchronous command is executing.
private bool isExecuting;

// This example maintains the connection object
// externally, so that it's available for closing.
private SqlConnection connection;

private static string GetConnectionString()
{
    // To avoid storing the connection string in your code,
    // you can retrieve it from a configuration file.

    // If you have not included "Asynchronous Processing=true" in the
    // connection string, the command will not be able
    // to execute asynchronously.
    return "..." + "Asynchronous Processing=true";
}

private void DisplayStatus(string Text)
{
    this.label1.Text = Text;
}

private void DisplayResults(string Text)
{
    this.label1.Text = Text;
    DisplayStatus("Ready");
}

private void Form1_FormClosing(object sender, System.Windows.Forms.FormClosingEventArgs e)
{
    if (isExecuting)
    {
        MessageBox.Show(this, "Can't close the form until " +
        "the pending asynchronous command has completed. Please " +
        "wait...");
        e.Cancel = true;
    }
}
```

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

### Run setup.bat with service argument

Source: https://learn.microsoft.com/en-us/dotnet/framework/wcf/samples/authorization-policy

Run on the service computer in Developer Command Prompt for Visual Studio with administrator privileges. Creates a service certificate with the fully qualified domain name of the computer and exports it to Service.cer.

```batch
setup.bat service
```

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

### Output of WorkWithGuids example

Source: https://learn.microsoft.com/en-us/dotnet/framework/data/adonet/sql/comparing-guid-and-uniqueidentifier-values

Shows the console output produced by the C# and VB examples. It displays the unsorted Guids, the sorted Guids (ordered by all 16 bytes), and the sorted SqlGuids (ordered by the last six bytes), demonstrating the different sort orders.

```text
Unsorted Guids:  
3aaaaaaa-bbbb-cccc-dddd-2eeeeeeeeeee  
2aaaaaaa-bbbb-cccc-dddd-1eeeeeeeeeee  
1aaaaaaa-bbbb-cccc-dddd-3eeeeeeeeeee  
  
Sorted Guids:  
1aaaaaaa-bbbb-cccc-dddd-3eeeeeeeeeee  
2aaaaaaa-bbbb-cccc-dddd-1eeeeeeeeeee  
3aaaaaaa-bbbb-cccc-dddd-2eeeeeeeeeee  
  
Sorted SqlGuids:  
2aaaaaaa-bbbb-cccc-dddd-1eeeeeeeeeee  
3aaaaaaa-bbbb-cccc-dddd-2eeeeeeeeeee  
1aaaaaaa-bbbb-cccc-dddd-3eeeeeeeeeee
```

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

### VB setup and supporting members for callback example

Source: https://learn.microsoft.com/en-us/dotnet/framework/data/adonet/sql/windows-applications-using-callbacks

VB class members and setup for the callback example. Includes imports, the delegate, connection string with asynchronous processing enabled, display methods, and a form-closing handler that prevents closing while a command is executing.

```VB
' Add these to the top of the class, if they're not already there:
Imports System
Imports System.Data
Imports System.Data.SqlClient

' Hook up the form's Load event handler (you can double-click on
' the form's design surface in Visual Studio), and then add
' this code to the form's class:

' You'll need this delegate in order to display text from a thread
' other than the form's thread. See the HandleCallback
' procedure for more information.
' This same delegate matches both the DisplayStatus
' and DisplayResults methods.
Private Delegate Sub DisplayInfoDelegate(ByVal Text As String)

' This flag ensures that the user doesn't attempt
' to restart the command or close the form while the
' asynchronous command is executing.
Private isExecuting As Boolean

' This example maintains the connection object
' externally, so that it's available for closing.
Private connection As SqlConnection

Private Shared Function GetConnectionString() As String
    ' To avoid storing the connection string in your code,
    ' you can retrieve it from a configuration file.

    ' If you have not included "Asynchronous Processing=true" in the
    ' connection string, the command will not be able
    ' to execute asynchronously.
    Return "..." & "Asynchronous Processing=true"
End Function

Private Sub DisplayStatus(ByVal Text As String)
    Me.label1.Text = Text
End Sub

Private Sub DisplayResults(ByVal Text As String)
    Me.label1.Text = Text
    DisplayStatus("Ready")
End Sub

Private Sub Form1_FormClosing(ByVal sender As Object, _
    ByVal e As System.Windows.Forms.FormClosingEventArgs) Handles Me.FormClosing
    If isExecuting Then
        MessageBox.Show(Me, "Can't close the form until " & _
        "the pending asynchronous command has completed. Please " & _
        "wait...")
        e.Cancel = True
    End If
End Sub
```

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

### Install by strong name: installutil /AssemblyName

Source: https://learn.microsoft.com/en-us/dotnet/framework/tools/installutil-exe-installer-tool

Executes installer components using the /AssemblyName switch with a fully qualified assembly name. Enclose the name in quotes.

```console
installutil /AssemblyName "myAssembly, Culture=neutral, PublicKeyToken=0038abc9deabfle5, Version=4.0.0.0"

```

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

### Substring example

Source: https://learn.microsoft.com/en-us/dotnet/framework/data/adonet/ef/language-reference/string-canonical-functions

Returns the substring starting at position 4 with length 3, yielding 'xyz'. Index numbering starts from 1.

```sql
-- The following example returns xyz.
Substring('abcxyz', 4, 3)
```

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

### Example: specifying runtime version in configuration file

Source: https://learn.microsoft.com/en-us/dotnet/framework/configure-apps/file-schema/startup/startup-element

Shows two configuration file examples: one using <requiredRuntime> for version 1.0, and one using <supportedRuntime> for version 1.1 or later.

```XML
<!-- When used with version 1.0 of the .NET Framework runtime -->
<configuration>
   <startup>
      <requiredRuntime version="v1.0.3705" safemode="true"/>
   </startup>
</configuration>
<!-- When used with version 1.1 (or later) of the runtime -->
<configuration>
   <startup>
      <supportedRuntime version="v1.1.4322"/>
      <supportedRuntime version="v1.0.3705"/>
   </startup>
</configuration>
```

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

### Example: Subscribe to Started state

Source: https://learn.microsoft.com/en-us/dotnet/framework/configure-apps/file-schema/wcf/state-of-wcf-workflowinstancequery

Configuration that subscribes to workflow instance-level tracking records for the Started instance state using a workflowInstanceQuery.

```XML
<workflowInstanceQueries>
  <workflowInstanceQuery>
    <states>
      <state name="Started" />
    </states>
  </workflowInstanceQuery>
</workflowInstanceQueries>
```

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

### Example output of Environment.Version

Source: https://learn.microsoft.com/en-us/dotnet/framework/install/how-to-determine-which-versions-are-installed

Sample output of the Environment.Version example.

```output
Version: 4.0.30319.18010
```

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

### C# ServiceHost example for hosting HelloWorldService

Source: https://learn.microsoft.com/en-us/dotnet/framework/wcf/how-to-host-a-wcf-service-in-a-managed-application

Creates a ServiceHost for HelloWorldService with a base address, enables metadata publishing via ServiceMetadataBehavior, and opens the host. Uses default endpoints and prints the service address. Requires the service to be running for the WCF Test Client to connect.

```C#
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ServiceModel;
using System.ServiceModel.Description;

namespace SelfHost
{
    [ServiceContract]
    public interface IHelloWorldService
    {
        [OperationContract]
        string SayHello(string name);
    }

    public class HelloWorldService : IHelloWorldService
    {
        public string SayHello(string name)
        {
            return string.Format("Hello, {0}", name);
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Uri baseAddress = new Uri("http://localhost:8080/hello");

            // Create the ServiceHost.
            using (ServiceHost host = new ServiceHost(typeof(HelloWorldService), baseAddress))
            {
                // Enable metadata publishing.
                ServiceMetadataBehavior smb = new ServiceMetadataBehavior();
                smb.HttpGetEnabled = true;
                smb.MetadataExporter.PolicyVersion = PolicyVersion.Policy15;
                host.Description.Behaviors.Add(smb);

                // Open the ServiceHost to start listening for messages. Since
                // no endpoints are explicitly configured, the runtime will create
                // one endpoint per base address for each service contract implemented
                // by the service.
                host.Open();

                Console.WriteLine($"The service is ready at {baseAddress}");
                Console.WriteLine("Press <Enter> to stop the service.");
                Console.ReadLine();

                // Close the ServiceHost.
                host.Close();
            }
        }
    }
}

```

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

### Load assembly and invoke method in C#

Source: https://learn.microsoft.com/en-us/dotnet/framework/app-domains/how-to-load-assemblies-into-an-application-domain

C# example using Assembly.Load to load 'example', get type 'Example', method 'MethodA', create instance, and invoke. Uses System.Reflection namespace.

```C#
using System;
using System.Reflection;

public class Asmload0
{
    public static void Main()
    {
        // Use the file name to load the assembly into the current
        // application domain.
        Assembly a = Assembly.Load("example");
        // Get the type to use.
        Type myType = a.GetType("Example");
        // Get the method to call.
        MethodInfo myMethod = myType.GetMethod("MethodA");
        // Create an instance.
        object obj = Activator.CreateInstance(myType);
        // Execute the method.
        myMethod.Invoke(obj, null);
    }
}

```

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

### Launch the development Web server for the sample client

Source: https://learn.microsoft.com/en-us/dotnet/framework/wcf/samples/data-binding-in-an-aspnet-client

Command to start the ASP.NET development Web server for the sample client. Replace <WebFormsSamplePath> with the actual path and use the /port:8000 and /vpath:/client arguments. After running, browse to http://localhost:8000/client.

```command
%SystemDrive%\Program Files\Common Files\Microsoft Shared\DevServer\9.0\WebDev.WebServer.EXE" /port:8000 /path:<WebFormsSamplePath>\CS\client /vpath:/client
```
Tokens:
Raw