diff --git a/Nuclex.Support (net-4.0).csproj b/Nuclex.Support (net-4.0).csproj
index 1148e8d..9203589 100644
--- a/Nuclex.Support (net-4.0).csproj
+++ b/Nuclex.Support (net-4.0).csproj
@@ -276,10 +276,6 @@
TypeHelper.cs
-
-
- Semaphore.cs
-
FloatHelper.cs
@@ -309,9 +305,6 @@
StringSegment.cs
-
- WeakReference.cs
-
WeakReference.cs
diff --git a/Properties/AssemblyInfo.cs b/Properties/AssemblyInfo.cs
index d15594c..9df33e8 100644
--- a/Properties/AssemblyInfo.cs
+++ b/Properties/AssemblyInfo.cs
@@ -21,7 +21,7 @@ using System.Runtime.InteropServices;
// The following GUID is for the ID of the typelib if this project is exposed to COM
[assembly: Guid("1308e4c3-a0c1-423a-aaae-61c7314777e0")]
-#if !(WINDOWS_PHONE || XBOX360) && UNITTEST
+#if UNITTEST
// This is required to NMock can derive its proxies from interfaces in
// the internal unit test classes
[assembly: InternalsVisibleTo(NMock.Constants.InternalsVisibleToDynamicProxy)]
diff --git a/Source/AffineThreadPool.cs b/Source/AffineThreadPool.cs
index 07f31a9..8e01aa1 100644
--- a/Source/AffineThreadPool.cs
+++ b/Source/AffineThreadPool.cs
@@ -49,11 +49,7 @@ namespace Nuclex.Support {
public static class AffineThreadPool {
/// Number of CPU cores available on the system
-#if XBOX360
- public static readonly int Processors = 4;
-#else
public static readonly int Processors = Environment.ProcessorCount;
-#endif
/// Delegate used by the thread pool to report unhandled exceptions
/// Exception that has not been handled
@@ -88,25 +84,16 @@ namespace Nuclex.Support {
// as we may run into situations where multiple operations need to be atomic.
// We keep track of the threads we've created just for good measure; not actually
// needed for any core functionality.
-#if XBOX360 || WINDOWS_PHONE
- workAvailable = new Semaphore();
-#else
workAvailable = new System.Threading.Semaphore(0, int.MaxValue);
-#endif
userWorkItems = new Queue(Processors * 4);
workerThreads = new List(Processors);
inUseThreads = 0;
-#if XBOX360
- // We can only use these hardware thread indices on the XBox 360
- hardwareThreads = new Queue(new int[] { 5, 4, 3, 1 });
-#else
// We can use all cores on a PC, starting from index 1
hardwareThreads = new Queue(Processors);
for(int core = Processors; core >= 1; --core) {
hardwareThreads.Enqueue(core);
}
-#endif
// Create all of the worker threads
for(int index = 0; index < Processors; index++) {
@@ -211,12 +198,7 @@ namespace Nuclex.Support {
hardwareThreadIndex = hardwareThreads.Dequeue();
}
-#if XBOX360
- // On the XBox 360, the only way to get a thread to run on another core is to
- // explicitly move it to that core. MSDN states that SetProcessorAffinity() should
- // be called from the thread whose affinity is being changed.
- Thread.CurrentThread.SetProcessorAffinity(new int[] { hardwareThreadIndex });
-#elif WINDOWS
+#if WINDOWS
if(Environment.OSVersion.Platform == PlatformID.Win32NT) {
// Prevent this managed thread from impersonating another system thread.
// In .NET, managed threads can supposedly be moved to different system threads
@@ -303,11 +285,7 @@ namespace Nuclex.Support {
///
/// Used to let the threads in the thread pool wait for new work to appear.
///
-#if XBOX360 || WINDOWS_PHONE
- private static Semaphore workAvailable;
-#else
private static System.Threading.Semaphore workAvailable;
-#endif
/// List of all worker threads at the disposal of the thread pool.
private static List workerThreads;
/// Number of threads currently active.
diff --git a/Source/Cloning/ReflectionCloner.cs b/Source/Cloning/ReflectionCloner.cs
index 9b7d06b..ca25ef6 100644
--- a/Source/Cloning/ReflectionCloner.cs
+++ b/Source/Cloning/ReflectionCloner.cs
@@ -161,11 +161,7 @@ namespace Nuclex.Support.Cloning {
/// A clone of the original instance
private static object shallowCloneComplexFieldBased(object original) {
Type originalType = original.GetType();
-#if (XBOX360 || WINDOWS_PHONE)
- object clone = Activator.CreateInstance(originalType);
-#else
object clone = FormatterServices.GetUninitializedObject(originalType);
-#endif
FieldInfo[] fieldInfos = originalType.GetFieldInfosIncludingBaseClasses(
BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance
@@ -243,11 +239,7 @@ namespace Nuclex.Support.Cloning {
/// A clone of the original instance
private static object deepCloneComplexFieldBased(object original) {
Type originalType = original.GetType();
-#if (XBOX360 || WINDOWS_PHONE)
- object clone = Activator.CreateInstance(originalType);
-#else
object clone = FormatterServices.GetUninitializedObject(originalType);
-#endif
FieldInfo[] fieldInfos = originalType.GetFieldInfosIncludingBaseClasses(
BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance
diff --git a/Source/Cloning/SerializationCloner.cs b/Source/Cloning/SerializationCloner.cs
index 2112b56..78aa190 100644
--- a/Source/Cloning/SerializationCloner.cs
+++ b/Source/Cloning/SerializationCloner.cs
@@ -18,8 +18,6 @@ License along with this library
*/
#endregion
-#if !(XBOX360 || WINDOWS_PHONE)
-
using System;
using System.IO;
using System.Reflection;
@@ -328,5 +326,3 @@ namespace Nuclex.Support.Cloning {
}
} // namespace Nuclex.Support.Cloning
-
-#endif // !(XBOX360 || WINDOWS_PHONE)
diff --git a/Source/ParallelBackgroundWorker.cs b/Source/ParallelBackgroundWorker.cs
index ec09b89..73d2e7e 100644
--- a/Source/ParallelBackgroundWorker.cs
+++ b/Source/ParallelBackgroundWorker.cs
@@ -1,3 +1,23 @@
+#region CPL License
+/*
+Nuclex Framework
+Copyright (C) 2002-2014 Nuclex Development Labs
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the IBM Common Public License as
+published by the IBM Corporation; either version 1.0 of the
+License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+IBM Common Public License for more details.
+
+You should have received a copy of the IBM Common Public
+License along with this library
+*/
+#endregion
+
#if !NO_CONCURRENT_COLLECTIONS
using System;
@@ -13,11 +33,7 @@ namespace Nuclex.Support {
public abstract class ParallelBackgroundWorker : IDisposable {
/// Number of CPU cores available on the system
-#if XBOX360
- public static readonly int Processors = 4;
-#else
public static readonly int Processors = Environment.ProcessorCount;
-#endif
///
/// Timeout after which Dispose() will stop waiting for unfinished tasks and
diff --git a/Source/Semaphore.Test.cs b/Source/Semaphore.Test.cs
deleted file mode 100644
index da704bc..0000000
--- a/Source/Semaphore.Test.cs
+++ /dev/null
@@ -1,127 +0,0 @@
-#region CPL License
-/*
-Nuclex Framework
-Copyright (C) 2002-2014 Nuclex Development Labs
-
-This library is free software; you can redistribute it and/or
-modify it under the terms of the IBM Common Public License as
-published by the IBM Corporation; either version 1.0 of the
-License, or (at your option) any later version.
-
-This library is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-IBM Common Public License for more details.
-
-You should have received a copy of the IBM Common Public
-License along with this library
-*/
-#endregion
-
-#if UNITTEST
-
-using System;
-using System.Collections.Generic;
-using System.Threading;
-
-using NUnit.Framework;
-
-namespace Nuclex.Support {
-
- /// Unit Test for the Semaphore class
- [
- TestFixture,
- Obsolete("Not obsolete, prevents warning when unit-testing custom Semaphore on Windows")
- ]
- internal class SemaphoreTest {
-
- ///
- /// Test whether a semaphore can be initialized with reverse counting
- ///
- [Test]
- public void TestReverseCountingConstructor() {
- using(Semaphore semaphore = new Semaphore()) {
- Assert.IsNotNull(semaphore); // nonsense, avoids compiler warning
- }
- }
-
- ///
- /// Test whether a semaphore can be initialized with a maximum user count
- ///
- [Test]
- public void TestLimitConstructor() {
- using(Semaphore semaphore = new Semaphore(16)) {
- Assert.IsNotNull(semaphore); // nonsense, avoids compiler warning
- }
- }
-
- ///
- /// Test whether a semaphore can be initialized with an initial user
- /// count and a maximum user count
- ///
- [Test]
- public void TestFullConstructor() {
- using(Semaphore semaphore = new Semaphore(8, 16)) {
- Assert.IsNotNull(semaphore); // nonsense, avoids compiler warning
- }
- }
-
- ///
- /// Verifies that the right exception is thrown if a semaphore is initialized
- /// with a larger number of initial users than the maximum number of users.
- ///
- [Test]
- public void TestThrowOnMoreInitialUsersThanMaximumUsers() {
- Assert.Throws(
- delegate() {
- Semaphore semaphore = new Semaphore(2, 1);
- semaphore.Close();
- }
- );
- }
-
- ///
- /// Verifies that the semaphore can time out if the resource does not become
- /// available within the time limit specified by the user
- ///
- [Test]
- public void TestWaitTimeout() {
- using(Semaphore semaphore = new Semaphore(1)) {
- Assert.IsTrue(semaphore.WaitOne(1000));
- Assert.IsFalse(semaphore.WaitOne(0));
- }
- }
-
- ///
- /// Verifies that the semaphore can time out if the resource does not become
- /// available within the time limit specified by the user, if the time limit
- /// is specified using the TimeSpan class
- ///
- [Test]
- public void TestWaitTimeoutWithTimeSpan() {
- using(Semaphore semaphore = new Semaphore(1)) {
- Assert.IsTrue(semaphore.WaitOne(TimeSpan.FromSeconds(1)));
- Assert.IsFalse(semaphore.WaitOne(TimeSpan.FromSeconds(0)));
- }
- }
-
- ///
- /// Tests whether an exception is thrown if the WaitOne() method is called
- /// with a time span that is too large for the underlying synchronization API
- ///
- [Test]
- public void TestThrowOnWaitWithTooLargeTimeSpan() {
- using(Semaphore semaphore = new Semaphore(1)) {
- Assert.Throws(
- delegate() {
- semaphore.WaitOne(TimeSpan.FromMilliseconds(1L << 32));
- }
- );
- }
- }
-
- }
-
-} // namespace Nuclex.Support
-
-#endif // UNITTEST
diff --git a/Source/Semaphore.cs b/Source/Semaphore.cs
deleted file mode 100644
index 9aff66f..0000000
--- a/Source/Semaphore.cs
+++ /dev/null
@@ -1,248 +0,0 @@
-#region CPL License
-/*
-Nuclex Framework
-Copyright (C) 2002-2014 Nuclex Development Labs
-
-This library is free software; you can redistribute it and/or
-modify it under the terms of the IBM Common Public License as
-published by the IBM Corporation; either version 1.0 of the
-License, or (at your option) any later version.
-
-This library is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-IBM Common Public License for more details.
-
-You should have received a copy of the IBM Common Public
-License along with this library
-*/
-#endregion
-
-using System;
-using System.Collections.Generic;
-using System.Threading;
-
-namespace Nuclex.Support {
-
- /// A reverse counting semaphore
- ///
- ///
- /// This semaphore counts in reverse, which means you can Release() the semaphore
- /// as often as you'd like a thread calling WaitOne() to be let through. You
- /// can use it in the traditional sense and have any Thread calling WaitOne()
- /// make sure to call Release() afterwards, or you can, for example, Release() it
- /// whenever work becomes available and let threads take work from the Semaphore
- /// by calling WaitOne() alone.
- ///
- ///
- /// Implementation notes (ignore this if you just want to use the Semaphore)
- ///
- ///
- /// We could design a semaphore that uses an auto reset event, where the thread
- /// that gets to pass immediately sets the event again if the semaphore isn't full
- /// yet to let another thread pass.
- ///
- ///
- /// However, this would mean that when a semaphore receives a large number of
- /// wait requests, assuming it would allow, for example, 25 users at once, the
- /// thread scheduler would see only 1 thread become eligible for execution. Then
- /// that thread would unlock the next and so on. In short, we wait 25 times
- /// for the thread scheduler to wake up a thread until all users get through.
- ///
- ///
- /// So we chose a ManualResetEvent, which will wake up more threads than
- /// neccessary and possibly cause a period of intense competition for getting
- /// a lock on the resource, but will make the thread scheduler see all threads
- /// become eligible for execution.
- ///
- ///
-#if WINDOWS
- [Obsolete("Prefer the normal semaphore on Windows builds.")]
- internal class Semaphore : WaitHandle {
-#else
- public class Semaphore : WaitHandle {
-#endif
-
- /// Initializes a new semaphore
- public Semaphore() {
- createEvent();
- }
-
- /// Initializes a new semaphore
- ///
- /// Number of users that can access the resource at the same time
- ///
- public Semaphore(int count) {
- this.free = count;
-
- createEvent();
- }
-
- /// Initializes a new semaphore
- ///
- /// Initial number of users accessing the resource
- ///
- ///
- /// Maximum numbr of users that can access the resource at the same time
- ///
- public Semaphore(int initialCount, int maximumCount) {
- if(initialCount > maximumCount) {
- throw new ArgumentOutOfRangeException(
- "initialCount", "Initial count must not be larger than the maximum count"
- );
- }
-
- this.free = maximumCount - initialCount;
- createEvent();
- }
-
- /// Immediately releases all resources owned by the instance
- ///
- /// Whether Dispose() has been called explictly
- ///
- protected override void Dispose(bool explicitDisposing) {
- if(this.manualResetEvent != null) {
- base.SafeWaitHandle = null;
-
- this.manualResetEvent.Close();
- this.manualResetEvent = null;
- }
-
- base.Dispose(explicitDisposing);
- }
-
- ///
- /// Waits for the resource to become available and locks it
- ///
- ///
- /// Number of milliseconds to wait at most before giving up
- ///
- ///
- /// True to exit the synchronization domain for the context before the wait (if
- /// in a synchronized context), and reacquire it afterward; otherwise, false.
- ///
- ///
- /// True if the resource was available and is now locked, false if
- /// the timeout has been reached.
- ///
-#if NO_EXITCONTEXT
- public override bool WaitOne(int millisecondsTimeout) {
-#else
- public override bool WaitOne(int millisecondsTimeout, bool exitContext) {
-#endif
- for (; ; ) {
-
- // Lock the resource - even if it is full. We will correct out mistake later
- // if we overcomitted the resource.
- int newFree = Interlocked.Decrement(ref this.free);
-
- // If we got the resource, let the thread pass without further processing.
- if(newFree >= 0) {
- if(newFree > 0) {
- this.manualResetEvent.Set();
- }
-
- return true;
- }
-
- // We overcomitted the resource, count it down again. We know that, at least
- // moments ago, the resource was busy, so block the event.
- this.manualResetEvent.Reset();
- Thread.MemoryBarrier();
- newFree = Interlocked.Increment(ref this.free);
-
- // Unless we have been preempted by a Release(), we now have to wait for the
- // resource to become available.
- if(newFree >= 0) {
-#if NO_EXITCONTEXT
- if(!this.manualResetEvent.WaitOne(millisecondsTimeout)) {
-#else
- if(!this.manualResetEvent.WaitOne(millisecondsTimeout, exitContext)) {
-#endif
- return false;
- }
- }
-
- } // for(; ; )
- }
-
- ///
- /// Waits for the resource to become available and locks it
- ///
- ///
- /// True if the resource was available and is now locked, false if
- /// the timeout has been reached.
- ///
- public override bool WaitOne() {
-#if NO_EXITCONTEXT
- return WaitOne(-1);
-#else
- return WaitOne(-1, false);
-#endif
- }
-
- ///
- /// Waits for the resource to become available and locks it
- ///
- ///
- /// Time span to wait for the lock before giving up
- ///
- ///
- /// True to exit the synchronization domain for the context before the wait (if
- /// in a synchronized context), and reacquire it afterward; otherwise, false.
- ///
- ///
- /// True if the resource was available and is now locked, false if
- /// the timeout has been reached.
- ///
-#if NO_EXITCONTEXT
- public override bool WaitOne(TimeSpan timeout) {
-#else
- public override bool WaitOne(TimeSpan timeout, bool exitContext) {
-#endif
- long totalMilliseconds = (long)timeout.TotalMilliseconds;
- if((totalMilliseconds < -1) || (totalMilliseconds > int.MaxValue)) {
- throw new ArgumentOutOfRangeException(
- "timeout", "Timeout must be either -1 or positive and less than 2^31"
- );
- }
-
-#if NO_EXITCONTEXT
- return WaitOne((int)totalMilliseconds);
-#else
- return WaitOne((int)totalMilliseconds, exitContext);
-#endif
- }
-
- ///
- /// Releases a lock on the resource. Note that for a reverse counting semaphore,
- /// it is legal to Release() the resource before locking it.
- ///
- public void Release() {
-
- // Release one lock on the resource
- Interlocked.Increment(ref this.free);
-
- // Wake up any threads waiting for the resource to become available
- this.manualResetEvent.Set();
-
- }
-
- /// Creates the event used to make threads wait for the resource
- private void createEvent() {
- this.manualResetEvent = new ManualResetEvent(false);
- base.SafeWaitHandle = this.manualResetEvent.SafeWaitHandle;
- }
-
- /// Event used to make threads wait if the semaphore is full
- private ManualResetEvent manualResetEvent;
- /// Number of users currently accessing the resource
- ///
- /// Since this is a reverse counting semaphore, it will be negative if
- /// the resource is available and 0 if the semaphore is full.
- ///
- private int free;
-
- }
-
-} // namespace Nuclex.Support
diff --git a/Source/StringBuilderHelper.cs b/Source/StringBuilderHelper.cs
index 2adc189..6274b44 100644
--- a/Source/StringBuilderHelper.cs
+++ b/Source/StringBuilderHelper.cs
@@ -332,14 +332,8 @@ namespace Nuclex.Support {
/// String builder the number will be appended to
/// Remaining digits that will be recursively processed
private static void recursiveAppend(StringBuilder builder, int remaining) {
-#if !(XBOX360 || WINDOWS_PHONE)
int digit;
int tenth = Math.DivRem(remaining, 10, out digit);
-#else
- int digit = remaining % 10;
- int tenth = remaining / 10;
-#endif
-
if(tenth > 0) {
recursiveAppend(builder, tenth);
}
@@ -351,14 +345,8 @@ namespace Nuclex.Support {
/// String builder the number will be appended to
/// Remaining digits that will be recursively processed
private static void recursiveAppend(StringBuilder builder, long remaining) {
-#if !(XBOX360 || WINDOWS_PHONE)
long digit;
long tenth = Math.DivRem(remaining, 10, out digit);
-#else
- long digit = remaining % 10;
- long tenth = remaining / 10;
-#endif
-
if(tenth > 0) {
recursiveAppend(builder, tenth);
}
diff --git a/Source/TypeHelper.cs b/Source/TypeHelper.cs
index cdb4527..fb6490f 100644
--- a/Source/TypeHelper.cs
+++ b/Source/TypeHelper.cs
@@ -58,65 +58,6 @@ namespace Nuclex.Support {
#endregion // class MemberInfoComparer
-#if WINRT
-
- ///
- /// Returns all the fields of a type, including those defined in the type's base classes
- ///
- /// Type whose fields will be returned
- /// Binding flags to use when querying the fields
- /// All of the type's fields, including its base types
- public static FieldInfo[] GetFieldInfosIncludingBaseClasses(this Type type) {
- var fieldInfoSet = new HashSet(fieldInfos, FieldInfoComparer.Default);
-
- while(type != typeof(object)) {
- TypeInfo typeInfo = type.GetTypeInfo();
-
- foreach(FieldInfo fieldInfo in typeInfo.DeclaredFields) {
- fieldInfoSet.Add(fieldInfo);
- }
-
- type = typeInfo.BaseType;
- }
-
- FieldInfo[] fieldInfos = new FieldInfo[fieldInfoSet.Count];
- fieldInfoSet.CopyTo(fieldInfos, 0);
- return fieldInfos;
- }
-
-#elif !(XBOX360 || WINDOWS_PHONE)
-
- ///
- /// Returns all the fields of a type, including those defined in the type's base classes
- ///
- /// Type whose fields will be returned
- /// Binding flags to use when querying the fields
- /// All of the type's fields, including its base types
- public static FieldInfo[] GetFieldInfosIncludingBaseClasses(
- this Type type, BindingFlags bindingFlags
- ) {
- FieldInfo[] fieldInfos = type.GetFields(bindingFlags);
-
- // If this class doesn't have a base, don't waste any time
- if(type.BaseType != typeof(object)) {
- var fieldInfoSet = new HashSet(fieldInfos, FieldInfoComparer.Default);
- while(type.BaseType != typeof(object)) {
- type = type.BaseType;
- fieldInfos = type.GetFields(bindingFlags);
- for(int index = 0; index < fieldInfos.Length; ++index) {
- fieldInfoSet.Add(fieldInfos[index]);
- }
- }
-
- fieldInfos = new FieldInfo[fieldInfoSet.Count];
- fieldInfoSet.CopyTo(fieldInfos);
- }
-
- return fieldInfos;
- }
-
-#else // !(XBOX360 || WINDOWS_PHONE)
-
///
/// Returns all the fields of a type, including those defined in the type's base classes
///
@@ -164,25 +105,6 @@ namespace Nuclex.Support {
}
}
-#endif // !(XBOX360 || WINDOWS_PHONE)
-
-#if WINRT
-
- /// Determines whether the given type has a default constructor
- /// Type which is to be checked
- /// True if the type has a default constructor
- public static bool HasDefaultConstructor(this Type type) {
- foreach(ConstructorInfo constructorInfo in type.GetTypeInfo().DeclaredConstructors) {
- if(constructorInfo.IsPublic && (constructorInfo.GetParameters().Length == 0)) {
- return true;
- }
- }
-
- return false;
- }
-
-#else
-
/// Determines whether the given type has a default constructor
/// Type which is to be checked
/// True if the type has a default constructor
@@ -199,8 +121,6 @@ namespace Nuclex.Support {
return false;
}
-#endif
-
/// Determines whether the type has the specified attribute
/// Attribute the type will be checked for
///
@@ -211,20 +131,6 @@ namespace Nuclex.Support {
return type.HasAttribute(typeof(TAttribute));
}
-#if WINRT
-
- /// Determines whether the type has the specified attribute
- ///
- /// Type that will be checked for presence of the specified attribute
- ///
- /// Attribute the type will be checked for
- /// True if the type has the specified attribute, otherwise false
- public static bool HasAttribute(this Type type, Type attributeType) {
- return (type.GetTypeInfo().GetCustomAttribute(attributeType) != null);
- }
-
-#else
-
/// Determines whether the type has the specified attribute
///
/// Type that will be checked for presence of the specified attribute
@@ -236,8 +142,6 @@ namespace Nuclex.Support {
return (attributes != null) && (attributes.Length > 0);
}
-#endif
-
}
} // namespace Nuclex.Support
diff --git a/Source/WeakReference.Phone7.cs b/Source/WeakReference.Phone7.cs
deleted file mode 100644
index 3d32c93..0000000
--- a/Source/WeakReference.Phone7.cs
+++ /dev/null
@@ -1,106 +0,0 @@
-#region CPL License
-/*
-Nuclex Framework
-Copyright (C) 2002-2014 Nuclex Development Labs
-
-This library is free software; you can redistribute it and/or
-modify it under the terms of the IBM Common Public License as
-published by the IBM Corporation; either version 1.0 of the
-License, or (at your option) any later version.
-
-This library is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-IBM Common Public License for more details.
-
-You should have received a copy of the IBM Common Public
-License along with this library
-*/
-#endregion
-
-using System;
-using System.Collections.Generic;
-
-namespace Nuclex.Support {
-
-#if WINDOWS_PHONE
-
- ///
- /// Type-safe weak reference, referencing an object while still allowing
- /// that object to be garbage collected.
- ///
- public class WeakReference
- where ReferencedType : class {
-
- ///
- /// Initializes a new instance of the WeakReference class, referencing
- /// the specified object.
- ///
- /// The object to track or null.
- public WeakReference(ReferencedType target) {
- this.weakReference = new WeakReference(target);
- }
-
- ///
- /// Initializes a new instance of the WeakReference class, referencing
- /// the specified object optionally using resurrection tracking.
- ///
- /// An object to track.
- ///
- /// Indicates when to stop tracking the object. If true, the object is tracked
- /// after finalization; if false, the object is only tracked until finalization.
- ///
- public WeakReference(ReferencedType target, bool trackResurrection) {
- this.weakReference = new WeakReference(target, trackResurrection);
- }
-
- ///
- /// Implicitly converts a typed WeakReference into a non-typesafe WeakReference
- ///
- /// The types WeakReference that will be converted
- /// The non-typesafe WeakReference
- public static implicit operator WeakReference(WeakReference self) {
- return self.weakReference;
- }
-
- ///
- /// Gets or sets the object (the target) referenced by the current WeakReference
- /// object.
- ///
- ///
- /// Is null if the object referenced by the current System.WeakReference object
- /// has been garbage collected; otherwise, a reference to the object referenced
- /// by the current System.WeakReference object.
- ///
- ///
- /// The reference to the target object is invalid. This can occur if the current
- /// System.WeakReference object has been finalized
- ///
- public ReferencedType Target {
- get { return this.weakReference.Target as ReferencedType; }
- set { this.weakReference.Target = value; }
- }
-
- ///
- /// whether the object referenced by the WeakReference has been garbage collected
- ///
- public virtual bool IsAlive {
- get { return this.weakReference.IsAlive; }
- }
-
- ///
- /// Whether the object referenced by the WeakReference is tracked after it is finalized
- ///
- public virtual bool TrackResurrection {
- get { return this.weakReference.TrackResurrection; }
- }
-
- /// The non-typesafe WeakReference being wrapped
- private WeakReference weakReference;
-
- }
-
-#endif // WINDOWS_PHONE
-
-} // namespace Nuclex.Support
-
diff --git a/Source/WeakReference.cs b/Source/WeakReference.cs
index 36be2cd..f5b7e34 100644
--- a/Source/WeakReference.cs
+++ b/Source/WeakReference.cs
@@ -24,8 +24,6 @@ using System.Runtime.Serialization;
namespace Nuclex.Support {
-#if !WINDOWS_PHONE
-
///
/// Type-safe weak reference, referencing an object while still allowing
/// that object to be garbage collected.
@@ -98,6 +96,4 @@ namespace Nuclex.Support {
}
-#endif // !WINDOWS_PHONE
-
} // namespace Nuclex.Support