Continue reading ‘Using Async Enumerable To Save Memory’ »]]> I have encountered a problem recently. We have feature in the software that allows users to download large amounts of exported data. We found that some users selected so much data that the memory grew uncontrollably in .NET Core. So I researched the problem and found out that the async enumerable feature in C# 8 could solve the issue for me.

Here is how I could reproduce the problem in a controller.

[ApiController]
[Route("[controller]")]
public class StreamingController : ControllerBase
{
    private readonly ILogger<StreamingController> _logger;

    public StreamingController(ILogger<StreamingController> logger)
    {
        _logger = logger;
    }

    [HttpGet]
    [Route("async")]
    public IAsyncEnumerable<string> Get()
    {
        Response.Clear();
        Response.Headers.Add("Content-Disposition", "attachment;filename=somenameasync.csv");
        Response.Headers.Add("Content-Transfer-Encoding", "binary");
        return GetAsyncContent();
    }

    private IEnumerable<string> GetSyncContent()
    {
        var strings = new List<string>();
        for (int i = 0; i < 1000; i++)
        {
            strings.Add(Guid.NewGuid().ToString().PadRight(1000000) + Environment.NewLine);
        }

        return strings;
    }
}

If you run this code, you will see your process hitting 4 GB of RAM. Not an ideal situation for about 1 GB export file. So the solution is to use async enumerable and literally stream the data into the browser. Here is the final version of the same controller

[ApiController]
[Route("[controller]")]
public class StreamingController : ControllerBase
{
    private readonly ILogger<StreamingController> _logger;

    public StreamingController(ILogger<StreamingController> logger)
    {
        _logger = logger;
    }

    [HttpGet]
    [Route("async")]
    public IAsyncEnumerable<string> Get()
    {
        Response.Clear();
        Response.Headers.Add("Content-Disposition", "attachment;filename=somenameasync.csv");
        Response.Headers.Add("Content-Transfer-Encoding", "binary");
        return GetAsyncContent();
    }

    [HttpGet]
    [Route("sync")]
    public IEnumerable<string> GetSync()
    {
        Response.Clear();
        Response.Headers.Add("Content-Disposition", "attachment;filename=somenameasync.csv");
        Response.Headers.Add("Content-Transfer-Encoding", "binary");
        return GetSyncContent();
    }

    private async IAsyncEnumerable<string> GetAsyncContent()
    {
        for (int i = 0; i < 1000; i++)
        {
            await Task.Delay(1);
            yield return Guid.NewGuid().ToString().PadRight(1000000) + Environment.NewLine;
        }

    }

    private IEnumerable<string> GetSyncContent()
    {
        var strings = new List<string>();
        for (int i = 0; i < 1000; i++)
        {
            strings.Add(Guid.NewGuid().ToString().PadRight(1000000) + Environment.NewLine);
        }

        return strings;
    }
}

The key part here is the signature of our method to generate the data – async IAsyncEnumerable. I can now call yield return inside the loop and return one junk export at a time and stream it into the browser. The memory is now staying around 100 MB for the same 1 GB file! You have to of course use the same signature on the controller method to enable the magic.

Enjoy!

Continue reading ‘Setting Up GitHub Actions’ »]]> I have some Open Source projects that I maintain in my “free” time.  One of them is recurrence calculator – .NET library to computer recurrence date based on Outlook style rules: https://github.com/SergeyBarskiy/RecurrenceCalculator.  I was adding support for .NET 6, and decided to invest into some automation.  I wanted to setup two builds: one when I create pull request that builds and runs tests.  Then other when I merge into master, which in addition will also push to nuget.org.  I found a few articles and GitHub documentation, but nothing was specifying full flow.  So, as I worked thought this task, I wanted to document entire action for the next person.

To create actions, you simply need to create yaml file for each one in your repo in .github/workflows folder

Action1 – build and test on pull request – main.yml

name: Build

on:
   pull_request:
     branches: [ master ]
   workflow_dispatch:

jobs:
   build:
     env:
       BUILD_CONFIG: ‘Release’
       SOLUTION: ‘RecurrenceCalculator.sln’
    
     runs-on: ubuntu-latest

    steps:
       – uses: actions/checkout@v2

      – name: Setup NuGet
         uses: NuGet/setup-nuget@v1.0.5

      – name: Restore dependencies
         working-directory: ./RecurrenceCalculator
         run: nuget restore $SOLUTION

      – name: Setup .NET
         uses: actions/setup-dotnet@v1
         with:
           dotnet-version: 6.0.*

      – name: Build
         working-directory: ./RecurrenceCalculator
         run: dotnet build $SOLUTION –configuration $BUILD_CONFIG –no-restore

      – name: Run tests
         working-directory: ./RecurrenceCalculator
         run: dotnet test $SOLUTION /p:Configuration=$BUILD_CONFIG –no-restore –no-build –verbosity normal

