mkdir Processes  
cd Processes  
dotnet new webapp  
code .  

<ItemGroup>  
  <PackageReference Include="ElectronNET.API" Version="9.31.2" />  
</ItemGroup> 

using ElectronNET.API;  

webBuilder.UseElectron(args);  
webBuilder.UseEnvironment("Development");  

using ElectronNET.API;  
using ElectronNET.API.Entities;  
using System.Runtime.InteropServices; 

if (HybridSupport.IsElectronActive)  
{  
    CreateWindow();  
}  

private async void CreateWindow()  
{  
    var window = await Electron.WindowManager.CreateWindowAsync();  
    window.OnClosed += () => {  
        Electron.App.Quit();  
    };  
}

dotnet tool install ElectronNET.CLI -g  

dotnet tool list -g

electronize init  
electronize start

Uncaught TypeError: Cannot read property 'fn' of undefined  
    at util.js:55  
    at bootstrap.bundle.min.js:6  
    at bootstrap.bundle.min.js:6 

<script>window.$ = window.jquery = module.exports;</script>  

using System.Diagnostics;  

public List<Process> Processes { get; set; } 

var items = Process.GetProcesses().Where(p => !String.IsNullOrEmpty(p.ProcessName));
Processes = items.ToList();

<div>  
     <table id="myTable" class="table table-sm table-striped">  
        <thead class="thead-dark">  
            <tr class="d-flex">  
                <th scope="col" class="col-sm-2">Id</th>  
                <th scope="col" class="col-sm-6">Process Name</th>  
                <th scope="col" class="col-sm-4 text-right">Physical Memory</th>  
            </tr>  
        </thead>  
        <tbody>  
            @foreach (var item in Model.Processes)  
            {  
                <tr class="d-flex">  
                    <td class="col-sm-2" scope="row">@item.Id</td>  
                    <td class="col-sm-6">@try{@item.MainModule.ModuleName}catch{@item.ProcessName}</td>  
                    <td class="col-sm-4 text-right">@item.WorkingSet64</td>  
                </tr>  
            }  
        </tbody>  
    </table>  
</div> 

electronize start /watch  

@page  
@model ViewModel  
@{  
    ViewData["Title"] = "Process view";  
}  
<div>  
    <dl class="row">  
        @foreach (var property in @Model.PropertyList.Select(name => typeof(System.Diagnostics.Process).GetProperty(name)))  
        {  
        <dt class="col-sm-4">  
            @property.Name  
        </dt>  
        <dd class="col-sm-8">  
            @property.GetValue(Model.Process)  
        </dd>  
        }  
    </dl>  
</div>  
<div>  
    <hr />  
    <form method="post">  
        <input type="submit" value="Kill Process" class="btn btn-danger" />  
        <a class="btn btn-light" asp-page="./Index">Back to List</a>  
    </form>  
</div>  

using System.Diagnostics;  
using System.Threading.Tasks;  
using Microsoft.AspNetCore.Mvc;  
using Microsoft.AspNetCore.Mvc.RazorPages;  
using Microsoft.Extensions.Logging;  
using ElectronNET.API;  
using ElectronNET.API.Entities;

namespace Processes.Pages  
{  
    public class ViewModel : PageModel  
    {  
        private readonly ILogger<ViewModel> _logger;

        public ViewModel(ILogger<ViewModel> logger)  
        {  
            _logger = logger;

            PropertyList = new string[] {  
                "Id",  
                "ProcessName",  
                "PriorityClass",  
                "WorkingSet64"  
            };  
        }  

        public Process Process { get; set; }

        public string[] PropertyList { get; set; }

        public void OnGet(int? id)  
        {  
            if (id.HasValue)  
            {  
                Process = Process.GetProcessById(id.Value);  
            }  

            if (Process == null)  
            {  
                NotFound();  
            }  
        }  
    }  
} 

@item.Id  

<a asp-page="./View" asp-route-id="@item.Id">@item.Id</a>  

public async Task<IActionResult> OnPostAsync(int? id)  
{  
    if (id.HasValue)  
    {  
        Process = Process.GetProcessById(id.Value);  
    }  

    if (Process == null)  
    {  
        return NotFound();  
    }

    Process.Kill();  
    return RedirectToPage("Index");  
}  

const string msg = "Are you sure you want to kill this process?";  
MessageBoxOptions options = new MessageBoxOptions(msg);  
options.Type = MessageBoxType.question;  
options.Buttons = new string[] {"No", "Yes"};  
options.DefaultId = 1;  
options.CancelId = 0;  
MessageBoxResult result = await Electron.Dialog.ShowMessageBoxAsync(options);

if (result.Response == 1)  
{  
    Process.Kill();  
    return RedirectToPage("Index");  
}

return Page();  

