qidao123.com技术社区-IT企服评测·应用市场

标题: 【UWP】让 UWP 自己和自己通信 [打印本页]
作者: 拉不拉稀肚拉稀    时间: 2025-4-1 19:49
标题: 【UWP】让 UWP 自己和自己通信
众所周知，UWP 一般是运行在沙盒内里的，当我们需要访问沙盒外资源的时间，就需要通过沙盒外的署理服务器来获取。一般情况下我们都是利用 WinRT API 通过 Runtime Broker 来和沙盒外互通，遇到要自定义的情况则是手动开一个 Win32 服务器来互通，但是有没有可能我们可以直接拿 UWP 本体当服务器呢？
UWP 本体现实上就是一个普通的 Win32 EXE 程序，只是想要以 UWP 状态运行只能通过系统托管，但是如果我们不需要它以 UWP 状态执行的时间完全可以直接双击打开它，这时间它就是一个很普通的散装 Win32 程序了。
利用这个特性，我们可以制作一种假装双击打开的方法，只需要在发现是 Win32 状态下启动就去用 API 唤起 UWP 形态的自己就行了。
  1. private static unsafe bool IsPackagedApp
  2. {
  3.     get
  4.     {
  5.         uint length = 0;
  6.         PWSTR str = new();
  7.         _ = PInvoke.GetCurrentPackageFullName(ref length, str);
  9.         char* ptr = stackalloc char[(int)length];
  10.         str = new(ptr);
  11.         WIN32_ERROR result = PInvoke.GetCurrentPackageFullName(ref length, str);
  12.         return result != WIN32_ERROR.APPMODEL_ERROR_NO_PACKAGE;
  13.     }
  14. }
  16. private static void Main()
  17. {
  18.     if (IsPackagedApp)
  19.     {
  20.         Application.Start(static p =>
  21.         {
  22.             DispatcherQueueSynchronizationContext context = new(DispatcherQueue.GetForCurrentThread());
  23.             SynchronizationContext.SetSynchronizationContext(context);
  24.             _ = new App();
  25.         });
  26.     }
  27.     else
  28.     {
  29.         StartCoreApplicationAsync().Wait();
  30.     }
  31. }
  33. private static async Task StartCoreApplicationAsync()
  34. {
  35.     PackageManager manager = new();
  36.     string basePath = AppDomain.CurrentDomain.BaseDirectory;
  37.     XmlDocument manifest = await XmlDocument.LoadFromFileAsync(await StorageFile.GetFileFromPathAsync(Path.Combine(basePath, "AppxManifest.xml")));
  38.     IXmlNode identity = manifest.GetElementsByTagName("Identity")?[0];
  39.     string name = identity.Attributes.FirstOrDefault(x => x.NodeName == "Name")?.InnerText;
  40.     IXmlNode application = manifest.GetElementsByTagName("Application")?[0];
  41.     string id = application.Attributes.FirstOrDefault(x => x.NodeName == "Id")?.InnerText;
  42.     IEnumerable<Package> packages = manager.FindPackagesForUser(string.Empty).Where(x => x.Id.FamilyName.StartsWith(name));
  43.     if (packages.FirstOrDefault() is Package package)
  44.     {
  45.         IReadOnlyList<AppListEntry> entries = await package.GetAppListEntriesAsync();
  46.         if (entries?[0] is AppListEntry entry)
  47.         {
  48.             _ = await entry.LaunchAsync();
  49.         }
  50.     }
  51. }
复制代码
既然我们可以让自己唤起自己，那么自己和自己通信也不是什么难事了，我们只需要在 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 中添加任务：
  1. <Target Name="OutputWinMD" BeforeTargets="BuildCompile">
  2.   <PropertyGroup>
  3.     <PlatformName Condition="'$(Platform)' == 'Win32'">x86</PlatformName>
  4.     <PlatformName Condition="'$(Platform)' == 'ARM64EC'">ARM64</PlatformName>
  5.     <PlatformName Condition="'$(PlatformName)' == ''">$(Platform)</PlatformName>
  6.   </PropertyGroup>
  7.   <Copy SourceFiles="$(OutDir)\$(ProjectName).winmd" DestinationFolder="..\WinMD\$(PlatformName)\$(Configuration)" />
  8.   <Message Text="Copied output metadata file to '..\WinMD\$(PlatformName)\$(Configuration)\'." />
  9. </Target>
