have code will travel

Update to ASP.NET Core

Bill Forney — Sun, 19 Aug 2018 07:46:15 GMT

Recently I updated the blog to MiniBlog.Core on ASP.NET Core. So far it seems pretty fast. I’m working on a new engine for it in my spare time using Azure Functions and blob storage. More to come when I find some time to update this.

Technorati Tags: ASP.NET Core,MiniBlog.Core,update

Getting Started with Aurelia on ASP.NET Core

Bill Forney — Mon, 22 May 2017 12:33:51 GMT

Aurelia, one of the leading JavaScript client frameworks for single page applications (SPAs), has been around for a while now and there are a number of resources for getting started with it. Rather than try to make yet another demo, I thought it might be fun to create a site repository that could be used as a template with a few more bells and whistles already setup. It is my hope that this will be useful not just to me, but to anyone else who wants to start a project. We’re going to use the command line tools to do this, but you can use Visual Studio 2017 if you want as well.

Setting up the ASP.NET Core Project

Prerequisites

Node.js (preferably current)
ASP.NET Core SDK

Steps

Create a folder for your project.
Open a command prompt (cmd) in that folder.

Install the SPA templates with the following command:

dotnet new --install Microsoft.AspNetCore.SpaTemplates::*

Create the Aurelia project like this:
```
dotnet new Aurelia 
```
Prepare the environment to run using these commands, ignoring any warnings from npm as they are expected…
```
dotnet restore
npm install
setx ASPNETCORE_ENVIRONMENT "Development"
```
Restart your command prompt to ensure that the environment change takes effect.
Run your new app with the command line
```
dotnet run
```

These steps should give you a bare bones ASP.NET Core site with a basic Aurelia setup that looks like this…

Publishing to a Host

Now that you have a working site you’ll want to publish it to an actual server somewhere. To do that you’ll perform a publish. You can do this by running this command:

dotnet publish -c Release

This command compiles the server side C# code and runs a webpack production build on the TypeScript and client assets. You can then find the files to upload to your host in the bin\Release\netcoreapp1.1\publish folder.

Exploring the Template

This template takes care of a lot of things that you would have to setup manually and makes a good starting point for adding more functionality, such as logging with Application Insights or another logging provider, fleshing out an administration interface for user management and authentication/authorization using Identity Server, or any number of other useful additions that are widely available.

To get started understanding what we’ve got here, you’ll want to take a look into the files in your new project. You’ll notice that in Startup.cs we have setup a fallback route that allows anything not dealt with by a static file or MVC route to be sent to the Home Index view. This is the secret sauce that lets all your links work even though they aren’t configured individually.

routes.MapSpaFallbackRoute(
                    name: "spa-fallback",
                    defaults: new { controller = "Home", action = "Index" });

To be continued…

Technorati Tags: ASP.NET Core,Aurelia,TypeScript,SPA

Aurelia with TypeScript on ASP.NET Core

Bill Forney — Tue, 08 Mar 2016 11:24:11 GMT

I’ve been tracking the ASP.NET betas and release candidates over the past year or more and it’s coming along nicely. I like the separation of client side and server side in the new folder structure and the unification of the MVC and WebAPI controllers. For the past few years I’ve used jsViews, Kendo UI, Angular, Durandal, Knockout, and Aurelia for front end JavaScript development.

A while ago I was using TypeScript with these to help with intellisense and typing issues across the libraries and sites I worked on. I often find myself introducing whatever team I’m on to these technologies in one way or another. I’ve been working with the combination of ASP.NET Core, formerly ASP.NET 5, and Aurelia with TypeScript and Web Components.

I start with the yoeman generator for ASP.NET and add the pieces as I go. I use ASP.NET MVC for the API and plain old HTML and TypeScript for the UI. The client tool chain consists of the usual npm, jspm, and gulp. When the new ASP.NET bits are done I’ll make a template for all this and post it to github. In the meantime I’m considering doing a short video or slide deck walking through the setup if anyone is interested.

Something different, something new, something blue

Bill Forney — Mon, 09 Nov 2015 04:36:19 GMT

Amusingly today I’m looking at new cars, hence the blue and new, but that’s not all that’s going on. Today I am starting something new that will change hopefully not just my perception of the world, but others as well. It’s time for change. Let’s do this.

Technorati Tags: different,new window,blue,change,winds of change,world,perception

How to open a “new window” in a Windows 10 Universal App

Bill Forney — Thu, 13 Aug 2015 14:59:52 GMT

