Dotnet script

2017/12/04 · 1031 words · 5 minutes to read Last week, together with [Bernhard][1] we released version [0.16 of dotnet-script][2], the .NET Core 2.0 C# script runner. I’d like to summarize the new features in this short blog post - as there are two highlights of this release - which we are very excited about!The project now offers a C# REPL (interactive mode) which can be access when launching dotnet-script without any arguments. All the features of scripting are supported in the interactive mode, including support for adding Nuget references via #r “nuget: {package}”.The second large feature is support for #load “nuget: {package}”, which works similar to its #r counterpart, except not for assemblies but for referencing CSX files from Nuget.REPL overview 🔗The REPL mode (“interactive mode”) is started by executing dotnet-script without any arguments.The interactive mode allows you to supply individual C# code blocks and have them executed as soon as you press Enter. The REPL is configured with the same default set of assembly references and using statements as regular CSX script execution.Once dotnet-script starts you will see a prompt for input. You can start typing C# code there.~$ dotnet script> var x = 1;> x+x2If you submit an unterminated expression into the REPL (no ; at the end), it will be evaluated and the result will be serialized using a formatter and printed in the output. This is a bit more interesting than just calling ToString() on the object, because it attempts to capture the actual structure of the object. For example:~$ dotnet script> var x = new List();> x.Add("foo");> xList(1) { "foo" }> x.Add("bar");> xList(2) { "foo", "bar" }>Inline Nuget packages in REPL 🔗REPL also supports inline Nuget packages - meaning the Nuget packages can be installed into the REPL from within the REPL. This is done via our #r and #load from Nuget support and uses identical syntax.~$ dotnet script> #r "nuget: Automapper, 6.1.1"> using AutoMapper;> typeof(MapperConfiguration)[AutoMapper.MapperConfiguration]> #load "nuget: simple-targets-csx, 6.0.0";> using static SimpleTargets;> typeof(TargetDictionary)[Submission#0+SimpleTargets+TargetDictionary]```### REPL Multiline modeUsing Roslyn syntax parsing, we also support multiline REPL mode. This means that if you have an uncompleted code block and press _Enter_, we will automatically enter the multiline mode. The mode is indicated by the _*_ character. This is particularly useful for declaring classes and other more complex constructs. ~$ dotnet script > class Foo { * public string Bar {get; set;} * } > var foo = new Foo();### REPL commandsAside from the regular C# script code, you can invoke the following commands (directives) from within the REPL: Command Description #load Load a script into the REPL (same as #load usage in CSX) #r Load an assembly into the REPL (same as #r usage in CSX)

Git Credential Manager RPMInstallThere are prebuilt RPMs for the following distributionsCentOS 8Fedora 39Fedora 40openSUSE 15.5openSUSE 15.6openSUSE SlowrollopenSUSE TumbleweedFollow the instruction to installPatchesThere are several patches appied to the original source codeNameSourceArchDescriptionlinux-only.patchAlecJY/git-credential-manager@446e4eballAdd linux-arm64 runtime identifier to support aarch64 and remove other non-Linux identifiers to prevent downloading dependencies of other platformsruntime-arm64.patchAlecJY/git-credential-manager@b2065a7aarch64Patch the Linux build script to set dotnet runtime to linux-arm64install-buildoutput.patchAlecJY/git-credential-manager@e256ea3allPatch the Linux build script to install Git Credential Manager into "buildoutput" directory instead of generating deb and tar packagesBuildThere are to variants of the RPM SPEC file, the normal one requires Internet access and the one especially for openSUSE Build Service or other environments without Internet access.Build with Internet accessInstall the build dependencies# For RHEL / CentOS / Fedora / etc...$ sudo yum install -y rpm-build dotnet-sdk-8.0 openssl-libs libicu# For SLES / openSUSE / etc...# Run the first command only if you didn't install dotnet SDK$ sudo zypper addrepo sudo zypper refresh$ sudo zypper install -y rpm-build dotnet-sdk-8.0 libopenssl1_1 libicuBuild the RPM$ git clone cd git-credential-manager-rpm$ rpmbuild -bb git-credential-manager.spec --undefine "_disable_source_fetch" --define "_sourcedir $PWD"Build without Internet accessPrepare the following files on a machine with Internet accessThis repo (branch obs)Download from Credential Manager source codeDownload from ${version} with the latest version of Git Credential Manager. For example: dotnet SDK 8.0 binariesYou can download from both arm64 and x64 binaries for Linux even if you only want to build on one architecture.The reason that you need to download dotnet SDK for both platforms is to make sure all architectures share the same source RPM.If you really don't want to download dotnet SDK for the other architecture, you can just create an empty file with the name.Pre-downloaded NuGet dependenciesRecommend to do this step in a clean docker container to prevent other unnecessary NuGet packages being includedBuild Git Credential Manager on a machine with Internet access once (such as follow the steps in Build with Internet access section). Then compress the packages directory generated by Nuget$ cd ~/.nuget/$ tar Jcvf nuget-packages.tar.xz packages/Some packages are platform-specific such as Microsoft.NETCore.App.Host.xxx. Therefore, to make a cross-platform offline NuGet packages archive you need to run this step on each platform then combine the data in the archives together.Install the build dependencies# For RHEL / CentOS / Fedora / etc...$ sudo yum install -y rpm-build openssl-libs libicu# For SLES / openSUSE / etc...$ sudo zypper install -y rpm-build libopenssl1_1 libicuBuild the RPMNow you should have four filesobs.tar.gzThe compressed GCM source code. Ex: v2.1.0.tar.gzdotnet-sdk-8.0.xxx-linux-arm64.tar.gzdotnet-sdk-8.0.xxx-linux-x64.tar.gznuget-packages.tar.xzExtract obs.tar.gz and put other four files into the extracted git-credential-manager-rpm-obs directory.Then open git-credential-manager.spec with a text editor. Check the two lines...%global dotnet_version 8.0.xxx...Version: 2.x.x...dotnet_version is the version of dotnet SDK, and Version is the version of Git Credential Manager.If the version differ from the files you downloaded,

