C# – implicit & explicit keywords

Posted on September 11, 2013 by Thuru

What are the uses of the implicit and explicit keywords in C#.

implicit is used when we need implicit conversions between types. It works on value types and as well on reference types.

The below code shows the use of implicit keyword. Create a class named Digit as below and note the two static methods with implicit keyword.

class Digit
{
    public double val;
    
    public Digit(double d)
    {
        val = d;
    }
  
    public static implicit operator double(Digit d)
    {
        return d.val;
    }
  
    public static implicit operator Digit(double d)
    {
        return new Digit(d);
    }
  
}

Since the Digit class has both the Digit to double conversion and the double to Digit conversion implicit functions defined, it is safe to do the following.

Digit dig = new Digit(7);
  
//This call invokes the implicit "double" operator 
double num = dig;
//This call invokes the implicit "Digit" operator
Digit dig2 = 12;

Same works on complete reference types as well. Look at the following example.

class Animal
{
    public string  Family { get; set; }
  
    public static implicit operator Dog(Animal animal)
    {
        return new Dog() { Breed = animal.Family };
    }
  
    public static implicit operator Animal(Dog d)
    {
        return new Animal() { Family = d.Breed };
    }
}
  
class Dog
{
    public string Breed { get; set; }
}

These following conversions are possible.

Animal a = new Animal() { Family = "Golden Retriever" };
Dog d1 = a;
a = d1;

explicit keyword does the right opposite, where we have to explicitly cast the one type to the other. Say we’ve a set of classed like this.

class WaterCleaner
{
    public string Name;
}
  
class RoboticCleaner
{
    public string Name;
  
    public static explicit operator WaterCleaner(RoboticCleaner r)
    {
        return new WaterCleaner() { Name = r.Name };
    }
  
    public static explicit operator RoboticCleaner(WaterCleaner w)
    {
        return new RoboticCleaner() { Name = w.Name };
    }
}

Then you should do the explicit casting like this.

   1: RoboticCleaner rc = new RoboticCleaner() { Name = "Super Cleaner" };
   2: WaterCleaner wc = (WaterCleaner)rc;

If RoboticCleaner has implicit conversion defined then you don’t need the explicit conversion.

Now the question is what if the RoboticCleaner class has both implicit and explicit conversions defined.

Now your RoboticCleaner should be like this.

class RoboticCleaner
{
    public string Name;
  
    public static explicit operator WaterCleaner(RoboticCleaner r)
    {
        return new WaterCleaner() { Name = r.Name };
    }
  
    public static explicit operator RoboticCleaner(WaterCleaner w)
    {
        return new RoboticCleaner() { Name = w.Name };
    }
  
    public static implicit operator WaterCleaner(RoboticCleaner r)
    {
        return new WaterCleaner() { Name = r.Name };
    }
}

Then the compiler gets confused and shows this message. (click on the image to enlarge)

Embedding Resources in Silverlight

Posted on July 30, 2013 by Thuru

This post explains how to embed a resource file in Silverlight and use it. For the example we’ll consider embedding a CSV file and using it.

Copy the file inside the project under the appropriate path. In the properties of the file set the Build Action as Embedded Resource.

The below sample code shows how to access an embedded CSV file.

Stream shareInfo = typeof(ShareInformationManipulation)
                   .Assembly
                   .GetManifestResourceStream("data.csv");

You can read any type of embedded resource as a Stream.

Uploading a file to Azure Blob

Posted on June 10, 2013 by Thuru

Windows Azure storage provides flexible storage services. Blob storage is one of them which is used to store binary large objects.

Windows Azure blob has the concepts of containers (which you can think like partitions of a disk). Containers are either private or public.

Private containers are only accessible to the user and application developer with proper storage access keys. Public containers are accessible to all. So just by URL you can access a file stored in the public container.

You can use the Azure Storage Explorer to create and manipulate your Azure storage. It is a handy tool available for free from codeplex. Download link : http://azurestorageexplorer.codeplex.com/

The below code sample demonstrates how you can upload a file to a private container named ‘privatecontainer’ in Windows Azure.

private void UploadFileToPrivateContainer()
{
    // get the storage (blob) connection string from the config file
    var storageAccount = Microsoft.WindowsAzure.Storage.CloudStorageAccount.Parse
        (CloudConfigurationManager.GetSetting("StorageConnectionString"));
  
    // creates a blob client
    CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient();
  
    // creates a container :: container name should be small otherwise you'll get Error 400 Bad Request Error.
    CloudBlobContainer container = blobClient.GetContainerReference("privatecontainer");
    container.CreateIfNotExists();
  
    // gets the physicall file path to be uploaded from ASP.NET FileUpload content.
    string path = FileUpload1.FileName;
    
    // creating a blockBlob, if a block blob exists witht the same name then it will be replaced.
    CloudBlockBlob blockBlob = container.GetBlockBlobReference(Path.GetFileName(path));
  
    var stream = FileUpload1.FileContent;
  
    // uploads the stream.
    blockBlob.UploadFromStream(stream);
  
    stream.Close();
  
    Label1.Text = "Upload Success";
}

I used the Azure Storage Explorer to create the container, you can create it using the code as well.

In order to run the above sample you should have Azure SDK installed and use Nuget Package manager to install the Windows Azure Storage assemblies.

Here’s the code for transfer a file from a private container to public container. Azure storage SDK doesn’t have an operation for move. So here we copy the file to the public container by downloading and re uploading it and deleting the file from the private container.

protected void BtnMove_Click(object sender, EventArgs e)
{
    var storageAccount = Microsoft.WindowsAzure.Storage.CloudStorageAccount.Parse(CloudConfigurationManager.GetSetting("StorageConnectionString"));
    CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient();
  
    CloudBlobContainer privateContainer = blobClient.GetContainerReference("privatecontainer");
  
    CloudBlobContainer publicContainer = blobClient.GetContainerReference("testpubliccontainer");
  
    /*
     * Moving is not available directly, so we download from priavte blob and upload to public blob.
     * and delete the file from private file from private blob
     */ 
  
    // getting the blob to move.
    // based on my UI user has t type the name of the file he/she wants to move.
    var prblob = privateContainer.ListBlobs(null, false).OfType<CloudBlockBlob>().FirstOrDefault(b => b.Name == TextBox1.Text);
  
    var stream = prblob.OpenRead();
  
    var blobref = publicContainer.GetBlockBlobReference(prblob.Name);
    blobref.UploadFromStream(stream);
  
    stream.Close();
  
    prblob.DeleteIfExists();           
}

Finally the below code samples how to query the files in a blob.

protected void BtnGetVideos_Click(object sender, EventArgs e)
{
    var storageAccount = Microsoft.WindowsAzure.Storage.CloudStorageAccount.Parse(CloudConfigurationManager.GetSetting("StorageConnectionString"));
  
    // creates a blob client
    CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient();
  
   
    CloudBlobContainer publiccontainer = blobClient.GetContainerReference("testpubliccontainer");
    List<BlobDetails> list2 = new List<BlobDetails>();
  
    foreach (IListBlobItem item in publiccontainer.ListBlobs(null, false))
    {
        if (item.GetType() == typeof(CloudBlockBlob))
        {
            CloudBlockBlob blob = (CloudBlockBlob)item;
            list2.Add(new BlobDetails() { BlobName = blob.Name, URL = blob.Uri.AbsoluteUri });
        }
    }
}

HTTP Headers

Posted on May 13, 2013 by Thuru

This is a quick and a small post on reading the HTTP headers in ASP.NET. Code gets the HTTP header key – value pairs and write it to a text file.

protected void Page_Load(object sender, EventArgs e)
{
    var headers = Request.Headers;
    StreamWriter writer = new StreamWriter(Server.MapPath("~/data.txt"));
  
    foreach (var item in headers.AllKeys)
    {
        string data = item + "---" + headers[item];              
        writer.WriteLine(data);
    }
  
    writer.Flush();
    writer.Close();
}

Output text file as follows.

Connection---Keep-Alive
Accept---text/html, application/xhtml+xml, */*
Accept-Encoding---gzip, deflate
Accept-Language---en-US
Host---localhost:24859
User-Agent---Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; Trident/5.0)

AES Cryptography

Posted on April 30, 2013 by Thuru

Contains the code for AES encryption and decryption in C#.

public byte [] EncryptText(string plainData)
        {
            RijndaelManaged rij = new RijndaelManaged();
            
            rij.GenerateKey();
            _key = rij.Key;
  
            rij.GenerateIV();
            _intializationVector = rij.IV;
  
            ICryptoTransform encryptor = rij.CreateEncryptor(_key, _intializationVector);
  
            using (MemoryStream msEncrypt = new MemoryStream())
            {
                using (CryptoStream csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
                {
                    using (StreamWriter swEncrypt = new StreamWriter(csEncrypt))
                    {
                        swEncrypt.Write(plainData);
                    }
  
                    return msEncrypt.ToArray();
                }
            }
  
        }
  
  
        public string  DecryptText(byte [] encrytedData)
        {
            RijndaelManaged rij = new RijndaelManaged();
  
            ICryptoTransform decryptor = rij.CreateDecryptor(_key, _intializationVector);
  
            using (MemoryStream msDecrypt = new MemoryStream(encrytedData))
            {
                using (CryptoStream csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read))
                {
                    using (StreamReader srDecrypt = new StreamReader(csDecrypt))
                    {
                        return srDecrypt.ReadToEnd();
                    }
                }
            }
        }
        
    }

UI Updates – Part 2

Posted on April 10, 2013 by Thuru

ASP.NET

ASP.NET UI updates are handles using Ajax. In this example it is described how to use the ASP.NET Ajax for the updates.

In ASP.NET Ajax we can have update panel and make the updates via Ajax calls. Prepare your ASPX markup like below.

<body>
    <form id="form1" runat="server">
        <asp:ScriptManager ID="ScriptManager1" runat="server"></asp:ScriptManager>
        
        <div>
            <asp:Button ID="BtnPostback" runat="server" Text="PostBack" OnClick="BtnPostback_Click" />
        </div>
  
        <div>
            <asp:UpdateProgress ID="UpdateProgress1" runat="server">
                <ProgressTemplate>
                    <asp:Label Text="Working..." ID="LblBusyIndicator" runat="server"></asp:Label>
                </ProgressTemplate>
            </asp:UpdateProgress>
        </div>
  
        <div>
            <asp:UpdatePanel ID="UpdatePanel1" runat="server">
                <ContentTemplate>
                    <asp:Label ID="Label1" runat="server" Text=""></asp:Label>
                </ContentTemplate>
                <Triggers>
                    <asp:AsyncPostBackTrigger ControlID="BtnPostback" />
                </Triggers>
            </asp:UpdatePanel>
        </div>
  
    </form>
</body>

Code behind..

private void PerformTask()
{
    // job time 4 - 10 seconds
    int time = new Random().Next(4, 11);
    Thread.Sleep(1000 * time);
    Label1.Text = String.Format("Hello from worker - ran for {0} seconds", time);
}
  
  
protected void BtnPostback_Click(object sender, EventArgs e)
{
    PerformTask();
}

Silverlight

Silverlight the platform itself is asynchronous. And we can have the same mechanism we used in WPF for the UI updates, but little different.

Read the Silverlight Dispatcher for the Silverlight UI updates

UI Updates – Part 1

Posted on March 29, 2013 by Thuru

Updating the UI is a problem and it is tricky. There are very few simple rules to follow. Let’s see Here we’ll see some smart ways to perform UI updates on Console applications, Windows Forms, WPF, ASP.NET, Silverlight, Windows Phone and Windows Store apps.

Console Applications

Do they have UI ? No. But we’ll check how different threads perform updates on Console applications. Look at the following code. It has a main thread and another thread (worker thread) perform some time consuming task and updates the UI. Main thread shows a rotating bar till the worker thread completes.

class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Application Start");
            Thread worker = new Thread(PerformTask);
  
            worker.Start();
  
            ShowConsoleWaitAnimation(worker);
  
            Console.WriteLine("Application End");
            Console.ReadKey();
  
        }
  
  
        private static void PerformTask()
        {
            // job time 4 - 10 seconds
            int time = new Random().Next(4,11);
            Thread.Sleep(1000 * time);
            Console.WriteLine("Hello from worker - ran for {0} seconds",time);
        }
  
  
        private static void ShowConsoleWaitAnimation(Thread thread)
        {
            while (thread.IsAlive)
            {
                Console.Write("Processing - /\r");
                Thread.Sleep(100);
                Console.Write("Processing - -\r");
                Thread.Sleep(100);
                Console.Write("Processing - \\\r");
                Thread.Sleep(100);
                Console.Write("Processing - |\r");
                Thread.Sleep(100);
            }
        }
    }

Windows Forms

Look at the below code. In a simple Windows Forms application, for a button click event, a time consuming task runs in a separate thread and tries to update a Label control.

private void BtnStartWork_Click(object sender, EventArgs e)
{
    Thread worker = new Thread(PerformTask);
    worker.Start();
}
  
private void PerformTask()
{
    // job time 4 - 10 seconds
    int time = new Random().Next(4, 11);
    Thread.Sleep(1000 * time);
    LblStatus.Text = String.Format("Work completed - ran for {0} seconds", time);
} 

When you run the above code, you will get this famous Exception. Because the Label control is created in UI thread and our worker thread tries to reach it. Cross thread referencing cannot happen as this is a violation of operating system thread handling policies. ( Do not mistake the cross thread communication and cross thread referencing, cross thread communication can happen among threads)

There are plenty of solutions for this problem, but the ready made one is to use BackgroundWorker class. The below code shows how you can use BackgroundWorker class and perform UI updates and also shows a progress bar on the UI. Events are coded inline to reduce the number of methods for this small demo.

public partial class Form1 : Form
{       
       private BackgroundWorker _bgWorker = new BackgroundWorker();
       private string _result = String.Empty;
  
       public Form1()
       {
           InitializeComponent();
       }
  
       private void BtnStartWork_Click(object sender, EventArgs e)
       {
           _bgWorker.WorkerReportsProgress = true;
  
           _bgWorker.DoWork += (s, ev) =>
               {
                   _result = PerformTask();
               };
           
           _bgWorker.ProgressChanged += (s, ev) =>
               {
                   workerProgressBar.Value = ev.ProgressPercentage * 100;
               };
  
           _bgWorker.RunWorkerCompleted += (s, ev) =>
               {
                   LblStatus.Text = _result;
               };
  
           _bgWorker.RunWorkerAsync();
       }
  
  
       private string PerformTask()
       {
           // job time 4 - 10 seconds
           int time = new Random().Next(4, 11);
           int fullTime = time;
  
           while (time >= 0)
           {
               Thread.Sleep(1000);
               _bgWorker.ReportProgress(1 - (time / fullTime));
               time--;
           }
  
           return String.Format("Work completed - ran for {0} seconds", fullTime);
        }
          
} 

WPF

In WPF we can use the BackgroundWorker, but also there’s a well refined solution in the WPF is to use the Dispatcher object. WPF model has Dispatcher object common across all the controls. So we can use this to update the UI.

Little modification in the PerformTask() and make it return the result.

private string PerformTask()
{
    // job time 4 - 10 seconds
    int time = new Random().Next(4, 11);
    int fullTime = time;
  
    Thread.Sleep(time);      
  
    return String.Format("Work completed - ran for {0} seconds", fullTime);
} 

Button click event.

private void BtnWork_Click(object sender, RoutedEventArgs e)
{
    Thread thread = new Thread(() =>
        {
            string result = PerformTask();
            Dispatcher.Invoke(() =>
                {
                    TxtStatus.Text = result;
                });
        });
    thread.Start();
}

Part 2 – will discuss about UI updates in ASP.NET and Silverlight.

Delegates

Posted on February 5, 2013 by Thuru

Methods are delegate types. It is that simple. Since delegates are types in .NET we can use any method as types, that means we can pass methods as parameters and we can return methods.

The below code shows different ways we can instantiate a delegate.

namespace DelegatesVsInterfaces
{
    public delegate string MyDelegate(string param);
 
    class Program
    {
        static void Main(string[] args)
        {
            // delegate initialization based on history
            
            // C# 1.0
            MyDelegate md1 = new MyDelegate(MyMethod);
            Console.WriteLine(md1("C# 1.0"));
 
            // C# 2.0
            MyDelegate md2 = MyMethod;
            Console.WriteLine(md2("C# 2.0"));
 
            // C# 2.0 - anonymous method
            MyDelegate md3 = delegate(string message) 
            { 
                return String.Format("Your message, {0} - from anonymous method",message); 
            };
            Console.WriteLine(md3("C# 2.0 and later"));
 
            // C# 3.0 - lamda expressions
            MyDelegate md4 = message => 
            { 
                return String.Format("Your message, {0} - from lamda methods", message); 
            };
            Console.WriteLine(md4("C# 3.0 and later"));
 
            Console.ReadKey();
        }
 
       public static string MyMethod(string greeting)
       {
           //Thread.Sleep(5000);
           return String.Format("Your message, {0} - relayed from MyMethod",greeting);
       }
   }
}

A delegate has different ways of invocation. The very direct way is calling the delegate itself with the parameters. This indirectly invokes the Invoke() method of the delegate. Invoke() is generated by the compiler with the correct parameter list.

The following code shows the direct invocation.

   1: string result = md1("parameter");
   2: result = md1.Invoke("parameter");

Other way of handling a delegate invocation is, invoking the method asynchronously. BeginInvoke() and EndInvoke() of a delegate is used for this.

BeginInvoke() is generated for a delegate with that specific delegate’s parameters as first set of parameters, next parameter is a AsyncCallback type method and last one is a object which could have values to the callback method.

The following code explains how to use the BeginInvoke() and EndInvoke() to asynchronous execution.

// put this in your method invocation code
MyDelegate md = MyMethod;
AsyncCallback callback = CallBackMethod;
 
IAsyncResult result = md.BeginInvoke("Param", callback, null);
 
 
// callback method
public static void CallBackMethod(IAsyncResult result)
{
    AsyncResult asyncResult = (AsyncResult)result;
    MyDelegate caller = (MyDelegate)asyncResult.AsyncDelegate;
    
    string value = caller.EndInvoke(result);
 
    Console.WriteLine(value);
}

If the method hasn’t finished the execution when the EndInvoke() is called, the callback method waits till the execution is finished.

Another way of invoking a delegate is by using its DynamicInvoke(). More often this is direct as Invoke(), but has the difference in the parameters passed to the delegate. DynamicInvoke() has a object array parameter. We should pass the parameters with the correct data types and it should be with the correct parameter count. If the parameter is not correct it will throw an ArgumentException and if the number of parameters doesn’t match it will throw TargetParameterCountException.

Versatile Digital DNA

Category Archives: C#

C# – implicit & explicit keywords

Embedding Resources in Silverlight

Uploading a file to Azure Blob

HTTP Headers

AES Cryptography

UI Updates – Part 2

UI Updates – Part 1

Delegates

Share this:

Share this:

Share this:

Share this:

Share this:

Share this:

Share this:

Share this: