Equinox

Monday, May 14, 2012

.NET FRAMEWORK INTERVIEW QUESTIONS

What is Interface based polymorphism ?

Answer:

Interfaces provide another way you can accomplish polymorphism in Visual Basic. Interfaces describe properties and methods like classes, but unlike classes, interfaces cannot provide any implementation. Multiple interfaces have the advantage of allowing systems of software components to evolve without breaking existing code.

To achieve polymorphism with interfaces, you implement an interface in different ways in several classes. Client applications can use either the old or the new implementations in exactly the same way. The advantage to interface-based polymorphism is that you do not need to re-compile existing client applications to get them to work with new interface implementations.

For More information:

http://msdn.microsoft.com/en-us/library/z9k8e08x%28v=vs.90%29

What is Deferred Execution of LiNQ ?

Answer:

http://blogs.msdn.com/b/charlie/archive/2007/12/09/deferred-execution.aspx

What is explicit implementation of Interfaces ?

http://msdn.microsoft.com/en-us/library/aa288461%28v=vs.71%29.aspx

What is Keyword Extern ?

Answer:

The extern modifier is used to declare a method that is implemented externally. A common use of the extern modifier is with the DllImport attribute when you are using Interop services to call into unmanaged code .

http://msdn.microsoft.com/en-us/library/e59b22c5%28v=vs.90%29.aspx

Tell me about constructor Hierarchy ?

http://www.yoda.arachsys.com/csharp/constructors.html

How GC(Garbage Collector) will evaluates an object is unused ?

http://msdn.microsoft.com/en-us/library/system.gc%28v=vs.90%29.aspx

What is the difference between interface and abstract class ?

Difference between Interface and abstract class :

The choice of whether to design your functionality as an interface or an abstract class (a MustInherit class in Visual Basic) can sometimes be a difficult one. An abstract class is a class that cannot be instantiated, but must be inherited from. An abstract class may be fully implemented, but is more usually partially implemented or not implemented at all, thereby encapsulating common functionality for inherited classes. For details, see Abstract Classes.

An interface, by contrast, is a totally abstract set of members that can be thought of as defining a contract for conduct. The implementation of an interface is left completely to the developer.

Both interfaces and abstract classes are useful for component interaction. If a method requires an interface as an argument, then any object that implements that interface can be used in the argument.

This method could accept any object that implemented IWidget as the widget argument, even though the implementations of IWidget might be quite different. Abstract classes also allow for this kind of polymorphism, but with a few caveats:

Classes may inherit from only one base class, so if you want to use abstract classes to provide polymorphism to a group of classes, they must all inherit from that class.

Abstract classes may also provide members that have already been implemented. Therefore, you can ensure a certain amount of identical functionality with an abstract class, but cannot with an interface.

Here are some recommendations to help you to decide whether to use an interface or an abstract class to provide polymorphism for your components.

If you anticipate creating multiple versions of your component, create an abstract class. Abstract classes provide a simple and easy way to version your components. By updating the base class, all inheriting classes are automatically updated with the change. Interfaces, on the other hand, cannot be changed once created. If a new version of an interface is required, you must create a whole new interface.

If the functionality you are creating will be useful across a wide range of disparate objects, use an interface. Abstract classes should be used primarily for objects that are closely related, whereas interfaces are best suited for providing common functionality to unrelated classes.

If you are designing small, concise bits of functionality, use interfaces. If you are designing large functional units, use an abstract class.

If you want to provide common, implemented functionality among all implementations of your component, use an abstract class. Abstract classes allow you to partially implement your class, whereas interfaces contain no implementation for any members.

What is Generics and the need of generics ?

Difference between list and sorted list ?

What is the scope of Session ?

What is the property to know is Client is connected ?

What are all the new key words introduced in .Net 4.0 ?

What is the default access modifier for a class ?

Answer: Private

What is GetHashCode?

Ans: GetHashCode Serves as a hash function for a particular type.

http://msdn.microsoft.com/en-us/library/system.object.gethashcode.aspx

Can we have a abstract class without any any abstract method in it ?

Yes

