Remove unnecessary and poorly worded part of xmldoc

This isn't relevant to consumers, and the underlying implementation
could very well change (for potential future implementations).

--- osu.Framework/Input/ReadableKeyCombinationProvider.cs
+++ osu.Framework/Input/ReadableKeyCombinationProvider.cs
@@ -5,7 +5,6 @@
 using System.Linq;
 using osu.Framework.Extensions.EnumExtensions;
 using osu.Framework.Input.Bindings;
-using osu.Framework.Platform;

 namespace osu.Framework.Input
 {
@@ -14,9 +13,6 @@
         /// <summary>
         /// Invoked when the system keyboard layout has changed.
         /// </summary>
-        /// <remarks>
-        /// Mirrored from <see cref="IWindow.KeymapChanged"/> for convenience.
-        /// </remarks>
         public event Action KeymapChanged;

         internal void OnKeymapChanged()


minor change (from merge)

minor change (from merge)


Fix repetitive IPN for lightning network payments (https://github.com/btcpayserver/btcpayserver/issues/564)


working on timer

working on timer


Revised VS2019 support.

Revised VS2019 support.


AttributesDirectiveクラスにregionを追加

AttributesDirectiveクラスにregionを追加


Add AppSerializer for windows phone

Add AppSerializer for windows phone


updated tests

updated tests

git-tfs-id: [https://tfs.caes.ucdavis.edu:8088/tfs/DefaultCollection]$/CRP/Trunk/CRP;C9567

--- CRP.Tests/Repositories/DisplayProfileRepositoryTests.cs
+++ CRP.Tests/Repositories/DisplayProfileRepositoryTests.cs
@@ -525,41 +525,6 @@
         #endregion SchoolMaster Tests

         #region CustomCss Tests
-        #region Invalid Tests
-
-        /// <summary>
-        /// Tests the CustomCss with too long value does not save.
-        /// </summary>
-        [TestMethod]
-        [ExpectedException(typeof(ApplicationException))]
-        public void TestCustomCssWithTooLongValueDoesNotSave()
-        {
-            DisplayProfile displayProfile = null;
-            try
-            {
-                #region Arrange
-                displayProfile = GetValid(9);
-                displayProfile.CustomCss = "x".RepeatTimes((50 + 1));
-                #endregion Arrange
-
-                #region Act
-                DisplayProfileRepository.DbContext.BeginTransaction();
-                DisplayProfileRepository.EnsurePersistent(displayProfile);
-                DisplayProfileRepository.DbContext.CommitTransaction();
-                #endregion Act
-            }
-            catch (Exception)
-            {
-                Assert.IsNotNull(displayProfile);
-                Assert.AreEqual(50 + 1, displayProfile.CustomCss.Length);
-                var results = displayProfile.ValidationResults().AsMessageList();
-                results.AssertErrorsAre("CustomCss: length must be between 0 and 50");
-                Assert.IsTrue(displayProfile.IsTransient());
-                Assert.IsFalse(displayProfile.IsValid());
-                throw;
-            }
-        }
-        #endregion Invalid Tests

         #region Valid Tests

@@ -663,17 +628,17 @@
         {
             #region Arrange
             var displayProfile = GetValid(9);
-            displayProfile.CustomCss = "x".RepeatTimes(50);
-            #endregion Arrange
-
-            #region Act
-            DisplayProfileRepository.DbContext.BeginTransaction();
-            DisplayProfileRepository.EnsurePersistent(displayProfile);
-            DisplayProfileRepository.DbContext.CommitTransaction();
-            #endregion Act
-
-            #region Assert
-            Assert.AreEqual(50, displayProfile.CustomCss.Length);
+            displayProfile.CustomCss = "x".RepeatTimes(500);
+            #endregion Arrange
+
+            #region Act
+            DisplayProfileRepository.DbContext.BeginTransaction();
+            DisplayProfileRepository.EnsurePersistent(displayProfile);
+            DisplayProfileRepository.DbContext.CommitTransaction();
+            #endregion Act
+
+            #region Assert
+            Assert.AreEqual(500, displayProfile.CustomCss.Length);
             Assert.IsFalse(displayProfile.IsTransient());
             Assert.IsTrue(displayProfile.IsValid());
             #endregion Assert
@@ -802,7 +767,8 @@
         {
             #region Arrange

-            var expectedFields = new List<NameAndType>();
+            var expectedFields = new List<NameAndType>();
+            expectedFields.Add(new NameAndType("CustomCss", "System.String", new List<string>()));
             expectedFields.Add(new NameAndType("DepartmentAndSchool", "System.Boolean", new List<string>
             {
                  "[NHibernate.Validator.Constraints.AssertTrueAttribute(Message = \"Department and School cannot be selected together.\")]"
@@ -811,10 +777,7 @@
             {
                  "[NHibernate.Validator.Constraints.AssertTrueAttribute(Message = \"A Department or School must be specified.\")]"
             }));
-            expectedFields.Add(new NameAndType("CustomCss", "System.String", new List<string>
-            {
-                 "[NHibernate.Validator.Constraints.LengthAttribute((Int32)50)]"
-            }));
+
             expectedFields.Add(new NameAndType("Id", "System.Int32", new List<string>
             {
                  "[Newtonsoft.Json.JsonPropertyAttribute()]",


Removed restrictions

Removed restrictions

--- CSharpTradeOffers/Configuration/GenericConfigHandler.cs
+++ CSharpTradeOffers/Configuration/GenericConfigHandler.cs
@@ -20,7 +20,7 @@
         /// Reloads the configuration file (path). If file is not present, it will generate a new one.
         /// </summary>
         /// <returns>A generic object where TConfig:IConfig.</returns>
-        public TConfig Reload<TConfig>(TConfig config) where TConfig : ConfigFrame
+        public TConfig Reload<TConfig>(TConfig config)
         {
             if (!File.Exists(_path))
             {
@@ -42,7 +42,7 @@
         /// Writes the changes made to the config.
         /// </summary>
         /// <param name="towrite"></param>
-        public void WriteChanges<TConfig>(TConfig towrite) where TConfig : ConfigFrame
+        public void WriteChanges<TConfig>(TConfig towrite)
         {
             File.WriteAllText(_path, towrite.SerializeToXml());
         }


beauty

beauty

--- CSharpTradeOffers/Configuration/GenericConfigHandler.cs
+++ CSharpTradeOffers/Configuration/GenericConfigHandler.cs
@@ -20,7 +20,7 @@
         /// Reloads the configuration file (path). If file is not present, it will generate a new one.
         /// </summary>
         /// <returns>A generic object where TConfig:IConfig.</returns>
-        public TConfig Reload<TConfig>(TConfig config) where TConfig: ConfigFrame
+        public TConfig Reload<TConfig>(TConfig config) where TConfig : ConfigFrame
         {
             if (!File.Exists(_path))
             {


CCI - 2466 class def fix

CCI - 2466 class def fix

--- ComputeClient/Compute.Contracts/Drs/ConsistencyGroup.cs
+++ ComputeClient/Compute.Contracts/Drs/ConsistencyGroup.cs
@@ -309,18 +309,6 @@

         /// <remarks/>
         public string targetServerId;
-
-        /// <remarks/>
-        [System.Xml.Serialization.XmlAttributeAttribute()]
-        public string id;
-
-        /// <remarks/>
-        [System.Xml.Serialization.XmlAttributeAttribute()]
-        public string state;
-
-        /// <remarks/>
-        [System.Xml.Serialization.XmlAttributeAttribute()]
-        public bool reIpAddressRulesDefined;
     }


Make properties camel case

Make properties camel case

--- src/Anywhere.ArcGIS/Operation/ServiceLayerDescription.cs
+++ src/Anywhere.ArcGIS/Operation/ServiceLayerDescription.cs
@@ -199,56 +199,56 @@
     public class LayerTimeInfo
     {
         [DataMember(Name = "startTimeField")]
-        public string startTimeField { get; set; }
+        public string StartTimeField { get; set; }

         [DataMember(Name = "endTimeField")]
-        public string endTimeField { get; set; }
+        public string EndTimeField { get; set; }

         [DataMember(Name = "trackIdField")]
-        public string trackIdField { get; set; }
+        public string TrackIdField { get; set; }

         [DataMember(Name = "timeExtent")]
-        public List<long> timeExtent { get; set; }
+        public List<long> TimeExtent { get; set; }

         [DataMember(Name = "timeReference")]
-        public TimeReference timeReference { get; set; }
+        public TimeReference TimeReference { get; set; }

         [DataMember(Name = "timeInterval")]
-        public int timeInterval { get; set; }
+        public int TimeInterval { get; set; }

         [DataMember(Name = "timeIntervalUnits")]
-        public string timeIntervalUnits { get; set; }
+        public string TimeIntervalUnits { get; set; }

         [DataMember(Name = "exportOptions")]
-        public ExportOptions exportOptions { get; set; }
+        public ExportOptions ExportOptions { get; set; }

         [DataMember(Name = "hasLiveData")]
-        public bool hasLiveData { get; set; }
+        public bool HasLiveData { get; set; }
     }

     [DataContract]
     public class ExportOptions
     {
         [DataMember(Name = "useTime")]
-        public bool useTime { get; set; }
+        public bool UseTime { get; set; }

         [DataMember(Name = "timeDataCumulative")]
-        public bool timeDataCumulative { get; set; }
+        public bool TimeDataCumulative { get; set; }

         [DataMember(Name = "timeOffset")]
-        public int timeOffset { get; set; }
+        public int TimeOffset { get; set; }

         [DataMember(Name = "timeOffsetUnits")]
-        public string timeOffsetUnits { get; set; }
+        public string TimeOffsetUnits { get; set; }
     }

     [DataContract]
     public class TimeReference
     {
         [DataMember(Name = "timeZone")]
-        public string timeZone { get; set; }
+        public string TimeZone { get; set; }

         [DataMember(Name = "respectsDaylightSaving")]
-        public bool respectsDaylightSaving { get; set; }
+        public bool RespectsDaylightSaving { get; set; }
     }
 }


Protect TextMate sending wrong offsets

Protect TextMate sending wrong offsets

--- src/AvaloniaEdit.TextMate/TextMateColoringTransformer.cs
+++ src/AvaloniaEdit.TextMate/TextMateColoringTransformer.cs
@@ -90,7 +90,7 @@
                 var startIndex = token.StartIndex;
                 var endIndex = nextToken?.StartIndex ?? _model.GetLines().GetLineLength(lineNumber - 1);

-                if (startIndex == endIndex || token.Scopes == null || token.Scopes.Count == 0)
+                if (endIndex <= startIndex || token.Scopes == null || token.Scopes.Count == 0)
                 {
                     continue;
                 }


Allow KeepAlive controller Ping method to be requested by non local requests (#10126)

* Allow KeepAlive controller Ping method to be requested by non local requests and accept head requests

* removed unused references

--- src/Umbraco.Web/Editors/KeepAliveController.cs
+++ src/Umbraco.Web/Editors/KeepAliveController.cs
@@ -1,14 +1,12 @@
 using System.Runtime.Serialization;
 using System.Web.Http;
-using Umbraco.Web.Mvc;
 using Umbraco.Web.WebApi;
-using Umbraco.Web.WebApi.Filters;

 namespace Umbraco.Web.Editors
 {
     public class KeepAliveController : UmbracoApiController
     {
-        [OnlyLocalRequests]
+        [HttpHead]
         [HttpGet]
         public KeepAlivePingResult Ping()
         {


Added Shuffle extension method

Added Shuffle extension method

--- ZedSharp/Collections.cs
+++ ZedSharp/Collections.cs
@@ -84,12 +84,25 @@

         public static IEnumerable<int> Indicies<A>(this IEnumerable<A> seq)
         {
-            return seq.Select((x, i) => i);
+            return Enumerable.Range(0, seq.Count());
         }

         public static IEnumerable<A> WithoutAt<A>(this IEnumerable<A> seq, int index)
         {
             return seq.Take(index).Concat(seq.Skip(index + 1));
         }
+
+        public static IEnumerable<A> Shuffle<A>(this IEnumerable<A> seq)
+        {
+            var rand = new Random();
+            var temp = seq.ToArray();
+
+            foreach (var i in seq.Indicies())
+            {
+                int j = rand.Next(i, temp.Length);
+                yield return temp[j];
+                temp[j] = temp[i];
+            }
+        }
     }
 }


[director] Fixed note deletion failure.

[director] Fixed note deletion failure.

--- DereTore.Applications.StarlightDirector/Entities/Bar.cs
+++ DereTore.Applications.StarlightDirector/Entities/Bar.cs
@@ -18,7 +18,7 @@
         }

         public bool RemoveNote(Note note) {
-            if (Notes.Contains(note)) {
+            if (!Notes.Contains(note)) {
                 return false;
             }
             Notes.Remove(note);


Fix StackChange value for OpCodes.Stelem (dotnet/coreclr#25382)

Fixes dotnet/corefx#37955

Signed-off-by: dotnet-bot <03c4cb6107ae99956a7681f2c97ff7104809a2bd@microsoft.com>

--- src/Common/src/CoreLib/System/Reflection/Emit/OpCodes.cs
+++ src/Common/src/CoreLib/System/Reflection/Emit/OpCodes.cs
@@ -1,6 +1,16 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
+
+/*============================================================
+**
+** Class: OpCodes
+**
+** Purpose: Exposes all of the IL instructions supported by the runtime.
+**
+** THIS FILE IS AUTOMATICALLY GENERATED. DO NOT EDIT BY HAND!
+** See $(RepoRoot)\src\inc\OpCodeGen.pl for more information.**
+==============================================================*/

 namespace System.Reflection.Emit
 {
@@ -1875,7 +1885,7 @@
             ((int)StackBehaviour.Popref_popi_pop1 << OpCode.StackBehaviourPopShift) |
             ((int)StackBehaviour.Push0 << OpCode.StackBehaviourPushShift) |
             (1 << OpCode.SizeShift) |
-            (0 << OpCode.StackChangeShift)
+            (-3 << OpCode.StackChangeShift)
         );

         public static readonly OpCode Unbox_Any = new OpCode(OpCodeValues.Unbox_Any,


foreach() removal

foreach() removal

--- NLog/src/NLog/LoggerImpl.cs
+++ NLog/src/NLog/LoggerImpl.cs
@@ -82,7 +82,9 @@
             bool needTrace = false;
             bool needTraceSources = false;

-            foreach (Appender app in appenders) {
+            for (int i = 0; i < appenders.Count; ++i) {
+                Appender app = (Appender)appenders[i];
+
                 int nst = app.NeedsStackTrace();

                 if (nst > 1) {
@@ -116,7 +118,9 @@
                 logMessage.SetStackTrace(stackTrace, firstUserFrame);
             }
 #endif
-            foreach (Appender app in appenders) {
+            for (int i = 0; i < appenders.Count; ++i) {
+                Appender app = (Appender)appenders[i];
+
                 try {
                     app.Append(logMessage);
                 }


Fix winners display sequence.

Fix winners display sequence.

--- src/CompetitionPlatform/Controllers/ProjectController.cs
+++ src/CompetitionPlatform/Controllers/ProjectController.cs
@@ -306,6 +306,8 @@

             var winnersList = await _winnersRepository.GetWinnersAsync(model.Id);

+            winnersList = winnersList.OrderBy(x => x.Place).ThenByDescending(x => x.Votes).ThenByDescending(x => x.Score);
+
             model.ResultsPartial.Winners = winnersList;

             return model;


Make a bunch of helper methods static that don't need instance state

--- src/Compilers/Shared/ShadowCopyAnalyzerAssemblyLoader.cs
+++ src/Compilers/Shared/ShadowCopyAnalyzerAssemblyLoader.cs
@@ -103,7 +103,7 @@
             return base.LoadImpl(shadowCopyPath);
         }

-        private string CopyFileAndResources(string fullPath, string assemblyDirectory)
+        private static string CopyFileAndResources(string fullPath, string assemblyDirectory)
         {
             string fileNameWithExtension = Path.GetFileName(fullPath);
             string shadowCopyPath = Path.Combine(assemblyDirectory, fileNameWithExtension);
@@ -137,7 +137,7 @@
             return shadowCopyPath;
         }

-        private void CopyFile(string originalPath, string shadowCopyPath)
+        private static void CopyFile(string originalPath, string shadowCopyPath)
         {
             var directory = Path.GetDirectoryName(shadowCopyPath);
             Directory.CreateDirectory(directory);
@@ -147,7 +147,7 @@
             ClearReadOnlyFlagOnFile(new FileInfo(shadowCopyPath));
         }

-        private void ClearReadOnlyFlagOnFiles(string directoryPath)
+        private static void ClearReadOnlyFlagOnFiles(string directoryPath)
         {
             DirectoryInfo directory = new DirectoryInfo(directoryPath);

@@ -157,7 +157,7 @@
             }
         }

-        private void ClearReadOnlyFlagOnFile(FileInfo fileInfo)
+        private static void ClearReadOnlyFlagOnFile(FileInfo fileInfo)
         {
             try
             {


updated CustomerController

updated CustomerController

--- src/ConfigService.Api/Controllers/CustomersController.cs
+++ src/ConfigService.Api/Controllers/CustomersController.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using ConfigService.Api.ViewModels;
@@ -67,6 +67,26 @@
         }

         /// <summary>
+        /// Get a customers settings
+        /// </summary>
+        /// <param name="customerId"></param>
+        /// <returns></returns>
+        [HttpGet("{customerid}/settings", Name = "GetCustomersSettings")]
+        [SwaggerResponse(200, typeof(List<Setting>), "Get a customers settings")]
+        [SwaggerResponse(404, null, "A customer with the provided Id was not found")]
+        public IActionResult GetCustomerSettings(Guid customerId)
+        {
+            var customer = _repository.GetListOf(c => c.Id == customerId, c => c.Name).SingleOrDefault();
+            if (customer == null)
+            {
+                _logger.LogError($"No customer found with the id of {customerId}");
+                return NotFound();
+            }
+
+            return RedirectToRoute("GetSettingsForCustomer", customerId);
+        }
+
+        /// <summary>
         /// Create a new customer
         /// </summary>
         /// <param name="customerFromPost"></param>
@@ -77,6 +97,7 @@
         {
             if (customerFromPost == null)
             {
+                _logger.LogError("The customer from a Post was null.");
                 return BadRequest();
             }

@@ -109,6 +130,7 @@
             var customer = _repository.GetListOf(c => c.Id == id).SingleOrDefault();
             if (customer == null)
             {
+                _logger.LogError("Could not delete customer with the id {id} as it does not exist in the repository.");
                 return NotFound();
             }


Updated Array.joinImpl

Updated Array.joinImpl

--- NiL.JS/BaseLibrary/Array.cs
+++ NiL.JS/BaseLibrary/Array.cs
@@ -913,58 +913,60 @@
         [DoNotEnumerate]
         [InstanceMember]
         [ArgumentsCount(1)]
-        public static JSValue join(JSValue self, Arguments separator)
-        {
-            return joinImpl(self, separator == null || separator.length == 0 || !separator[0].Defined ? "," : separator[0].ToString(), false);
+        public static JSValue join(JSValue self, Arguments args)
+        {
+            return joinImpl(self, args == null || args.length == 0 || !args[0].Defined ? "," : args[0].ToString(), false);
         }

         private static string joinImpl(JSValue self, string separator, bool locale)
         {
-            if ((self._oValue == null && self._valueType >= JSValueType.Object) || self._valueType <= JSValueType.Undefined)
+            if (self == null || self._valueType <= JSValueType.Undefined || (self._valueType >= JSValueType.Object && self.Value == null))
                 ExceptionHelper.Throw(new TypeError("Array.prototype.join called for null or undefined"));

-            if (self._valueType >= JSValueType.Object && self._oValue.GetType() == typeof(Array))
-            {
-                var selfa = self as Array;
-                if (selfa._data.Length == 0)
-                    return "";
-                var _data = selfa._data;
-                try
-                {
-                    selfa._data = emptyData;
-                    System.Text.StringBuilder sb = new System.Text.StringBuilder();
-                    JSValue t;
-                    JSValue temp = 0;
-                    for (var i = 0L; i < (long)_data.Length; i++)
-                    {
-                        t = _data[(int)i];
-                        if (i <= int.MaxValue)
-                            temp._iValue = (int)i;
-                        else
-                        {
-                            temp._dValue = i;
-                            temp._valueType = JSValueType.Double;
-                        }
-                        if (((t != null && t.Exists) || null != (t = self.GetProperty(temp, false, PropertyScope.Сommon)))
-                            && t.Defined)
-                        {
-                            if (t._valueType < JSValueType.String || t._oValue != null)
-                                sb.Append(locale ? t.ToPrimitiveValue_LocaleString_Value() : t.ToPrimitiveValue_String_Value());
-                        }
-                        sb.Append(separator);
-                    }
-                    sb.Length -= separator.Length;
-                    return sb.ToString();
-                }
-                finally
-                {
-                    selfa._data = _data;
-                }
-            }
-            else
-            {
-                return joinImpl(Tools.arraylikeToArray(self, true, false, false, -1), separator, locale);
-            }
+            var selfA = self.Value as Array;
+            selfA = selfA ?? Tools.arraylikeToArray(self, true, false, false, -1);
+
+            var _data = selfA._data;
+
+            if (_data == null || _data.Length == 0)
+                return "";
+
+            var sb = new System.Text.StringBuilder();
+            JSValue t, temp = 0;
+
+            for (long i = 0; i < _data.Length; i++)
+            {
+                if (i > 0)
+                    sb.Append(separator);
+
+                int index = unchecked((int)i);
+                t = _data[index];
+
+                if (t == null || !t.Exists)
+                {
+                    if (i <= int.MaxValue)
+                    {
+                        temp._iValue = index;
+                        temp._valueType = JSValueType.Integer;
+                    }
+                    else
+                    {
+                        temp._dValue = i;
+                        temp._valueType = JSValueType.Double;
+                    }
+                    t = self.GetProperty(temp, false, PropertyScope.Сommon);
+                }
+
+                if (t != null && t.Defined)
+                {
+                    if (t._valueType == JSValueType.String)
+                        sb.Append(t.ToString());
+                    else if (t._valueType < JSValueType.String || t._oValue != null)
+                        sb.Append(locale ? t.ToPrimitiveValue_LocaleString_Value() : t.ToPrimitiveValue_String_Value());
+                }
+            }
+
+            return sb.ToString();
         }

         [DoNotEnumerate]


TrackActions: Use "" instead of null for empty accels (bgo#657565)

Setting the accelerator parameter in ActionEntry to null causes the
accelerator to be uneditable. So we set the accelerator to "" instead,
except for stock actions because we want to keep the default accelerator
for those.

Signed-off-by: Bertrand Lorentz <eb7ac131ef7bff6d2ebccd6e5bf9a7cb6485cf2c@gmail.com>

--- src/Core/Banshee.ThickClient/Banshee.Gui/TrackActions.cs
+++ src/Core/Banshee.ThickClient/Banshee.Gui/TrackActions.cs
@@ -123,11 +123,11 @@
                     Catalog.GetString ("View information on selected tracks"), OnTrackProperties),

                 new ActionEntry ("PlayTrack", null,
-                    Catalog.GetString ("_Play"), null,
+                    Catalog.GetString ("_Play"), "",
                     Catalog.GetString ("Play the selected item"), OnPlayTrack),

                 new ActionEntry ("AddToPlaylistAction", null,
-                    Catalog.GetString ("Add _to Playlist"), null,
+                    Catalog.GetString ("Add _to Playlist"), "",
                     Catalog.GetString ("Append selected items to playlist or create new playlist from selection"),
                     OnAddToPlaylistMenu),

@@ -145,11 +145,11 @@
                     Catalog.GetString ("Remove selected track(s) from library"), OnRemoveTracksFromLibrary),

                 new ActionEntry ("OpenContainingFolderAction", null,
-                    Catalog.GetString ("_Open Containing Folder"), null,
+                    Catalog.GetString ("_Open Containing Folder"), "",
                     Catalog.GetString ("Open the folder that contains the selected item"), OnOpenContainingFolder),

                 new ActionEntry ("DeleteTracksFromDriveAction", null,
-                    Catalog.GetString ("_Delete From Drive"), null,
+                    Catalog.GetString ("_Delete From Drive"), "",
                     Catalog.GetString ("Permanently delete selected item(s) from medium"), OnDeleteTracksFromDrive),

                 new ActionEntry ("RateTracksAction", null,
@@ -160,11 +160,11 @@
                     Catalog.GetString ("Search for items matching certain criteria"), null),

                 new ActionEntry ("SearchForSameAlbumAction", null,
-                    Catalog.GetString ("By Matching _Album"), null,
+                    Catalog.GetString ("By Matching _Album"), "",
                     Catalog.GetString ("Search all songs of this album"), OnSearchForSameAlbum),

                 new ActionEntry ("SearchForSameArtistAction", null,
-                    Catalog.GetString ("By Matching A_rtist"), null,
+                    Catalog.GetString ("By Matching A_rtist"), "",
                     Catalog.GetString ("Search all songs of this artist"), OnSearchForSameArtist),
             });


dont use AddAsync on context. it's useless

--- SoraBot/SoraBot.Data/Extensions/SoraContextExtensions.cs
+++ SoraBot/SoraBot.Data/Extensions/SoraContextExtensions.cs
@@ -14,7 +14,7 @@

             // Otherwise we'll have to create the user ourselves
             user = new User(){Id = userId};
-            await users.AddAsync(user);
+            users.Add(user);
             return user;
         }
     }


chore: more comments

chore: more comments

--- src/JsonApiDotNetCore/Hooks/Traversal/TraversalHelper.cs
+++ src/JsonApiDotNetCore/Hooks/Traversal/TraversalHelper.cs
@@ -193,6 +193,11 @@
             return newEntities;
         }

+        /// <summary>
+        /// Parses all relationships from <paramref name="type"/> to
+        /// other models in the resource graphs by constructing RelationshipProxies .
+        /// </summary>
+        /// <param name="type">The type to parse</param>
         void RegisterRelationshipProxies(DependentType type)
         {
             var contextEntity = _graph.GetContextEntity(type);


Fixed Substring bug in Support.StringCharSequenceWrapper

--- src/Lucene.Net.Core/Support/StringCharSequenceWrapper.cs
+++ src/Lucene.Net.Core/Support/StringCharSequenceWrapper.cs
@@ -23,7 +23,7 @@

         public ICharSequence SubSequence(int start, int end)
         {
-            return new StringCharSequenceWrapper(value.Substring(start, end));
+            return new StringCharSequenceWrapper(value.Substring(start, end - start));
         }

         public override int GetHashCode()


Added logging in autofac middleware

Added logging in autofac middleware

--- source/Core/Configuration/Hosting/AutofacContainerMiddleware.cs
+++ source/Core/Configuration/Hosting/AutofacContainerMiddleware.cs
@@ -20,11 +20,14 @@
 using System.Collections.Generic;
 using System.Threading.Tasks;
 using Thinktecture.IdentityServer.Core.Extensions;
+using Thinktecture.IdentityServer.Core.Logging;

 namespace Thinktecture.IdentityServer.Core.Configuration.Hosting
 {
     internal class AutofacContainerMiddleware
     {
+        readonly private static ILog Logger = LogProvider.GetCurrentClassLogger();
+
         readonly private Func<IDictionary<string, object>, Task> _next;
         readonly private IContainer _container;

@@ -38,17 +41,25 @@
         {
             var context = new OwinContext(env);

-            // this creates a per-request, disposable scope
-            using (var scope = _container.BeginLifetimeScope(b =>
+            try
             {
-                // this makes owin context resolvable in the scope
-                b.RegisterInstance(context).As<IOwinContext>();
-            }))
+                // this creates a per-request, disposable scope
+                using (var scope = _container.BeginLifetimeScope(b =>
+                {
+                    // this makes owin context resolvable in the scope
+                    b.RegisterInstance(context).As<IOwinContext>();
+                }))
+                {
+                    // this makes scope available for downstream frameworks
+                    env.SetLifetimeScope(scope);
+
+                    await _next(env);
+                }
+            }
+            catch (Exception ex)
             {
-                // this makes scope available for downstream frameworks
-                env.SetLifetimeScope(scope);
-
-                await _next(env);
+                Logger.FatalException("unhandled exception in Autofac middleware", ex);
+                throw;
             }
         }
     }


Changed switch statements to fix building on Linux and macOS.

--- src/Magick.NET/Shared/Profiles/Exif/Values/ExifValues.cs
+++ src/Magick.NET/Shared/Profiles/Exif/Values/ExifValues.cs
@@ -22,292 +22,294 @@
         {
             bool isArray = numberOfComponents != 1;

-            return dataType switch
+            switch (dataType)
             {
-                ExifDataType.Byte => isArray ? (ExifValue)new ExifByteArray(tag, dataType) : new ExifByte(tag, dataType),
-                ExifDataType.Double => isArray ? (ExifValue)new ExifDoubleArray(tag) : new ExifDouble(tag),
-                ExifDataType.Float => isArray ? (ExifValue)new ExifFloatArray(tag) : new ExifFloat(tag),
-                ExifDataType.Long => isArray ? (ExifValue)new ExifLongArray(tag) : new ExifLong(tag),
-                ExifDataType.Rational => isArray ? (ExifValue)new ExifRationalArray(tag) : new ExifRational(tag),
-                ExifDataType.Short => isArray ? (ExifValue)new ExifShortArray(tag) : new ExifShort(tag),
-                ExifDataType.SignedByte => isArray ? (ExifValue)new ExifSignedByteArray(tag) : new ExifSignedByte(tag),
-                ExifDataType.SignedLong => isArray ? (ExifValue)new ExifSignedLongArray(tag) : new ExifSignedLong(tag),
-                ExifDataType.SignedRational => isArray ? (ExifValue)new ExifSignedRationalArray(tag) : new ExifSignedRational(tag),
-                ExifDataType.SignedShort => isArray ? (ExifValue)new ExifSignedShortArray(tag) : new ExifSignedShort(tag),
-                ExifDataType.String => new ExifString(tag),
-                ExifDataType.Undefined => isArray ? (ExifValue)new ExifByteArray(tag, dataType) : new ExifByte(tag, dataType),
-
-                _ => null,
-            };
+                case ExifDataType.Byte: return isArray ? (ExifValue)new ExifByteArray(tag, dataType) : new ExifByte(tag, dataType);
+                case ExifDataType.Double: return isArray ? (ExifValue)new ExifDoubleArray(tag) : new ExifDouble(tag);
+                case ExifDataType.Float: return isArray ? (ExifValue)new ExifFloatArray(tag) : new ExifFloat(tag);
+                case ExifDataType.Long: return isArray ? (ExifValue)new ExifLongArray(tag) : new ExifLong(tag);
+                case ExifDataType.Rational: return isArray ? (ExifValue)new ExifRationalArray(tag) : new ExifRational(tag);
+                case ExifDataType.Short: return isArray ? (ExifValue)new ExifShortArray(tag) : new ExifShort(tag);
+                case ExifDataType.SignedByte: return isArray ? (ExifValue)new ExifSignedByteArray(tag) : new ExifSignedByte(tag);
+                case ExifDataType.SignedLong: return isArray ? (ExifValue)new ExifSignedLongArray(tag) : new ExifSignedLong(tag);
+                case ExifDataType.SignedRational: return isArray ? (ExifValue)new ExifSignedRationalArray(tag) : new ExifSignedRational(tag);
+                case ExifDataType.SignedShort: return isArray ? (ExifValue)new ExifSignedShortArray(tag) : new ExifSignedShort(tag);
+                case ExifDataType.String: return new ExifString(tag);
+                case ExifDataType.Undefined: return isArray ? (ExifValue)new ExifByteArray(tag, dataType) : new ExifByte(tag, dataType);
+                default: return null;
+            }
         }

-        private static object CreateValue(ExifTagValue tag) => tag switch
+        private static object CreateValue(ExifTagValue tag)
         {
-            ExifTagValue.FaxProfile => new ExifByte(ExifTag.FaxProfile, ExifDataType.Byte),
-            ExifTagValue.ModeNumber => new ExifByte(ExifTag.ModeNumber, ExifDataType.Byte),
-            ExifTagValue.GPSAltitudeRef => new ExifByte(ExifTag.GPSAltitudeRef, ExifDataType.Byte),
-
-            ExifTagValue.ClipPath => new ExifByteArray(ExifTag.ClipPath, ExifDataType.Byte),
-            ExifTagValue.VersionYear => new ExifByteArray(ExifTag.VersionYear, ExifDataType.Byte),
-            ExifTagValue.XMP => new ExifByteArray(ExifTag.XMP, ExifDataType.Byte),
-            ExifTagValue.CFAPattern2 => new ExifByteArray(ExifTag.CFAPattern2, ExifDataType.Byte),
-            ExifTagValue.TIFFEPStandardID => new ExifByteArray(ExifTag.TIFFEPStandardID, ExifDataType.Byte),
-            ExifTagValue.XPTitle => new ExifByteArray(ExifTag.XPTitle, ExifDataType.Byte),
-            ExifTagValue.XPComment => new ExifByteArray(ExifTag.XPComment, ExifDataType.Byte),
-            ExifTagValue.XPAuthor => new ExifByteArray(ExifTag.XPAuthor, ExifDataType.Byte),
-            ExifTagValue.XPKeywords => new ExifByteArray(ExifTag.XPKeywords, ExifDataType.Byte),
-            ExifTagValue.XPSubject => new ExifByteArray(ExifTag.XPSubject, ExifDataType.Byte),
-            ExifTagValue.GPSVersionID => new ExifByteArray(ExifTag.GPSVersionID, ExifDataType.Byte),
-
-            ExifTagValue.PixelScale => new ExifDoubleArray(ExifTag.PixelScale),
-            ExifTagValue.IntergraphMatrix => new ExifDoubleArray(ExifTag.IntergraphMatrix),
-            ExifTagValue.ModelTiePoint => new ExifDoubleArray(ExifTag.ModelTiePoint),
-            ExifTagValue.ModelTransform => new ExifDoubleArray(ExifTag.ModelTransform),
-
-            ExifTagValue.SubfileType => new ExifLong(ExifTag.SubfileType),
-            ExifTagValue.SubIFDOffset => new ExifLong(ExifTag.SubIFDOffset),
-            ExifTagValue.GPSIFDOffset => new ExifLong(ExifTag.GPSIFDOffset),
-            ExifTagValue.T4Options => new ExifLong(ExifTag.T4Options),
-            ExifTagValue.T6Options => new ExifLong(ExifTag.T6Options),
-            ExifTagValue.XClipPathUnits => new ExifLong(ExifTag.XClipPathUnits),
-            ExifTagValue.YClipPathUnits => new ExifLong(ExifTag.YClipPathUnits),
-            ExifTagValue.ProfileType => new ExifLong(ExifTag.ProfileType),
-            ExifTagValue.CodingMethods => new ExifLong(ExifTag.CodingMethods),
-            ExifTagValue.T82ptions => new ExifLong(ExifTag.T82ptions),
-            ExifTagValue.JPEGInterchangeFormat => new ExifLong(ExifTag.JPEGInterchangeFormat),
-            ExifTagValue.JPEGInterchangeFormatLength => new ExifLong(ExifTag.JPEGInterchangeFormatLength),
-            ExifTagValue.MDFileTag => new ExifLong(ExifTag.MDFileTag),
-            ExifTagValue.StandardOutputSensitivity => new ExifLong(ExifTag.StandardOutputSensitivity),
-            ExifTagValue.RecommendedExposureIndex => new ExifLong(ExifTag.RecommendedExposureIndex),
-            ExifTagValue.ISOSpeed => new ExifLong(ExifTag.ISOSpeed),
-            ExifTagValue.ISOSpeedLatitudeyyy => new ExifLong(ExifTag.ISOSpeedLatitudeyyy),
-            ExifTagValue.ISOSpeedLatitudezzz => new ExifLong(ExifTag.ISOSpeedLatitudezzz),
-            ExifTagValue.FaxRecvParams => new ExifLong(ExifTag.FaxRecvParams),
-            ExifTagValue.FaxRecvTime => new ExifLong(ExifTag.FaxRecvTime),
-
-            ExifTagValue.FreeOffsets => new ExifLongArray(ExifTag.FreeOffsets),
-            ExifTagValue.FreeByteCounts => new ExifLongArray(ExifTag.FreeByteCounts),
-            ExifTagValue.ColorResponseUnit => new ExifLongArray(ExifTag.TileOffsets),
-            ExifTagValue.TileOffsets => new ExifLongArray(ExifTag.TileOffsets),
-            ExifTagValue.SMinSampleValue => new ExifLongArray(ExifTag.SMinSampleValue),
-            ExifTagValue.SMaxSampleValue => new ExifLongArray(ExifTag.SMaxSampleValue),
-            ExifTagValue.JPEGQTables => new ExifLongArray(ExifTag.JPEGQTables),
-            ExifTagValue.JPEGDCTables => new ExifLongArray(ExifTag.JPEGDCTables),
-            ExifTagValue.JPEGACTables => new ExifLongArray(ExifTag.JPEGACTables),
-            ExifTagValue.StripRowCounts => new ExifLongArray(ExifTag.StripRowCounts),
-            ExifTagValue.IntergraphRegisters => new ExifLongArray(ExifTag.IntergraphRegisters),
-            ExifTagValue.TimeZoneOffset => new ExifLongArray(ExifTag.TimeZoneOffset),
-
-            ExifTagValue.ImageWidth => new ExifNumber(ExifTag.ImageWidth),
-            ExifTagValue.ImageLength => new ExifNumber(ExifTag.ImageLength),
-            ExifTagValue.TileWidth => new ExifNumber(ExifTag.TileWidth),
-            ExifTagValue.TileLength => new ExifNumber(ExifTag.TileLength),
-            ExifTagValue.BadFaxLines => new ExifNumber(ExifTag.BadFaxLines),
-            ExifTagValue.ConsecutiveBadFaxLines => new ExifNumber(ExifTag.ConsecutiveBadFaxLines),
-            ExifTagValue.PixelXDimension => new ExifNumber(ExifTag.PixelXDimension),
-            ExifTagValue.PixelYDimension => new ExifNumber(ExifTag.PixelYDimension),
-
-            ExifTagValue.StripOffsets => new ExifNumberArray(ExifTag.StripOffsets),
-            ExifTagValue.TileByteCounts => new ExifNumberArray(ExifTag.TileByteCounts),
-            ExifTagValue.ImageLayer => new ExifNumberArray(ExifTag.ImageLayer),
-
-            ExifTagValue.XPosition => new ExifRational(ExifTag.XPosition),
-            ExifTagValue.YPosition => new ExifRational(ExifTag.YPosition),
-            ExifTagValue.XResolution => new ExifRational(ExifTag.XResolution),
-            ExifTagValue.YResolution => new ExifRational(ExifTag.YResolution),
-            ExifTagValue.BatteryLevel => new ExifRational(ExifTag.BatteryLevel),
-            ExifTagValue.ExposureTime => new ExifRational(ExifTag.ExposureTime),
-            ExifTagValue.FNumber => new ExifRational(ExifTag.FNumber),
-            ExifTagValue.MDScalePixel => new ExifRational(ExifTag.MDScalePixel),
-            ExifTagValue.CompressedBitsPerPixel => new ExifRational(ExifTag.CompressedBitsPerPixel),
-            ExifTagValue.ApertureValue => new ExifRational(ExifTag.ApertureValue),
-            ExifTagValue.MaxApertureValue => new ExifRational(ExifTag.MaxApertureValue),
-            ExifTagValue.SubjectDistance => new ExifRational(ExifTag.SubjectDistance),
-            ExifTagValue.FocalLength => new ExifRational(ExifTag.FocalLength),
-            ExifTagValue.FlashEnergy2 => new ExifRational(ExifTag.FlashEnergy2),
-            ExifTagValue.FocalPlaneXResolution2 => new ExifRational(ExifTag.FocalPlaneXResolution2),
-            ExifTagValue.FocalPlaneYResolution2 => new ExifRational(ExifTag.FocalPlaneYResolution2),
-            ExifTagValue.ExposureIndex2 => new ExifRational(ExifTag.ExposureIndex2),
-            ExifTagValue.Humidity => new ExifRational(ExifTag.Humidity),
-            ExifTagValue.Pressure => new ExifRational(ExifTag.Pressure),
-            ExifTagValue.Acceleration => new ExifRational(ExifTag.Acceleration),
-            ExifTagValue.FlashEnergy => new ExifRational(ExifTag.FlashEnergy),
-            ExifTagValue.FocalPlaneXResolution => new ExifRational(ExifTag.FocalPlaneXResolution),
-            ExifTagValue.FocalPlaneYResolution => new ExifRational(ExifTag.FocalPlaneYResolution),
-            ExifTagValue.ExposureIndex => new ExifRational(ExifTag.ExposureIndex),
-            ExifTagValue.DigitalZoomRatio => new ExifRational(ExifTag.DigitalZoomRatio),
-            ExifTagValue.LensInfo => new ExifRational(ExifTag.LensInfo),
-            ExifTagValue.GPSAltitude => new ExifRational(ExifTag.GPSAltitude),
-            ExifTagValue.GPSDOP => new ExifRational(ExifTag.GPSDOP),
-            ExifTagValue.GPSSpeed => new ExifRational(ExifTag.GPSSpeed),
-            ExifTagValue.GPSTrack => new ExifRational(ExifTag.GPSTrack),
-            ExifTagValue.GPSImgDirection => new ExifRational(ExifTag.GPSImgDirection),
-            ExifTagValue.GPSDestBearing => new ExifRational(ExifTag.GPSDestBearing),
-            ExifTagValue.GPSDestDistance => new ExifRational(ExifTag.GPSDestDistance),
-
-            ExifTagValue.WhitePoint => new ExifRationalArray(ExifTag.WhitePoint),
-            ExifTagValue.PrimaryChromaticities => new ExifRationalArray(ExifTag.PrimaryChromaticities),
-            ExifTagValue.YCbCrCoefficients => new ExifRationalArray(ExifTag.YCbCrCoefficients),
-            ExifTagValue.ReferenceBlackWhite => new ExifRationalArray(ExifTag.ReferenceBlackWhite),
-            ExifTagValue.GPSLatitude => new ExifRationalArray(ExifTag.GPSLatitude),
-            ExifTagValue.GPSLongitude => new ExifRationalArray(ExifTag.GPSLongitude),
-            ExifTagValue.GPSTimestamp => new ExifRationalArray(ExifTag.GPSTimestamp),
-            ExifTagValue.GPSDestLatitude => new ExifRationalArray(ExifTag.GPSDestLatitude),
-            ExifTagValue.GPSDestLongitude => new ExifRationalArray(ExifTag.GPSDestLongitude),
-
-            ExifTagValue.OldSubfileType => new ExifShort(ExifTag.OldSubfileType),
-            ExifTagValue.Compression => new ExifShort(ExifTag.Compression),
-            ExifTagValue.PhotometricInterpretation => new ExifShort(ExifTag.PhotometricInterpretation),
-            ExifTagValue.Thresholding => new ExifShort(ExifTag.Thresholding),
-            ExifTagValue.CellWidth => new ExifShort(ExifTag.CellWidth),
-            ExifTagValue.CellLength => new ExifShort(ExifTag.CellLength),
-            ExifTagValue.FillOrder => new ExifShort(ExifTag.FillOrder),
-            ExifTagValue.Orientation => new ExifShort(ExifTag.Orientation),
-            ExifTagValue.SamplesPerPixel => new ExifShort(ExifTag.SamplesPerPixel),
-            ExifTagValue.PlanarConfiguration => new ExifShort(ExifTag.PlanarConfiguration),
-            ExifTagValue.GrayResponseUnit => new ExifShort(ExifTag.GrayResponseUnit),
-            ExifTagValue.ResolutionUnit => new ExifShort(ExifTag.ResolutionUnit),
-            ExifTagValue.CleanFaxData => new ExifShort(ExifTag.CleanFaxData),
-            ExifTagValue.InkSet => new ExifShort(ExifTag.InkSet),
-            ExifTagValue.NumberOfInks => new ExifShort(ExifTag.NumberOfInks),
-            ExifTagValue.DotRange => new ExifShort(ExifTag.DotRange),
-            ExifTagValue.Indexed => new ExifShort(ExifTag.Indexed),
-            ExifTagValue.OPIProxy => new ExifShort(ExifTag.OPIProxy),
-            ExifTagValue.JPEGProc => new ExifShort(ExifTag.JPEGProc),
-            ExifTagValue.JPEGRestartInterval => new ExifShort(ExifTag.JPEGRestartInterval),
-            ExifTagValue.YCbCrPositioning => new ExifShort(ExifTag.YCbCrPositioning),
-            ExifTagValue.Rating => new ExifShort(ExifTag.Rating),
-            ExifTagValue.RatingPercent => new ExifShort(ExifTag.RatingPercent),
-            ExifTagValue.ExposureProgram => new ExifShort(ExifTag.ExposureProgram),
-            ExifTagValue.Interlace => new ExifShort(ExifTag.Interlace),
-            ExifTagValue.SelfTimerMode => new ExifShort(ExifTag.SelfTimerMode),
-            ExifTagValue.SensitivityType => new ExifShort(ExifTag.SensitivityType),
-            ExifTagValue.MeteringMode => new ExifShort(ExifTag.MeteringMode),
-            ExifTagValue.LightSource => new ExifShort(ExifTag.LightSource),
-            ExifTagValue.FocalPlaneResolutionUnit2 => new ExifShort(ExifTag.FocalPlaneResolutionUnit2),
-            ExifTagValue.SensingMethod2 => new ExifShort(ExifTag.SensingMethod2),
-            ExifTagValue.Flash => new ExifShort(ExifTag.Flash),
-            ExifTagValue.ColorSpace => new ExifShort(ExifTag.ColorSpace),
-            ExifTagValue.FocalPlaneResolutionUnit => new ExifShort(ExifTag.FocalPlaneResolutionUnit),
-            ExifTagValue.SensingMethod => new ExifShort(ExifTag.SensingMethod),
-            ExifTagValue.CustomRendered => new ExifShort(ExifTag.CustomRendered),
-            ExifTagValue.ExposureMode => new ExifShort(ExifTag.ExposureMode),
-            ExifTagValue.WhiteBalance => new ExifShort(ExifTag.WhiteBalance),
-            ExifTagValue.FocalLengthIn35mmFilm => new ExifShort(ExifTag.FocalLengthIn35mmFilm),
-            ExifTagValue.SceneCaptureType => new ExifShort(ExifTag.SceneCaptureType),
-            ExifTagValue.GainControl => new ExifShort(ExifTag.GainControl),
-            ExifTagValue.Contrast => new ExifShort(ExifTag.Contrast),
-            ExifTagValue.Saturation => new ExifShort(ExifTag.Saturation),
-            ExifTagValue.Sharpness => new ExifShort(ExifTag.Sharpness),
-            ExifTagValue.SubjectDistanceRange => new ExifShort(ExifTag.SubjectDistanceRange),
-            ExifTagValue.GPSDifferential => new ExifShort(ExifTag.GPSDifferential),
-
-            ExifTagValue.BitsPerSample => new ExifShortArray(ExifTag.BitsPerSample),
-            ExifTagValue.MinSampleValue => new ExifShortArray(ExifTag.MinSampleValue),
-            ExifTagValue.MaxSampleValue => new ExifShortArray(ExifTag.MaxSampleValue),
-            ExifTagValue.GrayResponseCurve => new ExifShortArray(ExifTag.GrayResponseCurve),
-            ExifTagValue.ColorMap => new ExifShortArray(ExifTag.ColorMap),
-            ExifTagValue.ExtraSamples => new ExifShortArray(ExifTag.ExtraSamples),
-            ExifTagValue.PageNumber => new ExifShortArray(ExifTag.PageNumber),
-            ExifTagValue.TransferFunction => new ExifShortArray(ExifTag.TransferFunction),
-            ExifTagValue.Predictor => new ExifShortArray(ExifTag.Predictor),
-            ExifTagValue.HalftoneHints => new ExifShortArray(ExifTag.HalftoneHints),
-            ExifTagValue.SampleFormat => new ExifShortArray(ExifTag.SampleFormat),
-            ExifTagValue.TransferRange => new ExifShortArray(ExifTag.TransferRange),
-            ExifTagValue.DefaultImageColor => new ExifShortArray(ExifTag.DefaultImageColor),
-            ExifTagValue.JPEGLosslessPredictors => new ExifShortArray(ExifTag.JPEGLosslessPredictors),
-            ExifTagValue.JPEGPointTransforms => new ExifShortArray(ExifTag.JPEGPointTransforms),
-            ExifTagValue.YCbCrSubsampling => new ExifShortArray(ExifTag.YCbCrSubsampling),
-            ExifTagValue.CFARepeatPatternDim => new ExifShortArray(ExifTag.CFARepeatPatternDim),
-            ExifTagValue.IntergraphPacketData => new ExifShortArray(ExifTag.IntergraphPacketData),
-            ExifTagValue.ISOSpeedRatings => new ExifShortArray(ExifTag.ISOSpeedRatings),
-            ExifTagValue.SubjectArea => new ExifShortArray(ExifTag.SubjectArea),
-            ExifTagValue.SubjectLocation => new ExifShortArray(ExifTag.SubjectLocation),
-
-            ExifTagValue.ShutterSpeedValue => new ExifSignedRational(ExifTag.ShutterSpeedValue),
-            ExifTagValue.BrightnessValue => new ExifSignedRational(ExifTag.BrightnessValue),
-            ExifTagValue.ExposureBiasValue => new ExifSignedRational(ExifTag.ExposureBiasValue),
-            ExifTagValue.AmbientTemperature => new ExifSignedRational(ExifTag.AmbientTemperature),
-            ExifTagValue.WaterDepth => new ExifSignedRational(ExifTag.WaterDepth),
-            ExifTagValue.CameraElevationAngle => new ExifSignedRational(ExifTag.CameraElevationAngle),
-
-            ExifTagValue.Decode => new ExifSignedRationalArray(ExifTag.Decode),
-
-            ExifTagValue.ImageDescription => new ExifString(ExifTag.ImageDescription),
-            ExifTagValue.Make => new ExifString(ExifTag.Make),
-            ExifTagValue.Model => new ExifString(ExifTag.Model),
-            ExifTagValue.Software => new ExifString(ExifTag.Software),
-            ExifTagValue.DateTime => new ExifString(ExifTag.DateTime),
-            ExifTagValue.Artist => new ExifString(ExifTag.Artist),
-            ExifTagValue.HostComputer => new ExifString(ExifTag.HostComputer),
-            ExifTagValue.Copyright => new ExifString(ExifTag.Copyright),
-            ExifTagValue.DocumentName => new ExifString(ExifTag.DocumentName),
-            ExifTagValue.PageName => new ExifString(ExifTag.PageName),
-            ExifTagValue.InkNames => new ExifString(ExifTag.InkNames),
-            ExifTagValue.TargetPrinter => new ExifString(ExifTag.TargetPrinter),
-            ExifTagValue.ImageID => new ExifString(ExifTag.ImageID),
-            ExifTagValue.MDLabName => new ExifString(ExifTag.MDLabName),
-            ExifTagValue.MDSampleInfo => new ExifString(ExifTag.MDSampleInfo),
-            ExifTagValue.MDPrepDate => new ExifString(ExifTag.MDPrepDate),
-            ExifTagValue.MDPrepTime => new ExifString(ExifTag.MDPrepTime),
-            ExifTagValue.MDFileUnits => new ExifString(ExifTag.MDFileUnits),
-            ExifTagValue.SEMInfo => new ExifString(ExifTag.SEMInfo),
-            ExifTagValue.SpectralSensitivity => new ExifString(ExifTag.SpectralSensitivity),
-            ExifTagValue.DateTimeOriginal => new ExifString(ExifTag.DateTimeOriginal),
-            ExifTagValue.DateTimeDigitized => new ExifString(ExifTag.DateTimeDigitized),
-            ExifTagValue.SubsecTime => new ExifString(ExifTag.SubsecTime),
-            ExifTagValue.SubsecTimeOriginal => new ExifString(ExifTag.SubsecTimeOriginal),
-            ExifTagValue.SubsecTimeDigitized => new ExifString(ExifTag.SubsecTimeDigitized),
-            ExifTagValue.RelatedSoundFile => new ExifString(ExifTag.RelatedSoundFile),
-            ExifTagValue.FaxSubaddress => new ExifString(ExifTag.FaxSubaddress),
-            ExifTagValue.OffsetTime => new ExifString(ExifTag.OffsetTime),
-            ExifTagValue.OffsetTimeOriginal => new ExifString(ExifTag.OffsetTimeOriginal),
-            ExifTagValue.OffsetTimeDigitized => new ExifString(ExifTag.OffsetTimeDigitized),
-            ExifTagValue.SecurityClassification => new ExifString(ExifTag.SecurityClassification),
-            ExifTagValue.ImageHistory => new ExifString(ExifTag.ImageHistory),
-            ExifTagValue.ImageUniqueID => new ExifString(ExifTag.ImageUniqueID),
-            ExifTagValue.OwnerName => new ExifString(ExifTag.OwnerName),
-            ExifTagValue.SerialNumber => new ExifString(ExifTag.SerialNumber),
-            ExifTagValue.LensMake => new ExifString(ExifTag.LensMake),
-            ExifTagValue.LensModel => new ExifString(ExifTag.LensModel),
-            ExifTagValue.LensSerialNumber => new ExifString(ExifTag.LensSerialNumber),
-            ExifTagValue.GDALMetadata => new ExifString(ExifTag.GDALMetadata),
-            ExifTagValue.GDALNoData => new ExifString(ExifTag.GDALNoData),
-            ExifTagValue.GPSLatitudeRef => new ExifString(ExifTag.GPSLatitudeRef),
-            ExifTagValue.GPSLongitudeRef => new ExifString(ExifTag.GPSLongitudeRef),
-            ExifTagValue.GPSSatellites => new ExifString(ExifTag.GPSSatellites),
-            ExifTagValue.GPSStatus => new ExifString(ExifTag.GPSStatus),
-            ExifTagValue.GPSMeasureMode => new ExifString(ExifTag.GPSMeasureMode),
-            ExifTagValue.GPSSpeedRef => new ExifString(ExifTag.GPSSpeedRef),
-            ExifTagValue.GPSTrackRef => new ExifString(ExifTag.GPSTrackRef),
-            ExifTagValue.GPSImgDirectionRef => new ExifString(ExifTag.GPSImgDirectionRef),
-            ExifTagValue.GPSMapDatum => new ExifString(ExifTag.GPSMapDatum),
-            ExifTagValue.GPSDestLatitudeRef => new ExifString(ExifTag.GPSDestLatitudeRef),
-            ExifTagValue.GPSDestLongitudeRef => new ExifString(ExifTag.GPSDestLongitudeRef),
-            ExifTagValue.GPSDestBearingRef => new ExifString(ExifTag.GPSDestBearingRef),
-            ExifTagValue.GPSDestDistanceRef => new ExifString(ExifTag.GPSDestDistanceRef),
-            ExifTagValue.GPSDateStamp => new ExifString(ExifTag.GPSDateStamp),
-
-            ExifTagValue.FileSource => new ExifByte(ExifTag.FileSource, ExifDataType.Undefined),
-            ExifTagValue.SceneType => new ExifByte(ExifTag.SceneType, ExifDataType.Undefined),
-
-            ExifTagValue.JPEGTables => new ExifByteArray(ExifTag.JPEGTables, ExifDataType.Undefined),
-            ExifTagValue.OECF => new ExifByteArray(ExifTag.OECF, ExifDataType.Undefined),
-            ExifTagValue.ExifVersion => new ExifByteArray(ExifTag.ExifVersion, ExifDataType.Undefined),
-            ExifTagValue.ComponentsConfiguration => new ExifByteArray(ExifTag.ComponentsConfiguration, ExifDataType.Undefined),
-            ExifTagValue.MakerNote => new ExifByteArray(ExifTag.MakerNote, ExifDataType.Undefined),
-            ExifTagValue.UserComment => new ExifByteArray(ExifTag.UserComment, ExifDataType.Undefined),
-            ExifTagValue.FlashpixVersion => new ExifByteArray(ExifTag.FlashpixVersion, ExifDataType.Undefined),
-            ExifTagValue.SpatialFrequencyResponse => new ExifByteArray(ExifTag.SpatialFrequencyResponse, ExifDataType.Undefined),
-            ExifTagValue.SpatialFrequencyResponse2 => new ExifByteArray(ExifTag.SpatialFrequencyResponse2, ExifDataType.Undefined),
-            ExifTagValue.Noise => new ExifByteArray(ExifTag.Noise, ExifDataType.Undefined),
-            ExifTagValue.CFAPattern => new ExifByteArray(ExifTag.CFAPattern, ExifDataType.Undefined),
-            ExifTagValue.DeviceSettingDescription => new ExifByteArray(ExifTag.DeviceSettingDescription, ExifDataType.Undefined),
-            ExifTagValue.ImageSourceData => new ExifByteArray(ExifTag.ImageSourceData, ExifDataType.Undefined),
-            ExifTagValue.GPSProcessingMethod => new ExifByteArray(ExifTag.GPSProcessingMethod, ExifDataType.Undefined),
-            ExifTagValue.GPSAreaInformation => new ExifByteArray(ExifTag.GPSAreaInformation, ExifDataType.Undefined),
-
-            _ => null,
-        };
+            switch (tag)
+            {
+                case ExifTagValue.FaxProfile: return new ExifByte(ExifTag.FaxProfile, ExifDataType.Byte);
+                case ExifTagValue.ModeNumber: return new ExifByte(ExifTag.ModeNumber, ExifDataType.Byte);
+                case ExifTagValue.GPSAltitudeRef: return new ExifByte(ExifTag.GPSAltitudeRef, ExifDataType.Byte);
+
+                case ExifTagValue.ClipPath: return new ExifByteArray(ExifTag.ClipPath, ExifDataType.Byte);
+                case ExifTagValue.VersionYear: return new ExifByteArray(ExifTag.VersionYear, ExifDataType.Byte);
+                case ExifTagValue.XMP: return new ExifByteArray(ExifTag.XMP, ExifDataType.Byte);
+                case ExifTagValue.CFAPattern2: return new ExifByteArray(ExifTag.CFAPattern2, ExifDataType.Byte);
+                case ExifTagValue.TIFFEPStandardID: return new ExifByteArray(ExifTag.TIFFEPStandardID, ExifDataType.Byte);
+                case ExifTagValue.XPTitle: return new ExifByteArray(ExifTag.XPTitle, ExifDataType.Byte);
+                case ExifTagValue.XPComment: return new ExifByteArray(ExifTag.XPComment, ExifDataType.Byte);
+                case ExifTagValue.XPAuthor: return new ExifByteArray(ExifTag.XPAuthor, ExifDataType.Byte);
+                case ExifTagValue.XPKeywords: return new ExifByteArray(ExifTag.XPKeywords, ExifDataType.Byte);
+                case ExifTagValue.XPSubject: return new ExifByteArray(ExifTag.XPSubject, ExifDataType.Byte);
+                case ExifTagValue.GPSVersionID: return new ExifByteArray(ExifTag.GPSVersionID, ExifDataType.Byte);
+
+                case ExifTagValue.PixelScale: return new ExifDoubleArray(ExifTag.PixelScale);
+                case ExifTagValue.IntergraphMatrix: return new ExifDoubleArray(ExifTag.IntergraphMatrix);
+                case ExifTagValue.ModelTiePoint: return new ExifDoubleArray(ExifTag.ModelTiePoint);
+                case ExifTagValue.ModelTransform: return new ExifDoubleArray(ExifTag.ModelTransform);
+
+                case ExifTagValue.SubfileType: return new ExifLong(ExifTag.SubfileType);
+                case ExifTagValue.SubIFDOffset: return new ExifLong(ExifTag.SubIFDOffset);
+                case ExifTagValue.GPSIFDOffset: return new ExifLong(ExifTag.GPSIFDOffset);
+                case ExifTagValue.T4Options: return new ExifLong(ExifTag.T4Options);
+                case ExifTagValue.T6Options: return new ExifLong(ExifTag.T6Options);
+                case ExifTagValue.XClipPathUnits: return new ExifLong(ExifTag.XClipPathUnits);
+                case ExifTagValue.YClipPathUnits: return new ExifLong(ExifTag.YClipPathUnits);
+                case ExifTagValue.ProfileType: return new ExifLong(ExifTag.ProfileType);
+                case ExifTagValue.CodingMethods: return new ExifLong(ExifTag.CodingMethods);
+                case ExifTagValue.T82ptions: return new ExifLong(ExifTag.T82ptions);
+                case ExifTagValue.JPEGInterchangeFormat: return new ExifLong(ExifTag.JPEGInterchangeFormat);
+                case ExifTagValue.JPEGInterchangeFormatLength: return new ExifLong(ExifTag.JPEGInterchangeFormatLength);
+                case ExifTagValue.MDFileTag: return new ExifLong(ExifTag.MDFileTag);
+                case ExifTagValue.StandardOutputSensitivity: return new ExifLong(ExifTag.StandardOutputSensitivity);
+                case ExifTagValue.RecommendedExposureIndex: return new ExifLong(ExifTag.RecommendedExposureIndex);
+                case ExifTagValue.ISOSpeed: return new ExifLong(ExifTag.ISOSpeed);
+                case ExifTagValue.ISOSpeedLatitudeyyy: return new ExifLong(ExifTag.ISOSpeedLatitudeyyy);
+                case ExifTagValue.ISOSpeedLatitudezzz: return new ExifLong(ExifTag.ISOSpeedLatitudezzz);
+                case ExifTagValue.FaxRecvParams: return new ExifLong(ExifTag.FaxRecvParams);
+                case ExifTagValue.FaxRecvTime: return new ExifLong(ExifTag.FaxRecvTime);
+
+                case ExifTagValue.FreeOffsets: return new ExifLongArray(ExifTag.FreeOffsets);
+                case ExifTagValue.FreeByteCounts: return new ExifLongArray(ExifTag.FreeByteCounts);
+                case ExifTagValue.ColorResponseUnit: return new ExifLongArray(ExifTag.TileOffsets);
+                case ExifTagValue.TileOffsets: return new ExifLongArray(ExifTag.TileOffsets);
+                case ExifTagValue.SMinSampleValue: return new ExifLongArray(ExifTag.SMinSampleValue);
+                case ExifTagValue.SMaxSampleValue: return new ExifLongArray(ExifTag.SMaxSampleValue);
+                case ExifTagValue.JPEGQTables: return new ExifLongArray(ExifTag.JPEGQTables);
+                case ExifTagValue.JPEGDCTables: return new ExifLongArray(ExifTag.JPEGDCTables);
+                case ExifTagValue.JPEGACTables: return new ExifLongArray(ExifTag.JPEGACTables);
+                case ExifTagValue.StripRowCounts: return new ExifLongArray(ExifTag.StripRowCounts);
+                case ExifTagValue.IntergraphRegisters: return new ExifLongArray(ExifTag.IntergraphRegisters);
+                case ExifTagValue.TimeZoneOffset: return new ExifLongArray(ExifTag.TimeZoneOffset);
+
+                case ExifTagValue.ImageWidth: return new ExifNumber(ExifTag.ImageWidth);
+                case ExifTagValue.ImageLength: return new ExifNumber(ExifTag.ImageLength);
+                case ExifTagValue.TileWidth: return new ExifNumber(ExifTag.TileWidth);
+                case ExifTagValue.TileLength: return new ExifNumber(ExifTag.TileLength);
+                case ExifTagValue.BadFaxLines: return new ExifNumber(ExifTag.BadFaxLines);
+                case ExifTagValue.ConsecutiveBadFaxLines: return new ExifNumber(ExifTag.ConsecutiveBadFaxLines);
+                case ExifTagValue.PixelXDimension: return new ExifNumber(ExifTag.PixelXDimension);
+                case ExifTagValue.PixelYDimension: return new ExifNumber(ExifTag.PixelYDimension);
+
+                case ExifTagValue.StripOffsets: return new ExifNumberArray(ExifTag.StripOffsets);
+                case ExifTagValue.TileByteCounts: return new ExifNumberArray(ExifTag.TileByteCounts);
+                case ExifTagValue.ImageLayer: return new ExifNumberArray(ExifTag.ImageLayer);
+
+                case ExifTagValue.XPosition: return new ExifRational(ExifTag.XPosition);
+                case ExifTagValue.YPosition: return new ExifRational(ExifTag.YPosition);
+                case ExifTagValue.XResolution: return new ExifRational(ExifTag.XResolution);
+                case ExifTagValue.YResolution: return new ExifRational(ExifTag.YResolution);
+                case ExifTagValue.BatteryLevel: return new ExifRational(ExifTag.BatteryLevel);
+                case ExifTagValue.ExposureTime: return new ExifRational(ExifTag.ExposureTime);
+                case ExifTagValue.FNumber: return new ExifRational(ExifTag.FNumber);
+                case ExifTagValue.MDScalePixel: return new ExifRational(ExifTag.MDScalePixel);
+                case ExifTagValue.CompressedBitsPerPixel: return new ExifRational(ExifTag.CompressedBitsPerPixel);
+                case ExifTagValue.ApertureValue: return new ExifRational(ExifTag.ApertureValue);
+                case ExifTagValue.MaxApertureValue: return new ExifRational(ExifTag.MaxApertureValue);
+                case ExifTagValue.SubjectDistance: return new ExifRational(ExifTag.SubjectDistance);
+                case ExifTagValue.FocalLength: return new ExifRational(ExifTag.FocalLength);
+                case ExifTagValue.FlashEnergy2: return new ExifRational(ExifTag.FlashEnergy2);
+                case ExifTagValue.FocalPlaneXResolution2: return new ExifRational(ExifTag.FocalPlaneXResolution2);
+                case ExifTagValue.FocalPlaneYResolution2: return new ExifRational(ExifTag.FocalPlaneYResolution2);
+                case ExifTagValue.ExposureIndex2: return new ExifRational(ExifTag.ExposureIndex2);
+                case ExifTagValue.Humidity: return new ExifRational(ExifTag.Humidity);
+                case ExifTagValue.Pressure: return new ExifRational(ExifTag.Pressure);
+                case ExifTagValue.Acceleration: return new ExifRational(ExifTag.Acceleration);
+                case ExifTagValue.FlashEnergy: return new ExifRational(ExifTag.FlashEnergy);
+                case ExifTagValue.FocalPlaneXResolution: return new ExifRational(ExifTag.FocalPlaneXResolution);
+                case ExifTagValue.FocalPlaneYResolution: return new ExifRational(ExifTag.FocalPlaneYResolution);
+                case ExifTagValue.ExposureIndex: return new ExifRational(ExifTag.ExposureIndex);
+                case ExifTagValue.DigitalZoomRatio: return new ExifRational(ExifTag.DigitalZoomRatio);
+                case ExifTagValue.LensInfo: return new ExifRational(ExifTag.LensInfo);
+                case ExifTagValue.GPSAltitude: return new ExifRational(ExifTag.GPSAltitude);
+                case ExifTagValue.GPSDOP: return new ExifRational(ExifTag.GPSDOP);
+                case ExifTagValue.GPSSpeed: return new ExifRational(ExifTag.GPSSpeed);
+                case ExifTagValue.GPSTrack: return new ExifRational(ExifTag.GPSTrack);
+                case ExifTagValue.GPSImgDirection: return new ExifRational(ExifTag.GPSImgDirection);
+                case ExifTagValue.GPSDestBearing: return new ExifRational(ExifTag.GPSDestBearing);
+                case ExifTagValue.GPSDestDistance: return new ExifRational(ExifTag.GPSDestDistance);
+
+                case ExifTagValue.WhitePoint: return new ExifRationalArray(ExifTag.WhitePoint);
+                case ExifTagValue.PrimaryChromaticities: return new ExifRationalArray(ExifTag.PrimaryChromaticities);
+                case ExifTagValue.YCbCrCoefficients: return new ExifRationalArray(ExifTag.YCbCrCoefficients);
+                case ExifTagValue.ReferenceBlackWhite: return new ExifRationalArray(ExifTag.ReferenceBlackWhite);
+                case ExifTagValue.GPSLatitude: return new ExifRationalArray(ExifTag.GPSLatitude);
+                case ExifTagValue.GPSLongitude: return new ExifRationalArray(ExifTag.GPSLongitude);
+                case ExifTagValue.GPSTimestamp: return new ExifRationalArray(ExifTag.GPSTimestamp);
+                case ExifTagValue.GPSDestLatitude: return new ExifRationalArray(ExifTag.GPSDestLatitude);
+                case ExifTagValue.GPSDestLongitude: return new ExifRationalArray(ExifTag.GPSDestLongitude);
+
+                case ExifTagValue.OldSubfileType: return new ExifShort(ExifTag.OldSubfileType);
+                case ExifTagValue.Compression: return new ExifShort(ExifTag.Compression);
+                case ExifTagValue.PhotometricInterpretation: return new ExifShort(ExifTag.PhotometricInterpretation);
+                case ExifTagValue.Thresholding: return new ExifShort(ExifTag.Thresholding);
+                case ExifTagValue.CellWidth: return new ExifShort(ExifTag.CellWidth);
+                case ExifTagValue.CellLength: return new ExifShort(ExifTag.CellLength);
+                case ExifTagValue.FillOrder: return new ExifShort(ExifTag.FillOrder);
+                case ExifTagValue.Orientation: return new ExifShort(ExifTag.Orientation);
+                case ExifTagValue.SamplesPerPixel: return new ExifShort(ExifTag.SamplesPerPixel);
+                case ExifTagValue.PlanarConfiguration: return new ExifShort(ExifTag.PlanarConfiguration);
+                case ExifTagValue.GrayResponseUnit: return new ExifShort(ExifTag.GrayResponseUnit);
+                case ExifTagValue.ResolutionUnit: return new ExifShort(ExifTag.ResolutionUnit);
+                case ExifTagValue.CleanFaxData: return new ExifShort(ExifTag.CleanFaxData);
+                case ExifTagValue.InkSet: return new ExifShort(ExifTag.InkSet);
+                case ExifTagValue.NumberOfInks: return new ExifShort(ExifTag.NumberOfInks);
+                case ExifTagValue.DotRange: return new ExifShort(ExifTag.DotRange);
+                case ExifTagValue.Indexed: return new ExifShort(ExifTag.Indexed);
+                case ExifTagValue.OPIProxy: return new ExifShort(ExifTag.OPIProxy);
+                case ExifTagValue.JPEGProc: return new ExifShort(ExifTag.JPEGProc);
+                case ExifTagValue.JPEGRestartInterval: return new ExifShort(ExifTag.JPEGRestartInterval);
+                case ExifTagValue.YCbCrPositioning: return new ExifShort(ExifTag.YCbCrPositioning);
+                case ExifTagValue.Rating: return new ExifShort(ExifTag.Rating);
+                case ExifTagValue.RatingPercent: return new ExifShort(ExifTag.RatingPercent);
+                case ExifTagValue.ExposureProgram: return new ExifShort(ExifTag.ExposureProgram);
+                case ExifTagValue.Interlace: return new ExifShort(ExifTag.Interlace);
+                case ExifTagValue.SelfTimerMode: return new ExifShort(ExifTag.SelfTimerMode);
+                case ExifTagValue.SensitivityType: return new ExifShort(ExifTag.SensitivityType);
+                case ExifTagValue.MeteringMode: return new ExifShort(ExifTag.MeteringMode);
+                case ExifTagValue.LightSource: return new ExifShort(ExifTag.LightSource);
+                case ExifTagValue.FocalPlaneResolutionUnit2: return new ExifShort(ExifTag.FocalPlaneResolutionUnit2);
+                case ExifTagValue.SensingMethod2: return new ExifShort(ExifTag.SensingMethod2);
+                case ExifTagValue.Flash: return new ExifShort(ExifTag.Flash);
+                case ExifTagValue.ColorSpace: return new ExifShort(ExifTag.ColorSpace);
+                case ExifTagValue.FocalPlaneResolutionUnit: return new ExifShort(ExifTag.FocalPlaneResolutionUnit);
+                case ExifTagValue.SensingMethod: return new ExifShort(ExifTag.SensingMethod);
+                case ExifTagValue.CustomRendered: return new ExifShort(ExifTag.CustomRendered);
+                case ExifTagValue.ExposureMode: return new ExifShort(ExifTag.ExposureMode);
+                case ExifTagValue.WhiteBalance: return new ExifShort(ExifTag.WhiteBalance);
+                case ExifTagValue.FocalLengthIn35mmFilm: return new ExifShort(ExifTag.FocalLengthIn35mmFilm);
+                case ExifTagValue.SceneCaptureType: return new ExifShort(ExifTag.SceneCaptureType);
+                case ExifTagValue.GainControl: return new ExifShort(ExifTag.GainControl);
+                case ExifTagValue.Contrast: return new ExifShort(ExifTag.Contrast);
+                case ExifTagValue.Saturation: return new ExifShort(ExifTag.Saturation);
+                case ExifTagValue.Sharpness: return new ExifShort(ExifTag.Sharpness);
+                case ExifTagValue.SubjectDistanceRange: return new ExifShort(ExifTag.SubjectDistanceRange);
+                case ExifTagValue.GPSDifferential: return new ExifShort(ExifTag.GPSDifferential);
+
+                case ExifTagValue.BitsPerSample: return new ExifShortArray(ExifTag.BitsPerSample);
+                case ExifTagValue.MinSampleValue: return new ExifShortArray(ExifTag.MinSampleValue);
+                case ExifTagValue.MaxSampleValue: return new ExifShortArray(ExifTag.MaxSampleValue);
+                case ExifTagValue.GrayResponseCurve: return new ExifShortArray(ExifTag.GrayResponseCurve);
+                case ExifTagValue.ColorMap: return new ExifShortArray(ExifTag.ColorMap);
+                case ExifTagValue.ExtraSamples: return new ExifShortArray(ExifTag.ExtraSamples);
+                case ExifTagValue.PageNumber: return new ExifShortArray(ExifTag.PageNumber);
+                case ExifTagValue.TransferFunction: return new ExifShortArray(ExifTag.TransferFunction);
+                case ExifTagValue.Predictor: return new ExifShortArray(ExifTag.Predictor);
+                case ExifTagValue.HalftoneHints: return new ExifShortArray(ExifTag.HalftoneHints);
+                case ExifTagValue.SampleFormat: return new ExifShortArray(ExifTag.SampleFormat);
+                case ExifTagValue.TransferRange: return new ExifShortArray(ExifTag.TransferRange);
+                case ExifTagValue.DefaultImageColor: return new ExifShortArray(ExifTag.DefaultImageColor);
+                case ExifTagValue.JPEGLosslessPredictors: return new ExifShortArray(ExifTag.JPEGLosslessPredictors);
+                case ExifTagValue.JPEGPointTransforms: return new ExifShortArray(ExifTag.JPEGPointTransforms);
+                case ExifTagValue.YCbCrSubsampling: return new ExifShortArray(ExifTag.YCbCrSubsampling);
+                case ExifTagValue.CFARepeatPatternDim: return new ExifShortArray(ExifTag.CFARepeatPatternDim);
+                case ExifTagValue.IntergraphPacketData: return new ExifShortArray(ExifTag.IntergraphPacketData);
+                case ExifTagValue.ISOSpeedRatings: return new ExifShortArray(ExifTag.ISOSpeedRatings);
+                case ExifTagValue.SubjectArea: return new ExifShortArray(ExifTag.SubjectArea);
+                case ExifTagValue.SubjectLocation: return new ExifShortArray(ExifTag.SubjectLocation);
+
+                case ExifTagValue.ShutterSpeedValue: return new ExifSignedRational(ExifTag.ShutterSpeedValue);
+                case ExifTagValue.BrightnessValue: return new ExifSignedRational(ExifTag.BrightnessValue);
+                case ExifTagValue.ExposureBiasValue: return new ExifSignedRational(ExifTag.ExposureBiasValue);
+                case ExifTagValue.AmbientTemperature: return new ExifSignedRational(ExifTag.AmbientTemperature);
+                case ExifTagValue.WaterDepth: return new ExifSignedRational(ExifTag.WaterDepth);
+                case ExifTagValue.CameraElevationAngle: return new ExifSignedRational(ExifTag.CameraElevationAngle);
+
+                case ExifTagValue.Decode: return new ExifSignedRationalArray(ExifTag.Decode);
+
+                case ExifTagValue.ImageDescription: return new ExifString(ExifTag.ImageDescription);
+                case ExifTagValue.Make: return new ExifString(ExifTag.Make);
+                case ExifTagValue.Model: return new ExifString(ExifTag.Model);
+                case ExifTagValue.Software: return new ExifString(ExifTag.Software);
+                case ExifTagValue.DateTime: return new ExifString(ExifTag.DateTime);
+                case ExifTagValue.Artist: return new ExifString(ExifTag.Artist);
+                case ExifTagValue.HostComputer: return new ExifString(ExifTag.HostComputer);
+                case ExifTagValue.Copyright: return new ExifString(ExifTag.Copyright);
+                case ExifTagValue.DocumentName: return new ExifString(ExifTag.DocumentName);
+                case ExifTagValue.PageName: return new ExifString(ExifTag.PageName);
+                case ExifTagValue.InkNames: return new ExifString(ExifTag.InkNames);
+                case ExifTagValue.TargetPrinter: return new ExifString(ExifTag.TargetPrinter);
+                case ExifTagValue.ImageID: return new ExifString(ExifTag.ImageID);
+                case ExifTagValue.MDLabName: return new ExifString(ExifTag.MDLabName);
+                case ExifTagValue.MDSampleInfo: return new ExifString(ExifTag.MDSampleInfo);
+                case ExifTagValue.MDPrepDate: return new ExifString(ExifTag.MDPrepDate);
+                case ExifTagValue.MDPrepTime: return new ExifString(ExifTag.MDPrepTime);
+                case ExifTagValue.MDFileUnits: return new ExifString(ExifTag.MDFileUnits);
+                case ExifTagValue.SEMInfo: return new ExifString(ExifTag.SEMInfo);
+                case ExifTagValue.SpectralSensitivity: return new ExifString(ExifTag.SpectralSensitivity);
+                case ExifTagValue.DateTimeOriginal: return new ExifString(ExifTag.DateTimeOriginal);
+                case ExifTagValue.DateTimeDigitized: return new ExifString(ExifTag.DateTimeDigitized);
+                case ExifTagValue.SubsecTime: return new ExifString(ExifTag.SubsecTime);
+                case ExifTagValue.SubsecTimeOriginal: return new ExifString(ExifTag.SubsecTimeOriginal);
+                case ExifTagValue.SubsecTimeDigitized: return new ExifString(ExifTag.SubsecTimeDigitized);
+                case ExifTagValue.RelatedSoundFile: return new ExifString(ExifTag.RelatedSoundFile);
+                case ExifTagValue.FaxSubaddress: return new ExifString(ExifTag.FaxSubaddress);
+                case ExifTagValue.OffsetTime: return new ExifString(ExifTag.OffsetTime);
+                case ExifTagValue.OffsetTimeOriginal: return new ExifString(ExifTag.OffsetTimeOriginal);
+                case ExifTagValue.OffsetTimeDigitized: return new ExifString(ExifTag.OffsetTimeDigitized);
+                case ExifTagValue.SecurityClassification: return new ExifString(ExifTag.SecurityClassification);
+                case ExifTagValue.ImageHistory: return new ExifString(ExifTag.ImageHistory);
+                case ExifTagValue.ImageUniqueID: return new ExifString(ExifTag.ImageUniqueID);
+                case ExifTagValue.OwnerName: return new ExifString(ExifTag.OwnerName);
+                case ExifTagValue.SerialNumber: return new ExifString(ExifTag.SerialNumber);
+                case ExifTagValue.LensMake: return new ExifString(ExifTag.LensMake);
+                case ExifTagValue.LensModel: return new ExifString(ExifTag.LensModel);
+                case ExifTagValue.LensSerialNumber: return new ExifString(ExifTag.LensSerialNumber);
+                case ExifTagValue.GDALMetadata: return new ExifString(ExifTag.GDALMetadata);
+                case ExifTagValue.GDALNoData: return new ExifString(ExifTag.GDALNoData);
+                case ExifTagValue.GPSLatitudeRef: return new ExifString(ExifTag.GPSLatitudeRef);
+                case ExifTagValue.GPSLongitudeRef: return new ExifString(ExifTag.GPSLongitudeRef);
+                case ExifTagValue.GPSSatellites: return new ExifString(ExifTag.GPSSatellites);
+                case ExifTagValue.GPSStatus: return new ExifString(ExifTag.GPSStatus);
+                case ExifTagValue.GPSMeasureMode: return new ExifString(ExifTag.GPSMeasureMode);
+                case ExifTagValue.GPSSpeedRef: return new ExifString(ExifTag.GPSSpeedRef);
+                case ExifTagValue.GPSTrackRef: return new ExifString(ExifTag.GPSTrackRef);
+                case ExifTagValue.GPSImgDirectionRef: return new ExifString(ExifTag.GPSImgDirectionRef);
+                case ExifTagValue.GPSMapDatum: return new ExifString(ExifTag.GPSMapDatum);
+                case ExifTagValue.GPSDestLatitudeRef: return new ExifString(ExifTag.GPSDestLatitudeRef);
+                case ExifTagValue.GPSDestLongitudeRef: return new ExifString(ExifTag.GPSDestLongitudeRef);
+                case ExifTagValue.GPSDestBearingRef: return new ExifString(ExifTag.GPSDestBearingRef);
+                case ExifTagValue.GPSDestDistanceRef: return new ExifString(ExifTag.GPSDestDistanceRef);
+                case ExifTagValue.GPSDateStamp: return new ExifString(ExifTag.GPSDateStamp);
+
+                case ExifTagValue.FileSource: return new ExifByte(ExifTag.FileSource, ExifDataType.Undefined);
+                case ExifTagValue.SceneType: return new ExifByte(ExifTag.SceneType, ExifDataType.Undefined);
+
+                case ExifTagValue.JPEGTables: return new ExifByteArray(ExifTag.JPEGTables, ExifDataType.Undefined);
+                case ExifTagValue.OECF: return new ExifByteArray(ExifTag.OECF, ExifDataType.Undefined);
+                case ExifTagValue.ExifVersion: return new ExifByteArray(ExifTag.ExifVersion, ExifDataType.Undefined);
+                case ExifTagValue.ComponentsConfiguration: return new ExifByteArray(ExifTag.ComponentsConfiguration, ExifDataType.Undefined);
+                case ExifTagValue.MakerNote: return new ExifByteArray(ExifTag.MakerNote, ExifDataType.Undefined);
+                case ExifTagValue.UserComment: return new ExifByteArray(ExifTag.UserComment, ExifDataType.Undefined);
+                case ExifTagValue.FlashpixVersion: return new ExifByteArray(ExifTag.FlashpixVersion, ExifDataType.Undefined);
+                case ExifTagValue.SpatialFrequencyResponse: return new ExifByteArray(ExifTag.SpatialFrequencyResponse, ExifDataType.Undefined);
+                case ExifTagValue.SpatialFrequencyResponse2: return new ExifByteArray(ExifTag.SpatialFrequencyResponse2, ExifDataType.Undefined);
+                case ExifTagValue.Noise: return new ExifByteArray(ExifTag.Noise, ExifDataType.Undefined);
+                case ExifTagValue.CFAPattern: return new ExifByteArray(ExifTag.CFAPattern, ExifDataType.Undefined);
+                case ExifTagValue.DeviceSettingDescription: return new ExifByteArray(ExifTag.DeviceSettingDescription, ExifDataType.Undefined);
+                case ExifTagValue.ImageSourceData: return new ExifByteArray(ExifTag.ImageSourceData, ExifDataType.Undefined);
+                case ExifTagValue.GPSProcessingMethod: return new ExifByteArray(ExifTag.GPSProcessingMethod, ExifDataType.Undefined);
+                case ExifTagValue.GPSAreaInformation: return new ExifByteArray(ExifTag.GPSAreaInformation, ExifDataType.Undefined);
+
+                default: return null;
+            }
+        }
     }
 }


pr feedback: parent game object name

pr feedback: parent game object name

--- Assets/MixedRealityToolkit-SDK/Features/Boundary/System/MixedRealityBoundarySystem.cs
+++ Assets/MixedRealityToolkit-SDK/Features/Boundary/System/MixedRealityBoundarySystem.cs
@@ -187,7 +187,7 @@
         /// </returns>
         private GameObject CreateBoundaryVisualizationParent()
         {
-            GameObject visualizationParent = new GameObject("Boundary System");
+            GameObject visualizationParent = new GameObject("Boundary System Visualizations");
             visualizationParent.transform.parent = CameraCache.Main.transform.parent;

             return visualizationParent;


Remove unused field.

Remove unused field.

--- src/Microsoft.AspNet.Owin/WebSockets/WebSocketAdapter.cs
+++ src/Microsoft.AspNet.Owin/WebSockets/WebSocketAdapter.cs
@@ -37,7 +37,6 @@
         private readonly WebSocket _webSocket;
         private readonly IDictionary<string, object> _environment;
         private readonly CancellationToken _cancellationToken;
-        private readonly WebSocket _context;

         internal WebSocketAdapter(WebSocket webSocket, CancellationToken ct)
         {


manifest updater now sets msbuild for unity v0.8.3

--- Assets/MixedRealityToolkit/Utilities/Editor/PackageManifest/PackageManifestUpdater.cs
+++ Assets/MixedRealityToolkit/Utilities/Editor/PackageManifest/PackageManifestUpdater.cs
@@ -18,7 +18,7 @@
         private static string[] MSBuildRegistryScopes = new string[] { "com.microsoft" };

         private static string MSBuildPackageName = "com.microsoft.msbuildforunity";
-        private static string MSBuildPackageVersion = "0.8.2";
+        private static string MSBuildPackageVersion = "0.8.3";

         /// <summary>
         /// Ensures the required settings exist in the package manager to allow for


Fix race preventing handling of the last request sent over a connection

We need to attempt to consume start lines and headers even after
SocketInput.RemoteIntakeFin is set to true to ensure we don't close a
connection without giving the application a chance to respond to a request
sent immediately before the a FIN from the client.

--- src/Microsoft.AspNetCore.Server.Kestrel/Http/FrameOfT.cs
+++ src/Microsoft.AspNetCore.Server.Kestrel/Http/FrameOfT.cs
@@ -37,8 +37,14 @@
                     {
                         if (SocketInput.RemoteIntakeFin)
                         {
+                            if (TakeStartLine(SocketInput))
+                            {
+                                break;
+                            }
+
                             return;
                         }
+
                         await SocketInput;
                     }

@@ -48,8 +54,14 @@
                     {
                         if (SocketInput.RemoteIntakeFin)
                         {
+                            if (TakeMessageHeaders(SocketInput, FrameRequestHeaders))
+                            {
+                                break;
+                            }
+
                             return;
                         }
+
                         await SocketInput;
                     }


sorted some usings

sorted some usings

--- Assets/MixedRealityToolkit/_Core/Definitions/Devices/MixedRealityControllerMapping.cs
+++ Assets/MixedRealityToolkit/_Core/Definitions/Devices/MixedRealityControllerMapping.cs
@@ -3,9 +3,9 @@

 using Microsoft.MixedReality.Toolkit.Internal.Attributes;
 using Microsoft.MixedReality.Toolkit.Internal.Definitions.Utilities;
+using Microsoft.MixedReality.Toolkit.Internal.Interfaces;
 using Microsoft.MixedReality.Toolkit.Internal.Interfaces.Devices;
 using System;
-using Microsoft.MixedReality.Toolkit.Internal.Interfaces;
 using UnityEngine;

 namespace Microsoft.MixedReality.Toolkit.Internal.Definitions.Devices


Fix FxCop issue for Microsoft.Restier.Security

--- src/Microsoft.Restier.Security/RoleBasedAuthorization.cs
+++ src/Microsoft.Restier.Security/RoleBasedAuthorization.cs
@@ -1,6 +1,7 @@
 // Copyright (c) Microsoft Corporation.  All rights reserved.
 // Licensed under the MIT License.  See License.txt in the project root for license information.

+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Security;
@@ -54,6 +55,7 @@
             InvocationContext context,
             IEdmModel model, IEdmSchemaElement element)
         {
+            Ensure.NotNull(element);
             // TODO GitHubIssue#34 : Filter out proper visible types
             if (element is IEdmType || element is IEdmOperation)
             {
@@ -87,6 +89,7 @@
             InvocationContext context,
             IEdmModel model, IEdmEntityContainerElement element)
         {
+            Ensure.NotNull(element);
             return this.IsVisible(configuration,
                 context, null, element.Name);
         }
@@ -102,6 +105,7 @@
         /// </returns>
         public bool Inspect(QueryExpressionContext context)
         {
+            Ensure.NotNull(context);
             // TODO GitHubIssue#35 : Support Inspect more elements in authorization
             if (context.ModelReference == null)
             {


Remove help box from the folders settings list

--- Assets/Plugins/RainbowFolders/Editor/Scripts/Settings/RainbowFoldersSettingsEditor.cs
+++ Assets/Plugins/RainbowFolders/Editor/Scripts/Settings/RainbowFoldersSettingsEditor.cs
@@ -31,12 +31,6 @@

         public override void OnInspectorGUI()
         {
-            EditorGUILayout.HelpBox("Please set your custom folder icons by specifying:\n\n" +
-                                    "- Folder Name\n" +
-                                    "Icon will be applied to all folders with the same name\n\n" +
-                                    "- Folder Path\n" +
-                                    "Icon will be applied to a single folder. The path format: Assets/SomeFolder/YourFolder", MessageType.Info);
-
             serializedObject.Update();
             ReorderableListGUI.Title("Rainbow Folders");
             ReorderableListGUI.ListField(_foldersProperty);


NameExpression with null variable

NameExpression with null variable

--- Src/PythonSharp.Tests/Expressions/NameExpressionTests.cs
+++ Src/PythonSharp.Tests/Expressions/NameExpressionTests.cs
@@ -24,6 +24,18 @@
         }

         [TestMethod]
+        public void EvaluateNameWithNull()
+        {
+            NameExpression expression = new NameExpression("foo");
+
+            BindingEnvironment environment = new BindingEnvironment();
+
+            environment.SetValue("foo", null);
+
+            Assert.IsNull(expression.Evaluate(environment));
+        }
+
+        [TestMethod]
         public void RaiseIfNameIsUndefined()
         {
             NameExpression expression = new NameExpression("foo");


Factor out common assertion code in rule serializer tests

--- src/NRules/Tests/NRules.Json.Tests/RuleSerializerTest.cs
+++ src/NRules/Tests/NRules.Json.Tests/RuleSerializerTest.cs
@@ -27,7 +27,6 @@
         [Fact]
         public void Roundtrip_SimpleMatchRuleWithMetadata_Equals()
         {
-            //Arrange
             var builder = new RuleBuilder();
             builder.Name("Test Rule");
             builder.Description("My test rule");
@@ -45,19 +44,14 @@

             Expression<Action<IContext, FactType1>> action = (ctx, fact1) => Calculations.DoSomething(fact1);
             builder.RightHandSide().Action(action);
-            var original = builder.Build();
-
-            //Act
-            var deserialized = Roundtrip(original);
-
-            //Assert
-            Assert.True(RuleDefinitionComparer.AreEqual(original, deserialized));
+            var ruleDefinition = builder.Build();
+
+            TestRoundtrip(ruleDefinition);
         }

         [Fact]
         public void Roundtrip_RuleWithFilter_Equals()
         {
-            //Arrange
             var builder = new RuleBuilder();
             builder.Name("Test Rule");

@@ -72,19 +66,14 @@

             Expression<Action<IContext, FactType1>> action = (ctx, fact1) => Calculations.DoSomething(fact1);
             builder.RightHandSide().Action(action);
-            var original = builder.Build();
-
-            //Act
-            var deserialized = Roundtrip(original);
-
-            //Assert
-            Assert.True(RuleDefinitionComparer.AreEqual(original, deserialized));
+            var ruleDefinition = builder.Build();
+
+            TestRoundtrip(ruleDefinition);
         }

         [Fact]
         public void Roundtrip_RuleWithDependency_Equals()
         {
-            //Arrange
             var builder = new RuleBuilder();
             builder.Name("Test Rule");

@@ -95,19 +84,14 @@

             Expression<Action<IContext, FactType1, ITestService>> action = (ctx, fact1, service) => Calculations.DoSomething(fact1, service);
             builder.RightHandSide().Action(action);
-            var original = builder.Build();
-
-            //Act
-            var deserialized = Roundtrip(original);
-
-            //Assert
-            Assert.True(RuleDefinitionComparer.AreEqual(original, deserialized));
+            var ruleDefinition = builder.Build();
+
+            TestRoundtrip(ruleDefinition);
         }

         [Fact]
         public void Roundtrip_TwoFactJoinRule_Equals()
         {
-            //Arrange
             var builder = new RuleBuilder();
             builder.Name("Test Rule");

@@ -120,19 +104,14 @@
             Expression<Action<IContext, FactType1, FactType2>> action = (ctx, fact1, fact2)
                 => Calculations.DoSomething(fact1, fact2);
             builder.RightHandSide().Action(action);
-            var original = builder.Build();
-
-            //Act
-            var deserialized = Roundtrip(original);
-
-            //Assert
-            Assert.True(RuleDefinitionComparer.AreEqual(original, deserialized));
+            var ruleDefinition = builder.Build();
+
+            TestRoundtrip(ruleDefinition);
         }

         [Fact]
         public void Roundtrip_ExistsRule_Equals()
         {
-            //Arrange
             var builder = new RuleBuilder();
             builder.Name("Test Rule");

@@ -141,19 +120,14 @@
             Expression<Action<IContext>> action = ctx
                 => Calculations.DoSomething();
             builder.RightHandSide().Action(action);
-            var original = builder.Build();
-
-            //Act
-            var deserialized = Roundtrip(original);
-
-            //Assert
-            Assert.True(RuleDefinitionComparer.AreEqual(original, deserialized));
+            var ruleDefinition = builder.Build();
+
+            TestRoundtrip(ruleDefinition);
         }

         [Fact]
         public void Roundtrip_NotRule_Equals()
         {
-            //Arrange
             var builder = new RuleBuilder();
             builder.Name("Test Rule");

@@ -162,19 +136,14 @@
             Expression<Action<IContext>> action = ctx
                 => Calculations.DoSomething();
             builder.RightHandSide().Action(action);
-            var original = builder.Build();
-
-            //Act
-            var deserialized = Roundtrip(original);
-
-            //Assert
-            Assert.True(RuleDefinitionComparer.AreEqual(original, deserialized));
+            var ruleDefinition = builder.Build();
+
+            TestRoundtrip(ruleDefinition);
         }

         [Fact]
         public void Roundtrip_AggregateRule_Equals()
         {
-            //Arrange
             var builder = new RuleBuilder();
             builder.Name("Test Rule");

@@ -192,19 +161,14 @@
             Expression<Action<IContext, IEnumerable<FactType1>>> action = (ctx, factGroup)
                 => Calculations.DoSomething(factGroup);
             builder.RightHandSide().Action(action);
-            var original = builder.Build();
-
-            //Act
-            var deserialized = Roundtrip(original);
-
-            //Assert
-            Assert.True(RuleDefinitionComparer.AreEqual(original, deserialized));
+            var ruleDefinition = builder.Build();
+
+            TestRoundtrip(ruleDefinition);
         }

         [Fact]
         public void Roundtrip_BindingRule_Equals()
         {
-            //Arrange
             var builder = new RuleBuilder();
             builder.Name("Test Rule");

@@ -219,19 +183,14 @@
             Expression<Action<IContext, int>> action = (ctx, length)
                 => Calculations.DoSomething(length);
             builder.RightHandSide().Action(action);
-            var original = builder.Build();
-
-            //Act
-            var deserialized = Roundtrip(original);
-
-            //Assert
-            Assert.True(RuleDefinitionComparer.AreEqual(original, deserialized));
+            var ruleDefinition = builder.Build();
+
+            TestRoundtrip(ruleDefinition);
         }

         [Fact]
         public void Roundtrip_ForAllRule_Equals()
         {
-            //Arrange
             var builder = new RuleBuilder();
             builder.Name("Test Rule");

@@ -249,28 +208,24 @@
                 Expression.Call(
                     Expression.Property(parameter1, nameof(FactType1.StringProperty)),
                     nameof(string.StartsWith),
-                    new Type[0],
+                    Type.EmptyTypes,
                     Expression.Constant("Valid")),
                 parameter1);
             pattern1.Condition(condition1);

             Expression<Action<IContext>> action = ctx => Calculations.DoSomething();
             builder.RightHandSide().Action(action);
-            var original = builder.Build();
-
-            //Act
-            var deserialized = Roundtrip(original);
-
-            //Assert
-            Assert.True(RuleDefinitionComparer.AreEqual(original, deserialized));
-        }
-
-        private IRuleDefinition Roundtrip(IRuleDefinition original)
+            var ruleDefinition = builder.Build();
+
+            TestRoundtrip(ruleDefinition);
+        }
+
+        private void TestRoundtrip(IRuleDefinition original)
         {
             var jsonString = JsonSerializer.Serialize(original, _options);
             //System.IO.File.WriteAllText(@"C:\temp\rule.json", jsonString);
             var deserialized = JsonSerializer.Deserialize<IRuleDefinition>(jsonString, _options);
-            return deserialized;
+            Assert.True(RuleDefinitionComparer.AreEqual(original, deserialized));
         }
     }
 }


include constant value in TypeLookup

include constant value in TypeLookup

--- src/OmniSharp.Roslyn.CSharp/Services/Types/TypeLookup.cs
+++ src/OmniSharp.Roslyn.CSharp/Services/Types/TypeLookup.cs
@@ -20,6 +20,15 @@
             WithMiscellaneousOptions(SymbolDisplayMiscellaneousOptions.None).
             WithMiscellaneousOptions(SymbolDisplayMiscellaneousOptions.EscapeKeywordIdentifiers);

+        // default from symbol.ToMinimalDisplayString + IncludeConstantValue
+        private static readonly SymbolDisplayFormat MinimalFormat = SymbolDisplayFormat.MinimallyQualifiedFormat.WithMemberOptions(
+            SymbolDisplayMemberOptions.IncludeParameters |
+            SymbolDisplayMemberOptions.IncludeType |
+            SymbolDisplayMemberOptions.IncludeRef |
+            SymbolDisplayMemberOptions.IncludeContainingType |
+            SymbolDisplayMemberOptions.IncludeConstantValue
+         );
+
         [ImportingConstructor]
         public TypeLookupService(OmniSharpWorkspace workspace, FormattingOptions formattingOptions)
         {
@@ -41,7 +50,7 @@
                 {
                     response.Type = symbol.Kind == SymbolKind.NamedType ?
                         symbol.ToDisplayString(DefaultFormat) :
-                        symbol.ToMinimalDisplayString(semanticModel, position);
+                        symbol.ToMinimalDisplayString(semanticModel, position, MinimalFormat);

                     if (request.IncludeDocumentation)
                     {


OCD updates :-)

OCD updates :-)