魔法薇ㄦ的书馆

【UWP】使用 Vue/Vite 编写 WinJS/UWP

2026-03-21T01:56:00.000Z

如今微软网页套壳越来越变本加厉，到处都是一人一个浏览器，套壳大小已经成百上千，但殊不知微软曾经有过对网页套壳的原生支持，打包大小只按k记，那就是 MSAppHost 了，不过更为人所知的是其控件库 WinJS，所以这里就用 WinJS 代指 JS/HTML 模式的 UWP 了。WinJS/UWP 本质就是直接让 Edge (过去为 IE) 的 WebView 直接打开打包好的网页，同时给这个环境加上 WinRT 支持，由于 MSAppHost 是系统组件，所以只用打包 Web 资源就行了。WinJS 曾作为 WSA (Windows Store App) 的主推平台，甚至 Win8 应用商店都是 JS/HTML 开发的，不过在进入 Win10 之后，有了 .NET Native 的加持，C#/UWP 逐渐变为主流，MSAppHost 基本上只剩下了作为 PWA 的用途。然而随着 Edge HTML 的停更，Windows 再也没有了原生的 HTML 渲染平台，微软也在 VS 2019 中彻底删除了对 WinJS 的支持。

不过 MSAppHost 框架作为系统组件并没有被删除，利用 electron-windows-msix 插件，我们可以轻松打包一个 NPM 项目，我们只需要将清单改为 MSAppHost 模式即可。接下来我们将演示如何新建一个 Vue/UWP 项目。

首先我们根据 Vue 官方教程新建一个空白 Vue 项目：

1	npm create vue@latest

进入项目文件夹后安装依赖：

npm i

然后我们测试一下它是否可以正常运行：

1	npm run dev

由于 MSAppHost 永远留在了 Edge HTML 18，所以我们需要把 JS 编译到 Edge 18 兼容的版本，安装 @vitejs/plugin-legacy：

1	npm i --save-dev @vitejs/plugin-legacy

在 vite.config.ts 配置插件，由于 vite 使用到了新版 ESM 模块特性，所以 Edge 只能使用 Legacy 模式，注意 base 一定要设置为 ./，因为打包插件会把编译结果打包进 app 文件夹：

import legacy from '@vitejs/plugin-legacy'
...
export default defineConfig({
  base: './',
  plugins: [
    ...
    legacy({
      targets: 'Edge >= 18',
      polyfills: true,
      renderModernChunks: false
    })
  ],
  ...
})

验证可以正常运行后，我们安装 electron-windows-msix 插件：

1	npm i --save-dev electron-windows-msix

然后编写打包脚本，可以参考 package.mjs：

import { packageMSIX } from "electron-windows-msix";

/** @type {import("electron-windows-msix").WindowsSignOptions} */
let windowsSignOptions = undefined;
const certificateFileIndex = process.argv.indexOf("--certificateFile");
if (certificateFileIndex != -1) {
    windowsSignOptions = {
        certificateFile: process.argv[certificateFileIndex + 1]
    };
    const certificatePasswordIndex = process.argv.indexOf("--certificatePassword");
    if (certificatePasswordIndex != -1) {
        windowsSignOptions.certificatePassword = process.argv[certificatePasswordIndex + 1];
    }
    const timestampServerIndex = process.argv.indexOf("--timestampServer");
    if (timestampServerIndex != -1) {
        windowsSignOptions.timestampServer = process.argv[timestampServerIndex + 1];
    }
}

const { msixPackage } = await packageMSIX({
    appManifest: "AppxManifest.xml",
    appDir: "dist",
    packageAssets: "assets",
    outputDir: "appx",
    packageName: "VueForUWP.msix",
    windowsKitVersion: "10.0.26100.0",
    windowsSignOptions,
    sign: !!windowsSignOptions
});
console.log(`MSIX package created at: ${msixPackage}`);

其中 appManifest 是 Appx 清单的路径；appDir 是 vite 编译结果文件夹；packageAssets 是 Appx 资源文件夹，如果不设置会使用插件默认的资源，下面的 Appx 清单使用的就是默认资源；windowsKitVersion 需要选择已安装的 Windows SDK 版本。

由于默认清单是 FullTrust Win32 打包项目，所以我们需要手动编写清单，新建 AppxManifest.xml 文件：

"1.0" encoding="utf-8"?>

<Package
  xmlns="http://schemas.microsoft.com/appx/manifest/foundation/windows10"
  xmlns:mp="http://schemas.microsoft.com/appx/2014/phone/manifest"
  xmlns:uap="http://schemas.microsoft.com/appx/manifest/uap/windows10"
  xmlns:uap5="http://schemas.microsoft.com/appx/manifest/uap/windows10/5"
  IgnorableNamespaces="uap uap5 mp">

  <Identity Name="wherewhere.VueForUWP"
    Publisher="CN=where"
    Version="0.0.1.0" />

  <mp:PhoneIdentity PhoneProductId="2d5eb3c5-2697-7f48-4085-ba24fba35ad1"
    PhonePublisherId="00000000-0000-0000-0000-000000000000" />

  <Properties>
    <DisplayName>VueForUWPDisplayName>
    <PublisherDisplayName>wherewherePublisherDisplayName>
    <Logo>assets\icon.pngLogo>
  Properties>

  <Dependencies>
    <TargetDeviceFamily Name="Windows.Universal" MinVersion="10.0.18362.0"
      MaxVersionTested="10.0.26100.0" />
  Dependencies>

  <Resources>
    <Resource Language="en-us" />
  Resources>

  <Applications>
    <Application Id="VueForUWP" StartPage="ms-appx-web:///app/index.html">
      <uap:VisualElements
        DisplayName="VueForUWP"
        Description="UWP running with vue.js 3.0"
        BackgroundColor="transparent"
        Square150x150Logo="assets\Square150x150Logo.png"
        Square44x44Logo="assets\Square44x44Logo.png">
        <uap:DefaultTile
          Wide310x150Logo="assets\Wide310x150Logo.scale-200.png">
          <uap:ShowNameOnTiles>
            <uap:ShowOn Tile="square150x150Logo" />
          uap:ShowNameOnTiles>
        uap:DefaultTile>
        <uap:SplashScreen Image="assets\SplashScreen.scale-200.png" uap5:Optional="true" />
        <uap:InitialRotationPreference>
          <uap:Rotation Preference="landscape" />
          <uap:Rotation Preference="portrait" />
          <uap:Rotation Preference="landscapeFlipped" />
          <uap:Rotation Preference="portraitFlipped" />
        uap:InitialRotationPreference>
      uap:VisualElements>
      <uap:ApplicationContentUriRules>
        <uap:Rule Match="ms-appx-web:///" Type="include" WindowsRuntimeAccess="all" />
      uap:ApplicationContentUriRules>
    Application>
  Applications>

  <Capabilities>
    <Capability Name="internetClient" />
  Capabilities>
Package>

然后编写部署脚本，可以参考 deploy.mjs：

import { powershell } from "electron-windows-msix/lib/powershell.js";

const results = await powershell("Add-AppxPackage -Path appx/msix_layout/AppxManifest.xml -Register");
console.log(results);

最后在 package.json 中添加打包和部署指令：

{
  ...
  "scripts": {
    ...
    "pack": "npm run build && node package.mjs",
    "deploy": "node deploy.mjs"
  },
  ...
}

现在我们可以通过执行 npm run pack 打包项目，用 npm run deploy 部署项目了。

由于 MSAppHost 永远留在了 Edge HTML 18，所以新的 Vue 样式库基本上都无法使用，为了符合 Windows 样式，还是建议使用 WinJS 控件库，可以在这里找到示例：https://github.com/wherewhere/VueForUWP

【UWP】使用 Vue/Vite 编写 WinJS/UWP 作者 @where-where 2026年3月21日发表于博客园，转载请注明出处

【UWP】让 UWP 自己和自己通信

2025-04-01T06:04:00.000Z

众所周知，UWP 一般是运行在沙盒里面的，当我们需要访问沙盒外资源的时候，就需要通过沙盒外的代理服务器来获取。一般情况下我们都是利用 WinRT API 通过 Runtime Broker 来和沙盒外互通，遇到要自定义的情况则是手动开一个 Win32 服务器来互通，但是有没有可能我们可以直接拿 UWP 本体当服务器呢？

UWP 本体实际上就是一个普通的 Win32 EXE 程序，只是想要以 UWP 状态运行只能通过系统托管，但是如果我们不需要它以 UWP 状态执行的时候完全可以直接双击打开它，这时候它就是一个很普通的散装 Win32 程序了。

利用这个特性，我们可以制作一种假装双击打开的方法，只需要在发现是 Win32 状态下启动就去用 API 唤起 UWP 形态的自己就行了

private static unsafe bool IsPackagedApp
{
    get
    {
        uint length = 0;
        PWSTR str = new();
        _ = PInvoke.GetCurrentPackageFullName(ref length, str);
 
        char* ptr = stackalloc char[(int)length];
        str = new(ptr);
        WIN32_ERROR result = PInvoke.GetCurrentPackageFullName(ref length, str);
        return result != WIN32_ERROR.APPMODEL_ERROR_NO_PACKAGE;
    }
}
 
private static void Main()
{
    if (IsPackagedApp)
    {
        Application.Start(static p =>
        {
            DispatcherQueueSynchronizationContext context = new(DispatcherQueue.GetForCurrentThread());
            SynchronizationContext.SetSynchronizationContext(context);
            _ = new App();
        });
    }
    else
    {
        StartCoreApplicationAsync().Wait();
    }
}
 
private static async Task StartCoreApplicationAsync()
{
    PackageManager manager = new();
    string basePath = AppDomain.CurrentDomain.BaseDirectory;
    XmlDocument manifest = await XmlDocument.LoadFromFileAsync(await StorageFile.GetFileFromPathAsync(Path.Combine(basePath, "AppxManifest.xml")));
    IXmlNode identity = manifest.GetElementsByTagName("Identity")?[0];
    string name = identity.Attributes.FirstOrDefault(x => x.NodeName == "Name")?.InnerText;
    IXmlNode application = manifest.GetElementsByTagName("Application")?[0];
    string id = application.Attributes.FirstOrDefault(x => x.NodeName == "Id")?.InnerText;
    IEnumerable packages = manager.FindPackagesForUser(string.Empty).Where(x => x.Id.FamilyName.StartsWith(name));
    if (packages.FirstOrDefault() is Package package)
    {
        IReadOnlyList entries = await package.GetAppListEntriesAsync();
        if (entries?[0] is AppListEntry entry)
        {
            _ = await entry.LaunchAsync();
        }
    }
}

既然我们可以让自己唤起自己，那么自己和自己通信也不是什么难事了，我们只需要在 UWP 形态下唤起一个 Win32 的自己，就可以自己利用自己滥权(bushi)了。

既然知道了原理可行，那么我们就来尝试把它造出来，众所周知，通信的方法有很多，比如 UWP 扩展通信、TCP 通信、管道通信甚至是写文件通信，但是这些用起来都太复杂了，既然我们已经用了 WinRT，那么我们直接用 WinRT 通信就是了。

不过真正的 OOP/WinRT 通信的例子并不多，我到目前为止也没有成功实现，所以就先用 COM 通信凑数了。现在微软到处都是 OOP/COM 通信，比如小组件和 Dev Home，自从微软疯狂用 OOP/COM 造插件之后这方面的示例已经非常多了，这里就展示一下如何用 C# 实现基于 OOP/COM 的 WinRT 通信。

既然是通信，肯定要有服务器和客户端，这里这两个都是自己，所以我们就只需要创建一个 UWP 项目就行了。由于 C#/WinRT 并不能实现 WinRT 类与非 WinRT 类混编，所以我们还需要创建一个 C++/WinRT 项目来生成 winmd 清单，这个 C++ 项目可以精简一下，只需要能编译 IDL 文件就行了，当然不修改也可以，只是看起来不太清爽罢了。

由于 C++/WinRT 项目只负责生成清单，如果直接引用该项目会报找不到 dll 实现，所以我们需要把 winmd 文件单独拿出来，在 vcxprj 中添加任务：

<Target Name="OutputWinMD" BeforeTargets="BuildCompile">
  <PropertyGroup>
    <PlatformName Condition="'$(Platform)' == 'Win32'">x86PlatformName>
    <PlatformName Condition="'$(Platform)' == 'ARM64EC'">ARM64PlatformName>
    <PlatformName Condition="'$(PlatformName)' == ''">$(Platform)PlatformName>
  PropertyGroup>
  <Copy SourceFiles="$(OutDir)\$(ProjectName).winmd" DestinationFolder="..\WinMD\$(PlatformName)\$(Configuration)\" />
  <Message Text="Copied output metadata file to '..\WinMD\$(PlatformName)\$(Configuration)\'." />
Target>

接下来我们就可以开始写 COM 类了，首先我们要实现一个负责服务器管理的类，这个类用来管理服务器的声明周期和远程类的获取方法。

其中我们需要先实现一种让服务器可以在客户端关闭后自动关闭的方法，让客户端通知是很不合理的，因为客户端可能会突然暴毙，这样就会导致服务器永远也不会释放了，所以我们必须让服务器去感知客户端不再需要服务器了。在 C++，我们可以通过观察引用计数的方法来知道远程类是否被客户端释放了，但是在 C#，远程类被客户端释放后并不会真的释放，我暂时不清楚其中的原因，表现出来就是解构方法并不会被执行，所以我们就无法通过类释放来关闭服务器了。于是我们还有一种方法，当通信断开后，我们执行远程方法就会报错，这样我们就知道通信已经断开了，于是我们可以让客户端给服务器发送一个保活委托，服务器每隔一段时间就去执行一次，这样通信断开后再执行委托就会直接报错了。当然我们还可以让这个保活委托变成一个永远也不会结束的异步，让 WinRT 自己去等待，这样服务器在通信断开的一瞬间知道通信结束了，不过由于我们并不需要瞬间就反应，有时候我们还需要考虑应用被关闭后马上就又打开的情况，所以我还是选择自己开个间隔比较长的定时器自己喂狗了。

