Example #1
0
        internal static List <Type> ReadTypesFromCache(
            string cacheName,
            Predicate <Type> predicate,
            IBuildManager buildManager,
            TypeCacheSerializer serializer
            )
        {
            try
            {
                Stream stream = buildManager.ReadCachedFile(cacheName);
                if (stream != null)
                {
                    using (StreamReader reader = new StreamReader(stream))
                    {
                        List <Type> deserializedTypes = serializer.DeserializeTypes(reader);
                        if (
                            deserializedTypes != null &&
                            deserializedTypes.All(
                                type => TypeIsPublicClass(type) && predicate(type)
                                )
                            )
                        {
                            // If all read types still match the predicate, success!
                            return(deserializedTypes);
                        }
                    }
                }
            }
            catch { }

            return(null);
        }
Example #2
0
		internal static List<Type> ReadTypesFromCache(string cacheName, Predicate<Type> predicate, IBuildManager buildManager, TypeCacheSerializer serializer)
		{
			try
			{
				Stream stream = buildManager.ReadCachedFile(cacheName);
				if (stream != null)
				{
					using (StreamReader streamReader = new StreamReader(stream))
					{
						List<Type> list = serializer.DeserializeTypes(streamReader);
						if (list != null)
						{
							if (list.All((Type type) => TypeIsPublicClass(type) && predicate(type)))
							{
								return list;
							}
						}
					}
				}
			}
			catch
			{
			}
			return null;
		}
        internal static Version GetPreviousRuntimeVersion(IBuildManager buildManagerFileSystem)
        {
            string fileName = GetCachedFileName();

            try
            {
                Stream stream = buildManagerFileSystem.ReadCachedFile(fileName);
                if (stream == null)
                {
                    return(null);
                }

                using (StreamReader reader = new StreamReader(stream))
                {
                    string  text = reader.ReadLine();
                    Version version;
                    if (Version.TryParse(text, out version))
                    {
                        return(version);
                    }
                }
            }
            catch
            {
            }
            return(null);
        }
        private static List<Type> ReadTypesFromCache(string cacheName, Predicate<Type> predicate, IBuildManager buildManager, HttpControllerTypeCacheSerializer serializer)
        {
            try
            {
                Stream stream = buildManager.ReadCachedFile(cacheName);
                if (stream != null)
                {
                    using (StreamReader reader = new StreamReader(stream))
                    {
                        List<Type> deserializedTypes = serializer.DeserializeTypes(reader);
                        if (deserializedTypes != null && deserializedTypes.All(type => predicate(type)))
                        {
                            // If all read types still match the predicate, success!
                            return deserializedTypes;
                        }
                    }
                }
            }
            catch
            {
                // cache failures are not considered fatal -- keep running.
            }

            return null;
        }
Example #5
0
        internal static List <Type> ReadTypesFromCache(string cacheName, Predicate <Type> predicate, IBuildManager buildManager, TypeCacheSerializer serializer)
        {
            Func <Type, bool> func = null;

            try
            {
                Stream stream = buildManager.ReadCachedFile(cacheName);
                if (stream != null)
                {
                    using (StreamReader reader = new StreamReader(stream))
                    {
                        List <Type> source = serializer.DeserializeTypes(reader);
                        if (source != null)
                        {
                            if (func == null)
                            {
                                func = type => TypeIsPublicClass(type) && predicate(type);
                            }
                            if (source.All <Type>(func))
                            {
                                return(source);
                            }
                        }
                    }
                }
            }
            catch
            {
            }
            return(null);
        }
        /// <summary>
        /// Reads the types from cache.
        /// </summary>
        /// <param name="buildManager">The build manager.</param>
        /// <param name="cacheName">Name of the cache.</param>
        /// <param name="predicate">The predicate.</param>
        /// <param name="serializer">The serializer.</param>
        /// <returns></returns>
        public static IEnumerable <Type> ReadTypesFromCache(IBuildManager buildManager, string cacheName, Predicate <Type> predicate, ITypeCacheSerializer serializer)
        {
            Func <Type, bool> func = type => (TypeIsPublicClass(type) && predicate(type));

            try
            {
                using (var s = buildManager.ReadCachedFile(cacheName))
                    if (s != null)
                    {
                        using (var r = new StreamReader(s))
                        {
                            var source = serializer.DeserializeTypes(r);
                            if (source != null)
                            {
                                if (source.All(func))
                                {
                                    return(source);
                                }
                            }
                        }
                    }
            }
            catch { }
            return(null);
        }
        internal static List<Type> ReadTypesFromCache(string cacheName, Predicate<Type> predicate, IBuildManager buildManager, TypeCacheSerializer serializer) {
            try {
                Stream stream = buildManager.ReadCachedFile(cacheName);
                if (stream != null) {
                    using (StreamReader reader = new StreamReader(stream)) {
                        List<Type> deserializedTypes = serializer.DeserializeTypes(reader);
                        if (deserializedTypes != null && deserializedTypes.All(type => TypeIsPublicClass(type) && predicate(type))) {
                            // If all read types still match the predicate, success!
                            return deserializedTypes;
                        }
                    }
                }
            }
            catch {
            }

            return null;
        }
        internal static Version GetPreviousRuntimeVersion(IBuildManager buildManagerFileSystem)
        {
            string fileName = GetCachedFileName();
            try
            {
                Stream stream = buildManagerFileSystem.ReadCachedFile(fileName);
                if (stream == null)
                {
                    return null;
                }

                using (StreamReader reader = new StreamReader(stream))
                {
                    string text = reader.ReadLine();
                    Version version;
                    if (Version.TryParse(text, out version))
                    {
                        return version;
                    }
                }
            }
            catch
            {
            }
            return null;
        }