Version Source----------------------------------------------------------------------------------------------Microsoft .NET SDK 9.0 Microsoft.DotNet.SDK.9 9.0.100 wingetMicrosoft .NET SDK 8.0 Microsoft.DotNet.SDK.8 8.0.300 wingetMicrosoft .NET SDK 7.0 Microsoft.DotNet.SDK.7 7.0.409 wingetMicrosoft .NET SDK 6.0 Microsoft.DotNet.SDK.6 6.0.422 wingetMicrosoft .NET SDK 5.0 Microsoft.DotNet.SDK.5 5.0.408 wingetMicrosoft .NET SDK 3.1 Microsoft.DotNet.SDK.3_1 3.1.426 wingetInstalar versões préviasSe uma versão prévia estiver disponível, substitua o número da versão no Id pela palavra Preview. O exemplo a seguir instala a versão prévia do Runtime da Área de Trabalho do .NET:winget install Microsoft.DotNet.DesktopRuntime.PreviewInstalar com o PowerShellA instalação do .NET por meio do script dotnet-install do PowerShell é recomendada para instalações de integração contínua e não administrador. Se você estiver instalando o .NET para uso normal em seu sistema, use os métodos de instalação do Instalador do .NET ou do Gerenciador de Pacotes do Windows.O script usa como padrão a instalação da versão LTS (suporte de longo prazo) mais recente, que é o .NET 8. Você pode escolher uma versão específica definindo a opção -Channel . Inclua a opção -Runtime para instalar um runtime. Caso contrário, o script instala o SDK. O script está disponível em e o código-fonte está hospedado no GitHub.Para obter mais informações sobre o script, consulte dotnet-referência do script de instalação.Instalar o runtimeO Runtime do .NET é instalado fornecendo a opção -Runtime .Baixar o script de instalação de o PowerShell e navegue até a pasta que contém o script.Execute os seguintes comandos para instalar o runtime da área de trabalho e o runtime do ASP.NET Core para obter a máxima compatibilidade:dotnet-install.ps1 -Runtime windowsdesktopdotnet-install.ps1 -Runtime aspnetcorePara saber como usar a CLI do .NET, consulte Visão geral da CLI do .NET.Instalar o SDKSe você instalar o SDK, não será necessário instalar os runtimes.Baixar o script de instalação de o PowerShell e navegue até a pasta que contém o script.Execute o comando a seguir para instalar o SDK do .NET.dotnet-install.ps1ObservaçãoO

