首先要引入程序集 using IntelliLock.Licensing;

1. 檢查授權(quán)是否有效

    /*** Check if a valid license file is available. ***/
    public bool IsValidLicenseAvailable()
    {
        return (EvaluationMonitor.CurrentLicense.LicenseStatus == IntelliLock.Licensing.LicenseStatus.Licensed);
    }

    /*** Read additonal license information from a license file ***/
    public void ReadAdditonalLicenseInformation()
    {
        /* Check first if a valid license file is found */
        if (EvaluationMonitor.CurrentLicense.LicenseStatus == IntelliLock.Licensing.LicenseStatus.Licensed)
        {
            /* Read additional license information */
            for (int i = 0; i < EvaluationMonitor.CurrentLicense.LicenseInformation.Count; i++)
            {
                string key = EvaluationMonitor.CurrentLicense.LicenseInformation.GetKey(i).ToString();
                string value = EvaluationMonitor.CurrentLicense.LicenseInformation.GetByIndex(i).ToString();
            }
        }
    }

/*** Check the license status of the Expiration Days Lock ***/
    public void CheckExpirationDaysLock()
    {
        bool lock_enabled = EvaluationMonitor.CurrentLicense.ExpirationDays_Enabled;
        int days = EvaluationMonitor.CurrentLicense.ExpirationDays;
        int days_current = EvaluationMonitor.CurrentLicense.ExpirationDays_Current;
    }

    /*** Check the license status of the Expiration Date Lock ***/
    public void CheckExpirationDateLock()
    {
        bool lock_enabled = EvaluationMonitor.CurrentLicense.ExpirationDate_Enabled;
        System.DateTime expiration_date = EvaluationMonitor.CurrentLicense.ExpirationDate;
    }
 

   /*** Check the license status of the Executions Lock ***/
    public void CheckExecutionsLock()
    {
        bool lock_enabled = EvaluationMonitor.CurrentLicense.Executions_Enabled;
        int max_executions = EvaluationMonitor.CurrentLicense.Executions;
        int current_executions = EvaluationMonitor.CurrentLicense.Executions_Current;
    }

   /*** Check the license status of the Instances Lock ***/
    public void CheckNumberOfInstancesLock()
    {
        bool lock_enabled = EvaluationMonitor.CurrentLicense.Instances_Enabled;
        int max_instances = EvaluationMonitor.CurrentLicense.Instances;
    }

    /*** Check the license status of Hardware Lock ***/
    public void CheckHardwareLock()
    {
        bool lock_enabled = EvaluationMonitor.CurrentLicense.HardwareLock_Enabled;
 
        if (lock_enabled)
        {
            /* Get Hardware ID stored in the license file */
            string lic_hardware_id = EvaluationMonitor.CurrentLicense.HardwareID;
        }
    }

    /*** Get Hardware ID of the current machine ***/
    public string GetHardwareID()
    {
        return HardwareID.GetHardwareID(true, true, false, true, true, false);
    }

    /*** Compare current Hardware ID with Hardware ID stored in License File ***/
    public bool CompareHardwareID()
    {
        if (HardwareID.GetHardwareID(true, true, false, true, true, false) == EvaluationMonitor.CurrentLicense.HardwareID)
            return true;
        else
            return false;
    }

    /*** Invalidate the license. Please note, your protected software does not accept a license file anymore! ***/
    public void InvalidateLicense()
    {
        string confirmation_code = License_DeActivator.DeactivateLicense();
    }

 /*** Reactivate an invalidated license. ***/
    public bool ReactivateLicense(string reactivation_code)
    {
        return License_DeActivator.ReactivateLicense(reactivation_code);
    }

 /*** Load the license. ***/
    public void LoadLicense(string filename)
    {
        EvaluationMonitor.LoadLicense(filename);
    }

    /*** Load the license. ***/
    public void LoadLicense(byte[] license)
    {
        EvaluationMonitor.LoadLicense(license);
    }

 /*** Get the license. ***/
    public byte[] GetLicense()
    {
        return EvaluationMonitor.GetCurrentLicenseAsByteArray();   
    }

/*** Check the license. ***/
    class Program
    {
        // To automatically check the license asynchronously the option "Asynchronous License Check" must be enabled in IntelliLock
        static void Main(string[] args)
        {
            IntelliLock.Licensing.EvaluationMonitor.LicenseCheckFinished += () =>
            {
                Console.WriteLine(IntelliLock.Licensing.HardwareID.GetHardwareID(false, true, false, true, true, false));
                Console.WriteLine(IntelliLock.Licensing.CurrentLicense.LicenseStatus.ToString());
            };
 
            Console.ReadLine();
        }
    }

/*** Check the license. ***/
    class Program
    {
        // To automatically check the license asynchronously the option "Asynchronous License Check" must be enabled in IntelliLock
        static void Main(string[] args)
        {
            string licenseFile = @"C:\license.license";
           
           // To ensure SDK method calls doesn't block/delay the control flow the SDK method LoadLicense(...) should be run in asynchronous context (new Action()..) as well
            new Action(() =>
            {
                IntelliLock.Licensing.EvaluationMonitor.LoadLicense(File.ReadAllBytes(licenseFile));
                IntelliLock.Licensing.EvaluationMonitor.LicenseCheckFinished += () =>
                {
                    Console.WriteLine(IntelliLock.Licensing.HardwareID.GetHardwareID(false, true, false, true, true, false));
                    Console.WriteLine(IntelliLock.Licensing.CurrentLicense.LicenseStatus.ToString());
                };
            }).BeginInvoke(null, null);
 
            Console.WriteLine("Due to asynchronous control flow this line is displayed first");
            Console.ReadLine();       
    }