To explain a few things:

On section states to run on pull request against master branch.  It will execute on that branch I want to merge to master.  Plus on workflow dispatch, which means I can manually click a button to run it.  Main step is build.  I am setting up a couple of environmental variable to avoid repeating the same thing – build configuration and solution name.  Then there are step to:

• Get source code from the branch – checkout action
• Download and setup NuGet.  I could use dotnet restore instead
• Run nuget restore.  Same comment – could use dotnet restore command instead
• Download and setup .net exe and environment
• Run build
• Run tests

Action 2 – build, test and publish to NuGet.org when merged into master build-publish.yml

name: BuildAndPublish

on:
   push:
     branches: [ master ]
     paths-ignore:
       – ‘.github/**’
   workflow_dispatch:

jobs:
   build:
     env:
       BUILD_CONFIG: ‘Release’
       SOLUTION: ‘RecurrenceCalculator.sln’
    
     runs-on: ubuntu-latest

    steps:
       – uses: actions/checkout@v2

      – name: Setup NuGet
         uses: NuGet/setup-nuget@v1.0.5

      – name: Restore dependencies
         working-directory: ./RecurrenceCalculator
         run: nuget restore $SOLUTION

      – name: Setup .NET
         uses: actions/setup-dotnet@v1
         with:
           dotnet-version: 6.0.*

      – name: Build
         working-directory: ./RecurrenceCalculator
         run: dotnet build $SOLUTION –configuration $BUILD_CONFIG –no-restore

      – name: Run tests
         working-directory: ./RecurrenceCalculator
         run: dotnet test $SOLUTION /p:Configuration=$BUILD_CONFIG –no-restore –no-build –verbosity normal
        
       – name: Push to nuget
         working-directory: ./RecurrenceCalculator
         run: dotnet nuget push **/*.nupkg -s https://api.nuget.org/v3/index.json -k ${{secrets.NUGET_API_KEY}}       

The only additional step is to push to nuget.org.  I did have to add a secret to the repo with the NuGet.org publish key and the secret’s name of NUGET_API_KEY

Enjoy

Continue reading ‘Vote for a Cool Project’ »]]> My son is taking part in NATIONAL TEXAS INSTRUMENTS/NASA CODING CONTEST! If they advance, they get to visit NASA in Houston and present their project to NASA engineers at Johnson Space Center and Mission Control! VOTE FOR HIS DESIGN, THE ASTROBUTLER. Vote on each device you have!  Go here to vote: https://education.ti.com/en/promotion/codescontest and click on the project to vote!

Continue reading ‘Materials I used to prepare for AWS Certification’ »]]> I have been studying for AWS Certified Solution Architect Associate for many months.  I finally took the test this weekend.  I wanted to document the preparation materials I used.

I started with AWS Certification web site: https://aws.amazon.com/certification/certification-prep/

I read frequently asked questions page for all AWS services: https://aws.amazon.com/faqs/.  I also specifically read all the white papers included in well architected framework: https://aws.amazon.com/architecture/well-architected/

I also read test preparation guide: https://d1.awsstatic.com/training-and-certification/docs-sa-assoc/AWS-Certified-Solutions-Architect-Associate_Exam-Guide.pdf and read over sample questions: https://d1.awsstatic.com/training-and-certification/docs-sa-assoc/AWS-Certified-Solutions-Architect-Associate_Sample-Questions.pdf

Finally I took Udemy course: https://www.udemy.com/course/aws-certified-solutions-architect-associate-practice-exams-k/

I also when through sample questions book: https://www.amazon.com/Practice-Questions-2019-800-Guaranteed-ebook/dp/B07YG6NNW3

I hope this is helpful for some folks.