We collect videos & images from online sites like youtube and some other websites which provide them. And most of the News is also gathered from other online websites. Any material downloaded or otherwise obtained through the use of the service is done at your own discretion and risk and that you will be solely responsible for any damage to your computer system or loss of data that results from the download of any such material. If you feel that the content on the site is illegal or Privacy please contact us at srinuchalla@gmail.com and such videos, images or any Content will be removed with immediate effect.

Saturday, March 3, 2012

Difference between WCF and Web services

Some of the differences between WCF and web services :

1) For internal (behind firewall) service-to-service calls we use the net:tcp binding, which is much faster than SOAP

2) We enabled both a net:tcp endpoint and a "web" endpoint on the same service with only a configuration file update (no code changes)

3) We were able to create AJAX-supporting RESTful web services with only configuration changes and using the DataContractJsonSerializer that's already built in. To do this otherwise, we would have had to write an HTTP Handler (ashx) and handle most of the Json serialization and url parsing by hand.

4) As our site needs to scale for performance optimization and stability, we are looking at converting to using an MSMQ-based messaging structure that is asynchronous AND guaranteed and participates in transactions; WCF provides an MSMQ bindng that requires little-to-no code change in our services--just reference updates and setting up MSMQ properly with the existing services (and adding attributes for Transactional boundaries).

BUT BE WARNED: Really invest in learning this (buy the blue O-Reily book and go through it). There are things like argument-name-changes during development that actually don't break the service references but result in null arguments being passed (built-in version skew handling), hosting models to consider (Windows Service vs. IIS), and instantiation models and FaultExceptions to all REALLY understand. We didn't going in and we had some pains. But we plowed ahead and are VERY happy with our learnings and the flexibility and growth opportunities we have not being tied to ASMX anymore!

ASMX is great and simple - but it's very limited in many ways:

you can only host your web services in IIS
you can only reach your web services over HTTP
security is very limited
WCF remedies this - and offer much more beyond that. You can host your WCF services in IIS - or self-host in a console app or Win NT Service, as need be. You can connect your WCF services using HTTP, TCP/IP, MSMQ, Peer-to-peer protocols, named pipes for on-machine communications and much more.

ASMX is great and simple - but it's very limited in many ways:

you can only host your web services in IIS
you can only reach your web services over HTTP
security is very limited
WCF remedies this - and offer much more beyond that. You can host your WCF services in IIS - or self-host in a console app or Win NT Service, as need be. You can connect your WCF services using HTTP, TCP/IP, MSMQ, Peer-to-peer protocols, named pipes for on-machine communications and much more.

We collect videos & images from online sites like youtube and some other websites which provide them. And most of the News is also gathered from other online websites. Any material downloaded or otherwise obtained through the use of the service is done at your own discretion and risk and that you will be solely responsible for any damage to your computer system or loss of data that results from the download of any such material. If you feel that the content on the site is illegal or Privacy please contact us at srinuchalla@gmail.com and such videos, images or any Content will be removed with immediate effect.

What is Scavenging?

Scavenging:

Scavenging is the process of deleting items from the cache when memory is scarce. Items are removed when they have not been accessed in some time or when items are marked as low priority when added to the cache. ASP.NET uses the CacheItemPriority object to determine which items to scavenge first.

To add an item to the Cache with priority settings:

Call the Insert method, specifying a value from the CacheItemPriority enumeration.

The following code example adds an item to the cache with a priority value of High

Cache.Insert("CacheItem8", "Cached Item 8",
    null, System.Web.Caching.Cache.NoAbsoluteExpiration,
    System.Web.Caching.Cache.NoSlidingExpiration,
    System.Web.Caching.CacheItemPriority.High, null);

The add an item to the cache with expiration policies:

Call the Insert method, passing it an absolute or sliding expiration time.

The following code example adds an item to the cache with an absolute expiration of one minute

Cache.Insert("CacheItem6", "Cached Item 6",
    null, DateTime.Now.AddMinutes(1d),
    System.Web.Caching.Cache.NoSlidingExpiration);

What is Marshalling ?

Marshaling:

Marshaling is the act of taking data from the environment you are in and exporting it to another environment.