复制代码
如许当项目编译完成后就会把 winmd 复制到..\WinMD\$(PlatformName)\$(Configuration)\内里，这个文件夹是什么可以根据情况修改，注意只复制 winmd 文件。
接着我们在 UWP 项目引用 winmd 文件 (SelfCOMServer.Metadata替换成现实值)：
  1. <ItemGroup>
  2.   <CsWinRTInputs Include="..\WinMD\$(Platform)\$(Configuration)\SelfCOMServer.Metadata.winmd" />
  3. </ItemGroup>
  5. <ItemGroup>
  6.   <None Include="..\WinMD\$(Platform)\$(Configuration)\SelfCOMServer.Metadata.winmd" Visible="False">
  7.     <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
  8.   </None>
  9. </ItemGroup>
复制代码
接下来我们就可以开始写 COM 类了，首先我们要实现一个负责服务器管理的类，这个类用来管理服务器的声明周期和远程类的获取方法。
其中我们需要先实现一种让服务器可以在客户端关闭后自动关闭的方法，让客户端通知是很不公道的，因为客户端可能会突然暴毙，如许就会导致服务器永远也不会释放了，所以我们必须让服务器去感知客户端不再需要服务器了。在 C++，我们可以通过观察引用计数的方法来知道远程类是否被客户端释放了，但是在 C#，远程类被客户端释放后并不会真的释放，我临时不清楚其中的原因，体现出来就是解构方法并不会被执行，所以我们就无法通过类释放来关闭服务器了。于是我们还有一种方法，当通信断开后，我们执行远程方法就会报错，如许我们就知道通信已经断开了，于是我们可以让客户端给服务器发送一个保活委托，服务器每隔一段时间就去执行一次，如许通信断开后再执行委托就会直接报错了。固然我们还可以让这个保活委托变成一个永远也不会结束的异步，让 WinRT 自己去等待，如许服务器在通信断开的一瞬间知道通信结束了，不过由于我们并不需要瞬间就反应，有时间我们还需要考虑应用被关闭后马上就又打开的情况，所以我照旧选择自己开个隔断比较长的定时器自己喂狗了。
实现很简单，开个定时器喂狗就行了：
  1. /// <summary>
  2. /// Represents a monitor that checks if a remote object is alive.
  3. /// </summary>
  4. public sealed partial class RemoteMonitor : IDisposable
  5. {
  6.     private bool disposed;
  7.     private readonly Timer _timer;
  8.     private readonly Action _dispose;
  10.     /// <summary>
  11.     /// Initializes a new instance of the <see cref="RemoteMonitor"/> class.
  12.     /// </summary>
  13.     /// <param name="handler">The handler to check if the remote object is alive.</param>
  14.     /// <param name="dispose">The action to dispose the remote object.</param>
  15.     /// <param name="period">The period to check if the remote object is alive.</param>
  16.     public RemoteMonitor(IsAliveHandler handler, Action dispose, TimeSpan period)
  17.     {
  18.         _dispose = dispose;
  19.         _timer = new(_ =>
  20.         {
  21.             bool isAlive = false;
  22.             try
  23.             {
  24.                 isAlive = handler.Invoke();
  25.             }
  26.             catch
  27.             {
  28.                 isAlive = false;
  29.             }
  30.             finally
  31.             {
  32.                 if (!isAlive)
  33.                 {
  34.                     Dispose();
  35.                 }
  36.             }
  37.         }, null, TimeSpan.Zero, period);
  38.     }
  40.     /// <summary>
  41.     /// Finalizes the instance of the <see cref="RemoteMonitor"/> class.
  42.     /// </summary>
  43.     ~RemoteMonitor() => Dispose();
  45.     /// <inheritdoc/>
  46.     public void Dispose()
  47.     {
  48.         if (!disposed)
  49.         {
  50.             disposed = true;
  51.             _timer.Dispose();
  52.             _dispose?.Invoke();
  53.             GC.SuppressFinalize(this);
  54.         }
  55.     }
  56. }
复制代码
同时在 IDL 定义IsAliveHandler委托：
  1. delegate Boolean IsAliveHandler();