Continue reading ‘Using ProxyKit to Simulate IIS Rewrite Rules’ »]]> In many ASP.NET apps I worked on, I used reverse proxy in a number of situations.  Typically I used IIS modules: Application Request Routing and URL Rewrite.  You can install both inside IIS using Microsoft Web Platform Installer.  In ASP.NET Core we cannot assume that the application is hosted on Windows inside IIS.  As I looked around for the replacement, I found this open source project: ProxyKit.  I created  small demo to verify that it works.  I picked a simple use case.  When I see a specific fragment inside the request URL, I would to create new URL by using predefined server and its path plus whatever follows the segment in question in the original URL. For example, I if I see request http://localhost:5001/my/site and my fragment is “my” and new URL is http://localhost:5002/site.

So, first step is to define our rules.  I am just going to dream up the the configuration:

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft": "Warning",
      "Microsoft.Hosting.Lifetime": "Information"
    }
  },
  "AllowedHosts": "*",
  "proxy": {
    "path": "/weather/v1/my/",
    "redirectTo": "http://localhost:5002/"
  }
}

My config is under proxy section.  Now I am going to use recipes to create my code.  Mainly I am basing this on conditional recipe.

using System;
using System.Text.RegularExpressions;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using ProxyKit;

namespace Site1
{
    public class Startup
    {
        public Startup(IConfiguration configuration)
        {
            Configuration = configuration;
        }

        public IConfiguration Configuration { get; }

        public void ConfigureServices(IServiceCollection services)
        {
            services.AddControllers();
            services.AddProxy();
        }

        public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
        {
            var testPath = Configuration["proxy:path"];
            var redirectTo = Configuration["proxy:redirectTo"];
            app.UseWhen(context =>
            {
                return Regex.IsMatch(context.Request.Path.ToString(), testPath, RegexOptions.IgnoreCase);
            },
            app =>
            {
                app.RunProxy(context =>
                {
                    var finalUrl = Regex.Replace(context.Request.Path.ToString().ToLower(), testPath, redirectTo, RegexOptions.IgnoreCase);
                    var finalContext = context.ForwardTo(finalUrl);
                    finalContext.UpstreamRequest.RequestUri = new Uri(finalUrl);

                    return finalContext
                        .CopyXForwardedHeaders()
                        .AddXForwardedHeaders()
                        .Send();
                });
            });

            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }

            app.UseRouting();

            app.UseAuthorization();

            app.UseEndpoints(endpoints =>
            {
                endpoints.MapControllers();
            });
        }
    }
}

If you look at the UseWhen line, I am testing the request for the initial path in my Rewrite rule.  I am using regular expressions for performance reasons.  Then, when condition is met, I am creating new URL based on my requirements.  I am replacing parts of the URL with the replacement.  I am using ProxyKit’s ForwardTo method, but I also have to replace the URL in the forwarded context’s Upstream Request.  I am also adding standard forward headers.  So far I love this library, and wanted to share my excitement.  Thanks, Damian for your work.

Enjoy.

Continue reading ‘Creating Schedule Driven Windows Service in .NET Core 3.0’ »]]> The upcoming version of .NET Core, 3.0, will have native support for Windows and Linux Services.  On Windows the services will rely on standard Windows features.  On Linux it will rely on Systemd.  One of the most common use of windows services in to run background tasks based on a schedule.  One of the most popular frameworks for scheduling in Quartz.net.  In this quick post I will demonstrate now to achieve this task on Windows.  Let’s go step by step.

As step 1, you will need to download and install Visual Studio preview 16.3 that includes support for .NET Core 3.0 and C#8.  Of course, the Studio may be released by the time you are reading this, so you do not need to use preview in this case, use main download channel.

In step 2, run Visual Studio, select Create New Project, and pick template called Worker Service.  This will stub out the project for you with two files.  Program.cs is your entry point.  Worker.cs is the actual service worker.

In step 3, we need to enable Windows service infrastructure by calling UseWindowsServices extension method.

        public static IHostBuilder CreateHostBuilder(string[] args) =>
            Host.CreateDefaultBuilder(args)
            .UseWindowsService()
            .ConfigureServices((hostContext, services) =>
            {
                services.AddHostedService<Worker>();
            });

To use Quartz we need to install the NuGet package called Quartz. 

In the next step we need to create a couple of Jobs.

    public class Job1 : IJob
    {
        public async Task Execute(IJobExecutionContext context)
        {
            await File.AppendAllLinesAsync(@"c:\temp\job1.txt", new[] { DateTime.Now.ToLongTimeString() });
        }
    }

    public class Job2 : IJob
    {
        public async Task Execute(IJobExecutionContext context)
        {
            await File.AppendAllLinesAsync(@"c:\temp\job2.txt", new[] { DateTime.Now.ToLongTimeString() });
        }
    }

