AArnott

Function Create-NuPkgSha512File {
    [CmdletBinding()]
    Param(
        [Parameter(Mandatory=$true,Position=1)]
        [string]$Path,
        [Parameter()]
        [string]$Sha512Path="$Path.sha512"
    )

    $sha512 = [Security.Cryptography.SHA512]::Create()

AArnott

Build started 9/3/2015 10:29:30 PM.
Environment at start of build:
ALLUSERSPROFILE = C:\ProgramData
ANSICON = 101x1000 (101x35)
ANSICON_DEF = 7
APPDATA = C:\Users\andarno\AppData\Roaming
ChocolateyInstall = C:\ProgramData\chocolatey
CommonProgramFiles = C:\Program Files (x86)\Common Files
CommonProgramFiles(x86) = C:\Program Files (x86)\Common Files
CommonProgramW6432 = C:\Program Files\Common Files

AArnott

Accelerate your network share hosted Package Source

NuGet is fairly flexible in where you set up your package sources. Besides the default nuget.org web service, you can set up alternate package sources at other HTTP URLs such as myget.org or your own NuGet server and even local directories on your hard disk or network UNC shares like \yourserver\nuget. When using a network share as your package store, there is a really fast and a really slow way to do it. In this post, we’ll review the two options and help you accelerate your network share based package store if you’re doing it the slow way.

Why would you want to set up a custom package source? There are a variety of reasons. Here are just a couple:

1. You want to use NuGet packages to share code internally without exposing them publicly on nuget.org
2. You have a continuous build server that produces nuget packages that you want to consume before releasing to nuget.org

Custom package sources

AArnott

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>exe</OutputType>
    <TargetFrameworks>net472;net5.0-windows</TargetFrameworks>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="System.IO.Pipes.AccessControl" Version="5.0.0" />
  </ItemGroup>

AArnott

namespace ILExaminer
{
    using System;

    static class Program
    {
        internal static Func<T> AsFunc<T>(this T value)
            where T : class
        {
            return new Func<T>(value.Return);

AArnott

/// <summary>
/// Static factory methods for creating .NET Func{T} instances with fewer allocations in some scenarios.
/// </summary>
/// <remarks>
/// These methods employ a neat trick where we take advantage of the fact that Delegate has a field to store
/// the instance on which to invoke the method. In general, that field is really just the first
/// argument to pass to the method. So if the method is static, we can use that field to store
/// something else as the first parameter.
/// So provided the valueFactory that the caller gave us is a reusable delegate to a static method
/// that takes one parameter that is a reference type, it means many Func{T} instances can be

AArnott

/// <summary>
/// Static factory methods for creating .NET Lazy<T> instances with fewer allocations in some scenarios.
/// </summary>
/// <remarks>
/// These methods employ a neat trick where we take advantage of the fact that Delegate has a field to store
/// the instance on which to invoke the method. In general, that field is really just the first
/// argument to pass to the method. So if the method is static, we can use that field to store
/// something else as the first parameter.
/// So provided the valueFactory that the caller gave us is a reusable delegate to a static method
/// that takes one parameter that is a reference type, it means many Lazy<T> instances can be

AArnott

JoinableTask longRunningAsyncWork = JoinableTaskFactory.RunAsync(async delegate
{
 await SomeOperationAsync(...);
});

// then later that async work becomes blocking:
longRunningAsyncWork.Join();

// or perhaps 
await longRunningAsyncWork;

AArnott

JoinableTaskFactory.Run(async delegate {
  await SomeOperationAsync(...);
});

AArnott

await joinableTaskFactoryInstance.SwitchToMainThreadAsync();