实现很简单，开个定时器喂狗就行了：

/// 
/// Represents a monitor that checks if a remote object is alive.
/// 
public sealed partial class RemoteMonitor : IDisposable
{
    private bool disposed;
    private readonly Timer _timer;
    private readonly Action _dispose;

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The handler to check if the remote object is alive.
    /// The action to dispose the remote object.
    /// The period to check if the remote object is alive.
    public RemoteMonitor(IsAliveHandler handler, Action dispose, TimeSpan period)
    {
        _dispose = dispose;
        _timer = new(_ =>
        {
            bool isAlive = false;
            try
            {
                isAlive = handler.Invoke();
            }
            catch
            {
                isAlive = false;
            }
            finally
            {
                if (!isAlive)
                {
                    Dispose();
                }
            }
        }, null, TimeSpan.Zero, period);
    }

    /// 
    /// Finalizes the instance of the  class.
    /// 
    ~RemoteMonitor() => Dispose();

    /// 
    public void Dispose()
    {
        if (!disposed)
        {
            disposed = true;
            _timer.Dispose();
            _dispose?.Invoke();
            GC.SuppressFinalize(this);
        }
    }
}

同时在 IDL 定义 IsAliveHandler 委托：

1	delegate Boolean IsAliveHandler();

接下来我们就可以写服务器管理类了，我们只需要让它能正确释放服务器就行了，分别写 IDL 定义和 C# 实现：

interface ISetMonitor
{
    void SetMonitor(IsAliveHandler handler, Windows.Foundation.TimeSpan period);
}

interface IRemoteThing requires ISetMonitor, Windows.Foundation.IClosable, Windows.Foundation.IStringable
{
    // 其他远程操作
}

/// 
/// The manage class for remote object.
/// 
public sealed partial class RemoteThing : IRemoteThing
{
    private bool disposed;
    private RemoteMonitor _monitor;

    /// 
    /// Initializes a new instance of the  class.
    /// 
    public RemoteThing() => Program.RefCount++;

    /// 
    /// Finalizes the instance of the  class.
    /// 
    ~RemoteThing() => Dispose();

    /// 
    /// Sets the monitor to check if the remote object is alive.
    /// 
    /// The handler to check if the remote object is alive.
    /// The period to check if the remote object is alive.
    public void SetMonitor(IsAliveHandler handler, TimeSpan period) => _monitor = new RemoteMonitor(handler, Dispose, period);

    #region 其他远程操作

    #endregion

    /// 
    public void Dispose()
    {
        if (!disposed)
        {
            disposed = true;
            _monitor?.Dispose();
            GC.SuppressFinalize(this);
            if (--Program.RefCount == 0)
            {
                _ = Program.CheckComRefAsync();
            }
        }
    }

    /// 
    /// 随便写点什么作为测试。
    /// 
    public override string ToString() =>
        new StringBuilder()
            .AppendLine("Information")
            .AppendLine($"Framework: {RuntimeInformation.FrameworkDescription}")
            .AppendLine($"OSPlatform: {Environment.OSVersion}")
            .Append($"OSArchitecture: {RuntimeInformation.OSArchitecture}")
            .ToString();
}

有了服务器管理类，我们就可以把它注册到 COM 服务器了。想要注册 COM 类，我们需要一个 Factory 工厂类来让 COM 服务器可以在通信时初始化 COM 类。首先我们需要导入 COM 相关 API，定义 IClassFactory 接口，其中 Factory.CLSID_IRemoteThing 为远程类的 CLSID。

public static partial class Factory
{
    public static readonly Guid CLSID_IRemoteThing = new("01153FC5-2F29-4F60-93AD-EFFB97CC9E20");
    public static readonly Guid CLSID_IUnknown = new("00000000-0000-0000-C000-000000000046");

    [LibraryImport("api-ms-win-core-com-l1-1-0.dll")]
    internal static partial int CoRegisterClassObject(in Guid rclsid, IClassFactory pUnk, uint dwClsContext, int flags, out uint lpdwRegister);

    [LibraryImport("api-ms-win-core-com-l1-1-0.dll")]
    internal static partial int CoRevokeClassObject(uint dwRegister);
}

// https://docs.microsoft.com/windows/win32/api/unknwn/nn-unknwn-iclassfactory
[GeneratedComInterface]
[Guid("00000001-0000-0000-C000-000000000046")]
public partial interface IClassFactory
{
    void CreateInstance(nint pUnkOuter, in Guid riid, out nint ppvObject);

    void LockServer([MarshalAs(UnmanagedType.Bool)] bool fLock);
}

接下来我们可以制作一个抽象的工厂类，然后就可以直接继承这个工厂类来实现对应类的工厂类，不过由于 COM 源生成暂时不支持泛型，所以这个抽象的工厂类不能加 GeneratedComClass。

public abstract partial class Factory<T, TInterface> : IActivationFactory, IClassFactory where T : TInterface, new()
{
    private const int E_NOINTERFACE = unchecked((int)0x80004002);
    private const int CLASS_E_NOAGGREGATION = unchecked((int)0x80040110);

    private readonly Guid _iid = typeof(TInterface).GUID;

    public nint ActivateInstance() => MarshalInspectable.FromManaged(new T());

    public void CreateInstance(nint pUnkOuter, in Guid riid, out nint ppvObject)
    {
        ppvObject = 0;

        if (pUnkOuter != 0)
        {
            Marshal.ThrowExceptionForHR(CLASS_E_NOAGGREGATION);
        }

        if (riid == _iid || riid == Factory.CLSID_IUnknown)
        {
            // Create the instance of the .NET object
            ppvObject = MarshalInspectable.FromManaged(new T());
        }
        else
        {
            // The object that ppvObject points to does not support the
            // interface identified by riid.
            Marshal.ThrowExceptionForHR(E_NOINTERFACE);
        }
    }

    public void LockServer([MarshalAs(UnmanagedType.Bool)] bool fLock)
    {
    }

    public abstract void RegisterClassObject();
    public abstract void RevokeClassObject();
}

然后我们继承这个抽象的工厂类来实现我们需要的工厂类：

[GeneratedComClass]
public partial class RemoteThingFactory : Factory<RemoteThing, IRemoteThing>
{
    private uint cookie;

    public override void RegisterClassObject()
    {
        int hresult = Factory.CoRegisterClassObject(
            Factory.CLSID_IRemoteThing,
            this,
            (uint)CLSCTX.CLSCTX_LOCAL_SERVER,
            (int)REGCLS.REGCLS_MULTIPLEUSE,
            out cookie);
        if (hresult < 0)
        {
            Marshal.ThrowExceptionForHR(hresult);
        }
    }

    public override void RevokeClassObject()
    {
        int hresult = Factory.CoRevokeClassObject(cookie);
        if (hresult < 0)
        {
            Marshal.ThrowExceptionForHR(hresult);
        }
    }
}

然后我们就可以在程序入口点注册这个 COM 类了：

public static class Program
{
    private static ManualResetEventSlim comServerExitEvent;

    public static int RefCount { get; set; }

    private static void Main(string[] args)
    {
        if (args is ["-RegisterProcessAsComServer", ..])
        {
            comServerExitEvent = new ManualResetEventSlim(false);
            comServerExitEvent.Reset();
            RemoteThingFactory factory = new();
            factory.RegisterClassObject();
            _ = CheckComRefAsync();
            comServerExitEvent.Wait();
            factory.RevokeClassObject();
        }
        else
        {
            Application.Start(static p =>
            {
                DispatcherQueueSynchronizationContext context = new(DispatcherQueue.GetForCurrentThread());
                SynchronizationContext.SetSynchronizationContext(context);
                _ = new App();
            });
        }
    }

    public static async Task CheckComRefAsync()
    {
        await Task.Delay(100);
        if (RefCount == 0)
        {
            comServerExitEvent?.Set();
        }
    }
}

最后我们需要在清单声明 COM 服务器，其中SelfCOMServer.exe为服务器所在的可执行文件，Class ID 填远程类的CLSID。

<Applications>
  <Application>
    ...
    <Extensions>
      <com:Extension Category="windows.comServer">
        <com:ComServer>
          <com:ExeServer
            Executable="SelfCOMServer.exe"
            Arguments="-RegisterProcessAsComServer"
            DisplayName="COM Server"
            LaunchAndActivationPermission="O:SYG:SYD:(A;;11;;;WD)(A;;11;;;RC)(A;;11;;;AC)(A;;11;;;AN)S:P(ML;;NX;;;S-1-16-0)">
            <com:Class Id="01153FC5-2F29-4F60-93AD-EFFB97CC9E20" DisplayName="COM Server" />
          com:ExeServer>
        com:ComServer>
      com:Extension>
    Extensions>
  Application>
Applications>

现在我们已经完成了服务端的制作，接下来我们就可以让客户端调用服务器远程类了。

在 Factory 类继续添加获取远程类的相关内容：

public static partial class Factory
{
    private static bool IsAlive() => true;

    public static IRemoteThing CreateRemoteThing() =>
        CreateInstance(CLSID_IRemoteThing, CLSCTX.CLSCTX_ALL, TimeSpan.FromMinutes(1));

    internal static T CreateInstance<T>(Guid rclsid, CLSCTX dwClsContext = CLSCTX.CLSCTX_INPROC_SERVER)
    {
        int hresult = CoCreateInstance(rclsid, 0, (uint)dwClsContext, CLSID_IUnknown, out nint result);
        if (hresult < 0)
        {
            Marshal.ThrowExceptionForHR(hresult);
        }
        return Marshaler.FromAbi(result);
    }

    internal static T CreateInstance<T>(Guid rclsid, CLSCTX dwClsContext, TimeSpan period) where T : ISetMonitor
    {
        T results = CreateInstance(rclsid, dwClsContext);
        results.SetMonitor(IsAlive, period);
        return results;
    }

    [LibraryImport("api-ms-win-core-com-l1-1-0.dll")]
    private static partial int CoCreateInstance(in Guid rclsid, nint pUnkOuter, uint dwClsContext, in Guid riid, out nint ppv);
}

现在我们只需要执行 IRemoteThing remote = Factory.CreateRemoteThing(); 就能获取远程类了。

到这里我们已经完成了 OOP COM 的全部流程，我们想要实现什么内容就可以按照构建服务器管理类的方法来制作 COM 远程类，然后通过在服务器管理类添加一个构造方法来获取这个远程类，这样我们就不需要单独分配 CLSID 和注册 COM 类了。

比如我们可以给 Process 套个壳：

/// 
public partial class RemoteProcess(Process inner) : IProcess
{
    /// 
    public string ProcessName => inner.ProcessName;

    /// 
    public ITextReader StandardError => new RemoteTextReader(inner.StandardError);

    /// 
    public ITextWriter StandardInput => new RemoteTextWriter(inner.StandardInput);

    /// 
    public ITextReader StandardOutput => new RemoteTextReader(inner.StandardOutput);

    /// 
    public IProcessStartInfo StartInfo
    {
        get => new RemoteProcessStartInfo(inner.StartInfo);
        set => value.ToProcessStartInfo();
    }

    private readonly ConditionalWeakTable errorDataReceived = [];
    /// 
    public event CoDataReceivedEventHandler ErrorDataReceived
    {
        add
        {
            void wrapper(object sender, DataReceivedEventArgs e) => value(this, new CoDataReceivedEventArgs(e.Data));
            DataReceivedEventHandler handler = wrapper;
            inner.ErrorDataReceived += handler;
            errorDataReceived.Add(value, handler);
        }
        remove
        {
            if (errorDataReceived.TryGetValue(value, out DataReceivedEventHandler handler))
            {
                inner.ErrorDataReceived -= handler;
                errorDataReceived.Remove(value);
            }
        }
    }

    private readonly ConditionalWeakTable outputDataReceived = [];
    /// 
    public event CoDataReceivedEventHandler OutputDataReceived
    {
        add
        {
            void wrapper(object sender, DataReceivedEventArgs e) => value(this, new CoDataReceivedEventArgs(e.Data));
            DataReceivedEventHandler handler = wrapper;
            inner.OutputDataReceived += handler;
            outputDataReceived.Add(value, handler);
        }
        remove
        {
            if (outputDataReceived.TryGetValue(value, out DataReceivedEventHandler handler))
            {
                inner.OutputDataReceived -= handler;
                outputDataReceived.Remove(value);
            }
        }
    }

    /// 
    public void BeginErrorReadLine() => inner.BeginErrorReadLine();

    /// 
    public void BeginOutputReadLine() => inner.BeginOutputReadLine();

    /// 
    public void CancelErrorRead() => inner.CancelErrorRead();

    /// 
    public void CancelOutputRead() => inner.CancelOutputRead();

    /// 
    public void Dispose()
    {
        inner.Dispose();
        GC.SuppressFinalize(this);
    }

    /// 
    public override string ToString() => inner.ToString();
}

静态部分可以弄一个假装的静态类：

/// 
public sealed partial class ProcessStatic : IProcessStatic
{
    /// 
    public IProcess[] GetProcesses() => Process.GetProcesses().Select(x => new RemoteProcess(x)).ToArray();

    public IProcess Start(IProcessStartInfo startInfo) =>
        Process.Start(startInfo.ToProcessStartInfo()) is Process process
            ? new RemoteProcess(process) : null;
}

然后我们在服务器管理类里增加构造方法：

1	public IProcessStatic CreateProcessStatic() => new ProcessStatic();

这样我们就可以在 UWP 里使用 Process 创建一个 cmd 进程了：

IRemoteThing remote = Factory.CreateRemoteThing();
process = remote.CreateProcessStatic().Start(new RemoteProcessStartInfo
{
    FileName = "cmd",
    CreateNoWindow = true,
    RedirectStandardError = true,
    RedirectStandardInput = true,
    RedirectStandardOutput = true,
    UseShellExecute = false
});
AppTitle.Text = process.ProcessName;
process.OutputDataReceived += OnOutputDataReceived;
process.ErrorDataReceived += OnErrorDataReceived;
process.BeginOutputReadLine();
process.BeginErrorReadLine();

