[CodeGen] Support net6+ on server

NuGet/OpenRiaServices.Client.CodeGen/OpenRiaServices.Client.CodeGen.nuspec

@@ -25,5 +25,7 @@
         <file src="..\..\src\bin\Release\net472\OpenRiaServices.Tools.dll" target="tasks\net472\OpenRiaServices.Tools.dll"/>
         <file src="..\..\src\bin\Release\net472\Mono.Cecil.dll" target="tasks\net472\Mono.Cecil.dll"/>
         <file src="..\..\src\bin\Release\net472\Mono.Cecil.Pdb.dll" target="tasks\net472\Mono.Cecil.Pdb.dll"/>
+        <!-- TODO: Make a publish of project and take assemblies from there instead -->
+        <file src="..\..\src\OpenRiaServices.Tools.CodeGenTask\bin\Release\net6.0\**\*.*" target="tasks\net6.0\"/>
     </files>
-</package>
+</package>

NuGet/OpenRiaServices.T4.nuspec

@@ -16,8 +16,14 @@
     <language>en-US</language>
     <tags>WCF RIA Services RIAServices T4 OpenRiaServices</tags>
     <dependencies>
-      <dependency id="OpenRiaServices.Server" version="$version$" />
-      <dependency id="Mono.Cecil" version="0.11.5" />
+      <group targetFramework="net6.0">
+        <dependency id="OpenRiaServices.Server" version="$version$" />
+        <dependency id="Mono.Cecil" version="0.11.5" />
+      </group>
+      <group targetFramework="net472">
+        <dependency id="OpenRiaServices.Server" version="$version$" />
+        <dependency id="Mono.Cecil" version="0.11.5" />
+      </group>
     </dependencies>
   </metadata>
   <files>
@@ -27,5 +33,12 @@
     <file src="..\src\bin\Release\net472\OpenRiaServices.Tools.dll" target="lib\net472\OpenRiaServices.Tools.dll" />
     <file src="..\src\bin\Release\net472\OpenRiaServices.Tools.pdb" target="lib\net472\OpenRiaServices.Tools.pdb" />
     <file src="..\src\bin\Release\net472\OpenRiaServices.Tools.xml" target="lib\net472\OpenRiaServices.Tools.xml" />
+
+    <file src="..\src\bin\Release\net6.0\OpenRiaServices.Tools.TextTemplate.dll" target="lib\net6.0\OpenRiaServices.Tools.TextTemplate.dll" />
+    <file src="..\src\bin\Release\net6.0\OpenRiaServices.Tools.TextTemplate.pdb" target="lib\net6.0\OpenRiaServices.Tools.TextTemplate.pdb" />
+    <file src="..\src\bin\Release\net6.0\OpenRiaServices.Tools.TextTemplate.xml" target="lib\net6.0\OpenRiaServices.Tools.TextTemplate.xml" />
+    <file src="..\src\bin\Release\net6.0\OpenRiaServices.Tools.dll" target="lib\net6.0\OpenRiaServices.Tools.dll" />
+    <file src="..\src\bin\Release\net6.0\OpenRiaServices.Tools.pdb" target="lib\net6.0\OpenRiaServices.Tools.pdb" />
+    <file src="..\src\bin\Release\net6.0\OpenRiaServices.Tools.xml" target="lib\net6.0\OpenRiaServices.Tools.xml" />
   </files>
 </package>

src/OpenRiaServices.Client.Web/Framework/Data/WebDomainClient.cs

