Merge branch 'feature/anotherCloningVariant' into develop

force-net · force-net · commit d94fac159e49 · 2016-02-09T00:00:24.000+03:00
diff --git a/DeepCloner.Tests/ArraysSpec.cs b/DeepCloner.Tests/ArraysSpec.cs
@@ -5,9 +5,15 @@
 
 namespace Force.DeepCloner.Tests
 {
-	[TestFixture]
-	public class ArraysSpec
+	[TestFixture(false)]
+	[TestFixture(true)]
+	public class ArraysSpec : BaseTest
 	{
+		public ArraysSpec(object isSafeInit)
+			: base((bool)isSafeInit)
+		{
+		}
+
 		[Test]
 		public void IntArray_Should_Be_Cloned()
 		{
diff --git a/DeepCloner.Tests/BaseTest.cs b/DeepCloner.Tests/BaseTest.cs
@@ -0,0 +1,20 @@
+﻿using System.Reflection;
+
+using Force.DeepCloner.Helpers;
+
+namespace Force.DeepCloner.Tests
+{
+	public class BaseTest
+	{
+		public BaseTest(bool isSafeInit)
+		{
+			SwitchTo(isSafeInit);
+		}
+
+		public static void SwitchTo(bool isSafeInit)
+		{
+			typeof(ShallowObjectCloner).GetMethod("SwitchTo", BindingFlags.NonPublic | BindingFlags.Static)
+									.Invoke(null, new object[] { isSafeInit });
+		}
+	}
+}
diff --git a/DeepCloner.Tests/CloneExtensionsSpec.cs b/DeepCloner.Tests/CloneExtensionsSpec.cs
@@ -4,9 +4,15 @@
 
 namespace Force.DeepCloner.Tests
 {
-	[TestFixture]
-	public class CloneExtensionsSpec
+	[TestFixture(false)]
+	[TestFixture(true)]
+	public class CloneExtensionsSpec : BaseTest
 	{
+		public CloneExtensionsSpec(bool isSafeInit)
+			: base(isSafeInit)
+		{
+		}
+
 		public class C1
 		{
 			public int X { get; set; }
diff --git a/DeepCloner.Tests/ConstructorsSpec.cs b/DeepCloner.Tests/ConstructorsSpec.cs
@@ -4,9 +4,15 @@
 
 namespace Force.DeepCloner.Tests
 {
-	[TestFixture]
-	public class ConstructorsSpec
+	[TestFixture(false)]
+	[TestFixture(true)]
+	public class ConstructorsSpec : BaseTest
 	{
+		public ConstructorsSpec(bool isSafeInit)
+			: base(isSafeInit)
+		{
+		}
+
 		public class T1
 		{
 			private T1()
diff --git a/DeepCloner.Tests/DeepCloner.Tests.csproj b/DeepCloner.Tests/DeepCloner.Tests.csproj
@@ -49,6 +49,7 @@
   </ItemGroup>
   <ItemGroup>
     <Compile Include="ArraysSpec.cs" />
+    <Compile Include="BaseTest.cs" />
     <Compile Include="CloneExtensionsSpec.cs" />
     <Compile Include="ConstructorsSpec.cs" />
     <Compile Include="GenericsSpec.cs" />
diff --git a/DeepCloner.Tests/GenericsSpec.cs b/DeepCloner.Tests/GenericsSpec.cs
@@ -4,9 +4,15 @@
 
 namespace Force.DeepCloner.Tests
 {
-	[TestFixture]
-	public class GenericsSpec
+	[TestFixture(false)]
+	[TestFixture(true)]
+	public class GenericsSpec : BaseTest
 	{
+		public GenericsSpec(bool isSafeInit)
+			: base(isSafeInit)
+		{
+		}
+
 		[Test]
 		public void Tuple_Should_Be_Cloned()
 		{
diff --git a/DeepCloner.Tests/InheritanceSpec.cs b/DeepCloner.Tests/InheritanceSpec.cs
@@ -5,9 +5,15 @@
 
 namespace Force.DeepCloner.Tests
 {
-	[TestFixture]
-	public class InheritanceSpec
+	[TestFixture(false)]
+	[TestFixture(true)]
+	public class InheritanceSpec : BaseTest
 	{
+		public InheritanceSpec(bool isSafeInit)
+			: base(isSafeInit)
+		{
+		}
+
 		public class C1 : IDisposable
 		{
 			[SuppressMessage("StyleCop.CSharp.MaintainabilityRules", "SA1401:FieldsMustBePrivate", Justification = "Reviewed. Suppression is OK here.")]
diff --git a/DeepCloner.Tests/LoopCheckSpec.cs b/DeepCloner.Tests/LoopCheckSpec.cs
@@ -2,9 +2,15 @@
 
 namespace Force.DeepCloner.Tests
 {
-	[TestFixture]
-	public class LoopCheckSpec
+	[TestFixture(false)]
+	[TestFixture(true)]
+	public class LoopCheckSpec : BaseTest
 	{
+		public LoopCheckSpec(bool isSafeInit)
+			: base(isSafeInit)
+		{
+		}
+
 		public class C1
 		{
 			public int F { get; set; }
diff --git a/DeepCloner.Tests/PerformanceSpec.cs b/DeepCloner.Tests/PerformanceSpec.cs
@@ -59,8 +59,12 @@ private T CloneViaFormatter<T>(T obj)
 		}
 
 		[Test, Ignore("Manual")]
-		public void Test_Construct_Variants()
+		[TestCase(false)]
+		[TestCase(true)]
+		public void Test_Construct_Variants(bool isSafe)
 		{
+			// we cache cloners for type, so, this only variant with separate run
+			BaseTest.SwitchTo(isSafe);
 			var c1 = new C1 { V1 = 1 };
 			// warm up
 			for (var i = 0; i < 1000; i++) ManualDeepClone(c1);
@@ -137,6 +141,9 @@ public void Test_Shallow_Variants()
 			// warm up
 			for (var i = 0; i < 1000; i++) ManualShallowClone(c1);
 			for (var i = 0; i < 1000; i++) c1.Clone();
+			BaseTest.SwitchTo(false);
+			for (var i = 0; i < 1000; i++) c1.ShallowClone();
+			BaseTest.SwitchTo(true);
 			for (var i = 0; i < 1000; i++) c1.ShallowClone();
 			for (var i = 0; i < 1000; i++) c1.GetClone();
 
@@ -150,10 +157,17 @@ public void Test_Shallow_Variants()
 
 			for (var i = 0; i < 1000000; i++) c1.Clone();
 			Console.WriteLine("Auto Internal: " + sw.ElapsedMilliseconds);
-			sw.Restart();
+			sw.Reset();
+			BaseTest.SwitchTo(false);
+			sw.Start();
+			for (var i = 0; i < 1000000; i++) c1.ShallowClone();
+			Console.WriteLine("Shallow Unsafe: " + sw.ElapsedMilliseconds);
+			sw.Reset();
 
+			BaseTest.SwitchTo(true);
+			sw.Start();
 			for (var i = 0; i < 1000000; i++) c1.ShallowClone();
-			Console.WriteLine("Shallow: " + sw.ElapsedMilliseconds);
+			Console.WriteLine("Shallow Safe: " + sw.ElapsedMilliseconds);
 			sw.Restart();
 
 			for (var i = 0; i < 1000000; i++) c1.GetClone(CloningFlags.Shallow);
diff --git a/DeepCloner.Tests/PermissionSpec.cs b/DeepCloner.Tests/PermissionSpec.cs
@@ -25,14 +25,19 @@ public void EnsurePermission()
 			// assembly execute
 			permissions.AddPermission(new SecurityPermission(SecurityPermissionFlag.Execution));
 
-			permissions.AddPermission(new ReflectionPermission(PermissionState.Unrestricted));
-
-			permissions.AddPermission(new SecurityPermission(PermissionState.Unrestricted));
+			permissions.AddPermission(new ReflectionPermission(ReflectionPermissionFlag.RestrictedMemberAccess | ReflectionPermissionFlag.MemberAccess));
+			// permissions.AddPermission(new ReflectionPermission(ReflectionPermissionFlag.RestrictedMemberAccess));
 
 			var test = AppDomain.CreateDomain("sandbox", null, setup, permissions);
 
 			var instance = (Executor)test.CreateInstanceFromAndUnwrap(this.GetType().Assembly.Location, typeof(Executor).FullName);
 			instance.DoShallowClone();
+			instance.DoDeepClone();
+		}
+
+		public class Test
+		{
+			public int X { get; set; }
 		}
 
 		public class Executor : MarshalByRefObject
@@ -44,7 +49,7 @@ public void DoDeepClone()
 
 			 public void DoShallowClone()
 			 {
-				 new List<int> { 1, 2, 3 }.ShallowClone();
+				new List<int> { 1, 2, 3 }.ShallowClone();
 			 }
 		}
 	}
diff --git a/DeepCloner.Tests/ShallowClonerSpec.cs b/DeepCloner.Tests/ShallowClonerSpec.cs
@@ -6,9 +6,15 @@
 
 namespace Force.DeepCloner.Tests
 {
-	[TestFixture]
-	public class ShallowClonerSpec
+	[TestFixture(false)]
+	[TestFixture(true)]
+	public class ShallowClonerSpec : BaseTest
 	{
+		public ShallowClonerSpec(bool isSafeInit)
+			: base(isSafeInit)
+		{
+		}
+
 		[Test]
 		public void SimpleObject_Should_Be_Cloned()
 		{
@@ -94,5 +100,15 @@ public void Primitive_Should_Be_Cloned()
 			Assert.That(((object)null).ShallowClone(), Is.Null);
 			Assert.That(3.ShallowClone(), Is.EqualTo(3));
 		}
+
+		[Test]
+		public void Array_Should_Be_Cloned()
+		{
+			var a = new[] { 3, 4 };
+			var clone = a.ShallowClone();
+			Assert.That(clone.Length, Is.EqualTo(2));
+			Assert.That(clone[0], Is.EqualTo(3));
+			Assert.That(clone[1], Is.EqualTo(4));
+		}
 	}
 }
diff --git a/DeepCloner.Tests/SimpleObjectSpec.cs b/DeepCloner.Tests/SimpleObjectSpec.cs
@@ -7,9 +7,15 @@
 
 namespace Force.DeepCloner.Tests
 {
-	[TestFixture]
-	public class SimpleObjectSpec
+	[TestFixture(true)]
+	[TestFixture(false)]
+	public class SimpleObjectSpec : BaseTest
 	{
+		public SimpleObjectSpec(bool isSafeInit)
+			: base(isSafeInit)
+		{
+		}
+
 		[Test]
 		public void SimpleObject_Should_Be_Cloned()
 		{
diff --git a/DeepCloner.Tests/StandardTypesSpec.cs b/DeepCloner.Tests/StandardTypesSpec.cs
@@ -9,9 +9,15 @@
 
 namespace Force.DeepCloner.Tests
 {
-	[TestFixture]
-	public class StandardTypesSpec
+	[TestFixture(false)]
+	[TestFixture(true)]
+	public class StandardTypesSpec : BaseTest
 	{
+		public StandardTypesSpec(bool isSafeInit)
+			: base(isSafeInit)
+		{
+		}
+
 		[Test]
 		public void StandardTypes_Should_Be_Cloned()
 		{
diff --git a/DeepCloner.nuspec b/DeepCloner.nuspec
@@ -3,7 +3,7 @@
   <metadata>
     <id>DeepCloner</id>
     <title>DeepCloner</title>
-    <version>0.8.2</version>
+    <version>0.9.0</version>
     <authors>force</authors>
     <owners>force</owners>
     <licenseUrl>https://github.com/force-net/DeepCloner/blob/develop/LICENSE</licenseUrl>
@@ -14,6 +14,7 @@
     <releaseNotes>
 Fixed an issue with handling references to arrays
 Added support for multidimensional arrays and non-zero-based arrays
+Added fallback for non-fulltrust code through expressions
     </releaseNotes>
     <copyright>Copyright by Force 2016</copyright>
     <tags>.NET shallow deep clone</tags>
diff --git a/DeepCloner/DeepCloner.csproj b/DeepCloner/DeepCloner.csproj
@@ -31,7 +31,7 @@
     <DocumentationFile>bin\Release\DeepCloner.xml</DocumentationFile>
   </PropertyGroup>
   <PropertyGroup>
-    <SignAssembly>true</SignAssembly>
+    <SignAssembly>false</SignAssembly>
   </PropertyGroup>
   <PropertyGroup>
     <DelaySign>true</DelaySign>
@@ -50,13 +50,14 @@
   </ItemGroup>
   <ItemGroup>
     <Compile Include="DeepClonerExtensions.cs" />
+    <Compile Include="Helpers\DeepClonerExprGenerator.cs" />
     <Compile Include="Helpers\DeepClonerCache.cs" />
     <Compile Include="Helpers\DeepClonerGenerator.cs" />
     <Compile Include="Helpers\DeepClonerMsilGenerator.cs" />
     <Compile Include="Helpers\DeepClonerSafeTypes.cs" />
     <Compile Include="Helpers\DeepCloneState.cs" />
     <Compile Include="Helpers\ShallowClonerGenerator.cs" />
-    <Compile Include="Helpers\ShallowSafeObjectCloner.cs" />
+    <Compile Include="Helpers\ShallowObjectCloner.cs" />
     <Compile Include="Helpers\TypeCreationHelper.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
   </ItemGroup>
diff --git a/DeepCloner/DeepClonerExtensions.cs b/DeepCloner/DeepClonerExtensions.cs
@@ -1,4 +1,5 @@
-﻿using System.Security;
+﻿using System;
+using System.Security;
 
 using Force.DeepCloner.Helpers;
 
@@ -12,7 +13,6 @@ public static class DeepClonerExtensions
 		/// <summary>
 		/// Performs deep (full) copy of object and related graph
 		/// </summary>
-		// [PermissionSetAttribute(SecurityAction.Demand, Name = "FullTrust")] // <-- this attribute slowers execution
 		public static T DeepClone<T>(this T obj)
 		{
 			return DeepClonerGenerator.CloneObject(obj);
@@ -21,7 +21,6 @@ public static T DeepClone<T>(this T obj)
 		/// <summary>
 		/// Performs shallow (only new object returned, without cloning of dependencies) copy of object
 		/// </summary>
-		// [PermissionSet(SecurityAction.Demand, Name = "FullTrust")] // <-- this attribute slowers execution
 		public static T ShallowClone<T>(this T obj)
 		{
 			return ShallowClonerGenerator.CloneObject(obj);
@@ -31,7 +30,7 @@ static DeepClonerExtensions()
 		{
 			if (!PermissionCheck())
 			{
-				throw new SecurityException("DeepCloner should have enough permissions to run. FullTrust set is enough to run.");
+				throw new SecurityException("DeepCloner should have enough permissions to run. Grant FullTrust or Reflection permission.");
 			}
 		}
 
@@ -47,6 +46,10 @@ private static bool PermissionCheck()
 			{
 				return false;
 			}
+			catch (MemberAccessException)
+			{
+				return false;
+			}
 			
 			return true;
 		}
diff --git a/DeepCloner/Helpers/DeepClonerExprGenerator.cs b/DeepCloner/Helpers/DeepClonerExprGenerator.cs
diff --git a/DeepCloner/Helpers/DeepClonerGenerator.cs b/DeepCloner/Helpers/DeepClonerGenerator.cs
diff --git a/DeepCloner/Helpers/DeepClonerMsilGenerator.cs b/DeepCloner/Helpers/DeepClonerMsilGenerator.cs
diff --git a/DeepCloner/Helpers/ShallowClonerGenerator.cs b/DeepCloner/Helpers/ShallowClonerGenerator.cs
diff --git a/DeepCloner/Helpers/ShallowObjectCloner.cs b/DeepCloner/Helpers/ShallowObjectCloner.cs
diff --git a/DeepCloner/Helpers/ShallowSafeObjectCloner.cs b/DeepCloner/Helpers/ShallowSafeObjectCloner.cs
diff --git a/DeepCloner/Properties/AssemblyInfo.cs b/DeepCloner/Properties/AssemblyInfo.cs
diff --git a/README.md b/README.md

Original file line number	Diff line number	Diff line change
`@@ -5,9 +5,15 @@`
`5`	`5`
`6`	`6`	`namespace Force.DeepCloner.Tests`
`7`	`7`	`{`
`8`		`- [TestFixture]`
`9`		`- public class ArraysSpec`
	`8`	`+ [TestFixture(false)]`
	`9`	`+ [TestFixture(true)]`
	`10`	`+ public class ArraysSpec : BaseTest`
`10`	`11`	`{`
	`12`	`+ public ArraysSpec(object isSafeInit)`
	`13`	`+ : base((bool)isSafeInit)`
	`14`	`+ {`
	`15`	`+ }`
	`16`	`+`
`11`	`17`	`[Test]`
`12`	`18`	`public void IntArray_Should_Be_Cloned()`
`13`	`19`	`{`
Original file line number	Diff line number	Diff line change
`@@ -4,9 +4,15 @@`
`4`	`4`
`5`	`5`	`namespace Force.DeepCloner.Tests`
`6`	`6`	`{`
`7`		`- [TestFixture]`
`8`		`- public class CloneExtensionsSpec`
	`7`	`+ [TestFixture(false)]`
	`8`	`+ [TestFixture(true)]`
	`9`	`+ public class CloneExtensionsSpec : BaseTest`
`9`	`10`	`{`
	`11`	`+ public CloneExtensionsSpec(bool isSafeInit)`
	`12`	`+ : base(isSafeInit)`
	`13`	`+ {`
	`14`	`+ }`
	`15`	`+`
`10`	`16`	`public class C1`
`11`	`17`	`{`
`12`	`18`	`public int X { get; set; }`
Original file line number	Diff line number	Diff line change
`@@ -2,9 +2,15 @@`
`2`	`2`
`3`	`3`	`namespace Force.DeepCloner.Tests`
`4`	`4`	`{`
`5`		`- [TestFixture]`
`6`		`- public class LoopCheckSpec`
	`5`	`+ [TestFixture(false)]`
	`6`	`+ [TestFixture(true)]`
	`7`	`+ public class LoopCheckSpec : BaseTest`
`7`	`8`	`{`
	`9`	`+ public LoopCheckSpec(bool isSafeInit)`
	`10`	`+ : base(isSafeInit)`
	`11`	`+ {`
	`12`	`+ }`
	`13`	`+`
`8`	`14`	`public class C1`
`9`	`15`	`{`
`10`	`16`	`public int F { get; set; }`
Original file line number	Diff line number	Diff line change
`@@ -25,14 +25,19 @@ public void EnsurePermission()`
`25`	`25`	`// assembly execute`
`26`	`26`	`permissions.AddPermission(new SecurityPermission(SecurityPermissionFlag.Execution));`
`27`	`27`
`28`		`- permissions.AddPermission(new ReflectionPermission(PermissionState.Unrestricted));`
`29`		`-`
`30`		`- permissions.AddPermission(new SecurityPermission(PermissionState.Unrestricted));`
	`28`	`+ permissions.AddPermission(new ReflectionPermission(ReflectionPermissionFlag.RestrictedMemberAccess \| ReflectionPermissionFlag.MemberAccess));`
	`29`	`+ // permissions.AddPermission(new ReflectionPermission(ReflectionPermissionFlag.RestrictedMemberAccess));`
`31`	`30`
`32`	`31`	`var test = AppDomain.CreateDomain("sandbox", null, setup, permissions);`
`33`	`32`
`34`	`33`	`var instance = (Executor)test.CreateInstanceFromAndUnwrap(this.GetType().Assembly.Location, typeof(Executor).FullName);`
`35`	`34`	`instance.DoShallowClone();`
	`35`	`+ instance.DoDeepClone();`
	`36`	`+ }`
	`37`	`+`
	`38`	`+ public class Test`
	`39`	`+ {`
	`40`	`+ public int X { get; set; }`
`36`	`41`	`}`
`37`	`42`
`38`	`43`	`public class Executor : MarshalByRefObject`
`@@ -44,7 +49,7 @@ public void DoDeepClone()`
`44`	`49`
`45`	`50`	`public void DoShallowClone()`
`46`	`51`	`{`
`47`		`- new List<int> { 1, 2, 3 }.ShallowClone();`
	`52`	`+ new List<int> { 1, 2, 3 }.ShallowClone();`
`48`	`53`	`}`
`49`	`54`	`}`
`50`	`55`	`}`
Original file line number	Diff line number	Diff line change
`@@ -6,9 +6,15 @@`
`6`	`6`
`7`	`7`	`namespace Force.DeepCloner.Tests`
`8`	`8`	`{`
`9`		`- [TestFixture]`
`10`		`- public class ShallowClonerSpec`
	`9`	`+ [TestFixture(false)]`
	`10`	`+ [TestFixture(true)]`
	`11`	`+ public class ShallowClonerSpec : BaseTest`
`11`	`12`	`{`
	`13`	`+ public ShallowClonerSpec(bool isSafeInit)`
	`14`	`+ : base(isSafeInit)`
	`15`	`+ {`
	`16`	`+ }`
	`17`	`+`
`12`	`18`	`[Test]`
`13`	`19`	`public void SimpleObject_Should_Be_Cloned()`
`14`	`20`	`{`
`@@ -94,5 +100,15 @@ public void Primitive_Should_Be_Cloned()`
`94`	`100`	`Assert.That(((object)null).ShallowClone(), Is.Null);`
`95`	`101`	`Assert.That(3.ShallowClone(), Is.EqualTo(3));`
`96`	`102`	`}`
	`103`	`+`
	`104`	`+ [Test]`
	`105`	`+ public void Array_Should_Be_Cloned()`
	`106`	`+ {`
	`107`	`+ var a = new[] { 3, 4 };`
	`108`	`+ var clone = a.ShallowClone();`
	`109`	`+ Assert.That(clone.Length, Is.EqualTo(2));`
	`110`	`+ Assert.That(clone[0], Is.EqualTo(3));`
	`111`	`+ Assert.That(clone[1], Is.EqualTo(4));`
	`112`	`+ }`
`97`	`113`	`}`
`98`	`114`	`}`
Original file line number	Diff line number	Diff line change
`@@ -7,9 +7,15 @@`
`7`	`7`
`8`	`8`	`namespace Force.DeepCloner.Tests`
`9`	`9`	`{`
`10`		`- [TestFixture]`
`11`		`- public class SimpleObjectSpec`
	`10`	`+ [TestFixture(true)]`
	`11`	`+ [TestFixture(false)]`
	`12`	`+ public class SimpleObjectSpec : BaseTest`
`12`	`13`	`{`
	`14`	`+ public SimpleObjectSpec(bool isSafeInit)`
	`15`	`+ : base(isSafeInit)`
	`16`	`+ {`
	`17`	`+ }`
	`18`	`+`
`13`	`19`	`[Test]`
`14`	`20`	`public void SimpleObject_Should_Be_Cloned()`
`15`	`21`	`{`
Original file line number	Diff line number	Diff line change
`@@ -9,9 +9,15 @@`
`9`	`9`
`10`	`10`	`namespace Force.DeepCloner.Tests`
`11`	`11`	`{`
`12`		`- [TestFixture]`
`13`		`- public class StandardTypesSpec`
	`12`	`+ [TestFixture(false)]`
	`13`	`+ [TestFixture(true)]`
	`14`	`+ public class StandardTypesSpec : BaseTest`
`14`	`15`	`{`
	`16`	`+ public StandardTypesSpec(bool isSafeInit)`
	`17`	`+ : base(isSafeInit)`
	`18`	`+ {`
	`19`	`+ }`
	`20`	`+`
`15`	`21`	`[Test]`
`16`	`22`	`public void StandardTypes_Should_Be_Cloned()`
`17`	`23`	`{`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,5 @@`
`1`		`-using System.Security;`
	`1`	`+using System;`
	`2`	`+using System.Security;`
`2`	`3`
`3`	`4`	`using Force.DeepCloner.Helpers;`
`4`	`5`
`@@ -12,7 +13,6 @@ public static class DeepClonerExtensions`
`12`	`13`	`/// <summary>`
`13`	`14`	`/// Performs deep (full) copy of object and related graph`
`14`	`15`	`/// </summary>`
`15`		`- // [PermissionSetAttribute(SecurityAction.Demand, Name = "FullTrust")] // <-- this attribute slowers execution`
`16`	`16`	`public static T DeepClone<T>(this T obj)`
`17`	`17`	`{`
`18`	`18`	`return DeepClonerGenerator.CloneObject(obj);`
`@@ -21,7 +21,6 @@ public static T DeepClone<T>(this T obj)`
`21`	`21`	`/// <summary>`
`22`	`22`	`/// Performs shallow (only new object returned, without cloning of dependencies) copy of object`
`23`	`23`	`/// </summary>`
`24`		`- // [PermissionSet(SecurityAction.Demand, Name = "FullTrust")] // <-- this attribute slowers execution`
`25`	`24`	`public static T ShallowClone<T>(this T obj)`
`26`	`25`	`{`
`27`	`26`	`return ShallowClonerGenerator.CloneObject(obj);`
`@@ -31,7 +30,7 @@ static DeepClonerExtensions()`
`31`	`30`	`{`
`32`	`31`	`if (!PermissionCheck())`
`33`	`32`	`{`
`34`		`- throw new SecurityException("DeepCloner should have enough permissions to run. FullTrust set is enough to run.");`
	`33`	`+ throw new SecurityException("DeepCloner should have enough permissions to run. Grant FullTrust or Reflection permission.");`
`35`	`34`	`}`
`36`	`35`	`}`
`37`	`36`
`@@ -47,6 +46,10 @@ private static bool PermissionCheck()`
`47`	`46`	`{`
`48`	`47`	`return false;`
`49`	`48`	`}`
	`49`	`+ catch (MemberAccessException)`
	`50`	`+ {`
	`51`	`+ return false;`
	`52`	`+ }`
`50`	`53`
`51`	`54`	`return true;`
`52`	`55`	`}`