private void CreateMenu()  
{  
    bool isMac = RuntimeInformation.IsOSPlatform(OSPlatform.OSX);  
    MenuItem[] menu = null;

    MenuItem[] appMenu = new MenuItem[]  
    {  
        new MenuItem { Role = MenuRole.about },  
        new MenuItem { Type = MenuType.separator },  
        new MenuItem { Role = MenuRole.services },  
        new MenuItem { Type = MenuType.separator },  
        new MenuItem { Role = MenuRole.hide },  
        new MenuItem { Role = MenuRole.hideothers },  
        new MenuItem { Role = MenuRole.unhide },  
        new MenuItem { Type = MenuType.separator },  
        new MenuItem { Role = MenuRole.quit }  
    };

    MenuItem[] fileMenu = new MenuItem[]  
    {  
        new MenuItem { Role = isMac ? MenuRole.close : MenuRole.quit }  
    };

    MenuItem[] viewMenu = new MenuItem[]  
    {  
        new MenuItem { Role = MenuRole.reload },  
        new MenuItem { Role = MenuRole.forcereload },  
        new MenuItem { Role = MenuRole.toggledevtools },  
        new MenuItem { Type = MenuType.separator },  
        new MenuItem { Role = MenuRole.resetzoom },  
        new MenuItem { Role = MenuRole.zoomin },  
        new MenuItem { Role = MenuRole.zoomout },  
        new MenuItem { Type = MenuType.separator },  
        new MenuItem { Role = MenuRole.togglefullscreen }  
    };  

    if (isMac)  
    {  
        menu = new MenuItem[]  
        {  
            new MenuItem { Label = "Electron", Type = MenuType.submenu, Submenu = appMenu },  
            new MenuItem { Label = "File", Type = MenuType.submenu, Submenu = fileMenu },  
            new MenuItem { Label = "View", Type = MenuType.submenu, Submenu = viewMenu }  
        };  
    }  
    else  
    {  
        menu = new MenuItem[]  
        {  
            new MenuItem { Label = "File", Type = MenuType.submenu, Submenu = fileMenu },  
            new MenuItem { Label = "View", Type = MenuType.submenu, Submenu = viewMenu }  
        };  
    }

    Electron.Menu.SetApplicationMenu(menu);  
}

private async void CreateWindow()  
{  
    CreateMenu(); // add this line  
    var window = await Electron.WindowManager.CreateWindowAsync();  
    window.OnClosed += () => {  
        Electron.App.Quit();  
    };  
} 

MenuItem[] fileMenu = new MenuItem[]  
{  
    new MenuItem { Label = "Save As...", Type = MenuType.normal, Click = async () => {  
        var mainWindow = Electron.WindowManager.BrowserWindows.First();  
        var options = new SaveDialogOptions() {  
            Filters = new FileFilter[] { new FileFilter{ Name = "CSV Files", Extensions = new string[] { "csv" } }  
        }};  
        string result = await Electron.Dialog.ShowSaveDialogAsync(mainWindow, options);  
        if (!string.IsNullOrEmpty(result))  
        {  
            string url = $"http://localhost:{BridgeSettings.WebPort}/SaveAs?path={result}";  
            mainWindow.LoadURL(url);  
        }  
    }},  
    new MenuItem { Type = MenuType.separator },  
    new MenuItem { Role = isMac ? MenuRole.close : MenuRole.quit }  
};  

public async Task<IActionResult> OnGetAsync(string path)  
{  
    System.IO.StringWriter writer = new System.IO.StringWriter();  
    writer.WriteLine("Id,Process Name,Physical Memory");  

    var items = Process.GetProcesses().Where(p => !String.IsNullOrEmpty(p.ProcessName)).ToList();  
    items.ForEach(p => {  
        writer.Write(p.Id);  
        writer.Write(",");  
        writer.Write(p.MainModule.ModuleName);  
        writer.Write(",");  
        writer.WriteLine(p.WorkingSet64);  
     });

    await System.IO.File.WriteAllTextAsync(path, writer.ToString());  
    return RedirectToPage("Index");  
} 

<PackageReference Include="C1.AspNetCore.Mvc" Version="3.0.20202.*" />  

@addTagHelper *, C1.AspNetCore.Mvc  

<c1-styles />  
<c1-scripts>  
    <c1-basic-scripts />  
</c1-scripts>  

app.UseEndpoints(endpoints =>  
{  
    endpoints.MapControllerRoute(  
        name: "default",  
        pattern: "{controller=Home}/{action=Index}/{id?}");

    endpoints.MapRazorPages();  
});  

@page  
@model ChartModel  
@{  
    ViewData["Title"] = "Chart view";  
}  
<div>  
<c1-flex-chart binding-x="Name" chart-type="Bar" legend-position="None">  
    <c1-items-source source-collection="@Model.Processes"></c1-items-source>  
    <c1-flex-chart-series binding="Memory" name="Physical Memory" />  
    <c1-flex-chart-axis c1-property="AxisX" position="None" />  
    <c1-flex-chart-axis c1-property="AxisY" reversed="true" />  
</c1-flex-chart>  
</div>  

using System;  
using System.Collections.Generic;  
using System.Linq;  
using System.Threading.Tasks;  
using Microsoft.AspNetCore.Mvc;  
using Microsoft.AspNetCore.Mvc.RazorPages;  
using Microsoft.Extensions.Logging;  
using System.Diagnostics;

namespace Processes.Pages  
{  
    public class ChartModel : PageModel  
    {  
        public List<object> Processes { get; set; }  
        private readonly ILogger<ChartModel> _logger;

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

        public void OnGet()  
        {  
            var items = Process.GetProcesses()  
                .Where(p => !String.IsNullOrEmpty(p.ProcessName))  
                .OrderByDescending(p => p.WorkingSet64)  
                .Take(10);

            Processes = items.Select(p => new {  
                Id = p.Id,  
                Name = p.ProcessName,  
                Memory = p.WorkingSet64  
            }).ToList<object>();  
        }  
    }  
}

electronize build /target xxx /PublishReadyToRun false 

지금 바로 ComponentOne을 다운로드하여 직접 테스트해 보세요!

• ComponentOne 공식 홈페이지
• ComponentOne 튜토리얼 및 샘플
• ComponentOne Q&A
• ComponentOne FAQ