GVKun编程网logo

Docker在Windows上运行NetCore系列（一）使用命令控制台运行.NetCore控制台应用

21

在本文中，您将会了解到关于Docker在Windows上运行NetCore系列的新资讯，同时我们还将为您解释一使用命令控制台运行.NetCore控制台应用的相关在本文中，我们将带你探索Docker在W

在本文中，您将会了解到关于Docker在Windows上运行NetCore系列的新资讯，同时我们还将为您解释一使用命令控制台运行.NetCore控制台应用的相关在本文中，我们将带你探索Docker在Windows上运行NetCore系列的奥秘，分析一使用命令控制台运行.NetCore控制台应用的特点，并给出一些关于(转).Net Core控制台生成exe能独立运行、.NET Core 2.1 以下的控制台应用程序生成 EXE，且使用命令行参数动态运行控制器应用程序的示例、.Net Core 3.1 异步控制台应用程序在 VS 之外运行时挂起、.Net Core 实践 - 如何在控制台应用(.Net Core)使用appsettings.json配置的实用技巧。

本文目录一览：

Docker在Windows上运行NetCore系列（一）使用命令控制台运行.NetCore控制台应用

Docker在Windows上运行NetCore系列（一）使用命令控制台运行.NetCore控制台应用

原文: Docker在Windows上运行NetCore系列（一）使用命令控制台运行.NetCore控制台应用

 

系列文章：https://www.cnblogs.com/alunchen/p/10121379.html

本篇文章操作系统信息

      Windows：Window 10

      Visual Studio：2017 15.8.0

 

创建项目并添加Dockerfile

      在VS2017及以上版本上创建一个控制台项目，这里的名称叫【ConsoleAppDockerWindows2】。

创建DockerFile文件

1）右键项目 --> 选中【添加】 --> 选中【容器业务流程协调程序支持】

clipboard

2）选择【Docker Compose】

clipboard

3）目标OS：选择【Windows】

clipboard

 

创建后的解析

      创建完成后，可以看到项目中多了DockerFile文件，并且也多了docker-compose的项目。我们着重看DockerFile文件，因为此文件是程序运行在Docker中的配置文件。而docker-compose可以删除，其作用是在告诉VS所要运行docker的入口点，并且可以定义多个不同容器中的依赖关系来运行。这里不讲述docker-compose。

      因为我们在VS中运行Docker，建议不要删除。

clipboard

 

怎么运行呢？

 

通过命令运行Dockerfile并生成镜像

      当完成创建Dockerfile文件后，在控制台可以看到此镜像已经安装在docker里面了。

clipboard

 

      并且通过 【docker ps -a】查看到已经添加到本地docker容器中。

      即当在VS中创建Dockerfile时，会自动地把程序添加到本地镜像与容器中。

      运行程序有很多种方法：

1）点击VS中运行 Docker 按钮，直接就可以运行

2）通过命令运行。

      第一种就不介绍了，界面华完成。

      第二种介绍一下。主要为了适应以后Linux的操作。

 

通过命令运行docker

      步骤是：编译项目->添加到镜像->将镜像添加到容器

 

      1）首先打开项目在本地包含Dockerfile的路径，路径里面必须有Dockerfile的文件。

clipboard

      并且修改一下Dockerfile文件，主要修改一下路径

clipboard

 

      2）然后生成镜像，运行命令【docker build -t consoleappdockerwindows2-cmd . 】

      如图：

clipboard

clipboard

 

      看到上图运行成功。

      运行生成运行的命令，首先会去找到Dockerfile文件，然后根据此文件配置下载需要的环境。

      输入【docker image】，可以看到运行镜像已经存在了

clipboard

 

      3）把镜像添加到容器中并运行

      使用docker run 【镜像id】，就能运行镜像了：

clipboard

 

下面说明说明一下Dockerfile

docker命令（FROM，COPY，RUN等）开头，每个命令将按从上到下的顺序执行。

  • FROM：指定要使用的docker镜像，在第1行中我们指定了用于运行应用程序的microsoft/dotnet:2.1-runtime-nanoserver-1803映像。
  • WORKDIR：指定image的工作目录。我们这里使用/ app作为我们的运行程序目录、/src编译目录。
  • COPY：将文件从本地文件系统复制到映像中。第一个COPY是将本地的csproj文件复制到image中，第二个COPY是将当前所有文件复制到image中。 复制我们将最初复制csproj文件并运行restore然后复制所有剩余文件并运行dotnet publish来构建我们的应用程序。

 

系列文章

Docker在Linux/Windows上运行NetCore文章系列

 

可以关注本人的公众号，多年经验的原创文章共享给大家。

(转).Net Core控制台生成exe能独立运行