具体实现可以查看：SelfCOMServer/SelfCOMServer/Common/RemoteProcess.cs at main · wherewhere/SelfCOMServer

最后附上示例应用：https://github.com/wherewhere/SelfCOMServer

【UWP】让 UWP 自己和自己通信作者 @where-where 2025年4月1日发表于博客园，转载请注明出处

【UAP】使用 .NET Core App 编写 UAP

2025-03-13T10:44:00.000Z

众所周知，2024年9月微软正式宣布了 .NET Core App 的 UWP 支持，至此我们终于可以在新版 csproj 用 .NET 8 及以上编写 UWP 了，那么我们可不可以通过修改清单的方式来让 UWP 变成 UAP 呢？

UWP 和 UAP 使用的是同一套 WinRT API ，Windows 区分 UAP 和 UWP 的方式是看清单，只要是用 UAP 的清单就会仿真成 Win8.1 模式，于是我们只需要将清单变成 UAP 的样子就行了。所以首先我们新建一个 .NET 9 Native AOT 的 UWP 项目

然后我们修改清单，Win8 App 清单如下，内容按需填写，Win8.1 App 的清单可以通过在 Github 搜索 OSMaxVersionTested language:XML 找到，6.2 是 Win8，6.3 是 Win8.1 ( $targetentrypoint$ 需配合 ApplicationEntryPoint 使用)

"1.0" encoding="utf-8"?>

<Package xmlns="http://schemas.microsoft.com/appx/2010/manifest">

  <Identity
    Name="wherewhere.CoreAppUAP"
    Publisher="CN=where"
    Version="0.0.1.0" />

  <Properties>
    <DisplayName>CoreAppUAPDisplayName>
    <PublisherDisplayName>wherewherePublisherDisplayName>
    <Logo>Assets\StoreLogo.pngLogo>
  Properties>

  <Prerequisites>
    <OSMinVersion>6.2.0OSMinVersion>
    <OSMaxVersionTested>6.3.0OSMaxVersionTested>
  Prerequisites>

  <Resources>
    <Resource Language="x-generate"/>
  Resources>

  <Applications>
    <Application Id="App"
      Executable="$targetnametoken$.exe"
      EntryPoint="$targetentrypoint$">
      <VisualElements
        DisplayName="CoreAppUAP"
        Logo="Assets\MediumTile.png"
        SmallLogo="Assets\AppIcon.png"
        Description="CoreAppUAP"
        ForegroundText="light"
        BackgroundColor="transparent">
        <DefaultTile WideLogo="Assets\WideTile.png"/>
        <SplashScreen Image="Assets\SplashScreen.png"/>
        <InitialRotationPreference>
          <Rotation Preference="landscape"/>
          <Rotation Preference="portrait"/>
          <Rotation Preference="landscapeFlipped"/>
          <Rotation Preference="portraitFlipped"/>
        InitialRotationPreference>
        <LockScreen Notification="badgeAndTileText" BadgeLogo="Assets\BadgeLogo.png"/>
      VisualElements>
    Application>
  Applications>

  <Capabilities>
    <Capability Name="internetClient" />
  Capabilities>
Package>

然后我们在 csproj 中添加以下内容来取消引用 VC++ 和 TargetDeviceFamily

<PropertyGroup>
  <AddMicrosoftVCLibsSDKReference>FalseAddMicrosoftVCLibsSDKReference>
  <EnableAppxWindowsUniversalTargetDeviceFamilyItem>FalseEnableAppxWindowsUniversalTargetDeviceFamilyItem>
PropertyGroup>

不过删除了这些引用仍然会在清单生成 Dependencies 标签，如果 Dependencies 是空的注册时会报错，所以我们需要添加任务来删除清单中的 Dependencies 元素

<UsingTask
  TaskName="RemoveDependencies"
  TaskFactory="CodeTaskFactory"
  AssemblyFile="$(MSBuildToolsPath)\Microsoft.Build.Tasks.Core.dll">
  <ParameterGroup>
    <AppxManifestPath ParameterType="System.String" Required="true" />
  ParameterGroup>
  <Task>
    <Reference Include="System.Xml" />
    <Reference Include="System.Xml.Linq" />
    <Using Namespace="System.Linq" />
    <Using Namespace="System.Xml.Linq" />
    <Code Type="Fragment" Language="cs">
      
          try
          {
              var xdoc = XDocument.Load(AppxManifestPath);
              var ns = xdoc.Root.Name.Namespace;
              var dependencies = xdoc.Root.Descendants(ns + "Dependencies");
              if (dependencies != null)
              {
                  foreach (var node in dependencies.ToArray())
                  {
                      if (!node.HasElements)
                      {
                          node.Remove();
                      }
                  }
              }
              xdoc.Save(AppxManifestPath);
          }
          catch
          {
              Log.LogError("Failed to load Appx Manifest.");
              _Success = false;
          }
      ]]>
    Code>
  Task>
UsingTask>

<Target
  Name="RemoveDependencies"
  AfterTargets="AfterGenerateAppxManifest">
  <Message Importance="high" Text="RemoveDependencies" />
  <RemoveDependencies AppxManifestPath="%(FinalAppxManifest.Identity)" />
Target>

由于 XAML 编译器编译 App.xaml 时生成的入口点会使用 DispatcherQueueSynchronizationContext 来注册线程上下文，这是 16299 才加入的 API，UAP 在获取 DispatcherQueue 时会返回 null，所以我们需要手动生成入口点和注册线程上下文

首先我们需要添加 DISABLE_XAML_GENERATED_MAIN 来注释自动生成的入口点

1	<DefineConstants>$(DefineConstants);DISABLE_XAML_GENERATED_MAINDefineConstants>

然后手动编写程序入口点

public static class Program
{
    public static void Main(string[] args) => Application.Start(static p => _ = new App());
}

接着我们需要手动创建一个使用 CoreDispatcher 的线程上下文

/// 
/// Provides a synchronization context for .
/// 
/// The  to associate this  with.
public sealed class CoreDispatcherSynchronizationContext(CoreDispatcher dispatcher) : SynchronizationContext
{
    /// 
    public override void Post(SendOrPostCallback d, object? state)
    {
        ArgumentNullException.ThrowIfNull(d);
        _ = dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => d.Invoke(state));
    }

    /// 
    public override SynchronizationContext CreateCopy() => new CoreDispatcherSynchronizationContext(dispatcher);

    /// 
    public override void Send(SendOrPostCallback d, object? state) => throw new NotSupportedException("'SynchronizationContext.Send' is not supported.");
}

并在合适的时间注册线程上下文，比如 OnWindowCreated

protected override void OnWindowCreated(WindowCreatedEventArgs e)
{
    if (SynchronizationContext.Current == null)
    {
        CoreDispatcherSynchronizationContext context = new(e.Window.Dispatcher);
        SynchronizationContext.SetSynchronizationContext(context);
    }
    base.OnWindowCreated(e);
}

然后就可以点运行运行了

经测试，热重载等调试功能正常，UAP 可以调用一些与 UI 无关的新 WinRT API，甚至可以扩展标题栏，不过打包后无法成功在 Win8.1 安装，原因未知

最后附上示例应用：https://github.com/wherewhere/CoreAppUAP

【UAP】使用 .NET Core App 编写 UAP 作者 @where-where 2025年3月13日发表于博客园，转载请注明出处

【UWP】让 UWP 自己托管自己 —— Windows SDK 篇

2025-01-17T08:06:00.000Z

众所周知，UWP 使用的窗口模型是 CoreWindow，但是 UWP 本身只是一个应用模型，所以完全可以创建 win32 窗口，那么我们可以不可以创建一个 win32 窗口，然后像 XAML 岛 (XAML Islands) 一样把 XAML 托管上去呢？本篇将讲述如何在 UWP 创建一个 XAML 岛窗口。

首先，XAML 岛会判断当前的应用模型是否为ClassicDesktop，所以我们需要利用Detours劫持AppPolicyGetWindowingModel方法。具体内容如下：

#r "nuget:Detours.Win32Metadata"
#r "nuget:Microsoft.Windows.CsWin32"

using System;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using Windows.Win32;
using Windows.Win32.Foundation;
using Windows.Win32.Storage.Packaging.Appx;
using Detours = Microsoft.Detours.PInvoke;

/// 
/// Represents a hook for the  function.
/// 
public sealed partial class HookWindowingModel : IDisposable
{
    /// 
    /// The value that indicates whether the class has been disposed.
    /// 
    private bool disposed;

    /// 
    /// The reference count for the hook.
    /// 
    private static int refCount;

    /// 
    /// The value that represents the current process token.
    /// 
    private const int currentProcessToken = -6;

    /// The original  function.
    /// 
    private static unsafe delegate* unmanaged[Stdcall] AppPolicyGetWindowingModel;

    /// 
    /// Initializes a new instance of the  class.
    /// 
    public HookWindowingModel()
    {
        refCount++;
        StartHook();
    }

    /// 
    /// Finalizes this instance of the  class.
    /// 
    ~HookWindowingModel()
    {
        Dispose();
    }

    /// 
    /// Gets the value that indicates whether the hook is active.
    /// 
    public static bool IsHooked { get; private set; }

    /// 
    /// Gets or sets the windowing model to use when the hooked  function is called.
    /// 
    internal static AppPolicyWindowingModel WindowingModel { get; set; } = AppPolicyWindowingModel.AppPolicyWindowingModel_ClassicDesktop;

    /// 
    /// Starts the hook for the  function.
    /// 
    private static unsafe void StartHook()
    {
        if (!IsHooked)
        {
            using FreeLibrarySafeHandle library = PInvoke.GetModuleHandle("KERNEL32.dll");
            if (!library.IsInvalid && NativeLibrary.TryGetExport(library.DangerousGetHandle(), nameof(PInvoke.AppPolicyGetWindowingModel), out nint appPolicyGetWindowingModel))
            {
                void* appPolicyGetWindowingModelPtr = (void*)appPolicyGetWindowingModel;
                delegate* unmanaged[Stdcall] overrideAppPolicyGetWindowingModel = &OverrideAppPolicyGetWindowingModel;

                _ = Detours.DetourRestoreAfterWith();

                _ = Detours.DetourTransactionBegin();
                _ = Detours.DetourUpdateThread(PInvoke.GetCurrentThread());
                _ = Detours.DetourAttach(ref appPolicyGetWindowingModelPtr, overrideAppPolicyGetWindowingModel);
                _ = Detours.DetourTransactionCommit();

                AppPolicyGetWindowingModel = (delegate* unmanaged[Stdcall])appPolicyGetWindowingModelPtr;
                IsHooked = true;
            }
        }
    }

    /// 
    /// Ends the hook for the  function.
    /// 
    private static unsafe void EndHook()
    {
        if (--refCount == 0 && IsHooked)
        {
            void* appPolicyGetWindowingModelPtr = AppPolicyGetWindowingModel;
            delegate* unmanaged[Stdcall] overrideAppPolicyGetWindowingModel = &OverrideAppPolicyGetWindowingModel;

            _ = Detours.DetourTransactionBegin();
            _ = Detours.DetourUpdateThread(PInvoke.GetCurrentThread());
            _ = Detours.DetourDetach(&appPolicyGetWindowingModelPtr, overrideAppPolicyGetWindowingModel);
            _ = Detours.DetourTransactionCommit();

            AppPolicyGetWindowingModel = null;
            IsHooked = false;
        }
    }

    /// A pointer to a variable of the AppPolicyWindowingModel enumerated type.
    /// When the function returns successfully, the variable contains the  when the identified process is current; otherwise, the windowing model of the identified process.
    /// The overridden  function.
    /// 
    [UnmanagedCallersOnly(CallConvs = [typeof(CallConvStdcall)])]
    private static unsafe WIN32_ERROR OverrideAppPolicyGetWindowingModel(HANDLE processToken, AppPolicyWindowingModel* policy)
    {
        if ((int)processToken.Value == currentProcessToken)
        {
            *policy = WindowingModel;
            return WIN32_ERROR.ERROR_SUCCESS;
        }
        return AppPolicyGetWindowingModel(processToken, policy);
    }

    /// 
    public void Dispose()
    {
        if (!disposed && IsHooked)
        {
            EndHook();
        }
        GC.SuppressFinalize(this);
        disposed = true;
    }
}

准备工作完成，接下来我们就可以创建窗口了，首先我们需要新创建一个线程，CoreWindow 线程无法新建 XAML 岛，新建线程只需要用Thread就行了。

1	new Thread(() => { ... });

首先我们需要创建 XAML 岛，这时我们就需要利用上面劫持器来劫持获取应用模型的方法了。

DesktopWindowXamlSource source;
using (HookWindowingModel hook = new())
{
    source = new DesktopWindowXamlSource();
}

微软并没有单独提供一个 Win32 窗口管理的轮子，如果引用 Windows Forms 就太臃肿了，于是我们需要手动制作一个 Window 类：

由于 C#/Win32 不支持源生成 COM 以支持 AOT，所以我们需要手写IDesktopWindowXamlSourceNative定义：