复制代码
接下来我们就可以写服务器管理类了，我们只需要让它能正确释放服务器就行了，分别写 IDL 定义和 C# 实现：
  1. interface ISetMonitor
  2. {
  3.     void SetMonitor(IsAliveHandler handler, Windows.Foundation.TimeSpan period);
  4. }
  6. interface IRemoteThing requires ISetMonitor, Windows.Foundation.IClosable, Windows.Foundation.IStringable
  7. {
  8.     // 其他远程操作
  9. }
复制代码
  1. /// <summary>
  2. /// The manage class for remote object.
  3. /// </summary>
  4. public sealed partial class RemoteThing : IRemoteThing
  5. {
  6.     private bool disposed;
  7.     private RemoteMonitor _monitor;
  9.     /// <summary>
  10.     /// Initializes a new instance of the <see cref="RemoteThing"/> class.
  11.     /// </summary>
  12.     public RemoteThing() => Program.RefCount++;
  14.     /// <summary>
  15.     /// Finalizes the instance of the <see cref="RemoteThing"/> class.
  16.     /// </summary>
  17.     ~RemoteThing() => Dispose();
  19.     /// <summary>
  20.     /// Sets the monitor to check if the remote object is alive.
  21.     /// </summary>
  22.     /// <param name="handler">The handler to check if the remote object is alive.</param>
  23.     /// <param name="period">The period to check if the remote object is alive.</param>
  24.     public void SetMonitor(IsAliveHandler handler, TimeSpan period) => _monitor = new RemoteMonitor(handler, Dispose, period);
  26.     #region 其他远程操作
  28.     #endregion
  30.     /// <inheritdoc/>
  31.     public void Dispose()
  32.     {
  33.         if (!disposed)
  34.         {
  35.             disposed = true;
  36.             _monitor?.Dispose();
  37.             GC.SuppressFinalize(this);
  38.             if (--Program.RefCount == 0)
  39.             {
  40.                 _ = Program.CheckComRefAsync();
  41.             }
  42.         }
  43.     }
  45.     /// <summary>
  46.     /// 随便写点什么作为测试。
  47.     /// </summary>
  48.     public override string ToString() =>
  49.         new StringBuilder()
  50.             .AppendLine("Information")
  51.             .AppendLine($"Framework: {RuntimeInformation.FrameworkDescription}")
  52.             .AppendLine($"OSPlatform: {Environment.OSVersion}")
  53.             .Append($"OSArchitecture: {RuntimeInformation.OSArchitecture}")
  54.             .ToString();
  55. }
复制代码
有了服务器管理类，我们就可以把它注册到 COM 服务器了。想要注册 COM 类，我们需要一个  Factory 工厂类来让 COM 服务器可以在通信时初始化 COM 类。首先我们需要导入 COM 相关 API，定义IClassFactory接口，其中Factory.CLSID_IRemoteThing为远程类的CLSID。
  1. public static partial class Factory
  2. {
  3.     public static readonly Guid CLSID_IRemoteThing = new("01153FC5-2F29-4F60-93AD-EFFB97CC9E20");
  4.     public static readonly Guid CLSID_IUnknown = new("00000000-0000-0000-C000-000000000046");
  6.     [LibraryImport("api-ms-win-core-com-l1-1-0.dll")]
  7.     internal static partial int CoRegisterClassObject(in Guid rclsid, IClassFactory pUnk, uint dwClsContext, int flags, out uint lpdwRegister);
  9.     [LibraryImport("api-ms-win-core-com-l1-1-0.dll")]
  10.     internal static partial int CoRevokeClassObject(uint dwRegister);
  11. }
  13. // https://docs.microsoft.com/windows/win32/api/unknwn/nn-unknwn-iclassfactory
  14. [GeneratedComInterface]
  15. [Guid("00000001-0000-0000-C000-000000000046")]
  16. public partial interface IClassFactory
  17. {
  18.     void CreateInstance(nint pUnkOuter, in Guid riid, out nint ppvObject);
  20.     void LockServer([MarshalAs(UnmanagedType.Bool)] bool fLock);
  21. }