@@ -109,7 +109,7 @@ public WebDomainClient(Uri serviceUri, bool usesHttps, WcfDomainClientFactory do
         private static WcfDomainClientFactory CreateDefaultDomainClientFactory()
         {
 
-#if NETSTANDARD
+#if !NETFRAMEWORK
             return new SoapDomainClientFactory();
 #else
             return new WebDomainClientFactory();

src/OpenRiaServices.Client.Web/Framework/OpenRiaServices.Client.Web.csproj

@@ -1,12 +1,12 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFrameworks>net472;netstandard2.0</TargetFrameworks>
+    <TargetFrameworks>net472;net6.0;netstandard2.0;</TargetFrameworks>
     <PackageTags>WCF;RIA;Services;RIAServices;Silverlight;OpenRiaServices</PackageTags>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
   </PropertyGroup>
 
-  <ItemGroup Condition=" '$(TargetFramework)' == 'netstandard2.0' ">
+  <ItemGroup Condition=" '$(TargetFramework)' != 'net472'  ">
     <PackageReference Include="System.ServiceModel.Http" Version="4.10.2" />
   </ItemGroup>
 
@@ -36,7 +36,7 @@
   </ItemGroup>
 
   <!-- Remove ServiceModel.Web dependent parts (binary endpoint) -->
-  <ItemGroup Condition="'$(TargetFramework)' == 'netstandard2.0'">
+  <ItemGroup Condition="'$(TargetFramework)' != 'net472'">
     <Compile Remove="Data\Behaviors\MessageUtility.cs" />
     <Compile Remove="Web\WebDomainClientFactory.cs" />
     <Compile Remove="Web\Behaviors\WebDomainClientWebHttpBehavior.cs" />

src/OpenRiaServices.Client.Web/Framework/Web/WcfDomainClientFactory.cs

@@ -10,7 +10,7 @@
 
 namespace OpenRiaServices.Client.Web
 {
-#if NETSTANDARD
+#if !NETFRAMEWORK
     /// <summary>
     /// Base class DomainClientFactories targeting WCF and creating <see cref="WebDomainClient{TContract}"/> instances.
     /// For most uses you should use a concerete implementation such as 

src/OpenRiaServices.Hosting.AspNetCore/Test/OpenRiaServices.Hosting.AspNetCore.Test/OpenRiaServices.Hosting.AspNetCore.Test.csproj

@@ -8,8 +8,8 @@
     <PackageReference Include="EntityFramework" Version="6.4.4" />
     <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="7.0.0" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.5.0" />
-    <PackageReference Include="MSTest.TestAdapter" Version="3.0.2" />
-    <PackageReference Include="MSTest.TestFramework" Version="3.0.2" />
+    <PackageReference Include="MSTest.TestAdapter" Version="2.2.10" />
+    <PackageReference Include="MSTest.TestFramework" Version="2.2.10" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\..\..\Test\Desktop\OpenRiaServices.Common.DomainServices.Test\OpenRiaServices.Common.DomainServices.Test.csproj" />

src/OpenRiaServices.Hosting.Local/Test/DomainServiceProxyTests.cs

@@ -666,28 +666,6 @@ public void DisposalTracking()
 
         #endregion // IDisposable Tests
 
-        #region MediumTrust Tests
-
-
-        [TestMethod]
-        [Ignore]
-        // TODO: [roncain] Need to work with CLR team to understand why we require SecurityPermission.Unrestricted to be
-        // run this test.  With only Internet zone permissions, OperationException throws TypeLoadException due to its
-        // GetObjectData being SecuritySafeCritical.
-        [Description("Verifies the proxies in partial trust")]
-        public void DomainServiceProxy_MediumTrust_Proxies()
-        {
-            SandBoxer.ExecuteInMediumTrust(Callback_MediumTrust_Proxies);
-        }
-
-        public static void Callback_MediumTrust_Proxies()
-        {
-            var proxy = DomainServiceProxy.Create<IMockDomainServiceContract, MockDomainService>(new MockDomainServiceContext(DomainOperationType.Query));
-            var results = proxy.GetEntities();
-        }
-
-        #endregion // MediumTrust Tests
-
         #endregion Test Methods
 
         #region Helper Methods

src/OpenRiaServices.Hosting.Wcf/Framework/Wcf/DataContractSurrogateGenerator.cs

@@ -672,39 +672,7 @@ private static ModuleBuilder CreateModuleBuilder()
             string name = string.Format(CultureInfo.InvariantCulture, "DataContractSurrogates_{0}", Guid.NewGuid().ToString());
             assemName.Name = name;
 
-            // The following code seems have been part of the original WCF Ria Services.
-            // Using it in signed build might enable medium trust support but, I haven't tested it
-#if MEDIUM_TRUST
-            // If the AppDomain is running in full trust, then put SecurityCriticalAttribute on the dynamic assembly 
-            // such that our surrogates can call into entity types that are critical (which is the default for 
-            // applications running in full trust).
-            // Otherwise, use SecurityTransparentAttribute.
-            CustomAttributeBuilder securityAttribute;
-            if (myDomain.IsFullyTrusted)
-            {
-                securityAttribute = new CustomAttributeBuilder(
-                       typeof(AllowPartiallyTrustedCallersAttribute).GetConstructor(Type.EmptyTypes),
-                       Array.Empty<object>());
-            }
-            else
-            {
-                securityAttribute = new CustomAttributeBuilder(
-                        typeof(SecurityTransparentAttribute).GetConstructor(Type.EmptyTypes),
-                        Array.Empty<object>());
-            }
-
-            AssemblyBuilder assemblyBuilder = myDomain.DefineDynamicAssembly(
-                assemName,
-                AssemblyBuilderAccess.Run,
-                new CustomAttributeBuilder[] 
-                {
-                    securityAttribute,
-                    new CustomAttributeBuilder(
-                        typeof(SecurityRulesAttribute).GetConstructor(new Type[] { typeof(SecurityRuleSet) }),
-                        new object[] { SecurityRuleSet.Level2 })
-                },
-                SecurityContextSource.CurrentAppDomain);
-#elif NET5_0_OR_GREATER
+#if NET6_0_OR_GREATER
 // Dev note: the SecurityContextSource.CurrentAppDomain is new in CLR 4.0
             // and permits the assembly builder to inherit the security permissions of the
             // app domain. - CDB Removed, Medium trust support removed

src/OpenRiaServices.Hosting.Wcf/Framework/Wcf/MessageEncoders/PoxBinaryMessageEncodingBindingElement.cs

@@ -96,7 +96,7 @@ public override bool CanBuildChannelFactory<TChannel>(BindingContext context)
             return context.CanBuildInnerChannelFactory<TChannel>();
         }
 
-#if !SILVERLIGHT && !NETSTANDARD2_0
+#if NETFRAMEWORK
         public override IChannelListener<TChannel> BuildChannelListener<TChannel>(BindingContext context)
         {
             if (context == null)

src/OpenRiaServices.Hosting.Wcf/Test/Data/DomainServiceHostTest.cs

@@ -122,22 +122,6 @@ private THost CreateHost<THost, TService>(params Uri[] baseAddresses) where THos
         {
             return (THost)Activator.CreateInstance(typeof(THost), typeof(TService), baseAddresses);
         }
-
-#if !MEDIUM_TRUST
-
-        [Ignore]
-#endif
-        [TestMethod]
-        [Description("Verifies the DomainServicesSection can be created in partial trust")]
-        public void DomainServiceHost_MediumTrust_DomainServicesSection()
-        {
-            SandBoxer.ExecuteInMediumTrust(Callback_MediumTrust_DomainServicesSection);
-        }
-
-        public static void Callback_MediumTrust_DomainServicesSection()
-        {
-            new DomainServicesSection();
-        }
     }
 
     [OpenRiaServices.Server.EnableClientAccess]

src/OpenRiaServices.Server.UnitTesting/Test/OpenRiaServices.Server.UnitTesting.Test.csproj

@@ -9,8 +9,8 @@
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.5.0" />
   </ItemGroup>
   <ItemGroup Condition=" '$(TargetFramework)' != 'net472' ">
-    <PackageReference Include="MSTest.TestAdapter" Version="3.0.2" />
-    <PackageReference Include="MSTest.TestFramework" Version="3.0.2" />
+    <PackageReference Include="MSTest.TestAdapter" Version="2.2.10" />
+    <PackageReference Include="MSTest.TestFramework" Version="2.2.10" />
   </ItemGroup>
   <ItemGroup Condition=" '$(TargetFramework)' == 'net472' ">
     <Reference Include="Microsoft.VisualStudio.QualityTools.UnitTestFramework, Version=10.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">

src/OpenRiaServices.Server/Test/DomainServiceDescriptionTest.cs

@@ -1594,119 +1594,6 @@ public void DomainServiceDescription_InterfaceAttributes()
             }
         }
 
-#if MEDIUM_TRUST
-
-        [TestMethod]
-        [Description("Verifies the medium trust sandbox calls back as SecurityTransparent")]
-        public void DomainServiceDescription_MediumTrust_Verify_Sandbox_IsTransparent()
-        {
-            Assert.IsFalse(typeof(DomainServiceDescriptionTest).IsSecurityTransparent, "Expected our unit test to be not transparent");
-            SandBoxer.ExecuteInMediumTrust(Callback_Verify_Sandbox_Transparent);
-        }
-
-        public static void Callback_Verify_Sandbox_Transparent()
-        {
-            Assert.IsTrue(typeof(DomainServiceDescriptionTest).IsSecurityTransparent, "Expected our unit test to be transparent");
-        }
-
-        [TestMethod]
-        [Description("Verifies the medium trust sandbox assert and parameter mechanisms are handled properly")]
-        public void DomainServiceDescription_MediumTrust_Verify_SandboxAssertMechanism()
-        {
-            AssertFailedException expectedException = null;
-            AssertFailedException actualException = null;
-
-            // Capture a real Assert.Fail exception for comparison
-            try
-            {
-                Assert.Fail("oops");
-            }
-            catch (AssertFailedException afe)
-            {
-                expectedException = afe;
-            }
-
-            // Now go do that in partial trust
-            try
-            {
-                SandBoxer.ExecuteInMediumTrust(Callback_Verify_SandboxAssertException, "oops");
-                Assert.Fail("SandBox mechanism failed to throw");
-            }
-            catch (AssertFailedException afe)
-            {
-                actualException = afe;
-            }
-
-            Assert.AreEqual(expectedException.Message, actualException.Message, "SandBoxAssertException did not work properly.");
-        }
-
-        public static void Callback_Verify_SandboxAssertException(string message)
-        {
-            Assert.Fail(message);
-        }
-
-        // TODO: [roncain] Investigating why this succeeds
-        //[TestMethod]
-        //[Description("Private reflection should not work in partial trust")]
-        //public void DomainServiceDescription_MediumTrust_PrivateReflection_Throws()
-        //{
-        //    MethodInfo mInfo = typeof(DomainServiceDescriptionTest).GetMethod("AFineAndPrivatePlace", BindingFlags.Static | BindingFlags.NonPublic);
-        //    Assert.IsNotNull(mInfo, "Expected to find AFineAndPrivatePlace method");
-        //    SandBoxer.ExecuteInMediumTrust(Callback_Verify_Sandbox_PrivateReflection);
-        //}
-
-        //public static void Callback_Verify_Sandbox_PrivateReflection()
-        //{
-        //    try
-        //    {
-        //        MethodInfo mInfo = typeof(DomainServiceDescriptionTest).GetMethod("AFineAndPrivatePlace", BindingFlags.Static | BindingFlags.NonPublic);
-        //        SandBoxer.Assert(mInfo == null, "Did not expect private reflection to succeed");
-        //    }
-        //    catch (SecurityException)
-        //    {
-        //    }
-        // }
-        //private static void AFineAndPrivatePlace() { }
-
-        [TestMethod]
-        [Description("TypeDescriptor.AddProvider should fail")]
-        public void DomainServiceDescription_MediumTrust_TdpRegistrationFails()
-        {
-            SandBoxer.ExecuteInMediumTrust(Callback_TdpRegistrationFail);
-        }
-
-        public static void Callback_TdpRegistrationFail()
-        {
-            try
-            {
-                Mock_CG_SimpleEntity entity = new Mock_CG_SimpleEntity();
-                RegisterProvider(entity);
-                Assert.Fail("Expected TDP registration to throw SecurityException");
-            }
-            catch (SecurityException)
-            {
-            }
-        }
-
-        private static void RegisterProvider(object instance)
-        {
-            TypeDescriptor.AddProvider(TypeDescriptor.GetProvider(instance), instance);
-        }
-
-        [TestMethod]
-        [Description("Verifies DomainServiceDescription.GetDescription works in medium trust")]
-        public void DomainServiceDescription_MediumTrust_GetDescription()
-        {
-            SandBoxer.ExecuteInMediumTrust(Callback_BasicDescriptionSucceeds);
-        }
-
-        public static void Callback_BasicDescriptionSucceeds()
-        {
-            DomainServiceDescription dsd = DomainServiceDescription.GetDescription(typeof(DomainService_Basic));
-            Assert.IsNotNull(dsd, "Expected nominal DomainServiceDescription to return non-null instance");
-        }
-#endif
-
         [TestMethod]
         [Description("DomainServiceDescription's internal cache should be thread-safe")]
         public void DomainServiceDescription_MultipleThreads()

