Cleanup, beta 3 preparation

andrewvk · andrewvk · commit 3e4a95b22ba8 · 2019-03-13T21:53:01.000+03:00
diff --git a/Build/Jetbrains.Annotations.cs b/Build/Jetbrains.Annotations.cs
diff --git a/Build/Props/CodeJam.Default.props b/Build/Props/CodeJam.Default.props
@@ -10,7 +10,7 @@
 		<AssemblyOriginatorKeyFile>..\Build\CodeJam.snk</AssemblyOriginatorKeyFile>
 
 		<Version>2.2.0.0</Version>
-		<PackageVersion>2.2.0-beta2</PackageVersion>
+		<PackageVersion>2.2.0-beta3</PackageVersion>
 		<PackageOutputPath>..\_Results</PackageOutputPath>
 
 		<Company>RSDN</Company>
diff --git a/CodeJam.Main/CodeJam.Main.csproj.DotSettings b/CodeJam.Main/CodeJam.Main.csproj.DotSettings
@@ -17,7 +17,7 @@
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=strings/@EntryIndexedValue">False</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=structures/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=structures_005Coption/@EntryIndexedValue">True</s:Boolean>
-	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=targeting/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=targeting/@EntryIndexedValue">False</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=targeting_005Cfw35_005Cvaluetuple/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=targeting_005Cfw40_005Cvaluetuple/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=targeting_005Cnet40_005Cvaluetuple/@EntryIndexedValue">True</s:Boolean>
diff --git a/CodeJam.Main/Collections/Array/ArrayExtensions.Infix.cs b/CodeJam.Main/Collections/Array/ArrayExtensions.Infix.cs
@@ -1,7 +1,8 @@
 ﻿using System;
-using System.Linq;
+
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
+using System.Linq;
 
 using JetBrains.Annotations;
 
diff --git a/CodeJam.Main/Collections/Dictionary/LazyDictionary.cs b/CodeJam.Main/Collections/Dictionary/LazyDictionary.cs
@@ -171,7 +171,7 @@ public static ILazyDictionary<TKey, TValue> Create<TKey, TValue>(
 		[Pure]
 		public static ILazyDictionary<TKey, TValue> Create<TKey, TValue>(
 			[NotNull] Func<TKey, TValue> valueFactory,
-			[NotNull] IEqualityComparer<TKey> comparer,
+			[CanBeNull] IEqualityComparer<TKey> comparer,
 			LazyThreadSafetyMode threadSafety)
 		{
 			switch (threadSafety)
diff --git a/CodeJam.Main/Collections/SuffixTree/SuffixTree.cs b/CodeJam.Main/Collections/SuffixTree/SuffixTree.cs
@@ -109,6 +109,7 @@ private void FindBranchingPoint()
 			Node activeEdge;
 			if (_activeEdgeIndex != InvalidNodeIndex)
 			{
+				Debug.Assert(children != null, nameof(children) + " != null");
 				childNodeIndex = children[_activeEdgeIndex];
 				activeEdge = GetNode(childNodeIndex);
 			}
@@ -132,6 +133,7 @@ private void FindBranchingPoint()
 						return;
 					}
 					var c = InternalData[_currentOffset];
+					Debug.Assert(children != null, nameof(children) + " != null");
 					var childIndex = children.LowerBound(c, EdgeComparer);
 					if (childIndex == children.Count)
 					{
@@ -223,6 +225,7 @@ private void UpdateActiveEdgeAndCurrentPosition()
 				DebugCode.AssertState(!branchNode.IsLeaf, "Invalid active state");
 				var index = _currentOffset - _activeLength;
 				var children = branchNode.Children;
+				Debug.Assert(children != null, nameof(children) + " != null");
 				var childIndex = children.LowerBound(InternalData[index], EdgeComparer);
 				DebugCode.AssertState(childIndex != children.Count, "Invalid active state");
 				var edgeIndex = children[childIndex];
@@ -256,6 +259,7 @@ private void InsertSuffix()
 			if (_activeEdgeIndex != InvalidNodeIndex)
 			{
 				var branchChildren = branchNode.Children;
+				Debug.Assert(branchChildren != null, nameof(branchChildren) + " != null");
 				var edgeNodeIndex = branchChildren[_activeEdgeIndex];
 				// need to create a new internal node
 				var edgeNode = GetNode(edgeNodeIndex);
diff --git a/CodeJam.Main/Ranges/[CompositeRanges]/CompositeRange`1.cs b/CodeJam.Main/Ranges/[CompositeRanges]/CompositeRange`1.cs
@@ -231,6 +231,7 @@ internal CompositeRange([NotNull] IEnumerable<Range<T>> ranges, UnsafeOverload s
 		/// <summary>Collection of subranges.</summary>
 		/// <value>The collection of subranges.</value>
 		[NotNull]
+		// ReSharper disable once ConstantNullCoalescingCondition
 		public ReadOnlyCollection<Range<T>> SubRanges => _ranges ?? _emptyRanges;
 
 		#region T4-dont-replace
diff --git a/CodeJam.Main/Readme.txt b/CodeJam.Main/Readme.txt
@@ -1,6 +1,8 @@
 ﻿CodeJam 2.2.0-beta3 Release Notes
 ---------------------------------
 
+What's new in 2.2.0-beta3
+-------------------------
 * Add frameworks support: .NET Standard 1.6, .NET Standard 1.5, .NET Core 1.0, .NET Core 1.1.
 * Extend .NET 2.0, .NET 3.5 and .NET 4.0 support.
 * Use Theraot.Core dependency for older frameworks targeting.
diff --git a/CodeJam.Main/Reflection/MemberAccessor.cs b/CodeJam.Main/Reflection/MemberAccessor.cs
@@ -21,6 +21,7 @@ namespace CodeJam.Reflection
 	[PublicAPI]
 	public class MemberAccessor
 	{
+		// ReSharper disable once NotNullMemberIsNotInitialized
 		internal MemberAccessor([NotNull] TypeAccessor typeAccessor, [NotNull] string memberName)
 		{
 			TypeAccessor = typeAccessor;
@@ -178,6 +179,7 @@ void MakeSetter(Expression ex, int i)
 			SetExpressions();
 		}
 
+		// ReSharper disable once NotNullMemberIsNotInitialized
 		internal MemberAccessor([NotNull] TypeAccessor typeAccessor, [NotNull] MemberInfo memberInfo)
 		{
 			TypeAccessor = typeAccessor;
diff --git a/CodeJam.Main/Targeting/TypeExtensions.cs b/CodeJam.Main/Targeting/TypeExtensions.cs
@@ -243,7 +243,7 @@ public static void SetPropertyValue(
 			var property = type.GetTypeInfo().GetDeclaredProperty(propertyName);
 			property.SetValue(target, value);
 #else
-			type.InvokeMember(propertyName, BindingFlags.SetProperty, null, target, new object[] { value });
+			type.InvokeMember(propertyName, BindingFlags.SetProperty, null, target, new[] { value });
 #endif
 		}
 
@@ -272,7 +272,7 @@ public static void SetFieldValue([NotNull] this Type type, [NotNull] string fiel
 				type.SetPropertyValue(fieldName, target, value);
 			}
 #else
-			type.InvokeMember(fieldName, BindingFlags.SetField | BindingFlags.SetProperty, null, target, new object[] { value });
+			type.InvokeMember(fieldName, BindingFlags.SetField | BindingFlags.SetProperty, null, target, new[] { value });
 #endif
 		}
 
diff --git a/CodeJam.Main/Threading/AsyncLock.cs b/CodeJam.Main/Threading/AsyncLock.cs
@@ -23,7 +23,6 @@ public class AsyncLock
 		/// Acquires async lock.
 		/// </summary>
 		/// <returns>A task that returns the <see cref="IDisposable"/> to release the lock.</returns>
-		[NotNull, ItemNotNull]
 		[MustUseReturnValue("Lock should be disposed")]
 		public AwaitableNonDisposable<IDisposable> AcquireAsync() => AcquireAsync(-1, CancellationToken.None);
 
@@ -36,7 +35,6 @@ public class AsyncLock
 		/// </param>
 		/// <returns>A task that returns the <see cref="IDisposable"/> to release the lock.</returns>
 		/// <exception cref="TimeoutException">The timeout has expired.</exception>
-		[NotNull, ItemNotNull]
 		[MustUseReturnValue("Lock should be disposed")]
 		public AwaitableNonDisposable<IDisposable> AcquireAsync(int timeout)
 			=> AcquireAsync(TimeSpan.FromMilliseconds(timeout), CancellationToken.None);
@@ -51,7 +49,6 @@ public AwaitableNonDisposable<IDisposable> AcquireAsync(int timeout)
 		/// </param>
 		/// <returns>A task that returns the <see cref="IDisposable"/> to release the lock.</returns>
 		/// <exception cref="TimeoutException">The timeout has expired.</exception>
-		[NotNull, ItemNotNull]
 		[MustUseReturnValue("Lock should be disposed")]
 		public AwaitableNonDisposable<IDisposable> AcquireAsync(TimeSpan timeout) => AcquireAsync(timeout, CancellationToken.None);
 
@@ -61,7 +58,6 @@ public AwaitableNonDisposable<IDisposable> AcquireAsync(int timeout)
 		/// <param name="cancellation">The <see cref="CancellationToken"/> to observe.</param>
 		/// <returns>A task that returns the <see cref="IDisposable"/> to release the lock.</returns>
 		/// <exception cref="OperationCanceledException">The token has had cancellation requested.</exception>
-		[NotNull, ItemNotNull]
 		[MustUseReturnValue("Lock should be disposed")]
 		public AwaitableNonDisposable<IDisposable> AcquireAsync(CancellationToken cancellation) => AcquireAsync(-1, cancellation);
 
@@ -76,7 +72,6 @@ public AwaitableNonDisposable<IDisposable> AcquireAsync(int timeout)
 		/// <returns>A task that returns the <see cref="IDisposable"/> to release the lock.</returns>
 		/// <exception cref="OperationCanceledException">The token has had cancellation requested.</exception>
 		/// <exception cref="TimeoutException">The timeout has expired.</exception>
-		[NotNull, ItemNotNull]
 		[MustUseReturnValue("Lock should be disposed")]
 		public AwaitableNonDisposable<IDisposable> AcquireAsync(int timeout, CancellationToken cancellation) =>
 			AcquireAsync(TimeSpan.FromMilliseconds(timeout), cancellation);
@@ -93,12 +88,9 @@ public AwaitableNonDisposable<IDisposable> AcquireAsync(int timeout, Cancellatio
 		/// <returns>A task that returns the <see cref="IDisposable"/> to release the lock.</returns>
 		/// <exception cref="OperationCanceledException">The token has had cancellation requested.</exception>
 		/// <exception cref="TimeoutException">The timeout has expired.</exception>
-		[NotNull, ItemNotNull]
 		[MustUseReturnValue("Lock should be disposed")]
 		public AwaitableNonDisposable<IDisposable> AcquireAsync(TimeSpan timeout, CancellationToken cancellation)
-		{
-			return new AwaitableNonDisposable<IDisposable>(AcquireAsyncImpl(timeout, cancellation));
-		}
+			=> new AwaitableNonDisposable<IDisposable>(AcquireAsyncImpl(timeout, cancellation));
 
 		[NotNull, ItemNotNull]
 		[MustUseReturnValue("Lock should be disposed")]
diff --git a/CodeJam.Main/Threading/AwaitableNonDisposable.cs b/CodeJam.Main/Threading/AwaitableNonDisposable.cs
@@ -1,4 +1,4 @@
-// BASEDON: https://github.com/StephenCleary/AsyncEx AwaitableDisposable class.
+﻿// BASEDON: https://github.com/StephenCleary/AsyncEx AwaitableDisposable class.
 
 using System;
 using System.Threading.Tasks;
@@ -16,6 +16,7 @@ namespace CodeJam.Threading
 	/// This prevents usage errors like <code>using (lock.AcquireAsync())</code> when the appropriate usage should be <code>using (await lock.AcquireAsync())</code>.
 	/// </summary>
 	/// <typeparam name="T">The type of the result of the underlying task.</typeparam>
+	[PublicAPI]
 	public struct AwaitableNonDisposable<T> where T : IDisposable
 	{
 		/// <summary>
@@ -40,31 +41,22 @@ public AwaitableNonDisposable([NotNull] Task<T> task)
 		/// </summary>
 		/// <returns>Underlying task.</returns>
 		[NotNull][MethodImpl(AggressiveInlining)]
-		public Task<T> AsTask()
-		{
-			return _task;
-		}
+		public Task<T> AsTask() => _task;
 
 		/// <summary>
 		/// Implicit conversion to the underlying task.
 		/// </summary>
 		/// <param name="source">The awaitable wrapper.</param>
 		/// <returns>Underlying task</returns>
 		[NotNull][MethodImpl(AggressiveInlining)]
-		public static implicit operator Task<T>([NotNull] AwaitableNonDisposable<T> source)
-		{
-			return source.AsTask();
-		}
+		public static implicit operator Task<T>(AwaitableNonDisposable<T> source) => source.AsTask();
 
 		/// <summary>
 		/// Infrastructure. Returns the task awaiter for the underlying task.
 		/// </summary>
 		/// <returns>Task awaiter for the underlying task.</returns>
 		[MethodImpl(AggressiveInlining)]
-		public TaskAwaiter<T> GetAwaiter()
-		{
-			return _task.GetAwaiter();
-		}
+		public TaskAwaiter<T> GetAwaiter() => _task.GetAwaiter();
 
 		/// <summary>
 		/// Infrastructure. Returns a configured task awaiter for the underlying task.
@@ -73,8 +65,6 @@ public TaskAwaiter<T> GetAwaiter()
 		/// <returns>A configured task awaiter for the underlying task.</returns>
 		[MethodImpl(AggressiveInlining)]
 		public ConfiguredTaskAwaitable<T> ConfigureAwait(bool continueOnCapturedContext)
-		{
-			return _task.ConfigureAwait(continueOnCapturedContext);
-		}
+			=> _task.ConfigureAwait(continueOnCapturedContext);
 	}
 }
diff --git a/CodeJam.Main/Threading/ConcurrentLazyDictionary.cs b/CodeJam.Main/Threading/ConcurrentLazyDictionary.cs
@@ -47,12 +47,12 @@ public ConcurrentLazyDictionary(
 		/// </summary>
 		/// <param name="valueFactory">Function to create value on demand.</param>
 		/// <param name="comparer">Key comparer.</param>
-		public ConcurrentLazyDictionary([NotNull] Func<TKey, TValue> valueFactory, [NotNull] IEqualityComparer<TKey> comparer)
+		public ConcurrentLazyDictionary([NotNull] Func<TKey, TValue> valueFactory, [CanBeNull] IEqualityComparer<TKey> comparer)
 		{
 			Code.NotNull(valueFactory, nameof(valueFactory));
 
 			_valueFactory = valueFactory;
-			_map = new ConcurrentDictionary<TKey, TValue>(comparer);
+			_map = new ConcurrentDictionary<TKey, TValue>(comparer ?? EqualityComparer<TKey>.Default);
 		}
 
 		/// <summary>
diff --git a/CodeJam.Main/Threading/ExecSyncConcurrentLazyDictionary.cs b/CodeJam.Main/Threading/ExecSyncConcurrentLazyDictionary.cs
@@ -25,8 +25,6 @@ public class ExecSyncConcurrentLazyDictionary<TKey, TValue> : ILazyDictionary<TK
 		[NotNull]
 		private readonly Func<TKey, TValue> _valueFactory;
 		[NotNull]
-		private readonly IEqualityComparer<TKey> _comparer;
-		[NotNull]
 		private readonly ConcurrentDictionary<TKey, Lazy<TValue>> _map;
 
 		/// <summary>
@@ -43,7 +41,6 @@ public ExecSyncConcurrentLazyDictionary(
 			Code.NotNull(valueFactory, nameof(valueFactory));
 
 			_valueFactory = valueFactory;
-			_comparer = comparer;
 			_map = new ConcurrentDictionary<TKey, Lazy<TValue>>(
 				collection
 					.Select(v => new KeyValuePair<TKey, Lazy<TValue>>(
@@ -59,13 +56,12 @@ public ExecSyncConcurrentLazyDictionary(
 		/// <param name="comparer">Key comparer.</param>
 		public ExecSyncConcurrentLazyDictionary(
 			[NotNull] Func<TKey, TValue> valueFactory,
-			[NotNull] IEqualityComparer<TKey> comparer)
+			[CanBeNull] IEqualityComparer<TKey> comparer)
 		{
 			Code.NotNull(valueFactory, nameof(valueFactory));
 
 			_valueFactory = valueFactory;
-			_comparer = comparer;
-			_map = new ConcurrentDictionary<TKey, Lazy<TValue>>(comparer);
+			_map = new ConcurrentDictionary<TKey, Lazy<TValue>>(comparer ?? EqualityComparer<TKey>.Default);
 		}
 
 		/// <summary>
diff --git a/CodeJam.sln.DotSettings b/CodeJam.sln.DotSettings
@@ -250,6 +250,8 @@
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=DB/@EntryIndexedValue">DB</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=FW/@EntryIndexedValue">FW</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=MS/@EntryIndexedValue">MS</s:String>
+	<s:Boolean x:Key="/Default/CodeStyle/Naming/CSharpNaming/ApplyAutoDetectedRules/@EntryValue">False</s:Boolean>
+	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/PredefinedNamingRules/=Constants/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AaBb" /&gt;</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/PredefinedNamingRules/=LocalConstants/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/PredefinedNamingRules/=PrivateConstants/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="_" Suffix="" Style="aaBb" /&gt;</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/PredefinedNamingRules/=PrivateInstanceFields/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="_" Suffix="" Style="aaBb" /&gt;</s:String>

Original file line number	Diff line number	Diff line change
`@@ -171,7 +171,7 @@ public static ILazyDictionary<TKey, TValue> Create<TKey, TValue>(`
`171`	`171`	`[Pure]`
`172`	`172`	`public static ILazyDictionary<TKey, TValue> Create<TKey, TValue>(`
`173`	`173`	`[NotNull] Func<TKey, TValue> valueFactory,`
`174`		`- [NotNull] IEqualityComparer<TKey> comparer,`
	`174`	`+ [CanBeNull] IEqualityComparer<TKey> comparer,`
`175`	`175`	`LazyThreadSafetyMode threadSafety)`
`176`	`176`	`{`
`177`	`177`	`switch (threadSafety)`
Original file line number	Diff line number	Diff line change
`@@ -109,6 +109,7 @@ private void FindBranchingPoint()`
`109`	`109`	`Node activeEdge;`
`110`	`110`	`if (_activeEdgeIndex != InvalidNodeIndex)`
`111`	`111`	`{`
	`112`	`+ Debug.Assert(children != null, nameof(children) + " != null");`
`112`	`113`	`childNodeIndex = children[_activeEdgeIndex];`
`113`	`114`	`activeEdge = GetNode(childNodeIndex);`
`114`	`115`	`}`
`@@ -132,6 +133,7 @@ private void FindBranchingPoint()`
`132`	`133`	`return;`
`133`	`134`	`}`
`134`	`135`	`var c = InternalData[_currentOffset];`
	`136`	`+ Debug.Assert(children != null, nameof(children) + " != null");`
`135`	`137`	`var childIndex = children.LowerBound(c, EdgeComparer);`
`136`	`138`	`if (childIndex == children.Count)`
`137`	`139`	`{`
`@@ -223,6 +225,7 @@ private void UpdateActiveEdgeAndCurrentPosition()`
`223`	`225`	`DebugCode.AssertState(!branchNode.IsLeaf, "Invalid active state");`
`224`	`226`	`var index = _currentOffset - _activeLength;`
`225`	`227`	`var children = branchNode.Children;`
	`228`	`+ Debug.Assert(children != null, nameof(children) + " != null");`
`226`	`229`	`var childIndex = children.LowerBound(InternalData[index], EdgeComparer);`
`227`	`230`	`DebugCode.AssertState(childIndex != children.Count, "Invalid active state");`
`228`	`231`	`var edgeIndex = children[childIndex];`
`@@ -256,6 +259,7 @@ private void InsertSuffix()`
`256`	`259`	`if (_activeEdgeIndex != InvalidNodeIndex)`
`257`	`260`	`{`
`258`	`261`	`var branchChildren = branchNode.Children;`
	`262`	`+ Debug.Assert(branchChildren != null, nameof(branchChildren) + " != null");`
`259`	`263`	`var edgeNodeIndex = branchChildren[_activeEdgeIndex];`
`260`	`264`	`// need to create a new internal node`
`261`	`265`	`var edgeNode = GetNode(edgeNodeIndex);`
Original file line number	Diff line number	Diff line change
`@@ -21,6 +21,7 @@ namespace CodeJam.Reflection`
`21`	`21`	`[PublicAPI]`
`22`	`22`	`public class MemberAccessor`
`23`	`23`	`{`
	`24`	`+ // ReSharper disable once NotNullMemberIsNotInitialized`
`24`	`25`	`internal MemberAccessor([NotNull] TypeAccessor typeAccessor, [NotNull] string memberName)`
`25`	`26`	`{`
`26`	`27`	`TypeAccessor = typeAccessor;`
`@@ -178,6 +179,7 @@ void MakeSetter(Expression ex, int i)`
`178`	`179`	`SetExpressions();`
`179`	`180`	`}`
`180`	`181`
	`182`	`+ // ReSharper disable once NotNullMemberIsNotInitialized`
`181`	`183`	`internal MemberAccessor([NotNull] TypeAccessor typeAccessor, [NotNull] MemberInfo memberInfo)`
`182`	`184`	`{`
`183`	`185`	`TypeAccessor = typeAccessor;`
Original file line number	Diff line number	Diff line change
`@@ -243,7 +243,7 @@ public static void SetPropertyValue(`
`243`	`243`	`var property = type.GetTypeInfo().GetDeclaredProperty(propertyName);`
`244`	`244`	`property.SetValue(target, value);`
`245`	`245`	`#else`
`246`		`- type.InvokeMember(propertyName, BindingFlags.SetProperty, null, target, new object[] { value });`
	`246`	`+ type.InvokeMember(propertyName, BindingFlags.SetProperty, null, target, new[] { value });`
`247`	`247`	`#endif`
`248`	`248`	`}`
`249`	`249`
`@@ -272,7 +272,7 @@ public static void SetFieldValue([NotNull] this Type type, [NotNull] string fiel`
`272`	`272`	`type.SetPropertyValue(fieldName, target, value);`
`273`	`273`	`}`
`274`	`274`	`#else`
`275`		`- type.InvokeMember(fieldName, BindingFlags.SetField \| BindingFlags.SetProperty, null, target, new object[] { value });`
	`275`	`+ type.InvokeMember(fieldName, BindingFlags.SetField \| BindingFlags.SetProperty, null, target, new[] { value });`
`276`	`276`	`#endif`
`277`	`277`	`}`
`278`	`278`