复制代码
接下来我们可以制作一个抽象的工厂类，然后就可以直接继承这个工厂类来实现对应类的工厂类，不过由于 COM 源天生临时不支持泛型，所以这个抽象的工厂类不能加GeneratedComClass。
  1. public abstract partial class Factory<T, TInterface> : IActivationFactory, IClassFactory where T : TInterface, new()
  2. {
  3.     private const int E_NOINTERFACE = unchecked((int)0x80004002);
  4.     private const int CLASS_E_NOAGGREGATION = unchecked((int)0x80040110);
  6.     private readonly Guid _iid = typeof(TInterface).GUID;
  8.     public nint ActivateInstance() => MarshalInspectable<TInterface>.FromManaged(new T());
  10.     public void CreateInstance(nint pUnkOuter, in Guid riid, out nint ppvObject)
  11.     {
  12.         ppvObject = 0;
  14.         if (pUnkOuter != 0)
  15.         {
  16.             Marshal.ThrowExceptionForHR(CLASS_E_NOAGGREGATION);
  17.         }
  19.         if (riid == _iid || riid == Factory.CLSID_IUnknown)
  20.         {
  21.             // Create the instance of the .NET object
  22.             ppvObject = MarshalInspectable<TInterface>.FromManaged(new T());
  23.         }
  24.         else
  25.         {
  26.             // The object that ppvObject points to does not support the
  27.             // interface identified by riid.
  28.             Marshal.ThrowExceptionForHR(E_NOINTERFACE);
  29.         }
  30.     }
  32.     public void LockServer([MarshalAs(UnmanagedType.Bool)] bool fLock)
  33.     {
  34.     }
  36.     public abstract void RegisterClassObject();
  37.     public abstract void RevokeClassObject();
  38. }
复制代码
然后我们继承这个抽象的工厂类来实现我们需要的工厂类：
  1. [GeneratedComClass]
  2. public partial class RemoteThingFactory : Factory<RemoteThing, IRemoteThing>
  3. {
  4.     private uint cookie;
  6.     public override void RegisterClassObject()
  7.     {
  8.         int hresult = Factory.CoRegisterClassObject(
  9.             Factory.CLSID_IRemoteThing,
  10.             this,
  11.             (uint)CLSCTX.CLSCTX_LOCAL_SERVER,
  12.             (int)REGCLS.REGCLS_MULTIPLEUSE,
  13.             out cookie);
  14.         if (hresult < 0)
  15.         {
  16.             Marshal.ThrowExceptionForHR(hresult);
  17.         }
  18.     }
  20.     public override void RevokeClassObject()
  21.     {
  22.         int hresult = Factory.CoRevokeClassObject(cookie);
  23.         if (hresult < 0)
  24.         {
  25.             Marshal.ThrowExceptionForHR(hresult);
  26.         }
  27.     }
  28. }
复制代码
然后我们就可以在程序入口点注册这个 COM 类了：
  1. public static class Program
  2. {
  3.     private static ManualResetEventSlim comServerExitEvent;
  5.     public static int RefCount { get; set; }
  7.     private static void Main(string[] args)
  8.     {
  9.         if (args is ["-RegisterProcessAsComServer", ..])
  10.         {
  11.             comServerExitEvent = new ManualResetEventSlim(false);
  12.             comServerExitEvent.Reset();
  13.             RemoteThingFactory factory = new();
  14.             factory.RegisterClassObject();
  15.             _ = CheckComRefAsync();
  16.             comServerExitEvent.Wait();
  17.             factory.RevokeClassObject();
  18.         }
  19.         else
  20.         {
  21.             Application.Start(static p =>
  22.             {
  23.                 DispatcherQueueSynchronizationContext context = new(DispatcherQueue.GetForCurrentThread());
  24.                 SynchronizationContext.SetSynchronizationContext(context);
  25.                 _ = new App();
  26.             });
  27.         }
  28.     }
  30.     public static async Task CheckComRefAsync()
  31.     {
  32.         await Task.Delay(100);
  33.         if (RefCount == 0)
  34.         {
  35.             comServerExitEvent?.Set();
  36.         }
  37.     }
  38. }
