private static bool ValidateInternalRecursive(LicenseContext context, Type type, object instance, bool allowExceptions, out License license, out string licenseKey)
{
LicenseProvider cachedProvider = GetCachedProvider(type);
if ((cachedProvider == null) && !GetCachedNoLicenseProvider(type))
{
LicenseProviderAttribute attribute = (LicenseProviderAttribute)Attribute.GetCustomAttribute(type, typeof(LicenseProviderAttribute), false);
if (attribute != null)
{
Type licenseProvider = attribute.LicenseProvider;
cachedProvider = GetCachedProviderInstance(licenseProvider);
if (cachedProvider == null)
{
cachedProvider = (LicenseProvider)SecurityUtils.SecureCreateInstance(licenseProvider);
}
}
CacheProvider(type, cachedProvider);
}
license = null;
bool flag = true;
licenseKey = null;
if (cachedProvider != null)
{
license = cachedProvider.GetLicense(context, type, instance, allowExceptions);
if (license == null)
{
flag = false;
}
else
{
licenseKey = license.LicenseKey;
}
}
if (flag && (instance == null))
{
string str;
Type baseType = type.BaseType;
if (!(baseType != typeof(object)) || (baseType == null))
{
return(flag);
}
if (license != null)
{
license.Dispose();
license = null;
}
flag = ValidateInternalRecursive(context, baseType, null, allowExceptions, out license, out str);
if (license != null)
{
license.Dispose();
license = null;
}
}
return(flag);
}
//============================================================
// Methods
//============================================================
///
/// <summary>
/// Enables a server control to perform final clean up before it is released from
/// memory.
/// </summary>
/// <remarks>
/// The Dispose method leaves the Control in an unusable state. After calling this
/// method, you must release all references to the control so the memory it was
/// occupying can be reclaimed by garbage collection.
/// </remarks>
/// <param name="disposing"><b>true</b> to release both managed and unmanaged resources; <b>false</b> to release only unmanaged resources.</param>
///
protected virtual void Dispose (bool disposing)
{
if ((disposing) && (_license != null))
{
_license.Dispose ();
_license = null;
}
return;
}
/// <summary>
/// Releases the resources used by the <see cref="ObjectManager">ObjectManager</see>.
/// </summary>
/// <param name="disposing"></param>
protected override void Dispose(bool disposing)
{
if (disposing)
{
if (license != null)
{
license.Dispose();
license = null;
}
}
}
/// <summary>Determines whether a license can be granted for the specified type.</summary>
/// <param name="type">A <see cref="T:System.Type" /> that represents the type of object that requests the license. </param>
/// <exception cref="T:System.ComponentModel.LicenseException">A <see cref="T:System.ComponentModel.License" /> cannot be granted. </exception>
public static void Validate(Type type)
{
License license = null;
if (!LicenseManager.privateGetLicense(type, null, true, out license))
{
throw new LicenseException(type, null);
}
if (license != null)
{
license.Dispose();
}
}
/// <summary>Determines whether a valid license can be granted for the specified type.</summary>
/// <returns>true if a valid license can be granted; otherwise, false.</returns>
/// <param name="type">A <see cref="T:System.Type" /> that represents the type of object that requests the <see cref="T:System.ComponentModel.License" />. </param>
public static bool IsValid(Type type)
{
License license = null;
if (!LicenseManager.privateGetLicense(type, null, false, out license))
{
return(false);
}
if (license != null)
{
license.Dispose();
}
return(true);
}
// Determine if a valid license can be granted for a type.
public static bool IsValid(Type type)
{
License license = PerformValidation(type, null);
if (license != null)
{
license.Dispose();
return(true);
}
else
{
return(false);
}
}
///
/// <summary>
/// Enables a server control to perform final clean up before it is released from
/// memory.
/// </summary>
/// <remarks>
/// The Dispose method leaves the Control in an unusable state. After calling this
/// method, you must release all references to the control so the memory it was
/// occupying can be reclaimed by garbage collection.
/// </remarks>
/// <param name="disposing"><b>true</b> to release both managed and unmanaged resources; <b>false</b> to release only unmanaged resources.</param>
///
protected override void Dispose(bool disposing)
{
try
{
if ((disposing) && (_license != null))
{
_license.Dispose();
_license = null;
}
}
finally
{
base.Dispose(disposing);
}
return;
}
///
/// <summary>
/// Enables a server control to perform final clean up before it is released from
/// memory.
/// </summary>
/// <remarks>
/// The Dispose method leaves the Control in an unusable state. After calling this
/// method, you must release all references to the control so the memory it was
/// occupying can be reclaimed by garbage collection.
/// </remarks>
/// <param name="disposing"><b>true</b> to release both managed and unmanaged resources; <b>false</b> to release only unmanaged resources.</param>
///
protected virtual void Dispose(bool disposing)
{
if (disposing)
{
if (_license != null)
{
_license.Dispose();
_license = null;
}
if (_realField != null)
{
_realField.Dispose();
_realField = null;
}
}
return;
}
/// <include file='doc\LicenseManager.uex' path='docs/doc[@for="LicenseManager.ValidateInternalRecursive"]/*' />
/// <devdoc>
/// Since we want to walk up the entire inheritance change, when not
/// give an instance, we need another helper method to walk up
/// the chain...
/// </devdoc>
private static bool ValidateInternalRecursive(LicenseContext context, Type type, object instance, bool allowExceptions, out License license, out string licenseKey) {
LicenseProvider provider = GetCachedProvider(type);
if (provider == null && !GetCachedNoLicenseProvider(type)) {
// NOTE : Must look directly at the class, we want no inheritance.
//
LicenseProviderAttribute attr = (LicenseProviderAttribute)Attribute.GetCustomAttribute(type, typeof(LicenseProviderAttribute), false);
if (attr != null) {
Type providerType = attr.LicenseProvider;
provider = GetCachedProviderInstance(providerType);
if (provider == null) {
provider = (LicenseProvider)SecurityUtils.SecureCreateInstance(providerType);
}
}
CacheProvider(type, provider);
}
license = null;
bool isValid = true;
licenseKey = null;
if (provider != null) {
license = provider.GetLicense(context, type, instance, allowExceptions);
if (license == null) {
isValid = false;
}
else {
// For the case where a COM client is calling "RequestLicKey",
// we try to squirrel away the first found license key
//
licenseKey = license.LicenseKey;
}
}
// When looking only at a type, we need to recurse up the inheritence
// chain, however, we can't give out the license, since this may be
// from more than one provider.
//
if (isValid && instance == null) {
Type baseType = type.BaseType;
if (baseType != typeof(object) && baseType != null) {
if (license != null) {
license.Dispose();
license = null;
}
string temp;
isValid = ValidateInternalRecursive(context, baseType, null, allowExceptions, out license, out temp);
if (license != null) {
license.Dispose();
license = null;
}
}
}
return isValid;
}
/// <include file='doc\LicenseManager.uex' path='docs/doc[@for="LicenseManager.ValidateInternalRecursive"]/*' />
/// <devdoc>
/// Since we want to walk up the entire inheritance change, when not
/// give an instance, we need another helper method to walk up
/// the chain...
/// </devdoc>
private static bool ValidateInternalRecursive(LicenseContext context, Type type, object instance, bool allowExceptions, out License license, out string licenseKey)
{
LicenseProvider provider = GetCachedProvider(type);
if (provider == null && !GetCachedNoLicenseProvider(type))
{
// NOTE : Must look directly at the class, we want no inheritance.
//
LicenseProviderAttribute attr = (LicenseProviderAttribute)Attribute.GetCustomAttribute(type, typeof(LicenseProviderAttribute), false);
if (attr != null)
{
Type providerType = attr.LicenseProvider;
provider = GetCachedProviderInstance(providerType);
if (provider == null)
{
provider = (LicenseProvider)SecurityUtils.SecureCreateInstance(providerType);
}
}
CacheProvider(type, provider);
}
license = null;
bool isValid = true;
licenseKey = null;
if (provider != null)
{
license = provider.GetLicense(context, type, instance, allowExceptions);
if (license == null)
{
isValid = false;
}
else
{
// For the case where a COM client is calling "RequestLicKey",
// we try to squirrel away the first found license key
//
licenseKey = license.LicenseKey;
}
}
// When looking only at a type, we need to recurse up the inheritence
// chain, however, we can't give out the license, since this may be
// from more than one provider.
//
if (isValid && instance == null)
{
Type baseType = type.BaseType;
if (baseType != typeof(object) && baseType != null)
{
if (license != null)
{
license.Dispose();
license = null;
}
string temp;
isValid = ValidateInternalRecursive(context, baseType, null, allowExceptions, out license, out temp);
if (license != null)
{
license.Dispose();
license = null;
}
}
}
return(isValid);
}
///
/// <summary>
/// Enables a server control to perform final clean up before it is released from
/// memory.
/// </summary>
/// <remarks>
/// The Dispose method leaves the Control in an unusable state. After calling this
/// method, you must release all references to the control so the memory it was
/// occupying can be reclaimed by garbage collection.
/// </remarks>
/// <param name="disposing"><b>true</b> to release both managed and unmanaged resources; <b>false</b> to release only unmanaged resources.</param>
///
protected virtual void Dispose(bool disposing)
{
if (disposing)
{
if (_license != null)
{
_license.Dispose();
_license = null;
}
if (_titleRow != null)
{
_titleRow.Dispose();
_titleRow = null;
}
if (_titleCell != null)
{
_titleCell.Dispose();
_titleCell = null;
}
if (_bodyRow != null)
{
_bodyRow.Dispose();
_bodyRow = null;
}
if (_bodyCell != null)
{
_bodyCell.Dispose();
_bodyCell = null;
}
if (_titleLinkButton != null)
{
_titleLinkButton.Dispose();
_titleLinkButton = null;
}
if (_titleStyle != null)
{
_titleStyle.Dispose();
_titleStyle = null;
}
if (_bodyStyle != null)
{
_bodyStyle.Dispose();
_bodyStyle = null;
}
if (_titleHyperLink != null)
{
_titleHyperLink.Dispose();
_titleHyperLink = null;
}
if (_hiddenState != null)
{
_hiddenState.Dispose();
_hiddenState = null;
}
}
return;
}
private static bool ValidateInternalRecursive(LicenseContext context, Type type, object instance, bool allowExceptions, out License license, out string licenseKey)
{
LicenseProvider cachedProvider = GetCachedProvider(type);
if ((cachedProvider == null) && !GetCachedNoLicenseProvider(type))
{
LicenseProviderAttribute attribute = (LicenseProviderAttribute) Attribute.GetCustomAttribute(type, typeof(LicenseProviderAttribute), false);
if (attribute != null)
{
Type licenseProvider = attribute.LicenseProvider;
cachedProvider = GetCachedProviderInstance(licenseProvider);
if (cachedProvider == null)
{
cachedProvider = (LicenseProvider) SecurityUtils.SecureCreateInstance(licenseProvider);
}
}
CacheProvider(type, cachedProvider);
}
license = null;
bool flag = true;
licenseKey = null;
if (cachedProvider != null)
{
license = cachedProvider.GetLicense(context, type, instance, allowExceptions);
if (license == null)
{
flag = false;
}
else
{
licenseKey = license.LicenseKey;
}
}
if (flag && (instance == null))
{
string str;
Type baseType = type.BaseType;
if (!(baseType != typeof(object)) || (baseType == null))
{
return flag;
}
if (license != null)
{
license.Dispose();
license = null;
}
flag = ValidateInternalRecursive(context, baseType, null, allowExceptions, out license, out str);
if (license != null)
{
license.Dispose();
license = null;
}
}
return flag;
}