src/OpenRiaServices.Tools.CodeGenTask/ClientCodeGenerationOptionsBinder.cs

@@ -0,0 +1,55 @@
+using System.CommandLine;
+using System.CommandLine.Binding;
+
+namespace OpenRiaServices.Tools.CodeGenTask;
+
+/// <summary>
+/// Binder class for <see cref="ClientCodeGenerationOptions"/>. Used to bind arguments to handlers
+/// </summary>
+public class ClientCodeGenerationOptionsBinder : BinderBase<ClientCodeGenerationOptions>
+{
+    private readonly Option<string> _language;
+    private readonly Option<string> _clientFrameworkPath;
+    private readonly Option<string> _serverProjectPath;
+    private readonly Option<string> _clientProjectPath;
+    private readonly Option<string> _clientRootNamespace;
+    private readonly Option<string> _serverRootNamespace;
+    private readonly Option<bool> _isApplicationContextGenerationEnabled;
+    private readonly Option<TargetPlatform> _clientProjectTargetPlatform;
+    private readonly Option<bool> _useFullTypeNames;
+
+    /// <summary>
+    /// Constructor that sets all arguments
+    /// </summary>
+    public ClientCodeGenerationOptionsBinder(Option<string> language, Option<string> clientFrameworkPath, Option<string> serverProjectPath, Option<string> clientProjectPath, Option<string> clientRootNamespace, Option<string> serverRootNamespace, Option<bool> isApplicationContextGenerationEnabled, Option<TargetPlatform> clientProjectTargetPlatform, Option<bool> useFullTypeNames)
+    {
+        _language = language;
+        _clientFrameworkPath = clientFrameworkPath;
+        _serverProjectPath = serverProjectPath;
+        _clientProjectPath = clientProjectPath;
+        _clientRootNamespace = clientRootNamespace;
+        _serverRootNamespace = serverRootNamespace;
+        _isApplicationContextGenerationEnabled = isApplicationContextGenerationEnabled;
+        _clientProjectTargetPlatform = clientProjectTargetPlatform;
+        _useFullTypeNames = useFullTypeNames;
+    }
+
+    /// <summary>
+    /// Parse result in binding context to create and return <see cref="ClientCodeGenerationOptions"/>
+    /// </summary>
+    protected override ClientCodeGenerationOptions GetBoundValue(BindingContext bindingContext)
+    {
+        return new ClientCodeGenerationOptions
+        {
+            Language = bindingContext.ParseResult.GetValueForOption(_language),
+            ClientFrameworkPath = bindingContext.ParseResult.GetValueForOption(_clientFrameworkPath),
+            ServerProjectPath = bindingContext.ParseResult.GetValueForOption(_serverProjectPath),
+            ClientProjectPath = bindingContext.ParseResult.GetValueForOption(_clientProjectPath),
+            ClientRootNamespace = bindingContext.ParseResult.GetValueForOption(_clientRootNamespace),
+            ServerRootNamespace = bindingContext.ParseResult.GetValueForOption(_serverRootNamespace),
+            IsApplicationContextGenerationEnabled = bindingContext.ParseResult.GetValueForOption(_isApplicationContextGenerationEnabled),
+            ClientProjectTargetPlatform = bindingContext.ParseResult.GetValueForOption(_clientProjectTargetPlatform),
+            UseFullTypeNames = bindingContext.ParseResult.GetValueForOption(_useFullTypeNames),
+        };
+    }
+}