In the context of .NET, marhsaling refers to moving data outside of the app-domain you are in, somewhere else.

When you work with unmanaged code, you are marshaling data from your managed app-domain to the unmanaged realm. Also, when transferring data between app-domains (to another application, on the same or another machine), you are also marshaling data from your app-domain, to another app-domain.

In computer science, marshalling (sometimes spelled marshaling, similar to serialization) is the process of transforming the memory representation of an object to a data format suitable for storage or transmission. It is typically used when data must be moved between different parts of a computer program or from one program to another.

Marshalling is a process that is used to communicate to remote objects with an object (in this case a serialized object). It simplifies complex communication, using custom/complex objects to communicate - instead of primitives.

The opposite, or reverse, of marshalling is called unmarshalling (or demarshalling, similar to deserialization).

In the .NET Framework, the conversion between an unmanaged type and a CLR type, as in the P/Invoke process, is also an example of an action that requires marshalling to take place

What is ASP.NET MapPath?

ASP.NET MapPath Resolves Virtual, Physical Paths

You need to use MapPath to resolve virtual paths and physical paths. You run the ASP.NET development server on your local machine, but the paths on it are not the same as they are on your server. Here we use MapPath to find physical paths and file locations, using the C# programming language.

Introduction
First, in ASP.NET the ~ tilde indicates the root of a virtual path. We need the tilde because otherwise ASP.NET can't figure out if a path is absolute or relative. Let's look at some virtual paths and what they might map to.

Virtual paths:

~/App_Data/Sample.xml
~/
~/Map.txt

Physical paths:

C:\Website\Files\Sample.xml
C:\Website\Default.aspx
C:\Website\Map.txtMapPath
For example
You can call MapPath in any C# file in your ASP.NET website. You may want to include the System.Web namespace first, but this is not required. Make sure you are looking at a C# file in your ASP.NET project and then add some code that looks similar to parts of the following.

Example code that uses MapPath

using System;
using System.Web;

public class Example
{
public Example()
{
// This will locate the Example.xml file in the App_Data folder.
// ... (App_Data is a good place to put data files.)
string a = HttpContext.Current.Server.MapPath("~/App_Data/Example.xml");

// This will locate the Example.txt file in the root directory.
// ... This can be used in a file in any directory in the application.
string b = HttpContext.Current.Request.MapPath("~/Example.txt");
}
}
Using Server.MapPath. Here we note that the Server.MapPath does the same thing as the Request.MapPath method. In this example, the two versions will do the same thing. There may be some differences in different usage scenarios, but in those cases a more detailed guide would be helpful. The two methods are interchangeable in most ASP.NET projects.

XML files
Here we note that you can use the MapPath method to access many different paths on the server. There is an entire article here about XElement examples. XElement is an XML object that can open a file, much like StreamReader.

Virtual hosts security
Here we note that if you are using a virtual shared host, there may be problems in your code related to file permissions and security checks. The problem may not be MapPath at all. MapPath is very simple and unless you have a typo in the argument, it won't cause you any problems.

Performance
You might be interested to find that MapPath performance is over 1000 times slower than a simple string append. Therefore, it could be worthwhile to cache the paths, in a technique similar to that in my article about appSettings caches.

Summary
MapPath is a method that resolves virtual paths to machine paths. It has great utility for XML and some other data files. It can work as a bridge between website-specific virtual paths, and a physical path that most .NET I/O methods will require.

We collect videos & images from online sites like youtube and some other websites which provide them. And most of the News is also gathered from other online websites. Any material downloaded or otherwise obtained through the use of the service is done at your own discretion and risk and that you will be solely responsible for any damage to your computer system or loss of data that results from the download of any such material. If you feel that the content on the site is illegal or Privacy please contact us at srinuchalla@gmail.com and such videos, images or any Content will be removed with immediate effect.

Basic guide lines for .Net(C#, ASP.NET) programming

Technical guide lines for .Net(C#, ASP.NET) programming

1) Sort all the namespaces alphabetically as shown below

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Web;

using System.Web.UI;

using System.Web.UI.WebControls;

2) Use #region for Segregation

#region Page Event Handlers

#region UI Event Handlers

#region Helper Methods

3) Always initialize String type with String.empty

Wrong:

String CardNo = "";

Correct:

String CardNo = String.empty;

4)Avoid parameters
When you call any method in the C# language that was not in-lined, the run time will actually physically copy the variables you pass as arguments to the formal parameter slot memory in the called method. It causes stack memory operations and incurs a performance hit. It is faster to minimize arguments, and even use constants in the called methods instead of passing them arguments.

5) Avoid local variables

When you call a method in your C# program, the run time allocates a separate memory region to store all the local variable slots. This memory is allocated on the stack even if you do not access the variables in the function call. Therefore, you can call methods faster if they have fewer variables in them.

6) Use arrays
In the .NET Framework, you have many options for collections, such as the List type, and various other types such as ArrayList. While these types are convenient and should be used when necessary, it is always more efficient to use a simple array if this is possible. The reason for this is that the more complex collections such as List are actually composed of internal arrays. They add logic to avoid the burden of managing the array size on each use. However, if you do not need this logic, or can adjust your code so that the logic is not needed, using an array will be faster.

7)Use StringBuilder
If you are doing significant appending of strings using the C# language, the StringBuilder type can improve performance. This is because the string type is immutable and cannot be changed without reallocating the entire object. Sometimes, using strings instead of StringBuilder for concatenations is faster; this is typically the case when using very small strings or doing infrequent appends.

8) Use static fields

Here, we note that static fields are faster than instance fields, for the same reason that static methods are faster than instance methods. When you load a static field into memory, you do not need the runtime to resolve the instance expression. Loading an instance field must have the object instance first resolved. In fact, even in an object instance, loading a static field is faster because no instance expression instruction is ever used.

9) Comparing Non-Case-Sensitive Strings

In an application sometimes it is necessary to compare two string variables, ignoring the cases. The tempting and traditionally approach is to convert both strings to all lower case or all upper case and then compare them, like such:

str1.ToLower() == str2.ToLower()

However repetitively calling the function ToLower() is a bottleneck in performace. By instead using the built-in string.Compare() function you can increase the speed of your applications.

To check if two strings are equal ignoring case would look like this:

string.Compare(str1, str2, true) == 0 //Ignoring cases

The C# string.Compare function returns an integer that is equal to 0 when the two strings are equal.

10) Use && and || operators

When building if statements, simply make sure to use the double-and notation (&&) and/or the double-or notation (||), (in Visual Basic they are AndAlso and OrElse).

If statements that use & and | must check every part of the statement and then apply the "and" or "or". On the other hand, && and || go thourgh the statements one at a time and stop as soon as the condition has either been met or not met.

Executing less code is always a performace benefit but it also can avoid run-time errors, consider the following C# code:

if (object1 != null && object1.runMethod())

If object1 is null, with the && operator, object1.runMethod()will not execute.

If the && operator is replaced with &, object1.runMethod() will run even if object1 is already known to be null, causing an exception.

11)Lazy Instantiation/Initialization

The Singleton design pattern is often used to provide a single global instance of a class. Sometimes it's the case that a particular singleton won't be needed during an application run. It's generally good practice to delay the creation of any object until it's needed, unless there's a specific need to the contrary - for instance, to pre-cache slow-initializing objects such as database connections. The "double-checked locking" pattern is useful in these situations, as a way to avoid synchronization and still ensure that a needed action is only performed once. Lazy initialization is a technique that can enhance the performance of an entire application through object reduction.

12)Working with Objects and Value Types

Objects are expensive to use, partly because of the overhead involved in allocating memory from the heap (which is actually well-optimized in .NET) and partly because every created object must eventually be destroyed. The destruction of an object may take longer than its creation and initialization,especially if the class contains a custom finalization routine. Also, the garbage collector runs in an indeterministic way; there's no guarantee that an object's memory will be immediately reclaimed when it goes out of scope, and until it's collected, this wasted memory can adversely affect performance.