The jobs just update text file, they are demo jobs after all, in c:\temp folder.  You need to create this folder if it does not exist.

In the next step we need to create schedule and schedule the jobs.  The final Worker class looks as follows.

using System;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using Quartz;
using Quartz.Impl;

namespace WorkerService1
{
    public class Worker : BackgroundService
    {
        private readonly ILogger<Worker> _logger;
        private StdSchedulerFactory _schedulerFactory;
        private CancellationToken _stopppingToken;
        private IScheduler _scheduler;

        public Worker(ILogger<Worker> logger)
        {
            _logger = logger;
        }

        protected override async Task ExecuteAsync(CancellationToken stoppingToken)
        {
            await StartJobs();
            _stopppingToken = stoppingToken;
            while (!stoppingToken.IsCancellationRequested)
            {
                await Task.Delay(1000, stoppingToken);
            }
            await _scheduler.Shutdown();
        }

        protected async Task StartJobs()
        {
            _schedulerFactory = new StdSchedulerFactory();

            _scheduler = await _schedulerFactory.GetScheduler();
            await _scheduler.Start();

            IJobDetail job1 = JobBuilder.Create<Job1>()
                .WithIdentity("job1", "gtoup")
                .Build();

            ITrigger trigger1 = TriggerBuilder.Create()
                .WithIdentity("trigger_10_sec", "group")
                .StartNow()
                .WithSimpleSchedule(x => x
                    .WithIntervalInSeconds(10)
                    .RepeatForever())
            .Build();


            IJobDetail job2 = JobBuilder.Create<Job2>()
               .WithIdentity("job2", "group")
               .Build();

            ITrigger trigger2 = TriggerBuilder.Create()
                .WithIdentity("trigger_20_sec", "group")
                .StartNow()
                .WithSimpleSchedule(x => x
                    .WithIntervalInSeconds(20)
                    .RepeatForever())
            .Build();


            await _scheduler.ScheduleJob(job1, trigger1, _stopppingToken);
            await _scheduler.ScheduleJob(job2, trigger2, _stopppingToken);
        }
    }
}

Now we just run the project and observe everything working.  Now we need to confirm that we can install and run our code as Windows Service. 

In this final step, we need to install the service by typing the following on the command prompt to create the service:

sc create “service1″ binPath=”C:\Users\serge.000\Source\Repos\WorkerService1\WorkerService1\bin\Debug\netcoreapp3.0\WorkerService1.exe”

To start the service just type the following and hit Enter

sc start service1

We should now see our files being updated in c:\temp folder at different intervals, base on the schedules we setup for each job.  When your testing is done, type “sc stop service1” to stop the service.  Then type “sc delete service1” to remove the service from your machine. 

Enjoy.

Continue reading ‘Distributed Cache, Redis and .NET Core’ »]]> In many apps there is a need to have distributed cache.  For years now, adopting distributed cache on Windows has been a challenge.  Most popular product, Redis, is no longer supported on Windows platform.  The easiest way to get it going on Windows today is Docker for Windows in my opinion.  To do so, first you have to install Docker for Windows.  I am a fan of graphical user interfaces, so I would also recommend installing Kitematic.  Once that is done, run Kitematic, click New and in search box type Redis.  In search results pick Redis (Redis:latest) and click Create.  Now just wait a bit while you are downloading and isntalling Redis.  Eventually, you will see in Kitematic that Redis is running.  Now you can test Redis.  Open command prompt, I use Terminal for Windows.  You can use PowerShell or Command Prompt, either one. 

Type the following and hit Enter

docker exec -it redis sh

At the next prompt type the following and hit Enter

redis-cli

Now type the following and hit Enter

set name John

You should see Ok.  Now type the following and hit Enter.

get name

You should see John, meaning that you were successful in storing and retrieving a cache entry with the key of name and value of John.

Now let’s create new .NET Core Console app.  Run Visual Studio, create new project, pick .NET Core Console App.  Add new NuGet package of Microsoft.Extensions.Caching.Redis.Core.  For testing reason I am just going to create options class.

    public class MyRedisOptions : IOptions<RedisCacheOptions>
    {
        public RedisCacheOptions Value => new RedisCacheOptions
        {
            Configuration = "127.0.0.1:32768",
            InstanceName = "serge"
        };
    }

The main thing you see is the port number.  You can get that from Kitematic.  If you click on Redis image, under IP and ports you will see Access Url, this is what we need.  I would like to store a instance of a class, so I am going to create a person class.

    [Serializable]
    public class Person
    {
        public string Name { get; set; }
        public Person Parent { get; set; }
    }

You will notices that I added Serializable attribute.  This comes for requirement of IDistributedCache interface.  it only operations on byte arrays.  I am going to lean on BinaryFormatter class, new in .NET Code 2.1 to serialize an object into a byte array.  I am going to create a little extensions class for that that I can reuse everywhere.

    public static class IDistributedCacheExtensions
    {
        public static async Task SetAsync<T>(this IDistributedCache cache, string key, T value, DistributedCacheEntryOptions options)
            where T : class, new()
        {
            using (var stream = new MemoryStream())
            {
                new BinaryFormatter().Serialize(stream, value);
                await cache.SetAsync(key, stream.ToArray(), options);
            }
        }

        public static async Task<T> GetAsync<T>(this IDistributedCache cache, string key)
            where T : class, new()
        {
            var data = await cache.GetAsync(key);
            using (var stream = new MemoryStream(data))
            {
                {
                    return (T)new BinaryFormatter().Deserialize(stream);
                }
            }
        }


        public static async Task SetAsync(this IDistributedCache cache, string key, string value, DistributedCacheEntryOptions options)
        {
            await cache.SetAsync(key, Encoding.UTF8.GetBytes(value), options);
        }

        public static async Task<string> GetAsync(this IDistributedCache cache, string key)
        {

            var data = await cache.GetAsync(key);
            if(data != null)
            {
                return Encoding.UTF8.GetString(data);
            }
            return null;
        }
    }

I am ready for the final test in my console app.

    class Program
    {
        public static async Task Main(string[] args)
        {
            RedisCache cache = new RedisCache(new MyRedisOptions());
            var person = new Person
            {
                Name = "Sergey",
                Parent = new Person
                {
                    Name = "John"
                }
            };
            await cache.SetAsync("sergey", person, new DistributedCacheEntryOptions ());

            var p = await cache.GetAsync<Person>("sergey");
            Console.WriteLine(p.Name + " " + p.Parent.Name);

            await cache.SetAsync("random", "some value", new DistributedCacheEntryOptions());
            Console.ReadKey();
        }
    }

As you can see I am creating an instance of RedisCache, new instance of a Person class, then just set and retrieve the value of Person and some random string.

A few of thoughts in conclusion.

• Did you notice that I used async main?  Console apps now support async entry point!
• In normal asp.net core app I would not use Redis options directly, instead I would use methods available in Microsoft.Extensions.Caching.Redis.Core to inject and configure Redis as distributed cache.
• Now anytime I need distributed cache, I would inject IDistributedCache and set or retrieve the data.
• I can also use Json.Net to serialize or deserialize object.

Thanks and enjoy.

Continue reading ‘Controlling Scrolling with @Angular/flex-layout’ »]]> Flex-layout library written by Angular team can be used to layout our web applications written in @Angular.  One of the issues that we had to persistently deal with is to control scrolling in various parts of the screen independently.  We can always let browser control the vertical scrolling.  However, this becomes a problem with more complex layouts, where for example, you want to have to columns, each one with independent scrolling.  Another example would be to let left column be fixed, and write to be scrollable.  If you let browser control scrolling, you will see that left side, albeit fixed, will show unusable space underneath.  Here is an example that looks Ok to begin with, but looks strange when you scroll the left side.

I wanted to create a clean prescriptive solution for independent vertical scrolling in multiple components.  To demonstrate I will re-create the layout above with a few components.

• Root component that is created automatically when you scaffold new app with Angular CLI.
• Left side component, called BlueComponent
• Write side wrapper component, called YellowComponent
• Small component that will be in the first row inside yellow, called RedComponent
• Component that will host a list, called GreenComponent
• Component which be a row inside green component, called ScrollableOrangeComponent

What I want is for yellow and blow occupy 50% of width of the visible screen without scrolling.  I also want the content of the green component to scroll independently.

Here is how it looks when all rows inside green are visible due to browser size.

Here is how it looks when green does not have enough height to accommodate all the instance of orange component

I created components with borders so that I can tell where it ends. In this case I achieved my goal.  How is this done?  You have to follow a few steps.

1. We have to constraint the browser window vertically to ensure there are no scrollbars in the browser, as you may end up with multiple vertical scrollbars in this case.