(转).Net Core控制台生成exe能独立运行

       原文介绍了两种方式，方式一经测试可用（生成exe在开发机器上可运行），但是因为服务器是windows server2012 r2，没有安装补丁，造成了困难，尚未在服务器上运行成功。

（提示 api-ms-win-crt-runtimel1-1-0.dll，需要安装多个补丁，暂时放弃）    

 

原文地址：https://blog.csdn.net/u011511086/article/details/80419676

方式一：强烈推荐，能独立运行，依赖DLL也会生成出来，支持无安装环境也能到处运行
按win+R输入cmd在控制台中，进入项目可见bin的目录下执行如下命令：
dotnet publish -r win10-x64 /p:PublishSingleFile=true
执行效果：

 

 


项目目录：

 

生成的exe，依赖的所有dll都在publish文件夹里面，如此此exe程序就可以打包到处运行了，而不用安装运行环境了
在这里插入图片描述

转载自：
https://blog.lindexi.com/post/dotnet-core-发布只有一个-exe-的方法.html

方式二：（不推荐）
修改项目的csproj文件内容，加入

<RuntimeIdentifier>win10-x64</RuntimeIdentifier>

变成：

 

 

打开Windows PowerShell
进入项目根目录命令
cd D:\项目\TankQiandaoWx\TankQiandaoWx\TankQiandaoWx
在项目根目录执行命令：
运行程序
dotnet run -p TankQiandaoWx.csproj

发布exe
dotnet publish TankQiandaoWx.csproj

转载：
https://www.cnblogs.com/linezero/p/nightlynetcore2.html
————————————————
版权声明：本文为CSDN博主「棉晗榜」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/u011511086/article/details/80419676

.NET Core 2.1 以下的控制台应用程序生成 EXE，且使用命令行参数动态运行控制器应用程序的示例

.NET Core 2.1 以下的控制台应用程序生成 EXE，且使用命令行参数动态运行控制器应用程序的示例

 

文章：

https://stackoverflow.com/questions/44038847/vs2017-compile-netcoreapp-as-exe

 

引用

<ItemGroup>
    <PackageReference Include="Microsoft.Extensions.CommandLineUtils" Version="1.1.1" />
    <PackageReference Include="System.Collections.NonGeneric" Version="4.3.0" />
  </ItemGroup>

Program.cs

using Microsoft.Extensions.CommandLineUtils;

namespace EnumerableSample
{
    class Program
    {
        static void Main(string[] args)
        {
            var app = new CommandLineApplication(throwOnUnexpectedArg: false);
            app.FullName = "LINQ Sample App";
            LinqSamples.Register(app);
            FilteringSamples.Register(app);
            GroupingSamples.Register(app);
            CompoundFromSamples.Register(app);
            JoinSamples.Register(app);
            SortingSamples.Register(app);

            app.Command("help", cmd =>
            {
                cmd.Description = "Get help for the application";
                CommandArgument commandArgument = cmd.Argument("<COMMAND>", "The command to get help for");
                cmd.OnExecute(() =>
                {
                    app.ShowHelp(commandArgument.Value);
                    return 0;
                });
            });

            app.OnExecute(() =>
            {
                app.ShowHelp();
                return 0;
            });

            app.Execute(args);
        }
    }
}

 

LinqSamples.cs

using Microsoft.Extensions.CommandLineUtils;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;

namespace EnumerableSample
{
    internal class LinqSamples
    {
        internal static void Register(CommandLineApplication app)
        {
            MethodInfo[] methods = Assembly.GetExecutingAssembly()
                .GetTypes()
                .Where(t => t.Name == nameof(LinqSamples))
                .Single()
                .GetMethods()
                .Where(m => m.IsPublic && m.IsStatic)
                .ToArray();

            foreach (var method in methods)
            {
                app.Command(method.Name.ToLower(), cmd =>
                {
                    cmd.Description = method.Name;
                    cmd.OnExecute(() => { method.Invoke(null, null); return 0; });
                });
            }
        }

        public static void GenerateRange()
        {
            var values = Enumerable.Range(1, 20);
            foreach (var item in values)
            {
                Console.Write($"{item} ", item);
            }
            Console.WriteLine();
        }
    ｝
｝

 

FilteringSamples.cs

using DataLib;
using Microsoft.Extensions.CommandLineUtils;
using System;
using System.Linq;

namespace EnumerableSample
{
    public class FilteringSamples
    {
        internal static void Register(CommandLineApplication app)
        {
            app.Command("filter", cmd =>
            {
                var invokeMethodOption = new CommandOption("-m", CommandOptionType.NoValue);
                var indexOption = new CommandOption("-i", CommandOptionType.NoValue);
                var typeOption = new CommandOption("-t", CommandOptionType.NoValue);
                cmd.Options.AddRange(new[] { invokeMethodOption, indexOption, typeOption });
                cmd.Description = "filter -[m|i|t]";
                cmd.OnExecute(() =>
                {
                    if (invokeMethodOption.HasValue())
                    {
                        FilteringWithMethods();
                    }
                    else if (indexOption.HasValue())
                    {
                        FilteringWithIndex();
                    }
                    else if (typeOption.HasValue())
                    {
                        TypeFiltering();
                    }
                    else
                    {
                        Filtering();
                    }
                    return 0;
                });
            });
        }

        public static void Filtering()
        {
            var racers = from r in Formula1.GetChampions()
                         where r.Wins > 15 && (r.Country == "Brazil" || r.Country == "Austria")
                         select r;

            foreach (var r in racers)
            {
                Console.WriteLine($"{r:A}");
            }
        }

        public static void FilteringWithIndex()
        {
            var racers = Formula1.GetChampions()
                .Where((r, index) => r.LastName.StartsWith("A") && index % 2 != 0);
            foreach (var r in racers)
            {
                Console.WriteLine($"{r:A}");
            }
        }

        public static void FilteringWithMethods()
        {
            var racers = Formula1.GetChampions()
                .Where(r => r.Wins > 15 && (r.Country == "Brazil" || r.Country == "Austria"));

            foreach (var r in racers)
            {
                Console.WriteLine($"{r:A}");
            }
        }

        public static void TypeFiltering()
        {
            object[] data = { "one", 2, 3, "four", "five", 6 };
            var query = data.OfType<string>();
            foreach (var s in query)
            {
                Console.WriteLine(s);
            }
        }
    }
}

 

 

 

运行截图：

 

 

 

谢谢浏览！

.Net Core 3.1 异步控制台应用程序在 VS 之外运行时挂起

.Net Core 3.1 异步控制台应用程序在 VS 之外运行时挂起

我看到的唯一问题是在这段代码中，它在 O(n^2) 时间内运行：

int total = 0;
while (apiTasks.Any())
{
  // if (apiTasks.Count % 100 == 0) await Console.Out.WriteLineAsync($"{apiTasks.Count} remaining.");
  Task<int> finishedTask = await Task.WhenAny(apiTasks);
  apiTasks.Remove(finishedTask);
  total += await finishedTask;
}

如果不需要输出，则将其替换为单个 Task.WhenAll：

var totals = await Task.WhenAll(apiTasks);
var total = totals.Sum();

如果您确实需要输出，那么您可以通过补全一次重新排序，然后await每一个。有 some blogs on how to do that，或者您可以使用 Nito.AsyncEx：

int total = 0;
var orderedApiTasks = apiTasks.OrderByCompletion();
for (int i = 0; i != orderedApiTasks.Count; ++i)
{
  total += await orderedApiTasks[i];
  if (i % 100 == 0) await Console.Out.WriteLineAsync($"{orderedApiTasks.Count - i} remaining.");
}
,

以下批处理解决方案有效。它在 2-3 秒内恢复每个批次（如果在调试器中运行约 10 秒）

感谢 https://www.michalbialecki.com/2018/04/19/how-to-send-many-requests-in-parallel-in-asp-net-core/ 并感谢所有人的帮助！

using System;
using System.Threading.Tasks;
using System.Collections.Generic;
using System.Data;
using Amazon.S3;
using System.Linq;
using Amazon.S3.Model;

namespace MyNamespace
{
    public class S3PrefixGrabber
    {
        private static IAmazonS3 clientS3;

        static async Task Main(string[] args)
        {
            var query = "SELECT bucket,prefix from myTable";
            DataTable dt = GetStuffFromDB(query);
            List<S3Prefix> unpopulatedList = (from DataRow dr in dt.Rows select new S3Prefix() { B = dr[0].ToString(),P = dr[1].ToString() }).ToList();

            var batchSize = 1000;
            int numberOfBatches = (int)Math.Ceiling((double)unpopulatedList.Count() / batchSize);
            List<S3Prefix> populatedList = new List<S3Prefix>();

            for (int i = 0; i < numberOfBatches; i++)
            {
                var currentItems = unpopulatedList.Skip(i * batchSize).Take(batchSize);
                var tasks = currentItems.Select(id => GetS3DataAsync(id));
                populatedList.AddRange(await Task.WhenAll(tasks));
            }
        }

        static async Task<S3Prefix> GetS3DataAsync(S3Prefix s3Item)
        {
            clientS3 = new AmazonS3Client();
            var response = await clientS3.ListObjectsV2Async(new ListObjectsV2Request { BucketName = s3Item.B,Prefix = s3Item.P });
            s3Item.O = response.S3Objects.Count;

            return s3Item;
        }
    }

    public class S3Prefix
    {
        public string B { get; set; }
        public string P { get; set; }
        public int O { get; set; }
    }
}

运行 10k 条记录，RAM 为 75MB，CPU 为 40%
运行 300k 条记录，RAM 为 700MB，CPU 为 40%

日志中的一个片段（我没有包含在上面的代码中），仅供参考：

06:32:52.310: ================== 开始 ==================
06:32:52.795：查询：SELECT 存储桶，前缀 FROM myTable
06:32:52.874：打开连接
06:32:54.205：灌装适配器
06:33:06.309: 313863 行从 DB
返回 06:33:07.647：批处理...批处理大小：1000 批处理：314
06:33:07.647：开始第 1/314 批……在 02.84 秒内完成。
06:33:10.492：开始第 2/314 批次......在 02.48 秒内完成。
06:33:12.977：开始第 3/314 批次......在 02.19 秒内完成。
...
06:38:55.435：开始批次 150/314... 02.32 秒内完成。
06:38:57.761：开始批次 151/314... 02.17 秒内完成。
06:38:59.936：开始批次 152/314... 02.27 秒内完成。
...
06:45:13.579：开始批次 312/314... 02.17 秒内完成。
06:45:15.751：开始批次 313/314... 02.35 秒内完成。
06:45:18.105：开始批次 314/314... 02.10s 完成。
06:45:20.211：将 313863 行写入 CSV...完成。
06:45:23.086：DB 行：313863 CSV 行：313863 NotInS3：0 InS3ButNotFound：0
06:45:23.087：在 12:30.77 秒内完成。
06:45:23.092：==================结束==================

.Net Core 实践 - 如何在控制台应用(.Net Core)使用appsettings.json配置

.Net Core 实践 - 如何在控制台应用(.Net Core)使用appsettings.json配置

新建控制台应用(.Net Core)程序

添加json文件，命名为appsettings.json，设置文件属性 如果较新则复制。添加内容如下

{
  "MyWords" : "Hello World!"   
}

nuget添加相关引用

依次添加以下引用

Microsoft.Extensions.Configuration
Microsoft.Extensions.Configuration.FileExtensions
Microsoft.Extensions.Configuration.Json
Microsoft.Extensions.Hosting

实现思路

在看到《.NET 通用主机》的文章之后，认为可以尝试借助GenericHost更优雅的在Console项目中使用appsetings.json进行项目配置。 Main入口代码如下：

using System;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;

namespace ConsoleApp1
{
    class Program
    {
        private static IConfiguration _appConfiguration;
        static void Main(string[] args)
        {
            var hostBuilder = new HostBuilder().ConfigureAppConfiguration((hostContext, configApp) =>
            {
                var hostingEnvironment = hostContext.HostingEnvironment;
                _appConfiguration = AppConfigurations.Get(hostingEnvironment.ContentRootPath, hostingEnvironment.EnvironmentName);
            }).ConfigureServices((hostContext, services) =>
            {
                //注入IConfiguration到DI容器
                services.AddSingleton(_appConfiguration);

                //注入MyService到DI容器
                services.AddSingleton<IMyService, MyService>();
            });

            //初始化通用主机
            var host = hostBuilder.Build();

            //获取MyService
            var myService = host.Services.GetService<IMyService>();

            //调用SayMyWords方法
            myService.SayMyWords();

            Console.ReadKey();
        }
    }
}

demo地址

https://github.com/PuzzledAlien/DotNetCore_Practice/tree/master/%E5%A6%82%E4%BD%95%E5%9C%A8%E6%8E%A7%E5%88%B6%E5%8F%B0%E5%BA%94%E7%94%A8(.Net%20Core)%E4%BD%BF%E7%94%A8appsetting.json%E9%85%8D%E7%BD%AE

参考文章与说明

  • .NET 通用主机

说明：

  • 通用主机Hosting的开源地址：https://github.com/aspnet/Extensions/tree/master/src/Hosting

今天关于Docker在Windows上运行NetCore系列和一使用命令控制台运行.NetCore控制台应用的分享就到这里，希望大家有所收获，若想了解更多关于(转).Net Core控制台生成exe能独立运行、.NET Core 2.1 以下的控制台应用程序生成 EXE，且使用命令行参数动态运行控制器应用程序的示例、.Net Core 3.1 异步控制台应用程序在 VS 之外运行时挂起、.Net Core 实践 - 如何在控制台应用(.Net Core)使用appsettings.json配置等相关知识，可以在本站进行查询。

本文标签：

上一篇关于 Android Studio 3.2 运行应用时提示 “Instant Run requires that the platform corresponding to your target...

下一篇我用 docker 部署 prometheus（docker安装prometheus）

相关文章