It's necessary to understand garbage collection to appreciate the full impact of using objects. The single most important fact to know about the garbage collector is that it divides objects into three "generations": 0, 1, and 2. Every object starts out in generation 0; if it survives (if at least one reference is maintained) long enough, it goes to 1; much later, it transitions to 2. The cost of collecting an object increases with each generation. For this reason, it's important to avoid creating unnecessary objects, and to destroy each reference as quickly as possible. The objects that are left will often be long-lived and won't be destroyed until application shutdown.

13) Using the 'Sealed' Keyword

Wherever extensibility is not required, you should use the sealed keyword. This makes your design easier to understand, as someone can tell at a glance if a certain class or method isn't meant to be extended or overridden. It also increases the chances that the compiler will inline code.

15) Use Page.IsPostback to avoid unnecessary processing on a round trip.

Optimizing C# Application

Very nice article...

check it out http://www.vcskicks.com/optimize_csharp_code.php

We collect videos & images from online sites like youtube and some other websites which provide them. And most of the News is also gathered from other online websites. Any material downloaded or otherwise obtained through the use of the service is done at your own discretion and risk and that you will be solely responsible for any damage to your computer system or loss of data that results from the download of any such material. If you feel that the content on the site is illegal or Privacy please contact us at srinuchalla@gmail.com and such videos, images or any Content will be removed with immediate effect.

Tuesday, August 9, 2011

Equinox: Difference Between ULIP and Traditional Plans

Equinox: Difference Between ULIP and Traditional Plans

We collect videos & images from online sites like youtube and some other websites which provide them. And most of the News is also gathered from other online websites. Any material downloaded or otherwise obtained through the use of the service is done at your own discretion and risk and that you will be solely responsible for any damage to your computer system or loss of data that results from the download of any such material.If you feel that the content on the site is illegal or Privacy please contact us at srinuchalla@gmail.com and such videos, images or any Content will be removed with immediate effect.

Difference Between ULIP and Traditional Plans

Srinivasa was grappling with a strange situation. He wanted to invest in an insurance product to take care of his risk as well as investment requirements, but he was not able to decide between “ULIP” or a Traditional insurance product (e.g. endowment plan) Fortunately he had ready help handy – his financial advisor – Anil.

Anil explained that both the types of insurance products have their own interesting nuances and, he went about explaining them as given below.

ULIP vs. Traditional Plan:

Definition:

ULIP means a “Unit Linked Insurance Plan.” It combines the characteristics of a mutual fund and life insurance product. Part of the premium goes into buying life insurance cover while the remaining part of the premium is invested in an asset class (Equity/Debt), based on one’s choice. Asset class investment is made after deduction of known charges.

Traditional Plan – Money Back Plan/Endowment Plan/ Term Plans. Before the advent of ULIP’s, these were the instruments of choice, for Insurance and Investment. However, they offered no option to choose between various asset classes and the investments were made solely at the discretion of the insurance company. Traditional plans provided returns in the form of sum insured plus bonus (if and when declared). The amount of bonus depends upon profits made by the insurance company and the declaration of the bonus at the sole discretion of the life insurance company.

Since traditional plans offer assured returns, a major portion of the premium is required to be invested in risk-free securities, as per Insurance Regulatory and Development Authority (IRDA) mandate.

Investments:

In ULIP, at the time of buying a life insurance plan, the policyholder has the option of choosing the type of fund depending upon the asset class (equity/debt) and the investment strategy of the policyholder.

Further, the policyholder can also switch the units between the available funds in a unit-linked life insurance product based on prevailing market conditions. In a Traditional life insurance plan, the investment decisions are made by the life insurance companies, where the investment is done in primarily in Government Securities and Corporate Bonds.

Transparency:

In a unit-linked life insurance product, before investing an individual should know the various charges upfront, namely:

• Premium Allocation Charge

• Fund Management Charge

• Mortality Charge

• Policy Administration Charge

• Surrender/Discontinuance Charge

• Switching Charge

• Redirection Charge

• Partial Withdrawal Charge

The amount after deduction of applicable charges called “Residual Amount” is finally invested in the fund chosen by the policyholder.Also, the current investment value of the funds invested is readily available to the policyholders in form of Net Asset Value (NAV), as this is declared regularly by an insurance company.

