.Net core

   1 using System;
   2 using myLib;
   3 
   4 namespace myApp
   5 {
   6     class Program
   7     {
   8         static void Main(string[] args)
   9         {
  10             Console.WriteLine( Class1.getHelloWorld() );
  11         }
  12     }
  13 }

   1 using System;
   2 
   3 namespace myLib
   4 {
   5     public class Class1
   6     {
   7         public static String getHelloWorld()
   8         {
   9             return "Hello world from library.";
  10         }
  11     }
  12 }

   1 using System;
   2 using Xunit;
   3 using myLib;
   4 
   5 namespace myLibTests
   6 {
   7     public class UnitTest1
   8     {
   9         [Fact]
  10         public void Test1()
  11         {
  12             Assert.Equal("Hello world from library." , Class1.getHelloWorld() );
  13         }
  14     }
  15 }

   1 // buiild and run with mono
   2 // mcs testTask.cs 
   3 // mono testTask.exe 
   4 
   5 using System;
   6 using System.Threading.Tasks;
   7 using System.Threading;
   8 // string interpolation with $ might not be supported in mono
   9 
  10 namespace testTask
  11 {
  12     class Program
  13     {
  14         static void Main()
  15         {
  16             var x=1;
  17             // String interpolation $"{varxyz}"
  18             //Console.WriteLine($"ThreadId {Thread.CurrentThread.ManagedThreadId}");
  19             Console.WriteLine("ThreadId {0}",Thread.CurrentThread.ManagedThreadId);
  20             Task t = Task.Run( () => {
  21                 x++;
  22                 Console.WriteLine("Stuff");
  23                 //Console.WriteLine($"ThreadId {Thread.CurrentThread.ManagedThreadId}");
  24                 Console.WriteLine("ThreadId {0}",Thread.CurrentThread.ManagedThreadId);
  25             } );
  26             t.ContinueWith((Task task)=>{
  27                 x++;
  28                 Console.WriteLine("This the end !");
  29                 //Console.WriteLine($"ThreadId {Thread.CurrentThread.ManagedThreadId}");
  30                 Console.WriteLine("ThreadId {0}",Thread.CurrentThread.ManagedThreadId);
  31                 task.ContinueWith((Task t2)=>{
  32                     x++;
  33                     Console.WriteLine("t2 {0}",x);
  34                     Console.WriteLine("ThreadId {0}",Thread.CurrentThread.ManagedThreadId);
  35                 });
  36             });
  37             //t.Wait();  
  38             var tx = Task<long>.Run( ()=>{ return 11L; } );
  39 
  40             tx.ContinueWith((Task<long> txy)=>{
  41                 //Console.WriteLine($"Res: {txy.Result}");
  42                 Console.WriteLine("Res: {0}",txy.Result);
  43             });         
  44         }
  45     }
  46 }

   1 //build and run using mono
   2 //mcs testForeach.cs 
   3 //mono testForeach.exe
   4 using System;
   5 using System.Collections.Generic;
   6 
   7 namespace loopNrs
   8 {
   9     class Program
  10     {
  11         static void Main()
  12         {
  13             var numbers = new List<long> { 1,2,3,4 };
  14             foreach (var nr in numbers)
  15             {
  16                 //string interpolation is not supported in mono !?
  17                 // Console.WriteLine($"Hello {nr}!");
  18                 Console.WriteLine("Hello {0}!",nr);
  19             }
  20         }
  21     }
  22 }

   1 using System;
   2 using Microsoft.Extensions.DependencyInjection;
   3 
   4 namespace testDI
   5 {
   6     interface IDummy : IDisposable
   7     {
   8         string GetPong();
   9     }
  10 
  11     interface ISnafu : IDisposable
  12     {
  13         string GetSnafu();
  14     }
  15     
  16     interface ITransx : IDisposable
  17     {
  18         string GetTransx();
  19     }
  20     
  21     class Transx : ITransx
  22     {
  23         private string guid;
  24         
  25         public Transx()
  26         {
  27             guid = Guid.NewGuid().ToString();
  28             Console.WriteLine($"Constructed transx {guid} !");
  29         }
  30         
  31         public string GetTransx()
  32         {
  33             return $"Transx {guid} !";
  34         }
  35         
  36         public void Dispose()
  37         {
  38             Console.WriteLine($"Disposing transx {guid} !");
  39         }        
  40     }
  41     
  42     class Dummy : IDummy
  43     {
  44         private string guid;
  45         
  46         public Dummy()
  47         {
  48             guid = Guid.NewGuid().ToString();
  49             Console.WriteLine($"Constructed dummy {guid} !");
  50         }
  51         
  52         public string GetPong()
  53         {
  54             return $"Pong {guid} !";
  55         }
  56         
  57         public void Dispose()
  58         {
  59             Console.WriteLine($"Disposing dummy {guid} !");
  60         }
  61     }
  62     
  63     class Snafu:ISnafu
  64     {
  65         private IDummy dummy;
  66         private string guid;
  67         
  68         public Snafu(IDummy dummy)
  69         {
  70             this.dummy = dummy;
  71             guid = Guid.NewGuid().ToString();
  72             Console.WriteLine($"Constructed snafu {guid} !");
  73         }
  74         
  75         public string GetSnafu()
  76         {
  77             return $"Snafu {guid} related with {dummy.GetPong() }!";
  78         }
  79         
  80         public void Dispose()
  81         {
  82             Console.WriteLine($"Disposing snafu {guid} !");
  83         }        
  84     }
  85     
  86     class Program
  87     {
  88         private static IServiceProvider ioc; //Default implementation ServiceProvider
  89         
  90         private static void PrepareContainer()
  91         {
  92             var serviceCollection = new ServiceCollection();
  93             serviceCollection.AddSingleton<IDummy, Dummy>();
  94             serviceCollection.AddSingleton<ISnafu, Snafu>();
  95             serviceCollection.AddTransient<ITransx, Transx>();
  96             ioc = serviceCollection.BuildServiceProvider();            
  97         }
  98         
  99         static void Main(string[] args)
 100         {
 101             Console.WriteLine("Hello World DI!");
 102             TestOne();
 103             TestTwo();
 104         }
 105         
 106         private static void TestOne()
 107         {
 108             Console.WriteLine("\nTestOne");
 109             PrepareContainer();
 110             var d1 = ioc.GetService<IDummy>();
 111             Console.WriteLine( $"{d1.GetPong()}" );
 112             var d2 = ioc.GetService<IDummy>();
 113             Console.WriteLine( $"{d2.GetPong()}" );
 114             var s1 = ioc.GetService<ISnafu>();
 115             Console.WriteLine($"{s1.GetSnafu()}" );
 116             var s2 = ioc.GetService<ISnafu>();
 117             Console.WriteLine($"{s2.GetSnafu()}" );            
 118             var t1 = ioc.GetService<ITransx>();
 119             Console.WriteLine($"{t1.GetTransx()}" );
 120             var t2 = ioc.GetService<ITransx>();
 121             Console.WriteLine($"{t2.GetTransx()}" );
 122             var t3 = ioc.GetService<ITransx>();
 123             Console.WriteLine($"{t3.GetTransx()}" );            
 124             ReleaseContainer();            
 125         }
 126         
 127         private static void TestTwo()
 128         {
 129             Console.WriteLine("\nTestTwo");
 130             PrepareContainer();            
 131             var sx1 = ioc.GetService<ISnafu>();
 132             Console.WriteLine($"{sx1.GetSnafu()}" );
 133             var dx1 = ioc.GetService<IDummy>();
 134             Console.WriteLine( $"{dx1.GetPong()}" );
 135             var dx2 = ioc.GetService<IDummy>();
 136             Console.WriteLine( $"{dx2.GetPong()}" );
 137             ReleaseContainer();            
 138         }
 139         
 140         private static void ReleaseContainer()
 141         {
 142             // dispose container and services in it
 143             if(ioc is IDisposable)
 144             {
 145                 Console.WriteLine("Can dispose stuff !");
 146                 ( (IDisposable)ioc).Dispose();
 147             }            
 148         }
 149     }
 150 }

   1 // method About related with About.cshtml
   2 // ViewData["Message"] defined in the method and accessed inside the view in the About.cshtml
   3 public IActionResult About()
   4 {
   5     ViewData["Message"] = "Your application description page.";
   6 
   7     return View();
   8     // return explicit view Orders
   9     // return View("Orders");
  10     // return both a view and a model
  11     // return View("Orders", Orders);
  12 }

   1 using System;
   2 using System.Collections.Generic;
   3 using System.IO;
   4 using System.Linq;
   5 using System.Threading.Tasks;
   6 using Microsoft.AspNetCore;
   7 using Microsoft.AspNetCore.Hosting;
   8 using Microsoft.Extensions.Configuration;
   9 using Microsoft.Extensions.Logging;
  10 
  11 namespace react_test
  12 {
  13     public class Program
  14     {
  15         public static void Main(string[] args)
  16         {
  17             CreateWebHostBuilder(args).Build().Run();
  18         }
  19 
  20         public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
  21             WebHost.CreateDefaultBuilder(args)
  22                 .UseStartup<Startup>().UseUrls("http://0.0.0.0:5000;https://0.0.0.0:5001");
  23     }
  24 }

   1 using Microsoft.OpenApi.Models;
   2 /* in Startup.cs ConfigureServices */
   3 services.AddSwaggerGen(c => { c.SwaggerDoc("v1", new OpenApiInfo { Title = "My API", Version = "v1" });  });
   4 /* in Startup,cs Configure */
   5 app.UseSwagger();
   6 app.UseSwaggerUI(c =>  { c.SwaggerEndpoint("/swagger/v1/swagger.json", "My API V1");     });

   1 using System;
   2 using System.Collections.Generic;
   3 using System.IO;
   4 using System.Text;
   5 using System.Threading;
   6 using System.Threading.Tasks;
   7 using Microsoft.AspNetCore.Http;
   8 using Microsoft.AspNetCore.Mvc;
   9 using Microsoft.Extensions.Logging;
  10 
  11 namespace test_webapi.Controllers
  12 {
  13     [ApiController]
  14     [Route("[controller]")]
  15     public class UploadController : ControllerBase
  16     {
  17         private readonly ILogger<UploadController> _logger;
  18 
  19         public UploadController(ILogger<UploadController> logger)
  20         {
  21             _logger = logger;
  22         }
  23 
  24         //---
  25         private void ShowHeadersConsole()
  26         {
  27             Console.WriteLine($"Headers");
  28             foreach (var h in Request.Headers)
  29             {
  30                 Console.WriteLine($"{h.Key}:{h.Value}");
  31             }
  32         }
  33 
  34         private async void ShowFormDataConsole()
  35         {
  36             Task<IFormCollection> task = Request.ReadFormAsync(CancellationToken.None);
  37 
  38             await task;
  39 
  40             Console.WriteLine($"Form stuff ...");
  41             // an uploaded file will not be shown  !
  42             foreach (var formItem in task.Result)
  43             {
  44                 Console.WriteLine($"{formItem.Key}:{formItem.Value}");
  45             }
  46         }
  47 
  48         private void ShowBodyConsole()
  49         {
  50             Console.WriteLine("Body");
  51             using (StreamReader reader = new StreamReader(Request.Body, Encoding.UTF8))
  52             {
  53                 Task<string> t = reader.ReadToEndAsync();
  54                 // await t;
  55                 t.Wait();
  56                 Console.WriteLine(t.Result);
  57             }
  58         }
  59 
  60         public class FormPayload1
  61         {
  62             public IFormFile UploadedFile1 { get; set; }
  63             public IFormFile UploadedFile2 { get; set; }
  64             public IFormFile UploadedFile3 { get; set; }
  65             public IFormFile UploadedFile4 { get; set; }
  66             public IFormFile UploadedFile5 { get; set; }
  67             public IFormFile UploadedFile6 { get; set; }
  68             public IFormFile UploadedFile7 { get; set; }
  69             public IFormFile UploadedFile8 { get; set; }
  70             public IFormFile UploadedFile9 { get; set; }
  71 
  72             public string TestName { get; set; }
  73         }
  74 
  75         public class FormPayload2
  76         {
  77             public IFormFileCollection UploadedFiles { get; set; }
  78             public string TestName { get; set; }
  79         }
  80 
  81         [HttpPost]
  82         [Route("[controller]/[action]")]
  83         public async Task<IActionResult> FilesApproach1([FromForm] FormPayload1 payload)
  84         {
  85             var millisSinceDawnTime = DateTime.Now.Ticks / 10000;
  86 
  87             ShowHeadersConsole();
  88             ShowFormDataConsole();
  89             ShowBodyConsole();
  90             List<string> paths = new List<string>();
  91 
  92             Console.WriteLine($"Test name: {payload.TestName} ");
  93 
  94             // identify uploaded files properties that have data and create asynch tasks to get that data
  95             List<Task<string>> tasks = new List<Task<string>>();
  96             foreach (var pi in payload.GetType().GetProperties())
  97             {
  98                 if (pi.GetValue(payload) != null && pi.Name.StartsWith("UploadedFile"))
  99                 {
 100                     Task<string> task = this.HandleFile((IFormFile)pi.GetValue(payload));
 101                     tasks.Add(task);
 102                 }
 103             }
 104 
 105             await Task.WhenAll(tasks);
 106             foreach (var task in tasks)
 107             {
 108                 paths.Add(task.Result);
 109             }
 110 
 111             return Ok(new { storePaths = paths });
 112         }
 113 
 114         [HttpPost]
 115         [Route("[controller]/[action]")]
 116         public async Task<IActionResult> FilesApproach2([FromForm] FormPayload2 payload)
 117         {
 118             /*
 119             Repeat the field uploadedFiles per file to upload
 120             curl -v -X POST -F 'UploadedFiles=@/home/vitor/test.png' -F 'UploadedFiles=@/home/vitor/Vitor.png' -F 'TestName=namex' -k https://localhost:5001/Upload/Upload/FilesApproach2
 121             */
 122             var millisSinceDawnTime = DateTime.Now.Ticks / 10000;
 123 
 124             ShowHeadersConsole();
 125             ShowFormDataConsole();
 126             ShowBodyConsole();
 127             List<string> paths = new List<string>();
 128             List<Task<string>> tasks = new List<Task<string>>();
 129 
 130             Console.WriteLine($"Test name: {payload.TestName} ");
 131             Console.WriteLine($"Amount files: {payload.UploadedFiles.Count} ");
 132 
 133             foreach (var f in payload.UploadedFiles)
 134             {
 135                 Task<string> task = this.HandleFile(f);
 136                 tasks.Add(task);
 137             }
 138 
 139             await Task.WhenAll(tasks);
 140             foreach (var t in tasks)
 141             {
 142                 paths.Add(t.Result);
 143             }
 144 
 145             return Ok(new { storePaths = paths });
 146         }
 147 
 148         private async Task<string> HandleFile(IFormFile filename)
 149         {
 150             var millisSinceDawnTime = DateTime.Now.Ticks / 10000;
 151             var filePath = String.Empty;
 152             if (filename != null)
 153             {
 154                 if (filename.Length > 0)
 155                 {
 156                     filePath = $"{Path.GetTempPath()}{millisSinceDawnTime}_{filename.FileName}";
 157                     Console.WriteLine($"Name: {filename.Name} ");
 158                     Console.WriteLine($"Filename: {filename.FileName} ");
 159                     Console.WriteLine($"Length: {filename.Length} ");
 160                     Console.WriteLine($"Type: {filename.ContentType} ");
 161                     Console.WriteLine($"Disposition: {filename.ContentDisposition} ");
 162                     Console.WriteLine($"File will be stored in: {filePath} ");
 163                     using (var stream = new FileStream(filePath, FileMode.Create))
 164                     {
 165                         await filename.CopyToAsync(stream, CancellationToken.None);
 166                     }
 167                 }
 168             }
 169 
 170             return filePath;
 171 
 172         }
 173     }
 174 }

   1 dotnet new mstest --name test-proj
   2 cd test-proj/
   3 //UnitTest1.cs
   4 using FluentAssertions;
   5 using Microsoft.VisualStudio.TestTools.UnitTesting; // MSTest 
   6 using Moq;
   7 
   8 dotnet add package Moq --version 4.14.1
   9 dotnet add package Microsoft.Extensions.Logging --version 3.1.4
  10 dotnet add package FluentAssertions --version 5.10.3
  11 dotnet add reference ../other-proj.csproj
  12 dotnet add package Microsoft.EntityFrameworkCore.Sqlite

   1 // dotnet add package Microsoft.EntityFrameworkCore.Sqlite
   2 var context = new MyDbContext(new DbContextOptionsBuilder<MyDbContext>().UseSqlite(CreateInMemoryDatabase()).Options);
   3 
   4         private static DbConnection CreateInMemoryDatabase()
   5         {
   6             var connection = new SqliteConnection("Filename=:memory:");
   7             connection.Open();
   8             return connection;
   9         }
  10 
  11 
  12 
  13 using System;
  14 using System.Data.Common;
  15 using FluentAssertions;
  16 using Microsoft.Data.Sqlite;
  17 using Microsoft.EntityFrameworkCore;
  18 using Microsoft.Extensions.Logging;
  19 using Microsoft.VisualStudio.TestTools.UnitTesting;
  20 using Moq;
  21 using test_webapi_efcore.Controllers;
  22 using test_webapi_efcore.Domain;
  23 using test_webapi_efcore.Persistence;
  24 
  25 namespace test_webapi_efcore.UnitTests
  26 {
  27     [TestClass]
  28     public class ControllerTest
  29     {
  30       [TestMethod]
  31        public void Create_IsOkay()
  32        {
  33        }
  34    }
  35 }