namespace Windows.Win32.System.WinRT.Xaml
{
    [GeneratedComInterface]
    [Guid("3CBCF1BF-2F76-4E9C-96AB-E84B37972554")]
    internal partial interface IDesktopWindowXamlSourceNative
    {
        /// 
        /// Attaches the current **IDesktopWindowXamlSourceNative** instance to a parent UI element in your desktop app that is associated with a window handle.
        /// 
        /// 
        /// Type: **HWND** The window handle of the parent UI element in which you want to host a WinRT XAML control.
        /// Read more on docs.microsoft.com.
        /// 
        /// If this method succeeds, it returns S_OK. Otherwise, it returns an **HRESULT** error code.
        /// 
        /// For a code example that demonstrates how to use this method, see [XamlBridge.cpp](https://github.com/microsoft/Xaml-Islands-Samples/blob/master/Samples/Win32/SampleCppApp/XamlBridge.cpp) in the SampleCppApp sample in the XAML Island samples repo. > [!IMPORTANT] > Make sure that your code calls the **AttachToWindow** method only once per [DesktopWindowXamlSource](/uwp/api/windows.ui.xaml.hosting.desktopwindowxamlsource) object. Calling this method more than once for a **DesktopWindowXamlSource** object could result in a memory leak.
        /// Read more on docs.microsoft.com.
        /// 
        [PreserveSig]
        [return: MarshalAs(UnmanagedType.Error)]
        int AttachToWindow(nint parentWnd);

        /// 
        /// Gets the window handle of the parent UI element that is associated with the current IDesktopWindowXamlSourceNative instance.
        /// 
        /// If this method succeeds, it returns S_OK. Otherwise, it returns an **HRESULT** error code.
        [PreserveSig]
        [return: MarshalAs(UnmanagedType.Error)]
        int get_WindowHandle(out nint hWnd);
    }

    file static class Extensions
    {
        /// 
        /// Gets the window handle of the parent UI element that is associated with the current IDesktopWindowXamlSourceNative instance.
        /// 
        public static HWND WindowHandle(this IDesktopWindowXamlSourceNative source)
        {
            _ = source.get_WindowHandle(out nint hWnd);
            return new HWND(hWnd);
        }
    }
}

然后就可以制作 Window 类了：

/// 
/// Represents a system-managed container for the content of an app.
/// 
public partial class DesktopWindow
{
    private bool m_bIsClosed = false;
    private DesktopWindowXamlSource m_source;
    private IDesktopWindowXamlSourceNative m_native;

    private readonly HWND m_hwnd;
    private readonly WNDCLASSEXW m_wndClassEx;

    /// 
    /// Initializes a new instance of the  class.
    /// 
    public DesktopWindow()
    {
        m_wndClassEx = RegisterDesktopWindowClass(WNDPROC);
        m_hwnd = CreateDesktopWindow();
    }

    /// 
    /// Gets the event dispatcher for the window.
    /// 
    public CoreDispatcher Dispatcher { get; private set; }

    /// 
    /// Gets the  to provide XAML for this window.
    /// 
    public DesktopWindowXamlSource WindowXamlSource
    {
        get => m_source;
        private init
        {
            if (m_source != value)
            {
                m_source = value;
                if (value != null)
                {
                    Dispatcher = CoreWindow.GetForCurrentThread().Dispatcher;
                    m_native = value.As();
                    m_native.AttachToWindow(m_hwnd);
                    ResizeWindowToDesktopWindowXamlSourceWindowDimensions();
                }
                else
                {
                    m_native = null;
                }
            }
        }
    }

    /// 
    /// Shows the window and activates it.
    /// 
    public void Show() => _ = PInvoke.ShowWindow(m_hwnd, SHOW_WINDOW_CMD.SW_NORMAL);

    private LRESULT WNDPROC(HWND hWnd, uint message, WPARAM wParam, LPARAM lParam)
    {
        switch (message)
        {
            case PInvoke.WM_PAINT:
                HDC hdc = PInvoke.BeginPaint(hWnd, out PAINTSTRUCT ps);
                _ = PInvoke.GetClientRect(hWnd, out RECT rect);
                _ = PInvoke.FillRect(hdc, rect, new DefaultSafeHandle(PInvoke.GetStockObject(GET_STOCK_OBJECT_FLAGS.WHITE_BRUSH)));
                _ = PInvoke.EndPaint(hWnd, ps);
                return new LRESULT();
            case PInvoke.WM_CLOSE when m_bIsClosed:
                goto default;
            case PInvoke.WM_CLOSE:
                m_bIsClosed = true;
                goto default;
            case PInvoke.WM_SIZE:
                ResizeWindowToDesktopWindowXamlSourceWindowDimensions();
                return new LRESULT();
            case PInvoke.WM_CREATE:
                return new LRESULT();
            case PInvoke.WM_DESTROY:
                PInvoke.PostQuitMessage(0);
                return new LRESULT();
            default:
                return PInvoke.DefWindowProc(hWnd, message, wParam, lParam);
        }
    }

    private void ResizeWindowToDesktopWindowXamlSourceWindowDimensions()
    {
        if (m_bIsClosed) return;
        _ = PInvoke.GetClientRect(m_hwnd, out RECT rect);
        _ = PInvoke.SetWindowPos(
            m_native.WindowHandle(),
            new HWND(),
            0, 0,
            rect.Width, rect.Height,
            SET_WINDOW_POS_FLAGS.SWP_NOACTIVATE | SET_WINDOW_POS_FLAGS.SWP_NOZORDER | SET_WINDOW_POS_FLAGS.SWP_SHOWWINDOW);
    }
}

public partial class DesktopWindow
{
    private static readonly unsafe HINSTANCE g_hInstance = new((void*)Process.GetCurrentProcess().Handle);

    // win32 window class name for top-level WinUI desktop windows
    private const string s_windowClassName = "WinUIDesktopWin32WindowClass";

    // Default window title for top-level WinUI desktop windows
    private const string s_defaultWindowTitle = "WinUI Desktop";

    private static unsafe WNDCLASSEXW RegisterDesktopWindowClass(WNDPROC lpfnWndProc)
    {
        if (!PInvoke.GetClassInfoEx(new DefaultSafeHandle(g_hInstance), s_windowClassName, out WNDCLASSEXW wndClassEx))
        {
            wndClassEx.cbSize = (uint)Marshal.SizeOf(wndClassEx);
            wndClassEx.style = WNDCLASS_STYLES.CS_HREDRAW | WNDCLASS_STYLES.CS_VREDRAW;
            wndClassEx.cbClsExtra = 0;
            wndClassEx.cbWndExtra = 0;
            wndClassEx.hCursor = PInvoke.LoadCursor(new HINSTANCE(), PInvoke.IDC_ARROW);
            wndClassEx.hbrBackground = (HBRUSH)((nint)SYS_COLOR_INDEX.COLOR_WINDOW + 1);
            wndClassEx.hInstance = g_hInstance;

            fixed (char* lps_windowClassName = s_windowClassName)
            {
                wndClassEx.lpszClassName = lps_windowClassName;
            }

            wndClassEx.lpfnWndProc = lpfnWndProc;
            _ = PInvoke.RegisterClassEx(wndClassEx);

            return wndClassEx;
        }
        return default;
    }

    private static unsafe HWND CreateDesktopWindow() =>
        PInvoke.CreateWindowEx(
            0,                                  // Extended Style
            s_windowClassName,                  // name of window class
            s_defaultWindowTitle,               // title-bar string
            WINDOW_STYLE.WS_OVERLAPPEDWINDOW | WINDOW_STYLE.WS_VISIBLE,  // top-level window
            int.MinValue,                       // default horizontal position
            (int)SHOW_WINDOW_CMD.SW_HIDE,       // If the y parameter is some other value,
                                                // then the window manager calls ShowWindow with that value as the nCmdShow parameter
            int.MinValue,                       // default width
            int.MinValue,                       // default height
            new HWND(),                         // no owner window
            null,                               // use class menu
            new DefaultSafeHandle(g_hInstance),
            null);

    private partial class DefaultSafeHandle(nint invalidHandleValue, bool ownsHandle) : SafeHandle(invalidHandleValue, ownsHandle)
    {
        public DefaultSafeHandle(nint handle) : this(handle, true) => SetHandle(handle);

        public override bool IsInvalid => handle != nint.Zero;

        protected override bool ReleaseHandle() => true;
    }
}

然后我们就可以初始化一个窗口了。

1	DesktopWindow window = new() { WindowXamlSource = source };

最后不要忘了用消息循环保持当前线程，不然这里跑完了窗口就退出了。

MSG msg = new();
while (msg.message != PInvoke.WM_QUIT)
{
    if (PInvoke.PeekMessage(out msg, new HWND(), 0, 0, PEEK_MESSAGE_REMOVE_TYPE.PM_REMOVE))
    {
        _ = PInvoke.DispatchMessage(msg);
    }
}

最后把之前的东西组合起来，再加点东西：

/// 
/// Represents a system-managed container for the content of an app.
/// 
public partial class DesktopWindow
{
    private bool m_bIsClosed = false;
    private DesktopWindowXamlSource m_source;
    private IDesktopWindowXamlSourceNative m_native;

    private readonly HWND m_hwnd;
    private readonly WNDCLASSEXW m_wndClassEx;

    /// 
    /// Initializes a new instance of the  class.
    /// 
    public DesktopWindow()
    {
        m_wndClassEx = RegisterDesktopWindowClass(WNDPROC);
        m_hwnd = CreateDesktopWindow();
    }

    /// 
    /// Get the handle of the window.
    /// 
    public nint Hwnd => m_hwnd;

    /// 
    /// Gets the event dispatcher for the window.
    /// 
    public CoreDispatcher Dispatcher { get; private set; }

    /// 
    /// Gets or sets the visual root of an application window.
    /// 
    public UIElement Content
    {
        get => WindowXamlSource.Content;
        set => WindowXamlSource.Content = value;
    }

    /// 
    /// Gets or sets the XamlRoot in which this element is being viewed.
    /// 
    [SupportedOSPlatform("Windows10.0.18362.0")]
    public XamlRoot XamlRoot
    {
        get => WindowXamlSource.Content.XamlRoot;
        set => WindowXamlSource.Content.XamlRoot = value;
    }

    /// 
    /// Gets or sets a string used for the window title.
    /// 
    public unsafe string Title
    {
        get
        {
            int windowTextLength = PInvoke.GetWindowTextLength(m_hwnd);
            char* windowText = stackalloc char[windowTextLength + 1];
            _ = PInvoke.GetWindowText(m_hwnd, windowText, windowTextLength + 1);
            return new string(windowText);
        }
        set => _ = PInvoke.SetWindowText(m_hwnd, value);
    }

    /// 
    /// Gets the  to provide XAML for this window.
    /// 
    public DesktopWindowXamlSource WindowXamlSource
    {
        get => m_source;
        private init
        {
            if (m_source != value)
            {
                m_source = value;
                if (value != null)
                {
                    Dispatcher = CoreWindow.GetForCurrentThread().Dispatcher;
                    m_native = value.As();
                    m_native.AttachToWindow(m_hwnd);
                    ResizeWindowToDesktopWindowXamlSourceWindowDimensions();
                }
                else
                {
                    m_native = null;
                }
            }
        }
    }

    /// 
    /// Occurs when the window has closed.
    /// 
    public event TypedEventHandlerobject> Closed;

    /// 
    /// Shows the window and activates it.
    /// 
    public void Show() => _ = PInvoke.ShowWindow(m_hwnd, SHOW_WINDOW_CMD.SW_NORMAL);

    /// 
    /// Sets the icon for the window, using the specified icon path.
    /// 
    /// The path of the icon.
    public unsafe void SetIcon(string iconPath)
    {
        fixed (char* ptr = iconPath)
        {
            HANDLE icon = PInvoke.LoadImage(new HINSTANCE(), ptr, GDI_IMAGE_TYPE.IMAGE_ICON, 0, 0, IMAGE_FLAGS.LR_LOADFROMFILE);
            _ = PInvoke.SendMessage(m_hwnd, PInvoke.WM_SETICON, PInvoke.ICON_BIG, new LPARAM((nint)icon.Value));
        }
    }

    private LRESULT WNDPROC(HWND hWnd, uint message, WPARAM wParam, LPARAM lParam)
    {
        switch (message)
        {
            case PInvoke.WM_PAINT:
                HDC hdc = PInvoke.BeginPaint(hWnd, out PAINTSTRUCT ps);
                _ = PInvoke.GetClientRect(hWnd, out RECT rect);
                _ = PInvoke.FillRect(hdc, rect, new DefaultSafeHandle(PInvoke.GetStockObject(GET_STOCK_OBJECT_FLAGS.WHITE_BRUSH)));
                _ = PInvoke.EndPaint(hWnd, ps);
                return new LRESULT();
            case PInvoke.WM_CLOSE when m_bIsClosed:
                goto default;
            case PInvoke.WM_CLOSE:
                m_bIsClosed = true;
                Closed?.Invoke(this, null);
                goto default;
            case PInvoke.WM_SIZE:
                ResizeWindowToDesktopWindowXamlSourceWindowDimensions();
                return new LRESULT();
            case PInvoke.WM_CREATE:
                return new LRESULT();
            case PInvoke.WM_DESTROY:
                PInvoke.PostQuitMessage(0);
                return new LRESULT();
            default:
                return PInvoke.DefWindowProc(hWnd, message, wParam, lParam);
        }
    }

    private void ResizeWindowToDesktopWindowXamlSourceWindowDimensions()
    {
        if (m_bIsClosed) return;
        _ = PInvoke.GetClientRect(m_hwnd, out RECT rect);
        _ = PInvoke.SetWindowPos(
            m_native.WindowHandle(),
            new HWND(),
            0, 0,
            rect.Width, rect.Height,
            SET_WINDOW_POS_FLAGS.SWP_NOACTIVATE | SET_WINDOW_POS_FLAGS.SWP_NOZORDER | SET_WINDOW_POS_FLAGS.SWP_SHOWWINDOW);
    }
}

public partial class DesktopWindow
{
    private static readonly unsafe HINSTANCE g_hInstance = new((void*)Process.GetCurrentProcess().Handle);

    // win32 window class name for top-level WinUI desktop windows
    private const string s_windowClassName = "WinUIDesktopWin32WindowClass";

    // Default window title for top-level WinUI desktop windows
    private const string s_defaultWindowTitle = "WinUI Desktop";

    private static unsafe WNDCLASSEXW RegisterDesktopWindowClass(WNDPROC lpfnWndProc)
    {
        if (!PInvoke.GetClassInfoEx(new DefaultSafeHandle(g_hInstance), s_windowClassName, out WNDCLASSEXW wndClassEx))
        {
            wndClassEx.cbSize = (uint)Marshal.SizeOf(wndClassEx);
            wndClassEx.style = WNDCLASS_STYLES.CS_HREDRAW | WNDCLASS_STYLES.CS_VREDRAW;
            wndClassEx.cbClsExtra = 0;
            wndClassEx.cbWndExtra = 0;
            wndClassEx.hCursor = PInvoke.LoadCursor(new HINSTANCE(), PInvoke.IDC_ARROW);
            wndClassEx.hbrBackground = (HBRUSH)((nint)SYS_COLOR_INDEX.COLOR_WINDOW + 1);
            wndClassEx.hInstance = g_hInstance;

            fixed (char* lps_windowClassName = s_windowClassName)
            {
                wndClassEx.lpszClassName = lps_windowClassName;
            }

            wndClassEx.lpfnWndProc = lpfnWndProc;
            _ = PInvoke.RegisterClassEx(wndClassEx);

            return wndClassEx;
        }
        return default;
    }

    private static unsafe HWND CreateDesktopWindow() =>
        PInvoke.CreateWindowEx(
            0,                                  // Extended Style
            s_windowClassName,                  // name of window class
            s_defaultWindowTitle,               // title-bar string
            WINDOW_STYLE.WS_OVERLAPPEDWINDOW | WINDOW_STYLE.WS_VISIBLE,  // top-level window
            int.MinValue,                       // default horizontal position
            (int)SHOW_WINDOW_CMD.SW_HIDE,       // If the y parameter is some other value,
                                                // then the window manager calls ShowWindow with that value as the nCmdShow parameter
            int.MinValue,                       // default width
            int.MinValue,                       // default height
            new HWND(),                         // no owner window
            null,                               // use class menu
            new DefaultSafeHandle(g_hInstance),
            null);

    private partial class DefaultSafeHandle(nint invalidHandleValue, bool ownsHandle) : SafeHandle(invalidHandleValue, ownsHandle)
    {
        public DefaultSafeHandle(nint handle) : this(handle, true) => SetHandle(handle);

        public override bool IsInvalid => handle != nint.Zero;

        protected override bool ReleaseHandle() => true;
    }
}

public partial class DesktopWindow
{
    /// 
    /// Create a new  instance.
    /// 
    /// Do something after  created.
    /// The new instance of .
    public static Task CreateAsync(Action launched)
    {
        TaskCompletionSource taskCompletionSource = new();

        new Thread(() =>
        {
            try
            {
                DesktopWindowXamlSource source;
                using (HookWindowingModel hook = new())
                {
                    source = new DesktopWindowXamlSource();
                }

                DesktopWindow window = new() { WindowXamlSource = source };

                launched(source);
                taskCompletionSource.SetResult(window);

                MSG msg = new();
                while (msg.message != PInvoke.WM_QUIT)
                {
                    if (PInvoke.PeekMessage(out msg, new HWND(), 0, 0, PEEK_MESSAGE_REMOVE_TYPE.PM_REMOVE))
                    {
                        _ = PInvoke.DispatchMessage(msg);
                    }
                }
            }
            catch (Exception e)
            {
                taskCompletionSource.SetException(e);
            }
        })
        {
            Name = nameof(DesktopWindowXamlSource)
        }.Start();

        return taskCompletionSource.Task;
    }
}

namespace Windows.Win32.System.WinRT.Xaml
{
    [GeneratedComInterface]
    [Guid("3CBCF1BF-2F76-4E9C-96AB-E84B37972554")]
    internal partial interface IDesktopWindowXamlSourceNative
    {
        /// 
        /// Attaches the current **IDesktopWindowXamlSourceNative** instance to a parent UI element in your desktop app that is associated with a window handle.
        /// 
        /// 
        /// Type: **HWND** The window handle of the parent UI element in which you want to host a WinRT XAML control.
        /// Read more on docs.microsoft.com.
        /// 
        /// If this method succeeds, it returns S_OK. Otherwise, it returns an **HRESULT** error code.
        /// 
        /// For a code example that demonstrates how to use this method, see [XamlBridge.cpp](https://github.com/microsoft/Xaml-Islands-Samples/blob/master/Samples/Win32/SampleCppApp/XamlBridge.cpp) in the SampleCppApp sample in the XAML Island samples repo. > [!IMPORTANT] > Make sure that your code calls the **AttachToWindow** method only once per [DesktopWindowXamlSource](/uwp/api/windows.ui.xaml.hosting.desktopwindowxamlsource) object. Calling this method more than once for a **DesktopWindowXamlSource** object could result in a memory leak.
        /// Read more on docs.microsoft.com.
        /// 
        [PreserveSig]
        [return: MarshalAs(UnmanagedType.Error)]
        int AttachToWindow(nint parentWnd);

        /// 
        /// Gets the window handle of the parent UI element that is associated with the current IDesktopWindowXamlSourceNative instance.
        /// 
        /// If this method succeeds, it returns S_OK. Otherwise, it returns an **HRESULT** error code.
        [PreserveSig]
        [return: MarshalAs(UnmanagedType.Error)]
        int get_WindowHandle(out nint hWnd);
    }

    file static class Extensions
    {
        /// 
        /// Gets the window handle of the parent UI element that is associated with the current IDesktopWindowXamlSourceNative instance.
        /// 
        public static HWND WindowHandle(this IDesktopWindowXamlSourceNative source)
        {
            _ = source.get_WindowHandle(out nint hWnd);
            return new HWND(hWnd);
        }
    }
}

这样创建的窗口还存在一些问题，但是我不知道该怎么解决，所以该方法还是仅供参考。

最后附上示例应用：https://github.com/wherewhere/CoreAppUWP/tree/wuxc

MUXC 篇：【UWP】让 UWP 自己托管自己 —— Windows App SDK 篇

【UWP】让 UWP 自己托管自己 —— Windows SDK 篇作者 @where-where 2025年1月17日发表于博客园，转载请注明出处

【UWP】让 UWP 自己托管自己 —— Windows App SDK 篇

2024-11-03T08:10:00.000Z

众所周知，UWP 使用的窗口模型是 CoreWindow，但是 UWP 本身只是一个应用模型，所以完全可以创建 win32 窗口，那么我们可以不可以创建一个 win32 窗口，然后像 XAML 岛 (XAML Islands) 一样把 XAML 托管上去呢？本篇将讲述如何利用 WAS (Windows App SDK，俗称 WinUI3) 在 UWP 创建一个 XAML 岛窗口。

演示视频：https://x.com/wherewhere7/status/1721570411388039587

由于 WAS 在 win32 应用模型下本身就是个 XAML 岛，所以 WAS 对 XAML 岛的支持要比 WUXC (Windows.UI.Xaml.Controls) 要好多了，接下来的内容大多是将 WAS 中实现窗口的方法迁移到 C#。

首先，不管是 WUXC 还是 WAS 的 XAML 岛都会判断当前的应用模型是否为ClassicDesktop，所以我们需要利用Detours劫持AppPolicyGetWindowingModel方法。具体内容如下：

#r "nuget:Detours.Win32Metadata"
#r "nuget:Microsoft.Windows.CsWin32"

using System;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using Windows.Win32;
using Windows.Win32.Foundation;
using Windows.Win32.Storage.Packaging.Appx;
using Detours = Microsoft.Detours.PInvoke;

/// 
/// Represents a hook for the  function.
/// 
public sealed partial class HookWindowingModel : IDisposable
{
    /// 
    /// The value that indicates whether the class has been disposed.
    /// 
    private bool disposed;

    /// 
    /// The reference count for the hook.
    /// 
    private static int refCount;

    /// 
    /// The value that represents the current process token.
    /// 
    private const int currentProcessToken = -6;

    /// The original  function.
    /// 
    private static unsafe delegate* unmanaged[Stdcall] AppPolicyGetWindowingModel;

    /// 
    /// Initializes a new instance of the  class.
    /// 
    public HookWindowingModel()
    {
        refCount++;
        StartHook();
    }

    /// 
    /// Finalizes this instance of the  class.
    /// 
    ~HookWindowingModel()
    {
        Dispose();
    }

    /// 
    /// Gets the value that indicates whether the hook is active.
    /// 
    public static bool IsHooked { get; private set; }

    /// 
    /// Gets or sets the windowing model to use when the hooked  function is called.
    /// 
    internal static AppPolicyWindowingModel WindowingModel { get; set; } = AppPolicyWindowingModel.AppPolicyWindowingModel_ClassicDesktop;

    /// 
    /// Starts the hook for the  function.
    /// 
    private static unsafe void StartHook()
    {
        if (!IsHooked)
        {
            using FreeLibrarySafeHandle library = PInvoke.GetModuleHandle("KERNEL32.dll");
            if (!library.IsInvalid && NativeLibrary.TryGetExport(library.DangerousGetHandle(), nameof(PInvoke.AppPolicyGetWindowingModel), out nint appPolicyGetWindowingModel))
            {
                void* appPolicyGetWindowingModelPtr = (void*)appPolicyGetWindowingModel;
                delegate* unmanaged[Stdcall] overrideAppPolicyGetWindowingModel = &OverrideAppPolicyGetWindowingModel;

                _ = Detours.DetourRestoreAfterWith();

                _ = Detours.DetourTransactionBegin();
                _ = Detours.DetourUpdateThread(PInvoke.GetCurrentThread());
                _ = Detours.DetourAttach(ref appPolicyGetWindowingModelPtr, overrideAppPolicyGetWindowingModel);
                _ = Detours.DetourTransactionCommit();

                AppPolicyGetWindowingModel = (delegate* unmanaged[Stdcall])appPolicyGetWindowingModelPtr;
                IsHooked = true;
            }
        }
    }

    /// 
    /// Ends the hook for the  function.
    /// 
    private static unsafe void EndHook()
    {
        if (--refCount == 0 && IsHooked)
        {
            void* appPolicyGetWindowingModelPtr = AppPolicyGetWindowingModel;
            delegate* unmanaged[Stdcall] overrideAppPolicyGetWindowingModel = &OverrideAppPolicyGetWindowingModel;

            _ = Detours.DetourTransactionBegin();
            _ = Detours.DetourUpdateThread(PInvoke.GetCurrentThread());
            _ = Detours.DetourDetach(&appPolicyGetWindowingModelPtr, overrideAppPolicyGetWindowingModel);
            _ = Detours.DetourTransactionCommit();

            AppPolicyGetWindowingModel = null;
            IsHooked = false;
        }
    }

    /// A pointer to a variable of the AppPolicyWindowingModel enumerated type.
    /// When the function returns successfully, the variable contains the  when the identified process is current; otherwise, the windowing model of the identified process.
    /// The overridden  function.
    /// 
    [UnmanagedCallersOnly(CallConvs = [typeof(CallConvStdcall)])]
    private static unsafe WIN32_ERROR OverrideAppPolicyGetWindowingModel(HANDLE processToken, AppPolicyWindowingModel* policy)
    {
        if ((int)processToken.Value == currentProcessToken)
        {
            *policy = WindowingModel;
            return WIN32_ERROR.ERROR_SUCCESS;
        }
        return AppPolicyGetWindowingModel(processToken, policy);
    }

    /// 
    public void Dispose()
    {
        if (!disposed && IsHooked)
        {
            EndHook();
        }
        GC.SuppressFinalize(this);
        disposed = true;
    }
}

准备工作完成，接下来我们就可以创建窗口了，如果顺利的话我们只需要new Microsoft.UI.Xaml.Window()就行了，但是很遗憾，经过测试在 UWP 并不能正常初始化这个类，有可能是我使用的方法不太正确，或许以后可能能找到正常使用的办法，不过现在我们只能去手动创建一个 Win32 窗口了。

首先我们需要新创建一个线程，CoreWindow 线程无法新建 XAML 岛，不过在 XAML 岛线程可以，新建线程只需要用Thread就行了。

1	new Thread(() => { ... });

WAS 提供了AppWindow来管理 win32 窗口，我们只需要使用它创建一个窗口就行了。

1	AppWindow window = AppWindow.Create();

接下来我们需要创建 XAML 岛，这时我们就需要利用上面劫持器来劫持获取应用模型的方法了

DispatcherQueueController controller;
DesktopWindowXamlSource source;

using (HookWindowingModel hook = new())
{
    controller = DispatcherQueueController.CreateOnCurrentThread();
    source = new DesktopWindowXamlSource();
}

然后我们就可以把 XAML 岛糊到之前创建的 AppWindow 上了。

source.Initialize(window.Id);
DesktopChildSiteBridge bridge = source.SiteBridge;
bridge.ResizePolicy = ContentSizePolicy.ResizeContentToParentWindow;
bridge.Show();

DispatcherQueue dispatcherQueue = controller.DispatcherQueue;
window.AssociateWithDispatcherQueue(dispatcherQueue);

由于 XAML 岛存在的一些特性，当窗口扩展标题栏或者全屏化的时候窗口内容并不会跟着变化，所以我们需要一些小魔法来让它在变化时调整大小。

window.Changed += (sender, args) =>
{
    if (args.DidPresenterChange)
    {
        bridge.ResizePolicy = ContentSizePolicy.None;
        bridge.ResizePolicy = ContentSizePolicy.ResizeContentToParentWindow;
    }
};

最后不要忘了保持当前线程，不然这里跑完了窗口就退出了。

1 2	dispatcherQueue.RunEventLoop(); await controller.ShutdownQueueAsync();

当窗口关闭后记得执行DispatcherQueue.EnqueueEventLoopExit()来释放保持的线程。

最后把之前的东西组合起来，再加点东西：

/// 
/// Create a new  instance.
/// 
/// Do something after  created.
/// The new instance of .
public static Task CreateAsync(Action launched)
{
    TaskCompletionSource taskCompletionSource = new();

    new Thread(async () =>
    {
        try
        {
            DispatcherQueueController controller;
            DesktopWindowXamlSource source;
            AppWindow window = AppWindow.Create();

            using (HookWindowingModel hook = new())
            {
                controller = DispatcherQueueController.CreateOnCurrentThread();
                source = new DesktopWindowXamlSource();
            }

            source.Initialize(window.Id);
            DesktopChildSiteBridge bridge = source.SiteBridge;
            bridge.ResizePolicy = ContentSizePolicy.ResizeContentToParentWindow;
            bridge.Show();

            window.Changed += (sender, args) =>
            {
                if (args.DidPresenterChange)
                {
                    bridge.ResizePolicy = ContentSizePolicy.None;
                    bridge.ResizePolicy = ContentSizePolicy.ResizeContentToParentWindow;
                }
            };

            DispatcherQueue dispatcherQueue = controller.DispatcherQueue;
            window.AssociateWithDispatcherQueue(dispatcherQueue);
            TrackWindow(window);

            launched(source);
            DesktopWindow desktopWindow = new()
            {
                AppWindow = window,
                WindowXamlSource = source
            };
            taskCompletionSource.SetResult(desktopWindow);

            dispatcherQueue.RunEventLoop();
            await controller.ShutdownQueueAsync();
        }
        catch (Exception e)
        {
            taskCompletionSource.SetException(e);
        }
    })
    {
        Name = nameof(DesktopWindowXamlSource)
    }.Start();

    return taskCompletionSource.Task;
}

/// 
/// Create a new  instance.
/// 
/// The  to provide thread.
/// Do something after  created.
/// The new instance of .
public static Task CreateAsync(DispatcherQueue dispatcherQueue, Action launched)
{
    TaskCompletionSource taskCompletionSource = new();

    _ = dispatcherQueue.TryEnqueue(() =>
    {
        try
        {
            DesktopWindowXamlSource source;
            AppWindow window = AppWindow.Create();
            window.AssociateWithDispatcherQueue(dispatcherQueue);
            TrackWindow(window);

            using (HookWindowingModel hook = new())
            {
                source = new DesktopWindowXamlSource();
            }

            source.Initialize(window.Id);
            DesktopChildSiteBridge bridge = source.SiteBridge;
            bridge.ResizePolicy = ContentSizePolicy.ResizeContentToParentWindow;
            bridge.Show();

            window.Changed += (sender, args) =>
            {
                if (args.DidPresenterChange)
                {
                    bridge.ResizePolicy = ContentSizePolicy.None;
                    bridge.ResizePolicy = ContentSizePolicy.ResizeContentToParentWindow;
                }
            };

            launched(source);
            DesktopWindow desktopWindow = new()
            {
                AppWindow = window,
                WindowXamlSource = source
            };
            taskCompletionSource.SetResult(desktopWindow);
        }
        catch (Exception e)
        {
            taskCompletionSource.SetException(e);
        }
    });

    return taskCompletionSource.Task;
}

private static void TrackWindow(AppWindow window)
{
    if (ActiveDesktopWindows.ContainsKey(window.DispatcherQueue))
    {
        ActiveDesktopWindows[window.DispatcherQueue] += 1;
    }
    else
    {
        ActiveDesktopWindows[window.DispatcherQueue] = 1;
    }
    window.Destroying -= AppWindow_Destroying;
    window.Destroying += AppWindow_Destroying;
}

private static void AppWindow_Destroying(AppWindow sender, object args)
{
    if (ActiveDesktopWindows.TryGetValue(sender.DispatcherQueue, out ulong num))
    {
        num--;
        if (num == 0)
        {
            ActiveDesktopWindows.Remove(sender.DispatcherQueue);
            sender.DispatcherQueue.EnqueueEventLoopExit();
            return;
        }
        ActiveDesktopWindows[sender.DispatcherQueue] = num;
    }
}

private static Dictionaryulong> ActiveDesktopWindows { get; } = [];

其中DesktopWindow是用来存放AppWindow和DesktopWindowXamlSource的类，如果不嫌麻烦的话可以包裹成一个和Microsoft.UI.Xaml.Window一样的东西。

最后附上示例应用：https://github.com/wherewhere/CoreAppUWP/tree/muxc

WUXC 篇：【UWP】让 UWP 自己托管自己 —— Windows SDK 篇

【UWP】让 UWP 自己托管自己 —— Windows App SDK 篇作者 @where-where 2024年11月3日发表于博客园，转载请注明出处

【UWP】在 UWP 中使用 Windows App SDK

2024-10-18T07:49:00.000Z

众所周知，WAS (Windows App SDK，俗称 WinUI3)在刚开始是支持 UWP 的，甚至最早只支持 UWP，但是微软在正式版发布前删除了对 UWP 的支持，不过真的删除了吗？初生之鸟在2023年10月发现在 VS 调试下无视报错继续运行可以正常在 UWP 加载 WAS。随着 WAS 的开源，WAS 阻止在 UWP 上运行的原因也被找到，至此大家终于找到在 UWP 上使用 WAS 的方法了。

WAS 阻止在 UWP 上运行的方法很简单，就是检查注册表HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\WinUI\Xaml\EnableUWPWindow是否为00000001，如果不是就直接报错。

Window_Partial.cpp#L80-L114

【UWP】修改清单脱离沙盒运行

2024-05-03T08:37:00.000Z

众所周知，UWP 是运行在沙盒里面的，所有权限都有严格限制，和沙盒外交互也需要特殊的通道，所以从根本杜绝了 UWP 毒瘤的存在。但是实际上 UWP 只是一个应用模型，本身是没有什么权限管理的，权限管理全靠 App Container 沙盒控制，如果我们脱离了这个沙盒，UWP 就会放飞自我了。那么有没有这种可能呢？

我们打开设置应用，通过任务管理器查看进程，就会发现它并没有 Runtime Broker 存在，这个进程是用来在沙盒间代理的，这说明微软给 UWP 开了一个后门。

那么我们是不是也有办法脱离沙盒运行呢？Ahmed Walid 在 2023年2月发表了这样一个帖子：

同时他还提交了一个名为 Added a remark about uap10:TrustLevel 的 PR，在这个 PR 中明确提到了如何通过设置 Custom Capability 来修改 UWP 的 TrustLevel

Setting uap10:TrustLevel="mediumIL" while uap10:RuntimeBehavior="windowsApp" requires the Microsoft.coreAppActivation_8wekyb3d8bbwe Custom Capability.
This is also true if uap10:TrustLevel="mediumIL" and EntryPoint is any other value than "windows.fullTrustApplication" or "windows.partialTrustApplication".
You can read more about this custom capability here in Custom Capabilities.

如今这个 PR 已经合并，现在可以直接在微软文档《应用程序 (Windows 10)》中找到了

根据文档描述，我们需要添加一个名为 Microsoft.coreAppActivation_8wekyb3d8bbwe 的自定义权限，然后将 uap10:TrustLevel 设置为 mediumIL 即可

首先我们在清单中加入权限

"1.0" encoding="utf-8"?>
<Package
  ...
  xmlns:uap4="http://schemas.microsoft.com/appx/manifest/uap/windows10/4"
  xmlns:rescap="http://schemas.microsoft.com/appx/manifest/foundation/windows10/restrictedcapabilities"
  IgnorableNamespaces="... uap4 rescap">
  ...
  <Capabilities>
    ...
    
    <rescap:Capability Name="runFullTrust" />
    <uap4:CustomCapability Name="Microsoft.coreAppActivation_8wekyb3d8bbwe" />
  Capabilities>
Package>

Custom Capability 不同于其他权限，这是用来给 OEM 自定义使用的，需要 SCCD 文件来证明你有使用权限的资格，所以想上架是基本没可能了，相关内容可以查看教程 [UWP] Custom Capability的使用

我们在项目根目录新建一个名为 CustomCapability.SCCD 的文件，在其中写入

"1.0" encoding="utf-8"?>
<CustomCapabilityDescriptor xmlns="http://schemas.microsoft.com/appx/2018/sccd" xmlns:s="http://schemas.microsoft.com/appx/2018/sccd">
  <CustomCapabilities>
    <CustomCapability Name="Microsoft.coreAppActivation_8wekyb3d8bbwe">CustomCapability>
  CustomCapabilities>
  <AuthorizedEntities AllowAny="true"/>
  <Catalog>FFFFCatalog>
CustomCapabilityDescriptor>

然后将该文件设置为内容，或者选择复制到输出，只要最后能出现在安装包里面就行了

最后我们将 uap10:TrustLevel 设置为 mediumIL

"1.0" encoding="utf-8"?>
<Package
  ...
  xmlns:uap10="http://schemas.microsoft.com/appx/manifest/uap/windows10/10"
  IgnorableNamespaces="... uap10">
  ...
  <Applications>
    <Application
      ...
      uap10:TrustLevel="mediumIL">
      ...
    Application>
  Applications>
  ...
Package>

我们调用Process.GetProcesses()获取进程列表（UAP 10.0.15138.0虽然加入了Process支持，但是并没有实现Process.GetProcesses()，所以这里是运行在 .NET 8.0 上的

using Microsoft.UI.Xaml.Controls;
using System.Diagnostics;

// To learn more about WinUI, the WinUI project structure,
// and more about our project templates, see: http://aka.ms/winui-project-info.

namespace FullTrustUWP.Pages
{
    /// 
    /// An empty page that can be used on its own or navigated to within a Frame.
    /// 
    public sealed partial class MainPage : Page
    {
        public MainPage() => InitializeComponent();

        public void Test()
        {
            // 这里使用了 Windows App SDK，实际上 WAS 是支持 UWP 的
            Content = new ItemsView
            {
                // 必须使用 .NET Core App，因为微软没有给 .NET Core 5.0 实现这个方法
                ItemsSource = Process.GetProcesses()
            };
        }
    }
}

运行效果

如果没有设置uap10:TrustLevel 为 mediumIL，则依然运行在沙盒中，Process.GetProcesses()只能获取到沙盒中的进程

【UWP】修改清单脱离沙盒运行作者 @where-where 2024年4月17日发表于博客园，转载请注明出处

【.NET】利用 IL 魔法实现随心随意的泛型约束

2024-04-17T09:10:00.000Z

众所周知，C# 只支持对 基类/接口/class/struct/new() 以及一些 IDE 魔法的约束，比如这样

public static string Test<T>(T value) where T : ITest
{
    return value.Test();
}

public interface ITest
{
    string Test();
}

但是如果我们想要随心所欲的约束就不行了

public static string Test<T>(T value) where T : { string Test(); }
{
    return value.Test();
}

最近无聊乱折腾 MSIL，弄出来好多不能跑的魔法，虽然不能跑但是反编译出的 C# 看着很神奇，其中正好就有想看看能不能弄个神奇的泛型出来，于是我胡写了一段代码

.assembly _
{
}

.class public Test
{
    .method public void .ctor()
    {
        ldarg.0
        call instance void object::.ctor()
        ret
    }

    .method public static void Main()
    {
        .entrypoint
        newobj instance void Test::.ctor()
        call string Test::Test(!!0)
        call void [mscorlib]System.Console::WriteLine(string)
        ret
    }

    .method public static string Test(!!T t)
    {
        ldarg.s t
        callvirt instance string !!T::Test()
        ret
    }

    .method public string Test()
    {
        ldstr "Call instance string Test::Test()"
        ret
    }
}

反编译出来是这样的

public class Test
{
    public static void Main()
    {
        Console.WriteLine(Test(new Test()));
    }

    public unsafe static string Test<T>(T t)
    {
        return ((T*)t)->Test();
    }

    public string Test()
    {
        return "Call instance string Test::Test()";
    }
}

这段代码是无法运行的，在 .NET Framework 会直接无返回，而在 Mono 会报错

[ERROR] FATAL UNHANDLED EXCEPTION: System.MissingMethodException: Method not found: string .T_REF.Test()
　　at Test.Main () [0x00005] in :0

于是我就当这是 .NET 泛型的局限性了，后来有群友提醒我说约束会影响运行时，于是我就尝试加上约束

.method public static string Test<(Test) T>(!!T t)
{
    ldarg.s t
    callvirt instance string !!T::Test()
    ret
}

发现真的能跑了（Framework 依然无返回。。。），于是我就看看能不能同时约束两个类型

.method public static string Test<(Test, Test2) T>(!!T t)
{
    ldarg.s t
    callvirt instance string !!T::Test()
    ret
}

Mono 成功输出

Call instance string Test::Test()
Call instance string Test2::Test()

而 Framework 直接运行时约束了。。。

未经处理的异常: System.Security.VerificationException: 方法 Test.Test: 类型参数“Test”与类型参数“T”的约束冲突。
　　在 Test.Main()

很明显 Mono 给泛型开了洞

随后测试发现，只要约束的类有相关成员就可以正常调用，于是我就利用抽象类做接口

.assembly _
{
}

.class public Test
{
    .field string Test

    .method public void .ctor()
    {
        ldarg.0
        ldstr "This is Test"
        stfld string Test::Test
        ldarg.0
        call instance void object::.ctor()
        ret
    }

    .method public static void Main()
    {
        .entrypoint
        .locals init (
            class Test test,
            class Test2 test2
        )
        newobj instance void Test::.ctor()
        stloc.s test
        ldloc.s test
        call void Test::Test(!!0)
        ldloc.s test
        call string Test::Test(!!0)
        call void [mscorlib]System.Console::WriteLine(string)
        newobj instance void Test2::.ctor()
        stloc.s test2
        ldloc.s test2
        call void Test::Test(!!0)
        ldloc.s test2
        call string Test::Test(!!0)
        call void [mscorlib]System.Console::WriteLine(string)
        ret
    }

    .method public static void Test<(WithTest) T>(!!T t)
    {
        ldarg.s t
        ldfld string !!T::Test
        call void [mscorlib]System.Console::WriteLine(string)
        ret
    }

    .method public static string Test<(WithTest) T>(!!T t)
    {
        ldarg.s t
        callvirt instance string !!T::Test()
        ret
    }

    .method public string Test()
    {
        ldstr "Call instance string Test::Test()"
        ret
    }
}

.class public Test2
{
    .field string Test

    .method public void .ctor()
    {
        ldarg.0
        ldstr "This is Test2"
        stfld string Test2::Test
        ldarg.0
        call instance void object::.ctor()
        ret
    }

    .method public newslot virtual string Test()
    {
        ldstr "Call instance string Test2::Test()"
        ret
    }
}

.class public abstract WithTest
{
    .field string Test

    .method public newslot abstract virtual string Test()
    {
    }
}

正确输出

This is Test
Call instance string Test::Test()
This is Test2
Call instance string Test2::Test()

Framework 自然还是炸的

最后反编译出来长这样

public class Test
{
    private string m_Test = "This is Test";

    public static void Main()
    {
        Test t = new Test();
        global::Test.Test(t);
        Console.WriteLine(global::Test.Test(t));
        Test2 t2 = new Test2();
        global::Test.Test(t2);
        Console.WriteLine(global::Test.Test(t2));
    }

    public unsafe static void Test<T>(T t) where T : WithTest
    {
        Console.WriteLine(((T*)t)->Test);
    }

    public unsafe static string Test<T>(T t) where T : WithTest
    {
        return ((T*)t)->Test();
    }

    public string Test()
    {
        return "Call instance string Test::Test()";
    }
}

public class Test2
{
    private string m_Test = "This is Test2";

    public virtual string Test()
    {
        return "Call instance string Test2::Test()";
    }
}

public abstract class WithTest
{
    private string m_Test;

    public abstract string Test();
}

当然，这种操作仅限娱乐，经测试 .NET Framework 和 .NET Core App 都会卡在约束，所以 .NET 是别想有随意的约束了，不过 C# 题案 "Roles and extensions" 倒是给出了曲线实现方案

【.NET】利用 IL 魔法实现随心随意的泛型约束作者 @where-where 2024年4月17日发表于博客园，转载请注明出处

Announcing to the WinRT package of AdvancedSharpAdbClient

2023-07-19T07:37:25.000Z

Announcing

We have packaged this project into winrt. With the winrt version, we can use it in cpp/winrt and other projects. You can find the winrt version in winrt branch.

How to use it

There are two way to reference it.

Reference to the project directly

Fork this repository and change the branch to winrt.

If your project is face to uwp, add this to your .vcproj

<ProjectReference Include="\path\to\AdvancedSharpAdbClient.WinRT.csproj">
  <Project>{083cdc04-9cc2-46e4-84c2-55b645be9d50}Project>
  <SetTargetFramework>TargetFramework=uap10.0SetTargetFramework>
ProjectReference>

If your project is face to desktop, add this to your .vcproj

<ProjectReference Include="\path\to\AdvancedSharpAdbClient.WinRT.csproj">
  <Project>{083cdc04-9cc2-46e4-84c2-55b645be9d50}Project>
  <SetTargetFramework>TargetFramework=net6.0-windows10.0.17763.0SetTargetFramework>
ProjectReference>

Reference to the nuget package
Download AdvancedSharpAdbClient.WinRT.zip.
Unzip it into nupkgs folder of the root path of your project
Create nuget.config into the root path of your project and add
1
2
3
4
5
6
"1.0" encoding="utf-8"?>
<configuration>
<packageSources>
<add key="Offline Nugets" value="nupkgs" />
packageSources>
configuration>
Open the manager of nuget and you will find it. Just install it like a normal nuget.

After that, if your project is not packaged into appx or misx, remember to create ProjectName.exe.manifest in the root of your project to register winrt class.

"1.0" encoding="utf-8"?>
<assembly manifestVersion="1.0" xmlns="urn:schemas-microsoft-com:asm.v1">
  <assemblyIdentity version="1.0.0.0" name="ProjectName"/>
  <file name="WinRT.Host.dll">
    <activatableClass
      name="AdvancedSharpAdbClient.WinRT.AdbClient"
      threadingModel="both"
      xmlns="urn:schemas-microsoft-com:winrt.v1" />
    <activatableClass
      name="AdvancedSharpAdbClient.WinRT.AdbCommandLineClient"
      threadingModel="both"
      xmlns="urn:schemas-microsoft-com:winrt.v1" />
    <activatableClass
      name="AdvancedSharpAdbClient.WinRT.AdbServer"
      threadingModel="both"
      xmlns="urn:schemas-microsoft-com:winrt.v1" />
    <activatableClass
      name="AdvancedSharpAdbClient.WinRT.AdbServerFeatures"
      threadingModel="both"
      xmlns="urn:schemas-microsoft-com:winrt.v1" />
    <activatableClass
      name="AdvancedSharpAdbClient.WinRT.AdbSocket"
      threadingModel="both"
      xmlns="urn:schemas-microsoft-com:winrt.v1" />
    <activatableClass
      name="AdvancedSharpAdbClient.WinRT.CrossPlatformFunc"
      threadingModel="both"
      xmlns="urn:schemas-microsoft-com:winrt.v1" />
    <activatableClass
      name="AdvancedSharpAdbClient.WinRT.DateTimeHelper"
      threadingModel="both"
      xmlns="urn:schemas-microsoft-com:winrt.v1" />
    <activatableClass
      name="AdvancedSharpAdbClient.WinRT.DeviceMonitor"
      threadingModel="both"
      xmlns="urn:schemas-microsoft-com:winrt.v1" />
    <activatableClass
      name="AdvancedSharpAdbClient.WinRT.Factories"
      threadingModel="both"
      xmlns="urn:schemas-microsoft-com:winrt.v1" />
    <activatableClass
      name="AdvancedSharpAdbClient.WinRT.SyncCommandConverter"
      threadingModel="both"
      xmlns="urn:schemas-microsoft-com:winrt.v1" />
    <activatableClass
      name="AdvancedSharpAdbClient.WinRT.SyncService"
      threadingModel="both"
      xmlns="urn:schemas-microsoft-com:winrt.v1" />
    <activatableClass
      name="AdvancedSharpAdbClient.WinRT.TcpSocket"
      threadingModel="both"
      xmlns="urn:schemas-microsoft-com:winrt.v1" />
    <activatableClass
      name="AdvancedSharpAdbClient.WinRT.DeviceCommands.LinuxPath"
      threadingModel="both"
      xmlns="urn:schemas-microsoft-com:winrt.v1" />
    <activatableClass
      name="AdvancedSharpAdbClient.WinRT.DeviceCommands.PackageManager"
      threadingModel="both"
      xmlns="urn:schemas-microsoft-com:winrt.v1" />
    <activatableClass
      name="AdvancedSharpAdbClient.WinRT.Logs.LogReader"
      threadingModel="both"
      xmlns="urn:schemas-microsoft-com:winrt.v1" />
  file>
assembly>

Announcing to the WinRT package of AdvancedSharpAdbClient 作者 @wherewhere 2023年7月19日发表于 GitHub，转载请注明出处

【UWP】开发小技巧――简单的增量加载

2022-01-24T14:46:06.000Z

#UWP# #爱编程# #电脑玩家#

增量加载的原理这里就不多说了，具体是干什么的可以看 CNBlogs 的讲解：查看链接

这里只讲解如何使用 CNBlogs UAP 中使用的增量加载方案(我硬是看了一天才知道怎么用。。。

首先附上代码(已经被我修改过了)：查看链接

部分代码

引用时不要忘了附上出处(不是我这，是CNBlogs

/// 
/// Datasource base for Coolapk that enabled incremental loading (page based). 

/// Clone from .
///

引用

接下来就是如何调用增量加载了(同样的，不解释代码

众所周知，UWP 中只有 ListView 系列支持增量加载，所以不要拿 ItemsRepeater 问我为什么不会自动加载。。。

首先，我们需要一个 ListView，光秃秃的，在不会用之前就先光秃秃的。。。

<Page
    x:Class="CoolapkLite.Pages.BlankPage"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="using:CoolapkLite.Pages"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    Background="{ThemeResource ApplicationPageBackgroundThemeBrush}"
    mc:Ignorable="d">
    <ListView x:Name="ListView" />
Page>

然后，新建一个集合，代码如下

internal class NewDS : DataSourceBase<string>
{
    private int _loadnum = 0;

    protected async override Taskstring>> LoadItemsAsync(uint count)
    {
        List<string> items = new List<string>();
        await Task.Run(() =>
        {
            for (int i = 0; i < count; i++)
            {
                items.Add((i + _loadnum).ToString ());
            }
        });
        _loadnum += items.Count;
        return items;
    }

    protected override void AddItems(IList<string> items)
    {
        if (items != null)
        {
            foreach (string item in items)
            {
                Add(item);
            }
        }
    }
}

其中，LoadItemsAsync 用来获取更多内容，这里是获取行数，AddItems 用来把东西丢进集合里，一般可以用来处理重复项。

接着，新建这个集合，直接把它绑定到 ListView 上就行了。

/// 
/// 可用于自身或导航至 Frane 内部的空白页。
/// 
public sealed partial class BlankPage : Page
{
    public BlankPage()
    {
        this.InitializeComponent();
        ListView.ItemsSource = new NewDS();
    }
}

绑定集合

我们来跑一跑看看

运行

如果真的要用在非 ListView 控件上或者自动加载不生效，可以通过 LoadMoreItemsAsync 方法手动来让它加载，所以一般刷新方法会写成这样，第一次加载时 Refresh(-2)，之后只要检测到滑到底了就执行一次 Refresh (不要问我为什么用数字，要问去问 Tan

public async Task Refresh(int p = -1)
{
    if (p == -2)
    {
        await Reset();
    }
    else if (p == -1)
    {
        _ = await LoadMoreItemsAsync(20);
    }
}

Tan 祖传的刷新方法

这里的 Reset 方法在 CNBlogs UAP 里叫 Refresh，内容是清空集合并初始化，我为了不和 Tan 祖传的 Refresh 方法冲突就给改掉了，如果直接使用我给的代码的话就不用管了。

LoadMoreItemsAsync 方法用来手动加载内容，输入的数字代表要加载的数量，自动加载的时候这个数是会自行计算出来的

好了，本次教程就先说这么多了，更多内容等我下次再说

【UWP】开发小技巧――简单的增量加载作者 @wherewhere 2022年1月24日发表于酷安，转载请注明出处

【开源】APK Installer —— 一个适用于 Windows 的 Android 应用安装程序

2022-01-05T06:50:00.000Z

APK Installer

一个适用于 Windows 的 Android 应用安装程序

注意

本应用已上架应用商店，请认准作者为 wherewhere，请不要使用来历不明的版本，如果因为使用不明版本而出现的故障请自行解决。
本应用分为 WinUI3版和 WPF版，请根据需要选取

下载链接

如何安装应用

最低需求

Windows 10 Build 18362及以上
设备需支持ARM64/x86/x64
至少400MB的空余储存空间(用于储存安装包与安装应用)

使用应用安装脚本安装应用

下载并解压最新的安装包(APKInstaller (Package)_x.x.x.0_Test.rar)
如果没有应用安装脚本，下载Install.ps1到目标目录
右击Install.ps1，选择“使用PowerShell运行”
应用安装脚本将会引导您完成此过程的剩余部分

使用应用安装程序安装应用

下载并解压最新的安装包(APKInstaller (Package)_x.x.x.0_Test.rar)
开启旁加载模式
- 如果您想开发UWP应用，您可以开启开发人员模式，对于大多数不需要做UWP开发的用户来说，开发人员模式是没有必要的
安装Dependencies文件夹下的适用于您的设备的所有依赖包
安装*.cer证书到本地计算机→受信任的根证书颁发机构
- 这项操作需要用到管理员权限，如果您安装证书时没有用到该权限，则可能是因为您将证书安装到了错误的位置或者您使用的是超级管理员账户
双击*.appxbundle，单击安装，坐和放宽

更新应用

下载并解压最新的安装包(APKInstaller (Package)_x.x.x.0_x86_x64_arm_arm64.appxbundle)
双击*.appxbundle，单击更新，坐和放宽

屏幕截图

WinUI3版
WPF版

使用到的模块

【开源】APK Installer —— 一个适用于 Windows 的 Android 应用安装程序作者 @wherewhere 2022年1月5日发表于吾爱破解，转载请注明出处

【UWP】开发小技巧――判断类是否存在

2021-12-19T06:58:37.000Z

#UWP# #爱编程# #电脑玩家#

不要问我这个需求是怎么冒出来的，自己没事找事要支持 10240，结果发现啥都不支持，真是太糟糕了。

一般而言，这类需求都是想办法通过类名新建对象，一开始我也是这么想的，不过网上那些教程都是单纯 .NET 的，不支持 UWP (也可能是我太菜了，不会用)，所以直接白嫖是不可能了。。。

不过判断是否存在不需要这么复杂，C# 有专门的 GetType 方法来找类，所以事情就简单了，直接 Type.GetType("类名") 就行了，不过真的是这样吗？

经过调试，并没有成功找到这个类型，不过不止 Type 有 GetType ，在 C# 中 Assembly 也有 GetType ，我直接找到要找的类的程序集再找类应该就能找到了吧。

很明显，这个方案才是对的。现在知道了方法，就搓个函数出来吧。

public static bool IsTypePresent(string AssemblyName, string TypeName)
{
    try
    {
        Assembly asmb = Assembly.Load(new AssemblyName(AssemblyName));
        Type supType = asmb.GetType($"{AssemblyName}.{TypeName}");
        return supType != null;
    }
    catch
    {
        return false;
    }
}

额，好像不太对，10240 不支持和类在不在程序集里好像没关系吧。。。

我们似乎还是要新建一个对象来判断它到底是不是支持，于是函数就变成这样了。。。

public static bool IsTypePresent(string AssemblyName, string TypeName)
{
    try
    {
        Assembly asmb = Assembly.Load(new AssemblyName(AssemblyName));
        Type supType = asmb.GetType($"{AssemblyName}.{TypeName}");
        if (supType != null)
        {
            try { Activator.CreateInstance(supType); }
            catch (MissingMethodException) { }
        }
        return supType != null;
    }
    catch
    {
        return false;
    }
}

终于正常了。。。

判断 API 是否存在就不要用这个方法了，官方有 ApiInformation，肯定比这个好用

哦对了，记得把函数放在要用的项目里，不要问我怎么知道的。。。

【UWP】开发小技巧――判断类是否存在作者 @wherewhere 2021年12月19日发表于酷安，转载请注明出处

Hello World

2021-03-13T11:24:57.000Z

Welcome to Hexo! This is your very first post. Check documentation for more info. If you get any problems when using Hexo, you can find the answer in troubleshooting or you can ask me on GitHub.

Quick Start

Create a new post

1	$ hexo new "My New Post"

More info: Writing

Run server

1	$ hexo server

More info: Server

Generate static files

1	$ hexo generate

More info: Generating

Deploy to remote sites

1	$ hexo deploy

More info: Deployment

【材质】BareBones 红石显示材质包

2021-02-04T12:53:59.000Z

材质简介

01:24

【MCBE】预告-Bare Bones塑料材质红石辅助显示预览

1151

视频

where-where

由于基岩版没有红石百搭包，于是就自己做了一套红石显示，基于 BareBones 材质包，借鉴了 XeKr 红石显示。

材质自用，按照个人喜好设计，如果有建议欢迎提出，但不一定接受

BareBones 材质简介：Bare Bones Texture Pack 官方都在用的朴素真理材质包

屏幕截图

更新日志

2021-01-24

v0.0.1 更新日志

05:34

【MCBE】BareBones红石显示v0.0.1发布了！

4240

视频

where-where

第一个版本发布
基于BareBones 1.1.1 适用于Minecraft BE 1.16

2021-01-30

v0.0.2 更新日志

04:51

【MCBE】BareBones红石显示v0.0.2发布了！

5336

视频

where-where

更新版本号至v0.0.2
炉子侧面现在可以动态显示状态了
重生锚顶部现在可以显示能量等级了
普通箱子现在可以显示方向了
末地传送门框架现在可以显示方向了
修复了观察者侧面高低不平的Bug
现在可以分辨南瓜和西瓜梗了
炼药锅现在可以分辨是否承装岩浆了
教育版方块和特殊方块现在可以正常显示名称了
数据更新方块现在可以作为绿幕和蓝幕使用

2021-03-19

v0.0.3 更新日志

更新版本号至v0.0.3
优化了线的贴图
更正了炉子动态的速度
为炉子背面贴图添加动画
修复了重生锚顶部贴图错误
现在可以显示铁傀儡破损了

2022-01-21

v0.0.4 更新日志

更新版本号至v0.0.4
适配新版 BareBones 样式
岩浆箭头现在不再不流畅了
修复了岩浆坩埚的材质方向
添加 missing_tile 方块

2023-06-19

v0.0.5 更新日志

更新版本号至v0.0.5
更新虫蚀方块材质

2025-04-19

v0.1.6 更新日志

10:05

【MCBE】BareBones 红石显示 v0.1.6 发布了！

1085

视频

where-where

更新版本号至v0.1.6
适配新版 BareBones 样式
删除铁傀儡破损
更新教育版与基岩版特供方块贴图
更新语言文本
现在虫蚀方块使用蠹虫贴图表示
添加校频/幽匿感测体、幽匿尖啸体、幽匿催发体
添加铜系列方块
添加一键合成和交易解锁
添加合成器
添加雕纹书架

2025-06-26

v0.1.7 更新日志

更新版本号至v0.1.7
适配新版 BareBones 样式
更改蜂巢与蜂箱底部样式
更改一些贴图的命名方式
修复旧版本虫蚀方块贴图

2026-02-25

v0.1.8 更新日志

更新版本号至v0.1.8
适配新版 BareBones 样式
适配向上的漏斗
更改熏炉火焰位置
添加英文文本和国际化

下载链接

BareBones红石显示材质包作者 @wherewhere 2021年2月4日发表于 MineBBS，转载请注明出处

回顾我在麦块里度过的时光

2020-12-20T08:32:36.000Z

#Minecraft# #我的世界# #我的2020年度总结#

一晃一年就快要过去了，这一年我正式接触了麦块，知道了各种各样神奇的东西，也遇到了各种各样的人，所以我想在这里分享我这一年的历程，也说一说我是应何而接触的麦块

在我初中的时候，我第一次听说了麦块，那时的麦块，移动端应该还在Alpha阶段，看到别人在那建宏伟的建筑，觉得特别无聊，也就没去接触

回顾旧版

一晃就到了2018年，我在B站上看到了恩氟烷瑞大佬的珍珠炮，指哪打哪的震撼感使我第一次想认真的玩一玩麦块，不过可惜的是，我最终只造出了窜天猴，还被麻将给修复了。。。(查看链接

【MCBE】上百个TNT爆炸会怎样

坏了的大炮

不过红石炮没了也没事，这时一个叫TIS的服务器横空出世，TIS是啥我就不多说了，但是他们才成立100天，但100天的宣传视频简直就和工业革命似的，量产一切的思想就在我的心中扎根了

12:33

一群肝帝在MC里生存了6695天后会是什么样子——TIS服务器100天游览 TIS Trinity Union 100-day Server Tour

我就是看着这个视频入坑生电的

还有一个大佬叫做本正，因为在晚上想关灯看星星，结果看出了BE生态下的红石通信系统，但是由于过于玄奥，我当时根本不敢去想自己也去研究这方面，光是看完花里胡哨的视频就已经够呛了。。。

27:16

历时一年！建造能互相收发短信的-自动化二进制通信设施（全自动编码解码寻址）

本正大佬的通信系统

于是，随着高考结束，我也开始了放飞自我，我开始真正去认真玩生存模式，尝试去量产一切，不过很可惜，我只造出了甘蔗/南瓜/西瓜/仙人掌/鸡蛋农场。。。

【MCBE】高考结束了，浪啊！！！

随着1.13更新，麦块出了一些Bug，总是卡在验证阶段，于是我弃坑了

2019年末，收到铺路群群友Santorsia的邀请，我加入了他的服务器，但是因为没啥兴趣也没上线过

到了12月31日，Santorsia在服里搞起了跨年活动，我上线看了看，也录了视频，但是总是感觉有些隔阂，于是我决定再次入坑麦块

2019年跨年活动

然后，我就发现了刷物品的Bug。。。(查看链接

05:16

【MCBE】当你的背包同时处于掉落与不掉落的状态时

511

视频

where-where

一地的金苹果

这次我造出了刷石机，学会了附魔，甚至打完了龙，可惜这个存档后来丢了，不然就能水点图片了。。。

于是我怀着忐忑的心情，在1月24日，正式加入了Santorsia's Server

我在服里看到了特别特别大的刷石机，这让我非常激动，以为进了一个生电大服，结果，绕了一圈才发现，这是唯一的生电设施了。。。

这一下子我就再也不紧张了，看到地狱基本处于未开发阶段，我决定，开始搞地狱交通！

好吧，一开始的确是轨道交通。。。

我在唯一的地狱交通站处建了家，以彰显地狱交通的方便，但是当时的我根本不知道地狱交通应该长啥，于是，随便开个门，然后进别人家后院了。。。

我家入口(实际上是个车站

随着交通的进展，我与成员的关系也更活络了，于是我打算考一个大一些但比较简单的生电项目，最终我选择了守卫者农场

守卫者农场选址

几乎所有成员都参与了，这使得我非常兴奋，也是我觉得最愉快的时刻了，于是我有了更大的计划

我想搞那个16联的史莱姆农场，还有全物品！

2月8日，Santorsia服举办了元宵节活动，在我的提议下服主决定用C4D画一张全家福，但是我的皮肤没法导出，于是我决定自己画一个

元宵节

说画就画，第二天，皮肤就绘制完成了

I am the caption of Federation StarShip...

不过好景不长，2月12日，鱼塔改造工程开始，我们也成功获取了传送门方块，但是到了15日，服务器莫名其妙崩溃了，而且每隔一段时间就崩溃。于是我们就回档了，但没过多久，又崩溃了。这个现象预演欲烈，服主认为是传送门的问题，但我不同意，因为在获取传送门之前就已经崩溃过一次了，于是我提议回档到崩溃前一天，果不其然，过了一会又崩溃了，这使得大家的心情都很糟糕

但大家还是得玩啊，2月17日，史莱姆农场完工，随后，工业化大改造开始，地狱交通也开始向冰道迈进

高速火炉

为此我仔细研究了Wiki，地狱交通统一规划也开始了

交通绘图

当然，我也没有忘记当年引我入坑的红石，我开始尝试制作一些红石设备，比如储存器

显示器

随后我再次学习了本正大佬的视频和存档，并成功仿制出了编码器和解码器，并自研了一个编码器

土制版编码器

甚至在生存里实装了一个

数码管

虽然一切似乎都按照计划进行，但实际上已经发生了分歧，随着刷物品的引入，大家开始逐渐失去了对工业化的心情，全都拿着活塞和箱子玩推推乐了。同时，这个服有个很糟糕的特性，我从来都没有看见过服主以生存模式进入服务器过，各管理员也是如此，也就是所说的滥权严重。这使得工业化变成了一个面子工程，毕竟大家都能通过其他方式去获取资源，也没人在乎有没有什么生电了。。。

于是，在一个破坏分子的骚扰下，服内乱了，服主开始乱来一气，把建筑拆了，把出生点搞到万米之外。

我是一脸懵逼，最终我的地狱交通在被未通知的情况下被全拆掉了。。。

地狱交通遗照

我很生气，知道生电在这个服里不会有什么发展了，于是我愤怒的离开了这个服

在此之前，受到 @发呆蛋糕的邀请，我前往了Cake Mania参观学习，这是一个2月份才建立的服务器，但是生电化比发展了3年的Santorsia's Server要高的多，我就像乡下人进城一样看着猪人塔，大型农场，虽然设施不多，但也能看出这是一个生电服

Cake Mania !

结果，我就从参观变成了常驻。。。(查看链接

一上来我就打算把服里的地狱交通整改一下，群友们非常热情，几分钟下来(0,0)附近直接被挖空了，我是一脸懵逼

地狱大厅

于是
3月19日，全物品计划开始，全物品样品完成(查看链接

五分之一物品

3月22日，刷沙机完工(查看链接

刷沙机

4月5日，全重力方块分类完工(查看链接

全重力

突然有一天，我脑子一抽，百来块钱就没了，我终于入坑JE了，随后受San邀请去参观了他的服务器

这回真的是进城了，一切量产，按盒算，看的我是一愣一愣的。单区块史莱姆农场效率高的吓人，守卫者农场收集不完的直接烧掉。。。

他们正在建设的全物品

很遗憾的是，我不小心把我的存档全搞没了，全没了。。。

最后只复原了一个存档，花了十分钟。。。

回忆啊。。。

结果服主去上学了，忘记开服了，我们经历了很长时间的无服期。。。

于是
4月19日，烧服庆典

啦啦啦啦啦啦！

4月20日，自研解码器成功，我终于有自己的作品了！(查看链接

03:53

【MCBE】交作业-适用于本正设计的高速编码器的译码器

这是我们审核群的群号/滑稽

【MCBE】适用于本正设计的传统编码与高速编码间的转换器(单向)

277

视频

where-where

5月1日，全物品设计开始了，我参(fu)考(ke)了TIS全物品废案，在这期间，自研的作品越来越多

潜隐盒卸货机：查看链接

【MCBE】全物品组件展示-潜隐盒卸货机

不可堆叠分离：查看链接

【MCBE】全物品基础教程-不可堆叠分离组件

小天才过滤器：查看链接

【MCBE】全物品组件教程-小天才过滤器(占位符过滤器)

1547

视频

where-where

以及很多咕咕咕还没制作视频的作品

最早的设计

5月15日，16联史莱姆农场正式开工了，非常幸运(不幸)这个种子的16联史莱姆区块是一片带沼泽的森林。。。区块挖(zha)下来，收获那叫一个多(查看链接

好大一个坑

17天后，也就是6月2日，史莱姆农场终于完工了，这一个在前服就开始构思的工程终于实现了(查看链接

非常壮观

6月23日，全物品主体设计也完成了(查看链接

全物品

于是，在7月3日，我们决定开工全物品(为了不咕下去，我让Wade在天上先画个十字架，这样不开工也得开工了。。。(查看链接

全物品

7月26日，全物品普通分类部分完工(查看链接

02:10

【MCBE】胜利啦！全物品的最后一个物品！

1301

视频

where-where

最后一个物品

在此之间，我也参观了其他的服，体验到了按需分配的感觉，也遇到了一个非常奇葩的服，动不动就回档，以至于我只来得及造一个领事馆。。。

Cake Mania领事馆

9月中旬，我突发奇想想玩玩光速船，于是我废了九牛二虎之力才造出来一个能用的，还煞有其事的测了一下速。。。(查看链接

08:06

【MCBE】磁悬浮高铁――适用于 Minecraft 基岩版 1.16+ 的光速船

2043

视频

where-where

光速船

10月30日，全物品主体工程完工(查看链接

N方向

10月31日，在10月的最后一天，我突然想造鱼塔了，于是我就造了一个。。。

铺这玩意真费劲

11月的时候，无意中发现麦块居然要搞比赛了，这是第一次官方搞比赛，我就想着蹭一蹭，结果进去傻眼了，别人一个个都是建筑大佬，全都按城建，就我不会建筑，于是我耗尽毕生所学，造了一个。。。

。。。。。

最终Cake Mania代表队参赛我的世界未来挑战大赛并获得本赛道第五的成绩(共9人参赛。。。(查看链接

04:00

【我的世界未来挑战大赛】Cake Mania代表队作品展示——基于单线通讯的数字轨道交通系统

314

视频

where-where

蛋糕糕是个桶~~~

随后是一些无线电通信的成果