Encontrá-lo.Na página de lançamento, você pode ver a versão do Runtime do .NET e do SDK do .NET e um link para o arquivo de soma de verificação:Copie o link do arquivo de soma de verificação.Use o script a seguir, mas substitua o link para baixar o arquivo de soma de verificação apropriado:Invoke-WebRequest -OutFile 8.0.0-sha.txtCom o arquivo de soma de verificação e o arquivo de versão do .NET baixados no mesmo diretório, pesquise no arquivo de soma de verificação a soma de verificação do download do .NET:Quando a validação for aprovada, você verá True impresso:> (Get-Content .\8.0.0-sha.txt | Select-String "dotnet-sdk-8.0.100-win-x64.exe").Line -like (Get-FileHash .\dotnet-sdk-8.0.100-win-x64.exe -Algorithm SHA512).Hash + "*"TrueSe False for impresso, o arquivo baixado não será válido e não deverá ser usado.Solução de problemasDepois de instalar o SDK do .NET, você pode ter problemas ao tentar executar comandos da CLI do .NET. Esta seção coleta esses problemas comuns e fornece soluções.Nenhum SDK do .NET foi encontradoA criação de aplicativos está mais lenta do que o esperadohostfxr.dll / api-ms-win-crt-runtime-l1-1-0.dll / api-ms-win-cor-timezone-l1-1-0.dll está ausenteNenhum SDK do .NET foi encontradoProvavelmente, você instalou as versões x86 (32 bits) e x64 (64 bits) do SDK do .NET. Isso está causando um conflito porque quando você executa o comando dotnet, ele está resolvendo para a versão x86 quando ele deve ser resolvido para a versão x64. Esse problema é corrigido ajustando a variável %PATH% para resolver a versão x64 primeiro.Verifique se você tem as duas versões instaladas executando o comando where.exe dotnet. Se você fizer isso, deverá encontrar uma entrada para as pastas Program Files\ e Program Files (x86)\. Se a pasta Program Files (x86)\ estiver em primeiro lugar, como mostrado no exemplo a seguir, isso estará incorreto e você deverá prosseguir para a próxima etapa.> where.exe dotnetC:\Program Files (x86)\dotnet\dotnet.exeC:\Program Files\dotnet\dotnet.exeDicaEmbora Program Files seja usado neste exemplo,

#reset Reset the REPL back to initial state (without restarting it) #cls Clear the console screen without resetting the REPL state #exit Exits the REPL ### Seeding REPL with a scriptYou can execute a CSX script and, at the end of it, drop yourself into the context of the REPL. This way, the REPL becomes “seeded” with your code - all the classes, methods or variables are available in the REPL context. This is achieved by running a script with an _-i_ flag.For example, given the following CSX script:```csharpvar msg = "Hello World";Console.WriteLine(msg);```When you run this with the _-i_ flag, _Hello World_ is printed, REPL starts and _msg_ variable is available in the REPL context. ~$ dotnet script foo.csx -i Hello World > You can also seed the REPL from inside the REPL - at any point - by invoking a _#load_ directive pointed at a specific file. For example: ~$ dotnet script > #load "foo.csx" Hello World >### _#load_ with Nuget support ("Script packages")On the heels of our _#r_ from Nuget for referencing Nuget packages, we are now introducing _#load_ with Nuget support. It allows you to reference a Nuget package containing not assemblies, bur _other CSX files_ and consume them directly against your script.Script packages are a way of organizing reusable scripts into NuGet packages that can be consumed by other scripts. This means that we now can leverage scripting infrastructure without the need for any kind of bootstrapping.### Creating a script packageA script package is just a regular NuGet package that contains script files inside the _content_ or _contentFiles_ folder.The following example shows how the scripts are laid out inside the NuGet package according to the [standard convention][3] .```└── contentFiles └── csx └── netstandard2.0 └── main.csx```This example contains just the _main.csx_ file in the root folder, but packages may have multiple script files either in the root folder or in subfolders below the root folder.When loading a script package we will look for an entry point script to be loaded. This entry point script is identified by one of the following. * A script called _main.csx_ in the root folder * A single script file in the root folderIf the entry point script cannot be determined, we will simply load all the scripts files in the package.> The advantage with using an entry point script is that we can control loading other scripts from the package.### Consuming a script packageTo consume a script package all we need to do specify the NuGet package in the _#load_directive.The following example loads the [simple-targets][4] package that contains script files to be included in our script.```csharp#! "netcoreapp2.0"#load "nuget:simple-targets-csx, 6.0.0"using static SimpleTargets;var targets = new TargetDictionary();targets.Add("default", () => Console.WriteLine("Hello, world!"));Run(Args, targets);```> Note: