LearnC#WithDarko

Page 2 of 6

WinMD Assembly

Windows 8 introduced WinRT(Windows Runtime) that allows us to develop applications based on C++, C#, Vb and JavaScript by allowing access to its Api and by allowing communication between different programming languages. Communication between languages is possible through Windows Runtime Component that creates WinMD Assembly. WinMD Assembly is a Assembly that contains metadata but can also contain types.

When you try to create Windows 8.1 store app you cannot add usual Class Library, you have to add Windows Runtime Component and there you can write your usual code.

Trying to add Class library to your Store App will result in “Unable to add a reference to project” error.

WinMD limitations (copied from https://www.microsoftpressstore.com/articles/article.aspx?p=2199428&seqNum=3):

The fields, parameters, and return values of all the public types and members in your component must be WinRT types.
Public structures may not have any members other than public fields, and those fields must be value types or strings.
Public classes must be sealed. If your programming model requires polymorphism, you can create a public interface and implement that interface on the classes that must be polymorphic. The only exceptions are XAML controls.
All public types must have a root namespace that matches the assembly name, and the assembly name must not begin with “Windows.”

Why would I need to create WinMD class library?

Lets explore it through Windows store app example.

Create new Solution and there add two Blank App.s for Windows 8.1 (one for C# and another for JS).

Both of these apps should have:

2x Textbox

1x Label

2x Button

Goal of this Application is to create Application where you can input data inside two different TextBoxes and combine their values inside Label after clicking button. Second goal is to copy some text value in your clipboard(simply copy some text with Ctrl+C) and display value in Label after clicking second button.

All this code can be easily achieved by writing it in backend of MainPage.xaml.cs file or inside JavaScript function, but we want our Application to share code, and that is here WinMD steps in. You can create methods that perform that actions and reuse it across different applications and different languages. Yup, even JavaScript can use WinMD classes written in C#.

Example of WinMD / Windows Runtime Component Assembly

MainPage.xaml

<Page
    x:Class="XamlApp.MainPage"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="using:XamlApp"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d">

    <Grid Background="{ThemeResource ApplicationPageBackgroundThemeBrush}">
        <TextBox x:Name="TextBox1" HorizontalAlignment="Left" Margin="50,50,0,0" TextWrapping="Wrap" Text="First Word" VerticalAlignment="Top" Width="306"/>
        <TextBox x:Name="TextBox2" HorizontalAlignment="Left" Margin="50,100,0,0" TextWrapping="Wrap" Text="Second Word" VerticalAlignment="Top" Width="306"/>
        <TextBox x:Name="TextBox3" HorizontalAlignment="Left" Margin="50,150,0,0" TextWrapping="Wrap" Text="Result" VerticalAlignment="Top" Width="306"/>
        <Button x:Name="Button1" Content="Combine Text" HorizontalAlignment="Left" Margin="47,200,0,0" VerticalAlignment="Top" Click="Button1_Click"/>
        <Button x:Name="Butonn2" Content="Get Clipboard data" HorizontalAlignment="Left" Margin="47,250,0,0" VerticalAlignment="Top" Click="Butonn2_Click"/>

    </Grid>
</Page>

<Page

x:Class="XamlApp.MainPage"

xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

xmlns:local="using:XamlApp"

xmlns:d="http://schemas.microsoft.com/expression/blend/2008"

xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"

mc:Ignorable="d">

</Grid>

</Page>

default.html

<!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8" />
    <title>JsApp.Windows</title>

    <!-- Style -->
    <style>
        body {
            display: block;
        }

        #txtBox1, #txtBox2, #result, .button {
            display: inherit;
            margin: 20px;
        }
    </style>

    <!-- WinJS references -->
    <link href="//Microsoft.WinJS.2.0/css/ui-dark.css" rel="stylesheet" />
    <script src="//Microsoft.WinJS.2.0/js/base.js"></script>
    <script src="//Microsoft.WinJS.2.0/js/ui.js"></script>

    <!-- JsApp.Windows references -->
    <link href="/css/default.css" rel="stylesheet"/>

    <!-- Functions -->
    <script type="text/javascript">
        function combineText() {
            var hlpClass = new WindowsRuntimeComponentTest.HelperClass();
            document.getElementById('result').innerText = hlpClass.combineTwoStrings(window.txtBox1.value, window.txtBox1.value);
        }

        // JavaScript has already function to get clipboard data so there is no need to use GetTextFromClipboard method
        function getClipboard() {
            document.getElementById('result').innerText = window.clipboardData.getData('Text');
        }
    </script>
</head>
<body>
    <input type="text" id="txtBox1" value="First Word"/>
    <input type="text" id="txtBox2" value="Second Word"/>
    <label id="result">Result</label>
    <button class="button" onclick="combineText()">Combine Text</button>
    <button class="button" onclick="getClipboard()">Get Clipboard data</button>
</body>
</html>

<!DOCTYPE html>

<html>

<head>

<title>JsApp.Windows</title>

<style>

body {

display: block;

}

#txtBox1, #txtBox2, #result, .button {

display: inherit;

margin: 20px;

}

</style>

function combineText() {

var hlpClass = new WindowsRuntimeComponentTest.HelperClass();

document.getElementById('result').innerText = hlpClass.combineTwoStrings(window.txtBox1.value, window.txtBox1.value);

}

// JavaScript has already function to get clipboard data so there is no need to use GetTextFromClipboard method

function getClipboard() {

document.getElementById('result').innerText = window.clipboardData.getData('Text');

}

</script>

</head>

<body>

<label id="result">Result</label>

<button class="button" onclick="combineText()">Combine Text</button>

<button class="button" onclick="getClipboard()">Get Clipboard data</button>

</body>

</html>

MainPage.xaml.cs – Buttons

private void Button1_Click(object sender, RoutedEventArgs e)
    {
        HelperClass hlpClass = new HelperClass();
        TextBox3.Text = "";

        TextBox3.Text = hlpClass.CombineTwoStrings(TextBox1.Text, TextBox2.Text);
    }

    private async void Butonn2_Click(object sender, RoutedEventArgs e)
    {
        HelperClass hlpClass = new HelperClass();
        TextBox3.Text = "";

        TextBox3.Text = await hlpClass.GetTextFromClipboard(Clipboard.GetContent());
    }

private void Button1_Click(object sender, RoutedEventArgs e)

{

HelperClass hlpClass = new HelperClass();

TextBox3.Text = "";

TextBox3.Text = hlpClass.CombineTwoStrings(TextBox1.Text, TextBox2.Text);

}

private async void Butonn2_Click(object sender, RoutedEventArgs e)

{

HelperClass hlpClass = new HelperClass();

TextBox3.Text = "";

TextBox3.Text = await hlpClass.GetTextFromClipboard(Clipboard.GetContent());

}

Windows Runtime Component – Helper class

public sealed class HelperClass
{
	public string CombineTwoStrings(string v1, string v2)
	{
		return v1 + " " + v2;
	}

	public IAsyncOperation<string> GetTextFromClipboard(DataPackageView clipboard)
	{
		var result =  ReturnStringFromClipboardData(clipboard).AsAsyncOperation();
		return result;
	}

	internal async Task<string> ReturnStringFromClipboardData(DataPackageView value)
	{
		string cliboardStringValue = await value.GetTextAsync();
		return cliboardStringValue;
	}
}

public sealed class HelperClass

{

public string CombineTwoStrings(string v1, string v2)

{

return v1 + " " + v2;

}

public IAsyncOperation<string> GetTextFromClipboard(DataPackageView clipboard)

{

var result = ReturnStringFromClipboardData(clipboard).AsAsyncOperation();

return result;

}

internal async Task<string> ReturnStringFromClipboardData(DataPackageView value)

{

string cliboardStringValue = await value.GetTextAsync();

return cliboardStringValue;

}

If you wish to inspect entire solution , download it from this link.

Please do not use code from solution for your projects because no checks were implemented what so ever.

GAC (Global Assembly Cache)

19/09/2016 / Darko / 2 Comments

You can locate GAC folder inside Windows directory. GAC folder contains only strongly named assemblies. All applications that are running on your machine can access GAC folder and use its assemblies. Benefits of storing strongly named assemblies inside GAC are:

There is no need to distribute that particular assembly with every new version of application
Assemblies stored in GAC folder are strongly named so you need not to worry about having two or more version of same assembly distributed.

How can i locate GAC folder?

There are actually two locations:

Location for assemblies created with .Net Framework 2.0 to .Net Framework 3.5
Location for assemblies created with .Net Framework 4.0 and newer

Usually you cal locate it by typing C:\Windows\assembly for older strongly named assemblies or C:\Windows\Microsoft.NET\assembly for newer strongly named assemblies.

If your machine is not installed on C drive or your windows folder is not named Windows simply type in File explorer : %WINDIR%\Assembly or %WINDIR%\Microsoft.NET\assembly and you there you can find GAC folder.

How to install Strongly named assembly inside Global Assembly Cache?

Add new Class library project to Solution and name it AssemblyToInstall and strong name it.

Drag and drop approach:

Just simple locate bin\Debug folder inside AssemblyToInstall project, locate AssemblyToInstall.dll file and drop it to appropriate location (C:\Windows\Microsoft.NET\assembly). Note that you can do this only if your user has elevated privileges.

Using GacUtil.exe

If you are using Visual Studio 2013 or 2015 version, you can search for Developer Command Prompt and run it as Administrator.

New console will open.

Navigate to project. Mine is located on D drive under charp folder

Next you will need to run gacutil toll with -i parameter (basically -i switch is telling gacutil that we want to install assembly) followed by Assembly dll we want to install.

run command: gacutil.exe -i AssemblyToInstall.dll

How to use gacutil to install strongly named assembly inside GAC folder

You should receive message: “Assembly successfully added to the cache”

If you receive message: “Failure adding assembly to the cache: Attempt to install an assembly without a strong name”. That means that you have not signed assembly.

Now navigate to %WINDIR%\Microsoft.NET\assembly\GAC_MSIL\AssemblyToInstall and there you can see your assembly and can use that path to provide reference to that assembly to all applications located on this machine.

Tomorrow we will continue with topic on how to implement side-by-side hosting.

Strongly named assemblies

19/09/2016 / Darko / 0 Comments

Purpose of strong naming assemblies is to create unique identity for desired assembly. You would typically want to do that when you need multiple versions of same assembly to be used, when assembly must be installed inside GAC (global assembly cache) or when you want assemblies to be to be referenced by strongly named assemblies.

What does it mean to be strongly named?

Strongly named assemblies are assemblies that have:

Name (usually name of project)

AssemblyVersion (AssemblyVersion information)

Culture information (Assemblies are usually culture neutral but if you wish to change them you can access AssemblyInfo.cs file and change AssemblyCulture attribute)

Private/Public key token (main difference between strongly named assemblies and weakly named assemblies)

I wish to create strongly named assemblies! What do i do?

First you would create a project. That first step would create weakly named assembly. Next what you want to do is sign it. There are multiple ways to achieve this.

First Approach:

From Visual studio:

Right click project
Properties
Select Signing tab
Check “Sign the assembly” CheckBox
From Drop-down control select New
Input necessary Information
Select Drop-down control again and find your .pfx file

How to strongly name assemblies

Now when we know how to strong name assemblies we can continue to part on how to put an assembly in the global assembly cache.

Version assemblies

19/09/2016 / Darko / 0 Comments

When talking about Version assemblies you would usually interact with AssemblyVersion, AssemblyFileVersion, AssemblyInformationalVersion Atrributes. Ability to successfully version assemblies is important while testing, debugging and deploying your assemblies. Why? Because it allows you and your team to inspect and debug same version of assemblies on one hand and to know what version of assemblies is are your customers using when talking about future requirements and current problems.

AssemblyVersion and AssemblyFileVersion

attributes

Can be manually located in your Solution explorer:

AssemblyInfo.cs

AssemblyInfo.cs file you can manually change values of a few Attributes. But now we will take look at AssemblyVersion and AssemblyFileVersion attributes. Both these Attributes provide default value in string format. Default values should appear like this when you initially create project:

[assembly: AssemblyVersion("1.0.0.0")]
[assembly: AssemblyFileVersion("1.0.0.0")]

1 2	[assembly: AssemblyVersion("1.0.0.0")] [assembly: AssemblyFileVersion("1.0.0.0")]

Number values inside string have specific meaning:

value -> major value. Value should be changed when changes to your program are noticeable, like major User interface and under the hood changes
value -> minor. increment this value when adding new capabilities to your Application.
value -> build number. Obviously this value should be incremented when running a build
value -> revision. Value that you should increment when choosing which build version to deploy

Build number and revision can be automated by using asterisk(*). Just change strings too look like this and their values will be incremented automatically after each build:

[assembly: AssemblyVersion("1.0.*")]
[assembly: AssemblyFileVersion("1.0.*")]

1 2	[assembly: AssemblyVersion("1.0.")] [assembly: AssemblyFileVersion("1.0.")]

If you are developing small scale application it is best to change minor and major values manually.

AssemblyVersion attribute is used by other assemblies. When value of this attribute is changed, all assemblies that reference it must change value to match current value to ensure that communication between them will proceed uninterrupted.

AssemblyFileVersion attribute is used for deployment (when you ship assemblies to end user). You always need to know which version of assembly is shipped to your customer so that you can assist them, detect bugs and plan future changes.

AssemblyInformationalVersion

Usually you would not like to bore or even worse scare customers by displaying version of your Application in format like 8.56.7520.1459. You will want to display assembly version in user friendly format like 8.56 RC or 8 Orange, or any other format that will appeal to end user. This is where AssemblyInformationalVersion steps in. We can declare AssemblyInformationalVersion inside AssemblyInfo.cs file.

[assembly: AssemblyInformationalVersion("3.1 (Demonstration)")]

1	[assembly: AssemblyInformationalVersion("3.1 (Demonstration)")]

Nice. Please show me how to access these values.

First of. make sure that your AssemblyInfo.cs files has following values:

[assembly: AssemblyVersion("1.0.0.0")]
[assembly: AssemblyFileVersion("2.0.0.0")]
[assembly: AssemblyInformationalVersion("3.1.0.0 (Demonstration)")]

[assembly: AssemblyVersion("1.0.0.0")]

[assembly: AssemblyFileVersion("2.0.0.0")]

[assembly: AssemblyInformationalVersion("3.1.0.0 (Demonstration)")]

And inside main Method put following code:

// Access Attributes 1st approach
string assemblyVersionInfoValue = Assembly.GetExecutingAssembly().GetName().Version.ToString();
string assemblyFileVersionInfoValue = FileVersionInfo.GetVersionInfo(Assembly.GetExecutingAssembly().Location).FileVersion;
string assemblyInformationalVersionValue = FileVersionInfo.GetVersionInfo(Assembly.GetExecutingAssembly().Location).ProductVersion;

Console.WriteLine("AssemblyVersion attribute value: {0}", assemblyVersionInfoValue);
Console.WriteLine("AssemblyFileVersion attribute value: {0}", assemblyFileVersionInfoValue);
Console.WriteLine("AssemblyInformationalVersion attribute value: {0}", assemblyInformationalVersionValue);

Console.WriteLine("...");


// Access Attributes 2nd approach
Assembly assembly = Assembly.GetExecutingAssembly();
Attribute[] attributes = Attribute.GetCustomAttributes(assembly);  

foreach (Attribute attribute in attributes)
{
	if (attribute is AssemblyVersionAttribute)
	{
		AssemblyVersionAttribute a = (AssemblyVersionAttribute)attribute;
		Console.WriteLine("Name: {0}, version {1}", a, a.Version );
	}

	if (attribute is AssemblyFileVersionAttribute)
	{
		AssemblyFileVersionAttribute a = (AssemblyFileVersionAttribute)attribute;
		Console.WriteLine("Name: {0}, version {1}", a, a.Version);
	}

	if (attribute is AssemblyInformationalVersionAttribute)
	{
		AssemblyInformationalVersionAttribute a = (AssemblyInformationalVersionAttribute)attribute;
		Console.WriteLine("Name: {0}, version {1}", a, a.InformationalVersion);
	}
}

// Access Attributes 1st approach

string assemblyVersionInfoValue = Assembly.GetExecutingAssembly().GetName().Version.ToString();

string assemblyFileVersionInfoValue = FileVersionInfo.GetVersionInfo(Assembly.GetExecutingAssembly().Location).FileVersion;

string assemblyInformationalVersionValue = FileVersionInfo.GetVersionInfo(Assembly.GetExecutingAssembly().Location).ProductVersion;

Console.WriteLine("AssemblyVersion attribute value: {0}", assemblyVersionInfoValue);

Console.WriteLine("AssemblyFileVersion attribute value: {0}", assemblyFileVersionInfoValue);

Console.WriteLine("AssemblyInformationalVersion attribute value: {0}", assemblyInformationalVersionValue);

Console.WriteLine("...");

// Access Attributes 2nd approach

Assembly assembly = Assembly.GetExecutingAssembly();

Attribute[] attributes = Attribute.GetCustomAttributes(assembly);

foreach (Attribute attribute in attributes)

{

if (attribute is AssemblyVersionAttribute)

{

AssemblyVersionAttribute a = (AssemblyVersionAttribute)attribute;

Console.WriteLine("Name: {0}, version {1}", a, a.Version );

}

if (attribute is AssemblyFileVersionAttribute)

{

AssemblyFileVersionAttribute a = (AssemblyFileVersionAttribute)attribute;

Console.WriteLine("Name: {0}, version {1}", a, a.Version);

}

if (attribute is AssemblyInformationalVersionAttribute)

{

AssemblyInformationalVersionAttribute a = (AssemblyInformationalVersionAttribute)attribute;

Console.WriteLine("Name: {0}, version {1}", a, a.InformationalVersion);

}

This post has thought you how to version assemblies and was first post in Manage assemblies topic. Now we will continue to topic on how to strong name your assembly.

Streams

16/09/2016 / Darko / 2 Comments

Streams are sequence of bytes that you can use to read from or write to a backing store.

Let’s break down last sentence into a few parts:

„Stream is a sequence of bytes“ – When working with data it is preferable that we read data in chunks of bytes. By breaking data in chunks we do not have to wait for our application to retrieve all parts of a data. For example, we may be accessing a audio file from network location and we want to process that audio file. Retrieving that file would take time and our application would need to wait until retrieval process is done before it can do some job. When using Streams we can specify how large chunks will be. You have seen this example: when listening to a music from popular music streaming site you will see information about bit-rate, that bit-rate represents chunk of data that is downloaded to you device for consumption.
„that you can use to read from or write“ – Stream allows us to read, write or both to a storage device.
„to a backing store“ – backing store represents your local Hard drive, memory, network location or any type of storage medium.

System class in System.IO namespace is a base class for all streams.

When using streams type of file (.txt, .mp3, .mkv, .doc, …) does not matter because it will be transformed to a sequence of bytes and your job is to convert that sequence to a meaningful representation of data. Retrieving data from a backing store will store data in a memory so you can use it in your application.

Every backing store type has appropriate streaming class for reading and writing operations. These streams are called Base Streams retrieve bytes. To consume:

FileSytem (local Hard drive, usbv drive…) you would use FileStream
Local memory -> MemoryStream
Remote location (Internet, Local network) -> NetworkStream

You use Stream Adapters allow you to transform bytes to types you would usually use in your application, such as integers and strings, by giving you access to classes and methods to consume data. Most commonly used are:

StreamReader/StreamWriter
BinaryReader/BinaryWriter
XmlReader/XmlWriter

For Streams to know where is beginning, current position, and end of a stream, pointer is used. Default position of pointer is at the beginning of a stream, or poistion 0. Streaming ends when pointer hits last position in a stream.

Example:

Lets say that we need to read 10 bytes which will be redistributed to positions 0-9, and we read data in chunks of 4 bytes. First we will read first 4 bytes and pointer will be at the position 3, then next four bytes are read and position will move to 7 and finally last two bytes will be read an pointer will be moved to position 9 and stream will end because end of stream is reached.

Caution! Sometimes, mostly while using network streams, when we expect stream to retrieve certain number of bytes we will not retrieve them all, so be careful when reading or writing data and always check if all bytes are written or read.

Is it possible to set pointer at certain position of a stream?

Yes it is, that process is called seeking. Note that MemoryStream andFile stream support it but NetworkStream does not. Also seeking allows us to read from beginning, end or custom location from within a stream.

Do I have to dispose of a Streams?

Yes, you should always dispose of a stream or or use using statement.

This conclude introduction to Streams lets see some examples.

Example of using FileStream:

using System;
using System.IO;

namespace Streams
{
    class Program
    {
        static void Main(string[] args)
        {
            string path = @"d:\csharp\stream.txt";

            using (FileStream fs = File.Create(path))
            {
                // It is always good practice
                // to check if we can read or write to a stream
                if (!fs.CanRead || !fs.CanWrite)
                    return;

                // To get Current position
                // we use long type because 
                // FileStream.Position method 
                // returns us long type
                long startPosition = fs.Position;

                Console.WriteLine("Position at the start of a stream is: {0}", startPosition);

                // Inside byte array we store bytes
                // that we want to save
                // to a file
                byte[] byteArray = { 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113 };

                // Write function expects 3 parameters:
                // bytes to write
                // Position at which we will start storing bytes
                // Maximum number of bytes to write in one chunk
                fs.Write(byteArray, 0, byteArray.Length);

                long currentPosition = fs.Position; 

                // Note that result will be 14
                // Although we have written 14 bytes
                // Starting position was 0, so 0 position was first to be filled
                // so when byte "113" was written, position was incremented by 1
                Console.WriteLine("Position at the end of a writing to a stream is: {0}", currentPosition);


                // Because Stream is at position 5
                // we need to reset position manually 
                // so that we can read it again from the start
                fs.Position = 0;


                // To read stream we need a new byte array
                // to verify that all bytes were written
                byte[] newByteArray = new byte[fs.Length];

                // FileStream.Read method is used to read from a stream
                // FileStream.Read method has a int return type
                // so we can use it to get number of bytes read 
                // and verify that entire stream is read
                int allBytesRead = fs.Read(newByteArray, 0, newByteArray.Length);

                // You can triger this exception if you change third parameter
                // of fs.Read method to be less than bytes written
                if (allBytesRead != byteArray.Length)
                {
                    throw new Exception("Number of bytes read is not equal to number of bytes written.");
                }


                // We can use Seek method to get stream position from 
                // the Begining of a Stream
                long positionFive = fs.Seek(5, SeekOrigin.Begin);
                // We can use Seek method to get stream position from 
                // the current position +/- number of places 
                long positionSix = fs.Seek(7, SeekOrigin.Current);

                // We can use Seek method to get stream position from 
                // the end position +/- number of places 
                long positionLenghtOfAStreamPlusTen = fs.Seek(-10, SeekOrigin.End);

                Console.WriteLine("");
            }
        }
    }
}

using System;

using System.IO;

namespace Streams

{

class Program

{

static void Main(string[] args)

{

string path = @"d:\csharp\stream.txt";

using (FileStream fs = File.Create(path))

{

// It is always good practice

// to check if we can read or write to a stream

if (!fs.CanRead || !fs.CanWrite)

return;

// To get Current position

// we use long type because

// FileStream.Position method

// returns us long type

long startPosition = fs.Position;

Console.WriteLine("Position at the start of a stream is: {0}", startPosition);

// Inside byte array we store bytes

// that we want to save

// to a file

byte[] byteArray = { 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113 };

// Write function expects 3 parameters:

// bytes to write

// Position at which we will start storing bytes

// Maximum number of bytes to write in one chunk

fs.Write(byteArray, 0, byteArray.Length);

long currentPosition = fs.Position;

// Note that result will be 14

// Although we have written 14 bytes

// Starting position was 0, so 0 position was first to be filled

// so when byte "113" was written, position was incremented by 1

Console.WriteLine("Position at the end of a writing to a stream is: {0}", currentPosition);

// Because Stream is at position 5

// we need to reset position manually

// so that we can read it again from the start

fs.Position = 0;

// To read stream we need a new byte array

// to verify that all bytes were written

byte[] newByteArray = new byte[fs.Length];

// FileStream.Read method is used to read from a stream

// FileStream.Read method has a int return type

// so we can use it to get number of bytes read

// and verify that entire stream is read

int allBytesRead = fs.Read(newByteArray, 0, newByteArray.Length);

// You can triger this exception if you change third parameter

// of fs.Read method to be less than bytes written

if (allBytesRead != byteArray.Length)

{

throw new Exception("Number of bytes read is not equal to number of bytes written.");

}

// We can use Seek method to get stream position from

// the Begining of a Stream

long positionFive = fs.Seek(5, SeekOrigin.Begin);

// We can use Seek method to get stream position from

// the current position +/- number of places

long positionSix = fs.Seek(7, SeekOrigin.Current);

// We can use Seek method to get stream position from

// the end position +/- number of places

long positionLenghtOfAStreamPlusTen = fs.Seek(-10, SeekOrigin.End);

Console.WriteLine("");

}

Assembly class

15/09/2016 / Darko / 0 Comments

Assembly class allows us to:

Load assemblies
Explore metadata and types
Create instance of types

Easiest way to load assembly is by load them using following methods :

GetAssembly (requires Type variable)

GetCallingAssembly (returns Assembly from which this method has been called)

These two methods have Assembly return type. After acquiring Assembly variable we can use it to get types that we want using GetType method.

Let’s explore Assembly class:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;

namespace ReflectionAssembly
{
    class Program
    {
        static void Main(string[] args)
        {
            // First we acquire desired assembly
            Assembly currentAssembly = Assembly.GetEntryAssembly();

            // Then a type we want to inspect
            Type employeeType = currentAssembly.GetType("ReflectionAssembly.Employee");

            // Because our Employee class has constructor with parameters
            // we need to create object array that holds that parameters
            // that will be used on next line
            object[] areja = { 100, "Mark", 28, 2, 200.0 };

            // To create an instance of a class we use Activator class
            // and its CreateInstance method
            // if we do not want to use default parameterless constructor
            // just do not provide them
            object employeeInstance = Activator.CreateInstance(employeeType, areja);

            // nothing new here
            MethodInfo printEmployeeDetailsMethod = employeeType.GetMethod("PrintEmployeeDetails");

            // To call a method just use Invoke method
            // In this example our method does not have input parameters
            // so we provide null value
            // If method needed parameters we would provide object array with parameters
            printEmployeeDetailsMethod.Invoke(employeeInstance, null);

            // Just accessing property and retrieving it's return type name
            PropertyInfo pi = employeeType.GetProperty("Name");
            Console.WriteLine(pi.PropertyType.Name);

        }
    }

    public class Employee
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public int Age { get; set; }
        public int YearsEmployed { get; set; }
        public double Salary { get; set; }

        public Employee()
        {
            Id = -1;
            Name = "John Doe";
            Age = 0;
            YearsEmployed = 0;
            Salary = 0.0;
        }

        public Employee(int id, string name, int age, int years, double salary)
        {
            Id = id;
            Name = name;
            Age = age;
            YearsEmployed = years;
            Salary = salary;
        }

        public void PrintEmployeeDetails()
        {
            Console.WriteLine("Employee name: {0}, Age: {1}, Current salary {2}", Name, Age, Salary);
        }

        public double SalaryIncreaseCoefficient(double coefficient, string justEmptyParameter)
        {
            return coefficient * YearsEmployed;
        }
    }
}

using System;

using System.Collections.Generic;

using System.Linq;

using System.Reflection;

using System.Text;

using System.Threading.Tasks;

namespace ReflectionAssembly

{

class Program

{

static void Main(string[] args)

{

// First we acquire desired assembly

Assembly currentAssembly = Assembly.GetEntryAssembly();

// Then a type we want to inspect

Type employeeType = currentAssembly.GetType("ReflectionAssembly.Employee");

// Because our Employee class has constructor with parameters

// we need to create object array that holds that parameters

// that will be used on next line

object[] areja = { 100, "Mark", 28, 2, 200.0 };

// To create an instance of a class we use Activator class

// and its CreateInstance method

// if we do not want to use default parameterless constructor

// just do not provide them

object employeeInstance = Activator.CreateInstance(employeeType, areja);

// nothing new here

MethodInfo printEmployeeDetailsMethod = employeeType.GetMethod("PrintEmployeeDetails");

// To call a method just use Invoke method

// In this example our method does not have input parameters

// so we provide null value

// If method needed parameters we would provide object array with parameters

printEmployeeDetailsMethod.Invoke(employeeInstance, null);

// Just accessing property and retrieving it's return type name

PropertyInfo pi = employeeType.GetProperty("Name");

Console.WriteLine(pi.PropertyType.Name);

}

public class Employee

{

public int Id { get; set; }

public string Name { get; set; }

public int Age { get; set; }

public int YearsEmployed { get; set; }

public double Salary { get; set; }

public Employee()

{

Id = -1;

Name = "John Doe";

Age = 0;

YearsEmployed = 0;

Salary = 0.0;

}

public Employee(int id, string name, int age, int years, double salary)

{

Id = id;

Name = name;

Age = age;

YearsEmployed = years;

Salary = salary;

}

public void PrintEmployeeDetails()

{

Console.WriteLine("Employee name: {0}, Age: {1}, Current salary {2}", Name, Age, Salary);

}

public double SalaryIncreaseCoefficient(double coefficient, string justEmptyParameter)

{

return coefficient * YearsEmployed;

}

Events

14/09/2016 / Darko / 0 Comments

Events allow us two things:

If something important has occurred object notifies its subscribers about that occurrence.
Objects that listen to another object are notified about changes of that object.

To declare event, you use event keyword followed by the type of delegate for the event, meaning we have to declare delegate before we can use event.

Typically, to raise an event, you would use protected void method. Name of that method by convention goes should be like this: OnEventName. Method should raise event and provide two parameters object and EventArgs. Delegate upon whose type event uses should have two parameters: Object parameter is usually named sender and EventArgs parameter is named args. sender parameter is the source of the event. You should use EventArgs if you do not intend to send any parameters to subscriber, if on the other hand you wish to supply parameters create an class that inherits from from EventArgs and use that class as an parameter.

Example:

Lets create an application that is used to insert an employee to database. Upon inserting and after inserting few people should be notified, meaning we will have two events.

First, when we start inserting employee in database, we will notify our System Administrator that process of inserting has started. Also we will provide Sys Admin with DateTime value which will represent time when insert operation has started.
Second, after employee has been inserted in database, CEO, Website and System Admin will be notified.

using System;
using System.Threading;

namespace Events
{
    #region Delegates
    public delegate void NewEmployeeInsertedEventHandler(object source, EventArgs args);
    public delegate void NewEmployeeInsertingEventHandler(object source, EmployeeEventArgs args);
    #endregion

    class Program
    {
        static void Main(string[] args)
        {
            HRDepartment hr = new HRDepartment();
            SystemAdmin sysAdmin = new SystemAdmin();
            Ceo ceo = new Ceo();
            WebSite webSite = new WebSite();
            Employee newEmployee = new Employee() {Id = 1000, Name = "John Doe", Age = 25, Salary = 1000, YearsEmployed = 0};

            // Subscribing SysAdmin to NewEmployeeInserting event
            hr.NewEmployeeInserting += sysAdmin.OnNewEmployeeInserting;

            // Subscribing subscribers to NewEmployeeInserted event
            hr.NewEmployeeInserted += sysAdmin.OnNewEmployeeInserted;
            hr.NewEmployeeInserted += ceo.OnNewEmployeeInserted;
            hr.NewEmployeeInserted += webSite.OnNewEmployeeInserted;

            // By calling InsertNewEmployee, few thing will happen:
            // 1. Process of inserting employee will start
            // 2. SysAdmin will be notiffied that process of inserting has started
            // 1. Employees information will be inserted in database
            // 1. All subscribers will be notified that employee has been inserted
            hr.InsertNewEmployee(newEmployee);

            Console.ReadKey();
        }
    }

    public class HRDepartment
    {
        // Events
        public event NewEmployeeInsertedEventHandler NewEmployeeInserted;
        public event NewEmployeeInsertingEventHandler NewEmployeeInserting;

        public void InsertNewEmployee(Employee employee)
        {
            Console.WriteLine("Inserting new employee in database...");
            // Firing NewEmployeeInserting event
            OnEmployeeInserting();

            // TODO insert new employee in database
            // Because there is no logic to insert our employee
            // into database we are simulating wait time
            Thread.Sleep(3500);

            Console.WriteLine("New employee has been successfully inserted.");

            // Firing NewEmployeeInserted event
            OnNewEmployeeInserted();
        }

        protected virtual void OnNewEmployeeInserted()
        {
            // Checking if there are any subscribers to our event
            if (NewEmployeeInserted != null)
            {
                // as parameters whe are sending 
                // this instance of a class
                // and no EventArgs
                NewEmployeeInserted(this, EventArgs.Empty);
            }
        }

        protected virtual void OnEmployeeInserting()
        {
            if (NewEmployeeInserting != null)
            {
                // as parameters we are sending 
                // this instance of a class
                // and EmployeeEventArgs instance with DateTime value
                NewEmployeeInserting(this, new EmployeeEventArgs() {TimeOfInserting = DateTime.Now});
            }
        }
    }

    public class Employee
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public int Age { get; set; }
        public int YearsEmployed { get; set; }
        public double Salary { get; set; }
    }

    public class EmployeeEventArgs : EventArgs
    {
        // DateTime value that will be shown while
        // inserting new employee
        public DateTime TimeOfInserting { get; set; }
    }

    public class Ceo
    {
        // Method signature must match delegate NewEmployeeInsertedEventHandler
        public void OnNewEmployeeInserted(object source, EventArgs args)
        {
            Console.WriteLine("Ceo notified about new employee.");
        }
    }

    public class WebSite
    {
        // Method signature must match delegate NewEmployeeInsertedEventHandler
        public void OnNewEmployeeInserted(object source, EventArgs args)
        {
            Console.WriteLine("WebSite notified about new employee.");
        }
    }

    // Because SysAdmin is subscribed to two events that consume two diferent delegates
    // we need two different methods for subscription
    public class SystemAdmin
    {
        // Method signature must match delegate NewEmployeeInsertingEventHandler
        public void OnNewEmployeeInserting(object source, EmployeeEventArgs args)
        {
            Console.WriteLine("Notification to SysAdmin: A new employee is beeing created {0}", args.TimeOfInserting);
        }

        // Method signature must match delegate NewEmployeeInsertedEventHandler
        public void OnNewEmployeeInserted(object source, EventArgs args)
        {
            Console.WriteLine("SysAdmin notified about new employee.");
        }
    }

}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

using System;

using System.Threading;

namespace Events

{

#region Delegates

public delegate void NewEmployeeInsertedEventHandler(object source, EventArgs args);

public delegate void NewEmployeeInsertingEventHandler(object source, EmployeeEventArgs args);

#endregion

class Program

{

static void Main(string[] args)

{

HRDepartment hr = new HRDepartment();

SystemAdmin sysAdmin = new SystemAdmin();

Ceo ceo = new Ceo();

WebSite webSite = new WebSite();

Employee newEmployee = new Employee() {Id = 1000, Name = "John Doe", Age = 25, Salary = 1000, YearsEmployed = 0};

// Subscribing SysAdmin to NewEmployeeInserting event

hr.NewEmployeeInserting += sysAdmin.OnNewEmployeeInserting;

// Subscribing subscribers to NewEmployeeInserted event

hr.NewEmployeeInserted += sysAdmin.OnNewEmployeeInserted;

hr.NewEmployeeInserted += ceo.OnNewEmployeeInserted;

hr.NewEmployeeInserted += webSite.OnNewEmployeeInserted;

// By calling InsertNewEmployee, few thing will happen:

// 1. Process of inserting employee will start

// 2. SysAdmin will be notiffied that process of inserting has started

// 1. Employees information will be inserted in database

// 1. All subscribers will be notified that employee has been inserted

hr.InsertNewEmployee(newEmployee);

Console.ReadKey();

}

public class HRDepartment

{

// Events

public event NewEmployeeInsertedEventHandler NewEmployeeInserted;

public event NewEmployeeInsertingEventHandler NewEmployeeInserting;

public void InsertNewEmployee(Employee employee)

{

Console.WriteLine("Inserting new employee in database...");

// Firing NewEmployeeInserting event

OnEmployeeInserting();

// TODO insert new employee in database

// Because there is no logic to insert our employee

// into database we are simulating wait time

Thread.Sleep(3500);

Console.WriteLine("New employee has been successfully inserted.");

// Firing NewEmployeeInserted event

OnNewEmployeeInserted();

}

protected virtual void OnNewEmployeeInserted()

{

// Checking if there are any subscribers to our event

if (NewEmployeeInserted != null)

{

// as parameters whe are sending

// this instance of a class

// and no EventArgs

NewEmployeeInserted(this, EventArgs.Empty);

}

protected virtual void OnEmployeeInserting()

{

if (NewEmployeeInserting != null)

{

// as parameters we are sending

// this instance of a class

// and EmployeeEventArgs instance with DateTime value

NewEmployeeInserting(this, new EmployeeEventArgs() {TimeOfInserting = DateTime.Now});

}

public class Employee

{

public int Id { get; set; }

public string Name { get; set; }

public int Age { get; set; }

public int YearsEmployed { get; set; }

public double Salary { get; set; }

}

public class EmployeeEventArgs : EventArgs

{

// DateTime value that will be shown while

// inserting new employee

public DateTime TimeOfInserting { get; set; }

}

public class Ceo

{

// Method signature must match delegate NewEmployeeInsertedEventHandler

public void OnNewEmployeeInserted(object source, EventArgs args)

{

Console.WriteLine("Ceo notified about new employee.");

}

public class WebSite

{

// Method signature must match delegate NewEmployeeInsertedEventHandler

public void OnNewEmployeeInserted(object source, EventArgs args)

{

Console.WriteLine("WebSite notified about new employee.");

}

// Because SysAdmin is subscribed to two events that consume two diferent delegates

// we need two different methods for subscription

public class SystemAdmin

{

// Method signature must match delegate NewEmployeeInsertingEventHandler

public void OnNewEmployeeInserting(object source, EmployeeEventArgs args)

{

Console.WriteLine("Notification to SysAdmin: A new employee is beeing created {0}", args.TimeOfInserting);

}

// Method signature must match delegate NewEmployeeInsertedEventHandler

public void OnNewEmployeeInserted(object source, EventArgs args)

{

Console.WriteLine("SysAdmin notified about new employee.");

}

You can also download entire solution for easier readability.

If you prefer using Action delegate instead of declaring delegates you can easily doe that. Just replace following code in HRDepartment class:

// Events
// comment following two lines
//public event NewEmployeeInsertedEventHandler NewEmployeeInserted;
//public event NewEmployeeInsertingEventHandler NewEmployeeInserting;

// and insert these two lines
public event Action<object, EventArgs> NewEmployeeInserted;
public event Action<object, EmployeeEventArgs> NewEmployeeInserting;

// Events

// comment following two lines

//public event NewEmployeeInsertedEventHandler NewEmployeeInserted;

//public event NewEmployeeInsertingEventHandler NewEmployeeInserting;

// and insert these two lines

public event Action<object, EventArgs> NewEmployeeInserted;

public event Action<object, EmployeeEventArgs> NewEmployeeInserting;

For now we will finish our journey with Delegates and return to Reflection.

Lambda expressions

13/09/2016 / Darko / 0 Comments

A lambda expressions are an anonymous function that helps us write easy to read code.

Let’s see how we can achieve this. First we will take example from previous post about anonymous methods:

using System;

namespace AnonymousMethodsTutorial
{
    class Program
    {
        public delegate int SumTwoNumberDelegate(int numberOne, int numberTwo);
        static void Main(string[] args)
        {
            SumTwoNumberDelegate sumOfTwoNumber = delegate (int x, int y) { return x + y; };
            int sum = sumOfTwoNumber(2, 2);
            Console.WriteLine(sum);
        }
    }
}

using System;

namespace AnonymousMethodsTutorial

{

class Program

{

public delegate int SumTwoNumberDelegate(int numberOne, int numberTwo);

static void Main(string[] args)

{

SumTwoNumberDelegate sumOfTwoNumber = delegate (int x, int y) { return x + y; };

int sum = sumOfTwoNumber(2, 2);

Console.WriteLine(sum);

}

We can simplify this code by removing delegate keyword and inserting => operator between anonymous method’s parameters and statement.

using System;

namespace AnonymousMethodsTutorial
{
    class Program
    {
        public delegate int SumTwoNumberDelegate(int numberOne, int numberTwo);
        static void Main(string[] args)
        {
            SumTwoNumberDelegate sumOfTwoNumber = (int x, int y) => { return x + y; };
            int sum = sumOfTwoNumber(2, 2);
            Console.WriteLine(sum);
        }
    }
}

using System;

namespace AnonymousMethodsTutorial

{

class Program

{

public delegate int SumTwoNumberDelegate(int numberOne, int numberTwo);

static void Main(string[] args)

{

SumTwoNumberDelegate sumOfTwoNumber = (int x, int y) => { return x + y; };

int sum = sumOfTwoNumber(2, 2);

Console.WriteLine(sum);

}

How do you pronounce => operator?

There are quite a few names for => operator. Here are a few typical names:

Goes to
Maps
Such that
Becomes

Lambda expressions do not look like a easier way to write delegates, can we for example remove delegate declaration?

You are correct. We can simplify thing even more with Action and Func.

Action

Action is a generic delegate type that describes a method that does not return a value. Action can have 16 overloads, of which not a single one describes a return type. You can picture action like a method with a void return type.

Action example

using System;

namespace AnonymousMethodsTutorial
{
    class Program
    {
        //public delegate void SumTwoNumberDelegate(int numberOne, int numberTwo);
        static void Main(string[] args)
        {
            //SumTwoNumberDelegate sumOfTwoNumber = (int x, int y) =>
            //{
            //    int sumTwoNumbers = x + y;
            //    Console.WriteLine(sumTwoNumbers);
            //};

            Action<int, int> sumOfTwoNumber = (int x, int y) =>
            {
                int sumTwoNumbers = x + y;
                Console.WriteLine(sumTwoNumbers);
            };

            sumOfTwoNumber(2, 2);
        }
    }
}

using System;

namespace AnonymousMethodsTutorial

{

class Program

{

//public delegate void SumTwoNumberDelegate(int numberOne, int numberTwo);

static void Main(string[] args)

{

//SumTwoNumberDelegate sumOfTwoNumber = (int x, int y) =>

//{

// int sumTwoNumbers = x + y;

// Console.WriteLine(sumTwoNumbers);

//};

Action<int, int> sumOfTwoNumber = (int x, int y) =>

{

int sumTwoNumbers = x + y;

Console.WriteLine(sumTwoNumbers);

};

sumOfTwoNumber(2, 2);

}

Code here is not deleted but commented out for you to see benefits of using Action. First of we do not need to declare delegate and lastly because we do not need to declare delegate we are free to decide upon our types while writing an Action.

Func

Func is a generic delegate type that describes a method that has an return a value. Func can have 17 overloads, but note that last type is your return type.

Func Example

using System;

namespace AnonymousMethodsTutorial
{
    class Program
    {
        //public delegate int SumTwoNumberDelegate(int numberOne, int numberTwo);
        static void Main(string[] args)
        {
            //SumTwoNumberDelegate sumOfTwoNumber = (int x, int y) => { return x + y; };
            Func<int, int, int> sumOfTwoNumber = (int x, int y) => { return x + y; };
            int sum = sumOfTwoNumber(2, 2);
            Console.WriteLine(sum);
        }
    }
}

using System;

namespace AnonymousMethodsTutorial

{

class Program

{

//public delegate int SumTwoNumberDelegate(int numberOne, int numberTwo);

static void Main(string[] args)

{

//SumTwoNumberDelegate sumOfTwoNumber = (int x, int y) => { return x + y; };

Func<int, int, int> sumOfTwoNumber = (int x, int y) => { return x + y; };

int sum = sumOfTwoNumber(2, 2);

Console.WriteLine(sum);

}

Same as Action but note, that when looking at our sumOfTwoNumber Func, third int type is our return type.

We will now continue our journey with delegates by learning about events.

Anonymous methods

13/09/2016 / Darko / 0 Comments

Anonymous methods allow us to create delegate methods inline.

What does that mean?

Let’s create a simple delegate whose role is to sum two numbers:

using System;

namespace AnonymousMethodsTutorial
{
    class Program
    {
        public delegate int SumTwoNumberDelegate(int numberOne, int numberTwo);
        static void Main(string[] args)
        {
            SumTwoNumberDelegate sumOfTwoNumber = new SumTwoNumberDelegate(SumTwoNumber);
            int sum = sumOfTwoNumber(2, 2);
            Console.WriteLine(sum);
        }

        private static int SumTwoNumber(int x, int y)
        {
            return x + y;
        }
    }
}

using System;

namespace AnonymousMethodsTutorial

{

class Program

{

public delegate int SumTwoNumberDelegate(int numberOne, int numberTwo);

static void Main(string[] args)

{

SumTwoNumberDelegate sumOfTwoNumber = new SumTwoNumberDelegate(SumTwoNumber);

int sum = sumOfTwoNumber(2, 2);

Console.WriteLine(sum);

}

private static int SumTwoNumber(int x, int y)

{

return x + y;

}

Would not it be nice if we could get rid of the SumTwoNumber method and just write it’s content while we instantiate delegate ? Yes it would and we can do it! Steps are:

While instantiating your delegate, remove new… part.
Write delegate keyword followed by input parameter in round brackets.
Type your code inside curly brackets.

using System;

namespace AnonymousMethodsTutorial
{
    class Program
    {
        public delegate int SumTwoNumberDelegate(int numberOne, int numberTwo);
        static void Main(string[] args)
        {
            SumTwoNumberDelegate sumOfTwoNumber = delegate (int x, int y) { return x + y; };
            int sum = sumOfTwoNumber(2, 2);
            Console.WriteLine(sum);
        }
    }
}

using System;

namespace AnonymousMethodsTutorial

{

class Program

{

public delegate int SumTwoNumberDelegate(int numberOne, int numberTwo);

static void Main(string[] args)

{

SumTwoNumberDelegate sumOfTwoNumber = delegate (int x, int y) { return x + y; };

int sum = sumOfTwoNumber(2, 2);

Console.WriteLine(sum);

}

What we essentially did is we created a method without method name and thus we created anonymous method. Don’t believe me? Look again at the same code that has been reformatted a bit:

using System;

namespace AnonymousMethodsTutorial
{
    class Program
    {
        public delegate int SumTwoNumberDelegate(int numberOne, int numberTwo);
        static void Main(string[] args)
        {
            SumTwoNumberDelegate sumOfTwoNumber = delegate (int x, int y)
            {
                return x + y;
            };
            int sum = sumOfTwoNumber(2, 2);
            Console.WriteLine(sum);
        }
    }
}

using System;

namespace AnonymousMethodsTutorial

{

class Program

{

public delegate int SumTwoNumberDelegate(int numberOne, int numberTwo);

static void Main(string[] args)

{

SumTwoNumberDelegate sumOfTwoNumber = delegate (int x, int y)

{

return x + y;

};

int sum = sumOfTwoNumber(2, 2);

Console.WriteLine(sum);

}

When you mentioned we can write delegate methods inline, does that mean we can write methods in one line only?

No, you can write as many lines as you want. Notice semicolon (;) on line 12, you can write additional code below. But beware of that feature, because if you write too many lines whole purpose of anonymous methods disappears and that is readability. Generally you would like to keep it to 1-3 lines, more than that would best be very good candidate for standalone method.

How do i know which parameters and return types to use wile writing an anonymous methods?

Your delegate tells you that information. In our example SumTwoNumberDelegate delegate expects return type int and two int input parameters, so that is what we provided him within anonymous method.

Anonymous methods are awesome! Are there any drawbacks to using them?

You would normally use delegate, instead of method, if you do not intend to use a function multiple times. On the other hand it makes no sense to write same anonymous method multiple times if you can reuse one method + it is easier to maintain that one method than multiple anonymous methods.

Can i make my code even simpler?

Yes you can, by using lambda expressions!

MethodInfo

09/09/2016 / Darko / 0 Comments

Type’s class GetMethods method returns us with a array of MethodInfo objects. Similarly GetMethod method provided with a name of Method returns us a MethodInfo object. It allows us to access a lot of information and interaction concerning specific Method, such as:

Check if a method is a constructor,

Access modifier of a method,

Method parameters,

Method name,

Invoking/Calling method

And many more…

Example:

using System;
using System.Reflection;
using System.Text;

namespace ReflectionTutorial
{
    class Program
    {
        static void Main(string[] args)
        {
            Employee emp1 = new Employee(100, "Mark", 28, 2, 2000);
            double salaryIncreaseCoefficient = emp1.SalaryIncreaseCoeficient(0.1, "empty");

            Type type = Type.GetType("ReflectionTutorial.Employee");   

            // GetMethod allows us to access Method if we know its name
            MethodInfo methodInfo = type.GetMethod("SalaryIncreaseCoeficient");

            // Checking if this method is a constructor
            bool isThisMethodAConstructor = methodInfo.IsConstructor;

            // Checking if this method is an Generic method
            bool isGenericMethod = methodInfo.IsGenericMethod;

            // Checking if this is a public method
            bool isPublicMthod = methodInfo.IsPublic;

            // Checking if this is a IsPrivate method
            bool isPrivateMthod = methodInfo.IsPrivate;

            // We can easily see return type of a method
            ParameterInfo parameterInfo = methodInfo.ReturnParameter;
            string methodReturnType = parameterInfo.ToString();

            // Method name
            string methodName = methodInfo.Name;

            // Invoke/Call method with no parameters
            MethodInfo mi = type.GetMethod("PrintEmployeeDetails");
            mi.Invoke(emp1, null);

            //Invoke call method with parameters
            object[] parametersArray = new object[] { 0.2, "Tada" };
            var methodResult = methodInfo.Invoke(emp1, parametersArray);
            Console.WriteLine("Method Result is: {0}", methodResult);

            // We can easily get all types methods, display its return type
            // and parameters using GetMethods method.
            MethodInfo[] methodInfoArray = type.GetMethods();
            foreach (MethodInfo method in methodInfoArray)
            {
                StringBuilder builder = new StringBuilder();
                ParameterInfo[] parameters = method.GetParameters();

                for (int i = 0; i < parameters.Length; i++)
                {
                    builder.Append(parameters[i].ParameterType);

                    // We do not want to display comma 
                    // after last parameter type
                    if (i != parameters.Length - 1)
                        builder.Append(',');
                }

                Console.WriteLine(method.ReturnType + " " + method.Name + " " + builder);
            }

            Console.WriteLine("");
        }
    }

    public class Employee
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public int Age { get; set; }
        public int YearsEmployed { get; set; }
        public double Salary { get; set; }

        public Employee()
        {
            Id = -1;
            Name = "John Doe";
            Age = 0;
            YearsEmployed = 0;
            Salary = 0.0;
        }

        public Employee(int id, string name, int age, int years, double salary)
        {
            Id = id;
            Name = name;
            Age = age;
            YearsEmployed = years;
            Salary = salary;
        }

        public void PrintEmployeeDetails()
        {
            Console.WriteLine("Employee name: {0}, Age: {1}, Current salary {2}", Name, Age, Salary);
        }

        public double SalaryIncreaseCoefficient(double coeficient, string justEmptyParameter)
        {
            return coefficient * YearsEmployed;
        }
    }
}

100

101

102

103

104

105

106

107

108

using System;

using System.Reflection;

using System.Text;

namespace ReflectionTutorial

{

class Program

{

static void Main(string[] args)

{

Employee emp1 = new Employee(100, "Mark", 28, 2, 2000);

double salaryIncreaseCoefficient = emp1.SalaryIncreaseCoeficient(0.1, "empty");

Type type = Type.GetType("ReflectionTutorial.Employee");

// GetMethod allows us to access Method if we know its name

MethodInfo methodInfo = type.GetMethod("SalaryIncreaseCoeficient");

// Checking if this method is a constructor

bool isThisMethodAConstructor = methodInfo.IsConstructor;

// Checking if this method is an Generic method

bool isGenericMethod = methodInfo.IsGenericMethod;

// Checking if this is a public method

bool isPublicMthod = methodInfo.IsPublic;

// Checking if this is a IsPrivate method

bool isPrivateMthod = methodInfo.IsPrivate;

// We can easily see return type of a method

ParameterInfo parameterInfo = methodInfo.ReturnParameter;

string methodReturnType = parameterInfo.ToString();

// Method name

string methodName = methodInfo.Name;

// Invoke/Call method with no parameters

MethodInfo mi = type.GetMethod("PrintEmployeeDetails");

mi.Invoke(emp1, null);

//Invoke call method with parameters

object[] parametersArray = new object[] { 0.2, "Tada" };

var methodResult = methodInfo.Invoke(emp1, parametersArray);

Console.WriteLine("Method Result is: {0}", methodResult);

// We can easily get all types methods, display its return type

// and parameters using GetMethods method.

MethodInfo[] methodInfoArray = type.GetMethods();

foreach (MethodInfo method in methodInfoArray)

{

StringBuilder builder = new StringBuilder();

ParameterInfo[] parameters = method.GetParameters();

for (int i = 0; i < parameters.Length; i++)

{

builder.Append(parameters[i].ParameterType);

// We do not want to display comma

// after last parameter type

if (i != parameters.Length - 1)

builder.Append(',');

}

Console.WriteLine(method.ReturnType + " " + method.Name + " " + builder);

}

Console.WriteLine("");

}

public class Employee

{

public int Id { get; set; }

public string Name { get; set; }

public int Age { get; set; }

public int YearsEmployed { get; set; }

public double Salary { get; set; }

public Employee()

{

Id = -1;

Name = "John Doe";

Age = 0;

YearsEmployed = 0;

Salary = 0.0;

}

public Employee(int id, string name, int age, int years, double salary)

{

Id = id;

Name = name;

Age = age;

YearsEmployed = years;

Salary = salary;

}

public void PrintEmployeeDetails()

{

Console.WriteLine("Employee name: {0}, Age: {1}, Current salary {2}", Name, Age, Salary);

}

public double SalaryIncreaseCoefficient(double coeficient, string justEmptyParameter)

{

return coefficient * YearsEmployed;

}

We will continue our voyage with Reflection in next lesson about Assembly class.

Theme by Anders Noren — Up ↑

Language

Recent Posts

Archives

Categories

Page 2 of 6

Why would I need to create WinMD class library?

Example of WinMD / Windows Runtime Component Assembly

How can i locate GAC folder?

How to install Strongly named assembly inside Global Assembly Cache?

Drag and drop approach:

Using GacUtil.exe

What does it mean to be strongly named?

I wish to create strongly named assemblies! What do i do?

AssemblyVersion and AssemblyFileVersion

attributes

AssemblyInformationalVersion

Nice. Please show me how to access these values.

Is it possible to set pointer at certain position of a stream?

Do I have to dispose of a Streams?

Let’s explore Assembly class:

Example:

How do you pronounce => operator?

Lambda expressions do not look like a easier way to write delegates, can we for example remove delegate declaration?

Action

Action example

Func

Func Example

What does that mean?

Would not it be nice if we could get rid of the SumTwoNumber method and just write it’s content while we instantiate delegate ? Yes it would and we can do it! Steps are:

When you mentioned we can write delegate methods inline, does that mean we can write methods in one line only?

How do i know which parameters and return types to use wile writing an anonymous methods?

Anonymous methods are awesome! Are there any drawbacks to using them?

Can i make my code even simpler?