复制代码
最后我们需要在清单声明 COM 服务器，其中SelfCOMServer.exe为服务器所在的可执行文件，Class ID 填远程类的CLSID。
  1. <Applications>
  2.   <Application>
  3.     ...
  4.     <Extensions>
  5.       <com:Extension Category="windows.comServer">
  6.         <com:ComServer>
  7.           <com:ExeServer
  8.             Executable="SelfCOMServer.exe"
  9.             Arguments="-RegisterProcessAsComServer"
  10.             DisplayName="COM Server"
  11.             LaunchAndActivationPermission="O:SYG:SYD:(A;;11;;;WD)(A;;11;;;RC)(A;;11;;;AC)(A;;11;;;AN)S:P(ML;;NX;;;S-1-16-0)">
  12.             <com:Class Id="01153FC5-2F29-4F60-93AD-EFFB97CC9E20" DisplayName="COM Server" />
  13.           </com:ExeServer>
  14.         </com:ComServer>
  15.       </com:Extension>
  16.     </Extensions>
  17.   </Application>
  18. </Applications>
复制代码
如今我们已经完成了服务端的制作，接下来我们就可以让客户端调用服务器远程类了。
在Factory类继续添加获取远程类的相关内容：
  1. public static partial class Factory
  2. {
  3.     private static bool IsAlive() => true;
  5.     public static IRemoteThing CreateRemoteThing() =>
  6.         CreateInstance<IRemoteThing>(CLSID_IRemoteThing, CLSCTX.CLSCTX_ALL, TimeSpan.FromMinutes(1));
  8.     internal static T CreateInstance<T>(Guid rclsid, CLSCTX dwClsContext = CLSCTX.CLSCTX_INPROC_SERVER)
  9.     {
  10.         int hresult = CoCreateInstance(rclsid, 0, (uint)dwClsContext, CLSID_IUnknown, out nint result);
  11.         if (hresult < 0)
  12.         {
  13.             Marshal.ThrowExceptionForHR(hresult);
  14.         }
  15.         return Marshaler<T>.FromAbi(result);
  16.     }
  18.     internal static T CreateInstance<T>(Guid rclsid, CLSCTX dwClsContext, TimeSpan period) where T : ISetMonitor
  19.     {
  20.         T results = CreateInstance<T>(rclsid, dwClsContext);
  21.         results.SetMonitor(IsAlive, period);
  22.         return results;
  23.     }
  25.     [LibraryImport("api-ms-win-core-com-l1-1-0.dll")]
  26.     private static partial int CoCreateInstance(in Guid rclsid, nint pUnkOuter, uint dwClsContext, in Guid riid, out nint ppv);
  27. }
