private async Task DeleteInDestination(HashSet<Tuple<string, string, string>> src, HashSet<Tuple<string, string, string>> dst) { dst.ExceptWith(src); int n = 0; // group by table + partition foreach (var batch1 in dst.GroupBy(x => x.Item1 + x.Item2)) { CloudTable dstTable = _dstClient.GetTableReference(batch1.First().Item1); if (_token.IsCancellationRequested) return; foreach (var batch2 in batch1.Batch(100)) { if (_token.IsCancellationRequested) return; var op = new TableBatchOperation(); foreach (var tuple in batch2) { op.Delete(new TableEntity(tuple.Item2, tuple.Item3) {ETag = "*"}); } await dstTable.ExecuteBatchAsync(op, _token); n += Math.Min(op.Count, 100); Console.WriteLine("deleted {0} rows", n); } } }
public void ExecuteTasks(HashSet<EndRequestTask> tasks) { var tasksGroupedByType = tasks.GroupBy(task => task.GetType()) .ToDictionary(grouping => grouping.Key, grouping => grouping.ToHashSet()); foreach (var type in tasksGroupedByType.Keys.OrderByDescending(GetExecutionPriority)) { if (OnRequestExecutionTypes.ContainsKey(type) && OnRequestExecutionTypes[type] != null) { var requestBase = _kernel.Get(OnRequestExecutionTypes[type]) as ExecuteEndRequestBase; if (requestBase != null) { var data = tasksGroupedByType[type].Select(task => task.BaseData).ToHashSet(); requestBase.Execute(data); continue; } } CurrentRequestData.ErrorSignal.Raise( new Exception( string.Format( "Could not process tasks of type {0}. Please create a valid executor for the type", type.FullName))); } }
public static void SomeFunction() { Dictionary<int, int> dict = new Dictionary<int, int>(); dict.Add(4, 3); Console.WriteLine(dict[4]); Console.WriteLine(dict.ContainsKey(8)); dict.Remove(4); foreach(int key in dict.Keys) Console.WriteLine(key); foreach(int val in dict.Values) Console.WriteLine(val); foreach(var kv in dict) Console.WriteLine(kv.Key + " " + kv.Value); var dict2 = dict.ToDictionary(o => o.Key, o => o.Value); var vals = dict.Values; HashSet<int> hash = new HashSet<int>(); hash.Add(999); Console.WriteLine(hash.Contains(999)); hash.Remove(999); Console.WriteLine(hash.Contains(999)); foreach(int hashItem in hash) Console.WriteLine(hashItem); var z = hash.Select(o => 3).ToArray(); var g = hash.GroupBy(o => o).Select(o => o.Count()).Min(); }
/// <summary> /// Resolver context /// </summary> /// <param name="dependencyBehavior">behavior for non-target packages</param> /// <param name="targetIds">packages to install or update</param> /// <param name="requiredPackageIds">packages required in the solution</param> /// <param name="packagesConfig">existing packages</param> /// <param name="preferredVersions">preferred package versions or the installed version of a package</param> /// <param name="availablePackages">all packages from the gather stage</param> public PackageResolverContext(DependencyBehavior dependencyBehavior, IEnumerable<string> targetIds, IEnumerable<string> requiredPackageIds, IEnumerable<Packaging.PackageReference> packagesConfig, IEnumerable<PackageIdentity> preferredVersions, IEnumerable<SourcePackageDependencyInfo> availablePackages) { if (targetIds == null) { throw new ArgumentNullException(nameof(targetIds)); } if (requiredPackageIds == null) { throw new ArgumentNullException(nameof(requiredPackageIds)); } if (packagesConfig == null) { throw new ArgumentNullException(nameof(packagesConfig)); } if (preferredVersions == null) { throw new ArgumentNullException(nameof(preferredVersions)); } if (availablePackages == null) { throw new ArgumentNullException(nameof(availablePackages)); } DependencyBehavior = dependencyBehavior; TargetIds = new HashSet<string>(targetIds, StringComparer.OrdinalIgnoreCase); RequiredPackageIds = new HashSet<string>(requiredPackageIds, StringComparer.OrdinalIgnoreCase); RequiredPackageIds.UnionWith(targetIds); PackagesConfig = packagesConfig; PreferredVersions = new HashSet<PackageIdentity>(preferredVersions, PackageIdentity.Comparer); AvailablePackages = availablePackages; Debug.Assert(PreferredVersions.GroupBy(p => p.Id, StringComparer.OrdinalIgnoreCase) .All(group => group.Count() == 1), "duplicate preferred ids"); }
public void HiloCannotGoDown() { using (var store = NewDocumentStore()) { store.DatabaseCommands.Put( "Raven/Hilo/Users", null, new RavenJObject { {"Max", 32} }, new RavenJObject()); var hiLoKeyGenerator = new HiLoKeyGenerator("Users", 32); var ids = new HashSet<long> { hiLoKeyGenerator.NextId(store.DatabaseCommands) }; store.DatabaseCommands.Put( "Raven/Hilo/Users", null, new RavenJObject { {"Max", 12} }, new RavenJObject()); for (int i = 0; i < 128; i++) { Assert.True(ids.Add(hiLoKeyGenerator.NextId(store.DatabaseCommands)), "Failed at " + i); } var list = ids.GroupBy(x => x).Select(g => new { g.Key, Count = g.Count() }).Where(x => x.Count > 1).ToList(); Assert.Empty(list); } }
/// <summary> /// Generates a syntax tree for the provided assemblies. /// </summary> /// <param name="assemblies">The assemblies to generate code for.</param> /// <param name="runtime">Whether or not runtime code generation is being performed.</param> /// <returns>The generated syntax tree.</returns> private static GeneratedSyntax GenerateForAssemblies(List<Assembly> assemblies, bool runtime) { if (Logger.IsVerbose) { Logger.Verbose( "Generating code for assemblies: {0}", string.Join(", ", assemblies.Select(_ => _.FullName))); } Assembly targetAssembly; HashSet<Type> ignoredTypes; if (runtime) { // Ignore types which have already been accounted for. ignoredTypes = GetTypesWithGeneratedSupportClasses(); targetAssembly = null; } else { ignoredTypes = new HashSet<Type>(); targetAssembly = assemblies.FirstOrDefault(); } var members = new List<MemberDeclarationSyntax>(); // If any KnownAssemblies have been specified, include them during code generation. var knownAssemblies = assemblies.SelectMany(_ => _.GetCustomAttributes<KnownAssemblyAttribute>()) .Select(_ => _.Assembly) .Distinct() .ToSet(); if (knownAssemblies.Count > 0) { knownAssemblies.UnionWith(assemblies); assemblies = knownAssemblies.ToList(); } // Get types from assemblies which reference Orleans and are not generated assemblies. var includedTypes = new HashSet<Type>(); for (var i = 0; i < assemblies.Count; i++) { var assembly = assemblies[i]; foreach (var attribute in assembly.GetCustomAttributes<KnownTypeAttribute>()) { ConsiderType(attribute.Type, runtime, targetAssembly, includedTypes); } foreach (var type in assembly.DefinedTypes) { ConsiderType(type, runtime, targetAssembly, includedTypes); } } includedTypes.RemoveWhere(_ => ignoredTypes.Contains(_)); // Group the types by namespace and generate the required code in each namespace. foreach (var group in includedTypes.GroupBy(_ => CodeGeneratorCommon.GetGeneratedNamespace(_))) { var namespaceMembers = new List<MemberDeclarationSyntax>(); foreach (var type in group) { // The module containing the serializer. var module = runtime ? null : type.Module; // Every type which is encountered must be considered for serialization. Action<Type> onEncounteredType = encounteredType => { // If a type was encountered which can be accessed, process it for serialization. SerializerGenerationManager.RecordTypeToGenerate(encounteredType, module, targetAssembly); }; if (Logger.IsVerbose2) { Logger.Verbose2("Generating code for: {0}", type.GetParseableName()); } if (GrainInterfaceData.IsGrainInterface(type)) { if (Logger.IsVerbose2) { Logger.Verbose2( "Generating GrainReference and MethodInvoker for {0}", type.GetParseableName()); } GrainInterfaceData.ValidateInterfaceRules(type); namespaceMembers.Add(GrainReferenceGenerator.GenerateClass(type, onEncounteredType)); namespaceMembers.Add(GrainMethodInvokerGenerator.GenerateClass(type)); } // Generate serializers. var first = true; Type toGen; while (SerializerGenerationManager.GetNextTypeToProcess(out toGen)) { if (!runtime) { if (first) { ConsoleText.WriteStatus("ClientGenerator - Generating serializer classes for types:"); first = false; } ConsoleText.WriteStatus( "\ttype " + toGen.FullName + " in namespace " + toGen.Namespace + " defined in Assembly " + toGen.Assembly.GetName()); } if (Logger.IsVerbose2) { Logger.Verbose2( "Generating & Registering Serializer for Type {0}", toGen.GetParseableName()); } namespaceMembers.AddRange(SerializerGenerator.GenerateClass(toGen, onEncounteredType)); } } if (namespaceMembers.Count == 0) { if (Logger.IsVerbose) { Logger.Verbose2("Skipping namespace: {0}", group.Key); } continue; } members.Add( SF.NamespaceDeclaration(SF.ParseName(group.Key)) .AddUsings( TypeUtils.GetNamespaces(typeof(TaskUtility), typeof(GrainExtensions)) .Select(_ => SF.UsingDirective(SF.ParseName(_))) .ToArray()) .AddMembers(namespaceMembers.ToArray())); } return new GeneratedSyntax { SourceAssemblies = assemblies, Syntax = members.Count > 0 ? SF.CompilationUnit().AddMembers(members.ToArray()) : null }; }
private void MarkMessages() { HashSet<MarkRequest> hash; using (_rwLock.GetReadLock()) hash = new HashSet<MarkRequest>(_requests); foreach (var group in hash .GroupBy(rq => rq.IsRead) .Select(grp => new { IsRead = grp.Key, Ids = grp.SelectMany(rq => rq.MsgIds) })) MarkMsgsRead( _provider, group.Ids, group.IsRead); using (_rwLock.GetWriteLock()) _requests.RemoveAll(hash.Contains); foreach (var notificator in hash.Select(rq => rq.MarkFinished)) notificator(); }
/// <summary> /// Generates a syntax tree for the provided assemblies. /// </summary> /// <param name="assemblies">The assemblies to generate code for.</param> /// <param name="runtime">Whether or not runtime code generation is being performed.</param> /// <returns>The generated syntax tree.</returns> private static GeneratedSyntax GenerateForAssemblies(List<Assembly> assemblies, bool runtime) { if (Logger.IsVerbose) { Logger.Verbose( "Generating code for assemblies: {0}", string.Join(", ", assemblies.Select(_ => _.FullName))); } Assembly targetAssembly; HashSet<Type> ignoredTypes; if (runtime) { // Ignore types which have already been accounted for. ignoredTypes = CodeGeneratorCommon.GetTypesWithImplementations( typeof(MethodInvokerAttribute), typeof(GrainReferenceAttribute), typeof(GrainStateAttribute), typeof(SerializerAttribute)); targetAssembly = null; } else { ignoredTypes = new HashSet<Type>(); targetAssembly = assemblies.FirstOrDefault(); } var members = new List<MemberDeclarationSyntax>(); // Get types from assemblies which reference Orleans and are not generated assemblies. var includedTypes = new HashSet<Type>(); foreach (var type in assemblies.SelectMany(_ => _.DefinedTypes)) { // The module containing the serializer. var module = runtime ? null : type.Module; var typeInfo = type.GetTypeInfo(); // Every type which is encountered must be considered for serialization. if (!typeInfo.IsNested && !typeInfo.IsGenericParameter && typeInfo.IsSerializable) { // If a type was encountered which can be accessed, process it for serialization. var isAccessibleForSerialization = !TypeUtilities.IsTypeIsInaccessibleForSerialization(type, module, targetAssembly); if (isAccessibleForSerialization) { includedTypes.Add(type); SerializerGenerationManager.RecordTypeToGenerate(type); } } // Collect the types which require code generation. if (GrainInterfaceData.IsGrainInterface(type)) { if (Logger.IsVerbose2) { Logger.Verbose2("Will generate code for: {0}", type.GetParseableName()); } includedTypes.Add(type); } } includedTypes.RemoveWhere(_ => ignoredTypes.Contains(_)); // Group the types by namespace and generate the required code in each namespace. foreach (var group in includedTypes.GroupBy(_ => CodeGeneratorCommon.GetGeneratedNamespace(_))) { var namespaceMembers = new List<MemberDeclarationSyntax>(); foreach (var type in group) { // The module containing the serializer. var module = runtime ? null : type.Module; // Every type which is encountered must be considered for serialization. Action<Type> onEncounteredType = encounteredType => { // If a type was encountered which can be accessed, process it for serialization. var isAccessibleForSerialization = !TypeUtilities.IsTypeIsInaccessibleForSerialization(encounteredType, module, targetAssembly); if (isAccessibleForSerialization) { SerializerGenerationManager.RecordTypeToGenerate(encounteredType); } }; if (Logger.IsVerbose2) { Logger.Verbose2("Generating code for: {0}", type.GetParseableName()); } if (GrainInterfaceData.IsGrainInterface(type)) { if (Logger.IsVerbose2) { Logger.Verbose2( "Generating GrainReference and MethodInvoker for {0}", type.GetParseableName()); } namespaceMembers.Add(GrainReferenceGenerator.GenerateClass(type, onEncounteredType)); namespaceMembers.Add(GrainMethodInvokerGenerator.GenerateClass(type)); } // Generate serializers. var first = true; Type toGen; while (SerializerGenerationManager.GetNextTypeToProcess(out toGen)) { // Filter types which are inaccessible by the serialzation module/assembly. var skipSerialzerGeneration = toGen.GetAllFields() .Any( field => TypeUtilities.IsTypeIsInaccessibleForSerialization( field.FieldType, module, targetAssembly)); if (skipSerialzerGeneration) { continue; } if (!runtime) { if (first) { ConsoleText.WriteStatus("ClientGenerator - Generating serializer classes for types:"); first = false; } ConsoleText.WriteStatus( "\ttype " + toGen.FullName + " in namespace " + toGen.Namespace + " defined in Assembly " + toGen.Assembly.GetName()); } if (Logger.IsVerbose2) { Logger.Verbose2( "Generating & Registering Serializer for Type {0}", toGen.GetParseableName()); } namespaceMembers.AddRange(SerializerGenerator.GenerateClass(toGen, onEncounteredType)); } } if (namespaceMembers.Count == 0) { if (Logger.IsVerbose) { Logger.Verbose2("Skipping namespace: {0}", group.Key); } continue; } members.Add( SF.NamespaceDeclaration(SF.ParseName(group.Key)) .AddUsings( TypeUtils.GetNamespaces(typeof(TaskUtility), typeof(GrainExtensions)) .Select(_ => SF.UsingDirective(SF.ParseName(_))) .ToArray()) .AddMembers(namespaceMembers.ToArray())); } return new GeneratedSyntax { SourceAssemblies = assemblies, Syntax = members.Count > 0 ? SF.CompilationUnit().AddMembers(members.ToArray()) : null }; }
private void Initialize() { if (null == _consumingMethod) throw new InvalidOperationException("Consuming method has not been defined"); if (!_assemblies.Any()) throw new InvalidOperationException("There are no assemblies to scan"); var types = _assemblies .SelectMany(a => { try { return a.GetExportedTypes(); } catch{} return new Type[0]; }).Where(x=>x!=null) .ToList(); var messageTypes = types.Where(x => !x.IsInterface && typeof(IMessage).IsAssignableFrom(x)).ToArray(); var consumerTypes = types.Where(x => typeof(IConsume).IsAssignableFrom(x)).ToArray(); var consumingDirectly = consumerTypes .SelectMany(consumerType => GetConsumedMessages(consumerType) .Select(messageType => new MessageMapping(consumerType, messageType, true))) .ToArray(); var result = new HashSet<MessageMapping>(); foreach (var m in consumingDirectly) { result.Add(m); } var allMessages = result.Select(m => m.Message).ToList(); foreach (var messageType in messageTypes) { if (!allMessages.Contains(messageType)) { allMessages.Add(messageType); result.Add(new MessageMapping(typeof(MessageMapping.BusNull), messageType, true)); } } _consumerInfos = result .GroupBy(x => x.Consumer) .Select(x => { var directs = x .Where(m => m.Direct) .Select(m => m.Message) .Distinct(); var assignables = x .Select(m => m.Message) .Where(t => directs.Any(d => d.IsAssignableFrom(t))) .Distinct(); return new ConsumerInfo(x.Key, assignables.ToArray()); }).ToList(); _messageInfos = result .ToLookup(x => x.Message) .Select(x => { var domainConsumers = x .Where(t => t.Consumer != typeof(MessageMapping.BusNull)) .ToArray(); return new MessageInfo { MessageType = x.Key, AllConsumers = domainConsumers.Select(m => m.Consumer).Distinct().ToArray(), DerivedConsumers = domainConsumers.Where(m => !m.Direct).Select(m => m.Consumer).Distinct().ToArray(), DirectConsumers = domainConsumers.Where(m => m.Direct).Select(m => m.Consumer).Distinct().ToArray(), }; }).ToList(); var includedTypes = _messageInfos .Select(m => m.MessageType).ToList(); // message directory should still include all messages for the serializers var orphanedMessages = result .Where(m => !includedTypes.Contains(m.Message)) .Select(m => new MessageInfo { MessageType = m.Message, AllConsumers = Type.EmptyTypes, DerivedConsumers = Type.EmptyTypes, DirectConsumers = Type.EmptyTypes }); _messageInfos.AddRange(orphanedMessages); }
static int Main(string[] args) { #region Command Line argument processing if ( args.Contains ("--help") ) { Console.WriteLine ("This tool depends on Microsoft Office 2010+"); Console.WriteLine ("Valid switches are"); Console.WriteLine ("-ignore <comma separated list of file extn> : Ignore line with pattern"); Console.WriteLine ("-include <comma separated list of file extn> : Filter for pattern"); Console.WriteLine ("-concurrency <No of minutes> : Concurrency Window in minutes"); Console.WriteLine ("-toppages <No of pages> : No of Top Pages/day"); Console.WriteLine ("-peaks <No of peaks> : No of Peak Hours to consider"); Console.WriteLine ("-param <comma seperated list of patterns> : Summarize specific URL parameters"); Console.WriteLine ("-export <export filename> : Excel file report name, default will be with time stamp"); Console.WriteLine ("-folder <log file folder path> : Current folder will be defaulted. All .log files in this folder will be processed."); Console.WriteLine ("Add a space after the pattern if you want extension mapping (e.g. .aspx ,.jpg)"); return 0; } if ( args.Length % 2 != 0 ) { throw new ArgumentException ("Command line arguments not valid, try --help to see valid ones!"); } Dictionary<string, string> cmdArgs = new Dictionary<string, string> (); for ( int i = 0; i < args.Length; i += 2 ) { cmdArgs.Add (args[i].ToLower (), args[i + 1]); } List<string> ignoredTypes = new List<string> (), filterTypes = new List<string> (), hitsPerURLParams = new List<string> (); if ( cmdArgs.ContainsKey (IgnoreSwitch) ) { ignoredTypes = cmdArgs[IgnoreSwitch].ToLower ().Split (',').ToList (); } if ( cmdArgs.ContainsKey (FilterSwitch) ) { filterTypes = cmdArgs[FilterSwitch].ToLower ().Split (',').ToList (); } if ( cmdArgs.ContainsKey (URLParamsSwitch) ) { hitsPerURLParams = cmdArgs[URLParamsSwitch].ToLower ().Split (',').ToList (); } float concurrencyWindow = 5; if ( cmdArgs.ContainsKey (ConcurrencySwitch) ) { concurrencyWindow = float.Parse (cmdArgs[ConcurrencySwitch]); } else cmdArgs.Add (ConcurrencySwitch, concurrencyWindow.ToString ()); int topPagesPerDay = 10; if ( cmdArgs.ContainsKey (TopPagesSwitch) ) { topPagesPerDay = int.Parse (cmdArgs[TopPagesSwitch]); } else cmdArgs.Add (TopPagesSwitch, topPagesPerDay.ToString ()); int peakHoursCount = 3; if ( cmdArgs.ContainsKey (PeakHoursSwitch) ) { peakHoursCount = int.Parse (cmdArgs[PeakHoursSwitch]); } else cmdArgs.Add (PeakHoursSwitch, peakHoursCount.ToString ()); string exportFileName = null; if ( cmdArgs.ContainsKey (ExportFileSwitch) ) { try { exportFileName = Path.GetFullPath (cmdArgs[ExportFileSwitch]); } catch ( Exception e ) { Console.WriteLine ("Error creating report file:{0},{1}", e.GetType ().Name, e.Message); } } if ( exportFileName == null ) { exportFileName = Path.GetFullPath ("Processing results_" + DateTime.Now.ToString ("dd_hh_mm") + ".xlsx"); Console.WriteLine ("Writing output to {0}", exportFileName); } string curerntPath; if ( cmdArgs.ContainsKey (FolderSwitch) ) { try { curerntPath = Path.GetFullPath (cmdArgs[FolderSwitch]); } catch ( Exception e ) { Console.WriteLine ("Error accessing folder {0}:{1},{2}", cmdArgs[FolderSwitch], e.GetType ().Name, e.Message); return 1; } } else { curerntPath = Directory.GetCurrentDirectory (); Console.WriteLine ("Working on IIS logs from current folder {0}", curerntPath); } #endregion Stopwatch stopWatch = new Stopwatch (); stopWatch.Start (); //var files = Directory.GetFiles(curerntPath, "*.log").ToList(); var files = new DirectoryInfo (curerntPath) .GetFiles ("*.log") .OrderBy (f => f.LastWriteTime) .Select (f => f.FullName) .ToArray (); var totalFile = files.Count (); if ( totalFile == 0 ) { Console.WriteLine ("No log files found!!"); return 0; } Console.WriteLine ("Found {0} log files", totalFile); var tmpFile = System.IO.Path.GetTempFileName (); int fileCount = 0; int headerRows = 4; int entryCount = 0; List<IISLogEntry> processingList = new List<IISLogEntry> (); DateTime nextTime = DateTime.MinValue; long TotalHits = 0, ServedRequests = 0; List<ConcurrentRequest> requests = new List<ConcurrentRequest> (); HashSet<string> uniqueIPs = new HashSet<string> (); Dictionary<int, int> httpStatus = new Dictionary<int, int> (); Dictionary<string, MethodInfo> pageViewsForPeriod = new Dictionary<string, MethodInfo> (); int totalDays = 0, totalHours = 0; Dictionary<string, MethodInfo> pageViewsDaily = new Dictionary<string, MethodInfo> (); HashSet<MethodInfo> dailyPages = new HashSet<MethodInfo> (); Dictionary<string, MethodInfo> pageViewsHourly = new Dictionary<string, MethodInfo> (); HashSet<MethodInfo> hourlyPages = new HashSet<MethodInfo> (); //hits for key URL parameters Dictionary<string, MethodInfo> urlParamHits = new Dictionary<string, MethodInfo> (); DateTime firstEntry = DateTime.MinValue, lastEntry = DateTime.MinValue; //placeholder HashSet<MethodInfo> filteredEntries = new HashSet<MethodInfo> (); int startRow = 1, startCol = 1; int reportRow = 2, reportCol = 1; Console.WriteLine ("Preparing to Process.."); foreach ( var f in files ) { try { ++fileCount; var progress = fileCount * 100 / totalFile; IEnumerable<string> matchedEntries = null; var contents = File.ReadLines (f); Dictionary<string, int> fieldIndex = new Dictionary<string, int> (); #region Content filter if ( filterTypes.Any () && ignoredTypes.Any () ) matchedEntries = contents.Where (s => s.StartsWith ("#") || ( filterTypes.Any (x => s.ToLower ().Contains (x)) && !ignoredTypes.Any (x => s.ToLower ().Contains (x)) )); else if ( filterTypes.Any () ) matchedEntries = contents.Where (s => s.StartsWith ("#") || filterTypes.Any (x => s.ToLower ().Contains (x))); else if ( ignoredTypes.Any () ) matchedEntries = contents.Where (s => s.StartsWith ("#") || !ignoredTypes.Any (x => s.ToLower ().Contains (x))); else matchedEntries = contents; foreach ( var rawLogEntry in matchedEntries ) { IISLogEntry logEntry; if ( rawLogEntry.StartsWith ("#") ) { if ( rawLogEntry.StartsWith ("#Fields:") ) fieldIndex = ParseHeaderFields (rawLogEntry); } else { Console.Write ("\r{0} File {1} of {2} files ({3}%), processing {4} ", stopWatch.Elapsed.ToString (@"hh\:mm\:ss"), fileCount, totalFile, progress, ++TotalHits); var columns = rawLogEntry.Split (' '); logEntry = new IISLogEntry () { TimeStamp = DateTime.Parse (columns[0] + " " + columns[1]), ClientIPAddress = fieldIndex.ContainsKey (IISLogEntry.propClientIPAddress) ? columns[fieldIndex[IISLogEntry.propClientIPAddress]] : String.Empty, UserName = fieldIndex.ContainsKey (IISLogEntry.propUserName) ? columns[fieldIndex[IISLogEntry.propUserName]] : String.Empty, ServiceNameandInstanceNumber = fieldIndex.ContainsKey (IISLogEntry.propServiceNameandInstanceNumber) ? columns[fieldIndex[IISLogEntry.propServiceNameandInstanceNumber]] : String.Empty, ServerName = fieldIndex.ContainsKey (IISLogEntry.propServerName) ? columns[fieldIndex[IISLogEntry.propServerName]] : String.Empty, ServerIPAddress = fieldIndex.ContainsKey (IISLogEntry.propServerIPAddress) ? columns[fieldIndex[IISLogEntry.propServerIPAddress]] : String.Empty, ServerPort = fieldIndex.ContainsKey (IISLogEntry.propClientIPAddress) ? Int32.Parse (columns[fieldIndex[IISLogEntry.propServerPort]]) : 0, Method = fieldIndex.ContainsKey (IISLogEntry.propMethod) ? columns[fieldIndex[IISLogEntry.propMethod]] : String.Empty, URIStem = fieldIndex.ContainsKey (IISLogEntry.propURIStem) ? columns[fieldIndex[IISLogEntry.propURIStem]] : String.Empty, URIQuery = fieldIndex.ContainsKey (IISLogEntry.propURIQuery) ? columns[fieldIndex[IISLogEntry.propURIQuery]] : String.Empty, HTTPStatus = fieldIndex.ContainsKey (IISLogEntry.propHTTPStatus) ? Int32.Parse (columns[fieldIndex[IISLogEntry.propHTTPStatus]]) : 0, //Win32Status = fieldIndex.ContainsKey(IISLogEntry.propWin32Status) ? Int32.Parse(row[fieldIndex[IISLogEntry.propWin32Status]]) : 0, BytesSent = fieldIndex.ContainsKey (IISLogEntry.propBytesSent) ? Int32.Parse (columns[fieldIndex[IISLogEntry.propBytesSent]]) : 0, BytesReceived = fieldIndex.ContainsKey (IISLogEntry.propBytesReceived) ? Int32.Parse (columns[fieldIndex[IISLogEntry.propBytesReceived]]) : 0, TimeTaken = fieldIndex.ContainsKey (IISLogEntry.propTimeTaken) ? Int32.Parse (columns[fieldIndex[IISLogEntry.propTimeTaken]]) : 0, ProtocolVersion = fieldIndex.ContainsKey (IISLogEntry.propProtocolVersion) ? columns[fieldIndex[IISLogEntry.propProtocolVersion]] : String.Empty, Host = fieldIndex.ContainsKey (IISLogEntry.propHost) ? columns[fieldIndex[IISLogEntry.propHost]] : String.Empty, UserAgent = fieldIndex.ContainsKey (IISLogEntry.propUserAgent) ? columns[fieldIndex[IISLogEntry.propUserAgent]] : String.Empty, Cookie = fieldIndex.ContainsKey (IISLogEntry.propCookie) ? columns[fieldIndex[IISLogEntry.propCookie]] : String.Empty, Referrer = fieldIndex.ContainsKey (IISLogEntry.propReferrer) ? columns[fieldIndex[IISLogEntry.propReferrer]] : String.Empty, ProtocolSubstatus = fieldIndex.ContainsKey (IISLogEntry.propProtocolSubstatus) ? columns[fieldIndex[IISLogEntry.propProtocolSubstatus]] : String.Empty }; #endregion #region entry processing var url = logEntry.URIStem.ToLower (); #region HTTP status codes & IP if ( httpStatus.ContainsKey (logEntry.HTTPStatus) ) httpStatus[logEntry.HTTPStatus]++; else httpStatus.Add (logEntry.HTTPStatus, 1); if ( !uniqueIPs.Contains (logEntry.ClientIPAddress) ) uniqueIPs.Add (logEntry.ClientIPAddress); #endregion if ( nextTime == DateTime.MinValue ) { firstEntry = logEntry.TimeStamp; lastEntry = logEntry.TimeStamp; nextTime = logEntry.TimeStamp.Date. AddHours (logEntry.TimeStamp.Hour). AddMinutes (logEntry.TimeStamp.Minute). AddMinutes (concurrencyWindow); } if ( logEntry.TimeStamp > nextTime ) { if ( processingList.Any () ) { requests.Add (new ConcurrentRequest (concurrencyWindow) { TimeStamp = nextTime, Transactions = processingList.Count, AverageResponseTime = processingList.Average (p => p.TimeTaken), BytesSent = processingList.Sum (t => t.BytesSent) }); processingList.Clear (); } else { requests.Add (new ConcurrentRequest (concurrencyWindow) { TimeStamp = nextTime, Transactions = 0, AverageResponseTime = 0, BytesSent = 0 }); } nextTime = nextTime.AddMinutes (concurrencyWindow); } if ( lastEntry.Hour != logEntry.TimeStamp.Hour ) { totalHours++; AddHourlyPages (pageViewsHourly, hourlyPages, lastEntry); } if ( lastEntry.Date != logEntry.TimeStamp.Date ) { totalDays++; AddDailyPages (pageViewsDaily, dailyPages, lastEntry); } //add the current one to future processing, otherwise one in teh borderlien will be missing if ( logEntry.HTTPStatus == 200 ) { processingList.Add (logEntry); ServedRequests++; if ( pageViewsForPeriod.ContainsKey (url) ) pageViewsForPeriod[url].Hit (logEntry.TimeTaken); else pageViewsForPeriod.Add (url, new MethodInfo (logEntry.URIStem, logEntry.TimeTaken)); if ( lastEntry.Hour == logEntry.TimeStamp.Hour ) { if ( pageViewsHourly.ContainsKey (url) ) pageViewsHourly[url].Hit (logEntry.TimeTaken); else pageViewsHourly.Add (url, new MethodInfo (logEntry.URIStem, logEntry.TimeTaken)); } if ( lastEntry.Date == logEntry.TimeStamp.Date ) { if ( pageViewsDaily.ContainsKey (url) ) pageViewsDaily[url].Hit (logEntry.TimeTaken); else pageViewsDaily.Add (url, new MethodInfo (logEntry.URIStem, logEntry.TimeTaken)); } if ( hitsPerURLParams.Any () ) { var urlParam = hitsPerURLParams.Where (p => logEntry.URIQuery.Contains (p)).FirstOrDefault (); if ( urlParam != null && urlParam != String.Empty ) { if ( urlParamHits.ContainsKey (url) ) urlParamHits[url].Hit (logEntry.TimeTaken); else urlParamHits.Add (url, new MethodInfo (urlParam, logEntry.TimeTaken)); } } } lastEntry = logEntry.TimeStamp; } } if ( processingList.Any () ) { requests.Add (new ConcurrentRequest (concurrencyWindow) { TimeStamp = nextTime, Transactions = processingList.Count, AverageResponseTime = processingList.Average (p => p.TimeTaken), BytesSent = processingList.Sum (t => t.BytesSent) }); processingList.Clear (); } AddHourlyPages (pageViewsHourly, hourlyPages, lastEntry); AddDailyPages (pageViewsDaily, dailyPages, lastEntry); #endregion } catch ( Exception e ) { Console.WriteLine ("Error!! {0}:{1} - {2}", e.GetType ().Name, e.Message, e.StackTrace); Debug.WriteLine ("Error!! {0}:{1}", e.GetType ().Name, e.Message); } } Console.WriteLine ("\nGenerating Statistics"); #region resultprocessing IEnumerable<MethodInfo> topPages; IEnumerable<IGrouping<DateTime, MethodInfo>> hourlyHits = null; long peakHits; IEnumerable<IGrouping<DateTime, MethodInfo>> peakHourPages = null; try { excelApp = new Application (); excelApp.Visible = false; reportSpreadsheet = excelApp.Workbooks.Add (); excelApp.Calculation = XlCalculation.xlCalculationManual; reportSheet = reportSpreadsheet.ActiveSheet; #region Concurrent Users if ( requests.Any () ) { Console.WriteLine ("{0} Calculating Concurrent User Count", stopWatch.Elapsed.ToString (@"hh\:mm\:ss")); reportSheet.Name = "Concurrent Users"; reportSheet.Cells[reportRow, reportCol++] = "Timestamp"; reportSheet.Cells[reportRow, reportCol++] = "Requests"; reportSheet.Cells[reportRow, reportCol++] = "TPS"; reportSheet.Cells[reportRow, reportCol++] = "Average Response Time"; reportSheet.Cells[reportRow, reportCol++] = "Concurrent Users (based on Little's Law)"; reportSheet.Cells[reportRow, reportCol++] = "Bytes Sent"; reportSheet.Cells[reportRow, reportCol++] = "Network Speed (Mbps)"; foreach ( var p in requests ) { reportCol = 1; reportRow++; reportSheet.Cells[reportRow, reportCol++] = p.TimeStamp; reportSheet.Cells[reportRow, reportCol++] = p.Transactions; reportSheet.Cells[reportRow, reportCol++] = p.Tps; reportSheet.Cells[reportRow, reportCol++] = p.AverageResponseTime; reportSheet.Cells[reportRow, reportCol++] = p.ConcurrentUsers; reportSheet.Cells[reportRow, reportCol++] = p.BytesSent; reportSheet.Cells[reportRow, reportCol++] = p.NetworkSpeed; } } #endregion reportSpreadsheet.Application.DisplayAlerts = false; reportSpreadsheet.SaveAs (exportFileName, ConflictResolution: XlSaveConflictResolution.xlLocalSessionChanges); #region Page visit Summary if ( pageViewsForPeriod.Any () ) { Console.WriteLine ("{0} Genrating Page visit Summary", stopWatch.Elapsed.ToString (@"hh\:mm\:ss")); reportSheet = reportSpreadsheet.Worksheets.Add (Type.Missing, reportSheet, 1); reportSheet.Name = "Page visit Summary"; startRow = startCol = 1; startRow = CollectionToTable (pageViewsForPeriod.Values, startRow, startCol, "Page visit Summary (for the period)"); reportSheet.Shapes.AddChart (XlChartType.xlLine).Select (); excelApp.ActiveChart.SetSourceData (Source: reportSheet.get_Range ("A1:B" + startRow)); reportSheet.Shapes.AddChart (XlChartType.xlPie).Select (); excelApp.ActiveChart.SetSourceData (Source: reportSheet.get_Range ("A1:B" + startRow)); excelApp.ActiveChart.ClearToMatchStyle (); try { excelApp.ActiveChart.ChartStyle = 256; } catch ( Exception e ) { } excelApp.ActiveChart.SetElement (Microsoft.Office.Core.MsoChartElementType.msoElementChartTitleAboveChart); excelApp.ActiveChart.ChartTitle.Text = "Page visit Summary (for the period) Most Visited Pages"; reportSheet.Shapes.AddChart (XlChartType.xlBarClustered).Select (); excelApp.ActiveChart.SetSourceData (Source: reportSheet.get_Range ("A1:D" + startRow)); excelApp.ActiveChart.ClearToMatchStyle (); try { excelApp.ActiveChart.ChartStyle = 222; } catch ( Exception e ) { } excelApp.ActiveChart.SetElement (Microsoft.Office.Core.MsoChartElementType.msoElementChartTitleAboveChart); excelApp.ActiveChart.ChartTitle.Text = "Page visit Summary (for the period) Average Response Time"; SpreadCharts (reportSheet); } #endregion #region Daily Analysis if ( dailyPages.Any () ) { Console.WriteLine ("{0} Genrating Daily Statistics", stopWatch.Elapsed.ToString (@"hh\:mm\:ss")); reportSheet = reportSpreadsheet.Worksheets.Add (Type.Missing, reportSheet, 1); reportSheet.Name = "Daily Analysis"; foreach ( var d in dailyPages.Select (p => p.Timestamp).Distinct () ) { filteredEntries.UnionWith (dailyPages.Where (p => p.Timestamp == d.Date) .OrderByDescending (p => p.Hits).Take (topPagesPerDay)); //Debug.WriteLine("Date: {0} - {1}", date, MethodInfo.TotalHits(dailyPages.Where(p => p.Timestamp == d.Date))); } topPages = filteredEntries.Where (p => filteredEntries.Count (q => q.Url == p.Url) > totalDays / 2); startRow = startCol = 1; AddChartFromSeries (startRow, startCol, "Daily Top Pages - Visits Trend", topPages, p => p.Hits, d => d.ToString (DateTimeFormatInfo.CurrentInfo.ShortDatePattern)); startRow = reportRow + 10; startCol = 1; AddChartFromSeries (startRow, startCol, "Daily Top Pages - Response Time(Average) Trend", topPages, p => p.AvgResponseTime, d => d.ToString (DateTimeFormatInfo.CurrentInfo.ShortDatePattern)); startRow = reportRow + 10; startCol = 1; AddChartFromSeries (startRow, startCol, "Daily Top Pages - Response Time(90%tile) Trend", topPages, p => p.NinetiethPercentile, d => d.ToString (DateTimeFormatInfo.CurrentInfo.ShortDatePattern)); startRow = 1; startCol = 30; filteredEntries.Clear (); //reportSheet.Cells[reportRow, reportCol] = "Date"; foreach ( var d in dailyPages.Select (p => p.Timestamp).Distinct () ) { filteredEntries.UnionWith (dailyPages.Where (p => p.Timestamp == d.Date) .OrderByDescending (p => p.NinetiethPercentile).Take (topPagesPerDay)); } topPages = filteredEntries.Where (p => filteredEntries.Count (q => q.Url == p.Url) > totalDays / 2); AddChartFromSeries (startRow, startCol, "Daily Slow Pages - Response Time(90%tile) Trend", topPages, p => p.NinetiethPercentile, d => d.ToString (DateTimeFormatInfo.CurrentInfo.ShortDatePattern)); startRow = reportRow + 10; startCol = 30; filteredEntries.Clear (); //reportSheet.Cells[reportRow, reportCol] = "Date"; foreach ( var d in dailyPages.Select (p => p.Timestamp).Distinct () ) { filteredEntries.UnionWith (dailyPages.Where (p => p.Timestamp == d.Date) .OrderByDescending (p => p.AvgResponseTime).Take (topPagesPerDay)); //Debug.WriteLine("Date: {0} - {1}", date, MethodInfo.TotalHits(dailyPages.Where(p => p.Timestamp == d.Date))); } topPages = filteredEntries.Where (p => filteredEntries.Count (q => q.Url == p.Url) > totalDays / 2); AddChartFromSeries (startRow, startCol, "Daily Slow Pages - Response Time(Average) Trend", topPages, p => p.AvgResponseTime, d => d.ToString (DateTimeFormatInfo.CurrentInfo.ShortDatePattern)); SpreadCharts (reportSheet); } #endregion #region Hourly analysis if ( hourlyPages.Any () ) { Console.WriteLine ("{0} Genrating Hourly Statistics", stopWatch.Elapsed.ToString (@"hh\:mm\:ss")); reportSheet = reportSpreadsheet.Worksheets.Add (Type.Missing, reportSheet, 1); reportSheet.Name = "Hourly Analysis"; startRow = 1; startCol = 1; filteredEntries.Clear (); foreach ( var d in hourlyPages.Select (p => p.Timestamp).Distinct () ) { filteredEntries.UnionWith (hourlyPages.Where (p => p.Timestamp == d.Date.AddHours (d.Hour)) .OrderByDescending (p => p.Hits).Take (topPagesPerDay)); //Debug.WriteLine("Date: {0} - {1}", date, MethodInfo.TotalHits(dailyPages.Where(p => p.Timestamp == d.Date))); } var totalHits = hourlyPages.Sum (p => p.Hits); //filter out top pages which are there for 10% of time or 2% traffic topPages = filteredEntries.Where (p => filteredEntries.Count (q => q.Url == p.Url) > totalHours / 10 || p.Hits > totalHits * 2 / 100); startRow += AddChartFromSeries (startRow, startCol, "Hourly Top Pages Summary (By Hits)", topPages, p => p.Hits, d => d.ToString ()); excelApp.ActiveChart.Axes (XlAxisType.xlCategory).CategoryType = XlCategoryType.xlCategoryScale; hourlyHits = hourlyPages.GroupBy (p => p.Timestamp, q => q); peakHits = hourlyHits.Select (p => p.Sum (q => q.Hits)).OrderByDescending (p => p).Take (peakHoursCount).Min (); peakHourPages = hourlyHits.Where (p => p.Sum (q => q.Hits) >= peakHits); startRow += 10; startCol = 1; startRow += AddChartFromSeries (startRow, startCol, "Peak Hour Top Pages Summary (By Hits)", peakHourPages.SelectMany (g => g.Where (p => p.Hits > peakHits * 2 / 100)), p => p.Hits, d => d.ToString ()); excelApp.ActiveChart.Axes (XlAxisType.xlCategory).CategoryType = XlCategoryType.xlCategoryScale; CollectionToTable (peakHourPages.SelectMany (g => g), startRow + 10, 1, "Peak Hour Pages", true); SpreadCharts (reportSheet); } #endregion #region URL Param Hits Summary if ( hitsPerURLParams.Any () ) { Console.WriteLine ("{0} Genrating URL parameter statistics", stopWatch.Elapsed.ToString (@"hh\:mm\:ss")); reportSheet = reportSpreadsheet.Worksheets.Add (Type.Missing, reportSheet, 1); startRow = startCol = 1; reportSheet.Name = "URL Parameters"; CollectionToTable (urlParamHits.Values, startRow, startCol, "URL Parameters Summary (for the period)"); } #endregion #region Summary Console.WriteLine ("{0} Genrating Summary", stopWatch.Elapsed.ToString (@"hh\:mm\:ss")); reportSheet = reportSpreadsheet.Worksheets.Add (reportSheet, Type.Missing, 1); reportRow = reportCol = 1; reportSheet.Name = "Summary"; reportSheet.Cells[reportRow, 1] = "Running From"; reportSheet.Cells[reportRow++, 2] = curerntPath; reportSheet.Cells[reportRow, 1] = "Commandline Argument"; reportSheet.Cells[reportRow++, 2] = string.Join (";", cmdArgs.Select (x => x.Key + "=" + x.Value)); reportSheet.Cells[reportRow, 1] = "Files Processed"; reportSheet.Cells[reportRow++, 2] = fileCount; reportSheet.Cells[reportRow, 1] = "From"; reportSheet.Cells[reportRow++, 2] = firstEntry; reportSheet.Cells[reportRow, 1] = "To"; reportSheet.Cells[reportRow++, 2] = lastEntry; reportSheet.Cells[reportRow, 1] = "TotalHits"; reportSheet.Cells[reportRow++, 2] = TotalHits; reportSheet.Cells[reportRow, 1] = "Average Transactions/Sec"; reportSheet.Cells[reportRow++, 2] = requests.Average (p => p.Tps); if ( hourlyHits!=null ) { reportSheet.Cells[reportRow, 1] = "Average Transactions/Hour"; reportSheet.Cells[reportRow++, 2] = hourlyHits.Average (p => p.Sum (q => q.Hits)); } if ( peakHourPages!=null ) { reportSheet.Cells[reportRow, 1] = "Peak Hour Transactions/Hour"; reportSheet.Cells[reportRow++, 2] = peakHourPages.Average (p => p.Sum (q => q.Hits)); reportSheet.Cells[reportRow, 1] = "Peak Hour Transactions/Sec"; reportSheet.Cells[reportRow++, 2] = peakHourPages.Average (p => p.Sum (q => q.Hits) / 3600); } reportSheet.Cells[reportRow, 1] = "UniqueIPs"; reportSheet.Cells[reportRow++, 2] = uniqueIPs.Count; reportSheet.Cells[reportRow, 1] = "ServedRequests"; reportSheet.Cells[reportRow++, 2] = ServedRequests; reportRow += 10; reportSheet.Cells[reportRow++, 1] = "Http Status code summary"; reportSheet.Cells[reportRow, 1] = "HTTP Code"; reportSheet.Cells[reportRow++, 2] = "Count"; foreach ( var i in httpStatus ) { reportSheet.Cells[reportRow, reportCol++] = i.Key; reportSheet.Cells[reportRow++, reportCol--] = ( i.Value ); } #endregion } catch ( Exception e ) { Console.WriteLine ("Error!! {0}:{1} - {2}", e.GetType ().Name, e.Message, e.StackTrace); Debug.WriteLine ("Error!! {0}:{1}", e.GetType ().Name, e.Message); } finally { if ( excelApp != null ) { excelApp.Calculation = XlCalculation.xlCalculationAutomatic; if ( reportSpreadsheet != null ) { reportSpreadsheet.Save (); reportSpreadsheet.Close (); excelApp.Quit (); } } File.Delete (tmpFile); stopWatch.Stop (); Console.WriteLine ("Done, Final time : {0}", stopWatch.Elapsed.ToString (@"hh\:mm\:ss")); } #endregion return 0; }
internal static ReadOnlyCollection<MethodMockableResult> GetMockableMethods(this Type @this, NameGenerator generator) { var objectMethods = @this.IsInterface ? typeof(object).GetMethods().Where(_ => _.IsExtern() || _.IsVirtual).ToList() : new List<MethodInfo>(); var methods = new HashSet<MockableResult<MethodInfo>>(@this.GetMethods(ReflectionValues.PublicNonPublicInstance) .Where(_ => !_.IsSpecialName && _.IsVirtual && !_.IsFinal && !objectMethods.Where(om => om.Match(_) == MethodMatch.Exact).Any() && _.DeclaringType.Assembly.CanBeSeenByMockAssembly(_.IsPublic, _.IsPrivate, _.IsFamily, _.IsFamilyOrAssembly, generator)) .Select(_ => new MockableResult<MethodInfo>(_, RequiresExplicitInterfaceImplementation.No))); if (@this.IsInterface) { var namespaces = new SortedSet<string>(); foreach (var @interface in @this.GetInterfaces()) { var interfaceMethods = @interface.GetMethods() .Where(_ => !_.IsSpecialName && !objectMethods.Where(om => om.Match(_) == MethodMatch.Exact).Any()); foreach (var interfaceMethod in interfaceMethods) { if (interfaceMethod.CanBeSeenByMockAssembly(generator)) { var matchMethodGroups = methods.GroupBy(_ => interfaceMethod.Match(_.Value)).ToDictionary(_ => _.Key); if (!matchMethodGroups.ContainsKey(MethodMatch.Exact)) { methods.Add(new MockableResult<MethodInfo>( interfaceMethod, matchMethodGroups.ContainsKey(MethodMatch.DifferByReturnTypeOnly) ? RequiresExplicitInterfaceImplementation.Yes : RequiresExplicitInterfaceImplementation.No)); } } } } } var baseStaticMethods = @this.IsInterface ? typeof(object).GetMethods().Where(_ => _.IsStatic).ToList() : @this.GetMethods().Where(_ => _.IsStatic).ToList(); return methods.Select(_ => new MethodMockableResult( _.Value, _.RequiresExplicitInterfaceImplementation, baseStaticMethods.Where(osm => osm.Match(_.Value) == MethodMatch.Exact).Any() ? RequiresIsNewImplementation.Yes : RequiresIsNewImplementation.No)).ToList().AsReadOnly(); }
internal static ReadOnlyCollection<PropertyMockableResult> GetMockableProperties(this Type @this, NameGenerator generator) { var properties = new HashSet<PropertyMockableResult>( from property in @this.GetProperties(ReflectionValues.PublicNonPublicInstance) let canGet = property.CanRead && property.GetMethod.IsVirtual && !property.GetMethod.IsFinal && property.GetMethod.DeclaringType.Assembly.CanBeSeenByMockAssembly( property.GetMethod.IsPublic, property.GetMethod.IsPrivate, property.GetMethod.IsFamily, property.GetMethod.IsFamilyOrAssembly, generator) let canSet = property.CanWrite && property.SetMethod.IsVirtual && !property.SetMethod.IsFinal && property.SetMethod.DeclaringType.Assembly.CanBeSeenByMockAssembly( property.SetMethod.IsPublic, property.SetMethod.IsPrivate, property.SetMethod.IsFamily, property.SetMethod.IsFamilyOrAssembly, generator) where canGet || canSet select new PropertyMockableResult(property, RequiresExplicitInterfaceImplementation.No, (canGet && canSet ? PropertyAccessors.GetAndSet : (canGet ? PropertyAccessors.Get : PropertyAccessors.Set)))); if (@this.IsInterface) { var namespaces = new SortedSet<string>(); foreach (var @interface in @this.GetInterfaces()) { foreach (var interfaceProperty in @interface.GetMockableProperties(generator)) { if (interfaceProperty.Value.GetDefaultMethod().CanBeSeenByMockAssembly(generator)) { var matchMethodGroups = properties.GroupBy(_ => interfaceProperty.Value.GetDefaultMethod().Match(_.Value.GetDefaultMethod())).ToDictionary(_ => _.Key); if (!matchMethodGroups.ContainsKey(MethodMatch.Exact)) { properties.Add(new PropertyMockableResult(interfaceProperty.Value, matchMethodGroups.ContainsKey(MethodMatch.DifferByReturnTypeOnly) ? RequiresExplicitInterfaceImplementation.Yes : RequiresExplicitInterfaceImplementation.No, interfaceProperty.Accessors)); } } } } } return properties.ToList().AsReadOnly(); }
/// <summary> /// Check for conflicts of versions in the referenced assemblies of the workflow. /// </summary> /// <param name="referencedTypes">Referenced types in the project</param> /// <param name="referencedAssemblies">Referenced assemblies in the project</param> /// <param name="projectName">Name of the main type (workflow) of the project</param> private static void CheckForConflictingVersions(HashSet<Type> referencedTypes, HashSet<Assembly> referencedAssemblies, string projectName) { // XamlBuildTask cannot support two different versions of the same dependency in XAML. // As a workaround, we raise an error here if the workflow contains activities/variables/etc. // from different versions of the same assembly. var conflicts = referencedAssemblies.GroupBy(asm => asm.GetName().Name).Where(grp => grp.Count() > 1).ToList(); if (conflicts.Any()) { var conflict = conflicts.First(); Assembly asm1 = referencedAssemblies.First(item => item.GetName().Name == conflict.Key); Assembly asm2 = referencedAssemblies.Last(item => item.GetName().Name == conflict.Key); var type1 = referencedTypes.First(item => item.Assembly.GetName().Name == asm1.GetName().Name && item.Assembly.GetName().Version == asm1.GetName().Version); var type2 = referencedTypes.First(item => item.Assembly.GetName().Name == asm2.GetName().Name && item.Assembly.GetName().Version == asm2.GetName().Version); string message = string.Format(CompileMessages.MultipleVersionsUsed, type1.Name, asm1.FullName, type2.Name, asm2.FullName, conflict.Key); throw new CompileException(message); } // Check if the workflow contains a previous version of itself var referencesToItself = new List<Assembly>( from assemblies in referencedAssemblies where assemblies.GetName().Name == projectName select assemblies); if (referencesToItself.Any()) { string message = string.Format(CompileMessages.PreviousSelfVersion, referencesToItself.First().GetName().Name, referencesToItself.First().GetName().FullName); throw new CompileException(message); } }