Silver Light and Blue Sky

C# and Infrastructure. Code is everything.

resource file naming in ASP.NET Core localization

While I'm reading the document, I found difficulty in resource file naming.

Globalization and localization | Microsoft Docs

To summarize first:

  • "name" property of the project.json uses as the assembly name of the .NET Core project. The top level folder name is used if this property is not specified.
  • We must abbreviate the assembly name from the resource class FQDN if the FQDN starts with the assembly name.
  • We must use full FQDN if the FQDN doesn't start with the assembly name.
Read more

Configure IDistributedCache and IDataProtection for session in ASP.NET Core

Background

This blog describes two things.

  • How to store session data out of the ASP.NET Core process
  • How to separate the life cycle of session data from that of ASP.NET Core process and host

In the background, ASP.NET Core app can run as a container (docker) architecture. When ASP.NET Core app runs as a docker, it's easy to scale up and down. In this situation, we would like to store session data out of Docker containers and separate lifecycle. However, you may think if we can store session data out of the ASP.NET Core process, we can separate the lifecycle of session data from that of ASP.NET Core process and host at the same time. However, this is not necessarily so at present ASP.NET Core. I explain it based on the Microsoft's document.

Managing Application State | Microsoft Docs

Read more

Update OpenShift ASP.NET Core s2i to .NET Core 1.1 Preview1

OpenShift provides ASP.NET Core s2i image.

GitHub - openshift-s2i/s2i-aspnet: Source-to-Image template for ASP.NET applications GitHub - openshift-s2i/s2i-aspnet-example: Example projects for the ASP.NET builder image

Now .NET Core 1.1 Preview 1 is released.

blogs.msdn.microsoft.com

So I updated s2i image to .NET Core 1.1 Preview1. Here are the steps.

Read more

P/Invoke in .NET Core on Red Hat Enterprise Linux

This post was originally published on Red Hat Developers, the community to learn, code, and share faster. To read the original post, click here.

P/Invoke(Platform Invocation Service) is one of the features of CLI (Common Language Interface) on .NET Framework. P/Invoke enables managed code to call a native function in DLL (Dynamic Link Library). It’s a powerful tool for .NET Framework to execute existing C-style functions easily. .NET Core also has a P/Invoke feature and it means we can call a native function in .so file (Linux) and . file (Max OSX). I will show you the short example P/Invoke in .NET Core on Red Hat Enterprise Linux (RHEL).

Here is the simple P/Invoke sample using read function in libc. It is the same way as .NET Framework on Windows to import native function.

using System;
using System.Runtime.InteropServices;
using System.Text;

namespace ConsoleApplication
{
    public class Program
    {
        [DllImport("libc")]
        static extern int read(int handle, byte[] buf, int n);

        public static void Main(string[] args)
        {
            Console.Write("Input value:");
            var buffer = new byte[100];
            read(0, buffer, 100);
            Console.WriteLine("Input value is:" + Encoding.UTF8.GetString(buffer));
        }
    }
}

[dllimport] is the attribute to import a native function. We can declare method name as a native function name, and declare method name as you like with specifying native function name in EntryPoint attribute value as below.

[DllImport("libc", EntryPoint="read")]
static extern int Read(int handle, byte[] buf, int n);

We can read text from console input with native libc method.

Next, I’d like to execute GUI sample written in .NET Core on RHEL. .NET Core doesn’t have GUI Framework at this point. However, we can call GUI library such as gtk+ from managed code in .NET Core. At first, install the package.

$ sudo yum install gtk3-devel

Now we can call functions in gtk+ from C# code. Here is the whole code to open dialog from C#.

using System;
using System.Runtime.InteropServices;

namespace ConsoleApplication
{
    public class Program
    {
        [DllImport("libgtk-x11-2.0.so.0")]
        private static extern void gtk_init (ref int argc, ref IntPtr argv);
        [DllImport("libgtk-x11-2.0.so.0")]
        static extern IntPtr gtk_message_dialog_new(IntPtr parent_window, DialogFlags flags, MessageType type, ButtonsType bt, string msg, IntPtr args);
        [DllImport("libgtk-x11-2.0.so.0")]
        static extern int gtk_dialog_run(IntPtr raw);
        [DllImport("libgtk-x11-2.0.so.0")]
        static extern void gtk_widget_destroy(IntPtr widget);
        [Flags]
        public enum DialogFlags 
        {
            Modal = 1 << 0,
            DestroyWithParent = 1 << 1,
        }

        public enum MessageType
        {
            Info,
            Warning,
            Question,
            Error,
            Other,
        }
        
        public enum ButtonsType
        {
            None,
            Ok,
            Close,
            Cancel,
            YesNo,
            OkCancel,
        }

        public static void Main(string[] args)
        {
            var argc = 0;
            var argv = IntPtr.Zero;
            gtk_init(ref argc, ref argv);
            var diag = gtk_message_dialog_new(IntPtr.Zero, DialogFlags.Modal, MessageType.Error, ButtonsType.Ok, "Hello from .NET Core on Red Hat!", IntPtr.Zero);
            var res = gtk_dialog_run(diag);
            gtk_widget_destroy(diag);
            Console.WriteLine(res);
        }
    }
}

Here is a result. The dialog is opened.

f:id:tanaka733:20160915095221p:plain

P/Invoke was a technology only for Windows platform, but now it enables many platforms to call native function easily from managed code. Of course, we shouldn’t forget Mono, which enabled P/Invoke on Linux.