RSS

Jobs for Engineers ( 2011 Passout) 0-1 Years Exp

Post:Engineering Freshers

Experience: Freshers
Job Location: All India
Education: BE /B.TechGraduates( Electronics,Electrical, Instrumentation and Computer)
Desired Candidates Profile:
* 2011 pass out.
* Minimum 70% or above marks in 10th, 12th and BE.
* Good communication skills.

Note 1 : If Your are Eligible Kindly Post your Updated Resume to this E-Mail :- sgroupresume1@gmail.com for further Process. Mention the Designation "Engineering Freshers "which your Seeking in Subject of the Mail.

Note 2 : Mention your Current Salary( CTC),Expected Salary (CTC),Notice Period, Current Employer,Current job location,contact number in your CV (Resume)

  • Digg
  • Del.icio.us
  • StumbleUpon
  • Reddit
  • RSS
Read User's Comments(0)

Jobs for Software Engineers (2010 and 2011) Freshers / Exp

Industry: IT / Software / Telecom

Job Position : Fresher /Exp

1.Software Programmer
2.Software Developer
3.Trainee Programmer

Free Recruitment.No Any Fees( Like Service Charges / Recruitment Fees / Exam Fees)


Any Two (Skills) Subject / Working Knowledge must:

Skills:C, C++, VB,C#,Sharepoint,.NET,Java, J2EE,J2ME, J2SE, JSP, JBoss,JavaScript, JSP, PHP,Oracle(Forms, Reports, SQL/ PLSQL,Database design), ADO, Perl, HTML, Web services, SOAP, XML, ASP, MySQL, SQL Server, Oracle, UNIX, Linux, Redhat Linux, STL, XSLT, OWL, AJAX, Sun Solaris, Python, BEA WebLogic, WebSphere,

Male/Female

Fresh / Exp

Remuneration : Negotiable

Desired Qualification :

BE / B.Tech / MCA / ME / M.Tech / M.Sc,Any UG / PG /BCA/B.SC/Diploma Any
CS, IT, Software, EC, Telecom, EEE, EI, I&C, Indl Elec, Elec & Pow, M.Sc (CS, IT).
50% aggregate marks in 10th & 12th


Desired Experience : Freshers

Selection Process :

Written Test [1 hour 40 minutes].
Critical Incident reporting 30 minutes (The participants to fill in the Critical Incidents
Interviewee Form just after the Written Test).
Group Interview (GI): 45 minutes.
The one-on-one Interview : Critical Incident Interview (CI) and Technical Interview (TI) : 1 hr each.


Walk-In Venue : Details will be sent E mail to shortlisted candidates

Note 1 : If Your are Eligible Kindly Post y our Updated Resume to this E-Mail :- "itcareercv@gmail.com" for further Process. Mention the "Software Engineer " which your Seeking in Subject of the Mail.

Note 2 :Candidates other than the specified sector are welcome to update their resume specifying
their expected sector


Regards

HR Team-Head

Forward this to all your friends and relatives

  • Digg
  • Del.icio.us
  • StumbleUpon
  • Reddit
  • RSS
Read User's Comments(0)

Introduction to Virtual Inheritance:

Labels: , , , ,

Inheritance is one of the most important concepts of object oriented programming and it is also present in C++ (added from Simula, where it was first invented in 1967).

Inheritance is used to create new classes, called derived classes, that inherit methods and properties from existing ones, called base classes. It provides a very efficient method of code reuse, giving the ability to create new classes that implement a common interface or use the functionality of an existing class in your own implementation. When more than one class fitting your implementation, you can join their functionality in your class by inheriting from all of them. This feature is allowed by the C++ standard and it's called multiple inheritance.



The diamond problem:

One of the problems that arises due to multiple inheritance is the diamond problem. A classical illustration of this is given by Bjarne Stroustrup (the creator of C++) in the following example:

class storable //this is the our base class inherited by transmitter and receiver classes
{
public:
storable(const char*);
virtual void read();
virtual void write();
virtual ~storable();
private:
....
}

class transmitter: public storable
{
public:
void write();
...
}

class receiver: public storable
{
public:
void read();
...
}

class radio: public transmitter, public receiver
{
public:
void read();
....
}



Since both transmitter and receiver classes are using the method write() from the base class, when calling the method write() from a radio object we are going to create an ambiguity--that is, the compiler can't know which implementation of write() to use, the one from the transmitter class or the one from the receiver class.

To understand how this is generated, let's take a look at how the objects are represented in memory. Inheritance simply puts the implementation of two objects one after another, but in this case radio is both a transmitter and a receiver, so the storable class gets duplicated inside the radio object. The g++ compiler will complain when compiling the code: error: 'request for member "write" is ambiguous', because it can't figure out either to get the method write() from storable::receiver::radio or from storable::transmitter::radio.

To prevent this behavior, C++ provides the virtual inheritance mechanism. In order to prevent the compiler from giving an error we use the keyword virtual when we inherit from the base class storable in both derived classes:



class transmitter: public virtual storable
{
public:
void read();
...
}

class receiver: public virtual storable
{
public:
void read();
...
}



Making the inheritance virtual will cause the compiler to provide a virtual function table (vtable) for classes transmitter and receiver, which will allow binding methods at run-time. By the way, the use of a vtable is also needed whenever virtual methods are declared, not only for virtual inheritance. The vtable is created in order to maintain the offset between the storable class and the beginning of transmitter/receiver for runtime binding. This will result in two new virtual pointers (vptr) in the memory layout of class radio, one pointing to the transmitter part and one to the receiver (there is a vptr for every virtual base class). Now the derived classes transmitter and receiver share the implementation of storable, making the implementation of radio unambiguous, and the code will compile fine.

The diamond problem is solved in many ways in different programming languages--for example, in Java and C#, full multiple inheritance is not allowed. Instead, they impose some constraints: allowing inheritance only from multiple interfaces (an interface is equivalent with an abstract base in C++, a class with virtual pure members).


Delegating to a sister class:

A powerful technique that arises from using virtual inheritance is to delegate a method from a class in another class by using a common abstract base class. This is also called cross delegation. Let's assume we have a similar scenario like in the diamond example, with small changes. Suppose the write() method in transmitter class needs to access the read() method from receiver for the radio to work (this is not a usual expected behavior, but let's suppose this for the sake of illustration) :


class storable
{
public:
storable(const char*);
virtual void read()=0; //this becomes pure virtual making storable an abstract
virtual void write(); //class
virtual ~storable();
private:
....
}

class transmitter: public virtual storable
{
public:
void write()
{
read();
....
}
}

class receiver: public virtual storable
{
public:
void read();
}

class radio: public transmitter, public receiver
{
public:
...
}

int main()
{
radio *rad = new radio();
receiver *r1 = rad;
transmitter *r2 =rad;

rad->write();
r1->write();
r2->write();
return 1;
}