This can be done by setting a little bit of css applied to the body element in the shared root CSS file included in Angular template project.  This file is called styles.css. I am going to use vertical size units called vh.  These are vertical height percentage unit.  If we set that to 100, this would occupy all available vertical space.  We also want to reset margins to ensure that they are 0 and occupy no space.

body {
    height: 100vh;
    background-color: bisque;
    margin: 0;
}

I set background color to be able to see the body.  In my case I do not see any, which is the idea.

2.  Now we have to setup root component to also be constrained vertically.

In order to do this, we have to use row layout from flex-layout (or flexbox) library.  I want to have to 50% columns, one for blue, one for yellow.

<div fxFlexFill fxLayoutAlign=”start stretch” fxLayout=”row” class=”root”>

    <app-blue fxFlex=”50″ fxFlexFill></app-blue>

    <app-yellow fxFlex></app-yellow>

</div>

Let’s walk through this if you have not use flex-layout library before.  FxFlexFill stretches out the content to occupy all available space, aka 100% of width and height.  fxLayout set to row, making sure that our content will be arranged as a number of columns.  In our case we have two compoentns: blue and yellow.  Each one is set to 50% via fxFlex=”50”.  We are using fxFlexFill on blue as well.  We are using additional root class, but just to set the border so that we can see our root component.

Blue component is very simple, just a title.

<div class=”blue” fxLayout=”row” fxlayoutAlign=”start stretch” fxFlexFill>

    <div fxFlex>Blue</div>

</div>

Again we are making sure it stretches the content with fxFlexFill.  It’s layout is not relevant for us.

3.  Now we need to setup component on the right hand side with two components inside arranged in rows.

<div class=”yellow” fxLayout=”column” fxlayoutAlign=”start stretch” fxFlexFill>

    <div fxFlex=”none”>Yellow</div>

    <app-red fxFlex=”none”></app-red>

    <app-green fxFlex></app-green>

</div>

What we have here is fxLayout set to column in order to arrange the inner components in rows.  In the first row we have just the title.  We are setting it;s fxFlex to none in order to opt out of flexbox layout and let the component size itself.  Red component in the next row, also opting out of any resizing.  Finally, our green component is set to fxFlex without a value, which means occupy all available space, in this case vertical space of the last row,

4.  Now we need to setup our next component to accommodate scrollable content when necessary.

<div class=”green” fxLayout=”column” fxlayoutAlign=”start stretch”>

    <div fxFlex>Green</div>

    <app-scrollable-orange [title]=”item” *ngFor=”let item of items”></app-scrollable-orange>

</div>

We layout this component’s contents in rows, using fxLayout set to column.  We set layout align to start stretch, where start means in the direction of the layout, horizontally in this case.  Then we want to occupy all available space in perpendicular direction, vertically in this case.  Then we are creating some number of scrollable components, using ngFor.

import { Component, OnInit } from '@angular/core';

@Component({
  selector: 'app-green',
  templateUrl: './green.component.html',
  styleUrls: ['./green.component.css']
})
export class GreenComponent implements OnInit {
  items: number[] = [];
  constructor() {}

  ngOnInit() {
    for (let i = 1; i <= 40; i++) {
      this.items.push(i);
    }
  }
}

We do that in the onInit method.  We also need to enable scrolling in this component in its css file.

.green {
  background: green;
  color: white;
  border: 5px bisque solid;
}
:host {
  overflow-y: auto;
}

We do two things here.  We set vertical overflow to automatic on the :host.  When angular creates components, it will create a component html tag, in our case aap-green, as this is what we have in our yellow component, then it will put the content of the green’s template inside of it.  We want to make sure the outer element (app-green) is scrollable.  Inside the css this is visible as :host.  The rest if css is not relevant, and just controls the colors.

Scrollable orange component is also not relevant for the layout, but for the sake of completeness, here is its source:

import { Component, OnInit, Input } from '@angular/core';

@Component({
  selector: 'app-scrollable-orange',
  templateUrl: './scrollable-orange.component.html',
  styleUrls: ['./scrollable-orange.component.css']
})
export class ScrollableOrangeComponent implements OnInit {

  @Input() title?: string = "1";

  constructor() { }


  ngOnInit() {
  }

}

It’s template is also simple:

<div class=”orange”>Orange {{ title }}</div>

