CODEWITHSUNDEEP
c#
John Hartley
John Hartley

Reputation: 483

Can I generate the compile date in my C# code to determine the expiry for a demo version?

I am creating a demonstration version of a C# program and I wish it to expire after a month.

        // DEMO - Check date
        DateTime expires = new DateTime(2016, 3, 16);
        expires.AddMonths(2);
        var diff = expires.Subtract(DateTime.Now);
        if (diff.Days < 0)
        {
            MessageBox.Show("Demonstration expired.");
            return;
        }

I am wanting to have the date the compile instead of the hard coded new DateTime(2016, 3, 16); Is there a compiler directive to give me the current date? Or am I aproaching this the wrong way?

Upvotes: 1

Views: 301

Answers (2)

Kory Gill
Kory Gill

Reputation: 7163

An alternative solution to hard-coding a date that also offers some flexibility and extensibility could be to host a license file on a web server. For my sample, I used github. Create a well-known file for the application (possibly one for demo and a new one for beta1, etc.). At startup, and possibly periodically, read the file and parse it to determine applicability, timeouts, disable/enable features (like activating a custom warning message), etc.

Now you can ship your demo, put the expire date in the file, change it if needed, etc. This is not the most elegant nor secure solution, but for many use cases for a demo/beta, this might be enough to serve its intended purpose.

Below is a working mock-up of how this might look (omitted error checking and proper cleanup for brevity):

public class LicenseInfo
{
    public string Info1 { get; private set; }

    public bool IsValid
    {
        get
        {
            // todo, add logic here
            return true;
        }
    }

    public bool ParseLicense(string data)
    {
        bool ret = false;

        if (data != null)
        {
            // todo, parse data and set status/attributes/etc
            Info1 = data;
            ret = true;
        }

        return ret;
    }
}

// could make a static class...
public class License
{
    public LicenseInfo GetLicenseInfo()
    {
        var license = new LicenseInfo();

        // todo: create whatever schema you want.
        // filename hard-coded per app/version/etc.
        // file could contain text/json/etc.
        // easy to manage, update, etc.
        // extensible.
        var uri = "https://raw.githubusercontent.com/korygill/Demo-License/master/StackOverflow-Demo-License.txt";

        var request = (HttpWebRequest)HttpWebRequest.Create(uri);
        var response = request.GetResponse();
        var data = new StreamReader(response.GetResponseStream()).ReadToEnd();

        license.ParseLicense(data);

        return license;
    }
}

class Program
{
    static void Main(string[] args)
    {
        // check if our license if valid
        var license = new License();
        var licenseInfo = license.GetLicenseInfo(); 

        if (!licenseInfo.IsValid)
        {
            Console.WriteLine("Sorry...license expired.");
            Environment.Exit(1);
        }

        Console.WriteLine("You have a valid license.");
        Console.WriteLine($"{licenseInfo.Info1}");

    }
}

Upvotes: 0

Mat&#237;as Fidemraizer
Mat&#237;as Fidemraizer

Reputation: 64923

But pre-processor directives are used during compile-time.

That expiration should be implemented using executable code. The issue here is you can hardcode it and hide it as much as possible, but it avid developers can find it and replace the intermediate language and generate a new assembly without the expiration. Actually, there're many other cases where an user can by-pass the whole expiration...

It seems like your best bet should be creating some kind of unique key, store it in your app and check if the whole key is still valid over the wire connecting to some licensing service developed by you.

Upvotes: 2

Related Questions