Because of virtual inheritance, when the write() function from the transmitter class is called, the method read() from the receiver class gets called (as you may have noticed, the transmitter class doesn't have a read() function). In the above hierarchy we can instantiate only the radio class because transmitter and receiver are abstract due to virtual inheritance.


Other considerations when using multiple inheritance in C++:


When creating a derived object like radio, constructors from the hierarchy, the object is built in a specific order: first a pointer to the vtable is created and initialized, then the virtual base class constructor is run (but only once), then constructors from non-virtual bases are run, then the runtime calls constructors for the data members in the order they are declared, and finally, the body of the constructor is executed. In the case of destruction these steps are performed in reverse order--virtual base classes that appear in the hierarchy are destroyed last.

  • Digg
  • Del.icio.us
  • StumbleUpon
  • Reddit
  • RSS
Read User's Comments(0)

  • Digg
  • Del.icio.us
  • StumbleUpon
  • Reddit
  • RSS
Read User's Comments(0)

  • Digg
  • Del.icio.us
  • StumbleUpon
  • Reddit
  • RSS
Read User's Comments(0)

Bitwise Operators in C and C++:

Labels: , ,

Generally, as a programmer you don't need to concern yourself about operations at the bit level. You're free to think in bytes, or ints and doubles, or even higher level data types composed of a combination of these. But there are times when you'd like to be able to go to the level of an individual bit. Exclusive-or encryption is one example when you need bitwise operations.

Another example comes up when dealing with data compression: what if you wanted to compress a file? In principle, this means taking one representation and turning it into a representation that takes less space. One way of doing this is to use an encoding that takes less than 8 bits to store a byte. (For instance, if you knew that you would only be using the 26 letters of the Roman alphabet and didn't care about capitalization, you'd only need 5 bits to do it.) In order to encode and decode files compressed in this manner, you need to actually extract data at the bit level.

Finally, you can use bit operations to speed up your program or perform neat tricks. (This isn't always the best thing to do.)

Thinking about Bits

The byte is the lowest level at which we can access data; there's no "bit" type, and we can't ask for an individual bit. In fact, we can't even perform operations on a single bit -- every bitwise operator will be applied to, at a minimum, an entire byte at a time. This means we'll be considering the whole representation of a number whenever we talk about applying a bitwise operator. (Note that this doesn't mean we can't ever change only one bit at a time; it just means we have to be smart about how we do it.) Understanding what it means to apply a bitwise operator to an entire string of bits is probably easiest to see with the shifting operators. By convention, in C and C++ you can think about binary numbers as starting with the most significant bit to the left (i.e., 10000000 is 128, and 00000001 is 1). Regardless of underlying representation, you may treat this as true. As a consequence, the results of the left and right shift operators are not implementation dependent for unsigned numbers (for signed numbers, the right shift operator is implementation defined).

The leftshift operator is the equivalent of moving all the bits of a number a specified number of places to the left:
[variable]<<[number of places]
For instance, consider the number 8 written in binary 00001000. If we wanted to shift it to the left 2 places, we'd end up with 00100000; everything is moved to the left two places, and zeros are added as padding. This is the number 32 -- in fact, left shifting is the equivalent of multiplying by a power of two.
int mult_by_pow_2(int number, int power) {     return number<Note that in this example, we're using integers, which are either 2 or 4 bytes, and that the operation gets applied to the entire sequence of 16 or 32 bits.

But what happens if we shift a number like 128 and we're only storing it in a single byte: 10000000? Well, 128 * 2 = 256, and we can't even store a number that big in a byte, so it shouldn't be surprising that the result is 00000000.

It shouldn't surprise you that there's a corresponding right-shift operator: >> (especially considering that I mentioned it earlier). Note that a bitwise right-shift will be the equivalent of integer division by 2.

Why is it integer division? Consider the number 5, in binary, 00000101. 5/2 is 2.5, but if you are performing integer division, 5/2 is 2. When you perform a right shift by one: (unsigned int)5>>1, you end up with 00000010, as the rightmost 1 gets shifted off the end; this is the representation of the number 2. Note that this only holds true for unsigned integers; otherwise, we are not guaranteed that the padding bits will be all 0s.

Generally, using the left and right shift operators will result in significantly faster code than calculating and then multiplying by a power of two. The shift operators will also be useful later when we look at how to manipulating individual bits.

For now, let's look at some of the other binary operators to see what they can do for us.
Bitwise AND
The bitwise AND operator is a single ampersand: &. A handy mnemonic is that the small version of the boolean AND, &&, works on smaller pieces (bits instead of bytes, chars, integers, etc). In essence, a binary AND simply takes the logical AND of the bits in each position of a number in binary form.

For instance, working with a byte (the char type):
01001000 &  10111000 =  -------- 00001000 
The most significant bit of the first number is 0, so we know the most significant bit of the result must be 0; in the second most significant bit, the bit of second number is zero, so we have the same result. The only time where both bits are 1, which is the only time the result will be 1, is the fifth bit from the left. Consequently,
72 & 184 = 8 
Bitwise OR
Bitwise OR works almost exactly the same way as bitwise AND. The only difference is that only one of the two bits needs to be a 1 for that position's bit in the result to be 1. (If both bits are a 1, the result will also have a 1 in that position.) The symbol is a pipe: |. Again, this is similar to boolean logical operator, which is ||.
01001000 |  10111000 =  -------- 11111000 
and consequently
72 | 184 = 248 
Let's take a look at an example of when you could use just these four operators to do something potentially useful. Let's say that you wanted to keep track of certain boolean attributes about something -- for instance, you might have eight cars (!) and want to keep track of which are in use. Let's assign each of the cars a number from 0 to 7.

Since we have eight items, all we really need is a single byte, and we'll use each of its eight bits to indicate whether or not a car is in use. To do this, we'll declare a char called in_use, and set it to zero. (We'll assume that none of the cars are initially "in use".)
char in_use = 0; 
Now, how can we check to make sure that a particular car is free before we try to use it? Well, we need to isolate the one bit that corresponds to that car. The strategy is simple: use bitwise operators to ensure every bit of the result is zero except, possibly, for the bit we want to extract.

Consider trying to extract the fifth bit from the right of a number: XX?XXXXX We want to know what the question mark is, and we aren't concerned about the Xs. We'd like to be sure that the X bits don't interfere with our result, so we probably need to use a bitwise AND of some kind to make sure they are all zeros. What about the question mark? If it's a 1, and we take the bitwise AND of XX?XXXXX and 00100000, then the result will be 00100000:
XX1XXXXX &  00100000 =  -------- 00100000 
Whereas, if it's a zero, then the result will be 00000000:
XX0XXXXX &  00100000 =  -------- 00000000 
So we get a non-zero number if, and only if, the bit we're interested in is a 1.

This procedure works for finding the bit in the nth position. The only thing left to do is to create a number with only the one bit in the correct position turned on. These are just powers of two, so one approach might be to do something like:
int is_in_use(int car_num) {     // pow returns an int, but in_use will also be promoted to an int     // so it doesn't have any effect; we can think of this as an operation     // between chars     return in_use & pow(2, car_num); } 
While this function works, it can be confusing. It obscures the fact that what we want to do is shift a bit over a certain number of places, so that we have a number like 00100000 -- a couple of zeros, a one, and some more zeros. (The one could also be first or last -- 10000000 or 00000001.)

We can use a bitwise leftshift to accomplish this, and it'll be much faster to boot. If we start with the number 1, we are guaranteed to have only a single bit, and we know it's to the far-right. We'll keep in mind that car 0 will have its data stored in the rightmost bit, and car 7 will be the leftmost.
int is_in_use(int car_num) {     return in_use & 1<Note that shifting by zero places is a legal operation -- we'll just get back the same number we started with.

All we can do right now is check whether a car is in use; we can't actually set the in-use bit for it. There are two cases to consider: indicating a car is in use, and removing a car from use. In one case, we need to turn a bit on, and in the other, turn a bit off.

Let's tackle the problem of turning the bit on. What does this suggest we should do? If we have a bit set to zero, the only way we know right now to set it to 1 is to do a bitwise OR. Conveniently, if we perform a bitwise OR with only a single bit set to 1 (the rest are 0), then we won't affect the rest of the number because anything ORed with zero remains the same (1 OR 0 is 1, and 0 OR 0 is 0).

Again we need to move a single bit into the correct position: void set_in_use(int car_num) { in_use = in_use | 1<The Bitwise ComplementThe bitwise complement operator, the tilde, ~, flips every bit. A useful way to remember this is that the tilde is sometimes called a twiddle, and the bitwise complement twiddles every bit: if you have a 1, it's a 0, and if you have a 0, it's a 1.

This turns out to be a great way of finding the largest possible value for an unsigned number:
unsigned int max = ~0; 
0, of course, is all 0s: 00000000 00000000. Once we twiddle 0, we get all 1s: 11111111 11111111. Since max is an unsigned int, we don't have to worry about sign bits or twos complement. We know that all 1s is the largest possible number.

Note that ~ and ! cannot be used interchangeably. When you take the logical NOT of a non-zero number, you get 0 (FALSE). However, when you twiddle a non-zero number, the only time you'll get 0 is when every bit is turned on. (This non-equivalence principle holds true for bitwise AND too, unless you know that you are using strictly the numbers 1 and 0. For bitwise OR, to be certain that it would be equivalent, you'd need to make sure that the underlying representation of 0 is all zeros to use it interchangeably. But don't do that! It'll make your code harder to understand.)

Now that we have a way of flipping bits, we can start thinking about how to turn off a single bit. We know that we want to leave other bits unaffected, but that if we have a 1 in the given position, we want it to be a 0. Take some time to think about how to do this before reading further.

We need to come up with a sequence of operations that leaves 1s and 0s in the non-target position unaffected; before, we used a bitwise OR, but we can also use a bitwise AND. 1 AND 1 is 1, and 0 AND 1 is 0. Now, to turn off a bit, we just need to AND it with 0: 1 AND 0 is 0. So if we want to indicate that car 2 is no longer in use, we want to take the bitwise AND of XXXXX1XX with 11111011.

How can we get that number? This is where the ability to take the complement of a number comes in handy: we already know how to turn a single bit on. If we turn one bit on and take the complement of the number, we get every bit on except that bit:
~(1<Now that we have this, we can just take the bitwise AND of this with the current field of cars, and the only bit we'll change is the one of the car_num we're interested in.
int set_unused(int car_num) {     in_use = in_use & ~(1<You might be thinking to yourself, but this is kind of clunky. We actually need to know whether a car is in use or not (if the bit is on or off) before we can know which function to call. While this isn't necessarily a bad thing, it means that we do need to know a little bit about what's going on. There is an easier way, but first we need the last bitwise operator: exclusive-or.
Bitwise Exclusive-Or (XOR)
There is no boolean operator counterpart to bitwise exclusive-or, but there is a simple explanation. The exclusive-or operation takes two inputs and returns a 1 if either one or the other of the inputs is a 1, but not if both are. That is, if both inputs are 1 or both inputs are 0, it returns 0. Bitwise exclusive-or, with the operator of a carrot, ^, performs the exclusive-or operation on each pair of bits. Exclusive-or is commonly abbreviated XOR.

For instance, if you have two numbers represented in binary as 10101010 and 01110010 then taking the bitwise XOR results in 11011000. It's easier to see this if the bits are lined up correctly:
01110010 ^ 10101010  -------- 11011000 
You can think of XOR in the following way: you have some bit, either 1 or 0, that we'll call A. When you take A XOR 0, then you always get A back: if A is 1, you get 1, and if A is 0, you get 0. On the other hand, when you take A XOR 1, you flip A. If A is 0, you get 1; if A is 1, you get 0.

So you can think of the XOR operation as a sort of selective twiddle: if you apply XOR to two numbers, one of which is all 1s, you get the equivalent of a twiddle.

Additionally, if you apply the XOR operation twice -- say you have a bit, A, and another bit B, and you set C equal to A XOR B, and then take C XOR B: you get A XOR B XOR B, which essentially either flips every bit of A twice, or never flips the bit, so you just get back A. (You can also think of B XOR B as cancelling out.) As an exercise, can you think of a way to use this to exchange two integer variables without a temporary variable? (Once you've figured it out, check the solution.)

How does that help us? Well, remember the first principle: XORing a bit with 0 results in the same bit. So what we'd really like to be able to do is just call one function that flips the bit of the car we're interested in -- it doesn't matter if it's being turned on or turned off -- and leaves the rest of the bits unchanged.

This sounds an awful lot like the what we've done in the past; in fact, we only need to make one change to our function to turn a bit on. Instead of using a bitwise OR, we use a bitwise XOR. This leaves everything unchanged, but flips the bit instead of always turning it on:
void flip_use_state(int car_num) {     in_use = in_use ^ 1<
When should you use bitwise operators?
Bitwise operators are good for saving space -- but many times, space is hardly an issue. And one problem with working at the level of the individual bits is that if you decide you need more space or want to save some time -- for instance, if we needed to store information about 9 cars instead of 8 -- then you might have to redesign large portions of your program. On the other hand, sometimes you can use bitwise operators to cleverly remove dependencies, such as by using ~0 to find the largest possible integer. And bit shifting to multiply by two is a fairly common operation, so it doesn't affect readability in the way that advanced use of bit manipulation can in some cases (for instance, using XOR to switch the values stored in two variables).

  • Digg
  • Del.icio.us
  • StumbleUpon
  • Reddit
  • RSS
Read User's Comments(0)

Windows Graphics & OpenGL

Labels: , , , ,

Introduction to C++ OpenGL Programming:

Welcome to another fine lesson in C++! Today you'll be introduced to the wonderful world of OpenGL. OpenGL is a fairly straight forward -- although at many times confusing -- concept. OpenGL gives the programmer an interface with the graphics hardware. OpenGL is a low-level, widely supported modeling and rendering software package, available on all platforms. It can be used in a range of graphics applications, such as games, CAD design, or modeling (to name a few).

OpenGL is the core graphics rendering option for many 3D games, such as Quake 3. The providing of only low-level rendering routines is fully intentional because this gives the programmer a great control and flexibility in his applications. These routines can easily be used to build high-level rendering and modeling libraries. The OpenGL Utility Library (GLU) does exactly this, and is included in most OpenGL distributions!

Unlike DirectX, OpenGL is only a graphics API; it doesn't include support for functionality such as sound, input, or networking (or anything not related to graphics). That's ok, however, because in future tutorials I will teach you how you how to use DirectX for these things.

OpenGL was originally developed in 1992 by Silicon Graphics, Inc, (SGI) as a multi-purpose, platform independent graphics API. Since 1992 all of the development of OpenGL has been headed by the OpenGL Architecture Review Board (ARB). This exclusive board is composed of the major graphics vendors and industry leaders. Some of these are Intel, IBM, NVIDIA, Microsoft, and Silicon Graphics.

OpenGL is a collection of several hundred functions that provide access to all of the features that your graphics hardware has to offer. Internally it acts like a state machine-a collection of states that tell OpenGL what to do. Using the API you can set various aspects of this state machine, including current color, blending, lighting effect, etc.

This is a very general introduction to OpenGL, and you may find other in-depth introductions elsewhere. There is a reason, however, to my generalized introduction. I don't want to slam you with specifics, but give you an idea as to what OpenGL is so that you may decide for yourself if this set of lessons is for you.


OpenGL vs. DirectX: A Comparison:

The competition between OpenGL and DirectX is possibly as well known as the wars waged between AMD and Intel enthusiasts. This topic has sparked the fires of many flame wars throughout the years, and I don't anticipate that changing anytime soon. I won't preach why I prefer OpenGL over DirectX, but rather lay out the facts and let you make that decision. So let's dive in!

Perhaps the most obvious difference is that DirectX, as opposed to OpenGL, is more than just a graphics API. DirectX contains tools to deal with such components of a game as sound, music, input, networking, and multimedia. On the other hand, OpenGL is strictly a graphics API. So what aspect of OpenGL sets it apart from the DirectX graphics component?

Well, first things first: both APIs rely on the use of the traditional graphics pipeline. This is the same pipeline that has been used in computer games since the early days of computer graphics. Although it has been modified in slight ways to adapt with advancements in hardware, the basic idea remains intact.

Both OpenGL and DirectX describe vertices as a set of data consisting of coordinates in space that define the vertex location and any other vertex related data. Graphics primitives, such as points, lines, and triangles, are defined as an ordered set of vertices. There is a difference in how each API handles how vertices are combined to form primitives.

There are a bunch of differences in the DirectX and OpenGL APIs, so I will list a few of those for you. This chart is based off the book, OpenGL Game Programming and a few of these may now be incorrect as new DirectX versions are released. If you wish to correct me, please do via one of the ways listed at the end of this tutorial.

Table 1.1:
Feature: OpenGL DirectX
Vertex Blending N/A Yes
Multiple Operating Systems Yes No
Extension Mechanism Yes Yes
Development Multiple member Board Microsoft
Thorough Specification Yes No
Two-sided lighting Yes No
Volume Textures Yes No
Hardware independent Z-buffers Yes No
Accumulation buffers Yes No
Full-screen Antialiasing Yes Yes
Motion Blur Yes Yes
Depth of field Yes Yes
Stereo Rendering Yes No
Point-size/line-width attributes Yes No
Picking Yes No
Parametric curves and surfaces Yes No
Cache geometry Display Lists Vertex Buffers
System emulation Hardware not present Let app determine
Interface Procedure calls COM
Updates Yearly Yearly
Source Code Sample SDK Implementation

So now you know what separates DirectX and OpenGL, and hopefully you have chosen based on facts which you would prefer, not on myths or opinions.


Introduction to Windows Programming and OpenGL:



At this time we will take a look into the vast world of Windows programming. Since this tutorial is based entirely on programming done within the Windows environment, it will be required of you to have access to a Windows machine and compiler such as Code::Blocks.


For the programs we will be creating you will need a base understanding of the mechanics and structuring of the Windows operating system. Not to worry, however, because I am going to teach this to you!

Microsoft Windows is a multi-tasking operating system that allows multiple applications, referred to here on out as processes. Every process in Windows is given a certain amount of time, called a time slice, where the application is given the right to control the system without being interrupted by the other processes. The runtime priority and the amount of time allocated to a process are determined by the scheduler.

The scheduler is, simply put, the manager of this multi-tasking operating system, ensuring that each process is given the time and the priority it needs depending on the current state of the system.

When it comes to game developers, you will find a large common interest in multithreading. Processes can be broken down into threads, where each thread can execute its own code to allow for multitasking within a single application. The scheduling for threads is the same as that for processes, except that threads are what make up the process.

This means that within your games you can have multiple threads running that can perform multiple calculations at once and thus provide your game with multitasking within itself. To go a step farther we can do a quick explanation of fibers. In newer versions of Windows (Windows 98+) there is an even lower level execution object exists, called a fiber. Each thread in your process has the ability to house multiple fibers that can perform multiple operations at once, all in a single thread.

Windows is what is known as an event-driven operating system. What this means is that each process is executed based on the events they receive from the operating system. For instance, an application may sit at idle and wait for the user to press a key. When that key is pressed Windows will register an event to the application that the key is down.

Windows programming is difficult at all in most cases, and to start we'll use the most basic program ever created. Hello World is used in almost every class when you begin programming in any language, and that won't change here. So, shall we have a look at Hello World in Windows style? Sure!


#include  int APIENTRY WinMain(HINSTANCE hInstance,                      HINSTANCE hPrevInstance,                      LPSTR     lpCmdLine,                      int       nCmdShow) {     MessageBox(NULL, "\tHello World!", "My first windows app", NULL);  return 0; }


As you can see, it's pretty straight forward. Don't pay attention to the things that don't make sense, as in the next lesson we will go in-depth to explain WinMain () and other functions, as well as show how this and OpenGL work together!


WinMain() and the Windows Procedure:

Every Windows programming needs a main entry point. That being said, you may be wondering what this entry point is. The main entry point for any Windows program is called WinMain. The function prototype for WinMain is a little confusing at first, but as we continue to work with it you'll notice it becomes much easier to understand. Well. we've told you what it is; now were going to show you! Here's the prototype for WinMain:

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nShowCmd);


As you may have already noticed, the return type for WinMain is, and always will be, int. All 32-bit Windows operating system uses the calling convention WINAPI. This calling convention MUST be used to distinguish the function as the entry point. Now for the parameters. As you can see, WinMain uses four parameters when the program starts. Let's have a look at them, shall we?
hInstance - is a handle to your applications instance, where an instance  can be considered to be a single run of your application. The instance  is used by windows as a reference to your application for event handling, message processing, and various other duties. hPrevInstance - is always NULL.  lpCmdLine - is a pointer string that is used to hold any command-line arguments that may have been specified when the application began.   For example, if the user opened the Run application and typed myapp.exe myparameter 1, then lpCmdLine would be myparameter 1. nShowCMD - is the parameter that determines how your application's window will be displayed once it begins executing.
Pretty simple, right? Don't worry if it's confusing, it will make sense soon enough! The Windows program you create is going to need some way to handle the messages that Windows will send to it. A few examples of these messages are: WM_CREATE, WM_SIZE, and WM_MOVE. There are TONS of these messages, and we'll show you how to handle a large number of them. To allow Windows to communicate with your application, we'll create a dandy little function called a Windows procedure. This most common name for this function is WndProc. This function MUST be created and used to determine how your application will respond to various events. The Windows procedure may also be called the event handler because, well, it responds to Windows events! So let's have a quick look at the prototype:
LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam);
This function is declared with a return type of LRESULT CALLBACK. The LRESULT type is used by Windows to declare a long integer, and CALLBACK is a calling convention used with functions that are called by Windows. The Windows Procedure is a function pointer, which allows you to call it whatever you want because the function's address will be assigned as a function pointer upon creation of the window class.
hwnd - Only important if you have several windows of the same class open at one time. This is used to determine which window hwnd pointed to before  deciding on an action. message - The actual message identifier that WndProc will be handling. wParam and lParam - Extensions of the message parameter. Used to give  more information and point to specifics that message cannot on its own.
Well now you should have a better understanding of these two topics. You may be wondering when you get to see some openGL usage, and the answer is soon. We first need to cover the basics, let's remember, we're here to learn!


First Windows Application:


The following code is a build up on the basic "hello world" program I showed you earlier. Take a minute to review it, maybe even key it into your compiler and run it, and then we will break it down so that it is easier to understand what is actually going on.

/* Trim fat from windows*/ #define WIN32_LEAN_AND_MEAN  #pragma comment(linker, "/subsystem:windows") /* Pre-processor directives*/ #include "stdafx.h" #include  /* Windows Procedure Event Handler*/ LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) {  PAINTSTRUCT paintStruct;  /* Device Context*/  HDC hDC;   /* Text for display*/  char string[] = "Hello, World!";   /* Switch message, condition that is met will execute*/  switch(message)  {   /* Window is being created*/   case WM_CREATE:     return 0;    break;   /* Window is closing*/   case WM_CLOSE:     PostQuitMessage(0);    return 0;    break;   /* Window needs update*/   case WM_PAINT:     hDC = BeginPaint(hwnd,&paintStruct);    /* Set txt color to blue*/    SetTextColor(hDC, COLORREF(0x00FF0000));    /* Display text in middle of window*/    TextOut(hDC,150,150,string,sizeof(string)-1);    EndPaint(hwnd, &paintStruct);    return 0;    break;   default:    break;  }  return (DefWindowProc(hwnd,message,wParam,lParam)); } /* Main function*/ int APIENTRY WinMain(HINSTANCE hInstance,                      HINSTANCE hPrevInstance,                      LPSTR     lpCmdLine,                      int       nCmdShow) {  WNDCLASSEX  windowClass;  //window class  HWND  hwnd;    //window handle  MSG   msg;    //message  bool  done;    //flag saying when app is complete  /* Fill out the window class structure*/  windowClass.cbSize = sizeof(WNDCLASSEX);  windowClass.style = CS_HREDRAW | CS_VREDRAW;  windowClass.lpfnWndProc = WndProc;  windowClass.cbClsExtra = 0;  windowClass.cbWndExtra = 0;  windowClass.hInstance = hInstance;  windowClass.hIcon = LoadIcon(NULL, IDI_APPLICATION);  windowClass.hCursor = LoadCursor(NULL, IDC_ARROW);  windowClass.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);  windowClass.lpszMenuName = NULL;  windowClass.lpszClassName = "MyClass";  windowClass.hIconSm = LoadIcon(NULL, IDI_WINLOGO);  /* Register window class*/  if (!RegisterClassEx(&windowClass))  {   return 0;  }  /* Class registerd, so now create window*/  hwnd = CreateWindowEx(NULL,  //extended style   "MyClass",   //class name   "A Real Win App",  //app name   WS_OVERLAPPEDWINDOW |  //window style   WS_VISIBLE |   WS_SYSMENU,   100,100,   //x/y coords   400,400,   //width,height   NULL,    //handle to parent   NULL,    //handle to menu   hInstance,   //application instance   NULL);    //no extra parameter's  /* Check if window creation failed*/  if (!hwnd)   return 0;  done = false; //initialize loop condition variable  /* main message loop*/  while(!done)  {   PeekMessage(&msg,NULL,NULL,NULL,PM_REMOVE);   if (msg.message == WM_QUIT) //check for a quit message   {    done = true; //if found, quit app   }   else   {    /* Translate and dispatch to event queue*/    TranslateMessage(&msg);     DispatchMessage(&msg);   }  }  return msg.wParam; }
Well isn't this a whole mess of code! The first thing that you may have noticed is #define WIN32_LEAN_AND_MEAN. This syntax prevents Visual C++ from linking modules that you aren't going to need in your application.

Moving on we come to the include line #include . This includes all the headers you need in this application. Sometimes you may want to include , which will give you a few useful macros to use in Windows development.

The first function we arrive at is the WndProc function. We've discussed this before, so I am just going to highlight two lines I have added here.
HDC hDC;    //device context Char string[] = "Hello World!"; //display text
These two lines are essential as they declare the device context that we are going to use to output to the window we create, and the string that we will display. As we continue on in the code we arrive at the switch statement. This switch is used to determine the message being passed to the windows procedure. In this particular instance we want to take a closer look at the WM_PAINT block.
case WM_PAINT:     hDC = BeginPaint(hwnd,&paintStruct);    /* Set txt color to blue*/    SetTextColor(hDC, COLORREF(0x00FF0000));    /* Display text in middle of window*/    TextOut(hDC,150,150,string,sizeof(string)-1);    EndPaint(hwnd, &paintStruct);    return 0;    break;
When the window is moved, resized, or is otherwise changed the window needs to be updated. The first noticeable change here is the use of the hDC device context. The win32 function BeginPaint() returns the graphics device context for the hwnd passed to it. You can then use this hDC to set the text color with SetTextColor() and follow up with the TextOut() function to display the text. If you want to know more about these functions, check out MSDN.

Next function up is the WinMain() function. Most of the WinMain() content is pretty straight forward, but were going to review a few parts of it for good measure. The msg variable holds the message received by PeekMessage() from the queue, and will be sent to TranslateMessage() and DispatchMessage(). The variable done is a Boolean value used by your message loop and will not equal true until a WM_QUIT message has been received from the queue to indicate that the application is about to be closed.

For easier understanding we will break the order of each setup task into a list.
1. Window-class setup 2. Window-class registration 3. Window Creation 4. Message loop with event handler
We now have a fully working Windows application! I encourage you to toy around with the code and alter it to your liking. Don't be discouraged by errors or problems, for it is these things that make us better.



WGL and the Wiggle Functions in C++:



The simple fact that OpenGL is only a graphics API means that any user interaction, or things like screen and window issues needs to be handled by the operating system. Most operating systems come with a set of extensions that tie OpenGL together with user interaction and window management. This tends to make our lives a little bit easier, but only if we know how to take advantage of this option. In Windows this set of functions are called the wiggle functions. Each of these functions is prefixed with wgl.

To maintain the portability of OpenGL, each operating system must supply functionality for specifying the rendering window before OpenGL can use it. In Windows the Graphics Device Interface uses a device context to remember settings about drawing modes and commands, but in OpenGL the rendering context is used to remember these things. You need to remember, however, that the device context is not a rendering context. The device context MUST be specified in a GDI call, unlike a rendering context, which is specified in an OpenGL call.

If you wish to render more than one window at once, multiple rendering contexts are allowed. You must ensure, however, that the proper rendering context is being used on the proper window. Another thing to remember is that OpenGL is thread-safe. You can have multiple threads rendering to the same device context at one time.

As I mentioned to you earlier, wiggle functions bring Windows API support into OpenGL. Well let's take this time to have a look at a few common wiggle functions:
  • wglCreateContext();
  • wglDeleteContext();
  • wglMakeCurrent();
The wglCreateContext() function creates a handle to the OpenGL rendering context while being passed like a handle to a GDI device context. The correct prototype for this function is:
 HGLRC wglCreateContext(HDC hDC);
This function should only be called after the pixel format for the device context has been set. Don't worry, pixel format is coming into teaching shortly.

Keep in mind that as with a device context, a rendering context must be deleted after you are finished with it. This is where the wglDeleteContext() function comes into play. Let's have a look at the prototype for good measure:
 BOOL  wglDeleteContext(HGLRC hRC);
The name wglMakeCurrent() is highly accurate to what the function does. The function makes the rendering context passed to it the current rendering context. Makes a lot of sense, doesn't it? The device context used must have the same pixel format characteristics as the device context that was used to create the rendering context. This means that the device context used to create the rendering context does not need to be the same as the device context assigned to the wglMakeCurrent() function. Without further delay, let's see the prototype!
 BOOL  wglMakeCurrent(HDC hDC, HGLRC hRC);
You need to ensure that the device context and the rendering context passed to the function have the same pixel format, or the function will not work. To deselect the rendering context you can simply pass NULL for the hRC parameter, or simply pass another rendering context.

Both the wglCreateContext() and the wglMakeCurrent() functions should be called upon window creation. Let's look at a code snippet for an example of these in use:
LRESULT CALLBACK WndProc (HWND hwnd, UNIT message, WPARAM wParam, LPARAM lParam) {  static HGLRC hRC; //rendering context  static HDC hDC; //device context  switch (message)  {  case WM_CREATE:  hDC = GetDC(hwnd); //get the device context for window  hRC = wglCreateContext(hDC); //create rendering context  wglMakeCurrent(hDC,hRC); //make rendering context current  break;  case WM_DESTROY:  wglMakeCurrent(hDC,NULL); //deselect rendering context  wglDeleteContext(hRC);  //delete rendering context  PostQuitMessage(0);  //send wm_quit  break;  } }
This code creates and destroys your OpenGL window.

  • Digg
  • Del.icio.us
  • StumbleUpon
  • Reddit
  • RSS
Read User's Comments(0)

DOTNET

Labels: , , ,

The .NET Framework is a managed type-safe environment for application development and execution. The .NET Framework manages all aspects of your program’s execution. It allocates memory for the storage of data and instructions, grants or denies the appropriate permissions to your application, initiates and manages application execution, and manages the reallocation of memory from resources that are no longer needed. The .NET Framework consists of two main components: the common language runtime (CLR)[equivalent to JRE] and the .NET Framework class library.

CLR : --The common language runtime can be thought of as the environment that manages code execution. It provides core services, such as code compilation, memory allocation, thread management, and garbage collection. Through the common type system (CTS), it enforces strict type-safety and ensures that code is executed in a safe environment by also enforcing code access security.

The .NET Framework class library provides a collection of useful and reusable types that are designed to integrate with the CLR. The types provided by the .NET Framework are object-oriented and fully extensible.

The .NET Framework is designed for cross-language compatibility, which means, simply, that .NET components can interact with each other no matter what supported language they were written in originally. So, an application written in Microsoft Visual Basic .NET might reference a dynamic-link library (DLL) file written in Microsoft Visual C#.

This level of cross-language compatibility is possible because of the CLR. When a .NET application is compiled, it is converted from the language in which it was written (Visual Basic .NET, C#, or any other .NET-compliant language) to Microsoft Intermediate Language (MSIL or IL)[equivalent to bytecode]. MSIL is a low-level language that the CLR can read and understand. Because all .NET executables and DLLs exist as MSIL, they can freely interoperate.
The Common Language Specification (CLS) defines the minimum standards to which .NET language compilers must conform.

The CTS ensures type compatibility between .NET components. Because .NET applications are converted to IL prior to deployment and execution, all primitive data types are represented as .NET types. Thus, a Visual Basic Integer and a C# int are both represented in IL code as a System.Int32. Because both languages use a CTS, it is possible to transfer data between components and avoid time-consuming conversions or hard-to-find errors.

The Structure of a .NET Application
---------------------------------------------
The primary unit of a .NET application is the assembly. An assembly is a self-describing collection of code, resources, and metadata. The assembly manifest contains information about what is contained within the assembly. An assembly contains one or more modules. A module contains the code that makes up your application or library, and it contains metadata that describes that code. When you compile a project into an assembly, your code is converted from high-level code to IL. Because all managed code is first converted to IL code, applications written in different languages can easily interact. Each module also contains a number of types. Types are templates that describe a set of data encapsulation and functionality. There are two kinds of types: reference types (classes) and value types (structures).

Each type is described to the CLR in the assembly manifest. A type can contain fields, properties, and methods, each of which should be related to a common functionality. For example, bank account(class).A field represents storage of a particular type of data. Properties are similar to fields, but properties usually provide some kind of validation when data is set or retrieved. Methods represent behavior, such as actions taken on data stored within the class or changes to the user interface.

Compilation and Execution of a .NET Application
------------------------------------------------------------
When you compile a .NET application, it is not compiled to binary machine code; rather, it is converted to IL. This is the form that your deployed application takes—one or more assemblies consisting of executable files and DLL files in IL form. At least one of these assemblies will contain an executable file that has been designated as the entry point for the application.
When execution of your program begins, the first assembly is loaded into memory. At this point, the CLR examines the assembly manifest and determines the requirements to run the program. It examines security permissions requested by the assembly and compares them with the system’s security policy. If the system’s security policy does not allow the requested permissions, the application will not run. If the application passes the system’s security policy, the CLR executes the code. It creates a process for the application to run in and begins application execution. When execution starts, the first bit of code that needs to be executed is loaded into memory and compiled into native binary code from IL by the CLR's Just-In-Time (JIT) compiler. Once compiled, the code is executed and stored in memory as native code. Thus, each portion of code is compiled only once when an application executes. Whenever program execution branches to code that has not yet run, the JIT compiler compiles it ahead of execution and stores it in memory as binary code. This way, application performance is maximized because only the parts of a program that are executed are compiled.

The .NET base class library is a collection of object-oriented types and interfaces that provide object models and services for many of the complex programming tasks you will face. Most of the types presented by the .NET base class library are fully extensible(INHERITANCE), allowing you to build types that incorporate your own functionality into your managed code.

The .NET Framework base class library contains the base classes that provide many of the services and objects you need when writing your applications. The class library is organized into namespaces[PACKAGES].
A namespace is a logical grouping of types that perform related functions. For example, the System.Windows.Forms namespace contains all the types that make up Windows forms and the controls used in those forms.
Namespaces are logical groupings of related classes. The root of the .NET Framework is the System namespace[like java in java.lang.*]. Other namespaces can be accessed with the period operator.


System: This namespace is the root for many of the low-level types required by the .NET Framework. It is the root for primitive data types as well, and it is the root for all the other namespaces in the .NET base class library.
System.Collections: This namespace contains classes that represent a variety of different container types, such as ArrayList, SortedList, Queue, and Stack. You also can find abstract classes, such as CollectionBase, which are useful for implementing your own collection functionality.
System.ComponentModel: This namespace contains classes involved in component creation and containment, such as attributes, type converters, and license providers.
System.Data: This namespace contains classes required for database access and manipulations, as well as additional namespaces used for data access.
System.Data.Common: This namespace contains a set of classes that are shared by the .NET managed data providers.
System.Data.OleDb: This namespace contains classes that make up the managed data provider for OLE DB data access.
System.Data.SQLClient: This namespace contains classes that are optimized for interacting with Microsoft SQL Server.
System.Drawing: This namespace exposes GDI+ functionality and provides classes that facilitate graphics rendering.
System.IO: In this namespace, you will find types for handling file system I/O.
System.Math: This namespace is home to common mathematics functions such as extracting roots and trigonometry.
System.Reflection: This namespace provides support for obtaining information and dynamic creation of types at runtime.
System.Security: This namespace is home to types dealing with permissions, cryptography, and code access security.
System.Threading: This namespace contains classes that facilitate the implementation of multithreaded applications.
System.Windows.Forms: This namespace contains types involved in creating standard Windows applications. Classes that represent forms and controls reside here as well.


Reference Types and Value Types
Application data memory is divided into two primary components, the stack and the heap. The stack is an area of memory reserved by the application to run the program. The heap, on the other hand, is a separate area of memory reserved for the creation of reusable objects. The CLR manages allocation of heap memory for objects and controls the reclamation of memory from unused objects through garbage collection.

All the data associated with a value type(STRUCTURE)is allocated on the stack. When a variable of a value type goes out of scope, it is destroyed and its memory is reclaimed. A variable of a reference type(CLASS), on the other hand, exists in two memory locations. The actual object data is allocated on the heap. A variable containing a pointer to that object is allocated on the stack. When that variable is called by a function, it returns the memory address for the object to which it refers. When that variable goes out of scope, the object reference is destroyed but the object itself is not. If any other references to that object exist, the object remains intact. If the object is left without any references, it is subject to garbage collection.
Examples of value types include primitives, such as Integer (int), Boolean (bool), Char (char), and so on, as well as user-defined types such as Structure (struct) and Enumeration (enum). Classes represent the majority of reference types. Other reference types include the interface, delegate, and array types.
Using Value Type and Reference Type Variables
A variable that represents a value type contains all the data represented by that type. A variable that represents a reference type contains a reference to a particular object.

The Imports and Using Statements
Visual Basic .NET
Imports System.Windows.Forms
Visual C#
using System.Windows.Forms;

Members
Classes describe the properties and behaviors of the objects they represent through members-- methods, fields, properties, and events.
Fields and properties represent the data about an object—the color of the car.
A method represents something the object can do, ---turn on headlights.
An event represents something interesting that happens to the object, such as overheating or crashing.

Classes vs. Structures
Both can contain members such as fields and methods.
Both require a constructor to create a new instance of themselves
Both inherit from Object.
The key difference between classes and structures is that classes are reference types and structures are value types. On a low level, this means that the instance data for classes is allocated on the heap, whereas the instance data for structures is allocated on the stack. Access to the stack is designed to be light and fast, but storage of large amounts of data on the stack can impede overall application performance.
Structures are best used for smaller, lightweight objects that contain relatively little instance data or for objects that do not persist for long.
Classes are best used for larger objects that contain more instance data and are expected to exist in memory for extended periods.

Methods
(Sub Procedures)
Public Sub MySub()
MessageBox.Show("WELCOME")
End Sub
(Functions)
Public Function Add(ByVal first as Integer, ByVal second as Integer) As Integer
Dim Result as Integer
Result = first + second
Return Result
End Function

Variables declared within methods are said to have method scope(local).
Variables that are not destroyed after a method finishes execution---static method variables, persist in memory and retain their values through multiple executions of a method.

Public Sub myMethod()
Static Iterations as Integer
Iterations += 1
End Sub

Parameters
A parameter is an argument that is passed to the method by the method that calls it. Parameters can be passed in two ways, by value(default) or by reference. ByVal / ByRef

Optional Parameters(default Parameters)
In Visual Basic .NET, you are able to specify optional parameters for your methods. This feature is not available in Visual C#. You specify a parameter as optional using the Optional keyword. Optional parameters must be the last parameters in a method declaration, and you must supply default values for optional parameters.
Public Sub Cook(ByVal time As Integer, Optional ByVal temp As Integer = 350)

End Sub

Constructors and Destructors
The constructor is the first method that is run when an instance of a type is created. In Visual Basic, the constructor is always Sub New. Constructors can never return a value and can be overridden to provide custom initialization functionality. A constructor can also contain calls to other methods.
Public Class A
Public Sub New()

End Sub
End Class
A destructor (known as a finalizer in Visual Basic) contains code to “clean up” when a class is destroyed. This cleanup might include decrementing counters or releasing resources. A finalizer in Visual Basic .NET is always Sub Finalize().

Public Class A
Protected Overrides Sub Finalize()

End Sub
End Class

Scope and Access Levels
Access levels define how types are instantiated and how members are accessed.
Access modifiers are keywords such as Public (public), Private (private), and Friend (internal) that precede a variable or type declaration. The keyword that is used controls the level of access the member is allowed. When a modifier precedes a type declaration, it determines both the scope of its members and how that type is instanced.
Access Modifier Effect on Members
Public (Visual Basic .NET), public (Visual C#) Can be accessed from anywhere.
Private (Visual Basic .NET), private (Visual C#) Can be accessed only by members within the type that defines it.
Friend (Visual Basic .NET), internal (Visual C#) Can be accessed from all types within the assembly, but not from outside the assembly.
Protected (Visual Basic .NET), protected (Visual C#) Can be accessed only by members within the type that defines it or types that inherit from that type.
Protected Friend (Visual Basic .NET), protected ¬internal (Visual C#) Can be accessed from all types within the assembly or from types inheriting from the owning type. This is the union of Protected (protected) and Friend (internal) access.
Any member with the
Public (public) modifier is visible to all code outside the class. Thus, other objects can access and modify public fields and can call public methods.
Private (private) methods are visible only inside the type to which they belong and cannot be accessed from the outside.
Friend (internal), indicates that members can be accessed by other types in the same assembly but cannot be accessed from types outside the assembly.
The Protected (protected) modifier allows access from within the type to which the member belongs and to any types that inherit that type.
The Protected Friend (protected internal) level provides the union of Protected (protected) and Friend (internal) access.
For member variables, the access modifier can replace the Dim statement. If the Dim statement is used (in Visual Basic .NET) or no access modifier is used (in Visual C#), the variable is
private in Visual C# and Visual Basic .NET classes,
public in Visual Basic .NET structures, and
private in Visual C# structures.
If no access modifier is specified, the method is
private (private) by default in a class or structure in C#,
public (public) in a class or structure in Visual Basic .NET.

The garbage collector continuously traces the reference tree in the background and identifies objects that no longer have references. When it finds one, it deletes it and reclaims the memory.
The garbage collector is a low-priority thread under normal circumstances. It operates when processor time is not consumed by more important tasks. When memory becomes limited, however, the garbage collector thread moves up in priority. Memory is reclaimed at a more rapid pace until it is no longer limited, at which point the priority of garbage collection is again lowered.


To add a form to your application at run time
'This example assumes that you have already designed a form called DialogForm
Dim myForm As DialogForm
myForm = New DialogForm()
To create an inherited form with the Inheritance Picker
1. From the Projects menu, select Add Inherited Form. The Add New Item dialog box opens.
2. In the left pane of the dialog box, choose Local Project Items. In the right pane, select Inherited Form. Name this form in the Name box, and click Open to open the Inheritance Picker.
3. The forms in your project are displayed in the Inheritance Picker. If the form from which you want to inherit is one of these forms, choose it and click OK. A new inherited form is added to your project.
If you want to inherit from a form outside of your project, click Browse. Navigate to the project containing the form you want. Click the DLL file containing the form, and click Open.
To create an inherited form in code
'This example assumes that you are inheriting from a form class named MainForm and that that form resides in your project
Public Class myForm
Inherits MainForm
' Additional class implementation omitted
End Class
Opacity
You can create striking visual effects for your form by altering its transparency with the Opacity property controls. Opacity values range between 0 and 1. A value of 1 indicates that a form is completely opaque, and a value of 0 creates a completely transparent form. Any value between the two settings results in a partially transparent form. An Opacity of 1 (fully opaque) is the default value. The Opacity property is useful when it is necessary to keep one form in the foreground but monitor action in a background form. Generally, a control inherits the opacity of the form that hosts it(parent).
MyForm.Opacity = .5

Form Lifetime Events
Load, Activated/Deactivate, VisibleChanged, Closing, Closed
The Load event is fired when an instance of a form is first loaded into the program. This event is raised the first time that the Form.Show or Form.ShowDialog method is called for each instance of a form.
Activated is raised whenever the form receives the focus.
The Deactivate event is raised whenever the current form loses the focus.
VisibleChanged event is raised the form is made visible or invisible. The form methods that cause this event to be raised include Form.Show, Form.ShowDialog, Form.Hide, and Form.Close.
The Closing event is raised when the current form is in the process of closing but has not yet fully closed.
The Closed event is raised after a form has been closed. Use the Closed event to provide any necessary clean-up code.

The .NET Data Types
They are value types and can be broken down into the following subcategories: Integer types, floating-point types, the Boolean type, and the Char type. Two built-in reference types, the String type and the Object type, are an integral part of your application.
Integer Types
Type Visual C# Name Visual Basic .NET Name Description Range
System.Byte byte Byte 8-bit unsigned integer 0 to 255
System.Int16 short Short 16-bit signed integer -32768 to 32767
System.Int32 int Integer 32-bit signed integer -231 to 231-1
System.Int64 long Long 64-bit signed integer -263 to 263-1
System.SByte sbyte (Not implemented) 8-bit signed integer -128 to 127
System.UInt16 ushort (Not implemented) 16-bit unsigned integer 0 to 65535
System.UInt32 uint (Not implemented) 32-bit unsigned integer 0 to 232-1
System.UInt64 ulong (Not implemented) 64-bit unsigned integer 0 to 264-1
Floating-Point Types
Type Visual C# Name Visual Basic .NET Name Description Precision Range (Approximate)
System.Single float Single 32-bit floating-point variable 7 significant digits +/- 1.4 x 10-45 to +/-3.4 x 1038
System.Double double Double 64-bit floating-point variable 15–16 significant digits +/- 5.0 x 10-324 to +/-1.7 x 10308
System.Decimal decimal Decimal 128-bit floating-point variable 28 significant digits +/- 1.0 x 10-28 to +/- 7.9 x 1028
System.Boolean
The values that are valid for Boolean variables are True and False (Visual Basic .NET) or true and false (Visual C#).
System.Char
The System.Char type represents a single instance of a 16-bit Unicode character. It is called Char in Visual Basic .NET and char in Visual C#.
System.String
is a reference type that represents a series of Char data types.
System.Object
is the supertype of all types in the .NET Framework. Every type, whether value type or reference type, derives from System.Object.
Implicit Conversions
From To
Byte (VB .NET)
byte (Visual C#) Short, Integer, Long, Single, Double, Decimal
short, ushort, int, uint, long, ulong, float, double, decimal
Short
short Integer, Long, Single, Double, Decimal
int, long, float, double, decimal
Integer
int Long, Single, Double, Decimal
long, float, double, decimal
Long
long Single, Double, Decimal
float, double, decimal
Single
float Double
double
Char
char Integer, Long, Single, Double, Decimal
int, uint, long, ulong, float, double, decimal
sbyte (Visual C# only) short, int, long, float, double, decimal
ushort (Visual C# only) int, uint, long, ulong, float, double, decimal
uint (Visual C# only) long, ulong, float, double, decimal
ulong (Visual C# only) float, double, decimal

Explicit Conversions - CType
Dim aLong As Long = 1000
Dim anInteger As Integer
anInteger = CType(aLong, Integer)

Dim anInteger As Integer = 100000
Dim aShort As Short
aShort = CType(anInteger, Short)
Option Strict in Visual Basic .NET
When Option Strict is on, strong typing is enforced and only conversions that can be performed without loss of data are allowed. When Option Strict is off, however, strong typing is not enforced and all conversions are performed implicitly. The default setting is Option Strict Off. (The primary purpose of Option Strict Off is backward compatibility with previous versions of Visual Basic.)
Option Strict On---to set it on

Using Data Type Functionality
All data types have built-in functionality. The methods are :
Equals.
Determines whether two instances are equal
GetHashCode.
Serves as a hash function for a particular type
GetType.
Returns the type object for the current instance
ToString.
Returns a human-readable form of the object
Boxing
Boxing is the implicit conversion of value types to reference types. All classes and types derive from Object, and each of these four methods is a method of the Object class. Because each class derives from Object, each class can be implicitly converted to that type. When you call one of these methods, the CLR creates a temporary reference for your value type variable and allows you to treat it as a reference type.
Dim I As Integer = 100
Dim O As Object
O = I
Parse
All of the value data types implement a Parse method. Parse is used to create a numeric value from a string. Controls that accept user input, such as TextBox, do so in the form of a string. The Parse method can be used to convert that string to usable data. In all implementations, Parse is a static (Shared) method and must be called from the type object rather than from an instance.
Dim I As Integer
Dim S As String
S = "1234"
I = Integer.Parse(S)
String Functions
Some Useful Instance String Methods
Name Description
String.Insert Inserts a specified string into the current instance
String.PadLeft, String.PadRight Adds characters to the left and right of the string, respectively
String.Remove Deletes a specified number of characters from the string, beginning at a specified character
String.Replace Replaces all occurrences of a specified character in the string with another specified character
String.Split Returns an array of substrings that are delimited by a specified character
String.Substring Returns a substring from the specified instance
String.ToCharArray Returns an array of the characters that make up the string
String.ToLower, String.ToUpper Returns the string converted to all lowercase or all uppercase, respectively
String.TrimEnd, String.TrimStart, String.Trim Removes trailing, leading, or both characters from the string, respectively

Some Useful Static (Shared) String Methods
Name Description
String.Compare Compares two specified string objects
String.Concat Returns a string that is the result of the concatenation of two or more strings
String.Format Returns a string that has been formatted according to a specified format
String.Join Returns a string that is the result of the concatenation of a specified array of strings, with a specified separation string between each member of the array

Constants allow you to assign user-friendly names to these values and refer to them in code.
Public Const Pi As Double = 3.14159265
Enumerations are user-defined sets of integral constants that correspond to a set of friendly names.
=>Public Enum DaysOfWeek
Monday = 1
Tuesday = 2
Wednesday = 3
Thursday = 4
Friday = 5
Saturday = 6
Sunday = 7
End Enum
=>Public Sub ScheduleDayOff(ByVal day As DaysOfWeek)
Select Case day
Case DaysOfWeek.Monday
' Implementation code omitted
Case DaysOfWeek.Tuesday
' Implementation code omitted
' Additional cases omitted
End Select
End Sub

=>Public Enum Numbers
zero ' equals zero
one ' equals one
two ' equals two
End Enum
=>MessageBox.Show((Numbers.two * 2).ToString()) 'Displays 4
Arrays
=>' This line declares and initializes an array of 33 integers, with indexes ranging from 0 to 32
Dim myIntegers(32) As Integer

=>' This line declares the array
Dim myIntegers() As Integer
' This line initializes the array to six members and sets their values
myIntegers = New Integer() {0,1,2,3,4,5}

=>Dim myIntegers(32) As Integer
' This line reinitializes the array
ReDim myIntegers(45)

=>' Declares the array and initializes it with four members
Dim myIntegers() As Integer = {0,1,2,3}
' Resizes the array, but retains the data in elements 0 through 3
ReDim Preserve myIntegers(10)

Multidimensional Arrays
Rectangular Arrays
-- all the rows have the same number of columns.

' Declares an array of 5 by 3 members
Dim intArrays(4, 2) As Integer
' Declares a two-dimensional array and sets initial values
Dim intArrays2( , ) As Integer = {{1, 2, 3}, {4, 5, 6}}
' Declares a cubical array and sets initial values
Dim cubeArray( , , ) As Integer = {{{7, 2}, {1, 4}}, {{3, 5}, {4, 4}}}
' Declares a complex array of 3 x 3 x 4 x 5 x 6 members
Dim complexArray(2, 2, 3, 4, 5) As Integer

Jagged Arrays
A two-dimensional jagged array can be thought of as a table where each row can have a different number of columns. A jagged array is really an array of arrays.

' Declares an array of 3 arrays
Dim Families(2)() As String
' Initializes the first array to 4 members and sets values
Families(0) = New String() {"Smith", "Mom", "Dad", "Uncle Phil"}
' Initializes the second array to 5 members and sets values
Families(1) = New String() {"Jones", "Mom", "Dad", "Suzie", "Little Bobby"}
' Initializes the third array to 3 members and sets values
Families(2) = New String() {"Williams", "Earl", "Bob"}

  • Digg
  • Del.icio.us
  • StumbleUpon
  • Reddit
  • RSS
Read User's Comments(0)
Subscribe to: Posts (Atom)