复制代码
如今我们只需要执行IRemoteThing remote = Factory.CreateRemoteThing();就能获取远程类了。
到这里我们已经完成了 OOP COM 的全部流程，我们想要实现什么内容就可以按照构建服务器管理类的方法来制作 COM 远程类，然后通过在服务器管理类添加一个构造方法来获取这个远程类，如许我们就不需要单独分配 CLSID 和注册 COM 类了。
比如我们可以给Process套个壳：
  1. /// <inheritdoc cref="Process"/>
  2. public partial class RemoteProcess(Process inner) : IProcess
  3. {
  4.     /// <inheritdoc cref="Process.ProcessName"/>
  5.     public string ProcessName => inner.ProcessName;
  7.     /// <inheritdoc cref="Process.StandardError"/>
  8.     public ITextReader StandardError => new RemoteTextReader(inner.StandardError);
  10.     /// <inheritdoc cref="Process.ProcessName"/>
  11.     public ITextWriter StandardInput => new RemoteTextWriter(inner.StandardInput);
  13.     /// <inheritdoc cref="Process.StandardOutput"/>
  14.     public ITextReader StandardOutput => new RemoteTextReader(inner.StandardOutput);
  16.     /// <inheritdoc cref="Process.StartInfo"/>
  17.     public IProcessStartInfo StartInfo
  18.     {
  19.         get => new RemoteProcessStartInfo(inner.StartInfo);
  20.         set => value.ToProcessStartInfo();
  21.     }
  23.     private readonly ConditionalWeakTable<CoDataReceivedEventHandler, DataReceivedEventHandler> errorDataReceived = [];
  24.     /// <inheritdoc cref="Process.ErrorDataReceived"/>
  25.     public event CoDataReceivedEventHandler ErrorDataReceived
  26.     {
  27.         add
  28.         {
  29.             void wrapper(object sender, DataReceivedEventArgs e) => value(this, new CoDataReceivedEventArgs(e.Data));
  30.             DataReceivedEventHandler handler = wrapper;
  31.             inner.ErrorDataReceived += handler;
  32.             errorDataReceived.Add(value, handler);
  33.         }
  34.         remove
  35.         {
  36.             if (errorDataReceived.TryGetValue(value, out DataReceivedEventHandler handler))
  37.             {
  38.                 inner.ErrorDataReceived -= handler;
  39.                 errorDataReceived.Remove(value);
  40.             }
  41.         }
  42.     }
  44.     private readonly ConditionalWeakTable<CoDataReceivedEventHandler, DataReceivedEventHandler> outputDataReceived = [];
  45.     /// <inheritdoc cref="Process.OutputDataReceived"/>
  46.     public event CoDataReceivedEventHandler OutputDataReceived
  47.     {
  48.         add
  49.         {
  50.             void wrapper(object sender, DataReceivedEventArgs e) => value(this, new CoDataReceivedEventArgs(e.Data));
  51.             DataReceivedEventHandler handler = wrapper;
  52.             inner.OutputDataReceived += handler;
  53.             outputDataReceived.Add(value, handler);
  54.         }
  55.         remove
  56.         {
  57.             if (outputDataReceived.TryGetValue(value, out DataReceivedEventHandler handler))
  58.             {
  59.                 inner.OutputDataReceived -= handler;
  60.                 outputDataReceived.Remove(value);
  61.             }
  62.         }
  63.     }
  65.     /// <inheritdoc cref="Process.BeginErrorReadLine"/>
  66.     public void BeginErrorReadLine() => inner.BeginErrorReadLine();
  68.     /// <inheritdoc cref="Process.BeginOutputReadLine"/>
  69.     public void BeginOutputReadLine() => inner.BeginOutputReadLine();
  71.     /// <inheritdoc cref="Process.CancelErrorRead"/>
  72.     public void CancelErrorRead() => inner.CancelErrorRead();
  74.     /// <inheritdoc cref="Process.CancelOutputRead"/>
  75.     public void CancelOutputRead() => inner.CancelOutputRead();
  77.     /// <inheritdoc cref="Component.Dispose"/>
  78.     public void Dispose()
  79.     {
  80.         inner.Dispose();
  81.         GC.SuppressFinalize(this);
  82.     }
  84.     /// <inheritdoc cref="Process.ToString"/>
  85.     public override string ToString() => inner.ToString();
  86. }
复制代码
静态部分可以弄一个假装的静态类：
  1. /// <inheritdoc cref="Process"/>
  2. public sealed partial class ProcessStatic : IProcessStatic
  3. {
  4.     /// <inheritdoc cref="Process.GetProcesses()"/>
  5.     public IProcess[] GetProcesses() => Process.GetProcesses().Select(x => new RemoteProcess(x)).ToArray();
  7.     public IProcess Start(IProcessStartInfo startInfo) =>
  8.         Process.Start(startInfo.ToProcessStartInfo()) is Process process
  9.             ? new RemoteProcess(process) : null;
  10. }
复制代码
然后我们在服务器管理类里增长构造方法：
  1. public IProcessStatic CreateProcessStatic() => new ProcessStatic();
复制代码
如许我们就可以在 UWP 里使用 Process 创建一个 cmd 进程了：
  1. IRemoteThing remote = Factory.CreateRemoteThing();
  2. process = remote.CreateProcessStatic().Start(new RemoteProcessStartInfo
  3. {
  4.     FileName = "cmd",
  5.     CreateNoWindow = true,
  6.     RedirectStandardError = true,
  7.     RedirectStandardInput = true,
  8.     RedirectStandardOutput = true,
  9.     UseShellExecute = false
  10. });
  11. AppTitle.Text = process.ProcessName;
  12. process.OutputDataReceived += OnOutputDataReceived;
  13. process.ErrorDataReceived += OnErrorDataReceived;
  14. process.BeginOutputReadLine();
  15. process.BeginErrorReadLine();
复制代码
具体实现可以查看：SelfCOMServer/SelfCOMServer/Common/RemoteProcess.cs at main · wherewhere/SelfCOMServer

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

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。



欢迎光临 qidao123.com技术社区-IT企服评测·应用市场 (https://dis.qidao123.com/) Powered by Discuz! X3.4