Updates,

Author: Kayla Firestack

UMFTests/UMFS.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Linq;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
+using UnityMultiFramework;
 
 namespace UMFTests
 {
@@ -10,7 +11,7 @@ public class UMFS
 		[TestMethod]
 		public void TestFileLocations()
 		{
-			var a = UnityMultiFramework.Unity.Projects.ProjectLocations.ToList();
+			var a = Unity.Projects.ToList();
 
 		}
 	}

UnityMultiFramework/Accessors/ExecutableAccessor.cs

@@ -0,0 +1,36 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace UnityMultiFramework
+{
+	public class ExecutableAccessor : IEnumerable<Executable>
+	{
+		internal ExecutableAccessor() { }
+
+		public List<Executable> Locations = new List<Executable>();
+
+		public void AddIn(Uri baseLocation)
+			=> Locations.AddRange(FindIn(baseLocation));
+
+		private IEnumerable<Executable> FindIn(Uri baseLocation)
+			=> System.IO.Directory
+				.EnumerateFiles(baseLocation.LocalPath, "Unity.exe", System.IO.SearchOption.AllDirectories)
+				.Select(loc => new Executable(new Uri(loc)));
+
+		public IEnumerable<Executable> ClosestExecutables(IVersionable ver) 
+			=> Locations.Where(loc => loc.FuzzyEquals(ver)).OrderBy(exe => Math.Abs(exe.FuzzyCompareTo(ver)));
+
+		public IEnumerator<Executable> GetEnumerator()
+		{
+			return ((IEnumerable<Executable>)Locations).GetEnumerator();
+		}
+
+		IEnumerator IEnumerable.GetEnumerator()
+		{
+			return ((IEnumerable<Executable>)Locations).GetEnumerator();
+		}
+	}
+
+}

UnityMultiFramework/Accessors/ProjectAccessor.cs

@@ -0,0 +1,58 @@
+using Microsoft.Win32;
+using System;
+using System.IO;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Collections;
+
+namespace UnityMultiFramework
+{
+
+		public class ProjectAccessor : IEnumerable<Project>
+		{
+			private const string UNITYREGKEY = @"SOFTWARE\Unity Technologies\Unity Editor 5.x\";
+
+			internal ProjectAccessor() { }
+
+			private List<Uri> ExtraLocations = new List<Uri>();
+
+			public IEnumerable<Project> ProjectLocations
+				=> ExistingLocations
+					.Select(uri => new Project(uri));
+
+			public IEnumerable<Uri> ExistingLocations
+				=> ExtraLocations
+					.Concat((RegKeyToUri() ?? Enumerable.Empty<Uri>()))
+					.Distinct()
+					.Where(uri => 
+						Directory.Exists(uri.LocalPath) && 
+						Directory.Exists(Path.Combine(uri.LocalPath, "Assets"))
+					);
+
+			public void AddLocations(params Uri[] uris)
+				=> ExtraLocations.AddRange(uris);
+
+			public IEnumerable<Uri> RegKeyToUri()
+			{
+				RegistryKey UnityRegKey = Registry
+					.CurrentUser
+					.OpenSubKey(UNITYREGKEY, false);
+
+				return UnityRegKey?
+					.GetValueNames()
+					.Where(key => key.StartsWith("RecentlyUsedProjectPaths"))
+					.Select(key =>
+						new Uri(Encoding.UTF8.GetString(UnityRegKey.GetValue(key) as byte[]).TrimEnd((char)0))
+					);
+			}
+
+			#region IEnumerable<Project> 
+
+			public IEnumerator<Project> GetEnumerator() => ProjectLocations.GetEnumerator();
+
+			IEnumerator IEnumerable.GetEnumerator() => ProjectLocations.GetEnumerator();
+
+			#endregion
+		}
+}

UnityMultiFramework/Executable.cs