Nature:

Traditional life insurance plans are aimed primarily to encourage savings and have adequate protection or life cover for the policyholder. Traditional policies are considered risk-free, as they provide fixed returns in case of death or maturity of the term. ULIPs in addition to providing protection cover are seen as tool for wealth generation because of the options of investing the policyholder‘s funds in various fund types depending upon the investment strategy and risk appetite -, therefore provide opportunities of higher returns. However, one must note that unlike the traditional life insurance plans the ULIPs are subject to the investment risks associated with the capital markets.In addition,a ULIP investor has the flexibility to switch funds, determine the amount of investment and withdraw funds partially or systematically.

Decision Maker:

The choice of investments in ULIP lies with the policyholder/investor. Therefore, depending upon the risk appetite, an individual can choose either a traditional life insurance plan or a unit-linked life insurance plan. ULIP is the instrument of choice for an “Active Investor.”

For “Passive Investors,” whose priority is savings and security along with protection cover, a traditional life insurance policy may be better suited.

The age of an individual and number of dependents is also directly proportional to his/her risk taking ability. The risk appetite is higher for younger people considering the larger amount of time they have to remain invested to average out market fluctuation.

This article is copied from Max New York Life Insurance..........

Tuesday, August 2, 2011

ఇది నిద్రయా లేక అమృత భాండమా....!

ఈ మత్తులో జగమే ఊగుతోంది

కానీ నా శరీరం ఊగుతూ ఆగలేనంటూంది

మనసు దేనికో ఆరాటపడుతోంది

కళ్ళు ఎందుకో మిటమిటమంటున్నాయి

ఇది నిద్రయా లేక అమృత భాండమా....!

మధుర క్షణాలు....!

నీతో గడిపిన ఆ మధుర క్షణాలు

నా శ్వాసలో అణువణువున నిండి ఉన్నాయి

నీకై పరితపించే నా కన్నులు నిన్నే వెతుకుచున్నాయి

నీ నవ యవ్వన సౌందర్య దర్శనం కోసం

నా మనస్సు ఉవ్విళ్లూరుతుంది

నా అణువణువు నీ స్పర్శకై అలమటిస్తోంది

ఓ నేస్తమా నీ వెక్కడ ?

ఓ ప్రియ నేస్తమా ఆ నాటి మధురాలు శున్యమా ?

ఈ నాటి నా కళల జీవితం అందకారమయమా ?

నీతో నడిచిన ఆ నాలుగడుగులు నీకై నడవమంటున్నాయి

నీవు లేని నా జీవితం నిర్జీవం ...!

నీకై వేచిచూసే కన్నులతో ,

నీ ప్రేమకై పరితపించే మనసుతో

నీ రాక కోసం నే వేచిచూస్తూ ........

Sunday, July 31, 2011

లోకాలే చీకటైన....!

ఇది ఏమి మాయ

నాలో కలిగిన అసంకల్పిత చర్య

నా మనస్సు నిద్రారణ్యంలో చిక్కి శల్యమై పోవుచున్నది

నిద్రించుటయా లేక పాఠములు పఠించుటయా ??

ఈ సంద్రంబు నుండి నను పడవేయవ ఓ శ్రీనివాసా ????

ఇవి పరీక్షల ప్రకంపనలులే...!

ప్రొద్దున్నే లేచాను నేను ఈ ప్రశాంత వాతావరణంలో

వేడి వేడి పానీయం అందుకున్నాను నా స్నేహితుని అభిమానంతో

ఎక్కడ లేని ఉత్సాహంతో రెపరెప లాడుతున్నాయి పుస్తకంలోని పేజీలు

రివ్వుమంటోది మనసు పాఠ్యాంశంలోకి వెళితే

ఇది ఆనంద సూచకమా లేక విషాద ఛాయకు అర్ధమా ?

అంతేలే ఇవి పరీక్షల ప్రకంపనలులే...!

ఇది రణరంగమా?

ఏమిటీ ఈ తపన

పరిపరి విధముల నిరీక్షణ

మళ్లీ మళ్లీ ప్రయత్నమా ?

వివిధ రకాల విజృంభనయా ?

ఎందుకీ పరి తపన ?

విజయమా ? విఫల యత్నమా ?

ఈ విచిత్ర పరిక్షలలో ??

మత్తులో తుళ్ళింత........

ఈ ప్రశాంత సమయాన నే విహరిస్తున్న సడిలేని ధ్యాసలోన
నా మనస్సు ఉరకలేస్తోంది ఈ నిర్విరామ ప్రపంచాన
ఓ మనసా ఏమీ ఈ పులకరింత ?

ఏమీ ఈ మహత్తర జలదరింత

ఏదో తెలియని మత్తుతో తుల్లింతలవుతోంది నా మనసు

ఇది వయస్సు ప్రభంజనమా ? లేక

పరీక్షల ప్రభావమా ??

ఓ మగువా !

నీ నవ్వుల్లో సౌందర్యాన్ని చూశా నీ నడకల్లో హొయలు చూశా

నీ మాటల్లో సప్త స్వరాలను గ్రహించా

నీ స్నేహంలో సప్త రుచులని చవిచూశా

నీ ప్రేమలో స్వర్గ సుఖాలను అనుభవించా

నీ చిరుకొపంలో అనురాగాన్ని చవిచూశా

నీ కనుసైగల్లో అభిమానం చూశా

నీ హృదయంలో నా మనస్సును(నా స్థానాన్ని ) చూశా

నాలో నిండిఉన్న నా ఆరో ప్రాణమా

నా అభిమానమా

ఇదే నా ప్రేమకు నిదర్శనం .....!

నువ్వేనా నా నువ్వేనా ?

ఓ నేస్తమా ! ఓ ప్రియ నేస్తమా !

నా ప్రాణమా నా అనురాగమా

నా మదిలో దాగిన మధుర స్వరమా

నా హృదయాన రేగిన మలిస్వరమా

నీ రాకకోసం నా నీరిక్షణ, నా తపన

నాలో సంగీతాన్ని పొంగిచిన మధుర మృదంగమా !

నీ ప్రేమలో నీ లాలనలో నీ పరితపించియున్న

నీవే నా సర్వస్వం నీకోసమే ఈ తపస్సు

మాయ

ఈ జగమే మాయ

నీవు నా పై చూపించిన ఆ ప్రేమ మాయ

నీ మనసులో నే చుసిన నా ప్రతిబింబం మాయ

నా గుండెల్లో నిండిఉన్న నువ్వే మాయ

నీ మాటల్లో నీ నడవడికల్లో ఉన్న ప్రేమ మాయ

ప్రేమే మాయ మాయే ప్రేమ

ప్రేమలేని ఈ జగమే మహా మాయ

ఈ జగత్తులో సర్వసం మాయ

WCF Interview Questions Part2

What is Transport and Message Reliability?

Transport reliability (such as the one offered by TCP) offers point-to-point guaranteed delivery at the network packet level, as well as guarantees the order of the packets. Transport reliability is not resilient to dropping network connections and a variety of other communication problems.

Message reliability deals with reliability at the message level independent of how many packets are required to deliver the message. Message reliability provides for end-to-end guaranteed delivery and order of messages, regardless of how many intermediaries are involved, and how many network hops are required to deliver the message from the client to the service.

What are contracts in WCF?

In WCF, all services expose contracts. The contract is a platform-neutral and standard way of describing what the service does.

WCF defines four types of contracts.
Service contracts
Describe which operations the client can perform on the service.

There are two types of Service Contracts.

ServiceContract - This attribute is used to define the Interface.

OperationContract - This attribute is used to define the method inside Interface.

[ServiceContract]
interface IMyContract
{

[OperationContract]
string MyMethod( );
}