That is it.  So, to summarize, we have to constrain the body and root component vertically.  Then we need to allow our component with scrollable content to occupy all available vertical space inside its parent and show scrollbar when the content is too large.  You can do something similar for horizontal scrolling, but this is far less common.

You can download the sample project here.

Enjoy.

Continue reading ‘IIS Log Parser’ »]]> I was troubleshooting performance issues today and needed to analyze IIS logs to see which requests are slow.  In the past I was able to use just Notepad to do that for small logs.  Today’s log was 172 MB in size, and I had some serious issues, even with Notepad++ trying to make sense of the data.  I looked around and found this great tool: Log Parser Studio.

You can download it from Tech Net Marketplace: https://gallery.technet.microsoft.com/Log-Parser-Studio-cd458765.

Once you donwload and unzip it, you will get a prompt to download LogParser.  Go ahead and do that.  Once you restart the studio, you will be able to query your data using T-SQL like language.  Click open folder yellow button and add your log files first.  Then you can use Search box to browse pre-built queries that ship with the tool, such as TOP 25 Slowest Url requests.

If you look at the query window, you will see the following:

SELECT TOP 25
cs-uri-stem as URL,
MAX(time-taken) As Max,
MIN(time-taken) As Min,
Avg(time-taken) As Average
FROM ‘[LOGFILEPATH]’
GROUP BY URL
ORDER By Average DESC

Now you can open a new query and start playing with your own data.  Executing top 25 slow URLs on my machine tool 1 second – that is on 172 MB worth of IIS logs.

I love this tool from Microsoft!

Enjoy.

Continue reading ‘Another .NET Core Tool’ »]]> A while ago I wrote my first global tool: http://www.dotnetspeak.com/sql-server/my-fist-net-core-tool-is-live-on-nuget/  I continued on my path to create more tools that eliminate the need for an ORM when writing .NET Core / .NET Standard apps and packages.  Since I wrote a package to generate stored procedures, I wrote a companion one that creates data access classes from an existing stored procedure.  It is oriented toward ad-hoc queries.  I am still wanting to do one specific to CRUD.  You can install it using the following command:

dotnet tool install –global dotnet-procstoclasses

This tool generates C# classes from SQL Server stored procedures. Those classes include the following: criteria class, model classes, one for each result set that a procedure returns and executor class that runs the stored procedure and returns the result. The result class will contain a property for each result set. All operations are asynchronous and target .NET Standard project. You have to create a project ahead of time and needs to reference System.Data.SqlClient NuGet. Interfaces are generated for the executor class and for classes that map reader to models.

In order to run the generator, you must create a configuration file in a folder that you are running the generator from. Here is an example of such file, by default named classes-config.json

{
  "procedures": [
    {
      "name": "usp_Company_GetById_With_Children",
      "criteria": "TestCriteria",
      "wrapperData": "WrappedData",
      "executor": "TestExecutor",
      "classes": [
        "FirstClass",
        "SecondClass"
      ],
      "locations": {
        "interfaces": "..\\..\\..\\..\\ProcsToClassesIntegrationTests\\Interfaces",
        "implementations": "..\\..\\..\\..\\ProcsToClassesIntegrationTests\\Implementations"
      },
      "namespaces": {
        "classes": "Classes",
        "interfaces": "Abstractions"
      }
    }
  ]
}

It contains a list of procedure objects. All fields are required.

name is just procedure’s name

criteria is the name of the class for criteria object. Leave blank for procedures without parameters

wrappedData is the name of the class that is returned once procedure is executed. It will have properties, one for each list corresponding to a single result set

executor is the name of the class that will execute the procedure

classes is the list of strings aka class names, one for each result set, created in the order of result sets

locations will have to properties, for locations of interfaces and implementations classes or files that are generated

namespaces has two properties, again one for interfaces, one for implementations, containing namespace that these classes and interfaces will be put into

To run the generator just type

procstoclasses -s SERVER -d DATABASE_NAME SERVER is the SQL Server instance, such as(local) or .. DATABASE_NAME is the name of the database. Windows security will be used for connecting, hence no user or password parameters.

Two more parameters are optional: -c FULL_PATH_AND_FILE_NAME_TO_CONFIG_JSON file as you see above

-p SINGLE_PROCEDURE_NAME_FROM_CONFIG_FILE. Use this to generate classes for just one procedure.

Please give me feedback on how to improve the tool.  You can view the code on github: https://github.com/SergeyBarskiy/dotnet-procstoclasses