internal override void AddToHashCodeCombiner(HashCodeCombiner combiner)
{
base.AddToHashCodeCombiner(combiner);
combiner.AddEnumerable(this.Arguments);
combiner.AddObject(this.Method);
combiner.AddFingerprint(this.Target);
}
internal override void AddToHashCodeCombiner(HashCodeCombiner combiner) {
base.AddToHashCodeCombiner(combiner);
combiner.AddFingerprint(Test);
combiner.AddFingerprint(IfTrue);
combiner.AddFingerprint(IfFalse);
}
public override void AddToHashCodeCombiner(HashCodeCombiner combiner)
{
base.AddToHashCodeCombiner(combiner);
combiner.AddObject(Method);
combiner.AddFingerprint(Operand);
}
public override void AddToHashCodeCombiner(HashCodeCombiner combiner)
{
base.AddToHashCodeCombiner(combiner);
combiner.AddObject(Member);
combiner.AddFingerprint(Target);
}
public override int GetHashCode()
{
var combiner = new HashCodeCombiner();
combiner.AddObject(Id);
combiner.AddObject(Version);
return combiner.CombinedHash;
}
public override int GetHashCode()
{
HashCodeCombiner combiner = new HashCodeCombiner();
combiner.AddObject(SourcePath);
combiner.AddObject(TargetPath);
return combiner.CombinedHash;
}
public override void AddToHashCodeCombiner(HashCodeCombiner combiner)
{
base.AddToHashCodeCombiner(combiner);
combiner.AddEnumerable(Arguments);
combiner.AddObject(Method);
combiner.AddFingerprint(Target);
}
private void CalculateProfilePropertySettingsHash(ProfilePropertySettingsCollection settings, HashCodeCombiner hashCombiner)
{
foreach (ProfilePropertySettings settings2 in settings)
{
hashCombiner.AddObject(settings2.Name);
hashCombiner.AddObject(settings2.Type);
}
}
protected override void ComputeHashCode(HashCodeCombiner hashCodeCombiner)
{
base.ComputeHashCode(hashCodeCombiner);
CompilationSection compilationConfig = MTConfigUtil.GetCompilationConfig(base.VirtualPath);
hashCodeCombiner.AddObject(compilationConfig.RecompilationHash);
PagesSection pagesConfig = MTConfigUtil.GetPagesConfig(base.VirtualPath);
hashCodeCombiner.AddObject(Util.GetRecompilationHash(pagesConfig));
}
public override void AddToHashCodeCombiner(HashCodeCombiner combiner)
{
base.AddToHashCodeCombiner(combiner);
combiner.AddFingerprint(_test);
combiner.AddFingerprint(_ifTrue);
combiner.AddFingerprint(_ifFalse);
}
internal override void AddToHashCodeCombiner(HashCodeCombiner combiner) {
base.AddToHashCodeCombiner(combiner);
combiner.AddInt32(IsLiftedToNull.GetHashCode());
combiner.AddFingerprint(Left);
combiner.AddObject(Method);
combiner.AddFingerprint(Right);
}
public override int GetHashCode()
{
HashCodeCombiner combiner = new HashCodeCombiner();
combiner.AddObject(this._varyByCustom);
combiner.AddArray(this._varyByParams);
combiner.AddArray(this._varyByControls);
return combiner.CombinedHash32;
}
internal override string ComputeSourceDependenciesHashCode(VirtualPath virtualPath)
{
if (virtualPath == null)
{
virtualPath = base.VirtualPath;
}
HashCodeCombiner combiner = new HashCodeCombiner();
combiner.AddResourcesDirectory(virtualPath.MapPathInternal());
return combiner.CombinedHashString;
}
public override int GetHashCode()
{
HashCodeCombiner combiner = new HashCodeCombiner();
combiner.AddObject(this._varyByAllParams);
combiner.AddObject(this._varyByCustom);
combiner.AddArray(this._contentEncodings);
combiner.AddArray(this._headers);
combiner.AddArray(this._params);
return combiner.CombinedHash32;
}
private string ComputeNonVaryCacheKey(HashCodeCombiner combinedHashCode)
{
combinedHashCode.AddObject(this._guid);
HttpBrowserCapabilities browser = this.Context.Request.Browser;
if (browser != null)
{
combinedHashCode.AddObject(browser.TagWriter);
}
return ("l" + combinedHashCode.CombinedHashString);
}
int IEqualityComparer.GetHashCode(object obj)
{
byte[] buffer = (byte[]) obj;
HashCodeCombiner combiner = new HashCodeCombiner();
foreach (byte num in buffer)
{
combiner.AddObject(num);
}
return combiner.CombinedHash32;
}
public override int GetHashCode()
{
HashCodeCombiner combiner = new HashCodeCombiner();
foreach (DictionaryEntry entry in this._bag)
{
combiner.AddObject(entry.Key);
combiner.AddObject(entry.Value);
}
return combiner.CombinedHash32;
}
/// <summary>
/// Create a unique hash code for the given set of items
/// </summary>
internal static int GetHashCode(params object[] objects)
{
HashCodeCombiner combiner = new HashCodeCombiner();
foreach (object obj in objects)
{
combiner.AddObject(obj);
}
return combiner.CombinedHash;
}
/// <summary>
/// Create a unique hash code for the given set of items
/// </summary>
public static int GetHashCode(params object[] objects)
{
var combiner = new HashCodeCombiner();
foreach (var obj in objects)
{
combiner.AddObject(obj);
}
return combiner.CombinedHash;
}
public override string GetFileHash(string virtualPath, IEnumerable virtualPathDependencies) {
HashCodeCombiner hashCodeCombiner = new HashCodeCombiner();
// Calculate the hash based on the time stamps of all the virtual paths
foreach (string virtualDependency in virtualPathDependencies) {
string physicalDependency = HostingEnvironment.MapPathInternal(virtualDependency);
hashCodeCombiner.AddFile(physicalDependency);
}
return hashCodeCombiner.CombinedHashString;
}
protected override void ComputeHashCode(HashCodeCombiner hashCodeCombiner)
{
base.ComputeHashCode(hashCodeCombiner);
if (base.VirtualPath != null)
{
Assembly localResourcesAssembly = BuildManager.GetLocalResourcesAssembly(base.VirtualPath.Parent);
if (localResourcesAssembly != null)
{
hashCodeCombiner.AddFile(localResourcesAssembly.Location);
}
}
}
public void GivenTheSameInputs_ItProducesTheSameOutput()
{
var hashCode1 = new HashCodeCombiner();
var hashCode2 = new HashCodeCombiner();
hashCode1.Add(42);
hashCode1.Add("foo");
hashCode2.Add(42);
hashCode2.Add("foo");
Assert.Equal(hashCode1.CombinedHash, hashCode2.CombinedHash);
}
int IEqualityComparer.GetHashCode(object obj) {
if (obj == null) {
return 0;
}
HashCodeCombiner combiner = new HashCodeCombiner();
foreach (object item in (IList)obj) {
combiner.AddObject(item);
}
return combiner.CombinedHash32;
}
private long CalculateHash()
{
HashCodeCombiner hashCombiner = new HashCodeCombiner();
this.CalculateProfilePropertySettingsHash(this.PropertySettings, hashCombiner);
if (this.PropertySettings != null)
{
foreach (ProfileGroupSettings settings in this.PropertySettings.GroupSettings)
{
hashCombiner.AddObject(settings.Name);
this.CalculateProfilePropertySettingsHash(settings.PropertySettings, hashCombiner);
}
}
return hashCombiner.CombinedHash;
}
/// <summary>
/// Hash code of the id and version
/// </summary>
public int GetHashCode(PackageIdentity obj)
{
if (ReferenceEquals(obj, null))
{
return 0;
}
var combiner = new HashCodeCombiner();
combiner.AddObject(obj.Id.ToUpperInvariant());
combiner.AddObject(_versionComparer.GetHashCode(obj.Version));
return combiner.CombinedHash;
}
public void HashCombiner_Test_Int()
{
var combiner1 = new HashCodeCombiner();
combiner1.AddInt(1234);
var combiner2 = new HashCodeCombiner();
combiner2.AddInt(1234);
Assert.AreEqual(combiner1.GetCombinedHashCode(), combiner2.GetCombinedHashCode());
combiner2.AddInt(1);
Assert.AreNotEqual(combiner1.GetCombinedHashCode(), combiner2.GetCombinedHashCode());
}
public void HashCombiner_Test_String()
{
var combiner1 = new HashCodeCombiner();
combiner1.AddCaseInsensitiveString("Hello");
var combiner2 = new HashCodeCombiner();
combiner2.AddCaseInsensitiveString("hello");
Assert.AreEqual(combiner1.GetCombinedHashCode(), combiner2.GetCombinedHashCode());
combiner2.AddCaseInsensitiveString("world");
Assert.AreNotEqual(combiner1.GetCombinedHashCode(), combiner2.GetCombinedHashCode());
}
public void HashCombiner_Test_DateTime()
{
var dt = DateTime.Now;
var combiner1 = new HashCodeCombiner();
combiner1.AddDateTime(dt);
var combiner2 = new HashCodeCombiner();
combiner2.AddDateTime(dt);
Assert.AreEqual(combiner1.GetCombinedHashCode(), combiner2.GetCombinedHashCode());
combiner2.AddDateTime(DateTime.Now);
Assert.AreNotEqual(combiner1.GetCombinedHashCode(), combiner2.GetCombinedHashCode());
}
public void HashCombiner_Test_Bool()
{
var combiner1 = new HashCodeCombiner();
combiner1.AddBool(true);
var combiner2 = new HashCodeCombiner();
combiner2.AddBool(true);
var combiner3 = new HashCodeCombiner();
combiner3.AddBool(false);
Assert.AreEqual(combiner1.GetCombinedHashCode(), combiner2.GetCombinedHashCode());
Assert.AreNotEqual(combiner2.GetCombinedHashCode(), combiner3.GetCombinedHashCode());
combiner2.AddBool(true);
Assert.AreNotEqual(combiner1.GetCombinedHashCode(), combiner2.GetCombinedHashCode());
}
public void HashCombiner_Test_Type()
{
var combiner1 = new HashCodeCombiner();
combiner1.AddType(typeof(HashCodeCombiner));
var combiner2 = new HashCodeCombiner();
combiner2.AddType(typeof(HashCodeCombiner));
var combiner3 = new HashCodeCombiner();
combiner3.AddType(typeof(HashCodeCombinerTests));
Assert.AreEqual(combiner1.GetCombinedHashCode(), combiner2.GetCombinedHashCode());
Assert.AreNotEqual(combiner2.GetCombinedHashCode(), combiner3.GetCombinedHashCode());
combiner2.AddType(typeof(HashCodeCombiner));
Assert.AreNotEqual(combiner1.GetCombinedHashCode(), combiner2.GetCombinedHashCode());
}
internal virtual void AddToHashCodeCombiner(HashCodeCombiner combiner)
{
combiner.AddInt32((int)NodeType);
combiner.AddObject(Type);
}
public override int GetHashCode()
{
return(HashCodeCombiner.GetHashCode(Parent, Range, Child));
}
public override int GetHashCode() => HashCodeCombiner.Combine <object>(Text, Key, DeepNestedField, DeepNestedProperty);
public override int GetHashCode() => HashCodeCombiner.Combine(Field, Property, ChildField, ChildProperty);
public virtual void AnonymizeData <TEntity>(TEntity entity, Expression <Func <TEntity, object> > expression, IdentifierDataType type, Language language = null)
where TEntity : BaseEntity
{
Guard.NotNull(entity, nameof(entity));
Guard.NotNull(expression, nameof(expression));
var originalValue = expression.Compile().Invoke(entity);
object maskedValue = null;
if (originalValue is DateTime d)
{
maskedValue = MinDate;
}
else if (originalValue is string s)
{
if (s.IsEmpty())
{
return;
}
language = language ?? (entity as Customer)?.GetLanguage();
switch (type)
{
case IdentifierDataType.Address:
case IdentifierDataType.Name:
case IdentifierDataType.Text:
maskedValue = T("Gdpr.DeletedText", language.Id).Text;
break;
case IdentifierDataType.LongText:
maskedValue = T("Gdpr.DeletedLongText", language.Id).Text;
break;
case IdentifierDataType.EmailAddress:
//maskedValue = s.Hash(Encoding.ASCII, true) + "@anony.mous";
maskedValue = HashCodeCombiner.Start()
.Add(entity.GetHashCode())
.Add(s)
.CombinedHashString + "@anony.mous";
break;
case IdentifierDataType.Url:
maskedValue = "https://anony.mous";
break;
case IdentifierDataType.IpAddress:
maskedValue = AnonymizeIpAddress(s);
break;
case IdentifierDataType.UserName:
maskedValue = T("Gdpr.Anonymous", language.Id).Text.ToLower();
break;
case IdentifierDataType.PhoneNumber:
maskedValue = "555-00000";
break;
case IdentifierDataType.PostalCode:
maskedValue = "00000";
break;
case IdentifierDataType.DateTime:
maskedValue = MinDate.ToString(CultureInfo.InvariantCulture);
break;
}
}
if (maskedValue != null)
{
var pi = expression.ExtractPropertyInfo();
pi.SetValue(entity, maskedValue);
}
}
internal override void AddToHashCodeCombiner(HashCodeCombiner combiner)
{
combiner.AddObject(Method);
base.AddToHashCodeCombiner(combiner);
}
public override int GetHashCode()
{
var code = HashCodeCombiner.Combine(Name, Type);
return(HashCodeCombiner.CombineCodes(code, CanWrite.GetHashCode()));
}
public void Add(int value)
{
this.currentHash = HashCodeCombiner.Combine(this.currentHash, value);
}
public override int GetHashCode()
{
return(HashCodeCombiner.GetHashCode(LibraryRange, Framework));
}
public override int GetHashCode()
{
return(HashCodeCombiner.Combine(flags.GetHashCode(), data.GetHashCode()));
}
internal override void AddToHashCodeCombiner(HashCodeCombiner combiner)
{
combiner.AddInt32(ParameterIndex);
base.AddToHashCodeCombiner(combiner);
}
public override int GetHashCode()
{
return(HashCodeCombiner.Combine(Alternatives.Select(p => p.GetHashCode()).ToArray()));
}
internal override void AddToHashCodeCombiner(HashCodeCombiner combiner)
{
combiner.AddObject(TypeOperand);
base.AddToHashCodeCombiner(combiner);
}
public override int GetHashCode()
{
return(HashCodeCombiner.CombineHashCodes(this.type.GetHashCode(), [email protected]()));
}
public override int GetHashCode() => HashCodeCombiner.Combine(Property, NullableProperty);
internal static Assembly GetCodeDirectoryAssembly(VirtualPath virtualDir, CodeDirectoryType dirType, string assemblyName, StringSet excludedSubdirectories, bool isDirectoryAllowed)
{
string path = virtualDir.MapPath();
if (!isDirectoryAllowed && Directory.Exists(path))
{
throw new HttpException(System.Web.SR.GetString("Bar_dir_in_precompiled_app", new object[] { virtualDir }));
}
bool supportLocalization = IsResourceCodeDirectoryType(dirType);
string cacheKey = assemblyName;
BuildResult buildResultFromCache = BuildManager.GetBuildResultFromCache(cacheKey);
Assembly a = null;
if ((buildResultFromCache != null) && (buildResultFromCache is BuildResultCompiledAssembly))
{
if (buildResultFromCache is BuildResultMainCodeAssembly)
{
_mainCodeBuildResult = (BuildResultMainCodeAssembly)buildResultFromCache;
}
a = ((BuildResultCompiledAssembly)buildResultFromCache).ResultAssembly;
if (!supportLocalization)
{
return(a);
}
if (!isDirectoryAllowed)
{
return(a);
}
BuildResultResourceAssembly assembly2 = (BuildResultResourceAssembly)buildResultFromCache;
if (HashCodeCombiner.GetDirectoryHash(virtualDir) == assembly2.ResourcesDependenciesHash)
{
return(a);
}
}
if (!isDirectoryAllowed)
{
return(null);
}
if ((dirType != CodeDirectoryType.LocalResources) && !StringUtil.StringStartsWithIgnoreCase(path, HttpRuntime.AppDomainAppPathInternal))
{
throw new HttpException(System.Web.SR.GetString("Virtual_codedir", new object[] { virtualDir.VirtualPathString }));
}
if (!Directory.Exists(path))
{
if (dirType != CodeDirectoryType.MainCode)
{
return(null);
}
if (!ProfileBuildProvider.HasCompilableProfile)
{
return(null);
}
}
BuildManager.ReportDirectoryCompilationProgress(virtualDir);
DateTime utcNow = DateTime.UtcNow;
CodeDirectoryCompiler compiler = new CodeDirectoryCompiler(virtualDir, dirType, excludedSubdirectories);
string outputAssemblyName = null;
if (a != null)
{
outputAssemblyName = a.GetName().Name;
compiler._onlyBuildLocalizedResources = true;
}
else
{
outputAssemblyName = BuildManager.GenerateRandomAssemblyName(assemblyName);
}
BuildProvidersCompiler compiler2 = new BuildProvidersCompiler(virtualDir, supportLocalization, outputAssemblyName);
compiler._bpc = compiler2;
compiler.FindBuildProviders();
compiler2.SetBuildProviders(compiler._buildProviders);
CompilerResults results = compiler2.PerformBuild();
if (results != null)
{
DateTime time2 = DateTime.UtcNow.AddMilliseconds(3000.0);
do
{
if (UnsafeNativeMethods.GetModuleHandle(results.PathToAssembly) == IntPtr.Zero)
{
a = results.CompiledAssembly;
goto Label_01E6;
}
Thread.Sleep(250);
}while (DateTime.UtcNow <= time2);
throw new HttpException(System.Web.SR.GetString("Assembly_already_loaded", new object[] { results.PathToAssembly }));
}
Label_01E6:
if (a == null)
{
return(null);
}
if (dirType == CodeDirectoryType.MainCode)
{
_mainCodeBuildResult = new BuildResultMainCodeAssembly(a);
buildResultFromCache = _mainCodeBuildResult;
}
else if (supportLocalization)
{
buildResultFromCache = new BuildResultResourceAssembly(a);
}
else
{
buildResultFromCache = new BuildResultCompiledAssembly(a);
}
buildResultFromCache.VirtualPath = virtualDir;
if (BuildManager.OptimizeCompilations && (dirType != CodeDirectoryType.LocalResources))
{
buildResultFromCache.AddVirtualPathDependencies(new SingleObjectCollection(virtualDir.AppRelativeVirtualPathString));
}
if (dirType != CodeDirectoryType.LocalResources)
{
buildResultFromCache.CacheToMemory = false;
}
BuildManager.CacheBuildResult(cacheKey, buildResultFromCache, utcNow);
return(a);
}
/// <internalonly/>
public override int GetHashCode()
{
return(HashCodeCombiner.CombineHashCodes(_isPersonalizable.GetHashCode(), _scope.GetHashCode(),
_isSensitive.GetHashCode()));
}
public override int GetHashCode()
{
return(HashCodeCombiner.Combine(IsPositive.GetHashCode(), CharSet.GetHashCode(),
HashCodeCombiner.Combine(ChildPatterns.Select(p => p.GetHashCode()).ToArray())));
}
public override int GetHashCode()
{
return(HashCodeCombiner.Combine(From.GetHashCode(), To.GetHashCode()));
}
public HashMethodKey(Type type, string methodName, IEnumerable <Type> parameterTypes)
{
_hash = HashCodeCombiner.Start().Add(type).Add(methodName).Add(parameterTypes).CombinedHash;
}
public override int GetHashCode()
{
return(HashCodeCombiner.GetHashCode(TargetFramework, Packages));
}
public override int GetHashCode()
{
return(HashCodeCombiner.Combine(Item1.GetHashCode(), Item2.GetHashCode()));
}
public override int GetHashCode()
{
return(HashCodeCombiner.Start()
.Add(Prefix)
.CombinedHash);
}
public override int GetHashCode()
{
return(HashCodeCombiner.Combine(Captures.Select(c => c.GetHashCode()).ToArray()));
}
public override int GetHashCode()
{
return(HashCodeCombiner.Start()
.Add(base.GetHashCode())
.CombinedHash);
}
public static int Combine(int code1, int code2, int code3, int code4)
{
return(HashCodeCombiner.Combine(HashCodeCombiner.Combine(code1, code2), HashCodeCombiner.Combine(code3, code4)));
}
public override int GetHashCode()
{
return(HashCodeCombiner.GetHashCode(PluginFilePath, PackageSourceRepository));
}
/// <inheritdoc />
public int GetHashCode(TagHelperDescriptor descriptor)
{
if (descriptor == null)
{
throw new ArgumentNullException(nameof(descriptor));
}
var hash = HashCodeCombiner.Start();
hash.Add(descriptor.Kind, StringComparer.Ordinal);
hash.Add(descriptor.AssemblyName, StringComparer.Ordinal);
hash.Add(descriptor.Name, StringComparer.Ordinal);
hash.Add(descriptor.DisplayName, StringComparer.Ordinal);
hash.Add(descriptor.CaseSensitive ? 1 : 0);
if (descriptor.BoundAttributes != null)
{
for (var i = 0; i < descriptor.BoundAttributes.Count; i++)
{
hash.Add(descriptor.BoundAttributes[i]);
}
}
if (descriptor.TagMatchingRules != null)
{
for (var i = 0; i < descriptor.TagMatchingRules.Count; i++)
{
hash.Add(descriptor.TagMatchingRules[i]);
}
}
if (descriptor.AllowedChildTags != null)
{
for (var i = 0; i < descriptor.AllowedChildTags.Count; i++)
{
hash.Add(descriptor.AllowedChildTags[i]);
}
}
if (descriptor.Diagnostics != null)
{
for (var i = 0; i < descriptor.Diagnostics.Count; i++)
{
hash.Add(descriptor.Diagnostics[i]);
}
}
if (descriptor.Metadata != null)
{
// � Avoid enumerator allocations for Dictionary<TKey, TValue>
if (descriptor.Metadata is Dictionary <string, string> metadata)
{
foreach (var kvp in metadata)
{
hash.Add(kvp.Key, StringComparer.Ordinal);
hash.Add(kvp.Value, StringComparer.Ordinal);
}
}
else
{
foreach (var kvp in descriptor.Metadata)
{
hash.Add(kvp.Key, StringComparer.Ordinal);
hash.Add(kvp.Value, StringComparer.Ordinal);
}
}
}
return(hash.CombinedHash);
}
public override int GetHashCode()
{
return(HashCodeCombiner.CombineHashCodes(base.GetHashCode(), GroupSettings.GetHashCode()));
}
internal static long GetRecompilationHash(CompilationSection ps)
{
HashCodeCombiner recompilationHash = new HashCodeCombiner();
AssemblyCollection assemblies;
BuildProviderCollection builders;
FolderLevelBuildProviderCollection buildProviders;
CodeSubDirectoriesCollection codeSubDirs;
// Combine items from Compilation section
recompilationHash.AddObject(ps.Debug);
recompilationHash.AddObject(ps.TargetFramework);
recompilationHash.AddObject(ps.Strict);
recompilationHash.AddObject(ps.Explicit);
recompilationHash.AddObject(ps.Batch);
recompilationHash.AddObject(ps.OptimizeCompilations);
recompilationHash.AddObject(ps.BatchTimeout);
recompilationHash.AddObject(ps.MaxBatchGeneratedFileSize);
recompilationHash.AddObject(ps.MaxBatchSize);
recompilationHash.AddObject(ps.NumRecompilesBeforeAppRestart);
recompilationHash.AddObject(ps.DefaultLanguage);
recompilationHash.AddObject(ps.UrlLinePragmas);
recompilationHash.AddObject(ps.DisableObsoleteWarnings);
if (ps.AssemblyPostProcessorTypeInternal != null)
{
recompilationHash.AddObject(ps.AssemblyPostProcessorTypeInternal.FullName);
}
if (!String.IsNullOrWhiteSpace(ps.ControlBuilderInterceptorType))
{
recompilationHash.AddObject(ps.ControlBuilderInterceptorType);
}
// Combine items from Compilers collection
foreach (Compiler compiler in ps.Compilers)
{
recompilationHash.AddObject(compiler.Language);
recompilationHash.AddObject(compiler.Extension);
recompilationHash.AddObject(compiler.Type);
recompilationHash.AddObject(compiler.WarningLevel);
recompilationHash.AddObject(compiler.CompilerOptions);
}
// Combine items from <expressionBuilders> section
foreach (System.Web.Configuration.ExpressionBuilder eb in ps.ExpressionBuilders)
{
recompilationHash.AddObject(eb.ExpressionPrefix);
recompilationHash.AddObject(eb.Type);
}
// Combine items from the Assembly collection
assemblies = ps.Assemblies;
if (assemblies.Count == 0)
{
recompilationHash.AddObject("__clearassemblies");
}
else
{
foreach (AssemblyInfo ai in assemblies)
{
recompilationHash.AddObject(ai.Assembly);
}
}
// Combine items from the Builders Collection
builders = ps.BuildProviders;
if (builders.Count == 0)
{
recompilationHash.AddObject("__clearbuildproviders");
}
else
{
foreach (System.Web.Configuration.BuildProvider bp in builders)
{
recompilationHash.AddObject(bp.Type);
recompilationHash.AddObject(bp.Extension);
}
}
// Combine items from the FolderLevelBuildProviderCollection
buildProviders = ps.FolderLevelBuildProviders;
if (buildProviders.Count == 0)
{
recompilationHash.AddObject("__clearfolderlevelbuildproviders");
}
else
{
foreach (System.Web.Configuration.FolderLevelBuildProvider bp in buildProviders)
{
recompilationHash.AddObject(bp.Type);
recompilationHash.AddObject(bp.Name);
}
}
codeSubDirs = ps.CodeSubDirectories;
if (codeSubDirs.Count == 0)
{
recompilationHash.AddObject("__clearcodesubdirs");
}
else
{
foreach (CodeSubDirectory csd in codeSubDirs)
{
recompilationHash.AddObject(csd.DirectoryName);
}
}
// Make sure the <system.CodeDom> section is hashed properly.
CompilerInfo[] compilerInfoArray = CodeDomProvider.GetAllCompilerInfo();
if (compilerInfoArray != null)
{
CompilerInfo cppCodeProvider = CodeDomProvider.GetCompilerInfo("cpp");
foreach (CompilerInfo info in compilerInfoArray)
{
// Skip cpp code provider (Dev11 193323).
if (info == cppCodeProvider)
{
continue;
}
// Ignore it if the type is not valid.
if (!info.IsCodeDomProviderTypeValid)
{
continue;
}
CompilerParameters parameters = info.CreateDefaultCompilerParameters();
string option = parameters.CompilerOptions;
if (!String.IsNullOrEmpty(option))
{
Type type = info.CodeDomProviderType;
if (type != null)
{
recompilationHash.AddObject(type.FullName);
}
// compilerOptions need to be hashed.
recompilationHash.AddObject(option);
}
// DevDiv 62998
// The tag providerOption needs to be added to the hash,
// as the user could switch between v2 and v3.5.
if (info.CodeDomProviderType == null)
{
continue;
}
// Add a hash for each providerOption added, specific for each codeDomProvider, so that
// if some codedom setting has changed, we know we have to recompile.
IDictionary <string, string> providerOptions = GetProviderOptions(info);
if (providerOptions != null && providerOptions.Count > 0)
{
string codeDomProviderType = info.CodeDomProviderType.FullName;
foreach (string key in providerOptions.Keys)
{
string value = providerOptions[key];
recompilationHash.AddObject(codeDomProviderType + ":" + key + "=" + value);
}
}
}
}
return(recompilationHash.CombinedHash);
}