I had to dig a little bit to find this. Since not all form factors support multiple windows and tablet mode generally discourages floating windows this is probably buried for a reason, but I wanted to do it anyway so here it is:

            var viewId = 0;
            var newView = CoreApplication.CreateNewView();
            await newView.Dispatcher.RunAsync(
                CoreDispatcherPriority.Normal,
                () =>
                    {
                        var frame = new Frame();
                        frame.Navigate(typeof(YourViewPageType), ViewModelDataOrNull);
                        Window.Current.Content = frame;

                        viewId = ApplicationView.GetForCurrentView().Id;

                        ApplicationView.GetForCurrentView().Consolidated += App.ViewConsolidated;

                        Window.Current.Activate();
                    });

            var viewShown = await ApplicationViewSwitcher.TryShowAsStandaloneAsync(viewId);

Hopefully that will save someone some digging.

Technorati Tags: Windows 10,Universal Apps,new window

Handy Developer Tools & Links

Bill Forney — Sat, 23 Aug 2014 03:24:29 GMT

There are a lot of tools out there and others have posted lists that are handy. I’m going to put my list of common tools here and try to keep it updated every now and then for my own use as well as anyone else who may like to reference it. Feel free to send me more to add to the list.

Helpful Blogs

The Morning Brew (Chris Alcock)

Code & Text Editors

Visual Studio Extensions

General Utilities

Updaters

Web Sites

MiniBlog

Bill Forney — Thu, 21 Aug 2014 15:43:22 GMT

Yes, I went and did it. I converted my blog to MiniBlog. It is much lighter than BlogEngine.NET. I'm liking the HTML5 and it should be fun to tweak it out a bit more too.

I've nixed some things, my old resume, the VS Achievements that only worked in VS 2012, a few other things. I might bring some back later. Still poking around with this. Stay tuned.

Technorati Tags: Blog

single page application architecture

Bill Forney — Tue, 17 Dec 2013 03:22:00 GMT

I've been poking around at a lot of JavaScript over the last year or two and have been refining this layered architecture for setting up applications. The main idea behind it is to cover all the old bases in a way that also reduces the number of requests and performs very well. The layers I am using are setup like so:

Web front end (static HTML)
- UI views, scripts, and related image files
- Localized strings as JSON files
Middle tier (WebAPI/SignalR)
Back end (database/web services)

So, to explain a little about this layout… The front end is all static. The files may be generated by a compiler or parser but upon publish they are static and require no server processing. This allows one to put these files into a CDN whether it is Azure or Amazon for massive scale and economy. Having the localization files as static JSON allows them to be packaged up with the front end and sent along with it. Depending on the configuration and build process these files could even be combined and minified further.

The middle tier is your standard WebAPI and/or SignalR server side code layer hosted on a standard ASP.NET server, usually Azure Web Sites in my case. This tier is basically an API that provides the site with any dynamic actions and information it needs.

Finally, the back end consists of a database used by the middle tier, usually a SQL server of some kind, and any external web services needed by the middle tier. You could lump the external web services into the middle tier but I prefer to think of them as something separate for the sake of organization.

There are some interesting issues you run into when implementing this pattern, including how to handle authorization and security trimming. I generally move the navigation page list into a JSON object that can be generated by the API. In this manner you avoid exposing all your pages to the client even though the templates for those pages may exist in your CDN as public files. All of the security should be enforced on the middle tier so that users cannot perform actions they are not supposed to be allowed to do.

I've found that this model is fast and performs well under load when done properly. The trick is keeping it simple while utilizing all the tooling available to generate the published result. If anyone is interested I could go into more detail about that.

Technorati Tags: JavaScript,single page application,SPA,architecture,layers,pattern

How to fix green video screen in Windows 8 Consumer Preview and Release Preview

Bill Forney — Fri, 06 Jul 2012 21:09:33 GMT

Flash has this problem where it will show up blank or green when using hardware acceleration to display video. You used to be able to turn that off in Flash options from the right click menu, but in IE10 you have to go to the Internet Explorer options’ advanced tab. There’s a checkbox there that you need to check to fix it at the top.

The computer furniture rant

Bill Forney — Fri, 08 Jun 2012 04:36:37 GMT

Have you ever noticed that furniture makers always make computer desks with those closed off little cubby holes for the tower? It’s about time someone told them computers need ventilation to work properly. I’ve seen countless computers overheat and die an untimely death due to this lack of understanding of simple common sense.

Computers have fans in them for a reason: air flow. They take cool air in and expel hot air, all the while keeping the internal case at a constant temperature, in theory. Most of the time though they run hot if they’re more than the little Wally-world special.

So, furniture companies, please remember to leave plenty of breathing room and exhaust ports for computers in your desks and nooks.