class MyService : IMyContract
{

public string MyMethod( )
{
return "Hello World";
}

Data contracts

Define which data types are passed to and from the service. WCF defines implicit contracts for built-in types such as int and string, but we can easily define explicit opt-in data contracts for custom types.

There are two types of Data Contracts.

DataContract - attribute used to define the class

DataMember - attribute used to define the properties.

[DataContract]
class Contact
{

[DataMember]
public string FirstName;

[DataMember]

public string LastName;
}

If DataMember attributes are not specified for a properties in the class, that property can't be passed to-from web service.

Fault contracts

Define which errors are raised by the service, and how the service handles and propagates errors to its clients.

Message contracts

Allow the service to interact directly with messages. Message contracts can be typed or untyped, and are useful in interoperability cases and when there is an existing message format we have to comply with.

What is endpoint in WCF?

Every service must have Address that defines where the service resides, Contract that defines what the service does and a Binding that defines how to communicate with the service. In WCF the relationship between Address, Contract and Binding is called Endpoint.
The Endpoint is the fusion of Address, Contract and Binding.

Where we can host WCF services?

Every WCF services must be hosted somewhere. There are three ways of hosting WCF services.
They are

1. IIS

2. Self Hosting
3. WAS (Windows Activation Service)

For more details see http://msdn.microsoft.com/en-us/library/bb332338.aspx

What is service and client in perspective of data communication?

A service is a unit of functionality exposed to the world.

The client of a service is merely the party consuming the service.

There are four core security features that WCF addresses:-

Confidentiality: This feature ensures that the information does not go in wrong hands when it travels from the sender to the receiver.

Integrity: This feature ensures that the receiver of the message gets the same information that the sender sends without any data tampering.

Authentication: This feature verifies who the sender is and who the receiver is.

Authorization: This feature verifies whether the user is authorized to perform the action they are requesting from the application.

We collect videos & images from online sites like youtube and some other websites which provide them. And most of the News is also gathered from other online websites. Any material downloaded or otherwise obtained through the use of the service is done at your own discretion and risk and that you will be solely responsible for any damage to your computer system or loss of data that results from the download of any such material. If you feel that the content on the site is illegal or Privacy please contact us at srinuchalla@gmail.com and such videos, images or any Content will be removed with immediate effect.

WCF interview Questions Part1

Web Services

1.It Can be accessed only over HTTP

2.It works in stateless environment

WCF

WCF is flexible because its services can be hosted in different types of applications. The following lists several common scenarios for hosting WCF services:

IIS

WAS

Self-hosting

Managed Windows Service

What are the various ways of hosting a WCF service?

Self hosting the service in his own application domain. This we have already covered in the first section. The service comes in to existence when you create the object of ServiceHost class and the service closes when you call the Close of the ServiceHost class.

Host in application domain or process provided by IIS Server.

Host in Application domain and process provided by WAS (Windows Activation Service) Server.

What is three major points in WCF?

Address --- Specifies the location of the service which will be like http://Myserver/MyService.Clients will use this location to communicate with our service.

Binding --- Specifies how the two parties will communicate in term of transport and encoding and protocols
Contract --- Specifies the interface between client and the server. It's a simple interface with some attribute.

What is the difference WCF and Web services?

Web services can only be invoked by HTTP (traditional web service with .asmx). While WCF Service or a WCF component can be invoked by any protocol (like http, tcp etc.) and any transport type.
Second web services are not flexible. However, WCF Services are flexible. If you make a new version of the service then you need to just expose a new end. Therefore, services are agile and which is a very practical approach looking at the current business trends.

We develop WCF as contracts, interface, operations, and data contracts. As the developer we are more focused on the business logic services and need not worry about channel stack. WCF is a unified programming API for any kind of services so we create the service and use configuration information to set up the communication mechanism like HTTP/TCP/MSMQ etc

For more details, read http://msdn.microsoft.com/en-us/library/aa738737.aspx

What are various ways of hosting WCF Services?

There are three major ways of hosting a WCF services

• Self-hosting the service in his own application domain. This we have already covered in the first section. The service comes in to existence when you create the object of Service Host class and the service closes when you call the Close of the Service Host class.

• Host in application domain or process provided by IIS Server.

• Host in Application domain and process provided by WAS (Windows Activation Service) Server.

More details http://www.dotnetfunda.com/articles/article221.aspx#whatarethevariouswaysofhostingaWCFservice