@@ -0,0 +1,52 @@
+using System;
+
+namespace UnityMultiFramework
+{
+	public class Executable : IVersionable, IEquatable<Executable>, ILaunchable
+	{
+		private const string WILDCARD = "*";
+
+		private Executable() { }
+
+		public Executable(Uri Location)
+		{
+			this.Location = Location;
+			VersionType = WILDCARD;
+
+			var versionInfo = System.Diagnostics.FileVersionInfo.GetVersionInfo(Location.LocalPath);
+			Version = new Version(versionInfo.ProductMajorPart, versionInfo.ProductMinorPart, versionInfo.ProductBuildPart, 0);
+		}
+
+		public Uri Location { get; private set; }
+
+		public Version Version { get; private set; }
+
+		public string VersionType { get; set; }
+
+		public int MinorVersion { set { Version = new Version(Version.Major, Version.Minor, Version.Build, value); } }
+
+		public void Launch(params string[] args)
+			=> System.Diagnostics.Process.Start(Location.LocalPath, string.Join(" ", args));
+
+		public int CompareTo(IVersionable other)
+			=> Version.CompareTo(other);
+
+		public bool Equals(IVersionable other)
+			=> FuzzyEquals(other) && (VersionType == WILDCARD || other.VersionType == WILDCARD) ? true : (VersionType == other.VersionType);
+
+		public bool FuzzyEquals(IVersionable other)
+		{
+			return (Version.Major == other.Version.Major) && (Version.Minor == other.Version.Minor) && (Version.Build == other.Version.Build); 
+		}
+
+		public int FuzzyCompareTo(IVersionable other)
+		{
+			if ( !FuzzyEquals(other) ) { return CompareTo(other); }
+			if( VersionType != other.VersionType ) { return VersionType.CompareTo(other.VersionType); }
+			return Version.Revision - other.Version.Revision;
+		}
+
+		public bool Equals(Executable other)
+			=> Location == other.Location;
+	}
+}

UnityMultiFramework/Interfaces/ILaunchable.cs

@@ -0,0 +1,13 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace UnityMultiFramework
+{
+	public interface ILaunchable
+	{
+		void Launch(params string[] args);
+	}
+}

…ultiFramework/Properties/IVersionable.cs …ultiFramework/Interfaces/IVersionable.csUnityMultiFramework/Properties/IVersionable.cs renamed to UnityMultiFramework/Interfaces/IVersionable.cs UnityMultiFramework/Properties/IVersionable.cs renamed to UnityMultiFramework/Interfaces/IVersionable.cs

@@ -6,5 +6,8 @@ public interface IVersionable : IComparable<IVersionable>, IEquatable<IVersionab
 	{
 		Version Version { get; }
 		string VersionType { get; }
+
+		//bool operator ==(IVersionable lhs, IVersionable rhs);
+		//bool operator !=(IVersionable lhs, IVersionable rhs);
 	}
 }

UnityMultiFramework/Project.cs

@@ -0,0 +1,86 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Text.RegularExpressions;
+using System.Linq;
+using System.Text;
+
+namespace UnityMultiFramework
+{
+
+	[System.Diagnostics.DebuggerDisplay("Name = {Name}, Version = {ProjectVersionString}")]
+	public class Project : IVersionable, IEquatable<Project>, ILaunchable
+	{
+		//m_EditorVersion: 2017.1.0f3
+		private static Regex versionExp = new Regex(@"^m_EditorVersion: (\d+\.\d+\.\d+([A-z]{1,4})\d+)", RegexOptions.Compiled);
+
+		public Project(Uri location)
+		{
+			Location = location;
+			LoadVersionInfo();
+			Name = Uri.UnescapeDataString(Location.Segments.Last());
+		}
+
+		public string Name { get; private set; }
+
+		public Uri Location { get; private set; }
+
+		public string ProjectVersionString { get; private set; }
+
+		public Version Version { get; private set; }
+
+		public string VersionType { get; private set; }
+
+		private void LoadVersionInfo()
+		{
+			var filename = Path.Combine(Location.LocalPath, @"ProjectSettings\ProjectVersion.txt");
+			if (File.Exists(filename))
+			{
+				var filedata = File.ReadAllText(filename, Encoding.UTF8);
+				var matches = versionExp.Match(filedata);
+				try
+				{
+					ProjectVersionString = matches.Groups[1].Value;
+					VersionType = matches.Groups[2].Value;
+					Version = Version.Parse(ProjectVersionString.Replace(VersionType, "."));
+				}
+				catch (Exception E)
+				{
+					E.Data["ProjectText"] = filedata.ToString();
+					E.Data["Matches"] = matches.ToString();
+					throw;
+				}
+			}
+		}
+
+		public void Launch(params string[] args)
+			=> Launch(Unity.Executables.ClosestExecutables(this).First(), args);
+
+		public void Launch(Executable exe = null, params string[] args)
+		{
+			var argsList = args.ToList();
+			argsList.Insert(0, $@"-projectpath ""{Location.LocalPath}""");
+
+			exe.Launch(argsList.ToArray());
+		}
+
+		#region Interfaces
+
+		public int CompareTo(IVersionable other)
+		{
+			return this.Version.CompareTo(other.Version);
+		}
+
+		public bool Equals(IVersionable other)
+		{
+			return Version == other.Version && VersionType == other.VersionType;
+		}
+
+		public bool Equals(Project other)
+		{
+			return Location == other.Location;
+		}
+
+		#endregion
+	}
+}