Adding a Subject.Create overload with a single generic parameter.

Rx.NET/Source/System.Reactive.Linq/Reactive/Subjects/Subject.Extensions.cs

@@ -29,6 +29,24 @@ namespace System.Reactive.Subjects
             return new AnonymousSubject<TSource, TResult>(observer, observable);
         }
 
+        /// <summary>
+        /// Creates a subject from the specified observer and observable.
+        /// </summary>
+        /// <typeparam name="T">The type of the elements received by the observer and produced by the observable sequence.</typeparam>
+        /// <param name="observer">The observer used to send messages to the subject.</param>
+        /// <param name="observable">The observable used to subscribe to messages sent from the subject.</param>
+        /// <returns>Subject implemented using the given observer and observable.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="observer"/> or <paramref name="observable"/> is null.</exception>
+        public static ISubject<T> Create<T>(IObserver<T> observer, IObservable<T> observable)
+        {
+            if (observer == null)
+                throw new ArgumentNullException("observer");
+            if (observable == null)
+                throw new ArgumentNullException("observable");
+
+            return new AnonymousSubject<T>(observer, observable);
+        }
+
         /// <summary>
         /// Synchronizes the messages sent to the subject.
         /// </summary>
@@ -104,5 +122,13 @@ namespace System.Reactive.Subjects
                 return _observable.Subscribe/*Unsafe*/(observer);
             }
         }
+
+        class AnonymousSubject<T> : AnonymousSubject<T, T>, ISubject<T>
+        {
+            public AnonymousSubject(IObserver<T> observer, IObservable<T> observable)
+                : base(observer, observable)
+            {
+            }
+        }
     }
 }

Rx.NET/Source/Tests.System.Reactive/Tests/Linq/Subjects/SubjectTest.cs

@@ -367,10 +367,13 @@ namespace ReactiveTests.Tests
         {
             ReactiveAssert.Throws<ArgumentNullException>(() => Subject.Create<int, int>(null, Observable.Return(42)));
             ReactiveAssert.Throws<ArgumentNullException>(() => Subject.Create<int, int>(Observer.Create<int>(x => {}), null));
+
+            ReactiveAssert.Throws<ArgumentNullException>(() => Subject.Create<int>(null, Observable.Return(42)));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Subject.Create<int>(Observer.Create<int>(x => { }), null));
         }
 
         [TestMethod]
-        public void Subject_Create()
+        public void Subject_Create1()
         {
             var _x = default(int);
             var _ex = default(Exception);
@@ -397,6 +400,34 @@ namespace ReactiveTests.Tests
             Assert.IsFalse(done); // already cut off
         }
 
+        [TestMethod]
+        public void Subject_Create2()
+        {
+            var _x = default(int);
+            var _ex = default(Exception);
+            var done = false;
+
+            var v = Observer.Create<int>(x => _x = x, ex => _ex = ex, () => done = true);
+            var o = Observable.Return(42);
+
+            var s = Subject.Create<int>(v, o);
+
+            ReactiveAssert.Throws<ArgumentNullException>(() => s.Subscribe(null));
+            s.Subscribe(x => _x = x);
+            Assert.AreEqual(42, _x);
+
+            s.OnNext(21);
+            Assert.AreEqual(21, _x);
+
+            ReactiveAssert.Throws<ArgumentNullException>(() => s.OnError(null));
+            var e = new Exception();
+            s.OnError(e);
+            Assert.AreSame(e, _ex);
+
+            s.OnCompleted();
+            Assert.IsFalse(done); // already cut off
+        }
+
         [TestMethod]
         public void Subject_Synchronize_ArgumentChecking()
         {